anchor.diff:              | (Pluggable stream, Pluggable stream2) ->
                   match (stream, stream2) with
                   | ((:? StreamPluggable as stream), (:? StreamPluggable as stream2)) ->
  -                    let stream = Stream.sum stream.Stream stream2.Stream
                       let stream =
  -                        Stream.map (fun eir ->
  -                            match eir with
  -                            | Right opt -> match opt with Some expr -> Some (Either (Right expr)) | None -> None
  -                            | Left opt -> match opt with Some expr -> Some (Either (Left expr)) | None -> None)
  -                            stream
  +                        Stream.sum stream.Stream stream2.Stream |>
  +                        Stream.map box |>
  +                        Stream.map (fun (eirObj : obj) ->
  +                            match eirObj with
  +                            | :? Either<Expr option, Expr option> as eir ->
  +                                match eir with
  +                                | Right opt -> match opt with Some expr -> Some (Either (Right expr)) |> box | None -> None |> box
  +                                | Left opt -> match opt with Some expr -> Some (Either (Left expr)) |> box | None -> None |> box
  +                            | _ -> None |> box)
                       struct (Pluggable { Stream = stream }, world)
                   | _ -> struct (Violation (["InvalidArgumentType"; String.capitalize fnName], "Function '" + fnName + "' requires a Stream for its 1st and 2nd arguments.", originOpt), world)
               | _ -> struct (Violation (["InvalidArgumentType"; String.capitalize fnName], "Function '" + fnName + "' requires a Stream for its 1st and 2nd arguments.", originOpt), world)
  
positive.code:                 | ((:? StreamPluggable as stream), (:? StreamPluggable as stream2)) ->
                      let stream =
                          Stream.map2Effect
                              (fun (evt : Event<Expr option, _>) (evt2 : Event<Expr option, _>) world ->
                                  match (evt.Data, evt2.Data) with
                                  | (Some expr, Some expr2) ->
                                      let context = World.getScriptContext world
                                      match World.tryGetSimulantScriptFrame context world with
                                      | Some scriptFrame ->
                                          let breakpoint = { BreakEnabled = false; BreakCondition = Unit }
                                          let application = Apply ([|fn; expr; expr2|], breakpoint, originOpt)
                                          let (evaled, world) = World.evalWithLogging application scriptFrame context world
                                          (Some evaled, world)
                                      | None -> (None, world)
                                  | (_, _) -> (None, world))
                              stream.Stream
                              stream2.Stream
                      struct (Pluggable { Stream = stream }, world)
  
negative.code: 
  /// The Stream value that can be plugged into the scripting language.
  type [<Struct; CustomEquality; CustomComparison>] StreamPluggable =
      { Stream : Stream<obj, Game, World> }
  
      static member equals _ _ = false
  
  