Comment author: @sbriais

Not exactly the same request, but I think it could be useful to refer to a class type in an inline object type. Currently, there is no real clean way to reuse class type for constraining the type of a function.

For instance,

class type foo =
object
method foo: int
end

class type bar =
object
method bar: int
end

It's possible to do that:

class f (x:'a) =
object
constraint 'a = #foo
constraint 'a = #bar
method apply = x # bar + x # foo
end

which have type:

class f: 'a ->
object
constraint 'a = #foo
constraint 'a = #bar
method apply: int
end

But it is not possible to write something like that:

let f x = x # foo + x # bar

with type of f being something else than

val f: < foo: int; bar: int; .. > -> int

Unless I am mistaken, the only way to have a clean interface is to define another class type which combines foo and bar like this

class type foobar =
object
inherit foo
inherit bar
end

and then we can write

val f: #foobar -> int

But this scales badly since this means we need to define 2^n interface if we have n basic class types (and also invent 2^n relevant class names)

Maybe allow to write something like

val f: #foo & #bar -> int

I guess the difficult thing is to find a syntax to express this :)

Comment author: @Octachron

This feature wish was granted in OCaml 4.06 with #1118 .