anchor.diff:          | Some system -> system.GetEntities ()
           | _ -> failwith ("Could not find expected system '" + systemName + "'.")
   
  -    (* Multi *)
  -
  -    member this.QualifyMulti<'t when 't : struct and 't :> Component> systemName multiId entityId =
  -        let systemOpt = this.TryGetSystem<SystemMulti<'t, 'w>> systemName
  +    (* Multiplexed *)
  +
  +    member this.QualifyMultiplexed<'t when 't : struct and 't :> Component> systemName multiId entityId =
  +        let systemOpt = this.TryGetSystem<SystemMultiplexed<'t, 'w>> systemName
           if Option.isNone systemOpt then failwith ("Could not find expected system '" + systemName + "'.")
           let system = Option.get systemOpt
  -        system.HasMulti multiId entityId
  -
  -    member this.IndexMulti<'t when 't : struct and 't :> Component> systemName multiId entityId =
  -        let systemOpt = this.TryGetSystem<SystemMulti<'t, 'w>> systemName
  +        system.HasMultiplexed multiId entityId
  +
  +    member this.IndexMultiplexed<'t when 't : struct and 't :> Component> systemName multiId entityId =
  +        let systemOpt = this.TryGetSystem<SystemMultiplexed<'t, 'w>> systemName
           if Option.isNone systemOpt then failwith ("Could not find expected system '" + systemName + "'.")
           let system = Option.get systemOpt
  -        let oneOf = system.GetMulti multiId entityId
  +        let oneOf = system.GetMultiplexed multiId entityId
           &oneOf.OneOf
   
  -    member this.RegisterMulti<'t when 't : struct and 't :> Component> systemName entityId comp =
  -        match this.TryGetSystem<SystemMulti<'t, 'w>> systemName with
  +    member this.RegisterMultiplexed<'t when 't : struct and 't :> Component> systemName entityId comp =
  +        match this.TryGetSystem<SystemMultiplexed<'t, 'w>> systemName with
           | Some system ->
  -            let _ = system.RegisterMulti entityId comp
  +            let _ = system.RegisterMultiplexed entityId comp
               match correlations.TryGetValue entityId with
               | (true, correlation) -> correlation.Add systemName
               | (false, _) -> correlations.Add (entityId, List [systemName])
           | None -> failwith ("Could not find expected system '" + systemName + "'.")
   
  -    member this.UnregisterMulti<'t when 't : struct and 't :> Component> systemName multiId entityId =
  -        match this.TryGetSystem<SystemMulti<'t, 'w>> systemName with
  +    member this.UnregisterMultiplexed<'t when 't : struct and 't :> Component> systemName multiId entityId =
  +        match this.TryGetSystem<SystemMultiplexed<'t, 'w>> systemName with
           | Some system ->
  -            if system.UnregisterMulti multiId entityId this then
  +            if system.UnregisterMultiplexed multiId entityId this then
                   match correlations.TryGetValue entityId with
                   | (true, correlation) -> correlation.Add systemName
                   | (false, _) -> correlations.Add (entityId, List [systemName])
  
positive.code: /// However, it uses a dictionary without a small-object optimization, so this functionality won't get the typical
  /// perf benefits of data-orientation. Really, this functionality is here for flexibility and convenience more than
  /// anything else (which is good enough in almost all cases where multi-components are used).
  type [<NoEquality; NoComparison; Struct>] ComponentMulti<'t when 't : struct> =
      internal
          { mutable RefCount : int
            Entries : Dictionary<Guid, 't OneOf> }
  
negative.code:             true
          | (false, _) -> false
  
  and [<AbstractClass>] SystemMultiplexed<'t, 'w when 't : struct and 't :> Component> () =
      inherit SystemCorrelated<'t ComponentMultiplexed, 'w> ()
  
      member this.HasMultiplexed multiId entityId =
          if this.HasComponent entityId then
              let comp = this.GetComponent entityId
              comp.Entries.ContainsKey multiId
          else false
  
      member this.GetMultiplexed multiId entityId =
          let componentMultiplexed = &this.GetComponent entityId
          componentMultiplexed.Entries.[multiId]
  
      member this.RegisterMultiplexed multiId entityId comp ecs =
          let _ = this.RegisterEntity entityId ecs
          let componentMultiplexed = &this.GetComponent entityId
          do componentMultiplexed.RegisterComponent (multiId, comp)
          multiId
  
      member this.UnregisterMultiplexed multiId entityId ecs =
          let componentMultiplexed = &this.GetComponent entityId
          let _ = componentMultiplexed.UnregisterComponent multiId
          this.UnregisterEntity entityId ecs
  
  /// Nu's custom Entity-Component-System implementation.
  