Stream: beginners

Topic: Can pipe-last (`|>>`) be implemented in user-space?

Dimitrios Piliouras (Jun 01 2024 at 19:23):

I understand roc has no macros (even though it seems to be fully expression-based), so I am inclined to guess 'no'.

Brendan Hansknecht (Jun 01 2024 at 19:23):

no, could not be implemented in userspace

Brendan Hansknecht (Jun 01 2024 at 19:24):

would have to be a compiler builtin

Dimitrios Piliouras (Jun 01 2024 at 19:24):

thanks :thumbs_up:

Dimitrios Piliouras (Jun 01 2024 at 19:27):

what is the rationale for having one, but not the other? i.e. what makes pipe-first special?

Brendan Hansknecht (Jun 01 2024 at 19:31):

Mostly around api design. Roc is not a curried language (curried languages tend to promote pipe last apis). As such, roc tends to design apis such that the main element is the first element of a function. List.someThing functions always take the List first. Str.someThing the Str first. So only having pipe first helps to keep things consistent and promote a specific style

Brendan Hansknecht (Jun 01 2024 at 19:31):

There has never really been a need or request for pipe last.

Brendan Hansknecht (Jun 01 2024 at 19:32):

Though there have definitely been requests for a generic place holder based piping. That said, so far a lambda has been the preferred only supported to do that.

Brendan Hansknecht (Jun 01 2024 at 19:33):

Something like list |> someFunc 123 _ "test" where _ is where the pipe goes to.

Dimitrios Piliouras (Jun 01 2024 at 19:47):

OK, fair enough...let me just make sure I understand you very first point about currying, because I'm not even sure where it comes into play. If I have a chain of 3 functions, and they happen to be able to be pipe-able at the last position, what does that have to do with currying?

Dimitrios Piliouras (Jun 01 2024 at 19:50):

For what its worth, in Clojure we have ->, ->>, as->, the latter being the most generic one, but the one used by far the least.

Dimitrios Piliouras (Jun 01 2024 at 19:53):

in other words, thread-first & thread-last are the easiest to implement (don't need to introduce any placeholder symbols), and cover 99% of the use-cases.

Brendan Hansknecht (Jun 01 2024 at 19:54):

It is just that in curried languages it tends to be more common to put the thing operated on as the last argument. This is so that you can partially apply what the function does leaving only what is operated on.

So a find function in a curried language is likely to be find needle haystack. When partially applied you would do findCoffee = find "coffee". When used in a pipe, you would want to pipe last because of this design

Brendan Hansknecht (Jun 01 2024 at 19:55):

in a curried language, |> find "coffee". That needs pipe last to work correctly.

Brendan Hansknecht (Jun 01 2024 at 19:56):

Given roc isn't curried, we have chosen the convention to put what is operated on first. This is essentially an arbitrary convention.

Brendan Hansknecht (Jun 01 2024 at 19:57):

A larger writeup: https://www.roc-lang.org/faq#curried-pipes

Brendan Hansknecht (Jun 01 2024 at 19:59):

in other words, thread-first & thread-last are the easiest to implement (don't need to introduce any placeholder symbols), and cover 99% of the use-cases.

I think thread-first and general language api conventions covers about 98% of the use cases.

Brendan Hansknecht (Jun 01 2024 at 19:59):

If that turns out to not be true, when friction arises, we can add thread-last

Dimitrios Piliouras (Jun 01 2024 at 20:00):

hmm ok i think i get it...there is no way to make up a function from another function (e.g. composition, currying etc) at runtime, right?

Brendan Hansknecht (Jun 01 2024 at 20:00):

Yeah, you would have to use an explicit lambda \x -> Num.add x 7

Dimitrios Piliouras (Jun 01 2024 at 20:01):

indeed, with this restriction in mind 98% sounds about right :)

Brendan Hansknecht (Jun 01 2024 at 20:02):

It does feel terrible if you have a pipe and have to do something like:

|> \buffer -> Str.concat "prefix: " buffer

Dimitrios Piliouras (Jun 01 2024 at 20:03):

but if I can create a lambda, then in theory there could be a compose, or a partial builtin, right?

Brendan Hansknecht (Jun 01 2024 at 20:03):

I guess you could make a helper function and do:

|> (flip Str.concat) "prefix: "

Dimitrios Piliouras (Jun 01 2024 at 20:03):

or a plain function that returns a lambda?

Dimitrios Piliouras (Jun 01 2024 at 20:04):

i see

Brendan Hansknecht (Jun 01 2024 at 20:04):

yeah, you can also manually curry in roc.

Brendan Hansknecht (Jun 01 2024 at 20:04):

functions that return functions

Brendan Hansknecht (Jun 01 2024 at 20:04):

Just a bit less ergonomic cause you have to add extra parens when calling compared to a curried language

Dimitrios Piliouras (Jun 01 2024 at 20:04):

i do not mind parens :)

Dimitrios Piliouras (Jun 01 2024 at 20:05):

many thanks for your explanation :thumbs_up:

Brendan Hansknecht (Jun 01 2024 at 20:06):

Glad to help

Isaac Van Doren (Jun 01 2024 at 21:07):

Given roc isn't curried, we have chosen the convention to put what is operated on first. This is essentially an arbitrary convention.

One big advantage of this convention is that it allows the trailing lambda syntax to work nicely because the thing being operated on is not the last argument

Last updated: Jul 06 2025 at 12:14 UTC