Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] Fwd: Polymorphic optional label argument, with default
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Jacques Garrigue <garrigue@k...>
Subject: Re: [Caml-list] Fwd: Polymorphic optional label argument, with default
From: nadji <nadji@noos.fr>
> Le Sunday 11 April 2004 15:16, Jacques Garrigue a ecrit :

> > Basically, what you are asking for is a new type of constraint, which
> > is only to be applied when the optional argument is omitted (and as
> > result the default is selected).
> > This is not possible in the current type system, and while there are
> > some uses for that, it would be hard to justify making types more
> > complex in the general case, just to handle this specific problem.

> I would like to point out that a machinery to handle this problem
> is guarded recursive datatypes proposed by Xi. It is a framework
> that solves a bunch of other problems and is compatible with ml type
> system (there is currently at Inria a student working on an Ocaml integration 
> of this type system).
> Combining it with your labeled parameters leads to a well typed code
> analogous to your phantom-type based solution. Some even view
> Xi's GRDT as a way to avoid your Obj.magic when matching against 
> a phantom type. 
> For those interested, the pseudo code would be something like :
> 
> guarded 'a opt = Omit with 'a = int | Arg of 'a->unit
> let plot : ?(labels:'a opt) -> 'a graph -> unit =
>   fun ?(labels=Omit) g ->
>   let printing_labels : 'a -> unit = 
>      match labels with 
>        Omit -> print_int
>     | Arg x -> x
>   in
>   ... printing_labels node_label ...

I was not aware that there was already work to include guarded types
in ocaml. They are indeed a nice solution to this problem,
particularly as they allow to cleanly separate issues.

Another (less clean) way to do that is with dependant
polymorphic variants, as implemented in a branch of the ocaml CVS:
# let incr ~f x =
    let x = x+1 in
    multimatch f with `None -> x | `Some f -> f x
  ;;
val incr :
  f:[< `None & 'a = int | `Some of int -> 'b & 'a = 'b ] -> int -> 'a = <fun>
# incr ~f:`None 3;;
- : int = 4
# incr ~f:(`Some string_of_int) 3;;
- : string = "4"

(Note that for this to really work, optional arguments would have to
use polymorphic variants, which is why it is not as clean as guarded
types.)

Jacques Garrigue

-------------------
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