anchor.diff:  /// Allows an entity to contain multiple of the same component.
   /// 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). Just make sure to
  -/// interface with the involved systems directly rather than through the Ecs API which indexes them implcitly.
  +/// anything else (which is good enough in almost all cases where multiplexing is used).
   type [<NoEquality; NoComparison; Struct>] ComponentMultiplexed<'c when 'c : struct and 'c :> 'c Component> =
       { mutable Active : bool
  -      Simplexes : Dictionary<Guid, 'c Simplex>
  +      Simplexes : Dictionary<string, 'c Simplex>
         TypeName : string }
       interface Component<'c ComponentMultiplexed> with
           member this.Active with get () = this.Active and set value = this.Active <- value
  
positive.code:         member this.Junction _ _ _ _ = this
          member this.Disjunction _ _ _ = ()
          member this.TypeName = getTypeName this
      member this.RegisterMultiplexed (multiId, comp) =
          this.Simplexes.Add (multiId, { Simplex = comp })
      member this.UnregisterMultiplexed multiId =
          this.Simplexes.Remove multiId
  
  /// An Ecs system that stores multiple components per entity id.
  type SystemMultiplexed<'c, 'w when 'c : struct and 'c :> 'c Component> (buffered, ecs : 'w Ecs) =
      inherit SystemCorrelated<'c ComponentMultiplexed, 'w> (buffered, ecs)
  
      new (ecs) = SystemMultiplexed (false, ecs)
  
      member this.QualifyMultiplexed multiId entityId =
          if this.QualifyCorrelated entityId then
              let comp = this.IndexCorrelated entityId
              comp.Index.Simplexes.ContainsKey multiId
          else false
  
      member this.IndexMultiplexed multiId entityId =
          let componentMultiplexed = this.IndexCorrelated entityId
          componentMultiplexed.Index.Simplexes.[multiId]
  
      member this.IndexMultiplexedBuffered multiId entityId =
          let componentMultiplexed = this.IndexCorrelated entityId
          componentMultiplexed.IndexBuffered.Simplexes.[multiId]
  
      member this.RegisterMultiplexed comp multiId entityId ecs =
          let _ = this.RegisterCorrelated Unchecked.defaultof<_> entityId ecs
          let componentMultiplexed = this.IndexCorrelated entityId
          componentMultiplexed.Index.RegisterMultiplexed (multiId, comp)
          componentMultiplexed
  
      member this.UnregisterMultiplexed multiId entityId ecs =
          let componentMultiplexed = this.IndexCorrelated entityId
          componentMultiplexed.Index.UnregisterMultiplexed multiId |> ignore<bool>
          this.UnregisterCorrelated entityId ecs
  
      type 'w Ecs with
  
          member this.QualifyMultiplexed<'c when 'c : struct and 'c :> 'c Component> multiId entityId =
              let systemOpt = this.TryIndexSystem<'c, SystemMultiplexed<'c, 'w>> ()
              if Option.isNone systemOpt then failwith ("Could not find expected system '" + Unchecked.defaultof<'c>.TypeName + "'.")
              let system = Option.get systemOpt
              system.QualifyMultiplexed multiId entityId
  
          member this.IndexMultiplexed<'c when 'c : struct and 'c :> 'c Component> multiId entityId =
              let systemOpt = this.TryIndexSystem<'c, SystemMultiplexed<'c, 'w>> ()
              if Option.isNone systemOpt then failwith ("Could not find expected system '" + Unchecked.defaultof<'c>.TypeName + "'.")
              let system = Option.get systemOpt
              let simplex = system.IndexMultiplexed multiId entityId
              &simplex.Simplex
  
          member this.IndexMultiplexedBuffered<'c when 'c : struct and 'c :> 'c Component> multiId entityId =
              let systemOpt = this.TryIndexSystem<'c, SystemMultiplexed<'c, 'w>> ()
              if Option.isNone systemOpt then failwith ("Could not find expected system '" + Unchecked.defaultof<'c>.TypeName + "'.")
              let system = Option.get systemOpt
              let simplex = system.IndexMultiplexedBuffered multiId entityId
              simplex.Simplex
  
          member this.RegisterMultiplexed<'c when 'c : struct and 'c :> 'c Component> comp multiId entityId =
              match this.TryIndexSystem<'c, SystemMultiplexed<'c, 'w>> () with
              | Some system ->
                  let _ = system.RegisterMultiplexed comp multiId entityId
                  match this.Correlations.TryGetValue entityId with
                  | (true, correlation) -> correlation.Add Unchecked.defaultof<'c>.TypeName
                  | (false, _) -> this.Correlations.Add (entityId, List [Unchecked.defaultof<'c>.TypeName])
              | None -> failwith ("Could not find expected system '" + Unchecked.defaultof<'c>.TypeName + "'.")
  
          member this.UnregisterMultiplexed<'c when 'c : struct and 'c :> 'c Component> multiId entityId =
              match this.TryIndexSystem<'c, SystemMultiplexed<'c, 'w>> () with
              | Some system ->
                  if system.UnregisterMultiplexed multiId entityId this then
                      match this.Correlations.TryGetValue entityId with
                      | (true, correlation) -> correlation.Add Unchecked.defaultof<'c>.TypeName
                      | (false, _) -> this.Correlations.Add (entityId, List [Unchecked.defaultof<'c>.TypeName])
  
negative.code:             let system = Option.get systemOpt
              &system.Component
  
  /// An ECS system with components stored by an integer index in an unordered fashion.
  type SystemUnordered<'c, 'w when 'c : struct and 'c :> 'c Component> (buffered, ecs : 'w Ecs) =
      inherit System<'w> (Unchecked.defaultof<'c>.TypeName)
  
  