anchor.diff:      member this.Publish<'d> eventName (eventData : 'd) publisher world =
           match systemSubscriptions.TryGetValue eventName with
           | (true, subscriptions) ->
  -            Seq.fold (fun world (callback : obj) ->
  +            (Some world, subscriptions.Values) ||>
  +            Seq.fold (fun worldOpt (callback : obj) ->
                   match callback with
                   | :? SystemCallback<obj, 'w> as objCallback ->
                       let evt = { SystemEventData = eventData :> obj; SystemPublisher = publisher }
  -                    objCallback evt publisher this world
  -                | _ -> failwithumf ())
  -                world subscriptions.Values
  +                    objCallback evt publisher this worldOpt
  +                | _ -> failwithumf ()) |>
  +            Option.get
           | (false, _) -> world
   
       member this.PublishParallel<'d> eventName (eventData : 'd) publisher =
  
positive.code:     member this.RegisterPipedValue<'a when 'a : not struct> key (value : 'a) =
          pipedValues.[key] <- value :> obj
  
      member this.WithPipedValue<'a when 'a : not struct> key fn (world : 'w) : 'w =
          let pipedValue = pipedValues.[key] :?> 'a
          lock pipedValue (fun () -> fn pipedValue world)
  
      member this.RegisterSystemGeneralized (system : 'w System) =
          systemsUnordered.Add (system.Name, system)
  
negative.code:     new (buffered, ecs) = SystemCorrelated (typeof<'c>.Name, buffered, ecs)
  
      member this.Components with get () = components
      member this.WithComponentsBuffered (fn : 'c ArrayRef -> 'w option -> 'w option) worldOpt = lock componentsBuffered (fun () -> fn componentsBuffered worldOpt)
  
      member this.GetJunction<'c> () = junctions |> Array.find SystemCorrelated<'c, 'w>.isJunction<'c> :?> 'c ArrayRef
      member this.WithJunctionBuffered<'c> fn (worldOpt : 'w option) = let junction = this.GetJunction<'c> () in  lock junction (fun () -> fn junction worldOpt)
  
      member private this.Compact ecs =
  
  