Pipe expression for optional record fields expects non-optional type

[nkrkv]

Experimenting with Playground. The following compiles with an error:

type t = {
  optValue?: int,
}

let x = Some(3)
let s1 = {optValue: ?(x->Belt.Option.map(a => a+1))} // <-- Type error
let s2 = {optValue: ?(Belt.Option.map(x, a => a+1))}

Type Errors
[E] Line 6, column 22:

This has type: option<int>
  Somewhere wanted: int

Screenshot:

So, the pipe expression highlighted has indeed type option<int> but the compiler wants a plain int for some reason.

Interesting, the same expression without the pipe compiles just fine.

[cristianoc]

Do you have a repro that does not use the ? syntax?
Does it also happen on a record with an explicit option type?

[cristianoc]

Possibly related? rescript-lang/syntax#203

[mununki]

Maybe? #5585

[cristianoc]

Maybe? #5585

Tried on master and this issue is still there.

[nkrkv]

Here’s some extra cases. Not sure if you meant that for repro:

type t = {
  optValue?: int,
  explicit: option<int>,
}

let x = Some(3)
let s1 = {explicit: (x->Belt.Option.map(a => a+1))} // <-- No error
let s2 = {explicit: None, optValue: @optional (x->Belt.Option.map(a => a+1))} // <-- Error

Possibly related? rescript-lang/syntax#203

I thought about it, but arguably no. I’ve put parens around the expression to exclude ? vs -> precedence issues.

[cristianoc]

Let's see what the parser does.

Input:

type t = {optValue?: int}

let x = Some(3)
let s1 = {optValue: ? (x->Belt.Option.map(a => a + 1)) } // <-- Type error
let s2 = {optValue: ? (Belt.Option.map(x, a => a + 1))}

Result:

type nonrec t = {
  optValue: int [@ns.optional ]}
let x = Some 3
let s1 = { optValue = ((x |. (Belt.Option.map (fun a -> a + 1)))[@ns.optional ]) }
let s2 = { optValue = ((Belt.Option.map x (fun a -> a + 1))[@ns.optional ]) }

[cristianoc]

That looks fine. It seems likely, the annotation is moved around during the processing of pipe in the compiler.

[cristianoc]

Let's do a formatting test now.

This:

let s1 = {optValue: @foo (x->Belt.Option.map(a => a + 1))}
let s2 = {optValue: @foo (Belt.Option.map(x, a => a + 1))}

Gets formatted to:

let s1 = {optValue: x->Belt.Option.map(a => a + 1)}
let s2 = {optValue: @foo Belt.Option.map(x, a => a + 1)}

so the annotation is eaten up in the first case

[cristianoc]

So it seems that the situation is:

• ? gets transformed to @bs.optional
• @bs.optional is not preserved in the AST at that position

Next up: investigate the reformatting issue.

[cristianoc]

The formatting issue affects |> too, so formatting could be a red herring, unless the same problematic example can be constructed using |>.

[cristianoc]

This works fine:

let s1 = {optValue: ?((a => a+1) |> Belt.Option.map(x))}

bringing more credibility to the red herring hypothesis.

[cristianoc]

Maybe? #5585

Tried on master and this issue is still there.

No I didn't.
It is in fact fixed in master.
Oh well, this turned out an unrelated printing issue at least.