The example code in the article is in Haskell. I've been learning OCaml for several months now and reading an article like this helps me learn a bit of Haskell along the way. I did a translation of the code in the article into OCaml which lets me compare and contrast the languages. Here's my OCaml translation:
(* RedBlack trees in OCaml *)
(* see Okasaki paper: Functional Pearls: Red-Black Trees in a Functional
Setting *)
type color = R | B ;;
type 'a tree = E | T of color * 'a tree * 'a * 'a tree ;;
let rec member x t = match t with
E -> false
| T( _, a, y , b) -> ( if x = y then true else
if x > y then (member x b) else
(member x a) ) ;;
let makeBlack node = match node with
E -> node
| T( _, a, y, b) -> T( B, a, y, b) ;;
let rec balance t = match t with
T(B, T(R, T(R, a,x,b), y, c), z, d) | T( B, T(R,a,x,T(R,b,y,c)),z,d) |
T(B,a,x, T(R,T(R,b,y,c),z,d) ) | T(B,a,x,T(R,b,y,T(R,c,z,d))) ->
T(R, T(B,a,x,b), y, T(B, c,z,d))
| _ -> t ;;
let rec insert x s =
let rec ins s = match s with
E -> T( R, E, x, E)
| T(c, a, y, b) -> ( if x = y then T(c,a,y,b ) else
if x > y then ( balance (T(c,a,y,(ins b))) ) else
( balance (T(c,(ins a),y,b)) ) ) in
makeBlack( ins s) ;;
Notice that in the balance function there are four patterns which lead to the same result. OCaml handles this nicely without repetition of code. However it seems that the Haskell version requires that the result be repeated for each of these cases as Okasaki notes in his article. His article was written in 1993 and he mentions that in the future Haskell could have or-patterns, but from what I can tell by googling around a bit and asking on the PDX_func mailing list this feature is still not in Haskell. So here's a situation where I definitely can say that I prefer the (OCa)ML solution. I'm sure there are other things to prefer in Haskell, though, like type classes.