Haskell中的函数currying

我有一个功能：

powerOf :: Int -> Int -> Int

操作系统使用示例：

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

我有两个问题。第一，为什么它不起作用：

map (powerOf 100) [2, 5]

我想得到[2,2]

第二个问题。我正在尝试创建pariatl函数。大概是这样的：

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

Int -> (Int -> Int)

Int -> Int -> Int

要这样使用它：

let powerOf100 = powerOfN 100
powerOf100 2
powerOf100 5

但我得到了错误信息：

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

下面是完整的五月代码：

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

divided:：Int->Int->Bool
除a和b=
设x=积分a
y=积分b
in（a==截断（x/y）*b）
listOfDividers:：Int->[Int]
驱动器数量列表=
设n=fromIntegral num
maxN=截断（sqrt n）
在[n | n布尔
isItSimple num=长度（listOfDividers num）==1
ListofSimpleViders:：Int->[Int]
ListofSimpleViders num=[n | n Int->Int->Int
内数p幂的幂
|除数p=powerOfInner（quot num p）p（power+1）
|否则=功率
powerOf:：Int->Int->Int
powerOf num p=powerOf INER num p 0
powerOfN:：Int->Int
powerOfN num=powerOf num

powerOf返回p的最大功率，以num为单位。例如：100=2*2*5*5，所以powerOf 100 2=2。10=2*5，所以powerOf 10 2=1

---

如何修复错误？谢谢。

除了powerOfN函数外，还使用您的代码。我无法用

map（powerOf 100）[2,5]

重现您的问题

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

你有什么错误吗

---

关于你的第二个问题：

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

类型签名不正确

powerOfN接受一个整数并返回一个函数，该函数接受一个整数并返回一个整数

所以类型签名应该是

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

与（感谢您的确认）相同：

---

使用你的代码，除了powerOfN函数。我无法用

map（powerof100）[2,5]

重现你的问题

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

你有什么错误吗

---

关于你的第二个问题：

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

类型签名不正确

powerOfN接受一个整数并返回一个函数，该函数接受一个整数并返回一个整数

所以类型签名应该是

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

与（感谢您的确认）相同：

---

我想我看到了你的困惑。你想要一个版本的“powerOf”只接受一个参数，所以你试图定义“powerOfN”，它只接受一个参数。但事实上，“powerOf”已经做到了。你必须把“->”读作类型运算符。就像“+”是数字上的运算符一样，所以“->”是类型上的运算符；它接受两个类型并返回一个新类型

Foo -> Bar

是从“Foo”到“Bar”的函数。但由于这是一种类型，您可以对其应用另一个“->”操作，如下所示：

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

Int -> (Int -> Int)

Int -> Int -> Int

这意味着一个函数接受一个Int，然后返回一个新函数，该函数接受第二个Int并返回一个Int作为结果

Haskell将“->”操作符定义为右关联，因此可以删除本例中的括号，因此看起来如下所示：

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

Int -> (Int -> Int)

Int -> Int -> Int

---

这就是“powerOf”函数的类型。所以你可以使用“powerOf”并给它一个参数，你得到的是一个新函数，它需要第二个参数。这就是你想要的。

我想我看到了你的困惑。你想要一个版本的“powerOf”只需要一个参数，所以你试图定义“powerOfN”它只接受一个参数。但事实上“powerOf”已经做到了。你必须把“->”作为类型运算符来读。正如“+”是数字上的运算符，所以“->”是类型上的运算符；它接受两个类型并返回一个新的类型。所以

Foo -> Bar

是从“Foo”到“Bar”的函数。但由于这是一种类型，您可以对其应用另一个“->”操作，如下所示：

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

Int -> (Int -> Int)

Int -> Int -> Int

这意味着一个函数接受一个Int，然后返回一个新函数，该函数接受第二个Int并返回一个Int作为结果

Haskell将“->”操作符定义为右关联，因此可以删除本例中的括号，因此看起来如下所示：

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

Int -> (Int -> Int)

Int -> Int -> Int

---

这是“powerOf”函数的类型。因此，您可以使用“powerOf”给它一个参数，你得到的是一个新函数，它需要第二个参数。这就是你想要的。

你能提供

powerOf

的代码吗？

powerOf

似乎被破坏或命名错误。据我所知，2的幂等于10000。我发布了所有代码并解释了powerOf。它仍然可以正常工作-这是我的错误。我正在尝试map（powerOf 100）[1,2,5]并得到了不确定的递归。你能提供

powerOf

的代码吗？

powerOf

似乎被破坏或命名错误。据我所知，100到2的幂等于10000。我发布了所有代码并解释了powerOf。它仍然可以正常工作-这是我的错误。我正在尝试map（powerOf 100）[1,2,5]并得到了不确定的递归。甚至没有必要，

powerOf n 100

与

powerOf 100

相同@Piotr：没错，这就是隐式currying/make n元函数一元函数返回（n-1）元函数的全部要点。是的，比你更重要。这是我的错误。我正在尝试map（powerOf 100）[1,2,5]并且得到了不确定的递归。甚至没有必要，

powerOfN 100

与

powerOf 100

@Piotr:没错，这就是隐式curry/生成n元函数一元函数返回（n-1）元函数的全部意义。是的，比你还重要。这是我的错误。我正在尝试映射（powerOf 100）[1,2,5]，得到了不确定的递归。