anchor.diff:      // Functor ----------------------------------------------------------------
   
       /// Lift a function into a Functor.
  -    let inline map    (f:'T->'U) (x:'Functor'T) :'Functor'U = Map.Invoke f x
  +    let inline map    (f:'T->'U) (x:'``Functor<'T>``) :'``Functor<'U>`` = Map.Invoke f x
   
       /// Lift a function into a Functor. Same as map.
  -    let inline (<!>)  (f:'T->'U) (x:'Functor'T) :'Functor'U = Map.Invoke f x
  +    let inline (<!>)  (f:'T->'U) (x:'``Functor<'T>``) :'``Functor<'U>`` = Map.Invoke f x
   
       /// Lift a function into a Functor. Same as map but with flipped arguments.
  -    let inline (|>>)  (x:'Functor'T) (f:'T->'U) :'Functor'U = Map.Invoke f x
  +    let inline (|>>)  (x:'``Functor<'T>``) (f:'T->'U) :'``Functor<'U>`` = Map.Invoke f x
   
       /// Like map but ignoring the results.
  -    let inline iter   (action :'T->unit) (source :'Functor'T) = Iterate.Invoke action source :unit
  +    let inline iter   (action :'T->unit) (source :'``Functor<'T>``) :unit = Iterate.Invoke action source
      
   
       // Applicative ------------------------------------------------------------
   
       /// Lift a value into a Functor. Same as return in Computation Expressions.
  -    let inline result (x:'T): 'Functor'T = Return.Invoke x
  +    let inline result (x:'T): '``Functor<'T>`` = Return.Invoke x
   
       /// Apply a lifted argument to a lifted function.
  -    let inline (<*>) (x:'Applicative'T_'U) (y:'Applicative'T): 'Applicative'U = Apply.Invoke x y : 'Applicative'U
  +    let inline (<*>) (x:'``Applicative<'T -> 'U>``) (y:'``Applicative<'T>``): '``Applicative<'U>`` = Apply.Invoke x y : '``Applicative<'U>``
   
       /// Apply 2 lifted arguments to a lifted function.
  -    let inline liftA2 (f:'T->'U->'V) (a:'Applicative'T) (b:'Applicative'U) :'Applicative'V = f <!> a <*> b
  -
  -    let inline (  *>) (x:'Applicative'a) :'Applicative'b->'Applicative'b = x |> liftA2 (fun   _ -> id)
  -    let inline (<*  ) (x:'Applicative'a) :'Applicative'b->'Applicative'a = x |> liftA2 (fun k _ -> k )
  -    let inline (<**>) (x:'Applicative'a): 'Applicative'a_'b->'Applicative'b = x |> liftA2 (|>)
  -    let inline optional (v:'Alternative'a) :'Alternative'Option'a = Some <!> v <|> result None
  +    let inline liftA2 (f:'T->'U->'V) (a:'``Applicative<'T>``) (b:'``Applicative<'U>``) : '``Applicative<'V>`` = f <!> a <*> b
  +
  +    let inline (  *>)   (x:'``Applicative<'T>``) : '``Applicative<'U>``->'``Applicative<'U>`` = x |> liftA2 (fun   _ -> id)
  +    let inline (<*  )   (x:'``Applicative<'T>``) : '``Applicative<'U>``->'``Applicative<'T>`` = x |> liftA2 (fun k _ -> k )
  +    let inline (<**>)   (x:'``Applicative<'T>``) : '``Applicative<'T -> 'U>``->'``Applicative<'U>`` = x |> liftA2 (|>)
  +    let inline optional (v:'``Applicative<'T>``) : '``Applicative<Option'T>`` = Some <!> v <|> result None
   
   
       // Monad -----------------------------------------------------------
       
  -    let inline (>>=) (x:'Monad'T) (f:'T->'Monad'U) :'Monad'U = Bind.Invoke x f
  -    let inline (=<<) (f:'T->'Monad'U) (x:'Monad'T) :'Monad'U = Bind.Invoke x f
  -    let inline (>=>) (f:'a->'Monad'b) (g:'b->'Monad'c) (x:'a) :'Monad'c = Bind.Invoke (f x) g
  -    let inline (<=<) (g:'b->'Monad'c) (f:'a->'Monad'b) (x:'a) :'Monad'c = Bind.Invoke (f x) g
  -    let inline join (x:'Monad'Monad'T) :'Monad'T = Join.Invoke x
  +    let inline (>>=) (x:'``Monad<'T>``) (f:'T->'``Monad<'U>``) :'``Monad<'U>`` = Bind.Invoke x f
  +    let inline (=<<) (f:'T->'``Monad<'U>``) (x:'``Monad<'T>``) :'``Monad<'U>`` = Bind.Invoke x f
  +    let inline (>=>) (f:'T->'``Monad<'U>``) (g:'U->'``Monad<'V>``) (x:'T) : '``Monad<'V>`` = Bind.Invoke (f x) g
  +    let inline (<=<) (g:'b->'``Monad<'V>``) (f:'T->'``Monad<'U>``) (x:'T) : '``Monad<'V>`` = Bind.Invoke (f x) g
  +    let inline join  (x:'``Monad<Monad<'T>>``) : '``Monad<'T>`` = Join.Invoke x
   
   
       // Monoid -----------------------------------------------------------------
  
positive.code:     /// <param name="source">The input collection.</param>
      ///
      /// <returns>The result collection.</returns>
      let inline drop  (count:int) (source:'Collection'T) : 'Collection'T = Drop.Invoke count source
  
      /// <summary>Returns a collection with at most N elements.</summary>
      ///
  
negative.code: 
      // Alternative/Monadplus/Arrowplus ----------------------------------------
  
      let inline mzero() :'``Functor<'T>`` = Mzero.Invoke()
      let inline (<|>) (x:'``Functor<'T>``) (y:'``Functor<'T>``) : '``Functor<'T>`` = Mplus.Invoke x y
      let inline guard x: '``MonadPlus<unit>`` = if x then Return.Invoke () else Mzero.Invoke()
  
     
      // Contravariant/Bifunctor/Profunctor -------------------------------------
  
      let inline contramap (f:'T->'U) (x:'``Contravariant<'U>``) :'``Contravariant<'T>`` = Contramap.Invoke f x
      let inline bimap f g x = Bimap.Invoke x f g
      let inline first   f x = First.Invoke f x
      let inline second  f x = Second.Invoke f x
  