A regular constructor has a type definition which is where explicit_arity is defined, i.e. it's inferred from either

type t = Foo of int * int

or

type t = Foo of (int * int)

which allows you to determine what Foo(42, 42) actually means.

Polymorphic variants have no type definition so, without a new syntax *for the values*, you can only have one interpretation. Requiring a type definition for polymorphic variants would defeat their purpose!


David



On 23 Jan 2015, at 09:06, Jordan W <jordojw@gmail.com<mailto:jordojw@gmail.com>> wrote:

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<mailto: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<http://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
>
>