anchor.diff:              true
           | (false, _) -> false
   
  +    type 'w Ecs with
  +    
  +        member this.QualifyEntity<'t when 't : struct and 't :> Component> systemName entityId =
  +            let systemOpt = this.TryGetSystem<SystemCorrelated<'t, 'w>> systemName
  +            if Option.isNone systemOpt then failwith ("Could not find expected system '" + systemName + "'.")
  +            let system = Option.get systemOpt
  +            system.HasComponent entityId
  +    
  +        member this.IndexEntity<'t when 't : struct and 't :> Component> systemName entityId =
  +            let systemOpt = this.TryGetSystem<SystemCorrelated<'t, 'w>> systemName
  +            if Option.isNone systemOpt then failwith ("Could not find expected system '" + systemName + "'.")
  +            let system = Option.get systemOpt
  +            &system.GetComponent entityId
  +    
  +        member this.RegisterEntity<'t when 't : struct and 't :> Component> systemName entityId comp =
  +            match this.TryGetSystem<SystemCorrelated<'t, 'w>> systemName with
  +            | Some system ->
  +                let _ = system.RegisterEntity entityId comp
  +                match this.Correlations.TryGetValue entityId with
  +                | (true, correlation) -> correlation.Add systemName
  +                | (false, _) -> this.Correlations.Add (entityId, List [systemName])
  +            | None -> failwith ("Could not find expected system '" + systemName + "'.")
  +    
  +        member this.UnregisterEntity<'t when 't : struct and 't :> Component> systemName entityId =
  +            match this.TryGetSystem<SystemCorrelated<'t, 'w>> systemName with
  +            | Some system ->
  +                if system.UnregisterEntity entityId this then
  +                    match this.Correlations.TryGetValue entityId with
  +                    | (true, correlation) -> correlation.Add systemName
  +                    | (false, _) -> this.Correlations.Add (entityId, List [systemName])
  +            | _ -> failwith ("Could not find expected system '" + systemName + "'.")
  +    
  +        member this.CorrelateEntity entityId =
  +            this.Correlations.[entityId] |>
  +            Seq.map (fun systemName -> (systemName, this.GetSystem<'w System> systemName)) |>
  +            dictPlus
  +
  +        member this.GetEntities<'t when 't : struct and 't :> Component> systemName =
  +            match this.TryGetSystem<SystemCorrelated<'t, 'w>> systemName with
  +            | Some system -> system.GetEntities ()
  +            | _ -> failwith ("Could not find expected system '" + systemName + "'.")
  +
   /// An Ecs system that stores multiple components per entity id.
  -and [<AbstractClass>] SystemMultiplexed<'t, 'w when 't : struct and 't :> Component> () =
  +type [<AbstractClass>] SystemMultiplexed<'t, 'w when 't : struct and 't :> Component> () =
       inherit SystemCorrelated<'t ComponentMultiplexed, 'w> ()
   
       member this.HasMultiplexed multiId entityId =
  
positive.code:             else this.FreeIndex <- dec this.FreeIndex
              this.Disjunction junctions entityId comp ecs
              true
          | (false, _) -> false
negative.code:     abstract Actualize : 'w Ecs -> 'w -> 'w
      default this.Actualize _ world = world
  
  /// Nu's custom Entity-Component-System implementation.
  /// While this isn't the most efficient ECS, it isn't the least efficient either. Due to the set-associative nature of
  /// modern caches, most cache hits will be of the L2 variety for junctioned components. Uncorrelated components will be
  /// L2-bound as is typical. Degradation of cache-prediction would only occur when a significant number of junctioned
  /// components are very chaotically unregistered in a use-case scenario that the I, the library author, have trouble
  /// even imagining.
  and [<NoEquality; NoComparison>] 'w Ecs () =
  
      let systemsUnordered = dictPlus [] : Dictionary<string, 'w System>
      let systemsOrdered = List () : (string * 'w System) List
      let correlations = dictPlus [] : Dictionary<Guid, string List>
  
      member internal this.Correlations 
          with get () = correlations
  
      member this.Update world =
          Seq.fold
              (fun world (_, system : 'w System) -> system.Update this world)
              world systemsOrdered
  
      member this.PostUpdate world =
          Seq.fold
              (fun world (_, system : 'w System) -> system.PostUpdate this world)
              world systemsOrdered
  
      member this.Actualize world =
          Seq.fold
              (fun world (_, system : 'w System) -> system.Actualize this world)
              world systemsOrdered
  
      member this.AddSystem systemName system =
          systemsUnordered.Add (systemName, system)
          systemsOrdered.Add (systemName, system)
  
      member this.RemoveSystem systemName =
          systemsOrdered.RemoveAll (fun (systemName', _) -> systemName' = systemName) |> ignore
          systemsUnordered.Remove systemName |> ignore
  
      member this.TryGetSystem<'s when 's :> 'w System> systemName =
          match systemsUnordered.TryGetValue systemName with
          | (true, system) ->
              match system with
              | :? 's as systemAsS -> Some systemAsS
              | _ -> None
          | (false, _) -> None
  
      member this.GetSystem<'s when 's :> 'w System> systemName =
          this.TryGetSystem<'s> systemName |> Option.get
  
  /// An Ecs system with just a single component.
  and [<AbstractClass>] SystemSingleton<'t, 'w when 't : struct and 't :> Component> (comp : 't) =
      inherit System<'w> ()
      let mutable comp = comp
      member this.Component with get () = &comp
      type 'w Ecs with
          member this.GetComponentSingleton<'t, 'w when 't : struct and 't :> Component> systemName =
              let systemOpt = this.TryGetSystem<SystemSingleton<'t, 'w>> systemName 
              if Option.isNone systemOpt then failwith ("Could not find expected system '" + systemName + "'.")
              let system = Option.get systemOpt
              &system.Component
  
  /// An Ecs system with components stored by a raw index.
  /// Uncorrelated systems could potentially be processed in parallel.
  type [<AbstractClass>] SystemUncorrelated<'t, 'w when 't : struct and 't :> Component> () =
      inherit System<'w> ()
  
      let mutable components = Array.zeroCreate 32 : 't array
  