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:             let context = World.getScriptContext world
              match World.tryResolveRelationOpt fnName relationOpt originOpt context world with
              | Right struct (simulant, world) ->
                  let stream = Stream.make (Events.SimulantChange propertyName ->>- simulant.SimulantAddress)
                  let stream =
                      Stream.mapEvent (fun (evt : Event<ChangeData, _>) world ->
                          match World.tryGetSimulantProperty evt.Data.PropertyName simulant world with
                          | Some prop -> ScriptingWorld.tryImport prop.PropertyType prop.PropertyValue world
                          | None -> None)
                          stream
                  struct (Pluggable { Stream = stream }, world)
              | Left error -> error
  
  
negative.code:             | (Pluggable stream, Pluggable stream2) ->
                  match (stream, stream2) with
                  | ((:? StreamPluggable as stream), (:? StreamPluggable as stream2)) ->
                      let 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)
  