anchor.diff:    let inline returnM x = returnM maybe x
     let inline (>>=) m f = bindM maybe m f
     let inline (=<<) f m = bindM maybe m f
  +  /// Sequential application
     let inline (<*>) f m = applyM maybe maybe f m
  +  /// Sequential application
  +  let inline ap m f = f <*> m
     let inline (<!>) f m = Option.map f m
     let inline map2 f a b = returnM f <*> a <*> b
  +  /// Sequence actions, discarding the value of the first argument.
     let inline ( *>) x y = map2 (fun _ z -> z) x y
  +  /// Sequence actions, discarding the value of the second argument.
     let inline ( <*) x y = map2 (fun z _ -> z) x y
  +
  +  /// Sequentially compose two maybe actions, discarding any value produced by the first
     let inline (>>.) m f = bindM maybe m (fun _ -> f)
   
     let fromNullable (n: _ Nullable) = 
  
positive.code:     | Choice1Of2 f, Choice2Of2 e   -> Choice2Of2 e
      | Choice2Of2 e1, Choice2Of2 e2 -> Choice2Of2 (append e1 e2)
  
    let inline apm (m: _ Monoid) = apa m.mappend
  
    type CustomValidation<'a>(monoid: 'a Monoid) =
      member this.ap x = apm monoid x
      member this.map2 f a b = returnM f |> this.ap a |> this.ap b
      member this.apr b a = this.map2 (fun _ z -> z) a b
      member this.apl b a = this.map2 (fun z _ -> z) a b
  
    let private stringListValidation = CustomValidation(ListMonoid<string>())
  
    let ap = stringListValidation.ap
  
    let inline (<*>) f x = ap x f
    let map2 = stringListValidation.map2
  
    let ( *>) = stringListValidation.apr
    let ( <*) = stringListValidation.apl
  
    let seqValidator f = 
  
negative.code:   let inline (<!>) f x = map f x
    let inline map2 f a b = f <!> a <*> b
  
    /// Sequence actions, discarding the value of the first argument.
    let inline ( *>) a b = map2 (fun _ z -> z) a b
    /// Sequence actions, discarding the value of the second argument.
    let inline ( <*) a b = map2 (fun z _ -> z) a b
  
    let bind f = 
  