RE: [Caml-list] Patterns that evaluate

[Don Syme <Don.Syme@microsoft.com>]

> > Because, thanks to typing, we can
> > check exhaustivity and overlapping, and use this information to detect
> > error and optimize compilation. Unfortunately, views do not allow
> > that...
>
> Actually, I believe F# implements that in some form.

Jon's jumping the gun a little: we have indeed recently redesigned active patterns for F# and I'll be writing up the details in the next few days, in a blog entry I guess. The implementation will also be in the next F# release.

There are still plenty of issues with using active patterns, especially in languages with side effects - how many times do you run those discrimination functions? Possible approaches to this issue were addressed by Chris Okasaki's paper on views for Standard ML, and the current specification we're using for F# is that "if we need to run an active discrimination function on a given input once, we can run it on the same input as many times as we wish within the given pattern match".  That is somewhat unsatisfactory semantically if the functions have visible side effects, but we want to strongly discourage such discriminator functions, in much the same way that side effects are strongly discouraged by the functions that implement the C# and F# property notations.  So I believe will be OK in practice, though I can see why people might find it distasteful (though if you don't choose this semantics then exponential code blow up looks hard to avoid, including in realistic code).

In any case our main aim has really been to explore the design space and find out how useful these things actually are in practice, and see if there's a reasonable version of this stuff that might make it into C# or a similar language.

BTW this work was done by Gregory Neverov over last summer during his internship at MSR. This led to me discussing the issue with a bunch of functional languages folk, including Martin Odersky, who was looking at the issue in Scala, along with Burak Emir.  Then I showed Greg's prototype to Simon Peyton Jones, which led to him making a proposal for views for Haskell, which led to Martin Jambon looking at the issue from the OCaml perspective (and going beyond what we had in the F# prototype in some interesting ways).

Cheers
don




-----Original Message-----
From: caml-list-bounces@yquem.inria.fr [mailto:caml-list-bounces@yquem.inria.fr] On Behalf Of Jon Harrop
Sent: 15 February 2007 03:58
To: caml-list@yquem.inria.fr
Subject: Re: [Caml-list] Patterns that evaluate

On Thursday 15 February 2007 00:26, Jacques Garrigue wrote:
> As with any extension, an important question with views is whether
> they should be in the language, as in F#, or supported by the
> preprocessor as you did. After all, pattern-matching in Scheme is
> entirely based on macros, and people are perfectly happy with
> that. Why is it not the case in ML? Because, thanks to typing, we can
> check exhaustivity and overlapping, and use this information to detect
> error and optimize compilation. Unfortunately, views do not allow
> that...

Actually, I believe F# implements that in some form.

--
Dr Jon D Harrop, Flying Frog Consultancy Ltd.
OCaml for Scientists
http://www.ffconsultancy.com/products/ocaml_for_scientists

_______________________________________________
Caml-list mailing list. Subscription management:
http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
Archives: http://caml.inria.fr
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs