anchor.diff:                  let scriptContext = World.getScriptContext world
                   let eventRelation = Relation.makeFromString str
                   let eventAddress = Relation.resolve scriptContext.SimulantAddress eventRelation
  -                let stream = Stream.make eventAddress
                   let stream =
  +                    Stream.make eventAddress |>
                       Stream.mapEffect (fun (evt : Event<obj, _>) world ->
                           match World.tryImportEvent evt world with
  -                        | Some evtImported -> (Some evtImported, world)
  -                        | None -> (None, world))
  -                        stream
  +                        | Some evtImported -> (Some evtImported |> box, world)
  +                        | None -> (None |> box, world))
                   struct (Pluggable { Stream = stream }, world)
               | _ -> struct (Violation (["InvalidArgumentType"; String.capitalize fnName], "Function '" + fnName + "' requires a Function for its 1st argument.", originOpt), world)
   
  
positive.code:             | (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
                      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)
  
negative.code:                 | ((:? StreamPluggable as stream), (:? StreamPluggable as stream2)) ->
                      let stream =
                          Stream.map2Effect
                              (fun (evt : Event<obj, _>) (evt2 : Event<obj, _>) world ->
                                  match (evt.Data, evt2.Data) with
                                  | ((:? (Expr option) as exprOpt), (:? (Expr option) as expr2Opt)) ->
                                      match (exprOpt, expr2Opt) with
                                      | (Some expr, Some expr2) -> (Some (Tuple [|expr; expr2|]) |> box, world)
                                      | (_, _) -> (None |> box, world)
                                  | (_, _) -> (None |> box, world))
                              stream.Stream
                              stream2.Stream
                      struct (Pluggable { Stream = stream }, world)
  