anchor.diff:  
   [<Extension;Sealed>]
   type MPlus =
  -    [<Extension>]static member        MPlus (x :'T option, y, [<Optional>]mthd :MPlus) = match x with None -> y | xs -> xs
  -    [<Extension>]static member        MPlus (x :'T list  , y, [<Optional>]mthd :MPlus) = x @ y
  -    [<Extension>]static member        MPlus (x :'T []    , y, [<Optional>]mthd :MPlus) = Array.append x y
  -    [<Extension>]static member        MPlus (x :'T seq   , y, [<Optional>]mthd :MPlus) = Seq.append   x y
  -    [<Extension>]static member inline MPlus (x :'T Id    , y, [<Optional>]mthd :MPlus) = Id (Append.Invoke (Id.run x) (Id.run y))
  +    [<Extension>]static member        MPlus (x :'T option, y, [<Optional>]mthd : MPlus) = match x with None -> y | xs -> xs
  +    [<Extension>]static member        MPlus (x :'T list  , y, [<Optional>]mthd : MPlus) = x @ y
  +    [<Extension>]static member        MPlus (x :'T []    , y, [<Optional>]mthd : MPlus) = Array.append x y
  +    [<Extension>]static member        MPlus (x :'T seq   , y, [<Optional>]mthd : MPlus) = Seq.append   x y
  +    [<Extension>]static member inline MPlus (x :'T Id    , y, [<Optional>]mthd : MPlus) = Id (Append.Invoke (Id.run x) (Id.run y))
   
       static member inline Invoke (x:'``FunctorPlus<'T>``) (y:'``FunctorPlus<'T>``)  : '``FunctorPlus<'T>`` =
           let inline call (mthd : ^M, input1 : ^I, input2 : ^I) = ((^M or ^I) : (static member MPlus: _*_*_ -> _) input1, input2, mthd)
  
positive.code: 
  
  type Contramap =
      static member Contramap (g:_->'R             , f:'U->'T) = (<<) g f
      static member Contramap (p:Predicate<_>      , f:'U->'T) = Predicate(fun x -> p.Invoke(f x))
      
      static member inline Invoke (f:'U->'T) (x:'``Contravariant<'T>``) : '``Contravariant<'U>`` = 
          let inline call (mthd : ^M, source : ^I, c:^c, f) = ((^M or ^I or ^c) : (static member Contramap: _*_ -> _) source, f)
          call (Unchecked.defaultof<Contramap>, x, Unchecked.defaultof<'``Contravariant<'U>``>, f)
  
  
  // Bifunctor class --------------------------------------------------------
  
negative.code:     static member inline Map (x : '``Applicative<'T>``, f : 'T->'U, [<Optional>]impl:Default2) = Apply.InvokeOnInstance (Return.InvokeOnInstance f) x : '``Applicative<'U>``
      static member inline Map (x : '``Functor<'T>``    , f : 'T->'U, [<Optional>]impl:Default1) = Map.InvokeOnInstance f x : '``Functor<'U>``
  
      static member Map (x : Lazy<_>        , f : 'T->'U, [<Optional>]mthd : Map) = Lazy.Create (fun () -> f x.Value)   : Lazy<'U>
      static member Map (x : seq<_>         , f : 'T->'U, [<Optional>]mthd : Map) = Seq.map f x                         : seq<'U>
      static member Map (x : option<_>      , f : 'T->'U, [<Optional>]mthd : Map) = Option.map  f x
      static member Map (x : list<_>        , f : 'T->'U, [<Optional>]mthd : Map) = List.map f x                        : list<'U>
      static member Map (g : 'R->'T         , f : 'T->'U, [<Optional>]mthd : Map) = (>>) g f
      static member Map ((m : 'Monoid, a)   , f : 'T->'U, [<Optional>]mthd : Map) = (m, f a)
      static member Map (x : _ []           , f : 'T->'U, [<Optional>]mthd : Map) = Array.map   f x
      static member Map (x : _ [,]          , f : 'T->'U, [<Optional>]mthd : Map) = Array2D.map f x
      static member Map (x : _ [,,]         , f : 'T->'U, [<Optional>]mthd : Map) = Array3D.map f x
      static member Map (x : _ [,,,]        , f : 'T->'U, [<Optional>]mthd : Map) = Array4D.init (x.GetLength 0) (x.GetLength 1) (x.GetLength 2) (x.GetLength 3) (fun a b c d -> f x.[a,b,c,d])
      static member Map (x : Async<_>       , f : 'T->'U, [<Optional>]mthd : Map) = async.Bind(x, async.Return << f)
      static member Map (x : Choice<_,'E>   , f : 'T->'U, [<Optional>]mthd : Map) = Error.map f x
      static member Map (KeyValue(k, x)     , f : 'T->'U, [<Optional>]mthd : Map) = KeyValuePair(k, f x)
      static member Map (x : Map<'Key,'T>   , f : 'T->'U, [<Optional>]mthd : Map) = Map.map (const' f) x : Map<'Key,'U>
      static member Map (x : Dictionary<_,_>, f : 'T->'U, [<Optional>]mthd : Map) = let d = Dictionary() in Seq.iter (fun (KeyValue(k, v)) -> d.Add(k, f v)) x; d: Dictionary<'Key,'U>
      static member Map (x : Expr<'T>       , f : 'T->'U, [<Optional>]mthd : Map) = Expr.Cast<'U>(Expr.Application(Expr.Value(f),x))
      static member Map (x : ResizeArray<'T>, f : 'T->'U, [<Optional>]mthd : Map) = ResizeArray(Seq.map f x) : ResizeArray<'U>
      static member Map (x : IObservable<'T>, f : 'T->'U, [<Optional>]mthd : Map) = Observable.map f x
  
      // Restricted
      static member Map (x : string         , f, [<Optional>]mthd : Map) = String.map f x
      static member Map (x : StringBuilder  , f, [<Optional>]mthd : Map) = new StringBuilder(String.map f (x.ToString()))
      static member Map (x : Set<_>         , f, [<Optional>]mthd : Map) = Set.map f x
          
  
  
  type MZero =
      static member        MZero ([<Optional>]output : option<'T>, [<Optional>]mthd : MZero) = None                   : option<'T>
      static member        MZero ([<Optional>]output : list<'T>  , [<Optional>]mthd : MZero) = [  ]                   : list<'T>  
      static member        MZero ([<Optional>]output : 'T []     , [<Optional>]mthd : MZero) = [||]                   : 'T []     
      static member        MZero ([<Optional>]output : seq<'T>   , [<Optional>]mthd : MZero) = Seq.empty              : seq<'T>
      static member inline MZero ([<Optional>]output : Id<'T>    , [<Optional>]mthd : MZero) = Id (Empty.Invoke())    : Id<'T>
  
      static member inline Invoke () : '``FunctorZero<'T>`` =
          let inline call (mthd : ^M, output : ^R) = ((^M or ^R) : (static member MZero: _*_ -> _) output, mthd)
  