anchor.diff:      module Haskell =
   
           // Types
  -
  +        open FsControl.Core.Types
  +
  +        let getDual (Dual x) = x
           type Dual<'t> = FsControl.Core.Types.Dual<'t>
  -        let getDual (FsControl.Core.Types.Dual x) = x
           let Dual = Dual.Dual 
   
  -        type All  = FsControl.Core.Types.All
  -        let getAll (FsControl.Core.Types.All x) = x
  +        let getAll (All x) = x
  +        type All  = All
           let All = All.All
   
  -        type Any  = FsControl.Core.Types.Any
  -        let getAny (FsControl.Core.Types.Any x) = x
  +        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 runKleisli (Kleisli f) = f
           let Kleisli = Kleisli.Kleisli
   
           // Operatots
  
positive.code:             if p a then return a else return! mzero()}
  
  
          open FsControl.Core.Types
  
  
          // Arrow
  
negative.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
          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
          type ErrorT = ErrorT
          let ErrorT = ErrorT.ErrorT