anchor.diff:          member inline x.Combine(a, b) = mplus a b
       
       let monad     = new MonadBuilder()
  -    let monadPlus = new MonadPlusBuilder()+    let monadPlus = new MonadPlusBuilder()
  
positive.code: 
  
      // Functor ----------------------------------------------------------------
      let inline map f x = Inline.instance (Functor.Map, x) f
  
  
      // Applicative ------------------------------------------------------------
      let inline result x  = Inline.instance Applicative.Pure x
      let inline (<*>) x y = Inline.instance (Applicative.Ap, x, y) ()
      let inline empty() = Inline.instance Alternative.Empty ()
      let inline (<|>) (x:'a) (y:'a) :'a = Inline.instance (Alternative.Append, x) y
      let inline (<!>)  f a   = map f a
      let inline liftA2 f a b = f <!> a <*> b
      let inline (  *>)   x   = x |> liftA2 (konst id)
      let inline (<*  )   x   = x |> liftA2  konst
      let inline (<**>)   x   = x |> liftA2 (|>)
      let inline optional v = Some <<|> v <|> result None
  
  
      // ZipList
  
negative.code: 
  
      // Monad -----------------------------------------------------------
      let inline (>>=) (x:'Monad'a) (f:'a->'Monad'b) :'Monad'b = Inline.instance (Monad.Bind, x) f
      let inline (=<<) (f:'a->'Monad'b) (x:'Monad'a) :'Monad'b = Inline.instance (Monad.Bind, x) f
      let inline join (x:'Monad'Monad'a) :'Monad'a =  x >>= id
  
  
      // Monoid -----------------------------------------------------------------
      let inline mempty() :'Monoid = Inline.instance Monoid.Mempty ()
      let inline mappend (x:'Monoid) (y:'Monoid) :'Monoid = Inline.instance (Monoid.Mappend, x) y
      let inline mconcat (x:List<'Monoid>) :'Monoid  =
          let foldR f s lst = List.foldBack f lst s
          foldR mappend (mempty()) x
  
  
      // Monad plus -------------------------------------------------------------
      let inline sequence (ms:List<'Monad'a>) :'Monad'List'a =
          let k m m' = m >>= fun (x:'Monad'a) -> m' >>= fun xs -> (result :list<'Monad'a> -> 'Monad'List'a) (List.Cons(x,xs))
          List.foldBack k ms ((result :list<'Monad'a> -> 'Monad'List'a) [])
  
      let inline mapM   (f:'a->'Monad'b) (xs:List<'a>) :'Monad'List'b = sequence (List.map f xs)
      let inline liftM  (f:'a->'b) (m1:'Monad'a) :'Monad'b = m1 >>= (result << f)
      let inline liftM2 (f:'a1->'a2->'r) (m1:'Monad'a1) (m2:'Monad'a2) :'Monad'r = m1 >>= fun x1 -> m2 >>= fun x2 -> result (f x1 x2)
      let inline ap (x:'Monad'a_'b) (y:'Monad'a): 'Monad'b = liftM2 id x y
  
      let inline (>=>)  (f:'a->'Monad'b) (g:'b->'Monad'c) (x:'a) :'Monad'c = f x >>= g
      let inline (<=<)  (g:'b->'Monad'c) (f:'a->'Monad'b) (x:'a) :'Monad'c = f x >>= g
  
      let inline mzero() :'MonadPlus'a = Inline.instance MonadPlus.Mzero ()
      let inline mplus (x:'MonadPlus'a) (y:'MonadPlus'a) :'MonadPlus'a = Inline.instance (MonadPlus.Mplus, x) y
      let inline guard x: 'MonadPlus'unit = if x then result () else mzero()
  
  
      // Arrows -----------------------------------------------------------------
  