anchor.diff:  
   
       // Common combinators
  +
  +    /// Creates a new function with first two arguments flipped
       let inline flip f x y = f y x
  +
       let inline konst k _ = k
       let inline curry f x y = f (x, y)
       let inline uncurry f (x, y) = f x y
       let inline (</) x = (|>) x
       let inline (/>) x = flip x
  +
       /// Case analysis for the Result type. If the value is Ok a, apply the first function to a; if it is Error b, apply the second function to b.
       let inline either f g = function Ok x   -> f x | Error x -> g x
  +
       /// The option function takes a function, a default value and a option value. If the option value is None, the function returns the default value. Otherwise, it applies the function to the value inside Some and returns the result.
       let inline option f n = function Some x -> f x | None    -> n
  +
       let inline tuple2 a b             = a,b
       let inline tuple3 a b c           = a,b,c
       let inline tuple4 a b c d         = a,b,c,d
  
positive.code: 
      // Collection
  
      let inline ofList (source: list<'T>) = OfList.Invoke source
      let inline ofSeq  (source: seq<'T> ) = OfSeq.Invoke  source : 'Collection
      let inline filter (predicate:_->bool) (x: 'Collection) : 'Collection = Filter.Invoke predicate x
  
      /// <summary>Returns a collection that skips N elements of the original collection and then yields the
  
negative.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
  
      /// Reverse Kleisli composition operator.
      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.
  