anchor.diff:  
       [<JavaScript>]
       let MapToResult m f =
  -        f |> MapResult (function
  -            | Failure msg -> Failure msg
  -            | Success x -> m x)
  +        f |> MapResult (fun r ->
  +            match r.Value with
  +            | None -> { Value = None; Errors = r.Errors }
  +            | Some v ->
  +                let res = m v
  +                { res with Errors = r.Errors @ res.Errors })
   
       [<JavaScript>]
       let Map m f =
  -        f |> MapResult (function
  -            | Failure msg -> Failure msg
  -            | Success x -> Success (m x))
  +        f |> MapResult (fun r ->
  +            { Value = Option.map m r.Value; Errors = r.Errors })
   
       [<JavaScript>]
       let MapAsyncResult m f =
  -        let out = Stream (Failure [])
  +        let out = Stream ({ Value = None; Errors = f.stream.Latest.Errors })
           f.stream.Subscribe (fun v ->
               async {
                   let! res = m v
  
positive.code: [<Sealed>]
  type Submitter<'a> [<JavaScript>] (input: Reader<'a>) =
  
      let output = Stream(Failure [])
  
      let writer =
          ConcreteWriter(fun unitIn ->
              match unitIn, input.Latest with
              | Failure m1, Failure m2 -> output.Trigger(Failure(m1 @ m2))
              | Failure m, Success _
              | Success _, Failure m -> output.Trigger(Failure m)
              | Success(), Success x -> output.Trigger(Success x))
          :> Writer<unit>
  
      [<JavaScript>]
  
negative.code: 
      [<JavaScript>]
      let Yield (x: 'a) =
          let s = Stream(Result.Success x)
          {
              stream = s
              view = fun f -> f s
  