What is a monad

Question

Having briefly looked at Haskell recently  what would be a brief  succinct  practical explanation as to what a monad essentially is   I have found most explanations I ve come across to be fairly inaccessible and lacking in practical detail

User · Answer

The two things that helped me best when learning about there were:

Chapter 8, "Functional Parsers," from Graham Hutton's book Programming in Haskell. This doesn't mention monads at all, actually, but if you can work through chapter and really understand everything in it, particularly how a sequence of bind operations is evaluated, you'll understand the internals of monads. Expect this to take several tries.

The tutorial All About Monads. This gives several good examples of their use, and I have to say that the analogy in Appendex I worked for me.

User · Answer

tl dr   -  LANGUAGE InstanceSigs  -   newtype Id t   Id t  instance Monad Id where    return    t - gt  Id t    return   Id        lt  lt       a - gt  Id b  - gt  Id a - gt  Id b    f   lt  lt   Id x    f x   Prologue  The application operator   of functions  forall a b  a - gt  b   is canonically defined          a - gt  b  - gt  a - gt  b f   x   f x  infixr 0     in terms of Haskell-primitive function application f x  infixl 10     Composition   is defined in terms of   as          b - gt  c  - gt   a - gt  b  - gt   a - gt  c  f   g     x - gt  f   g x  infixr 9     and satisfies the equivalences forall f g h        f   id     f               c - gt  d   Right identity      id   g     g               b - gt  c   Left identity  f   g    h     f    g   h      a - gt  d   Associativity     is associative  and id is its right and left identity   The Kleisli triple  In programming  a monad is a functor type constructor with an instance of the monad type class  There are several equivalent variants of definition and implementation  each carrying slightly different intuitions about the monad abstraction   A functor is a type constructor f of kind   - gt    with an instance of the functor type class    -  LANGUAGE KindSignatures  -   class Functor  f      - gt     where    map     a - gt  b  - gt   f a - gt  f b    In addition to following statically enforced type protocol  instances of the functor type class must obey the algebraic functor laws forall f g          map id     id              f t - gt  f t   Identity map f   map g     map  f   g      f a - gt  f c   Composition   short cut fusion   Functor computations have the type  forall f t  Functor f   gt  f t   A computation c r consists in results r within context c   Unary monadic functions or Kleisli arrows have the type  forall m a b  Functor m   gt  a - gt  m b   Kleisi arrows are functions that take one argument a and return a monadic computation m b   Monads are canonically defined in terms of the Kleisli triple forall m  Functor m   gt    m  return     lt  lt      implemented as the type class  class Functor m   gt  Monad m where    return    t - gt  m t       lt  lt        a - gt  m b  - gt  m a - gt  m b  infixr 1   lt  lt    The Kleisli identity return is a Kleisli arrow that promotes a value t into monadic context m  Extension or Kleisli application   lt  lt  applies a Kleisli arrow a - gt  m b to results of a computation m a   Kleisli composition  lt   lt  is defined in terms of extension as    lt   lt      Monad m   gt   b - gt  m c  - gt   a - gt  m b  - gt   a - gt  m c  f  lt   lt  g     x - gt  f   lt  lt  g x  infixr 1  lt   lt     lt   lt  composes two Kleisli arrows  applying the left arrow to results of the right arrow   s application   Instances of the monad type class must obey the monad laws  most elegantly stated in terms of Kleisli composition  forall f g h      f  lt   lt  return     f                   c - gt  m d   Right identity    return  lt   lt  g     g                   b - gt  m c   Left identity  f  lt   lt  g   lt   lt  h     f  lt   lt   g  lt   lt  h      a - gt  m d   Associativity    lt   lt  is associative  and return is its right and left identity   Identity  The identity type  type Id t   t   is the identity function on types  Id      - gt      Interpreted as a functor      return    t - gt  Id t        id    t - gt     t         lt  lt       a - gt  Id b  - gt  Id a - gt  Id b               a - gt     b  - gt     a - gt     b        lt   lt       b - gt  Id c  - gt   a - gt  Id b  - gt   a - gt  Id c                b - gt     c  - gt   a - gt     b  - gt   a - gt     c    In canonical Haskell  the identity monad is defined  newtype Id t   Id t  instance Functor Id where    map     a - gt  b  - gt  Id a - gt  Id b    map f  Id x    Id  f x   instance Monad Id where    return    t - gt  Id t    return   Id        lt  lt       a - gt  Id b  - gt  Id a - gt  Id b    f   lt  lt   Id x    f x   Option  An option type  data Maybe t   Nothing   Just t   encodes computation Maybe t that not necessarily yields a result t  computation that may    fail     The option monad is defined  instance Functor Maybe where    map     a - gt  b  - gt   Maybe a - gt  Maybe b     map f  Just x    Just  f x     map   Nothing    Nothing  instance Monad Maybe where    return    t - gt  Maybe t    return   Just        lt  lt       a - gt  Maybe b  - gt  Maybe a - gt  Maybe b    f   lt  lt   Just x    f x        lt  lt  Nothing    Nothing   a - gt  Maybe b is applied to a result only if Maybe a yields a result   newtype Nat   Nat Int   The natural numbers can be encoded as those integers greater than or equal to zero   toNat    Int - gt  Maybe Nat toNat i   i  gt   0      Just  Nat i            otherwise   Nothing   The natural numbers are not closed under subtraction    -      Nat - gt  Nat - gt  Maybe Nat  Nat n  -   Nat m    toNat  n - m   infixl 6 -    The option monad covers a basic form of exception handling    -  20   lt   lt  toNat    Int - gt  Maybe Nat   List  The list monad  over the list type  data    t        t    t   infixr 5     and its additive monoid operation    append              t  - gt   t  - gt   t   x   xs     ys   x   xs    ys             ys   ys  infixr 5      encodes nonlinear computation  t  yielding a natural amount 0  1      of results t   instance Functor    where    map     a - gt  b  - gt    a  - gt   b      map f  x   xs    f x   map f xs    map                  instance Monad    where    return    t - gt   t     return                 lt  lt       a - gt   b   - gt   a  - gt   b     f   lt  lt   x   xs    f x     f   lt  lt  xs         lt  lt                  Extension   lt  lt  concatenates    all lists  b  resulting from applications f x of a Kleisli arrow a - gt   b  to elements of  a  into a single result list  b    Let the proper divisors of a positive integer n be  divisors    Integral t   gt  t - gt   t  divisors n   filter   divides  n   2    n - 1   divides    Integral t   gt  t - gt  t - gt  Bool   divides  n        0     n  rem     then  forall n   let   f   f  lt   lt  divisors   in f n            In defining the monad type class  instead of extension   lt  lt   the Haskell standard uses its flip  the bind operator  gt  gt     class Applicative m   gt  Monad m where      gt  gt       forall a b  m a - gt   a - gt  m b  - gt  m b       gt  gt      forall a b  m a - gt  m b - gt  m b    m  gt  gt  k   m  gt  gt       - gt  k     -  INLINE   gt  gt    -      return    a - gt  m a    return   pure   For simplicity s sake  this explanation uses the type class hierarchy  class              Functor f class Functor m   gt  Monad m   In Haskell  the current standard hierarchy is  class                  Functor f class Functor p       gt  Applicative p class Applicative m   gt  Monad m   because not only is every monad a functor  but every applicative is a functor and every monad is an applicative  too   Using the list monad  the imperative pseudocode  for a in  1       10     for b in  1       10        p  lt - a   b       if even p           yield p   roughly translates to the do block   do a  lt -  1    10     b  lt -  1    10     let p   a   b    guard  even p     return p   the equivalent monad comprehension     p   a  lt -  1    10   b  lt -  1    10   let p   a   b  even p     and the expression   1    10   gt  gt      a - gt      1    10   gt  gt      b - gt        let p   a   b in          guard  even p   gt  gt        --        even p    gt  gt              return p                Do notation and monad comprehensions are syntactic sugar for nested bind expressions  The bind operator is used for local name binding of monadic results   let x   v in e           x - gt  e      v       v   amp      x - gt  e  do   r  lt - m  c           r - gt  c    lt  lt  m       m  gt  gt      r - gt  c    where    amp      a - gt   a - gt  b  - gt  b   amp     flip      infixl 0  amp    The guard function is defined  guard    Additive m   gt  Bool - gt  m    guard True    return    guard False   fail   where the unit type or    empty tuple     data           Additive monads that support choice and failure can be abstracted over using a type class  class Monad m   gt  Additive m where    fail     m t      lt   gt      m t - gt  m t - gt  m t  infixl 3  lt   gt   instance Additive Maybe where    fail   Nothing     Nothing  lt   gt  m   m    m        lt   gt      m  instance Additive    where    fail           lt   gt            where fail and  lt   gt  form a monoid forall k l m        k  lt   gt  fail     k      fail  lt   gt  l     l  k  lt   gt  l   lt   gt  m     k  lt   gt   l  lt   gt  m    and fail is the absorbing annihilating zero element of additive monads      lt  lt  fail     fail   If in  guard  even p   gt  gt  return p   even p is true  then the guard produces       and  by the definition of  gt  gt   the local constant function      - gt  return p   is applied to the result     If false  then the guard produces the list monad   s fail         which yields no result for a Kleisli arrow to be applied  gt  gt  to  so this p is skipped over   State  Infamously  monads are used to encode stateful computation   A state processor is a function  forall st t  st - gt   t  st    that transitions a state st and yields a result t  The state st can be anything  Nothing  flag  count  array  handle  machine  world   The type of state processors is usually called  type State st t   st - gt   t  st    The state processor monad is the kinded   - gt    functor State st  Kleisli arrows of the state processor monad are functions  forall st a b  a - gt   State st  b   In canonical Haskell  the lazy version of the state processor monad is defined  newtype State st t   State   stateProc    st - gt   t  st     instance Functor  State st  where    map     a - gt  b  - gt    State st  a - gt   State st  b     map f  State p    State     s0 - gt  let  x  s1    p s0                                      in   f x  s1   instance Monad  State st  where    return    t - gt   State st  t    return x   State     s - gt   x  s         lt  lt       a - gt   State st  b  - gt   State st  a - gt   State st  b    f   lt  lt   State p    State     s0 - gt  let  x  s1    p s0                                      in  stateProc  f x  s1   A state processor is run by supplying an initial state   run    State st t - gt  st - gt   t  st  run   stateProc  eval    State st t - gt  st - gt  t eval   fst   run  exec    State st t - gt  st - gt  st exec   snd   run   State access is provided by primitives get and put  methods of abstraction over stateful monads    -  LANGUAGE MultiParamTypeClasses  FunctionalDependencies  -   class Monad m   gt  Stateful m st    m - gt  st where    get    m st    put    st - gt  m      m - gt  st declares a functional dependency of the state type st on the monad m  that a State t  for example  will determine the state type to be t uniquely   instance Stateful  State st  st where    get    State st st    get   State     s - gt   s  s      put    st - gt  State st       put s   State       - gt       s    with the unit type used analogously to void in C   modify    Stateful m st   gt   st - gt  st  - gt  m    modify f   do    s  lt - get    put  f s   gets    Stateful m st   gt   st - gt  t  - gt  m t gets f   do    s  lt - get    return  f s    gets is often used with record field accessors   The state monad equivalent of the variable threading  let s0   34     s1      1  s0     n      12  s1     s2      7  s1 in   show n  s2    where s0    Int  is the equally referentially transparent  but infinitely more elegant and practical   flip run  34     do       modify    1        n  lt - gets    12        modify    7        return  show n         modify    1  is a computation of type State Int     except for its effect equivalent to return       flip run  34     modify    1   gt  gt        gets    12   gt  gt      n - gt           modify    7   gt  gt              return  show n                 The monad law of associativity can be written in terms of  gt  gt   forall m f g    m  gt  gt   f   gt  gt   g     m  gt  gt      x - gt  f x  gt  gt   g    or  do                   do                     do      r1  lt - do             x  lt - m                 r0  lt - m        r0  lt - m           do                     r1  lt - f r0        f r0                 r1  lt - f x           g r1                            g r1                  g r1                                            Like in expression-oriented programming  e g  Rust   the last statement of a block represents its yield  The bind operator is sometimes called a    programmable semicolon      Iteration control structure primitives from structured imperative programming are emulated monadically  for    Monad m   gt   a - gt  m b  - gt   a  - gt  m    for f   foldr    gt  gt     f   return      while    Monad m   gt  m Bool - gt  m t - gt  m    while c m   do    b  lt - c    if b then m  gt  gt  while c m         else return     forever    Monad m   gt  m t forever m   m  gt  gt  forever m   Input Output  data World   The I O world state processor monad is a reconciliation of pure Haskell and the real world  of functional denotative and imperative operational semantics  A close analogue of the actual strict implementation   type IO t   World - gt   t  World    Interaction is facilitated by impure primitives  getChar            IO Char putChar            Char - gt  IO    readFile           FilePath - gt  IO String writeFile          FilePath - gt  String - gt  IO    hSetBuffering      Handle - gt  BufferMode - gt  IO    hTell              Handle - gt  IO Integer                            The impurity of code that uses IO primitives is permanently protocolized by the type system  Because purity is awesome  what happens in IO  stays in IO   unsafePerformIO    IO t - gt  t   Or  at least  should   The type signature of a Haskell program  main    IO    main   putStrLn  Hello  World     expands to  World - gt       World    A function that transforms a world   Epilogue  The category whiches objects are Haskell types and whiches morphisms are functions between Haskell types is     fast and loose     the category Hask   A functor T is a mapping from a category C to a category D  for each object in C an object in D  Tobj    Obj C  - gt  Obj D     f           - gt      and for each morphism in C a morphism in D  Tmor    HomC X  Y  - gt  HomD Tobj X   Tobj Y    map     a - gt  b    - gt   f a - gt  f b    where X  Y are objects in C  HomC X  Y  is the homomorphism class of all morphisms X - gt  Y in C  The functor must preserve morphism identity and composition  the    structure    of C  in D                       Tmor    Tobj        T id      id          T X  - gt  T X    Identity T f    T g      T f   g     T X  - gt  T Z    Composition   The Kleisli category of a category C is given by a Kleisli triple   lt T  eta     gt    of an endofunctor  T   C - gt  C    f   an identity morphism eta  return   and an extension operator      lt  lt     Each Kleisli morphism in Hask        f    X - gt  T Y        f    a - gt  m b   by the extension operator             Hom X  T Y   - gt  Hom T X   T Y        lt  lt       a - gt  m b    - gt   m a - gt  m b    is given a morphism in Hask   s Kleisli category       f     T X  - gt  T Y   f   lt  lt      m a  - gt  m b   Composition in the Kleisli category  T is given in terms of extension   f  T g     f    g          X - gt  T Z  f  lt   lt  g      f   lt  lt     g     a - gt  m c   and satisfies the category axioms         eta  T g     g                   Y - gt  T Z    Left identity    return  lt   lt  g     g                   b - gt  m c         f  T eta     f                   Z - gt  T U    Right identity    f  lt   lt  return     f                   c - gt  m d     f  T g   T h     f  T  g  T h        X - gt  T U    Associativity  f  lt   lt  g   lt   lt  h     f  lt   lt   g  lt   lt  h      a - gt  m d   which  applying the equivalence transformations       eta  T g     g      eta    g     g               By definition of  T      eta    g     id   g          forall f   id   f     f          eta      id              forall f g h   f   h     g   h     gt   f     g   f  T g   T h     f  T  g  T h   f    g     h     f     g    h    By definition of  T  f    g     h     f    g    h       is associative      f    g       f    g          forall f g h   f   h     g   h     gt   f     g   in terms of extension are canonically given                 eta      id                    T X  - gt  T X    Left identity         return   lt  lt       id                    m t - gt  m t             f    eta     f                     Z - gt  T U       Right identity     f   lt  lt     return     f                     c - gt  m d             f    g       f    g                T X  - gt  T Z    Associativity    f   lt  lt     g    lt  lt        f   lt  lt      g   lt  lt       m a - gt  m c   Monads can also be defined in terms not of Kleislian extension  but a natural transformation mu  in programming called join  A monad is defined in terms of mu as a triple over a category C  of an endofunctor       T    C - gt  C      f      - gt      and two natural tranformations     eta    Id - gt  T return    t  - gt  f t      mu    T   T   - gt  T   join    f  f t  - gt  f t   satisfying the equivalences         mu   T mu      mu   mu                  T   T   T - gt  T   T   Associativity   join   map join     join   join              f  f  f t   - gt  f t        mu   T eta      mu   eta          id     T - gt  T               Identity join   map return     join   return     id     f t - gt  f t   The monad type class is then defined  class Functor m   gt  Monad m where    return    t - gt  m t    join      m  m t  - gt  m t   The canonical mu implementation of the option monad   instance Monad Maybe where    return   Just     join  Just m    m    join Nothing    Nothing   The concat function  concat      a   - gt   a  concat  x   xs    x    concat xs concat                 is the join of the list monad   instance Monad    where    return    t - gt   t     return                 lt  lt       a - gt   b   - gt    a  - gt   b       f   lt  lt     concat   map f   Implementations of join can be translated from extension form using the equivalence       mu     id               T   T - gt  T    join      id   lt  lt           m  m t  - gt  m t   The reverse translation from mu to extension form is given by       f      mu   T f         T X  - gt  T Y   f   lt  lt       join   map f     m a - gt  m b      Philip Wadler  Monads for functional programming Simon L Peyton Jones  Philip Wadler  Imperative functional programming Jonathan M  D  Hill  Keith Clarke  An introduction to category theory  category theory monads  and their relationship to functional programming    Kleisli category Eugenio Moggi  Notions of computation and monads What a monad is not      But why should a theory so abstract be of any use for programming       The answer is simple  as computer scientists  we value abstraction  When we design the interface to a software component  we want it to reveal as little as possible about the implementation  We want to be able to replace the implementation with many alternatives  many other    instances    of the same    concept     When we design a generic interface to many program libraries  it is even more important that the interface we choose have a variety of implementations  It is the generality of the monad concept which we value so highly  it is because category theory is so abstract that its concepts are so useful for programming       It is hardly suprising  then  that the generalisation of monads that we present below also has a close connection to category theory  But we stress that our purpose is very practical  it is not to    implement category theory     it is to find a more general way to structure combinator libraries  It is simply our good fortune that mathematicians have already done much of the work for us    from Generalising Monads to Arrows by John Hughes

User · Answer

Let the below     a  m   represent some piece of monadic data  A data type which advertises an a            I got an a                              a  m    Function  f  knows how to create a monad  if only it had an a           Hi f  What should I be                            You   Oh  you ll be    that data there                             I got a b        --------------                                   f a                           --later- gt           b  m    Here we see function  f  tries to evaluate a monad but gets rebuked    Hmm  how do I get that a    o        Get lost buddy  o         Wrong type   o         f    a  m    Funtion  f  finds a way to extract the a by using  gt  gt              Muaahaha  How you           like me now                Better                         Give me that a    Fine  well ok                                    a  m     gt  gt     f   Little does f know  the monad and  gt  gt   are in collusion                Yah got an a for me           Yeah  but hey        listen  I got       something to        tell you first                                                a  m     gt  gt     f   But what do they actually talk about  Well  that depends on the monad  Talking solely in the abstract has limited use  you have to have some experience with particular monads to flesh out the understanding    For instance  the data type Maybe   data Maybe a   Nothing   Just a   has a monad instance which will acts like the following     Wherein  if the case is Just a               Yah what is it               hm  Oh         forget about it     Hey a  yr up                              Evaluation         time already        Hows my hair                                      It s               fine                                  a  m     gt  gt     f   But for the case of Nothing           Yah what is it               There        is no a                       No a    No a                         Ok  I ll deal             with this                                 Hey f  get lost                          Where s my a                         I evaluate a               Not any more                 you don t                    We re returning              Nothing                                                                                        a  m     gt  gt     f       I got a b                           This is                             such a                               sham   o o                                        o                       --later- gt     b  m    So the Maybe monad lets a computation continue if it actually contains the a it advertises  but aborts the computation if it doesn t  The result  however is still a piece of monadic data  though not the output of f  For this reason  the Maybe monad is used to represent the context of failure    Different monads behave differently  Lists are other types of data with monadic instances  They behave like the following    Ok  here s your a  Well  its  a bunch of them  actually               Thanks  no problem  Ok         f  here you go  an a                                   Thank s  See                     you later         Whoa  Hold up f               I got another                 a for you                                 What  No  sorry                    Can t do it  I                    have my hands full                   with all these  b                     I just made          I ll hold those               you take this  and           come back for more          when you re done            and we ll do it            again                             Uhhh  All right                                                 a  m     gt  gt    f     In this case  the function knew how to make a list from it s input  but didn t know what to do with extra input and extra lists  The bind  gt  gt    helped f out by combining the multiple outputs  I include this example to show that while  gt  gt   is responsible for extracting a  it also has access to the eventual bound output of f  Indeed  it will never extract any a unless it knows the eventual output has the same type of context   There are other monads which are used to represent different contexts  Here s some characterizations of a few more  The IO monad doesn t actually have an a  but it knows a guy and will get that a for you  The State st monad has a secret stash of st that it will pass to f under the table  even though f just came asking for an a  The Reader r monad is similar to State st  although it only lets f look at r   The point in all this is that any type of data which is declared itself to be a Monad is declaring some sort of context around extracting a value from the monad  The big gain from all this  Well  its easy enough to couch a calculation with some sort of context  It can get messy  however  when stringing together multiple context laden calculations  The monad operations take care of resolving the interactions of context so that the programmer doesn t have to    Note  that use of the  gt  gt   eases a mess by by taking some of the autonomy away from f  That is  in the above case of Nothing for instance  f no longer gets to decide what to do in the case of Nothing  it s encoded in  gt  gt    This is the trade off  If it was necessary for f to decide what to do in the case of Nothing  then f should have been a function from Maybe a to Maybe b  In this case  Maybe being a monad is irrelevant   Note  however  that sometimes a data type does not export it s constructors  looking at you IO   and if we want to work with the advertised value we have little choice but to work with it s monadic interface

User · Answer

A Monad is an Applicative  i e  something that you can lift binary -- hence   n-ary  -- functions to  1  and inject pure values into 2   Functor  i e  something that you can map over  3  i e  lift unary functions to 3   with the added ability to flatten the nested datatype  with each of the three notions following its corresponding set of laws   In Haskell  this flattening operation is called join    The general  generic  parametric  type of this  join  operation is     join      Monad m    gt   m  m a   - gt   m a   for any monad m  NB all ms in the type are the same      A specific m monad defines its specific version of join working for any value type a  carried  by the monadic values of type m a  Some specific types are   join        a             - gt   a          -- for lists  or nondeterministic values join      Maybe  Maybe a  - gt  Maybe a     -- for Maybe  or optional values join      IO     IO    a  - gt  IO    a     -- for I O-produced values   The join operation converts an m-computation producing an m-computation of a-type values into one combined m-computation of a-type values  This allows for combination of computation steps into one larger computation   This computation steps-combining  bind    gt  gt    operator simply uses fmap and join together  i e     ma  gt  gt   k       join  fmap k ma   -   ma           m a            --  m -computation which produces  a -type values   k              a - gt  m b     --  create new  m -computation from an  a -type value   fmap k ma    m      m b     --  m -computation of  m -computation of  b -type values    m  gt  gt   k     m        b     --  m -computation which produces  b -type values -    Conversely  join can be defined via bind  join mma    join  fmap id mma     mma  gt  gt   id where id ma   ma -- whichever is more convenient for a given type m   For monads  both the do-notation  and its equivalent bind-using code   do   x  lt - mx   y  lt - my   return  f x y           --   x    a       mx    m a                                                  --   y    b       my    m b mx  gt  gt     x - gt                                     -- nested             my  gt  gt     y - gt                         --  lambda                          return  f x y           --   functions   can be read as      first  do  mx  and when it s done  get its  result  as x and let me use it to  do  something else    In a given do block  each of the values to the right of the binding arrow  lt - is of type m a for some type a and the same monad m throughout the do block    return x is a neutral m-computation which just produces the pure value x it is given  such that binding any m-computation with return does not change that computation at all      1  with liftA2    Applicative m   gt   a - gt  b - gt  c  - gt  m a - gt  m b - gt  m c   2  with pure      Applicative m   gt   a - gt  m a   3  with fmap      Functor m       gt   a - gt  b       - gt  m a - gt  m b   There s also the equivalent Monad methods   liftM2    Monad m   gt   a - gt  b - gt  c  - gt  m a - gt  m b - gt  m c return    Monad m   gt   a            - gt  m a liftM     Monad m   gt   a - gt  b       - gt  m a - gt  m b   Given a monad  the other definitions could be made as  pure   a         return a fmap   f ma      do   a  lt - ma              return  f a      liftA2 f ma mb   do   a  lt - ma   b  lt - mb    return  f a b     ma  gt  gt   k        do   a  lt - ma   b  lt - k a   return  b

User · Answer

After giving an answer to this question a few years ago  I believe I can improve and simplify that response with    A monad is a function composition technique that externalizes treatment for some input scenarios using a composing function  bind  to pre-process input during composition  In normal composition  the function  compose   gt  gt    is use to apply the composed function to the result of its predecessor in sequence  Importantly  the function being composed is required to handle all scenarios of its input   x - gt  y   gt  gt   y - gt  z  This design can be improved by restructuring the input so that relevant states are more easily interrogated  So  instead of simply y the value can become Mb such as  for instance   is OK  b  if y included a notion of validity  For example  when the input is only possibly a number  instead of returning a string which can dutifully contain a number or not  you could restructure the type into a bool indicating the presence of a valid number and a number in tuple such as  bool   float  The composed functions would now no longer need to parse an input string to determine whether a number exists but could merely inspect the bool portion of a tuple   Ma - gt  Mb   gt  gt   Mb - gt  Mc  Here  again  composition occurs naturally with compose and so each function must handle all scenarios of its input individually  though doing so is now much easier  However  what if we could externalize the effort of interrogation for those times where handling a scenario is routine  For example  what if our program does nothing when the input is not OK as in when is OK is false  If that were done then composed functions would not need to handle that scenario themselves  dramatically simplifying their code and effecting another level of reuse  To achieve this externalization we could use a function  bind   gt  gt     to perform the composition instead of compose  As such  instead of simply transferring values from the output of one function to the input of another Bind would inspect the M portion of Ma and decide whether and how to apply the composed function to the a  Of course  the function bind would be defined specifically for our particular M so as to be able to inspect its structure and perform whatever type of application we want  Nonetheless  the a can be anything since bind merely passes the a uninspected to the the composed function when it determines application necessary  Additionally  the composed functions themselves no longer need to deal with the M portion of the input structure either  simplifying them  Hence     a - gt  Mb   gt  gt    b - gt  Mc  or more succinctly Mb  gt  gt    b - gt  Mc  In short  a monad externalizes and thereby provides standard behaviour around the treatment of certain input scenarios once the input becomes designed to sufficiently expose them  This design is a shell and content model where the shell contains data relevant to the application of the composed function and is interrogated by and remains only available to the bind function  Therefore  a monad is three things   an M shell for holding monad relevant information  a bind function implemented to make use of this shell information in its application of the composed functions to the content value s  it finds within the shell  and composable functions of the form  a - gt  Mb  producing results that include monadic management data   Generally speaking  the input to a function is far more restrictive than its output which may include such things as error conditions  hence  the Mb result structure is generally very useful  For instance  the division operator does not return a number when the divisor is 0  Additionally  monads may include wrap functions that wrap values  a  into the monadic type  Ma  and general functions  a - gt  b  into monadic functions  a - gt  Mb  by wrapping their results after application  Of course  like bind  such wrap functions are specific to M  An example  let return a    a  let lift f a   return  f a   The design of the bind function presumes immutable data structures and pure functions others things get complex and guarantees cannot be made  As such  there are monadic laws  Given    M   return    a - gt  Ma  f    a - gt  Mb  g    b - gt  Mc   Then    Left Identity     return a   gt  gt   f     f a Right Identity   Ma  gt  gt   return        Ma Associative      Ma  gt  gt    f  gt  gt   g      Ma  gt  gt     fun x - gt  f x   gt  gt   g   Associativity means that bind preserves the order of evaluation regardless of when bind is applied  That is  in the definition of Associativity above  the force early evaluation of the parenthesized binding of f and g will only result in a function that expects Ma in order to complete the bind  Hence the evaluation of Ma must be determined before its value can become applied to f and that result in turn applied to g

User · Answer

A very simple answer is   Monads are an abstraction that provide an interface for encapsulating values  for computing new encapsulated values  and for unwrapping the encapsulated value   What s convenient about them in practice is that they provide a uniform interface for creating data types that model state while not being stateful   It s important to understand that a Monad is an abstraction  that is  an abstract interface for dealing with a certain kind of data structure  That interface is then used to build data types that have monadic behavior   You can find a very good and practical introduction in Monads in Ruby  Part 1  Introduction

User · Answer

http   mikehadlow blogspot com 2011 02 monads-in-c-8-video-of-my-ddd9-monad html  This is the video you are looking for    Demonstrating in C  what the problem is with composition and aligning the types  and then implementing them properly in C    Towards the end he displays how the same C  code looks in F  and finally in Haskell

User · Answer

Mathematial thinking  For short  An Algebraic Structure for Combining Computations   return data  create a computation who just simply generate a data in monad world    return data   gt  gt    return func   The second parameter accept first parameter as a data generator and create a new computations which concatenate them   You can think that       and return won t do any computation itself  They just simply combine and create computations   Any monad computation will be compute if and only if main trigs it

User · Answer

First  The term monad is a bit vacuous if you are not a mathematician  An alternative term is computation builder which is a bit more descriptive of what they are actually useful for  They are a pattern for chaining operations  It looks a bit like method chaining in object-oriented languages  but the mechanism is slightly different  The pattern is mostly used in functional languages  especially Haskell which uses monads pervasively  but can be used in any language which support higher-order functions  that is  functions which can take other functions as arguments   Arrays in JavaScript support the pattern  so let   s use that as the first example  The gist of the pattern is we have a type  Array in this case  which has a method which takes a function as argument  The operation supplied must return an instance of the same type  i e  return an Array   First an example of method chaining which does not use the monad pattern   1 2 3  map x   gt  x   1   The result is  2 3 4   The code does not conform to the monad pattern  since the function we are supplying as an argument returns a number  not an Array  The same logic in monad form would be   1 2 3  flatMap x   gt   x   1    Here we supply an operation which returns an Array  so now it conforms to the pattern  The flatMap method executes the provided function for every element in the array   It expects an array as result for each invocation  rather than single values   but merges the resulting set of arrays into a single array  So the end result is the same  the array  2 3 4    The function argument provided to a method like map or flatMap is often called a  quot callback quot  in JavaScript  I will call it the  quot operation quot  since it is more general   If we chain multiple operations  in the traditional way    1 2 3  map a   gt  a   1  filter b   gt  b    3   Results in the array  2 4  The same chaining in monad form   1 2 3  flatMap a   gt   a   1   flatMap b   gt  b    3    b         Yields the same result  the array  2 4   You will immediately notice that the monad form is quite a bit uglier than the non-monad  This just goes to show that monads are not necessarily    good     They are a pattern which is sometimes beneficial and sometimes not  Do note that the monad pattern can be combined in a different way   1 2 3  flatMap a   gt   a   1  flatMap b   gt  b    3    b          Here the binding is nested rather than chained  but the result is the same  This is an important property of monads as we will see later  It means two operations combined can be treated the same as a single operation  The operation is allowed to return an array with different element types  for example transforming an array of numbers into an array of strings or something else  as long as it still an Array  This can be described a bit more formally using Typescript notation  An array has the type Array lt T gt   where T is the type of the elements in the array  The method flatMap   takes a function argument of the type T   gt  Array lt U gt  and returns an Array lt U gt   Generalized  a monad is any type Foo lt Bar gt  which has a  quot bind quot  method which takes a function argument of type Bar   gt  Foo lt Baz gt  and returns a Foo lt Baz gt   This answers what monads are  The rest of this answer will try to explain through examples why monads can be a useful pattern in a language like Haskell which has good support for them  Haskell and Do-notation To translate the map filter example directly to Haskell  we replace flatMap with the  gt  gt   operator   1 2 3   gt  gt    a - gt   a 1   gt  gt    b - gt  if b    3 then    else  b    The  gt  gt   operator is the bind function in Haskell  It does the same as flatMap in JavaScript when the operand is a list  but it is overloaded with different meaning for other types  But Haskell also has a dedicated syntax for monad expressions  the do-block  which hides the bind operator altogether   do a  lt -  1 2 3       b  lt -  a 1       if b    3 then    else  b    This hides the  quot plumbing quot  and lets you focus on the actual operations applied at each step  In a do-block  each line is an operation  The constraint still holds that all operations in the block must return the same type  Since the first expression is a list  the other operations must also return a list  The back-arrow  lt - looks deceptively like an assignment  but note that this is the parameter passed in the bind  So  when the expression on the right side is a List of Integers  the variable on the left side will be a single Integer     but will be executed for each integer in the list  Example  Safe navigation  the Maybe type  Enough about lists  lets see how the monad pattern can be useful for other types  Some functions may not always return a valid value  In Haskell this is represented by the Maybe-type  which is an option that is either Some value or Nothing  Chaining operations which always return a valid value is of course straightforward  streetName   getStreetName  getAddress  getUser 17     But what if any of the functions could return Nothing  We need to check each result individually and only pass the value to the next function if it is not Nothing  case getUser 17 of       Nothing - gt  Nothing        Just user - gt           case getAddress user of             Nothing - gt  Nothing              Just address - gt                getStreetName address  Quite a lot of repetitive checks  Imagine if the chain was longer  Haskell solves this with the monad pattern for Maybe  do   user  lt - getUser 17   addr  lt - getAddress user   getStreetName addr  This do-block invokes the bind-function for the Maybe type  since the result of the first expression is a Maybe   The bind-function only executes the following operation if the value is Just value  otherwise it just passes the Nothing along  Here the monad-pattern is used to avoid repetitive code  This is similar to how some other languages use macros to simplify syntax  although macros achieve the same goal in a very different way  Note that it is the combination of the monad pattern and the monad-friendly syntax in Haskell which result in the cleaner code  In a language like JavaScript without any special syntax support for monads  I doubt the monad pattern would be able to simplify the code in this case  Mutable state Haskell does not support mutable state  All variables are constants and all values immutable  But the State type can be used to emulate programming with mutable state  add2    State Integer Integer add2   do         -- add 1 to state          x  lt - get          put  x   1           -- increment in another way          modify   1           -- return state          get   evalState add2 7   gt  9  The add2 function builds a monad chain which is then evaluated with 7 as the initial state  Obviously this is something which only makes sense in Haskell  Other languages support mutable state out of the box  Haskell is generally  quot opt-in quot  on language features - you enable mutable state when you need it  and the type system ensures the effect is explicit  IO is another example of this  IO The IO type is used for chaining and executing    impure    functions  Like any other practical language  Haskell has a bunch of built-in functions which interface with the outside world  putStrLine  readLine and so on  These functions are called    impure    because they either cause side effects or have non-deterministic results  Even something simple like getting the time is considered impure because the result is non-deterministic     calling it twice with the same arguments may return different values  A pure function is deterministic     its result depends purely on the arguments passed and it has no side effects on the environment beside returning a value  Haskell heavily encourages the use of pure functions     this is a major selling point of the language  Unfortunately for purists  you need some impure functions to do anything useful  The Haskell compromise is to cleanly separate pure and impure  and guarantee that there is no way that pure functions can execute impure functions  directly or indirect  This is guaranteed by giving all impure functions the IO type  The entry point in Haskell program is the main function which have the IO type  so we can execute impure functions at the top level  But how does the language prevent pure functions from executing impure functions  This is due to the lazy nature of Haskell  A function is only executed if its output is consumed by some other function  But there is no way to consume an IO value except to assign it to main  So if a function wants to execute an impure function  it has to be connected to main and have the IO type  Using monad chaining for IO operations also ensures that they are executed in a linear and predictable order  just like statements in an imperative language  This brings us to the first program most people will write in Haskell  main    IO    main   do          putStrLn    Hello World     The do keyword is superfluous when there is only a single operation and therefore nothing to bind  but I keep anyway it for consistency  The    type means    void     This special return type is only useful for IO functions called for their side effect  A longer example  main   do     putStrLn  quot What is your name  quot      name  lt - getLine     putStrLn  quot hello quot     name  This builds a chain of IO operations  and since they are assigned to the main function  they get executed  Comparing IO with Maybe shows the versatility of the monad pattern  For Maybe  the pattern is used to avoid repetitive code by moving conditional logic to the binding function  For IO  the pattern is used to ensure that all operations of the IO type are sequenced and that IO operations cannot  quot leak quot  to pure functions  Summing up In my subjective opinion  the monad pattern is only really worthwhile in a language which has some built-in support for the pattern  Otherwise it just leads to overly convoluted code  But Haskell  and some other languages  have some built-in support which hides the tedious parts  and then the pattern can be used for a variety of useful things  Like   Avoiding repetitive code  Maybe  Adding language features like mutable state or exceptions for delimited areas of the program  Isolating icky stuff from nice stuff  IO  Embedded domain-specific languages  Parser  Adding GOTO to the language

User · Answer

If I ve understood correctly  IEnumerable is derived from monads  I wonder if that might be an interesting angle of approach for those of us from the C  world   For what it s worth  here are some links to tutorials that helped me  and no  I still haven t understood what monads are     http   osteele com archives 2007 12 overloading-semicolon http   spbhug folding-maps org wiki MonadsEn http   www loria fr  kow monads

User · Answer

You should first understand what a functor is  Before that  understand higher-order functions   A higher-order function is simply a function that takes a function as an argument   A functor is any type construction T for which there exists a higher-order function  call it map  that transforms a function of type a - gt  b  given any two types a and b  into a function T a - gt  T b  This map function must also obey the laws of identity and composition such that the following expressions return true for all p and q  Haskell notation    map id   id map  p   q    map p   map q   For example  a type constructor called List is a functor if it comes equipped with a function of type  a - gt  b  - gt  List a - gt  List b which obeys the laws above  The only practical implementation is obvious  The resulting List a - gt  List b function iterates over the given list  calling the  a - gt  b  function for each element  and returns the list of the results   A monad is essentially just a functor T with two extra methods  join  of type T  T a  - gt  T a  and unit  sometimes called return  fork  or pure  of type a - gt  T a  For lists in Haskell   join      a   - gt   a  pure    a - gt   a    Why is that useful  Because you could  for example  map over a list with a function that returns a list  Join takes the resulting list of lists and concatenates them  List is a monad because this is possible   You can write a function that does map  then join  This function is called bind  or flatMap  or   gt  gt     or    lt  lt    This is normally how a monad instance is given in Haskell   A monad has to satisfy certain laws  namely that join must be associative  This means that if you have a value x of type    a    then join  join x  should equal join  map join x   And pure must be an identity for join such that join  pure x     x

User · Answer

Monads are to control flow what abstract data types are to data   In other words  many developers are comfortable with the idea of Sets  Lists  Dictionaries  or Hashes  or Maps   and Trees  Within those data types there are many special cases  for instance InsertionOrderPreservingIdentityHashMap    However  when confronted with program  flow  many developers haven t been exposed to many more constructs than if  switch case  do  while  goto  grr   and  maybe  closures   So  a monad is simply a control flow construct  A better phrase to replace monad would be  control type    As such  a monad has slots for control logic  or statements  or functions - the equivalent in data structures would be to say that some data structures allow you to add data  and remove it   For example  the  if  monad   if  clause   then block   at its simplest has two slots - a clause  and a block  The if monad is usually built to evaluate the result of the clause  and if not false  evaluate the block  Many developers are not introduced to monads when they learn  if   and it just isn t necessary to understand monads to write effective logic   Monads can become more complicated  in the same way that data structures can become more complicated  but there are many broad categories of monad that may have similar semantics  but differing implementations and syntax   Of course  in the same way that data structures may be iterated over  or traversed  monads may be evaluated   Compilers may or may not have support for user-defined monads  Haskell certainly does  Ioke has some similar capabilities  although the term monad is not used in the language

User · Answer

Actually  contrary to common understanding of Monads  they have nothing to do with state  Monads are simply a way to wrapping things and provide methods to do operations on the wrapped stuff without unwrapping it   For example  you can create a type to wrap another one  in Haskell   data Wrapped a   Wrap a   To wrap stuff we define  return    a - gt  Wrapped a return x   Wrap x   To perform operations without unwrapping  say you have a function f    a - gt  b  then you can do this to lift that function to act on wrapped values   fmap     a - gt  b  - gt   Wrapped a - gt  Wrapped b  fmap f  Wrap x    Wrap  f x    That s about all there is to understand  However  it turns out that there is a more general function to do this lifting  which is bind   bind     a - gt  Wrapped b  - gt   Wrapped a - gt  Wrapped b  bind f  Wrap x    f x   bind can do a bit more than fmap  but not vice versa  Actually  fmap can be defined only in terms of bind and return  So  when defining a monad   you give its type  here it was Wrapped a  and then say how its return and bind operations work   The cool thing is that this turns out to be such a general pattern that it pops up all over the place  encapsulating state in a pure way is only one of them   For a good article on how monads can be used to introduce functional dependencies and thus control order of evaluation  like it is used in Haskell s IO monad  check out IO Inside   As for understanding monads  don t worry too much about it  Read about them what you find interesting and don t worry if you don t understand right away  Then just diving in a language like Haskell is the way to go  Monads are one of these things where understanding trickles into your brain by practice  one day you just suddenly realize you understand them

User · Answer

See the following slide decks for an attempt to answer that question from a single angle at a time  the focus being on Scala       https   www slideshare net pjschwarz the-monad-fact-slide-deck-series-231063666 https   www slideshare net pjschwarz monad-fact-number-1 https   www slideshare net pjschwarz monad-fact-2 https   www slideshare net pjschwarz monad-fact-number-3 https   www slideshare net pjschwarz monad-fact-4 https   www slideshare net pjschwarz monad-fact-5 https   www slideshare net pjschwarz monad-fact-number-6

User · Answer

Princess s explanation of F  Computation Expressions helped me  though I still can t say I ve really understood   EDIT  this series - explaining monads with javascript - is the one that  tipped the balance  for me     http   blog jcoglan com 2011 03 05 translation-from-haskell-to-javascript-of-selected-portions-of-the-best-introduction-to-monads-ive-ever-read  http   blog jcoglan com 2011 03 06 monad-syntax-for-javascript  http   blog jcoglan com 2011 03 11 promises-are-the-monad-of-asynchronous-programming    I think that understanding monads is something that creeps up on you  In that sense  reading as many  tutorials  as you can is a good idea  but often strange stuff  unfamiliar language or syntax  prevents your brain from concentrating on the essential   Some things that I had difficulty understanding    Rules-based explanations never worked for me  because most practical examples actually require more than just return bind   Also  calling them rules didn t help  It is more a case of  there are these things that have something in common  let s call the things  monads   and the bits in common  rules    Return  a - gt  M lt a gt   and Bind  M lt a gt  - gt   a - gt  M lt b gt   - gt  M lt b gt   are great  but what I could never understand is HOW Bind could extract the a from M lt a gt  in order to pass it into a - gt  M lt b gt   I don t think I ve ever read anywhere  maybe it s obvious to everyone else   that the reverse of Return  M lt a gt  - gt  a  has to exist inside the monad  it just doesn t need to be exposed

User · Answer

Monoid appears to be something that ensures that all operations defined on a Monoid and a supported type will always return a supported type inside the Monoid  Eg  Any number   Any number   A number  no errors    Whereas division accepts two fractionals  and returns a fractional  which defined division by zero as Infinity in haskell somewhy which happens to be a fractional somewhy       In any case  it appears Monads are just a way to ensure that your chain of operations behaves in a predictable way  and a function that claims to be Num -  Num  composed with another function of Num- Num called with x does not say  fire the missiles   On the other hand  if we have a function which does fire the missiles  we can compose it with other functions which also fire the missiles  because our intent is clear -- we want to fire the missiles -- but it won t try printing  Hello World  for some odd reason   In Haskell  main is of type IO     or IO       the distiction is strange and I will not discuss it but here s what I think happens   If I have main  I want it to do a chain of actions  the reason I run the program is to produce an effect -- usually though IO  Thus I can chain IO operations together in main in order to -- do IO  nothing else   If I try to do something which does not  return IO   the program will complain that the chain does not flow  or basically  How does this relate to what we are trying to do -- an IO action   it appears to force the programmer to keep their train of thought  without straying off and thinking about firing the missiles  while creating algorithms for sorting -- which does not flow   Basically  Monads appear to be a tip to the compiler that  hey  you know this function that returns a number here  it doesn t actually always work  it can sometimes produce a Number  and sometimes Nothing at all  just keep this in mind   Knowing this  if you try to assert a monadic action  the monadic action may act as a compile time exception saying  hey  this isn t actually a number  this CAN be a number  but you can t assume this  do something to ensure that the flow is acceptable   which prevents unpredictable program behavior -- to a fair extent   It appears monads are not about purity  nor control  but about maintaining an identity of a category on which all behavior is predictable and defined  or does not compile  You cannot do nothing when you are expected to do something  and you cannot do something if you are expected to do nothing  visible    The biggest reason I could think of for Monads is -- go look at Procedural OOP code  and you will notice that you do not know where the program starts  nor ends  all you see is a lot of jumping and a lot of math magic and missiles  You will not be able to maintain it  and if you can  you will spend quite a lot of time wrapping your mind around the whole program before you can understand any part of it  because modularity in this context is based on interdependant  sections  of code  where code is optimized to be as related as possible for promise of efficiency inter-relation  Monads are very concrete  and well defined by definition  and ensure that the flow of program is possible to analyze  and isolate parts which are hard to analyze -- as they themselves are monads  A monad appears to be a  comprehensible unit which is predictable upon its full understanding  -- If you understand  Maybe  monad  there s no possible way it will do anything except be  Maybe   which appears trivial  but in most non monadic code  a simple function  helloworld  can fire the missiles  do nothing  or destroy the universe or even distort time -- we have no idea nor have any guarantees that IT IS WHAT IT IS  A monad GUARANTEES that IT IS WHAT IT IS  which is very powerful   All things in  real world  appear to be monads  in the sense that it is bound by definite observable laws preventing confusion  This does not mean we have to mimic all the operations of this object to create classes  instead we can simply say  a square is a square   nothing but a square  not even a rectangle nor a circle  and  a square has area of the length of one of it s existing dimensions multiplied by itself  No matter what square you have  if it s a square in 2D space  it s area absolutely cannot be anything but its length squared  it s almost trivial to prove  This is very powerful because we do not need to make assertions to make sure that our world is the way it is  we just use implications of reality to prevent our programs from falling off track   Im pretty much guaranteed to be wrong but I think this could help somebody out there  so hopefully it helps somebody

User · Answer

Another attempt at explaining monads  using just Python lists and the map function  I fully accept this isn t a full explanation  but I hope it gets at the core concepts   I got the basis of this from the funfunfunction video on Monads and the Learn You A Haskell chapter  For a Few Monads More   I highly recommend watching the funfunfunction video   At it s very simplest  Monads are objects that have a map and flatMap functions  bind in Haskell   There are some extra required properties  but these are the core ones   flatMap  flattens  the output of map  for lists this just concatenates the values of the list e g    concat   1    4    9       1  4  9    So in Python we can very basically implement a Monad with just these two functions     def flatMap func  lst       return concat map func  lst    def concat lst       return sum lst        func is any function that takes a value and returns a list e g   lambda x   x x    Explanation  For clarity I created the concat function in Python via a simple function  which sums the lists i e        1     4     9     1  4  9   Haskell has a native concat method    I m assuming you know what the map function is e g     gt  gt  gt  list map lambda x   x x    1 2 3      1    4    9     Flattening is the key concept of Monads and for each object which is a Monad this flattening allows you to get at the value that is wrapped in the Monad   Now we can call    gt  gt  gt  flatMap lambda x   x x    1 2 3    1  4  9    This lambda is taking a value x and putting it into a list  A monad works with any function that goes from a value to a type of the monad  so a list in this case   That s your monad defined    I think the question of why they re useful has been answered in other questions    More explanation  Other examples that aren t lists are JavaScript Promises  which have the then method and JavaScript Streams which have a flatMap method   So Promises and Streams use a slightly different function which flattens out a Stream or a Promise and returns the value from within   The Haskell list monad has the following definition   instance Monad    where       return x    x        xs  gt  gt   f   concat  map f xs        fail           i e  there are three functions return  not to be confused with return in most other languages    gt  gt    the flatMap  and fail   Hopefully you can see the similarity between   xs  gt  gt   f   concat  map f xs    and   def flatMap f  xs       return concat map f  xs

User · Answer

following your brief  succinct  practical indications   The easiest way to understand a monad is as a way to apply compose functions within a context  Let s say you have two computations which both can be seen as two mathematical functions f and g     f takes a String and produces another String  take the first two letters  g takes a String and produces another String  upper case transformation    So in any language the transformation  take the first two letter and convert them to upper case  would be written g f  some string     So  in the  world of pure perfect functions  composition is just  do one thing and then do the other    But let s say we live in the world of functions which can fail  For example  the input string might be one char long so f would fail  So in this case    f takes a String and produces a String or Nothing   g produces a String only if f hasn t failed  Otherwise  produces Nothing    So now  g f  some string    needs some extra checking   Compute f  if it fails then g should return Nothing  else compute g   This idea can be applied to any parametrized type as follows   Let Context Sometype  be a computation of Sometype within a Context  Considering functions    f   AnyType - gt  Context Sometype  g   Sometype - gt  Context AnyOtherType    the composition g f    should be readed as  compute f  Within this context do some extra computations and then compute g if it has sense within the context

User · Answer

Explaining monads seems to be like explaining control-flow statements  Imagine that a non-programmer asks you to explain them    You can give them an explanation involving the theory - Boolean Logic  register values  pointers  stacks  and frames  But that would be crazy   You could explain them in terms of the syntax  Basically all control-flow statements in C have curly brackets  and you can distinguish the condition and the conditional code by where they are relative to the brackets  That may be even crazier   Or you could also explain loops  if statements  routines  subroutines  and possibly co-routines   Monads can replace a fairly large number of programming techniques  There s a specific syntax in languages that support them  and some theories about them    They are also a way for functional programmers to use imperative code without actually admitting it  but that s not their only use

User · Answer

I am still new to monads  but I thought I would share a link I found that felt really good to read  WITH PICTURES     http   www matusiak eu numerodix blog 2012 3 11 monads-for-the-layman   no affiliation   Basically  the warm and fuzzy concept that I got from the article was the concept that monads are basically adapters that allow disparate functions to work in a composable fashion  i e  be able to string up multiple functions and mix and match them without worrying about inconsistent return types and such  So the BIND function is in charge of keeping apples with apples and oranges with oranges when we re trying to make these adapters  And the LIFT function is in charge of taking  lower level  functions and  upgrading  them to work with BIND functions and be composable as well   I hope I got it right  and more importantly  hope that the article has a valid view on monads  If nothing else  this article helped whet my appetite for learning more about monads

User · Answer

Essentially  and Practically  monads allow callback nesting  with a mutually-recursively-threaded state  pardon the hyphens    in a composable  or decomposable  fashion   with type safety  sometimes  depending on the language                                                                                           E G  this is NOT a monad       JavaScript is  Practical  var getAllThree             bind getFirst  function first       return bind getSecond function second       return bind getThird  function third         var fancyResult      And now make do fancy                           with first  second                           and third      return RETURN fancyResult                   But monads enable such code  The monad is actually the set of types for   bind RETURN maybe others I don t know      Which is essentially inessential  and practically impractical     So now I can use it     var fancyResultReferenceOutsideOfMonad       getAllThree someKindOfInputAcceptableToOurGetFunctionsButProbablyAString        Ignore this please  throwing away types  yay JavaScript      RETURN   K     bind    getterFn cb - gt          in - gt  let result newState    getterFn in  in cb result  newState    Or Break it up   var getFirstTwo               bind getFirst  function first         return bind getSecond function second           var fancyResult2      And now make do fancy                              with first and second       return RETURN fancyResult2                 getAllThree               bind getFirstTwo  function fancyResult2         return bind getThird     function third           var fancyResult3      And now make do fancy                              with fancyResult2                              and third        return RETURN fancyResult3                Or ignore certain results   var getFirstTwo               bind getFirst  function first         return bind getSecond function second           var fancyResult2      And now make do fancy                              with first and second       return RETURN fancyResult2                 getAllThree               bind getFirstTwo  function     dontCare    NotGonnaUse             return bind getThird     function three           var fancyResult3      And now make do fancy                              with  three  only        return RETURN fancyResult3                Or simplify a trivial case from   var getFirstTwo               bind getFirst  function first         return bind getSecond function second           var fancyResult2      And now make do fancy                              with first and second       return RETURN fancyResult2                 getAllThree               bind getFirstTwo  function           return bind getThird     function three           return RETURN three                To  using  Right Identity     var getFirstTwo               bind getFirst  function first         return bind getSecond function second           var fancyResult2      And now make do fancy                              with first and second       return RETURN fancyResult2                 getAllThree               bind getFirstTwo  function           return getThird            Or jam them back together   var getAllThree               bind getFirst  function first dontCareNow         return bind getSecond function second dontCareNow         return getThird               The practicality of these abilities doesn t really emerge  or become clear until you try to solve really messy problems like parsing  or module ajax resource loading   Can you imagine thousands of lines of indexOf subString logic  What if frequent parsing steps were contained in little functions  Functions like chars  spaces upperChars  or digits  And what if those functions gave you the result in a callback  without having to mess with Regex groups  and arguments slice  And what if their composition decomposition was well understood  Such that you could build big parsers from the bottom up     So the ability to manage nested callback scopes is incredibly practical  especially when working with monadic parser combinator libraries   that is to say  in my experience   DON T GET HUNG UP ON  - CATEGORY-THEORY - MAYBE-MONADS - MONAD LAWS - HASKELL -

User · Answer

See also the answers at What is a monad    A good motivation to Monads is sigfpe  Dan Piponi  s You Could Have Invented Monads   And Maybe You Already Have   There are a LOT of other monad tutorials  many of which misguidedly try to explain monads in  simple terms  using various analogies  this is the monad tutorial fallacy  avoid them   As DR MacIver says in Tell us why your language sucks    So  things I hate about Haskell        Let   s start with the obvious  Monad tutorials  No  not monads  Specifically the tutorials  They   re endless  overblown and dear god are they tedious  Further  I   ve never seen any convincing evidence that they actually help  Read the class definition  write some code  get over the scary name    You say you understand the Maybe monad  Good  you re on your way  Just start using other monads and sooner or later you ll understand what monads are in general    If you are mathematically oriented  you might want to ignore the dozens of tutorials and learn the definition  or follow lectures in category theory    The main part of the definition is that a Monad M involves a  type constructor  that defines for each existing type  T  a new type  M T   and some ways for going back and forth between  regular  types and  M  types    Also  surprisingly enough  one of the best introductions to monads is actually one of the early academic papers introducing monads  Philip Wadler s Monads for functional programming  It actually has practical  non-trivial motivating examples  unlike many of the artificial tutorials out there

User · Answer

What the world needs is another monad blog post  but I think this is useful in identifying existing monads in the wild    monads are fractals            The above is a fractal called Sierpinski triangle  the only fractal I can remember to draw  Fractals are self-similar structure like the above triangle  in which the parts are similar to the whole  in this case exactly half the scale as parent triangle        Monads are fractals  Given a monadic data structure  its values can be composed to form another value of the data structure  This is why it s useful to programming  and this is why it occurrs in many situations

User · Answer

A monad is a way of combining computations together that share a common context   It is like building a network of pipes   When constructing the network  there is no data flowing through it   But when I have finished piecing all the bits together with  bind  and  return  then I invoke something like runMyMonad monad data and the data flows through the pipes

User · Answer

Explanation  It s quite simple  when explained in C  Java terms    A monad is a function that takes arguments and returns a special type   The special type that this monad returns is also called monad   A monad is a combination of  1 and  2  There s some syntactic sugar to make calling this function and conversion of types easier    Example  A monad is useful to make the life of the functional programmer easier  The typical example  The Maybe monad takes two parameters  a value and a function  It returns null if the passed value is null  Otherwise it evaluates the function  If we needed a special return type  we would call this return type Maybe as well  A very crude implementation would look like this   object Maybe object value  Func lt object object gt  function        if value  null          return null       return function value       This is spectacularly useless in C  because this language lacks the required syntactic sugar to make monads useful  But monads allow you to write more concise code in functional programming languages   Oftentimes programmers call monads in chains  like so   var x   Maybe x  x2   gt  Maybe y  y2   gt  Add x2  y2       In this example the Add method would only be called if x and y are both non-null  otherwise null will be returned   Answer  To answer the original question  A monad is a function AND a type  Like an implementation of a special interface

User · Answer

I will try to explain Monad in the context of Haskell   In functional programming  function composition is important  It allows our program to consist of small  easy-to-read functions   Let s say we have two functions  g    Int - gt  String and f    String - gt  Bool   We can do  f   g  x  which is just the same as f  g x   where x is an Int value   When doing composition applying the result of one function to another  having the types match up is important  In the above case  the type of the result returned by g must be the same as the type accepted by f   But sometimes values are in contexts  and this makes it a bit less easy to line up types   Having values in contexts is very useful  For example  the Maybe Int type represents an Int value that may not be there  the IO String type represents a String value that is there as a result of performing some side effects    Let s say we now have g1    Int - gt  Maybe String and f1    String - gt  Maybe Bool  g1 and f1 are very similar to g and f respectively   We can t do  f1   g1  x or f1  g1 x   where x is an Int value  The type of the result returned by g1 is not what f1 expects   We could compose f and g with the   operator  but now we can t compose f1 and g1 with    The problem is that we can t straightforwardly pass a value in a context to a function that expects a value that is not in a context   Wouldn t it be nice if we introduce an operator to compose g1 and f1  such that we can write  f1 OPERATOR g1  x  g1 returns a value in a context  The value will be taken out of context and applied to f1  And yes  we have such an operator  It s  lt   lt    We also have the  gt  gt   operator that does for us the exact same thing  though in a slightly different syntax   We write  g1 x  gt  gt   f1  g1 x is a Maybe Int value  The  gt  gt   operator helps take that Int value out of the  perhaps-not-there  context  and apply it to f1  The result of f1  which is a Maybe Bool  will be the result of the entire  gt  gt   operation   And finally  why is Monad useful  Because Monad is the type class that defines the  gt  gt   operator  very much the same as the Eq type class that defines the    and    operators   To conclude  the Monad type class defines the  gt  gt   operator that allows us to pass values in a context  we call these monadic values  to functions that don t expect values in a context  The context will be taken care of   If there is one thing to remember here  it is that Monads allow function composition that involves values in contexts

User · Answer

A Monad is a box with a special machine attached that allows you to make one normal box out of two nested boxes - but still retaining some of the shape of both boxes   Concretely  it allows you to perform join  of type Monad m   gt  m  m a  - gt  m a   It also needs a return action  which just wraps a value  return    Monad m   gt  a - gt  m a You could also say join unboxes and return wraps - but join is not of type Monad m   gt  m a - gt  a  It doesn t unwrap all Monads  it unwraps Monads with Monads inside of them    So it takes a Monad box  Monad m   gt   m  with a box inside it   m a   and makes a normal box  m a    However  usually a Monad is used in terms of the   gt  gt     spoken  bind   operator  which is essentially just fmap and join after each other  Concretely   x  gt  gt   f   join  fmap f x    gt  gt       Monad m   gt   a - gt  m b  - gt  m a - gt  m b   Note here that the function comes in the second argument  as opposed to fmap   Also  join     gt  gt   id    Now why is this useful  Essentially  it allows you to make programs that string together actions  while working in some sort of framework  the Monad    The most prominent use of Monads in Haskell is the IO Monad  Now  IO is the type that classifies an Action in Haskell  Here  the Monad system was the only way of preserving  big fancy words     Referential Transparency Lazyness Purity   In essence  an IO action such as getLine    IO String can t be replaced by a String  as it always has a different type  Think of IO as a sort of magical box that teleports the stuff to you  However  still just saying that getLine    IO String and all functions accept IO a causes mayhem as maybe the functions won t be needed  What would const    p    getLine do   const discards the second argument  const a b   a   The getLine doesn t need to be evaluated  but it s supposed to do IO  This makes the behaviour rather unpredictable - and also makes the type system less  pure   as all functions would take a and IO a values   Enter the IO Monad   To string to actions together  you just flatten the nested actions  And to apply a function to the output of the IO action  the a in the IO a type  you just use   gt  gt      As an example  to output an entered line  to output a line is a function which produces an IO action  matching the right argument of  gt  gt      getLine  gt  gt   putStrLn    IO    -- putStrLn    String - gt  IO      This can be written more intuitively with the do environment   do line  lt - getLine    putStrLn line   In essence  a do block like this   do x  lt - a    y  lt - b    z  lt - f x y    w  lt - g z    h x    k  lt - h z    l k w       gets transformed into this   a      gt  gt    x - gt  b      gt  gt    y - gt  f x y  gt  gt    z - gt  g z    gt  gt    w - gt  h x    gt  gt      - gt  h z    gt  gt    k - gt  l k w   There s also the  gt  gt  operator for m  gt  gt      - gt  f  when the value in the box isn t needed to make the new box in the box  It can also be written a  gt  gt  b   a  gt  gt   const b  const a b   a   Also  the return operator is modeled after the IO-intuituion - it returns a value with minimal context  in this case no IO  Since the a in IO a represents the returned type  this is similar to something like return a  in imperative programming languages - but it does not stop the chain of actions  f  gt  gt   return  gt  gt   g is the same as f  gt  gt   g  It s only useful when the term you return has been created earlier in the chain - see above   Of course  there are other Monads  otherwise it wouldn t be called Monad  it d be called somthing like  IO Control    For example  the List Monad  Monad     flattens by concatenating - making the   gt  gt    operator perform a function on all elements of a list  This can be seen as  indeterminism   where the List is the many possible values and the Monad Framework is making all the possible combinations   For example  in GHCi    Prelude gt   1  2  3   gt  gt   replicate 3  -- Simple binding  1  1  1  2  2  2  3  3  3  Prelude gt  concat  map  replicate 3   1  2  3    -- Same operation  more explicit  1  1  1  2  2  2  3  3  3  Prelude gt   1  2  3   gt  gt   uq   uququq  Prelude gt  return 2     Int   2  Prelude gt  join   1  2    3  4    1  2  3  4    because   join a   concat a a  gt  gt   f   join  fmap f a  return a    a   -- or             The Maybe Monad just nullifies all results to Nothing if that ever occurs  That is  binding auto-checks if the function  a  gt  gt   f  returns or the value  a  gt  gt   f  is Nothing - and then returns Nothing as well   join       Nothing    Nothing join  Just Nothing    Nothing join  Just x          x a  gt  gt   f               join  fmap f a    or  more explicitly   Nothing   gt  gt            Nothing  Just x   gt  gt   f        f x   The State Monad is for functions that also modify some shared state - s - gt   a  s   so the argument of  gt  gt   is    a - gt  s - gt   a  s   The name is a sort of misnomer  since State really is for state-modifying functions  not for the state - the state itself really has no interesting properties  it just gets changed   For example   pop           a  - gt   a    a   pop  h t     h  t  sPop   state pop   -- The module for State exports no State constructor                     -- only a state function  push    a - gt   a  - gt        a   push x l         x   l  sPush   state push  swap   do a  lt - sPop           b  lt - sPop           sPush a           sPush b  get2   do a  lt - sPop           b  lt - sPop           return  a  b   getswapped   do swap                 get2   then   Main  gt  runState swap  1  2  3        2  1  3   Main  gt  runState get2  1  2  3    1  2    1  2  3  Main  gt  runState  swap  gt  gt  get2   1  2  3    2  1    2  1  3   Main  gt  runState getswapped  1  2  3    2  1    2  1  3     also   Prelude gt  runState  return 0  1  0  1

User · Answer

If you are asking for a succinct  practical explanation for something so abstract  then you can only hope for an abstract answer   a - gt  b   is one way of representing a computation from as to bs  You can chain computations  aka compose them together    b - gt  c  - gt   a - gt  b  - gt   a - gt  c    More complex computations demand more complex types  e g    a - gt  f b   is the type of computations from as to bs that are into fs  You can also compose them    b - gt  f c  - gt   a - gt  f b  - gt   a - gt  f c    It turns out this pattern appears literally everywhere and has the same properties as the first composition above  associativity  right- and left-identity    One had to give this pattern a name  but then would it help to know that the first composition is formally characterised as a Semigroupoid    Monads are just as interesting and important as parentheses   Oleg Kiselyov

User · Answer

A monad is a datatype that has two operations   gt  gt    aka bind  and return  aka unit   return takes an arbitrary value and creates an instance of the monad with it   gt  gt   takes an instance of the monad and maps a function over it   You can see already that a monad is a strange kind of datatype  since in most programming languages you couldn t write a function that takes an arbitrary value and creates a type from it  Monads use a kind of parametric polymorphism    In Haskell notation  the monad interface is written  class Monad m where   return    a - gt  m a     gt  gt       forall a b   m a - gt   a - gt  m b  - gt  m b   These operations are supposed to obey certain  laws   but that s not terrifically important  the  laws  just codify the way sensible implementations of the operations ought to behave  basically  that  gt  gt   and return ought to agree about how values get transformed into monad instances and that  gt  gt   is associative    Monads are not just about state and I O  they abstract a common pattern of computation that includes working with state  I O  exceptions  and non-determinism  Probably the simplest monads to understand are lists and option types   instance Monad     where             gt  gt   k           x xs   gt  gt   k   k x     xs  gt  gt   k      return x        x   instance Monad Maybe where     Just x   gt  gt   k   k x     Nothing  gt  gt   k   Nothing     return x        Just x   where    and   are the list constructors     is the concatenation operator  and Just and Nothing are the Maybe constructors  Both of these monads encapsulate common and useful patterns of computation on their respective data types  note that neither has anything to do with side effects or I O    You really have to play around writing some non-trivial Haskell code to appreciate what monads are about and why they are useful

User · Answer

I m trying to understand monads as well  It s my version   Monads are about making abstractions about repetitive things   Firstly  monad itself is a typed interface  like an abstract generic class   that has two functions  bind and return that have defined signatures  And then  we can create concrete monads based on that abstract monad  of course with specific implementations of bind and return  Additionally  bind and return must fulfill a few invariants in order to make it possible to compose chain concrete monads   Why create the monad concept while we have interfaces  types  classes and other tools to create abstractions  Because monads give more  they enforce rethinking problems in a way that enables to compose data without any boilerplate

User · Answer

According to What we talk about when we talk about monads the question  quot What is a monad quot  is wrong   The short answer to the question  quot What is a monad  quot  is that it is a monoid in the category of endofunctors or that it is a generic data type equipped with two operations that satisfy certain laws  This is correct  but it does not reveal an important bigger picture  This is because the question is wrong  In this paper  we aim to answer the right question  which is  quot What do authors really say when they talk about monads  quot   While that paper does not directly answer what a monad is it helps understanding what people with different backgrounds mean when they talk about monads and why

User · Answer

In the Coursera  Principles of Reactive Programming  training - Erik Meier describes them as    Monads are return types that guide you through the happy path   -Erik Meijer

User · Answer

In addition to the excellent answers above  let me offer you a link to the following article  by Patrick Thomson  which explains monads by relating the concept to the JavaScript library jQuery  and its way of using  method chaining  to manipulate the DOM   jQuery is a Monad  The jQuery documentation itself doesn t refer to the term  monad  but talks about the  builder pattern  which is probably more familiar   This doesn t change the fact that you have a proper monad there maybe without even realizing it

User · Answer

A monad is  effectively  a form of  type operator   It will do three things  First it will  wrap   or otherwise convert  a value of one type into another type  typically called a  monadic type    Secondly it will make all the operations  or functions  available on the underlying type available on the monadic type  Finally it will provide support for combining its self with another monad to produce a composite monad   The  maybe monad  is essentially the equivalent of  nullable types  in Visual Basic   C   It takes a non nullable type  T  and converts it into a  Nullable lt T gt    and then defines what all the binary operators mean on a Nullable lt T gt    Side effects are represented simillarly  A structure is created that holds descriptions of side effects alongside a function s return value  The  lifted  operations then copy around side effects as values are passed between functions   They are called  monads  rather than the easier-to-grasp name of  type operators  for several reasons    Monads have restrictions on what they can do  see the definiton for details   Those restrictions  along with the fact that there are three operations involved  conform to the structure of something called a monad in Category Theory  which is an obscure branch of mathematics  They were designed by proponents of  pure  functional languages Proponents of pure functional languages like obscure branches of mathematics Because the math is obscure  and monads are associated with particular styles of programming  people tend to use the word monad as a sort of secret handshake  Because of this no one has bothered to invest in a better name

User · Answer

But  You could have invented Monads      sigfpe says            But all of these introduce monads as something esoteric in need of explanation  But what I want to argue is that they aren t esoteric at all  In fact  faced with various problems in functional programming you would have been led  inexorably  to certain solutions  all of which are examples of monads  In fact  I hope to get you to invent them now if you haven t already  It s then a small step to notice that all of these solutions are in fact the same solution in disguise  And after reading this  you might be in a better position to understand other documents on monads because you ll recognise everything you see as something you ve already invented           Many of the problems that monads try to solve are related to the issue of side effects  So we ll start with them   Note that monads let you do more than handle side-effects  in particular many types of container object can be viewed as monads  Some of the introductions to monads find it hard to reconcile these two different uses of monads and concentrate on just one or the other            In an imperative programming language such as C    functions behave nothing like the functions of mathematics  For example  suppose we have a C   function that takes a single floating point argument and returns a floating point result  Superficially it might seem a little like a mathematical function mapping reals to reals  but a C   function can do more than just return a number that depends on its arguments  It can read and write the values of global variables as well as writing output to the screen and receiving input from the user  In a pure functional language  however  a function can only read what is supplied to it in its arguments and the only way it can have an effect on the world is through the values it returns

User · Answer

My favorite Monad tutorial   http   www haskell org haskellwiki All About Monads   out of 170 000 hits on a Google search for  monad tutorial      Stu  The point of monads is to allow you to add  usually  sequential semantics to otherwise pure code  you can even compose monads  using Monad Transformers  and get more interesting and complicated combined semantics  like parsing with error handling  shared state  and logging  for example  All of this is possible in pure code  monads just allow you to abstract it away and reuse it in modular libraries  always good in programming   as well as providing convenient syntax to make it look imperative   Haskell already has operator overloading 1   it uses type classes much the way one might use interfaces in Java or C  but Haskell just happens to also allow non-alphanumeric tokens like    amp  amp  and   as infix identifiers  It s only operator overloading in your way of looking at it if you mean  overloading the semicolon   2   It sounds like black magic and asking for trouble to  overload the semicolon   picture enterprising Perl hackers getting wind of this idea  but the point is that without monads there is no semicolon  since purely functional code does not require or allow explicit sequencing   This all sounds much more complicated than it needs to  sigfpe s article is pretty cool but uses Haskell to explain it  which sort of fails to break the chicken and egg problem of understanding Haskell to grok Monads and understanding Monads to grok Haskell    1  This is a separate issue from monads but monads use Haskell s operator overloading feature    2  This is also an oversimplification since the operator for chaining monadic actions is      pronounced  bind   but there is syntactic sugar   do   that lets you use braces and semicolons and or indentation and newlines

User · Answer

http   code google com p monad-tutorial  is a work in progress to address exactly this question

User · Answer

Monads Are Not Metaphors  but a practically useful abstraction emerging from a common pattern  as Daniel Spiewak explains

User · Answer

In the context of Scala you will find the following to be the simplest definition  Basically flatMap  or bind  is  associative  and there exists an identity   trait M  A      def flatMap B  f  A   gt  M B    M B     AKA bind       Pseudo Meta Code   def isValidMonad  Boolean            for every parameter the following holds     def isAssociativeOn X  Y  Z  x  M X   f  X   gt  M Y   g  Y   gt  M Z    Boolean         x flatMap f  flatMap g     x flatMap f    flatMap g           for every parameter X and x  there exists an id        such that the following holds     def isAnIdentity X  x  M X   id  X   gt  M X    Boolean         x flatMap id     x         E g      These could be any functions val f  Int   gt  Option String    number   gt  if  number    7  Some  hello   else None val g  String   gt  Option Double    string   gt  Some 3 14      Observe these are identical  Since Option is a Monad     they will always be identical no matter what the functions are scala gt  Some 7  flatMap f  flatMap g  res211  Option Double    Some 3 14   scala gt  Some 7  flatMap f    flatMap g   res212  Option Double    Some 3 14       As Option is a Monad  there exists an identity  val id  Int   gt  Option Int    x   gt  Some x      Observe these are identical scala gt  Some 7  flatMap id  res213  Option Int    Some 7   scala gt  Some 7  res214  Some Int    Some 7    NOTE Strictly speaking the definition of a Monad in functional programming is not the same as the definition of a Monad in Category Theory  which is defined in turns of map and flatten   Though they are kind of equivalent under certain mappings   This presentations is very good  http   www slideshare net samthemonad monad-presentation-scala-as-a-category

User · Answer

A monad is a thing used to encapsulate objects that have changing state  It is most often encountered in languages that otherwise do not allow you to have modifiable state  e g   Haskell    An example would be for file I O   You would be able to use a monad for file I O to isolate the changing state nature to just the code that used the Monad  The code inside the Monad can effectively ignore the changing state of the world outside the Monad - this makes it a lot easier to reason about the overall effect of your program

User · Answer

After much striving  I think I finally understand the monad  After rereading my own lengthy critique of the overwhelmingly top voted answer  I will offer this explanation  There are three questions that need to be answered to understand monads   Why do you need a monad  What is a monad  How is a monad implemented   As I noted in my original comments  too many monad explanations get caught up in question number 3  without  and before really adequately covering question 2  or question 1  Why do you need a monad  Pure functional languages like Haskell are different from imperative languages like C  or Java in that  a pure functional program is not necessarily executed in a specific order  one step at a time  A Haskell program is more akin to a mathematical function  in which you may solve the  quot equation quot  in any number of potential orders  This confers a number of benefits  among which is that it eliminates the possibility of certain kinds of bugs  particularly those relating to things like  quot state quot   However  there are certain problems that are not so straightforward to solve with this style of programming  Some things  like console programming  and file i o  need things to happen in a particular order  or need to maintain state  One way to deal with this problem is to create a kind of object that represents the state of a computation  and a series of functions that take a state object as input  and return a new modified state object  So let s create a hypothetical  quot state quot  value  that represents the state of a console screen  exactly how this value is constructed is not important  but let s say it s an array of byte length ascii characters that represents what is currently visible on the screen  and an array that represents the last line of input entered by the user  in pseudocode  We ve defined some functions that take console state  modify it  and return a new console state  consolestate MyConsole   new consolestate   So to do console programming  but in a pure functional manner  you would need to nest a lot of function calls inside eachother  consolestate FinalConsole   print input print myconsole   quot Hello  what s your name  quot     quot hello   inputbuffer   quot     Programming in this way keeps the  quot pure quot  functional style  while forcing changes to the console to happen in a particular order  But  we ll probably want to do more than just a few operations at a time like in the above example  Nesting functions in that way will start to become ungainly  What we want  is code that does essentially the same thing as above  but is written a bit more like this  consolestate FinalConsole   myconsole                              print  quot Hello  what s your name  quot                                input                                print  quot hello   inputbuffer   quot     This would indeed be a more convenient way to write it  How do we do that though  What is a monad  Once you have a type  such as consolestate  that you define along with a bunch of functions designed specifically to operate on that type  you can turn the whole package of these things into a  quot monad quot  by defining an operator like    bind  that automatically feeds return values on its left  into function parameters on its right  and a lift operator that turns normal functions  into functions that work with that specific kind of bind operator  How is a monad implemented  See other answers  that seem quite free to jump into the details of that

User · Answer

Explaining  what is a monad  is a bit like saying  what is a number   We use numbers all the time  But imagine you met someone who didn t know anything about numbers  How the heck would you explain what numbers are  And how would you even begin to describe why that might be useful   What is a monad  The short answer  It s a specific way of chaining operations together   In essence  you re writing execution steps and linking them together with the  bind function    In Haskell  it s named  gt  gt     You can write the calls to the bind operator yourself  or you can use syntax sugar which makes the compiler insert those function calls for you  But either way  each step is separated by a call to this bind function   So the bind function is like a semicolon  it separates the steps in a process  The bind function s job is to take the output from the previous step  and feed it into the next step   That doesn t sound too hard  right  But there is more than one kind of monad  Why  How   Well  the bind function can just take the result from one step  and feed it to the next step  But if that s  all  the monad does    that actually isn t very useful  And that s important to understand  Every useful monad does something else in addition to just being a monad  Every useful monad has a  special power   which makes it unique    A monad that does nothing special is called the  identity monad   Rather like the identity function  this sounds like an utterly pointless thing  yet turns out not to be    But that s another story trade     Basically  each monad has its own implementation of the bind function  And you can write a bind function such that it does hoopy things between execution steps  For example    If each step returns a success failure indicator  you can have bind execute the next step only if the previous one succeeded  In this way  a failing step aborts the whole sequence  automatically   without any conditional testing from you   The Failure Monad   Extending this idea  you can implement  exceptions    The Error Monad or Exception Monad   Because you re defining them yourself rather than it being a language feature  you can define how they work   E g   maybe you want to ignore the first two exceptions and only abort when a third exception is thrown   You can make each step return multiple results  and have the bind function loop over them  feeding each one into the next step for you  In this way  you don t have to keep writing loops all over the place when dealing with multiple results  The bind function  automatically  does all that for you   The List Monad   As well as passing a  result  from one step to another  you can have the bind function pass extra data around as well  This data now doesn t show up in your source code  but you can still access it from anywhere  without having to manually pass it to every function   The Reader Monad   You can make it so that the  extra data  can be replaced  This allows you to simulate destructive updates  without actually doing destructive updates   The State Monad and its cousin the Writer Monad   Because you re only simulating destructive updates  you can trivially do things that would be impossible with real destructive updates  For example  you can undo the last update  or revert to an older version  You can make a monad where calculations can be paused  so you can pause your program  go in and tinker with internal state data  and then resume it  You can implement  continuations  as a monad  This allows you to break people s minds    All of this and more is possible with monads  Of course  all of this is also perfectly possible without monads too  It s just drastically easier using monads

User · Answer

In practice  monad is a custom implementation of function composition operator that takes care of side effects and incompatible input and return values  for chaining

User · Answer

This answer begins with a motivating example  works through the example  derives an example of a monad  and formally defines  monad    Consider these three functions in pseudocode   f  lt x  messages gt       lt x  messages  called f    gt  g  lt x  messages gt       lt x  messages  called g    gt  wrap x               lt x     gt    f takes an ordered pair of the form  lt x  messages gt  and returns an ordered pair  It leaves the first item untouched and appends  called f    to the second item  Same with g   You can compose these functions and get your original value  along with a string that shows which order the functions were called in     f g wrap x      f g  lt x     gt      f  lt x   called g    gt      lt x   called g  called f    gt    You dislike the fact that f and g are responsible for appending their own log messages to the previous logging information   Just imagine for the sake of argument that instead of appending strings  f and g must perform complicated logic on the second item of the pair  It would be a pain to repeat that complicated logic in two -- or more -- different functions    You prefer to write simpler functions   f x         lt x   called f    gt  g x         lt x   called g    gt  wrap x      lt x     gt    But look at what happens when you compose them     f g wrap x      f g  lt x     gt      f  lt  lt x     gt    called g    gt      lt  lt  lt x     gt    called g    gt    called f    gt    The problem is that passing a pair into a function does not give you what you want  But what if you could feed a pair into a function     feed f  feed g  wrap x      feed f  feed g   lt x     gt      feed f   lt x   called g    gt      lt x   called g  called f    gt    Read feed f  m  as  feed m into f   To feed a pair  lt x  messages gt  into a function f is to pass x into f  get  lt y  message gt  out of f  and return  lt y  messages message gt    feed f   lt x  messages gt      let  lt y  message gt    f x                            in   lt y  messages message gt    Notice what happens when you do three things with your functions   First  if you wrap a value and then feed the resulting pair into a function     feed f  wrap x     feed f   lt x     gt     let  lt y  message gt    f x    in   lt y     message gt    let  lt y  message gt     lt x   called f    gt    in   lt y     message gt     lt x      called f    gt     lt x   called f    gt    f x    That is the same as passing the value into the function   Second  if you feed a pair into wrap     feed wrap   lt x  messages gt     let  lt y  message gt    wrap x    in   lt y  messages message gt    let  lt y  message gt     lt x     gt    in   lt y  messages message gt     lt x  messages    gt     lt x  messages gt    That does not change the pair   Third  if you define a function that takes x and feeds g x  into f   h x     feed f  g x     and feed a pair into it     feed h   lt x  messages gt     let  lt y  message gt    h x    in   lt y  messages message gt    let  lt y  message gt    feed f  g x     in   lt y  messages message gt    let  lt y  message gt    feed f   lt x   called g    gt     in   lt y  messages message gt    let  lt y  message gt    let  lt z  msg gt    f x                       in   lt z   called g    msg gt    in  lt y  messages message gt    let  lt y  message gt    let  lt z  msg gt     lt x   called f    gt                       in   lt z   called g    msg gt    in  lt y  messages message gt    let  lt y  message gt     lt x   called g     called f    gt    in  lt y  messages message gt     lt x  messages  called g     called f    gt    feed f   lt x  messages  called g    gt     feed f  feed g   lt x  messages gt      That is the same as feeding the pair into g and feeding the resulting pair into f   You have most of a monad  Now you just need to know about the data types in your program   What type of value is  lt x   called f    gt   Well  that depends on what type of value x is  If x is of type t  then your pair is a value of type  pair of t and string   Call that type M t   M is a type constructor  M alone does not refer to a type  but M   refers to a type once you fill in the blank with a type  An M int is a pair of an int and a string  An M string is a pair of a string and a string  Etc   Congratulations  you have created a monad   Formally  your monad is the tuple  lt M  feed  wrap gt    A monad is a tuple  lt M  feed  wrap gt  where    M is a type constructor  feed takes a  function that takes a t and returns an M u  and an M t and returns an M u  wrap takes a v and returns an M v    t  u  and v are any three types that may or may not be the same  A monad satisfies the three properties you proved for your specific monad    Feeding a wrapped t into a function is the same as passing the unwrapped t into the function   Formally  feed f  wrap x     f x  Feeding an M t into wrap does nothing to the M t   Formally  feed wrap  m    m Feeding an M t  call it m  into a function that   passes the t into g gets an M u  call it n  from g feeds n into f   is the same as   feeding m into g getting n from g feeding n into f   Formally  feed h  m    feed f  feed g  m   where h x     feed f  g x     Typically  feed is called bind  AKA  gt  gt   in Haskell  and wrap is called return

User · Answer

Disclaimer  I am still trying to fully grok monads  The following is just what I have understood so far  If it   s wrong  hopefully someone knowledgeable will call me on the carpet    Arnar wrote      Monads are simply a way to wrapping things and provide methods to do operations on the wrapped stuff without unwrapping it    That   s precisely it  The idea goes like this    You take some kind of value and wrap it with some additional information  Just like the value is of a certain kind  eg  an integer or a string   so the additional information is of a certain kind   E g   that extra information might be a Maybe or an IO  Then you have some operators that allow you to operate on the wrapped data while carrying along that additional information  These operators use the additional information to decide how to change the behaviour of the operation on the wrapped value   E g   a Maybe Int can be a Just Int or Nothing  Now  if you add a Maybe Int to a Maybe Int  the operator will check to see if they are both Just Ints inside  and if so  will unwrap the Ints  pass them the addition operator  re-wrap the resulting Int into a new Just Int  which is a valid Maybe Int   and thus return a Maybe Int  But if one of them was a Nothing inside  this operator will just immediately return Nothing  which again is a valid Maybe Int  That way  you can pretend that your Maybe Ints are just normal numbers and perform regular math on them  If you were to get a Nothing  your equations will still produce the right result     without you having to litter checks for Nothing everywhere    But the example is just what happens for Maybe  If the extra information was an IO  then that special operator defined for IOs would be called instead  and it could do something totally different before performing the addition   OK  adding two IO Ints together is probably nonsensical     I   m not sure yet    Also  if you paid attention to the Maybe example  you have noticed that    wrapping a value with extra stuff    is not always correct  But it   s hard to be exact  correct and precise without being inscrutable    Basically     monad    roughly means    pattern     But instead of a book full of informally explained and specifically named Patterns  you now have a language construct     syntax and all     that allows you to declare new patterns as things in your program   The imprecision here is all the patterns have to follow a particular form  so a monad is not quite as generic as a pattern  But I think that   s the closest term that most people know and understand    And that is why people find monads so confusing  because they are such a generic concept  To ask what makes something a monad is similarly vague as to ask what makes something a pattern   But think of the implications of having syntactic support in the language for the idea of a pattern  instead of having to read the Gang of Four book and memorise the construction of a particular pattern  you just write code that implements this pattern in an agnostic  generic way once and then you are done  You can then reuse this pattern  like Visitor or Strategy or Fa  ade or whatever  just by decorating the operations in your code with it  without having to re-implement it over and over   So that is why people who understand monads find them so useful  it   s not some ivory tower concept that intellectual snobs pride themselves on understanding  OK  that too of course  teehee   but actually makes code simpler

User · Answer

I ve been thinking of Monads in a different way  lately  I ve been thinking of them as abstracting out execution order in a mathematical way  which makes new kinds of polymorphism possible   If you re using an imperative language  and you write some expressions in order  the code ALWAYS runs exactly in that order   And in the simple case  when you use a monad  it feels the same -- you define a list of expressions that happen in order  Except that  depending on which monad you use  your code might run in order  like in IO monad   in parallel over several items at once  like in the List monad   it might halt partway through  like in the Maybe monad   it might pause partway through to be resumed later  like in a Resumption monad   it might rewind and start from the beginning  like in a Transaction monad   or it might rewind partway to try other options  like in a Logic monad    And because monads are polymorphic  it s possible to run the same code in different monads  depending on your needs   Plus  in some cases  it s possible to combine monads together  with monad transformers  to get multiple features at the same time

[haskell] What is a monad?

Examples related to haskell

Examples related to functional-programming

Examples related to monads

Examples related to terminology