I got used to this in Haskell, but I have to say that Elm's solution is pretty elegant: Elm: Haskell: f <| g <| x == f $ g $ x -- a

I got used to this in Haskell, but I have to say that Elm's solution is pretty elegant: Elm: Haskell: f <| g <| x == f $ g $ x -- application f << g == f . g -- composition x |> g |> f == x & g & f -- reverse application g >> f == g >>> f -- reverse composition It's nice to be able to change between composition and application by changing between | and < in the operator. I've actually done this quite a lot when refactoring code in Elm lately, there's something visual and intutive about it that I like. It makes it easier to mix left-to-right and right-to-left in the same code, while keeping it obvious what's going on. I've found that certain parts, that scan/read better as imperative steps (think chains of List.map, Maybe.map, <MonadlikeModule>.andThen etc.) often benefit from a reverse application and/or composition. Sort of to simulate the look of do notation since Elm doesn't have that. Smaller functional parts are better with regular application/composition. With the directional operators, this becomes quite ergonomical. Probaly helps that I use (and enjoy, ymmv) a font with ligatures for these symbols.