CODEWITHSUNDEEP
haskell
user2205541
user2205541

Reputation: 173

:: a -> (a -> b) -> b operator (Haskell)

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.

Upvotes: 17

Views: 1550

Answers (4)

comonad
comonad

Reputation: 5241

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.

Upvotes: 0

pmk
pmk

Reputation: 71

You can also define (|>) as "flip id", and understanding why this works is a great lesson in type inference by unification as used in Haskell.

Upvotes: 7

John Wiegley
John Wiegley

Reputation: 7182

The lens library defines this operator as &.

Upvotes: 12

AndrewC
AndrewC

Reputation: 32455

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

Upvotes: 16

Related Questions