An update on Moiell. Since the first post on Moiell I've been wanting to show you the quicksort example. But there was a bug in the implementation that prevented the example to run. And I wanted to be sure that I wasn't making a thinking error. The code is running now so here it is:

qsort : [|x::more|
  xs := more
  > qsort(xs < x), x, qsort(xs >= x)
]

> qsort(5,7,9,3,6,7,0,3,4)

First, to get that out of the way, xs := more is to kill the lazyness that was so useful in the prime sieve. The more variable is implemented using a single-shot continuation, but we need the values twice this time.

The next line shows the advantages of sequences and goal-directed programming. A part like qsort(xs < x) may seem odd for the average programmer, but not (and that's my hope) to the average person. This is because you can pronounce this as "qsort the X's smaller than X". Which is exactly what it does.

Compare this to the Haskell version of quicksort. The Moiell code is shorter, but still (I believe) easier to understand. Also note that the Moiell code doesn't need the special case for sorting no values. When pattern matching fails, the function simply returns no value. This is goal directed programming again.

I'll leave you with a more imperative flavored implementation of quicksort:

qsort : [|x::xs|
  lt := (); gte := ()
  xs.[(lt ,= me < x) or (gte ,= me)]
  > qsort(lt), x, qsort(gte)
]