anchor.diff:          match t with
           | Failure a -> f z a
           | Success a -> g z a
  -        
positive.code:         | Success a1 , Failure _  -> Success a1
          | Success a1 , Success _  -> Success a1
  
      let toResult x : Result<_,_>  = match x with Success a -> Ok a | Failure e -> Error e
      let ofResult (x :Result<_,_>) = match x with Ok a -> Success a | Error e -> Failure e
      let either f g                = function Success v -> f v      | Failure e     -> g e
  
      /// Validate's the [a] with the given predicate, returning [e] if the predicate does not hold.
      ///
      /// This can be thought of as having the less general type:
      ///
      /// validate : 'e -> ('a -> bool) -> 'a -> Validation<'e, 'a>
      ///
      [<System.Obsolete("This function will not be supported in future versions.")>]
      let validate (e: 'e) (p: 'a -> bool) (a: 'a) : Validation<'e,'a> = if p a then Success a else Failure e
  
  
negative.code:     ///
      /// There is nothing wrong with using this function, it just does not make a
      /// valid Monad instance.
      let bind (f: 'T->Validation<'Error,_>) x : Validation<_,'U> =
          match x with 
          | Failure e -> Failure e
          | Success a -> f a
  
      [<System.Obsolete("Use Validation.defaultValue instead.")>]
      let orElse v (a: 'a) = match v with | Failure _ -> a | Success x -> x
      
      /// Extracts the Success value or use the supplied default value when it's a Failure.
      let defaultValue (value: 'T) (source: Validation<'Error,'T>) : 'T = match source with Success v -> v | _ -> value
      
      /// Extracts the Success value or applies the compensation function over the Failure.
      let defaultWith (compensation: 'Error->'T) (source: Validation<'Error,'T>) : 'T = match source with | Success x -> x | Failure e -> compensation e
  
      [<System.Obsolete("Use Validation.defaultWith instead.")>]
      let valueOr ea (v: Validation<'e,'a>) = match v with | Failure e -> ea e | Success a -> a
  
      /// Converts a 'Result' to a 'Validation'
      /// when the 'Error' of the 'Result' needs to be lifted into a 'Semigroup'.
      let liftResult f : (Result<'T,'Error> -> Validation<'Semigroup,'T>) = function Error e -> Failure (f e) | Ok a -> Success a
  
      /// Converting a 'Choice' to a 'Validation'
      /// when the 'Choice2Of2' of the 'Choice' needs to be lifted into a 'Semigroup'.
      let liftChoice (f: 'b -> 'Semigroup) : (Choice<'b,'T>->Validation<'Semigroup,'T>) = Choice.either (Failure << f) Success
  
      let appValidation (m: 'err -> 'err -> 'err) (e1': Validation<'err,'a>) (e2': Validation<'err,'a>) =
          match e1', e2' with
  