Op provides operators for writing easier-to-read Haskell. It provides new operators with a consistent "look and feel" including fixity direction and precedence, resulting in easier- and quicker-to-read code especially when used on long chains of expressions.

All right-facing operators are defined with infixl 1 which is the same as >>=, so you can chain all of these together without using parentheses.

All left-facing operators are defined with infixr 1 which is the same as =<<, so you can chain all of these together also without using parentheses.

Unlike Flow and FunctorMonadic we do not restrict ourselves to functions and functors respectively, but we try to cover as many operators as possible.

This means we conflict with some non-Prelude base operators (search "redefined" below), but that is the trade-off we chose. They are used less commonly than the ones we retain compatibility with, IOO their inconsistency is part of the reason why they are used less commonly, and this package tries to fix that.

Examples

>>> :set -XTupleSections
>>> import Control.Op
>>> import Data.Functor
>>> import qualified Data.Map.Strict as M
>>> :{
data InnerMap k v = InnerMap
  { innerMeta :: !()
  , innerMap :: !(M.Map k v)
  }
:}

>>> type MultiMap k v = M.Map Integer (InnerMap k v)

Old way, needs extra parens due to <$>'s fixity:

>>> :{
lookupOldR :: Ord k => MultiMap k v -> (Integer, k) -> Maybe (Integer, v)
lookupOldR m (i, k) = (i,) <$> (M.lookup k . innerMap =<< M.lookup i m)
:}

or, slightly better but the . innerMap still breaks up the LTR flow:

>>> :{
lookupOldL :: Ord k => MultiMap k v -> (Integer, k) -> Maybe (Integer, v)
lookupOldL m (i, k) = M.lookup i m >>= M.lookup k . innerMap <&> (i,)
:}

New way:

>>> :{
lookupNewR :: Ord k => MultiMap k v -> (Integer, k) -> Maybe (Integer, v)
lookupNewR m (i, k) = (i,) <$< M.lookup k =<< innerMap <$< M.lookup i <| m
:}

>>> :{
lookupNewL :: Ord k => MultiMap k v -> (Integer, k) -> Maybe (Integer, v)
lookupNewL m (i, k) = m |> M.lookup i >$> innerMap >>= M.lookup k >$> (i,)
:}

Applicative

We omit defining an equivalent of <*> because it does not fit into our system very well. The main use-case for <*> translated into our system would look something like:

  (((f <$< a) <*< b) <*< c)

which is worse from a readability perspective, compared to the standard form:

  f <$> a <*> b <*> c

We could define extra "flipped" operators like:

  f >&> a >@> b >@> c

with (>&>) = (<$<) and (>@>) = (<*<) with flipped fixities, but didn't see a major demand to do this ATTOW. If you want this, please file a PR.

LTR applicative replacement, constrained to a monad.

This is >>.

LTR monad application.

This is >>=.

RTL monad application.

This is =<<.