Some((a, b)) formats to Some(a, b)

[johnridesabike]

let x = Some((1, 2))

formats to:

let x = Some(1, 2)

Either one compiles, so maybe this isn’t a bug? The syntax is misleading, though, since the Some constructor only takes one value.

This happens with other variant constructors as well.

[IwanKaramazow]

Where are you seeing this?

Just tested this on ReScript 9 and it seems to look ok?

[johnridesabike]

I can't test it on a local install at the moment, but it's reproducible on the playground. Click "format" https://rescript-lang.org/try?code=DYUwLgBAHhC8EGUD2BbEAKdBGANBATAJSFA

Regardless of the formatter preference, I wonder if Some(1, 2) should even be valid?

[ryyppy]

this is a bug in the playground when formatting code. Will fix.

[ryyppy]

Should now be fixed on the playground:
Check example

[IwanKaramazow]

Thanks for the work, this is great.

[johnridesabike]

I'm still curious if both of these are supposed to compile the same:

let a = Some((1, 2))
let b = Some(1, 2)

Right now, either one compiles identically (and the formatter doesn't seem to have a preference), but b doesn't look like correct syntax to me.

Sorry if this is the intended behavior, and thanks for fixing the playground.

[IwanKaramazow]

This is a technical consequence of ocaml's representation of your source code. We as humans think in terms of "multiple variant arguments", but internally in the compiler this is expressed as a tuple.

In ReScript variant argument are written between parens: Some(...arguments go here...). The compiler however requires a tuple to express multiple arguments, hence you get Some((1, 2)). This doesn't look super nice of course. So in this case we parse Some(1, 2) as Some((1, 2)) behind the scenes.

Does this make sense?

[anmonteiro]

I don't think that's true, and it's the reason for @implicit_arity to exist in Reason.

In OCaml there's a difference between Foo of 'a * 'b and Foo of ('a * 'b)

$ refmt -pa
Some(1,2)
[D
  structure_item ([1,0+0]..[1,0+9])
    Pstr_eval
    expression ([1,0+0]..[1,0+9])
      attribute "explicit_arity"
        []
      Pexp_construct "Some" ([1,0+0]..[1,0+4])
      Some
        expression ([1,0+4]..[1,0+9])
          Pexp_tuple
          [
            expression ([1,0+5]..[1,0+6])
              Pexp_constant PConst_int (1,None)
            expression ([1,0+7]..[1,0+8])
              Pexp_constant PConst_int (2,None)
          ]
]

$ refmt -pa
Some((1,2))

  structure_item ([1,0+0]..[1,0+11])
    Pstr_eval
    expression ([1,0+0]..[1,0+11])
      attribute "explicit_arity"
        []
      Pexp_construct "Some" ([1,0+0]..[1,0+4])
      Some
        expression ([1,0+4]..[1,0+11])
          Pexp_tuple
          [
            expression ([1,0+5]..[1,0+10])
              Pexp_tuple
              [
                expression ([1,0+6]..[1,0+7])
                  Pexp_constant PConst_int (1,None)
                expression ([1,0+8]..[1,0+9])
                  Pexp_constant PConst_int (2,None)
              ]
          ]
]

[IwanKaramazow]

oh wait, yes, that has something to do with it. Bit fuzzy on the topic, but explicit_arity gets ppx'ed away right in Reason?
There's an invariant that a tuple should have 2 or more things: https://github.com/ocaml/ocaml/blob/4.06/parsing/parsetree.mli#L277

So the second snippet becomes the first one?

[IwanKaramazow]

https://rescript-lang.org/try?code=C4TwDgpgBMCMUF4oBUCuYA2EAU2CWAdsADRSHACUFAUNVsDOlgFxT5GnkWJuymw06EBgA9WcHmkw5sfKAJr0oIgEzj4SKVmzAmEQaEgwVPAHIB7AlpzlORQUpEBmcSaQWre2f0EB6X1AQAE5B5kEAzlAAhpEQIpAAxsAQACbU-lCOACyuZpbWOno0QA

All cases seem to be ok now in the playground.

[chenglou]

There's indeed a difference and historically it stemmed from ocaml's small syntactic ambiguity in that case, which then gets disambiguated later in the pipeline instead of at the syntax level.