anchor.diff:  
       member this.IndexSystem<'s when 's :> 'w System> systemName =
           this.TryIndexSystem<'s> systemName |> Option.get
  +
  +    member this.ProcessUpdate world =
  +        Seq.fold
  +            (fun world (_, system : 'w System) -> system.ProcessUpdate this world)
  +            world systemsOrdered
  +
  +    member this.ProcessPostUpdate world =
  +        Seq.fold
  +            (fun world (_, system : 'w System) -> system.ProcessPostUpdate this world)
  +            world systemsOrdered
  +
  +    member this.ProcessActualize world =
  +        Seq.fold
  +            (fun world (_, system : 'w System) -> system.ProcessActualize this world)
  +            world systemsOrdered
   
   /// An Ecs system with just a single component.
   and [<AbstractClass>] SystemSingleton<'t, 'w when 't : struct and 't :> Component> (comp : 't) =
  
positive.code: 
  namespace Nu
  open System
  open System.IO
  open System.Collections.Generic
  open Prime
  
  /// The base component type of an Ecs.
  
negative.code:     abstract ProcessActualize : 'w Ecs -> 'w -> 'w
      default this.ProcessActualize _ world = world
  
  /// A collection of subsystems that can be run in parallel.
  and 'w SystemParallel () =
      inherit System<'w> ()
  
      let subsystems =
          dictPlus [] : Dictionary<string, 'w System>
  
      let processParallel fn =
          subsystems |>
          Seq.map (fun entry -> Task.Run (fun () -> fn entry.Value Unchecked.defaultof<'w> : 'w) |> Vsync.AwaitTask) |>
          Vsync.Parallel
  
      member this.RegisterSubsystem subsystemName subsystem =
          subsystems.[subsystemName] <- subsystem
  
      member this.UnregisterSubsystem subsystemName =
          subsystems.Remove subsystemName
  
      override this.ProcessUpdate ecs world =
          let _ = Vsync.RunSynchronously (processParallel (fun system -> system.ProcessUpdate ecs))
          world
  
      override this.ProcessPostUpdate ecs world =
          let _ = Vsync.RunSynchronously (processParallel (fun system -> system.ProcessPostUpdate ecs))
          world
  
      override this.ProcessActualize ecs world =
          let _ = Vsync.RunSynchronously (processParallel (fun system -> system.ProcessPostUpdate ecs))
          world
  
  /// A system with zero to many components.
  and [<AbstractClass>] 'w SystemMany () =
      inherit System<'w> ()
  