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

[Oleg <oleg@okmij.org>]

The question was about creating a class of the following type

>      class type ['a] container : 'a ->
>        object
>          method map : 'b. ('a -> 'b) -> 'b container
>        end

with a mapping method that makes a container of a different
type. Jeremy Yallop has explained very well the class of exactly such
type is not possible. The following is perhaps the simplest workaround
requiring neither modules nor other higher-class artillery. It should
have been possible even in OCaml 3.10 or earlier.

The idea was inspired by some high-falutin' Math, namely, left Kan
extension from Category Theory. I actually don't know CT but I think I
got the gist of the left Kan extension: rather than execute an an
operation, just collect all the needed arguments and declare the
operation performed. The recent paper on Freer monads (Haskell
Symposium 2015) used two instances of this new kind of laziness.

Here is the whole solution

    type 'a cont_proxy = P of 'a

    class ['a] container (x : 'a) = object
      method get_x = x
      method map' : 'b. ('a -> 'b) -> 'b cont_proxy = fun f ->
        P (f x)
    end

The class container has one argument, which is the value needed to
construct the container. The data type cont_proxy contains all the
information needed to construct the container, but not the container
itself (for one, the container type is not yet defined when we
declared P). The method map' doesn't actually construct anything; it
merely returns the data needed for the construction.

The map itself is then easy to define:

    let map : ('a -> 'b) -> ('a container -> 'b container) = fun f c ->
      match c#map' f with
        P x -> new container x

let c = new container 3
    val c : int container = <obj>
let _ = c#get_x
    - : int = 3
let c' = map string_of_int c
    val c' : string container = <obj>
let _ = c'#get_x
    - : string = "3"