Re: [Caml-list] "map"-ing parameterized class types

["Glen Mével" <glen.mevel@crans.org>]

Le 20/10/2015 13:57, Mikhail Mandrykin a écrit :
> Just in case an another possible work-around would be to use an abstract type 
> instead of a concrete nominal type as a proxy. This can be a little bit more 
> suitable as an abstract type can be later bound to the same structural type 
> and wrapping/unwrapping would become identity in the implementation. This is 
> more heavyweight, though, e.g:
> 
> module type S = sig
>   type 'a c'
>   val new_c : 'a -> 'a c'
> end
> 
> module rec F' :
>   functor (M : S) -> sig
>     class ['a] c : 'a -> object
>         method get : 'a
>         method map : 'b. ('a -> 'b) -> 'b M.c'
>       end
>   end =
>   functor (M : S) -> struct
>     class ['a] c (a : 'a) = object
>       method get = a
>       method map : 'b. (_ -> 'b) -> 'b M.c' = fun f -> M.new_c (f a)
>     end
>   end
> 
> module rec F : sig
>   type 'a c'
>   class ['a] c : 'a -> object
>       method get : 'a
>       method map : 'b. ('a -> 'b) -> 'b F.c'
>     end
>   val new_c : 'a -> 'a F.c'
>   val self_cast : 'a c' -> 'a c
> end = struct
>   module F' = F'(F)
>   class ['a] c = ['a] F'.c
>   type 'a c' = 'a c
>   let new_c a = new F.c a
>   let self_cast (x : 'a c') = (x : 'a c)
> end

nice solution! just saying, it can be simplified, with no need for functor:

    module rec F :
    sig
      class ['a] c : 'a -> object
        method get : 'a
        method map : 'b. ('a -> 'b) -> 'b F.t
      end
      type 'a t
      val make : 'a -> 'a t
      val cast : 'a t -> 'a c
    end =
    struct
      class ['a] c x = object
        method get = x
        method map : 'b. ('a -> 'b) -> 'b F.t = fun f -> F.make (f x)
      end
      type 'a t = 'a c
      let make x = new c x
      let cast x = x
    end

-- 
Glen Mével