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