# Defining custom pipe operator

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 `nothing`s 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 `nothing`s. 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.