Je suis un débutant dans la programmation haskell. J'ai déjà fais du Java (un ans et demi qu'on en fais dans mes cours) et j'ai décidé d'essayer de refaire les travaux que j'ai fais au début en Java en haskell pour m'entrainer.

J'ai donc ce code:

nbParfait :: Int -> Bool
nbParfait n =
        if ((sum . listDiv) n n [1]) == n
        then True
        else False

listDiv :: Int -> Int -> [Int] -> [Int]
listDiv n1 n2 list
        |n2 == 1 = list
        |mod n1 n2 == 0 = listDiv n1 (n2-1) (n2:list)
        |otherwise = listDiv n1 (n2-1) list

C'est pour vérifier si un nombre est parfait c'est a dire que la somme de ses diviseurs propre donne lui-même. Hors j'ai cette erreur de compilation et je n'arrive pas a trouve rpourquoi.

nbParfait.hs:3:20:
    Couldn't match type ‘Int -> [Int] -> [Int]’
                  with ‘[Int -> [t0] -> Int]’
    Expected type: Int -> [Int -> [t0] -> Int]
      Actual type: Int -> Int -> [Int] -> [Int]
    Probable cause: ‘listDiv’ is applied to too few arguments
    In the second argument of ‘(.)’, namely ‘listDiv’
    In the expression: sum . listDiv

J'imagine que c'est une erreur stupide du genre une parenthèse mal placé. Mais je n'y arrive pas.

P.S. : Si vous avez des conseils quand à ma façon de résoudre le problème je suis aussi preneur.

Je connais pas la syntaxe Haskell, mais cette ligne me parait bizarre :

(sum . listDiv) n n [1]

Au hasard, j'aurais plutôt écrit un truc genre

sum . (listDiv n n [1])

Après je comprends pas trop le "sum . chose", il a l'air de vouloir que "chose" soit de type

Int -> [Int -> [t0] -> Int]

alors que là tu lui donnes juste une liste d'entiers.
Sinon pour l'algo en lui même, pas la peine d'essayer tous les diviseurs jusqu'à n, il suffit de tester jusqu'à racine(n). Y'a plus efficace mais c'est déjà pas mal comme ça.

Oui alors c'est un problème qui a été donnée pour apprendre les bases du java. J'ai écrit

(sum $ listDiv n n [1])

et sa marche. $ est l'opérateur avec la plus basse priorité. La synthaxe (fonction1 . fonction2) c'est une composition de fonction. En gros, c'est sensé "fusionné" plusieurs fonction pour en faire une seule. Je me demande pourquoi ça ne marchais pas dans mon cas. J'ai du mal comprendre quelque chose dans la composition des fonctions. Mais merci de votre réponse!

P.S. : Présentement je code en haskell dans nano (le bloc note linux) et ce n'est pas trop la joie. Quelqu'un a réussis à faire marcher un IDE en haskell? Parce que je n'ai pas réussis à faire marcher EclipseFP et je n'ai même pas réussis à installer Leksah.

Ah d'accord si c'est une composition de fonctions, je comprends ce que tu avais écrit à la base.
A mon avis, le problème vient du fait que ton opérateur . doit avoir un type du genre

(B -> C) -> (A -> B) -> A -> C

Or, le type de ta fonction listDiv est le suivant (rappel : le type -> est associatif à droite)

Int -> (Int -> [Int] -> [Int])

Donc quand tu écris (sum . listDiv), le type "A" va être Int, et le "B" va être Int -> [Int] -> [Int].
Or la fonction sum prend juste un [Int] en argument, donc ça type pas.
A mon avis si tu écris (sum . (listDiv n n)) [1] ça doit marcher, mais c'est pas très joli.
Une autre solution serait de faire que listDiv soit de type Int * Int * [Int] -> [Int] (où je note * le type produit), et là (sum . listDiv) (n,n,[1]) devrait marcher