Re: [Caml-list] Patterns that evaluate

["Nathaniel Gray" <n8gray@gmail.com>]

On 2/14/07, Jacques Carette <carette@mcmaster.ca> wrote:
> Nathaniel Gray wrote:
> > On 2/13/07, Jacques Carette <carette@mcmaster.ca> wrote:
> >> So I wrote (in part):
> >>
> >> let buildsimp cast e f1 f2 = fun e1 -> fun e2 -> match (e1,e2) with
> >>                                                  | ({st = Some e}, _)
> >> -> e2
> >>
> >> and I expected it to work.  Only a code review by a colleague 'found'
> >> this bug in my code.
> >
> > I guess I'm not seeing it.  How did you expect it to work?  Is this
> > what you mean:
> >
> > ... | ({st = Some v}, _) when v = e -> e2
> Yes. that is what I meant.
>
> > Is there some functionality that you're looking for that when clauses
> > don't provide?
> No, there is not.  I was just (mistakenly) assuming that the "more
> pleasant" syntax for this ``worked''.
>
> Explanation: when I was a language designer, I learned a lot from user
> 'mistakes' like this.  Such mistakes told me of the mismatch between
> user expectations and current reality.  So I try to take the time to
> document my own 'mistakes'.
> Philosophy: if I don't take the time to give feedback, why should I
> expect users of my own work to be any different?

That's fine.  I just wasn't sure what you expected to happen.  I made
the same mistake myself when I was learning OCaml, but I don't think
it's something that should be changed.  It's good to minimize new user
mistakes, but you need to make a distinction between mistakes that new
users make once and never make again versus those that cause ongoing
grief.  I think this is definitely the former.  It only takes one
"bite" to make you understand that pattern matches don't compute.

One potential "solution" to this problem for new users would be a
compiler warning when you shadow an existing variable in an explicit
pattern match.

> PS: there is no real functionality that I am looking for that Turing
> Machines don't provide (or C or Java or ...).  And yet I prefer
> languages like (Meta)OCaml and Haskell.  The "raw functionality"
> argument does not seem to be the optimal way to look at these issues, IMHO.

Maybe, but the "it's all equivalent to Turing machines" argument is
pointless outside of formal proofs.  Proposing some syntactic sugar
for 'when' clauses is a very different thing from, say, proposing type
classes and operator overloading, even though neither one has any
impact on what the language can compute.

Cheers,
-n8

-- 
>>>-- Nathaniel Gray -- Caltech Computer Science ------>
>>>-- Mojave Project -- http://mojave.cs.caltech.edu -->