Browse thread
[Caml-list] look operator
[
Home
]
[ Index:
by date
|
by threads
]
[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: | 2002-06-06 (11:01) |
From: | Pixel <pixel@m...> |
Subject: | Re: [Caml-list] look operator |
Winfried Dreckmann <wd@lidingo.mail.telia.com> writes: [...] > 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. => "look" is only used for efficiency? couldn't the compiler achieve the same result without using an unsafe construct? > 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 > case > > val add_in1 : tref -> t -> t -> unit > val add_in2 : tref -> tref -> t -> unit > val add_in3 : tref -> tref -> tref -> unit are you saying that i would be nice to have this? As far as i have looked at numerix, it doesn't have this. > > 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, agreed, row subtyping can already achieve this: ---------------------------------------- let add_in_wrapped r a b = r := !r + a + b let deref = function | `Ref a -> !a | `Const a -> a let add_in (`Ref a) b c = add_in_wrapped a (deref b) (deref c) let x = `Ref (ref 1) let y = `Ref (ref 2) let c = `Const 3 ;; add_in x y c ; x ---------------------------------------- > 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? I don't think this will never be in OCaml! (but i may be prooved wrong :) I've not found many information about this. AFAIK C++ is the only language having constness subtyping (http://merd.net/inoutness.html) The few links i've found: http://merd.net/inoutness.html#references I someone knows better, please tell, i'm interested :) ------------------- 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