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 回答