anchor.diff:      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))
  +    static member inline Invoke (mapping :'T->'U) (source : '``Functor<'T>``) : '``Functor<'U>`` = 
  +        let inline call (mthd : ^M, source : ^I1, output : ^R) = ((^M or ^I1 or ^R) : (static member Map: _*_*_ -> _) source, mapping, mthd)
  +        call (Unchecked.defaultof<Map>, source, Unchecked.defaultof<'``Functor<'U>``>)
  +
  +    static member inline InvokeOnInstance (mapping :'T->'U) (source : '``Functor<'T>``) : '``Functor<'U>`` = 
  +        (^``Functor<'T>`` : (static member Map: _ * _ -> _) source, mapping)
  +
  +    [<Extension>]static member inline Map (x : '``Applicative<'T>``, f : 'T->'U, [<Optional>]impl:Default2) = Return.Invoke (Apply.Invoke f x) : '``Applicative<'U>``
  +    [<Extension>]static member inline Map (x : '``Functor<'T>``    , f : 'T->'U, [<Optional>]impl:Default1) = Map.InvokeOnInstance f x : '``Functor<'U>``
   
       [<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>
  
positive.code:     [<Extension>]static member Map (x:StringBuilder  , f, [<Optional>]impl:Map) = new StringBuilder(String.map f (x.ToString()))
      [<Extension>]static member Map (x:Set<_>         , f, [<Optional>]impl:Map) = Set.map f x
          
      static member inline Invoke (f:_->_) x = 
          let inline call_3 (a:^a, b:^b, c:^c, f) = ((^a or ^b or ^c) : (static member Map: _*_*_ -> _) b, f, a)
          let inline call (a:'a, b:'b, f) = call_3 (a, b, Unchecked.defaultof<'r>, f) :'r
          call (Unchecked.defaultof<Map>, x, f)
  
  
  type MZero =
  
negative.code:     [<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<'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:'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>
  