anchor.diff:      /// <exception cref="System.ArgumentNullException">Thrown when the input collection is null.</exception>
       /// <exception cref="System.InvalidOperationException">Thrown when count exceeds the number of elements
       /// in the collection.</exception>
  -    let inline skip  (count:int) (source:'Collection'T) : 'Collection'T = Skip.Invoke count source
  +    let inline skip  (count:int) (source:'``Collection<'T>``) : '``Collection<'T>`` = Skip.Invoke count source
   
       /// <summary>Returns the first N elements of the collection.</summary>
       /// <remarks>Throws <c>InvalidOperationException</c>
  
positive.code: 
      // Foldable
  
      let inline foldBack (folder:'T->'State->'State) (foldable:'Foldable'T) (state:'State) :'State = FoldBack.Invoke folder state foldable
      let inline fold     (folder:'State->'T->'State) (state:'State) (foldable:'Foldable'T) :'State = Fold.Invoke folder state foldable
      let inline foldMap (f:'T->'Monoid) (x:'Foldable'T) :'Monoid = FoldMap.Invoke f x
      let inline toList  value :'t list = ToList.Invoke  value
      let inline toArray value :'t []   = ToArray.Invoke value
      let inline exists     (predicate :'T->bool) (source:'Foldable'T)   = Exists.Invoke  predicate source  :bool
      let inline forall     (predicate :'T->bool) (source:'Foldable'T)   = Forall.Invoke  predicate source  :bool
      let inline find       (predicate :'T->bool) (source:'Foldable'T)   = Find.Invoke    predicate source  :'T
      let inline tryFind    (predicate :'T->bool) (source:'Foldable'T)   = TryFind.Invoke predicate source  :'T option
      let inline pick     (chooser:'T->'U option) (source:'Foldable'T)   = Pick.Invoke    chooser   source  :'U
      let inline tryPick  (chooser:'T->'U option) (source:'Foldable'T)   = TryPick.Invoke chooser   source  :'U option
      let inline filter (predicate:_->bool) (x:'Foldable'a) :'Foldable'a =  Filter.Invoke predicate x
  
  
      // Traversable
  
      /// Map each element of a structure to an action, evaluate these actions from left to right, and collect the results.
      let inline traverse (f:'T->'Applicative'U) (t:'Traversable'T) :'Applicative'Traversable'U = Traverse.Invoke f t
  
      /// Evaluate each action in the structure from left to right, and and collect the results.
      let inline sequenceA (t:'Traversable'Applicative'T) :'Applicative'Traversable'T = SequenceA.Invoke t
  
  
      // Indexable
  
      /// Map with access to the index.
      let inline mapi (mapping:'K->'T->'U) (source:'FunctorWithIndex'T) = MapIndexed.Invoke mapping source  :'FunctorWithIndex'U
  
      /// Map an action with access to an index.
      let inline iteri (action:'K->'T->unit) (source:'FunctorWithIndex'T) = IterateIndexed.Invoke action source   :unit
  
      /// Left-associative fold of an indexed container with access to the index i.
      let inline foldi (folder:'State->'K->'T->'State) (state:'State) (source:'FoldableWithIndex'T) = FoldIndexed.Invoke folder state source :'State
      
      /// Traverse an indexed container. Behaves exactly like a regular traverse except that the traversing function also has access to the key associated with a value.
      let inline traversei (f:'K->'T->'Applicative'U) (t:'Traversable'T) :'Applicative'Traversable'U = TraverseIndexed.Invoke f t  
  
  
      // Comonads
  
      let inline extract (x:'Comonad'T): 'T = Extract.Invoke x
      let inline extend (g:'Comonad'T->'U) (s:'Comonad'T): 'Comonad'U = Extend.Invoke g s
      let inline (=>>)  (s:'Comonad'T) (g:'Comonad'T->'U): 'Comonad'U = Extend.Invoke g s
      let inline duplicate x = Duplicate.Invoke x //'Comonad'T -> :'Comonad'Comonad'T  
  
  
      // Monad Transformers
  
      let inline lift      (x:'Monad'T ) :'MonadTrans'Monad'T = Lift.Invoke x
  
      let inline liftAsync (x:Async<'T>) :'MonadAsync'T       = LiftAsync.Invoke x
  
      let inline callCC (f:('T->'MonadCont'U)->'MonadCont'T): 'MonadCont'T = CallCC.Invoke f
     
      /// <summary>Haskell signature: get    :: MonadState  s m => m s</summary>
      let inline get() :'ms = Get.Invoke()
  
      /// <summary>Haskell signature: put    :: MonadState  s m => s -> m ()</summary>
      let inline put (x:'s) :'m = Put.Invoke x
  
      /// <summary>Haskell signature: ask    :: MonadReader r m => m r</summary>
      let inline ask() :'mr = Ask.Invoke()
     
      /// <summary>Haskell signature: local  :: MonadReader r m => (r -> r) -> m a -> m a</summary>
      let inline local (f:'rr) (m:'ma) :'ma = Local.Invoke f m
  
      /// <summary>Haskell signature: tell   :: MonadWriter w m => w   -> m ()</summary>
      let inline tell (x:'w) :'m = Tell.Invoke x
  
      /// <summary>Haskell signature: listen :: MonadWriter w m => m a -> m (a,w)</summary>
      let inline listen (m:'ma) :'maw = Listen.Invoke m
  
      /// <summary>Haskell signature: pass   :: MonadWriter w m => m (a, w -> w) -> m a</summary>
      let inline pass (m:'maww) :'ma = Pass.Invoke m
  
      /// <summary>Haskell signature: throw :: MonadError e m => e -> m a</summary>
      let inline throw (x:'e) :'ma = ThrowError.Invoke x
  
      /// <summary> Pure version of catch. Executes a function when the value represents an exception.
      /// <para/>   Haskell signature: catch :: MonadError e m => m a -> (e -> m b) -> m b </summary>
      let inline catch (v:'ma) (h:'e->'mb) :'mb = CatchError.Invoke v h
  
  
      // Collection
  
      let inline item (n:int) (source:'Collection'T) : 'T = Item.Invoke n source
  
      /// <summary>Returns a collection that skips N elements of the original collection and then yields the
      /// remaining elements of the collection.</summary>
  
negative.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>
      ///
  