Re: [Caml-list] Explicit Arity with Polymorphic Variants

[Jordan W <jordojw@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 2853 bytes --]

My understanding was that this "explicit_arity" attribute allows precisely
that - the capability to implement a specific syntax to distinguish between
multiple arguments and just one argument (that may coincidentally be a
tuple). My question is why this capability is not extended to polymorphic
variants in the same way it has been extended to standard variant types.

On Fri, Jan 23, 2015 at 12:03 AM, Jacques Garrigue <
garrigue@math.nagoya-u.ac.jp> wrote:

> The answer is simple: polymorphic variants can only accept one argument
> (which may of course be a tuple). The other behavior would have required
> a specific syntax for multi-parameter polymorphic variants, since there is
> no information associated to the constructor for them.
>
> Jacques Garrigue
>
> On 2015/01/23 15:53, Jordan W wrote:
> >
> > The OCaml compiler allows distinguishing between variants that accept a
> single tuple and variant types that accept several parameters. What looks
> like a variant type accepting a tuple, is actually the later:
> >
> > type x = TwoSeparateArguments of int * int
> > let tuple = (10,10)
> > let thisWontWork = TwoSeparateArguments tuple;;
> > >> Error: The constructor TwoSeparateArguments expects 2 argument(s),
>                                                               but is
> applied here to 1 argument(s)
> >
> > (* Notice the extra parens around the two ints *)
> > type x = OneArgumentThatIsATuple of (int * int)
> > let thisActuallyWorks = OneArgumentThatIsATuple tuple
> >
> > The extra parens distinguish at type definition time which of the two is
> intended.
> >
> > But OCaml does some automatic massaging of the data that you supply to
> constructor values.
> > let _ = OneArgumentThatIsATuple (4, 5)
> > let _ = TwoSeparateArguments (4, 5)
> >
> > No extra parens are required in this case. But OCaml does give you the
> ability to annotate patterns and expressions with an "explicit_arity"
> attribute which allows syntactic distinction between supplying two separate
> parameters vs. one that happens to be a tuple. This is important for other
> parser extensions that wish to treat the two distinctly. What OCaml allows
> (explicit_arity attribute) works well enough.
> >
> > The only problem is that there doesn't seem to be a way to utilize the
> same explicit_arity attributes with polymorphic variants. Such attributes
> are not acknowledged by the type system. Is this intended?
> >
> > Taking a quick look at typecore.ml, explicit_arity appears to be
> acknowledged on standard constructors but not polymorphic variants.
> >
> https://github.com/ocaml/ocaml/blob/6e85c2d956c8fd5b45acd70a27586e44bb3a3119/typing/typecore.ml
> >
> > It seems these should be brought to consistency. I will file a mantis
> issue unless anyone believes this is intended.
> >
> > Thank you in advance.
> >
> > Jordan
> >
> >
>
>
>

[-- Attachment #2: Type: text/html, Size: 3697 bytes --]