anchor.diff:                          let lens = lens.Map snd
                           PartialComparable.make guid (index, lens)) |>
                       Set.ofSeq
  -                let cpd = Set.difference c p
  -                let pcd = Set.difference p c
  +                let cpd = Set.difference current previous
  +                let pcd = Set.difference previous current
                   let changed = Set.notEmpty cpd || Set.notEmpty pcd
                   let world =
                       if changed then
  
positive.code:         /// Transform a stream into existing simulants.
          static member streamSimulants
              (lensSeq : Lens<obj seq, World>)
              (mapper : int -> Lens<obj, World> -> World -> SimulantContent)
              (origin : ContentOrigin)
              (parent : Simulant)
              (stream : Stream<Lens<(int * obj) option, World> seq, World>) =
              stream |>
              Stream.trackEffect4 (fun (guid, p, _, _) event world ->
                  let c =
                      event.Data |>
                      Seq.map (fun lens -> (Lens.get lens world, { Lens.dereference lens with Validate = fun world -> Option.isSome (lens.Get world) })) |>
                      Seq.filter (fst >> Option.isSome) |>
                      Seq.take (Lens.get lensSeq world |> Seq.length) |>
  
negative.code:                                 world pcd
                          world
                      else world
                  ((guid, current, cpd, pcd), changed, world))
                  id
                  (Gen.id, Set.empty, Set.empty, Set.empty)
  
          /// Turn an entity stream into a series of live simulants.
          static member expandSimulantStream (lens : Lens<obj, World>) indexerOpt mapper origin parent world =
              let lensSeq = Lens.map Reflection.objToObjSeq lens
              Stream.make (Events.Register --> lens.This.SimulantAddress) |>
              Stream.sum (Stream.make lens.ChangeEvent) |>
              World.streamSimulants lensSeq indexerOpt mapper origin parent |>
              Stream.subscribe (fun _ value -> value) Default.Game $ world