English version
Accueil     À propos     Téléchargement     Ressources     Contactez-nous    

Ce site est rarement mis à jour. Pour les informations les plus récentes, rendez-vous sur le nouveau site OCaml à l'adresse ocaml.org.

Browse thread
[Caml-list] look operator
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: 2002-06-06 (09:57)
From: Winfried Dreckmann <wd@l...>
Subject: [Caml-list] look operator
Dear everyone,

I can't resist to ask for people's opinion on a certain compromise between
imperative and functional programming which a found in the "numerix" library
of Michel Quercia. Of course, if you read this, Michel, I would be
particularly grateful for your own opinion.

It's about abstracting the ! operator by introducing a function

val look : tref -> t

which coerces a mutable object into a non-mutable one. Using this function
is dangerous because, with this function, the non-mutable type t is not
strictly non-mutable anymore. As the manual says, the result of "look r" is
volatile, it is only guaranteed to be valid until the next in-place
operation involving r. In my own experience, mistakes occur faster than
expected. But this is a great and elegant trick. Using "look", every single
function with arguments of type t, say

val add_in : tref -> t -> t -> unit,

replaces two or more functions which would otherwise be necessary, in this

val add_in1 : tref -> t -> t -> unit
val add_in2 : tref -> tref -> t -> unit
val add_in3 : tref -> tref -> tref -> unit

at least. This would certainly blow up the library to impractical
dimensions. Of course, overloading would help, and "look" might become
obsolete in this way.
However, I think the problem is not mainly about overloading, but about
reintroducing imperative features in an abstract and controlled way. I
could, for instance, also imagine an abstract assign operator

val set : tref -> t -> unit

where the contents of t is not copied but assigned to tref, and thus made
mutable, which could be useful in certain restricted ways.

My question to the caml list: Would you accept such constructions as decent
Caml programming, if applied carefully and only in cases where it allows
what is otherwise impossible (e. g. integrating mutable and non-mutable
objects as it is done in "numerix"). Or is it all just a silent
reintroduction of C pointers, and principally a bad thing?

Winfried Dreckmann

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