anchor.diff:              
   
           // 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
  -            
  +
  +        let runCont = Cont.run
  +        type Cont = Cont
  +        let Cont = Cont.Cont
  +            
  +
           // Reader
  +
           let ask'      = Reader.ask
           let local'    = Reader.local
  +
           let runReader = Reader.run
  -            
  +        type Reader = Reader
  +        let Reader = Reader.Reader
  +            
  +
           // State
  -        let runState  = State.run
  +
           let get'      = State.get
           let put'      = State.put
           let execState = State.exec
  +
  +        let runState  = State.run
  +        type State = State
  +        let State = State.State
  +
               
           // Monad Transformers
           type MaybeT<'T> = OptionT<'T>
  
positive.code:         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
              
          // ReaderT
          let runReaderT = ReaderT.run
              
          // StateT
          let runStateT = StateT.run
              
          // MonadError
          let inline throwError x   = throw x
          let inline catchError v h = catch v h
              
          // ErrorT
          let runErrorT = ErrorT.run
negative.code:     module Haskell =
  
          // Types
          open FsControl.Core.Types
  
          let getDual (Dual x) = x
          type Dual<'t> = FsControl.Core.Types.Dual<'t>
          let Dual = Dual.Dual 
  
          let getAll (All x) = x
          type All  = All
          let All = All.All
  
          let getAny (Any x) = x
          type Any  = Any
          let Any = Any.Any
  
          let runKleisli (Kleisli f) = f
          type Kleisli<'t,'u> = FsControl.Core.Types.Kleisli<'t,'u>
          let Kleisli = Kleisli.Kleisli
  
          // Operatots
  