0

我有一个功能：

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

以这种方式使用它：

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

powerOf 返回 num 中 p 的最大幂。例如：100 = 2 * 2 * 5 *5，所以 powerOf 100 2 = 2。10 = 2 * 5，所以 powerOf 10 2 = 1。

如何修复错误？谢谢。

4

2 回答 2

5

使用您的代码，除了 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)

这与（感谢delnan确认）相同：

powerOfN :: Int -> Int -> Int
于 2010-12-05T14:04:11.533 回答
0

我想我看到了你的困惑。您想要一个采用单个参数的“powerOf”版本，因此您尝试定义只采用一个参数的“powerOfN”。但实际上“powerOf”已经做到了。您必须将“->”作为类型运算符阅读。正如“+”是数字运算符一样，“->”是类型运算符；它需要两种类型并返回一种新类型。所以

Foo -> Bar

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

Int -> (Int -> Int)

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

Haskell 将 "->" 运算符定义为右结合，因此这种情况下的括号可以去掉，所以它看起来像这样：

Int -> Int -> Int

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

于 2010-12-05T15:06:47.723 回答