按 int (Haskell) 对 ('String', int) 的列表进行排序

Question

I am brand new to Haskell, so I'm still learning a lot of things. I was given a list of name and age, and I need to sort them in both alphabetical order and in increasing order using their age. I managed to sort the list alphabetically, but I'm unsure how to do it using its age values. What can I change in the code below? Thank you for your help.

qsort :: (Ord a) => [a] -> [a]
-- check to see if the list is empty
qsort [] = []
qsort [x] = [x] -- Single element list is always sorted
qsort [x, y] = [(min x y), (max x y)]
-- x is the pivot, left quicksort returns smaller sorted and right quicksort bigger sorted
qsort (x:xs) =
  qsort [a | a <- xs, a <= x] ++ [x] ++ qsort [a | a <- xs, a > x]


people=[("Steve",20),("Smith",31),("Kris",19),("Beth",21)]

main = do
  print(qsort people) -- sort alphabetically

Answer 1

First, let's simplify your function a bit. Both the [x] and [x, y] cases are redundant: they are completely captured by the (x:xs) case. So let's remove those.

qsort :: (Ord a) => [a] -> [a]
qsort [] = []
qsort (x:xs) =
  qsort [a | a <- xs, a <= x] ++ [x] ++ qsort [a | a <- xs, a > x]

Now, currently we assume that the type of our list and the type we're sorting by are the same. We call them both a . Let's instead have two types: a will be the type of our list and b will be the type we want to sort by. Only b has to satisfy Ord , and we'll need a function to convert an a into a b so we can sort our list. This is our desired type

qsort :: (Ord b) => (a -> b) -> [a] -> [a]

Our base case is basically the same, except that we ignore the function argument.

qsort _ [] = []

In our recursive case, we compare by applying the function f:: a -> b and then using <= or > .

qsort f (x:xs) =
    qsort f [a | a <- xs, f a <= f x] ++ [x] ++ qsort f [a | a <- xs, f a > f x]

Now we can sort by whatever Ord type we want. We can sort by the first element of a tuple

-- Note: (fst :: (a, b) -> a) is in Prelude
print (qsort fst people)

or the second

-- Note: (snd :: (a, b) -> b) is in Prelude
print (qsort snd people)

both by their natural sorting order.

If we want to sort in the opposite order (descending rather than ascending), we can use Down as our function. If we want to sort by some complex order, we can always use the newtype pattern .