Piping first multiple variables into functions

Question

I have code in BuckleScript:

let add = (x, y) => x+y;
2 -> (3 -> add);

I would expect it to compile for obvious reasons. But it doesn't. I get

'|.' is not a valid value identifier.

Why? Cheers.

score 4 · Answer 1 · answered Apr 27 '19 at 03:13

4

It is a bug, just made a tentative fix!

answered Apr 27 '19 at 03:13

bobzhang

1,771
3
17
19

score 1 · Answer 2 · answered Apr 23 '19 at 12:23

1

The pipe first operator is only available when compiling Reason to JavaScript with BuckleScript (see docs for pipe first in the BuckleScript site).

If you are working on a native Reason project (or a project that uses the native compiler in the browser through js_of_ocaml, like sketch.sh) the pipe operator won't be available.

The reason why the error message shows |. is because the pipe operator is written as -> in Reason syntax and as |. in OCaml syntax.

See What's the difference between -> and |> in reasonml? for more details.

answered Apr 23 '19 at 12:23

Javier Chávarri

1,605
11
21

I was actually compiling to JS using JavaScript. That's why it's strange. – Dominik Teiml Apr 23 '19 at 12:26
*using Bucklescript – Dominik Teiml Apr 23 '19 at 13:50
Oh, I see now. That's actually strange behavior... maybe worth filing an issue in BuckleScript repo: https://github.com/BuckleScript/bucklescript/ – Javier Chávarri Apr 23 '19 at 14:03
From the OCaml syntax: `2 |. (3 |. add)` It seems the pipe-first operator doesn't allow piping into anything other than a named function. – Yawar Apr 23 '19 at 14:27

glennsl · Answer 3 · 2019-04-24T10:53:22.153

I don't know why you get this error specifically, but because a syntactic transform instead of an ordinary operator but, I suspect BuckleScript might not check for |. recursively and instead passes it through to the compiler which determines it to be an invalid "value identifier", whatever that means.

But in any case, I don't see how this would work in practice. It works well with |> because that's an ordinary operator which relies on currying. Every application of |> will "append" an argument and because of currying returns an actual value, either the final value or a partially applied function, e.g.:

3 |> add  <=>  add(3)  <=>  y => add(3, y)

What would a partial application of |. return? Currying doesn't work in the reverse. The only possibility is to return an explicit function that applies the last argument, e.g. x => add(x, 3), but that requires knowing the arity of the function and hence is no longer just a syntactic transform.

|. is in my opinion a nasty hack that doesn't fit naturally into the language, but has been forced into BuckleScript anyway and its use unfortunately seems to be encouraged despite its flaws and severely negative implications. My advice is (as usual) to avoid it. In Reason you can use |> _ instead when needed, e.g. 3 |> add(_, 2) <=> 3 -> add(2).

Piping first multiple variables into functions

3 Answers3