anchor.diff:      fst (fromParaDefaults (Unchecked.defaultof<'a>, FromParaDefaults) x)
   
     let inline lister fn =
  -    map fn (wrap (ParaValue.asArray >> ParaResult.bind (ParaResult.paraFold fromPara)))
  +    map fn (wrap (ParaValue.asArray >> ParaResult.bind (ParaValue.reduce fromPara)))
   
     type FromParaDefaults with
       static member inline FromPara (_: 'a option) = map Some (fun b -> fromPara b, b)
       static member inline FromPara (_: 'a[]) : ParaValue<'a[]> =
  -      lister (fun x -> x.ToArray())
  +      lister id
       static member inline FromPara (_: 'a list) : ParaValue<'a list> =
         lister List.ofSeq
   
  
positive.code:   /// result in ok, then reduce the array of results into a single result of an
    /// array. If an element is an error, the first error is returned.
    let inline reduce (fn:ParaValue -> ParaResult<'a>) (arr:ParaValue[]) : ParaResult<'a[]> =
      let res = ParaResult.paraFold fn arr
      ParaResult.map (fun (x: List<'a>) -> x.ToArray()) res
  
    /// Given a function to map a value to a result, apply this function on every
    /// value of a record, or array, or any other element (and the result would be
  
negative.code:     | Some(res) -> res
      | None -> Ok def
  
    /// Takes an array of results and if all elements are ok then a result of
    /// array is returned else the first error
    let choose (arr: ParaResult<'a>[]) : ParaResult<'a[]> =
      let isError = function
      | Ok(x) -> false
      | Error(x) -> true
  
      let getError = function
      | Ok(x) -> failwith "Not expecting a value"
      | Error(x) -> x
  
      match Array.tryFind isError arr with
      | Some(err) -> Error(getError err)
      | None -> Array.map get arr |> Ok
  
  [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module ParaValue =
  