anchor.diff:      /// Like map but ignoring the results.
       let inline iter   (action :'T->unit) (source :'``Functor<'T>``) :unit = Iterate.Invoke action source
   
  +    // Un-zips (un-tuple) two functors.
       let inline unzip (source: '``Functor<'T1 * 'T2>``) = Unzip.Invoke source : '``Functor<'T1>`` * '``Functor<'T2>``
  +
  +    // Zips (tuple) two functors.
       let inline zip (source1:'``ZipFunctor<'T1>``) (source2:'``ZipFunctor<'T2>``) : '``ZipFunctor<'T1 * 'T2>`` = Zip.Invoke source1 source2
      
   
  
positive.code:     let inline (=<<) (f:'T->'``Monad<'U>``) (x:'``Monad<'T>``) :'``Monad<'U>`` = Bind.Invoke x f
      /// Kleisli composition (fish) operator
      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
  
      /// Flattens two layers of monadic information into one.
  
negative.code: 
      // Monoid -----------------------------------------------------------------
  
      /// Gets a value that represents the 0 element of a Monoid.
      let inline getZero () : 'Monoid = Zero.Invoke ()
  
      /// A value that represents the 0 element of a Monoid.
      let inline zero< ^Monoid when (Zero or ^Monoid) : (static member Zero : ^Monoid * Zero -> ^Monoid) > : ^Monoid = Zero.Invoke ()
  
      /// Combine two monoids in one.
      let inline (++) (x:'Monoid) (y:'Monoid): 'Monoid = Plus.Invoke x y
  
      /// Combine two monoids in one.
      let inline plus (x:'Monoid) (y:'Monoid): 'Monoid = Plus.Invoke x y
  
      module Seq =
  