Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] Polymorphic variant abbreviations
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Jacques Garrigue <garrigue@k...>
Subject: Re: [Caml-list] Polymorphic variant abbreviations
> I have some code that would like to use polymorphic type abbreviations
> along with labels.  It seems to be not behaving quite like I expected.
> What could I do to make this shorter:
> 
>   type a = [ `A ]
> 
>   let f ~a:(#a as a) = ...

Nothing. But this doesn't strike me as a very frequent idiom.

> I was hoping that I could use this:
> 
>   let f ~a:#a = ...
> 
> but then it says that 'a' is unbound.

Sure, nothing binds a here: ~a: is a label, and #a an abbreviation for
`A.

> I also find that the error messages are not as useful as they could be
> with the type abbreviations. E.g:
> 
>   This expression has type ... but is here used with #a as 'a = 'a

Could you give me the code leading to this error message?
This is clearly a bug.

> The last 2 questions were about possible minor improvements with using
> abbreviations. Now I'm stumped - can anyone bail me out?
> 
> (* Some type definitions and abbreviations *)
> type t = ([ `A of 'a list | `B | `C ]) as 'a 
> type b = [ `B ]
> type c = [ `C ]
> 
> (* A rename for one of the abbreviations *)
> type b2 = b
>
> (*
>    this doesn't compile - says unbound class b2
> 
> let g2 ~(xs : #b2 list) =
>   `A xs
> *)

I see. This is rather unexpected.
I'll try to correct this, but the problem is a bit involved.

> (* The first works as I would expect, the second gives a very unexpected
> type. There seems to be some kind of unexpected unification going on
> between terms. *)
> 
> let h1 (#b as x1) (#c as x2) = `A [x1; x2]
> let h2 (x1 : #b) (x2 : #c) = `A [x1; x2]

(#b as x1) and (x1 : #b) have completely different meanings.
The first one is just equivalent to (`B as x1), and gives x1 the type
[> `B]. The second one constrains x1 to have type #b = [< `B].
So in h2 you unify [< `A] and [< `B], which leaves no possible
constructor...
I think that I will make it an error, because this is confusing.

Jacques Garrigue
-------------------
Bug reports: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr