anchor.diff:  
       [<JavaScript>]
       let Yield (x: 'a) =
  -        let s = Stream(Success x)
  +        let s = Stream(Result.Success x)
           {
               stream = s
               view = fun f -> f s
  
positive.code: open IntelliFactory.WebSharper
  
  type Result<'a> =
      | Success of 'a
      | Failure of string list
  
      [<JavaScript>]
      member this.isSuccess =
          match this with
          | Success _ -> true
          | Failure _ -> false
  
      [<JavaScript>]
      static member Ap(r1: Result<'a -> 'b>, r2: Result<'a>) =
          match r1, r2 with
          | Success f, Success x -> Success(f x)
          | Failure m, Success _
          | Success _, Failure m -> Failure m
          | Failure m1, Failure m2 -> Failure(m1 @ m2)
  
      [<JavaScript>]
      static member Join (r: Result<Result<'a>>) =
          match r with
          | Failure m
          | Success (Failure m) -> Failure m
          | Success (Success x) -> Success x
  
  [<Interface>]
  type Reader<'a> =
  
negative.code: 
      [<JavaScript>]
      let MapToResult m f =
          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 (fun r ->
              { Value = Option.map m r.Value; Errors = r.Errors })
  
      [<JavaScript>]
      let MapAsyncResult m f =
          let out = Stream ({ Value = None; Errors = f.stream.Latest.Errors })
          f.stream.Subscribe (fun v ->
              async {
                  let! res = m v
  