(Just a) small collection of Haskell operators with some funny names for them. Haskell tutorials and discussions can sometimes be very dry, so lets “Put the fun back into computing” (distrowatch).


TIE fighter <*>


Package Module Description
base Control.Applicative Sequential application.

Definition:
(<*>) :: f (a -> b) -> f a -> f b
(<*>) = liftA2 id

Example:

> [(*2)] <*> [1,2,3]
[2,4,6]

Other names: ap, apply



Wedge-shaped Imperial Star Destroyer <|>


Package Module Description
base Control.Applicative Associative binary operation.

Definition:
(<|>) :: f a -> f a -> f a
(<|>) = (++)

Example:

> [1,2,3] <|> [4,5]
[1,2,3,4,5]

Other names: or, alternative



TIE bomber <**>


Package Module Description
base Control.Applicative A variant of <*> with arguments reversed.

Definition:
(<**>) :: f a -> f (a -> b) -> f b
(<**>) = liftA2 (\a f -> f a)

Example:

> [1,2,3] <**> [(*2)]
[2,4,6]



Right fish >=>

Package Module Description
base Control.Monad Left-to-right Kleisli composition of monads.

Definition:
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> (a -> m c)
f >=> g = \x -> f x >>= g

Example:

> (pure . (2 +)) >=> (pure . (3 *)) $ 2
12



Left fish <=<

Package Module Description
base Control.Monad (>=>), with arguments flipped.

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> (a -> m c)
(<=<) = flip (>=>)

Example:

> (pure . (2 +)) <=< (pure . (3 *)) $ 2
8



Right pipe >>>

Package Module Description
base Control.Category Left-to-right composition.

(>>>) :: cat a b -> cat b c -> cat a c
f >>> g = g . f

Example:

> ((*2) >>> (+3)) $ 2
7



Left pipe .

Package Module Description
base Prelude Right-to-left composition.

Definition:
(.) :: (b -> c) -> (a -> b) -> a -> c
(.) f g = \x -> f (g x)

Example:

> ((*2) . (+3)) $ 2
10



Operators and shenanigans without funny names, yet

Notation Signature Description
>>= (>>=) :: Monad m => m a -> (a -> m b) -> m b bind
>> (>>) :: Monad m => m a -> m b -> m b then
-> to
<- bind
<$> (<$>) :: Functor f => (a -> b) -> f a -> f b fmap
<$ (<$) :: Functor f => a -> f b -> f a map-replace by
!! (!!) :: [a] -> Int -> a index
! strict
++ (++) :: [a] -> [a] -> [a] concat
[] ([]) :: [a] empty list
: (:) :: a -> [a] -> [a] cons
:: of type
\ lambda
@ as
~ lazy