anchor.diff:    let private publicProperties (factory: Factory) source =
       seq {
         for (propertyInfo, result) in source |> getPublicInstancePropertyValues do
  -        let result = result |> Result.map factory.Invoke
  -        yield KeyValuePair<_, _>(propertyInfo.Name, MarshalResult result)
  +        let result =
  +          match result with
  +          | Success value ->
  +            ValueMarshalResult(factory.Invoke value) :> MarshalResult
  +          | Failure e ->
  +            ErrorMarshalResult(e) :> MarshalResult
  +        yield KeyValuePair<_, _>(propertyInfo.Name, result)
       }
     let private ofCollectionCore factory elementSelector showElement source =
       let typ = source.GetType()
  
positive.code:         yield! publicProperties factory source
          for (key, value) in items do
            let key = sprintf "[%s]" key
            let value = value |> Success |> MarshalResult
            yield KeyValuePair(key, value)
        }
      create factory typ string properties
  
negative.code: open System.Reflection
  open Basis.Core
  
  [<AbstractClass>]
  type MarshalResult() =
    abstract Unwrap: unit -> Result<MarshalValue, exn>
  
    member this.HasValue =
      this.Unwrap() |> Result.isSuccess
  
    member this.HasError =
      this.HasValue |> not
  
    member this.ValueOrThrow =
      this.Unwrap() |> Result.get
  
    member this.ErrorOrThrow =
      this.Unwrap() |> Result.getFailure
  
    member this.AsObject =
      this.Unwrap() |> Result.toObj
  
  and
    [<Sealed>]
    ValueMarshalResult(value: MarshalValue) =
    inherit MarshalResult()
  
    let result =
      Result.Success value
  
    override this.Unwrap() =
      result
  
  and
    [<Sealed>]
    ErrorMarshalResult(error: exn) =
    inherit MarshalResult()
  
    let result =
      Result.Failure error
  
    override this.Unwrap() =
      result
  
  and MarshalProperty =
    KeyValuePair<string, MarshalResult>
  