anchor.diff:      let validationNel (x: Result<_,_>) : (Validation<NonEmptyList<'e>,'a>) = (liftResult result) x
       #endif
   
  -    /// Leaves the validation unchanged when the predicate holds, or
  -    /// fails with [e] otherwise.
  -    ///
  -    /// This can be thought of as having the less general type:
  -    ///
  -    /// ensure : 'e -> ('a -> 'bool) -> Validation<'a,'e> -> Validation<'a,'e>
       [<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
  
positive.code:     ///
      /// There is nothing wrong with using this function, it just does not make a
      /// valid Monad instance.
      let bind (f: 'T->Validation<_,_>) x : Validation<_,_> =
          match x with 
          | Failure e -> Failure e
          | Success a -> f a
  
      /// orElse v a returns 'a when v is Failure, and the a in Success a.
      [<System.Obsolete("Use Validation.defaultValue instead.")>]
      let orElse v (a: 'a) = match v with | Failure _ -> a | Success x -> x
      /// defaultValue value source returns value when source is Failure, and the v in Success v.
      let defaultValue (value:'a) (source:Validation<'err,'a>) :'a = match source with Success v -> v | _ -> value
      /// defaultWith returns either x when the source is Success x, otherwise applies the function f on e if the source is Failure e.
      let defaultWith (f:'err->'a) (source:Validation<'err,'a>) :'a = match source with | Success x -> x | Failure e -> f e
  
      /// Return the 'a or run the given function over the 'e.
      [<System.Obsolete("Use Validation.defaultWith instead.")>]
      let valueOr ea (v: Validation<'e,'a>) = match v with | Failure e -> ea e | Success a -> a
  
      /// 'liftResult' is useful for converting a 'Result' to an 'Validation'
      /// when the 'Error' of the 'Result' needs to be lifted into a 'Semigroup'.
      let liftResult (f: 'b -> 'e) : (Result<'a,'b> -> Validation<'e,'a>) = function | Error e-> Failure (f e) | Ok a-> Success a
  
      /// 'liftChoice' is useful for converting a 'Choice' to an 'Validation'
      /// when the 'Choice2Of2' of the 'Choice' needs to be lifted into a 'Semigroup'.
      let liftChoice (f: 'b -> 'e) : (Choice<'b,'a>->Validation<'e,'a>) = Choice.either (Failure << f) Success
  
      let appValidation (m: 'err -> 'err -> 'err) (e1': Validation<'err,'a>) (e2': Validation<'err,'a>) =
          match e1', e2' with
  
negative.code:         match t with
          | Failure a -> f z a
          | Success a -> g z a
  