anchor.diff:      [<Extension>]static member        Join (x:Task<Task<'a>>    , [<Optional>]output:Task<'a>  , [<Optional>]impl:Join) = x.Unwrap()
   #endif
   
  -    static member inline Invoke (x:'Monad'Monad'a) : 'Monad'a =
  -        let inline call_3 (a:^a, b:^b, c:^c) = ((^a or ^b or ^c) : (static member Join: _*_*_ -> _) b, c, a)
  -        let inline call (a:'a, b:'b) = call_3 (a, b, Unchecked.defaultof<'r>):'r
  -        call (Unchecked.defaultof<Join>, x)
  +    static member inline Invoke (x:'``Monad<Monad<'T>>``) : '``Monad<'T>`` =
  +        let inline call (mthd : 'M, input : 'I, output : 'R) = ((^M or ^I or ^R) : (static member Join: _*_*_ -> _) input, output, mthd)
  +        call (Unchecked.defaultof<Join>, x, Unchecked.defaultof<'``Monad<'T>``>)
   
   
   type Return =
       inherit Default1
   
  -    static member inline Invoke x = 
  -        let inline call_2 (a:^a,b:^b) = ((^a or ^b) : (static member Return: _*_ -> _) b, a)
  -        call_2 (Unchecked.defaultof<Return>, Unchecked.defaultof<'r>) x :'r 
  -
  -    static member inline InvokeOnInstance (x:'T) = ((^R) : (static member Return: ^T -> ^R) x)
  -
  -    static member inline Return (r:'R    , _:Default1) = fun (x:'T) -> Return.InvokeOnInstance x :'R
  +    static member inline Invoke (x:'T) : '``Applicative<'T>`` =
  +        let inline call (mthd : ^M, output : ^R) = ((^M or ^R) : (static member Return: _*_ -> _) output, mthd)
  +        call (Unchecked.defaultof<Return>, Unchecked.defaultof<'``Applicative<'T>``>) x
  + 
  +    static member inline InvokeOnInstance (x:'T) = (^``Applicative<'T>`` : (static member Return: ^T -> ^``Applicative<'T>``) x)
  +
  +    static member inline Return (r:'R, _:Default1) = fun (x:'T) -> Return.InvokeOnInstance x :'R
  +
       static member        Return (_:Lazy<'a>, _:Return) = fun x -> Lazy.CreateFromValue x : Lazy<'a>
       static member        Return (_:seq<'a> , _:Return) = fun x -> Seq.singleton x :seq<'a>
       static member        Return (_:Id<'a>  , _:Return) = fun x -> Id x :Id<'a>
  
positive.code:     static member inline FromApplicative f x = Return.Invoke (Apply.Invoke f x)
      static member inline FromMonad       f x = Bind.Invoke x (Return.Invoke << f)
  
      [<Extension>]static member inline Map (x:'f, (f:'a->'b), [<Optional>]impl:Default2) = Return.Invoke (Apply.Invoke f x) :'r
      [<Extension>]static member inline Map (x:'F, (f:'a->'b), [<Optional>]impl:Default1) = ((^F) : (static member Map: ^F * ('a->'b) -> ^R) (x, f))
  
      [<Extension>]static member Map (x:Lazy<_>        , f, [<Optional>]impl:Map) = Lazy.Create (fun () -> f x.Value) : Lazy<'b>
      [<Extension>]static member Map (x:seq<_>         , f, [<Optional>]impl:Map) = Seq.map f x :seq<'b>
  
negative.code:     static member Return (_:StringBuilder, _:Return) = fun (x:char) -> new StringBuilder(string x):StringBuilder
      static member Return (_:'a Set       , _:Return) = fun (x:'a  ) -> Set.singleton x
  
  [<Extension;Sealed>]
  type Apply =
      inherit Default1
      
      [<Extension>]static member inline Apply (f:'``Monad<'T->'U>``  , x:'``Monad<'T>``  , [<Optional>]output:'``Monad<'U>``  , [<Optional>]impl:Default2) : '``Monad<'U>``   = Bind.InvokeOnInstance f (fun (x1:'T->'U) -> Bind.InvokeOnInstance x (fun x2 -> Return.Invoke(x1 x2)))
      [<Extension>]static member inline Apply (f:'``Applicative<'T->'U>``, x:'``Applicative<'T>``, [<Optional>]output:'``Applicative<'U>``, [<Optional>]impl:Default1) : '``Applicative<'U>`` = ((^``Applicative<'T->'U>`` or ^``Applicative<'T>`` or ^``Applicative<'U>``) : (static member (<*>): _*_ -> _) f, x)
  
      [<Extension>]static member        Apply (f:Lazy<'a->'b>, x:Lazy<'a>     , [<Optional>]output:Lazy<'b>     , [<Optional>]impl:Apply) = Lazy.Create (fun () -> f.Value x.Value) : Lazy<'b>
      [<Extension>]static member        Apply (f:seq<_>      , x:seq<'a>      , [<Optional>]output:seq<'b>      , [<Optional>]impl:Apply) = Seq.apply  f x :seq<'b>
  