Version française
Home     About     Download     Resources     Contact us    
Browse thread
Re: Syntax for label
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Steven Thomson <sthomson@z...>
Subject: Re: Syntax for label, ANOTHER NEW PROPOSAL

Pierre Weis wrote: [part of long post omitted]
> 
> $ ocaml
>         Objective Caml version 2.99+10
> 
> # let sum l = List.fold_right ( + ) l 0;;
> val sum : int list -> int = <fun>
> 
> Clearly application is denoted in ML with only one character: a space.
> 
> Now, consider using the so-called ``Modern'' versions of these
> functionals, obtained with the -modern option of the compiler:
> 
> $ ocamlpedantic
>         Objective Caml version 2.99+10
> 
> # let sum l = List.fold_right ( + ) l 0;;
>                               ^^^^^
> This expression has type int -> int -> int but is here used with type 'a list
> 
> Clearly, there is something wrong now! We may remark that the error
> message is not that clear, but this is a minor point, since error
> messages are never clear enough anyway!
> 
> The real problem is that fixing the code makes no good at all to its
> readability (at least that's what I would say):
> 
> # let sum l = List.fold_right fun:begin fun x acc:y -> x + y end acc:0;;
> val sum : 'a -> int list -> int = <fun>
> 
> It seems that, in the ``modern'' mode, application of higher order
> functions is now denoted by a new kind of parens opening by
> ``fun:begin fun'' and ending by ``end''. This is extremely explicit
> but also a bit heavy (in my mind).
> 
> For all these reasons, I would suggest to carefully use labels into
> the standard libraries:
> 
> -- remove labels from higher-order functional

I don't think that merely omitting labels from higher-order functional
arguments really solves the problem.  Consider the following:

  $ ocaml -modern
          Objective Caml version 2.99 (99/12/08)

  # let add' :acc x = acc + x;;
        val add' : acc:int -> int -> int = <fun>
  # let rec fold_left' f accu l =
    match l with
      [] -> accu
    | a::l -> fold_left' f (f accu a) l;;
        val fold_left' : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a = <fun>
  # let sum' = fold_left' add' 0;;
      Characters 24-28:
  This expression has type acc:int -> int -> int but is here used with
type
    'a -> 'b -> 'a

If the definition of fold_left' does NOT use a label, we still get a
compile error whenever we try to use an argument that DOES have a label.

My proposal is to introduce an operator that can be used to tell the
compiler to ignore labels when type-checking a higher-order functional
argument.  This could be thought of as a pragma which locally switches
the compiler from modern to classic mode.

Some possible variations:

1. A prefix operator, here shown as "~", that causes only the following
expression to be evaluated in classic mode: 

  let sum = List.fold_left fun:~(+) acc:0
  let sum' = fold_left' ~add' 0

2. A bracketing construct, here shown as [~ ~], that causes everything
inside the brackets to be evaluated in classic mode. 

  let sum = List.fold_left fun:[~(+)~] acc:0
  let sum' = fold_left' [~add'~] 0

option 2 is not as visually lightweight, but might be more useful if
there are several arguments that need to be altered:
  let aaa = bbb ccc:~ddd eee:~fff ggg:~hhh ~iii jjj
versus
  let aaa = bbb [~ ccc:ddd eee:fff ggg:hhh iii ~] jjj