Re: [Caml-list] OCaml wishlist

[William Lovas <wlovas@stwing.upenn.edu>]

> On Tue, Oct 21, 2003 at 03:29:21PM +0100, Richard Jones wrote:
On Tue, Oct 21, 2003 at 04:55:31PM +0200, Michal Moskal wrote:
> > 2. abstract data type syntactic sugar:
> >    obj#call		      [	or:   obj->call ]
> > 
> >    is exactly equivalent to:
> > 
> >    M.call obj
> 
> let f a b c = a->add b c
> 
> What type does f have? 

You could disambiguate by adding a module qualifier: `a->M.add b c'.  But
then, this can be done with an ordinary infix operator:

    # let (=>) obj meth = meth obj;;
    val ( => ) : 'a -> ('a -> 'b) -> 'b = <fun>
    # let l = [(1, "abc")];;
    val l : (int * string) list = [(1, "abc")]
    # l=>List.length;;
    - : int = 1
    # l=>List.assoc 1;;
    - : string = "abc"

... as long as you don't mind using a slightly different arrow, anyway --
`->' isn't a valid identifier due to O'Caml's lexical conventions.

Viewed in this way, though, this is really no more than an obfuscation of
code.  Providing multiple syntaxes for the same concept starts one down the
slippery slope of creating a write-only language (witness Perl).

> > After writing a fair bit of OCaml in commercial situations (although
> > I'm by no means an expert, and really should learn camlp4), here's my
> > wishlist:
> > 
> > 1. 'return' from a function. eg:
> > 
> >   let foo x =
> >     if x < 0 then return "OSL";
> >     (* long & complex code *)
> >     return "some other string"
> > 
> >   I know I can do this using if ... else, but when you have multiple
> >   levels of if ... else you end up being indented so far across the
> >   screen as to make coding unpleasant. 

This one's quite a bit more difficult, though: what is the type of a
`return'?  Under the current typing rules for if-then-else expressions, it
must be `unit', since the `else' branch has been omitted.  But if it's
unit, then the function returns unit, which is incorrect.

What you want is a return *statement*, but such a beast is incompatible
with O'Caml, since O'Caml is an expression-oriented language.  I don't see
an easy way of making a `return' expression that behaves the way you want
it to.

However, i will point out that code indentation is merely a programmer
convention, and is not enforced by the syntax of the language -- so you
could do what you want using ordinary O'Caml if-then-else expressions and
*still* not have your code be too indented:

    let foo x =
        if x < 0 then
            (* special case for negative x *)
            "OSL"
        else
        (* normal case *)
        <long and complex code>
        "some other string"


I don't think it would be beneficial in the long run to clutter up the core
language with these sorts of purely syntactic issues -- that's why we have
camlp4, isn't it?  Better, though, in my opinion, would be to adapt your
mental syntax to fit the functional style than to adapt the functional
language to cater to your imperative style.  That way, you end up producing
clearer code that can be read by any competent O'Caml programmer -- a major
win for the poor maintainer 10 years down the road! :)

cheers,
William

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners