Just started learning haskell and if someone wants a 'why' I give you quicksort:

quicksort [] = []
quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater)
where
lesser = filter (< p) xs
greater = filter (>= p) xs

@LeFlawk It's a good example of the difference between declarative and imperative programming. Imperative: change states and then get a final result. Declarative: "this is what this is". The parameter (x:xs) is a list [] where x is the first element and xs the rest of the list. You take x and say "everything greater is on the right side" and "everything lesser vice versa". So you DECLARE how it is recursively instead of changing what is inside the list recursively. The ++ operator just adds lists together

@LeFlawk when I said x I meant p

That's a stupid example to show the why.
From all the things that Haskell has to offer, Monads, ADTs, Typeclasses, ... you show a quicksort -.-

Reminds me of prolog!

@disolved Really?
I could understand when someone says that about dynamically typed, prologish pattern matching supporting Erlang, but Haskell?

@ac1235 It was a purely subjective observation, based on Prolog being my frame of reference for declarative languages. Was it really that hard to believe?

Just. Beautiful.

@ac1235 Good example of declarative and functional programming style. Everything else is awesome too but you gotta start selling from somewhere ;)

@Worldyn Agreed.

@disolved So K reminds you of Prolog, because it is declarative?

@ac1235 and my learning is a work in progress so haven't gotten to know everything yet 👍

@ac1235 if i wrote quicksort in prolog it would look and feel very similar to the example. In k it would not.