basic Haskell: defining sorting function by recursion

Question

So I have slight problem with sorting function. I need to define (using recursion) a function i , that takes as an argument a list of arguments a (this list needs to belong to Ord ), which outputs ordered list of elements of type a . Example: i [3,2,1] = [1,2,3]

I have managed to come with this solution:

i :: Ord a => [a] -> [a]

i [] = []
i (x:xs) 

| x <= head (xs) = x: i xs
| otherwise = i xs : x

But it doesn't compute, outputting many errors. What is wrong?

Answer 1

Let me give you some hints to get you started. First of all, let's fix the formatting:

i :: Ord a => [a] -> [a]
i [] = []
i (x:xs) 
    | x <= head (xs) = x: i xs
    | otherwise = i xs : x

This throws an error which says:

In the first argument of ‘(:)’, namely ‘i xs’
In the expression: i xs : x

Now, this expression i xs : x is problematic. The type of (:) is (:) :: a -> [a] -> [a] . But in your expression you are passing a list instead of a value. What you meant to use was possibly ++ . Using that fixes the compile error:

i :: Ord a => [a] -> [a]
i [] = []
i (x:xs)
    | x <= head (xs) = x: i xs
    | otherwise = i xs ++ [x]

Now, if you try it in ghci , you will get a runtime exception:

ghci> i [3,2,1]
*** Exception: Prelude.head: empty list

Can you guess why ? That's because you haven't handled the case where the list is of length 1 . So handling the case will give you this:

i :: Ord a => [a] -> [a]
i [] = []
i (x:[]) = [x]
i (x:xs)            
    | x <= head (xs) = x: i xs
    | otherwise = i xs ++ [x]

Now, you may think that this works:

ghci> i [3,2,1]
[1,2,3]
ghci> i [3,1,2]
[1,2,3]

But it doesn't actually work, because there is a flaw in your algorithm. Just comparing the first two elements of the list won't give you an sorted array.

ghci> i [2,1,3]
[1,3,2]

I hope this is enough to get you started.