anchor.diff:  
   
       // Foldable
  -    let inline foldr (f: 'a -> 'b -> 'b) (z:'b) x :'b = Inline.instance (Foldable.Foldr, x) (f,z)
  -    let inline foldMap f x = Inline.instance (Foldable.FoldMap, x) f
  +    let inline foldr  (f:'a->'b->'b) (z:'b) (x:'Foldable'a) :'b = Inline.instance (Foldable.Foldr  , x) (f,z)
  +    let inline foldMap (f:'a->'Monoid) (x:'Foldable'a) :'Monoid = Inline.instance (Foldable.FoldMap, x) f
   
   
       // Traversable
  -    let inline traverse f t = Inline.instance (Traversable.Traverse, t) f
  -    let inline sequenceA  x = traverse id x
  +    let inline traverse  (f:'a->'Applicative'b) (t:'Traversable'a) : 'Applicative'Traversable'b = Inline.instance (Traversable.Traverse, t) f
  +    let inline sequenceA (x:'Traversable'Applicative'a) : 'Applicative'Traversable'a = traverse id x
   
   
       // Comonads
  -    let inline extract   x = Inline.instance (Comonad.Extract  , x) ()
  -    let inline duplicate x = Inline.instance (Comonad.Duplicate, x) ()
  -    let inline extend  g s = map g (duplicate s)
  -    let inline (=>>)   s g = map g (duplicate s)
  +    let inline extract   (x:'Comonad'a): 'a = Inline.instance (Comonad.Extract, x) ()
  +    let inline duplicate (x:'Comonad'a): 'Comonad'Comonad'a = Inline.instance (Comonad.Duplicate, x) ()
  +    let inline extend  (g:'Comonad'a->'b) (s:'Comonad'a): 'Comonad'b = map g (duplicate s)
  +    let inline (=>>)   (s:'Comonad'a) (g:'Comonad'a->'b): 'Comonad'b = map g (duplicate s)
   
   
       // Monad Transformers
  -    let inline lift (x:'ma) = Inline.instance MonadTrans.Lift x
  -    let inline liftIO (x: Async<'a>) = Inline.instance MonadAsync.LiftAsync x
  -    let inline callCC f = Inline.instance MonadCont.CallCC f
  -    let inline get() = Inline.instance MonadState.Get ()
  -    let inline put x = Inline.instance MonadState.Put x
  -    let inline ask()     = Inline.instance  MonadReader.Ask ()
  -    let inline local f m = Inline.instance (MonadReader.Local, m) f
  -    let inline tell    x = Inline.instance  MonadWriter.Tell x
  -    let inline listen  m = Inline.instance (MonadWriter.Listen, m) ()
  -    let inline pass    m = Inline.instance (MonadWriter.Pass  , m) ()
  -    let inline throw x   = Inline.instance  MonadError.ThrowError x
  -    let inline catch v h = Inline.instance (MonadError.CatchError, v) h
  +    open FsControl.Core.Types
  +
  +    let inline lift   (x:'Monad'a ) : 'MonadTrans'Monad'a = Inline.instance MonadTrans.Lift x
  +    let inline liftIO (x:Async<'a>) : 'MonadAsync'a       = Inline.instance MonadAsync.LiftAsync x
  +
  +    let inline callCC (f:('a->'MonadCont'b)->'MonadCont'a): 'MonadCont'a = Inline.instance  MonadCont.CallCC f
  +    
  +    /// <summary>get    :: MonadState  s m => m s</summary>
  +    let inline get() :'ms = Inline.instance MonadState.Get ()
  +
  +    /// <summary>put    :: MonadState  s m => s -> m ()</summary>
  +    let inline put (x:'s) :'m = Inline.instance MonadState.Put x
  +
  +    /// <summary>ask    :: MonadReader r m => m r</summary>
  +    let inline ask() :'mr = Inline.instance  MonadReader.Ask ()
  +    
  +    /// <summary>local  :: MonadReader r m => (r -> r) -> m a -> m a</summary>
  +    let inline local (f:'rr) (m:'ma) :'ma = Inline.instance (MonadReader.Local, m) f
  +
  +    /// <summary>tell   :: MonadWriter w m => w   -> m ()</summary>
  +    let inline tell (x:'w) :'m = Inline.instance  MonadWriter.Tell x
  +
  +    /// <summary>listen :: MonadWriter w m => m a -> m (a,w)</summary>
  +    let inline listen (m:'ma) :'maw = Inline.instance (MonadWriter.Listen, m) ()
  +
  +    /// <summary>pass   :: MonadWriter w m => m (a, w -> w) -> m a</summary>
  +    let inline pass (m:'maww) :'ma = Inline.instance (MonadWriter.Pass  , m) ()
  +
  +    /// <summary>throw :: MonadError e m => e -> m a</summary>
  +    let inline throw (x:'e) :'ma = Inline.instance  MonadError.ThrowError x
  +
  +    /// <summary>catch :: MonadError e m => m a -> (e -> m b) -> m b</summary>
  +    let inline catch (v:'ma) (h:'e->'mb) :'mb = Inline.instance (MonadError.CatchError, v) h
   
   
       // Idiom brackets
  
positive.code: 
  
      // NonEmptyList
      type NonEmptyList<'T> = {Head: 'T; Tail: 'T list }
  
      [<RequireQualifiedAccess>]
      module NonEmptyList =
  
negative.code:         member inline x.Combine(a, b) = mplus a b
      
      let monad     = new MonadBuilder()
      let monadPlus = new MonadPlusBuilder()
  