implement syntax for arity zero vs arity one in uncurried application

[IwanKaramazow]

Since there is no syntax space for arity zero vs arity one, we parse
fn(. ()) into
fn(. {let __res_unit = (); __res_unit})
when the parsetree is intended for type checking

fn(.) is treated as zero arity application

Fixes #138

[ryyppy]

Not sure if there is any difference, but it might also be worth considering converting it into fn(. ignore())? At least it's easier to understand what's going on, and both versions compile to fn(undefined)

[chenglou]

Hummmm not too sure

[bobzhang]

@IwanKaramazow the proposal looks good to me.
fn(.) is compiled into fn()
fn(.()) is fn(undefined). For your short-cut implementation, it could be implemented as fn(Pervasives.(()) -- this way you don't need introduce a special name
Edit: a more robust solution: fn(. ()) could be implemented as fn(.{0;()})

[bobzhang]

would my proposal make the implementation a bit more clean? @IwanKaramazow

[IwanKaramazow]

@bobzhang not 100%, it results in a type-error: https://rescript-lang.org/try?code=DYUwLgBAZgdhC8EAUA6CB9AlAgfMzA3AFBGyoDeADAUpgL6ZA

It could be changed to: fn(. {ignore(0); ()})

[bobzhang]

@IwanKaramazow it is because we are more strict with sequence types. @ryyppy 's proposal also makes sense, the idea is not to introduce a magic name in the generated code

[ryyppy]

@IwanKaramazow @bobzhang I don't understand how fn(. {ignore(0); ()}) is cleaner than fn(. ignore())? Is there any benefit of having this local scope with two expressions?

I personally use fn(. ignore()) and we also recommend it in the docs right now, so ppl have a reference on how to work around the syntactical limitation. Having fn(. ()) as the more logical equivalent would help reduce unintuitive errors and also helps us keeping the docs lean.

[IwanKaramazow]

Yea, let’s go with ignore(). Will finish this tomorrow

[IwanKaramazow]

Ok, this PR is now ready to be merged.

The semantics are summarised by the following table:

Unfortunately, this is a breaking change. If you look at the table: f(. ()) used to be parsed as f(.) (arity0). With this PR f(. ()) would be parsed as f(. ignore()) (arity1).
@bobzhang do we schedule this for the next breaking changes release?

[bobzhang]

@IwanKaramazow I am happy to merge it, would you resolve the conflicts?

[IwanKaramazow]

@bobzhang rebased! Do we merge?

[bobzhang]

yes!