I just stumbled upon this Wiki page discussing MicMatch:

  http://ocaml.pbwiki.com/Micmatch

and noted that the implementation of views disables exhaustiveness checking. I 
think it is worth keeping the static checking of view patterns.

So MicMatch uses definitions like:

  type 'a lazy_list = Empty | Cons of 'a * 'a lazy_list lazy_t

  let view Empty = fun l -> Lazy.force l = Empty
  let view Cons = fun l -> match Lazy.force l with Cons x -> Some x

  match ll with
      %Empty -> ...
    | %Cons (x, %Empty) -> ...
    | %Cons (x1, %Cons (x2, %Empty)) -> ...
    | _ -> ...

where F# would use:

  let (|PEmpty|PCons|) l =
    match Lazy.force l with
    | Empty -> PEmpty
    | Cons(h, t) -> PCons(h, t)

This basically defines a new sum type and every time a view pattern is 
encountered, it is converted using this function into the new sum type and 
then matched over. This means you cannot mix view and non-view patterns in 
the same match but you do get to keep exhaustiveness checking.

Having said all of that, the only application of F#-style views in OCaml that 
I can think of is simply matching lazy values, which could be implemented 
more easily and with no syntactic overhead.

There are other applications that MicMatch might not cater for. Specifically, 
factoring patterns and parameterizing patterns over values. For example, you 
might want an active pattern than handles commutativity:

  Commute(p1, p2)  =>  p1, p2 | p2, p1

-- 
Dr Jon D Harrop, Flying Frog Consultancy Ltd.
http://www.ffconsultancy.com/products/?e