> 
> 
> from the documentation:
>   The pattern pattern1 | pattern2 represents the logical ``or'' of the two
>   patterns pattern1 and pattern2. [...] If both matchings succeed, it is
>   undefined which set of bindings is selected.
> 
> is there a reason for not using the classical pattern matching rule, to make
> the ordering matters? (i've been nastily beat by this :-/)
> 
> eg:
> 
> 
> type foo = Bar | Foo of foo
> 
> let f1 = function
>   | Foo(a) 
>   | a -> a
> 
> let f2 = function
>   | Foo(a) -> a
>   | a -> a
> 
> let e1 = f1 (Foo Bar)  (*=> Foo Bar *)
> let e2 = f2 (Foo Bar)  (*=> Bar *)
> 
> 
> thanks
> --
> Pixel

Yes there are two reasons
 1. ease of compilation.
    As you have experienced yourself. In case one of the patterns in
    the or-pattern is a variable, then the or-pattern is reduced to a
    variable. Otherwise, compilation would be a bit more complicated.

 2. Ideology. I consider that priority in or-patterns is something
    obscure, and would discourage relying on it.
    However the current (unspecified) semantics makes the idea
    of a ``partially useless'' matching clause a bit random, and this
    semantics may become more precise in the future.

Cheers,

--Luc
-------------------
Bug reports: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr