Hello! I’m trying to define a pipe operator which propagates nothing. It sounds quite easy: ⇒(x, f) = x == nothing ? nothing : f(x). This operator works fine when there is a single application of it, e.g. [1, 2, 3] ⇒ collect. However, multiple consequtive applications are called “backwards”: [1, 2, 3] ⇒ collect ⇒ length tries to call length(collect) first, and throws an error of course. Is there a way to modify this behaviour and call operator from left to right?
⇒(x, f) = x == nothing ? nothing : f(x)
⇒(g::Function, f) = g ∘ f
[1, 2, 3] ⇒ collect ⇒ length # returns 3
It kinda-works, but not always. First, you have a typo - it should be f \circ g, not the other way. Also compare this: sin |> typeof gives typeof(sin), while sin ⇒ typeof gives #52 (generic function with 1 method). However, for most cases I guess this should be ok…
A worse problem is that nothings that are output by f are not propagated at all. I need to think about this a bit more.
It is not possible to change the left/right associativity of operators programmatically since that happens at the parser level.
This should work, as long as the first input, x, is not a function.
⇒(x, f) = x == nothing ? nothing : f(x)
⇒(f::Function, g) = x -> ((x ⇒ f) ⇒ g)
1 Like
Consider using the existing |> operator.
julia> [1, 2, 3] |> collect |> length
3
But aren’t there any other predefined operators with the associativity needed here? I hoped that arrows are treated the same as |>, but apparently not.
The whole point is to make an operator similar to |>, which propagates nothings. Of course, I could overload |> itself, but this doesn’t look right.
All of the * and + like operators are left-associative, for example, which is what you want. For example, you could use ▷ (tab-complete \triangleright).
2 Likes
Oh, thank you! It’s not really intutinve how to get the associativity of all those unicode operators.