Not a variant??

Not a variant??

[Jacques Carette]

The function f1 below works fine -- so type d is seen to be a variant type.
However, f2 does not compile because type c is *not* a variant type. 

However, if one looks at O'Caml's output for type c, it visually looks 
like a variant, while that of d does not.  This is highly confusing.

This looks like a bug to me -- both c and d should be recognized as 
variant types.

Jacques

type a = [`A ]
type b = [`B ]
type 'a c = 'a
    constraint 'a = [< a | b]
    ;;
type 'a d = 'a
    constraint 'a = b
    ;;

let f1 = function
    | #d -> true
    | _  -> false

let f2 = function
    | #c -> true
    | _  -> false
;;

Re: [Caml-list] Not a variant??

[Jacques Garrigue]

From: Jacques Carette <carette@mcmaster.ca>

> The function f1 below works fine -- so type d is seen to be a variant type.
> However, f2 does not compile because type c is *not* a variant type. 
> 
> However, if one looks at O'Caml's output for type c, it visually looks 
> like a variant, while that of d does not.  This is highly confusing.
> 
> This looks like a bug to me -- both c and d should be recognized as 
> variant types.
> 
> Jacques
> 
> type a = [`A ]
> type b = [`B ]
> type 'a c = 'a
>     constraint 'a = [< a | b]
>     ;;

The message is maybe not clear enough: for pattern-matching and
inheritance, you need an "exact" variant type, i.e. a type whose lower
and upper bounds are identical. This is clearly not the case for
c. The standard workaround is to write:

type c0 = [a | b]
type 'a c = 'a constraint 'a = [< c0]

Jacques Garrigue

Re: [Caml-list] Not a variant??

[Jacques Carette]

Jacques Garrigue wrote:
> The message is maybe not clear enough: for pattern-matching and
> inheritance, you need an "exact" variant type, i.e. a type whose lower
> and upper bounds are identical. 
Indeed - I would suggest that the error include some clearer diagnostics 
that indicate how the variant is 'inexact'.

> The standard workaround is to write:
>
> type c0 = [a | b]
> type 'a c = 'a constraint 'a = [< c0]
>   
This got me further, thanks.  But not far enough... 
Here is a simple example of the problems I am now running into:

type 'a a = [`A of 'a ]
type 'a b = [`B of 'a ]
type    d = [`D ]
type ('a,'b) e = ['b a | 'a b | d]

type ('a,'b) c = ('a,'b) e
    constraint 'a = [< 'b a ]
    constraint 'b = [< 'a b ]

type 'd cc = 'd
    constraint 'd = [< ('a,'b) c]

let is_cc = function
    | #cc -> true
    | _   -> false 
;;

(* complains that cc is not a variant type when trying to define is_cc *)

Jacques Carette

Re: [Caml-list] Not a variant??

[Jacques Garrigue]

From: Jacques Carette <carette@mcmaster.ca>
> Jacques Garrigue wrote:
> > The message is maybe not clear enough: for pattern-matching and
> > inheritance, you need an "exact" variant type, i.e. a type whose lower
> > and upper bounds are identical. 
> Indeed - I would suggest that the error include some clearer diagnostics 
> that indicate how the variant is 'inexact'.
> 
> > The standard workaround is to write:
> >
> > type c0 = [a | b]
> > type 'a c = 'a constraint 'a = [< c0]
> >   
> This got me further, thanks.  But not far enough... 
> Here is a simple example of the problems I am now running into:
> 
> type 'a a = [`A of 'a ]
> type 'a b = [`B of 'a ]
> type    d = [`D ]
> type ('a,'b) e = ['b a | 'a b | d]
> 
> type ('a,'b) c = ('a,'b) e
>     constraint 'a = [< 'b a ]
>     constraint 'b = [< 'a b ]
> 
> type 'd cc = 'd
>     constraint 'd = [< ('a,'b) c]
> 
> let is_cc = function
>     | #cc -> true
>     | _   -> false 
> ;;
> 
> (* complains that cc is not a variant type when trying to define is_cc *)

Sure, you must use #c as pattern, not #cc.
Or are you thinking of another problem?

Jacques Garrigue