anchor.diff:    | ParaValue.String s -> Value(s)
     | y -> Error(sprintf "Expected string but received %O" y)
   
  -  let inline init (a: 'a) : ParaValue<'a> =
  -    fun paravalue -> Value a, paravalue
  -
  -  let inline bind2 (m: ParaResult<'a>) (f: 'a -> ParaResult<'b>) : ParaResult<'b> =
  -    match m with
  -    | Value(x) -> f x
  -    | Error(x) -> Error(x)
  -
  +  /// Wraps a result into a ParaValue<'a>
  +  let inline ofResult (result: ParaResult<'a>) : ParaValue<'a> =
  +    fun para -> result, para
  +
  +  /// Creates an error from a given string
  +  let inline error (e: string) : ParaValue<'a> = ofResult(Error e)
  +
  +  /// Creates a ParaValue<'a> from a value
  +  let inline init (a: 'a) : ParaValue<'a> = ofResult(Value a)
  +
  +  /// If a given result has a value, apply another function to the value
     let inline bind (m: ParaValue<'a>) (f: 'a -> ParaValue<'b>) : ParaValue<'b> =
       fun paravalue ->
         match m paravalue with
  
positive.code: module Functional =
    type ParaValue<'a> = ParaValue -> ParaResult<'a> * ParaValue
  
    and ParaResult<'a> =
    | Value of 'a
    | Error of string
  
    let inline error (e: string) : ParaValue<'a> = fun va -> Error e, va
  
    let number = function
    | ParaValue.Number x -> Value(x)
  
negative.code:     bind f (fun f' ->
        bind m (f' >> init))
  
    /// Maps the underlying value. If the result is currently an error
    /// the map does not happen
    let inline map (f: 'a -> 'b) (m: ParaValue<'a>) : ParaValue<'b> =
      bind m (f >> init)
  
    /// Given a function that given a ParaValue will return a ParaResult, wrap
    /// it into a ParaValue<'a>
    let wrap (fn:ParaValue -> ParaResult<'a>) =
      fun paravalue -> fn paravalue, paravalue
  
    type FromParaDefaults = FromParaDefaults with
      static member inline FromPara (_: bool)  = wrap bool
      static member inline FromPara (_: int) = map int (wrap number)
      static member inline FromPara (_: uint32) = map uint32 (wrap number)
      static member inline FromPara (_: sbyte) = map sbyte (wrap number)
      static member inline FromPara (_: byte) = map byte (wrap number)
      static member inline FromPara (_: int16) = map int16 (wrap number)
      static member inline FromPara (_: uint16) = map uint16 (wrap number)
      static member inline FromPara (_: int64) = map int64 (wrap number)
      static member inline FromPara (_: uint64) = map uint64 (wrap number)
      static member inline FromPara (_: single) = map single (wrap number)
      static member inline FromPara (_: float) = map float (wrap number)
      static member inline FromPara (_: string) = wrap stringify
  
    let inline internal fromParaDefaults (a: ^a, _: ^b) =
      ((^a or ^b) : (static member FromPara: ^a -> ^a ParaValue) a)
  