The quicksort algorithm in Haskell
First of all, great that you used type annotations, as they're sometimes missing. However, there are some remarks:


"edge" and "general"` condition are usually called "base case" and "recursive case"
"base case" and "recursive case" aren't commented in Haskell code, as they are everywhere
split is generic enough to be defined at top-level
split has a little bit of duplication that we can remove with a single where clause
functions are usually named in camelCase instead of snake_case, so we'd call it quickSort.


If we apply that we end up with

quickSort :: (Ord a) =&gt; [a] -&gt; [a]
quickSort []       = []
quickSort (x : xs) =
    let (lt, gt) = split x xs
    in  (quickSort lt) ++ [x] ++ (quickSort gt) 

split :: (Ord a) =&gt; a -&gt; [a] -&gt; ([a], [a])
split x [] = ([], [])
split x (h : hs)
    | h &lt;= x    = ( h : lt,     gt)
    | otherwise = (     lt, h : gt)
    where
        (lt, gt) = split x hs


That being said, split seems so helpful that there should be some function already in the standard library. And it turns out there is, namely partition :: (a -&gt; Bool) -&gt; [a] -&gt; ([a],[a]) from Data.List:

split :: (Ord a) =&gt; a -&gt; [a] -&gt; ([a], [a])
split x = partition (&lt;= x)


That's a lot cleaner than our own implementation. So how do we find partition if we don't know about it yet? We use Hoogle. However, a query for Ord a =&gt; a -&gt; [a] -&gt; ([a],[a]) does not yield partition. It's sometimes a good idea to generalize the query a little bit, for example to [a] -&gt; ([a],[a]), as Hoogle also scans parts of the type signature. That way, we find partition.

If we're going for brevity, we can then inline split to gain

-- | Sorts the given list in an ascending order.
quickSort :: (Ord a) =&gt; [a] -&gt; [a]
quickSort []       = []
quickSort (x : xs) =
    let (lt, gt) = partition (&lt;= x) xs
    in  (quickSort lt) ++ [x] ++ (quickSort gt)


but that's up to personal preference, as the compiler will inline split anyway.