anchor.diff:  open FSharpPlus.Data
   open System.ComponentModel
   
  -// Validation is based on AccValidation from https://github.com/qfpl/validation
  +// Validation is based on https://github.com/qfpl/validation
   
  -/// A 'Validation' is either a value of the type 'err or 'a, similar to 'Result'. However,
  +/// A 'Validation' is either a value of the type 'err or 't, similar to 'Result'. However,
   /// the 'Applicative' instance for 'Validation' /accumulates/ errors using a 'Semigroup' on 'err.
   /// In contrast, the Applicative for 'Result' returns only the first error.
   ///
  
positive.code:   | Failure of 'err
    | Success of 'a
  
  module Validation=
  
      let map (f: 'T->'U) = function
          | Failure e -> Failure e
          | Success a -> Success (f a) 
  
      let inline apply e1' e2' = 
          match e1', e2' with
          | Failure e1, Failure e2 -> Failure (plus e1 e2)
          | Failure e1, Success _  -> Failure e1
          | Success _ , Failure e2 -> Failure e2
          | Success f , Success a  -> Success (f a)
  
      let inline foldBack f state x =
          match state with
          | Success a -> f a x
          | Failure _ -> x
  
      #if !FABLE_COMPILER
      let inline traverse f = function 
          | Success a -> Success <!> f a
          | Failure e -> result (Failure e)
      #endif
  
      let bimap f g = function
          | Failure e -> Failure (f e)
          | Success a -> Success (g a)
  
      let bifoldBack f g x state =
          match x with
          | Success a -> g a state
          | Failure e -> f e state
  
      [<System.Obsolete("use bifoldBack from FSharpPlus.Operators (see: http://fsprojects.github.io/FSharpPlus/abstraction-bifoldable.html)")>]
      let biFoldBack f g state x =
          match state with
          | Success a -> g a x
          | Failure e -> f e x
  
      let inline bitraverse f g = function 
          | Success a -> Success <!> g a
          | Failure e -> Failure <!> f e
  
      /// Binds through a Validation, which is useful for
      /// composing Validations sequentially. Note that despite having a bind
  
negative.code:     let validationNel (x: Result<_,_>) : (Validation<NonEmptyList<'e>,'a>) = (liftResult result) x
      #endif
  
      [<System.Obsolete("This function will not be supported in future versions.")>]
      let ensure (e: 'e) (p: 'a-> bool) = function
          | Failure x -> Failure x
          | Success a -> validate e p a
  
      /// Creates a safe version of the supplied function, which returns a Validation<exn,'U> instead of throwing exceptions.
      let protect (f: 'T->'U) x =
          try
              Success (f x)
          with e -> Failure e
  
  
      let inline _Success x = (prism Success <| either Ok (Error << Failure)) x
  