Fonction curryfication dans Haskell

Question

J'ai une fonction:

powerOf :: Int -> Int -> Int 

Exemple d'utilisation de os:

*Main Data.List> powerOf 100 2 
2 
*Main Data.List> powerOf 100 5 
2 

J'ai deux questions. Première - pourquoi cela ne fonctionne pas:

map (powerOf 100) [2, 5] 

Je veux obtenir [2, 2].

Et deuxième question. J'essaie de créer une fonction pariatl. Quelque chose comme ceci:

powerOfN :: Int -> Int 
powerOfN num = powerOf num 

à l'utiliser de telle manière:

let powerOf100 = powerOfN 100 
powerOf100 2 
powerOf100 5 

mais je reçu le message d'erreur:

simplifier.hs:31:15: 
    Couldn't match expected type `Int' 
      against inferred type `Int -> Int' 
    In the expression: powerOf num 
    In the definition of `powerOfN': powerOfN num = powerOf num 

est ici plein de code mai:

divided :: Int -> Int -> Bool 
divided a b = 
    let x = fromIntegral a 
     y = fromIntegral b 
    in (a == truncate (x/y) * b) 

listOfDividers :: Int -> [Int] 
listOfDividers num = 
       let n = fromIntegral num 
        maxN = truncate (sqrt n) 
       in [n | n <- [1.. maxN], divided num n] 


isItSimple :: Int -> Bool 
isItSimple num = length(listOfDividers num) == 1 

listOfSimpleDividers :: Int -> [Int] 
listOfSimpleDividers num = [n | n <- listOfAllDividers, isItSimple n] 
        where listOfAllDividers = listOfDividers num 

powerOfInner :: Int -> Int -> Int -> Int 
powerOfInner num p power 
      | divided num p = powerOfInner (quot num p) p (power + 1) 
      | otherwise = power 

powerOf :: Int -> Int -> Int 
powerOf num p = powerOfInner num p 0 


powerOfN :: Int -> Int 
powerOfN num = powerOf num 

puissanceDe retour puissance maximale de p en num. Par exemple: 100 = 2 * 2 * 5 * 5, donc powerOf 100 2 = 2. 10 = 2 * 5, donc powerOf 10 2 = 1.

Comment réparer les erreurs? Merci.

Answer 1

En utilisant votre code, mis à part la fonction powerOfN. Je ne peux pas reproduire votre problème avec map (powerOf 100) [2,5].

*Main> map (powerOf 100) [2,5] 
[2,2] 

Avez-vous des erreurs?

---

En ce qui concerne votre deuxième problème:

powerOfN :: Int -> Int 
powerOfN num = powerOf num 

La signature de type est incorrect.

powerOfN prend un entier et renvoie une fonction qui prend un entier et renvoie un entier.

Ainsi, la signature de type devrait être

powerOfN :: Int -> (Int -> Int) 

Ce qui est le même que (Merci à delnan pour le confirmer):

powerOfN :: Int -> Int -> Int 

Answer 2

Je pense que je vois votre confusion. Vous voulez une version de "powerOf" qui prend un seul argument, alors vous avez essayé de définir "powerOfN" qui ne prend qu'un seul argument. Mais en fait "powerOf" le fait déjà. Vous devez lire "->" comme opérateur de type. Tout comme "+" est un opérateur sur les nombres, "->" est un opérateur sur les types; il faut deux types et renvoie un nouveau. Donc

Foo -> Bar 

est une fonction d'un "Foo" à un "Bar".Mais puisque c'est un type, vous pouvez appliquer une autre « -> » opération, comme ceci:

Int -> (Int -> Int) 

ce qui signifie une fonction qui prend un Int et retourne une nouvelle fonction qui prend une seconde Int et retourne un Int comme résultat.

Haskell définit le « -> » opérateur d'être associative droite, de sorte que les crochets dans ce cas peut être abandonné, il ressemble donc ceci:

Int -> Int -> Int 

Quel est le type de votre fonction « powerof » . Vous pouvez donc utiliser "powerOf" et lui donner un argument, et ce que vous obtenez est une nouvelle fonction qui attend le second argument. C'est ce que tu voulais.