Sorting 重写排序算法。错误的代码或只是错误的间距

我试着自学Haskell，所以我试着用另一种方式重写代码片段。我在一个在线教程中发现了这个排序算法，并试图看看是否有更好的方法来编写它

这是我写的

  quickerSort :: (Ord a) => [a] -> [a]
  quickerSort [] = []
  quickerSort (x:xs) = smallList ++ [x] ++ bigList
                     where let smallList = quickerSort [a | a<-xs, a <= x]
                               bigList = quickerSort [a | a<-xs, a > x]

quickerSort:：（Ord a）=>[a]->[a]
快速排序[]=[]
quickerSort（x:xs）=smallList++[x]+++bigList
其中let smallList=quickerSort[a | a
其中let
是无效语法；只写
其中
那里。
其中let
是无效语法；只写
其中
那里。
其中let
是无效语法；只写
其中
那里。
其中let
是无效语法；只写
其中
那里。
where

是

let

的另一种选择，let的顺序正好相反。您可以在code中编写

let var=foo或
code where var=foo
（尽管有些构造可以使用
let
，但不能使用
where
）。一个比另一个快吗？或者它们的功能相同吗？@Maz：它们之间的任何差异都会在编译过程中被删除。它们的速度完全相同。GHC的中间核心语言只有
let
，而不是
where
，因此它们或多或少都必须被删除为相同的东西。
其中
是
let的替代品
，事情的顺序正好相反。您可以在code
中编写
let var=foo或
code，其中var=foo
（尽管有些构造可以使用
let
，但不能使用
where
）。一个比另一个快吗？或者它们的功能相同吗？@Maz：它们之间的任何差异都会在编译过程中被删除。它们的速度完全相同。GHC的中间核心语言只有
let
，而不是
where
，因此它们或多或少都必须被删除为相同的东西。
其中
是
let的替代品
，事情的顺序正好相反。您可以在code
中编写
let var=foo或
code，其中var=foo
（尽管有些构造可以使用
let
，但不能使用
where
）。一个比另一个快吗？或者它们的功能相同吗？@Maz：它们之间的任何差异都会在编译过程中被删除。它们的速度完全相同。GHC的中间核心语言只有
let
，而不是
where
，因此它们或多或少都必须被删除为相同的东西。
其中
是
let的替代品
，事情的顺序正好相反。您可以在code
中编写
let var=foo或
code，其中var=foo
（尽管有些构造可以使用
let
，但不能使用
where
）。一个比另一个快吗？或者它们的功能相同吗？@Maz：它们之间的任何差异都会在编译过程中被删除。它们的速度完全相同。GHC的中间核心语言只有
let
，而不是
where
，因此它们或多或少都必须被删除为相同的东西。删除
let
。还有，你的
quickerSort
错误，因为它不会对子列表进行递归排序。请删除
let
。此外，您的
快速排序
错误，因为它不会对子列表进行递归排序。请删除
let
。此外，
快速排序
错误，因为它不会对子列表进行递归排序。请删除
let
。另外，您的
quickerSort
是错误的，因为它不会对子列表进行递归排序。
quicksort :: (Ord a) => [a] -> [a]  
quicksort [] = []  
quicksort (x:xs) =   
    let smallerSorted = quicksort [a | a <- xs, a <= x]  
        biggerSorted = quicksort [a | a <- xs, a > x]  
    in  smallerSorted ++ [x] ++ biggerSorted