anchor.diff:      /// <returns>The result sequence.</returns>
       ///
       /// <exception cref="System.ArgumentNullException">Thrown when the input sequence is null.</exception>
  -    let inline limit (count:int) (source:'Collection'T) : 'Collection'T = Limit.Invoke count source
  -
  -    let inline fromList (source :list<'t>) = FromList.Invoke source
  -    let inline fromSeq  (source :seq<'t> ) = FromSeq.Invoke  source
  -
  -    let inline groupBy    (projection:'T->'Key) (source:'Collection'T) : 'Collection'KeyX'Collection'T = GroupBy.Invoke projection source
  -    let inline groupAdjBy (projection:'T->'Key) (source:'Collection'T) : 'Collection'KeyX'Collection'T = GroupAdjBy.Invoke projection source
  -
  -
  -    let inline choose (chooser:'T->'U option)   (source:'Collection'T)        = Choose.Invoke chooser source    :'Collection'U
  -
  -    let inline distinct                         (source:'Collection'T)        = Distinct.Invoke              source  :'Collection'T
  -    let inline distinctBy (projection:'T->'Key) (source:'Collection'T)        = DistinctBy.Invoke projection source  :'Collection'T
  -    
  -    let inline head                             (source:'Collection'T)        = Head.Invoke source    :'T
  -    let inline tryHead                          (source:'Collection'T)        = TryHead.Invoke source :'T option
  -
  -    let inline intersperse      (sep:'T)        (source:'Collection'T)        = Intersperse.Invoke sep source        :'Collection'T
  -
  -    let inline length (source:'Collection'T)                                  = Length.Invoke source      :int
  -
  -    let inline maxBy (projection:'T->'U) (source:'Collection'T)               = MaxBy.Invoke projection  source    :'T
  -    let inline minBy (projection:'T->'U) (source:'Collection'T)               = MinBy.Invoke projection  source    :'T
  -
  -    let inline rev  (source:'Collection'T)                                    = Rev.Invoke source :'Collection'T
  -    let inline scan (folder:'State'->'T->'State) state (source:'Collection'T) = Scan.Invoke folder (state:'State) source :'Collection'State
  -
  -    let inline sort                         (source:'Collection'T) :'Collection'T = Sort.Invoke source 
  -    let inline sortBy (projection:'T->'Key) (source:'Collection'T) :'Collection'T = SortBy.Invoke projection source
  -    let inline toSeq (source:'Collection'T) = ToSeq.Invoke source  :seq<'T>
  -
  -    let inline zip (source1:'Collection'T1) (source2:'Collection'T2)          = Zip.Invoke source1 source2     :'Collection'T1'T2
  +    let inline limit (count:int) (source:'``Collection<'T>``) : '``Collection<'T>`` = Limit.Invoke count source
  +
  +    let inline fromList (source :list<'T>) = FromList.Invoke source
  +    let inline fromSeq  (source :seq<'T> ) = FromSeq.Invoke  source
  +
  +    let inline groupBy    (projection:'T->'Key) (source:'``Collection<'T>``) : '``Collection<'Key * 'Collection<'T>>`` = GroupBy.Invoke projection source
  +    let inline groupAdjBy (projection:'T->'Key) (source:'``Collection<'T>``) : '``Collection<'Key * 'Collection<'T>>`` = GroupAdjBy.Invoke projection source
  +
  +
  +    let inline choose (chooser:'T->'U option)   (source:'``Collection<'T>``) : '``Collection<'U>`` = Choose.Invoke chooser source        
  +
  +    let inline distinct                         (source:'``Collection<'T>``) : '``Collection<'T>`` = Distinct.Invoke              source 
  +    let inline distinctBy (projection:'T->'Key) (source:'``Collection<'T>``) : '``Collection<'T>`` = DistinctBy.Invoke projection source 
  +    
  +    let inline head                             (source:'``Collection<'T>``)        = Head.Invoke source    :'T
  +    let inline tryHead                          (source:'``Collection<'T>``)        = TryHead.Invoke source :'T option
  +
  +    let inline intersperse      (sep:'T)        (source:'``Collection<'T>``)        = Intersperse.Invoke sep source        : '``Collection<'T>``
  +
  +    let inline length (source:'``Collection<'T>``) :int                             = Length.Invoke source
  +
  +    let inline maxBy (projection:'T->'U) (source:'``Collection<'T>``)               = MaxBy.Invoke projection  source    : 'T
  +    let inline minBy (projection:'T->'U) (source:'``Collection<'T>``)               = MinBy.Invoke projection  source    : 'T
  +
  +    let inline rev  (source:'``Collection<'T>``)                                    = Rev.Invoke source :'``Collection<'T>``
  +    let inline scan (folder:'State'->'T->'State) state (source:'``Collection<'T>``) = Scan.Invoke folder (state:'State) source : '``Collection<'State>``
  +
  +    let inline sort                         (source:'``Collection<'T>``) : '``Collection<'T>`` = Sort.Invoke source 
  +    let inline sortBy (projection:'T->'Key) (source:'``Collection<'T>``) : '``Collection<'T>`` = SortBy.Invoke projection source
  +    let inline toSeq (source:'``Collection<'T>``) = ToSeq.Invoke source  :seq<'T>
  +
  +    let inline zip (source1:'``Collection<'T1>``) (source2:'``Collection<'T2>``) : '``Collection<'T1 * 'T2>`` = Zip.Invoke source1 source2    
   
   
   
  
positive.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
  
negative.code:     // Functor ----------------------------------------------------------------
  
      /// Lift a function into a Functor.
      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
  
      /// 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
  
      /// Like map but ignoring the results.
      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
  
      /// 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>``
  
      /// 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<'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:'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 -----------------------------------------------------------------
  