anchor.diff:          let inline mapMaybeT f x = OptionT.map f x
           let runListT  = ListT.run
           let inline liftIO (x: IO<'a>) = liftAsync x
  +
               
           // ContT
           let runContT  = ContT.run
  +        type ContT = ContT
  +        let ContT = ContT.ContT
               
           // ReaderT
           let runReaderT = ReaderT.run
  +        type ReaderT = ReaderT
  +        let ReaderT = ReaderT.ReaderT
               
           // StateT
           let runStateT = StateT.run
  +        type StateT = StateT
  +        let StateT = StateT.StateT
               
           // MonadError
           let inline throwError x   = throw x
           let inline catchError v h = catch v h
               
           // ErrorT
  -        let runErrorT = ErrorT.run+        let runErrorT = ErrorT.run
  +        type ErrorT = ErrorT
  +        let ErrorT = ErrorT.ErrorT
positive.code:             
  
          // Cont
          let runCont = Cont.run
          let callCC' = Cont.callCC
          let inline when'  p s = if p then s else return' ()
          let inline unless p s = when' (not p) s
              
          // Reader
          let ask'      = Reader.ask
          let local'    = Reader.local
          let runReader = Reader.run
              
          // State
          let runState  = State.run
          let get'      = State.get
          let put'      = State.put
          let execState = State.exec
              
          // Monad Transformers
          type MaybeT<'T> = OptionT<'T>
  
negative.code:             if p a then return a else return! mzero()}
  
  
  
  
          // Arrow
  