Question

我尝试在Haskell中编写一个快速排序，我知道那里有很多版本。

对于Int type

，这个非常简单

quickSort1::[Int]->[Int]
quickSort1 [] = []
quickSort1 (x:xs) = [l | l <- xs, l < x] ++ [x] ++ [ r | r <- xs, r > x]

我可以在Main上打印如下

print $ quickSort1 []   -- output []
print $ quickSort1 [2, 1] -- output [1, 2]

我将上面的quickSort1修改为＆＃34;更通用＆＃34;键入（Ord a）而不是Int

quickSort2::(Ord a)=>[a]->Maybe [a]
quickSort2 [] = Nothing 
quickSort2 (x:xs)  = Just $ [ l | l <- xs, l < x] ++ [x] ++ [ r | r <- xs, r > x]

在我的主要上，我可以运行

它有效

print $ quickSort2 [2, 1] -- output [1, 2]

运行以下

时出现编译错误

print $ quickSort2 [] -- got error

任何人都可以向我解释我的新版本quickSort2

的用途

Answer 1

我假设您使用文件foo.hs并在其中

main = print $ quicksort []

quicksort = ... - as defined above in quickSort2

然后在runghc foo.hs

时收到两条错误消息

foo.hs:3:8: error:
    • Ambiguous type variable ‘a0’ arising from a use of ‘print’
      prevents the constraint ‘(Show a0)’ from being solved.
      Probable fix: use a type annotation to specify what ‘a0’ should be.
      These potential instances exist:
        instance Show Ordering -- Defined in ‘GHC.Show’
        instance Show Integer -- Defined in ‘GHC.Show’
        instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
        ...plus 22 others
        ...plus 11 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the expression: print $ quicksort []
      In an equation for ‘main’: main = print $ quicksort []

有人告诉你，ghc无法告诉你使用Show个实例，而ghc 8已经告诉你如何解决这个问题：

添加类型注释（如@duplode已建议的那样）

main = print $ quicksort ([] :: [Int])

相似但略有不同的是第二条错误消息

foo.hs:3:16: error:
    • Ambiguous type variable ‘a0’ arising from a use of ‘quicksort’
      prevents the constraint ‘(Ord a0)’ from being solved.
      Probable fix: use a type annotation to specify what ‘a0’ should be.
      These potential instances exist:
        instance Ord Ordering -- Defined in ‘GHC.Classes’
        instance Ord Integer
          -- Defined in ‘integer-gmp-1.0.0.1:GHC.Integer.Type’
        instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Base’
        ...plus 22 others
        ...plus five instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In the second argument of ‘($)’, namely ‘quicksort []’
      In the expression: print $ quicksort []
      In an equation for ‘main’: main = print $ quicksort []

在第一条消息中，print函数要求Show实例 - 在此您承诺quicksort提供一个orderables列表 - 但没有说明要使用哪个，所以GHC抱怨Ord使用什么。

这两个消息都是由于[]过于多态，可能是任何事物的列表 - [Int]是好的，但它也可能像[Int -> Bool]那样Show能够Ord能够。{/ p>

你也可以为quicksort提供像

这样奇怪的东西

newtype HiddenInt = HI Int deriving (Ord) --but not Show

适用于quicksort功能，但不适用于print。

旁注

你的quicksort函数需要递归才能真正正确 - 正如我在评论中指出的那样 - 你的算法中存在逻辑问题 - 一定要正确测试你的函数，例如。

import Data.List (sort)

main :: IO ()
main = do print $ "quicksort [10,9..1] == Just (sort [10,9..1]) is: "
           ++ show $ quicksort ([10,9..1]::Int]) == Just (sort ([10,9..1]::Int]))
          print $ "quicksort [5,5,5] == Just (sort [5,5,5]) is: "
           ++ show $ quicksort ([5,5,5] :: [Int]) == Just (sort ([5,5,5] :: [Int]))

quicksort :: (Ord a) => [a] -> Maybe [a]
quicksort = ...

或者如果您有兴趣，请查看QuickCheck - 这是更先进的，但是朝着正确方向迈出的一步，可以按照您期望的方式运行。

在Haskell中编写快速排序并需要帮助来解决问题

1 个答案: