Union of polymorphic variants...

Union of polymorphic variants...

[Stephane Glondu]

Hi,

Why isn't possible to do the following?

type b = [`A of [`B of bool]]
type c = [`A of [`C of char]]
type a = [b|c]

I expect the last declaration to be equivalent to:

type a = [`A of [`B of bool | `C of char]]


Thanks,

-- 
Stephane Glondu

Re: [Caml-list] Union of polymorphic variants...

[Jacques Garrigue]

From: Stephane Glondu <steph@glondu.net>
> Why isn't possible to do the following?
> 
> type b = [`A of [`B of bool]]
> type c = [`A of [`C of char]]
> type a = [b|c]
> 
> I expect the last declaration to be equivalent to:
> 
> type a = [`A of [`B of bool | `C of char]]

Because union of polymorphic variant is flat.
So the above requires the parameter of `A to be of type both
[`B of bool] and [`C of char].

The reason is that dispatch only looks at the head constructor:

let f = function
  | #b as x -> fb x
  | #c as x -> fc x

is actually

let f = function
  | `A _ as x -> fb x
  | `A _ as x -> fc x

which only types if both parameters have the same type.

Polymorphic variants are _not_ XML types.
Use ocamlduce for that :-)

    Jacques

Re: [Caml-list] Union of polymorphic variants...

[Stephane Glondu]

Jacques Garrigue a écrit :
> [...] union of polymorphic variant is flat [...]
> The reason is that dispatch only looks at the head constructor:
> 
> let f = function
>   | #b as x -> fb x
>   | #c as x -> fc x
> [...]

Actually, I was faced to the problem in a similar pattern-matching, and 
I reduced the problem to the example in my post :-)

> [...] is actually
> 
> let f = function
>   | `A _ as x -> fb x
>   | `A _ as x -> fc x
> 
> which only types if both parameters have the same type.

However, one can do:

let f = function
   | `A (`B _) -> ...
   | `A (`C _) -> ..

Would it be difficult to extend the system so that #b and #c expand to 
the constructions above?

> Polymorphic variants are _not_ XML types.
> Use ocamlduce for that :-)

I am having a look at it...

-- 
Stéphane Glondu

Re: [Caml-list] Union of polymorphic variants...

[Jacques GARRIGUE]

From: Stephane Glondu <steph@glondu.net>

> However, one can do:
> 
> let f = function
>    | `A (`B _) -> ...
>    | `A (`C _) -> ..
> 
> Would it be difficult to extend the system so that #b and #c expand to 
> the constructions above?

Nothing is "difficult". But not everything is well-defined...
The question is where do we start, where do we stop.

type a = [`S of a | `Z]

should #a be (`S _ | `Z) or (`S (`S _ | `Z) | `Z) or ...?

type b = [`A of [`B] option]

should #b be (`A (None | Some `B)) ?

Generally, when such questions start to pop up, it is better to
forget about it. It could still be a good idea, but we need more
examples to see that.

Note that you can still build the types by hand

type 'a t = [`A of 'a]
type b = [`B of bool]
type c = [`C of char]
type a = [b|c] t

let f = function
    `A #b as x -> fb x
  | `A #c as x -> fc x

Jacques Garrigue

Re: [Caml-list] Union of polymorphic variants...

[Stephane Glondu]

Jacques GARRIGUE a écrit :
> Nothing is "difficult". But not everything is well-defined...
> The question is where do we start, where do we stop.
> 
> type a = [`S of a | `Z]
> 
> should #a be (`S _ | `Z) or (`S (`S _ | `Z) | `Z) or ...?

OK, I grasp now the difficulty of the problem.

> Note that you can still build the types by hand
> 
> type 'a t = [`A of 'a]
> type b = [`B of bool]
> type c = [`C of char]
> type a = [b|c] t
> 
> let f = function
>     `A #b as x -> fb x
>   | `A #c as x -> fc x

I didn't know this trick.


Thanks,

-- 
Stéphane Glondu