Support optional named arguments without a final unit in uncurried functions. #5907
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This was referenced Dec 14, 2022
cristianoc
force-pushed
the
uncurried_default_no_unit
branch
from
d29d94e
to
d314f94
Compare
… argument Functions such as this one ```res let foo1 = (~x=3, ~y) => x+y ``` normally require a final unit unlabeled argument to indicate that the optional argument `x` is not passed. In this example, writing ```res let r1 = foo1(~y=11) ``` makes `r1` a function that is still expecting the `x` argument. Requiring a final unit argument, and passing it as `foo1(~y=11, ())` is the only way to omit `x` in practice. With uncurried functions, there's the opportunity to treat `foo1(~y=11)` in a special way, meaning that argument `x` is omitted. TODO: - Figure out what to do with the warning ""This optional parameter in final position will, in practice, not be optional" - Figure out the case of all optional arguments. There's no way to pass zero arguments. One could interpret `foo()`, which actually passes `()` as single unlabelled argument, in a special way when `foo` does not accept unlabelled arguments, and use it to mean zero arguments passed.
…type checker. In reality this disables also the check for the body, but this check is on the way out so this should be reasonable in practice without over-complicating the error logic.
When all the processed arguments to the function are ignored (hence optional), and no arguments are ignored (so no mandatory labelled), it means the uncurried function only has optional arguments. - If the uncurried type of the function had an unlabelled arg, then it would be caught by the unit application, so it would be a non-ignored argument. But this is not possible as all the argiments are ignored. - If it had a labelled mandatory argument, then either it would be non-ignored, or omitted, but both cases are excluded. - It follows that the type only has optional arguments, and that the unit argument was the only argument supplied. The new mechanism does not kick in when some legit argument is passed alongside the unit. And noes not interfere with cases where the function expects a legitimate unit argument.
cristianoc
force-pushed
the
uncurried_default_no_unit
branch
from
1a289c2
to
7785b26
Compare
cristianoc
changed the title
cristianoc
changed the title
4 tasks
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Functions with optional named arguments normally require a final unit (or some other unnamed argument) to specify the end of supplied arguments: https://rescript-lang.org/docs/manual/latest/function#optional-labeled-arguments
With uncurried functions, the number of arguments is fixed, and there is no such ambiguity.
This PR supports the use of optional named arguments without a final unit.
For example:
can now be applied omitting
xasThere's one special case where all arguments are optional:
this can be applied without arguments as follows
Note that this application
foo(. )normally supplies a single argument of typeunit. However, the type offoois enough to disambiguate an interpret it as passing zero arguments whenfoodoes not take any unnamed arguments.This means in practice that uncurried functions are now strictly more expressive than curried ones.
foo(. ), as empty application whenfoois an uncurried function which only has optional arguments.