:: a - >（a - > b） - > b运算符（Haskell）

Question

Writing Haskell programs I found myself in need of an operator like this.

(|>) :: a -> (a -> b) -> b
(|>) = flip ($)
infixl 0 |>

I think it is useful when glueing many functions together.

tText cs = someFun cs   |>
           lines        |>
           map (drop 4) |>
           reverse

I prefer it over . because with |> the order in which the functions are applied is the same as the order in which the functions are written.

tText' cs = reverse      . 
            map (drop 4) . 
            lines        . 
            someFun $ cs

Question is: is this ( |> ) something that already exists in the Prelude / some other basic library? Reimplementing simple stuff is something silly which I would like to avoid.

A Hoogle search did not help. Closest thing I found was >>> (Arrows), but it seems an overkill.

Answer 1

No, there isn't anything in a standard library that I know of. Years and years ago a lot of my code imported my breif but handy Forwards module:

> module Forwards where

> infixl 0 |>
> infixl 9 .>

> (|>) = flip ($)
> (.>) = flip (.)

I even used the same name as you!

These days I don't use it much at all - I got used to the order that function composition uses.

Feel free to use your own handy shortcuts.

I also use $ less than I used to. Where I used to write

thing = this $ that arg $ an other $ it

Now I write

thing = this . that arg . an other $ it

Answer 2

lens库 将此运算符定义为& 。

Answer 3

您还可以将（|>）定义为“翻转id”，并理解其工作原理，这是Haskell中使用的统一类型推断的一个很好的教训。

Answer 4

As far as my experience goes, I don't know any such library. And if such a library exists, I'd advise against using it.

---

Unless you are using the lens package, I'd suggest not to use externally defined operators of that kind. (In case of that lens package, you really need and already have such an operator.)

In my experience, IMHO and such ...

In cases where the readability enhances with a forward composition in contrast to the usual composition (not only when dealing with lenses), it is beneficial to define a special operator in that module or locally via let or where . For that, I tend to use single unicode symbols rather than ascii combos.

(·) = flip (.)
infixl 1 (·)

(§) = ($) -- left associative, no flip
infixl 0 (§)

Some years ago(, when there were no lenses), I thought of defining my own module for these, too. But then I grow to use that module sooo infrequent that I tended to reinvent the wheel anyway. To have these operators in a library may even increase the effort of reading the code: The reader has to look those rarely used operators up. In that case, locally defined operators are way better.