Re: [Caml-list] Constraining abstract type to be of a given subtype

["Daniel Bünzli" <daniel.buenzli@erratique.ch>]

I'm just wondering.

Abstraction is about hiding type representation. Variant subtyping is
a kind of structural subtyping and is thus about type representation.
So constraining an abstract type to be of a given structural subtype
seems contradictory.

The only way I see to type what you want is to make FOO.kind_t
abstract. This doesn't ensure that the implementation of 'a kind_t is
a subtype of Kind.t itself. However if your goal is some kind of
phantom type constraints, it will do the job. And you can still
require a function to convert 'a kind to Kind.t. See the code below.

Best,

Daniel


module Kind:
sig
       type t = [ `A | `B | `C ]

       val to_string: t -> string
end =
struct
       type t = [ `A | `B | `C ]

       let to_string = function
               | `A -> "A"
               | `B -> "B"
               | `C -> "C"
end

module type FOO =
sig
       type custom_t
       type 'a kind_t constraint 'a = [< Kind.t]
       type 'a t = int * custom_t * 'a kind_t

       val make: int -> custom_t -> 'a kind_t -> 'a t
       val string_of_custom: custom_t -> string
       val string_of_kind: 'a kind_t -> string
       val kind_to_kind : 'a kind_t -> Kind.t
end


module Foo1: FOO =
struct
       type custom_t = float
       type 'a kind_t = [`A] constraint 'a = [< Kind.t]
       type 'a t = int * custom_t * 'a kind_t

       let make id custom kind = (id, custom, kind)
       let string_of_custom = string_of_float
       let string_of_kind k = Kind.to_string (k :> Kind.t)
       let kind_to_kind k = (k :> Kind.t)
end