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.

Polymorphic function in reference cell
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: 2009-11-18 (14:58) From: Marc de Falco Subject: Re: [Caml-list] Polymorphic function in reference cell
```I might have misunderstood your problem, and I do not have a solution
but hiding the function and its type inside a module argument for a functor
does the trick, no ?
For example, if you define

module Foo (M : sig type t val f : t -> t end) =
struct let use_f x = M.f x end

You can define too modules Foo1 and Foo2 using your different functions.

Marc

2009/11/18 Hans Ole Rafaelsen <hans@simula.no>

> Hi,
>
> I have a module that have several functions that take a polymorphic
> function as part of their arguments (Foo.f1 and Foo.f2 in the example).
>
> module Foo  = struct
>
>  let f1 f =
>   f 1
>
>  let f2 f =
>   f 1.0
>
>  let f1_ref = (ref (fun _ -> raise (Failure "undefined") : ('a -> 'a) ))
>  let set_f1_ref f =
>   f1_ref := f
>
>  let f2_ref = (ref (fun _ -> raise (Failure "undefined") : ('a -> 'a) ))
>  let set_f2_ref f =
>   f2_ref := f
>
>  let use_f1 () =
>   !f1_ref 1
>
>  let use_f2 () =
>   !f2_ref 1.0
>
>  let internal_f v =
>   v
>
>  let internal_f1 () =
>   internal_f 1
>
>  let internal_f2 () =
>   internal_f 1.0
>
> end
>
> let f v =
>  v
>
> let a = Foo.f1 f
> let b = Foo.f2 f
> let () = Foo.set_f1_ref f
> let () = Foo.set_f2_ref f
> let c = Foo.use_f1 ()
> let d = Foo.use_f2 ()
>
>
> In my code I don't want to pass this function around to to all functions
> where Foo.f1 is called. For this reason I would like to store this function
> that Foo.f1 needs within Foo. (The function is created outside the module
> and bound with values generated outside the module.) However you can not
> store polymorphic functions in references. So I have to make one reference
> for each concrete type it is used for. What I really would like is use it as
> if it was defined within Foo, like internal_f and used like the internal_f1
> and internal_f2.
>
> Is it possible to only store one reference to this kind of function within
> a module, or do I really have to write a reference for each usage of the
> function? If I have to create a reference for each case, do anyone have some
> trick to avoid code repetition?
>
> Regards,
>
> Hans Ole
>
> _______________________________________________
> Caml-list mailing list. Subscription management:
> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> Archives: http://caml.inria.fr
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs
>

```