Editing Monad (functional programming) (section)

=== Operators <span id="Lift"></span><span id="Compose"></span> ===
Monadic code can often be simplified even further through the judicious use of operators.
The {{mvar|map}} functional can be especially helpful since it works on more than just ad-hoc monadic functions; so long as a monadic function should work analogously to a predefined operator, {{mvar|map}} can be used to instantly "[[lift (mathematics)|lift]]" the simpler operator into a monadic one.{{efn|Some languages like Haskell even provide a pseudonym for {{mvar|map}} in other contexts called <code>lift</code>, along with multiple versions for different parameter counts, a detail ignored here.}}
With this technique, the definition of <code>add</code> from the <code>Maybe</code> example could be distilled into:
 add(mx,my)  =  map (+)

The process could be taken even one step further by defining <code>add</code> not just for <code>Maybe</code>, but for the whole <code>Monad</code> interface.
By doing this, any new monad that matches the structure interface and implements its own {{mvar|map}} will immediately inherit a lifted version of <code>add</code> too.
The only change to the function needed is generalizing the type signature:
 add : (Monad Number, Monad Number)  →  Monad Number<ref name="Lifting">{{cite web | last = Giles | first = Brett | title = Lifting | url = https://wiki.haskell.org/Lifting | date = 12 August 2013 | website = HaskellWiki | publisher = Haskell.org | archive-url = https://web.archive.org/web/20180129230953/https://wiki.haskell.org/Lifting | archive-date = 29 January 2018 | url-status = live | access-date = 25 November 2018}}</ref>

Another monadic operator that is also useful for analysis is monadic composition (represented as infix <code>>=></code> here), which allows chaining monadic functions in a more mathematical style:
 (f >=> g)(x)  =  f(x) >>= g

With this operator, the monad laws can be written in terms of functions alone, highlighting the correspondence to associativity and existence of an identity:
 (unit >=> g)     ↔  g
 (f >=> unit)     ↔  f
 (f >=> g) >=> h  ↔  f >=> (g >=> h)<ref name="RealWorldHaskell" />

In turn, the above shows the meaning of the "do" block in Haskell:

 do
  _p <- f(x)
  _q <- g(_p)
  h(_q)          ↔ ( f >=> g >=> h )(x)