anchor.diff:                  | None -> Map.empty
               | _ -> failwith <| "Invalid group address '" + acstring groupRep.GroupAddress + "'."
   
  -        static member private getOptEntity entityRep world =
  +        static member internal getOptEntity entityRep world =
               World.optEntityFinder entityRep.EntityAddress world
   
  -        static member private getEntity (entityRep : EntityRep) world =
  +        static member internal getEntity (entityRep : EntityRep) world =
               Option.get ^ World.getOptEntity entityRep world
   
  -        static member private setEntityWithoutEvent entity entityRep world =
  +        static member internal setEntityWithoutEvent entity entityRep world =
               World.entityAdder entity entityRep.EntityAddress world
   
  -        static member private setOptEntityWithoutEvent optEntity entityRep world =
  +        static member internal setOptEntityWithoutEvent optEntity entityRep world =
               match optEntity with 
               | Some entity -> World.entityAdder entity entityRep.EntityAddress world
               | None -> World.entityRemover entityRep.EntityAddress world
   
  -        static member private setEntity entity (entityRep : EntityRep) world =
  +        static member internal setEntity entity (entityRep : EntityRep) world =
               let oldWorld = world
               let world = World.entityAdder entity entityRep.EntityAddress world
               if entity.PublishChanges then
  
positive.code:             let screen = Screen.make dispatcher None
              Reflection.attachFields screen.DispatcherNp screen
              Reflection.readPropertiesToTarget screenNode screen
              let groupHierarchies = World.readGroupHierarchies (screenNode : XmlNode) defaultGroupDispatcherName defaultEntityDispatcherName world
              (screen, groupHierarchies)
  
          /// Read a screen hierarchy from an xml file.
          static member readScreenHierarchyFromFile (filePath : string) world =
              use reader = XmlReader.Create filePath
              let document = let emptyDoc = XmlDocument () in (emptyDoc.Load reader; emptyDoc)
              let rootNode = document.[RootNodeName]
              let screenNode = rootNode.[ScreenNodeName]
              World.readScreenHierarchy
                  screenNode
                  typeof<ScreenDispatcher>.Name
                  typeof<GroupDispatcher>.Name
                  typeof<EntityDispatcher>.Name
                  world
  
          /// Read multiple screen hierarchies from an xml node.
          static member readScreenHierarchies
              (gameNode : XmlNode) defaultDispatcherName defaultGroupDispatcherName defaultEntityDispatcherName world =
              match gameNode.SelectSingleNode ScreensNodeName with
              | null -> Map.empty
              | screensNode ->
                  let screenNodes = screensNode.SelectNodes ScreenNodeName
                  Seq.fold
                      (fun screenHierarchies screenNode ->
                          let screenHierarchy =
                              World.readScreenHierarchy
                                  screenNode
                                  defaultDispatcherName
                                  defaultGroupDispatcherName
                                  defaultEntityDispatcherName
                                  world
                          let screenName = (fst screenHierarchy).Name
                          Map.add screenName screenHierarchy screenHierarchies)
                      Map.empty
                      (enumerable screenNodes)
  
          (* Game *)
  
          /// Get the game, then transform it with the 'by' procudure.
          static member getGameBy by world =
              by <| fst world.Simulants
  
          /// Get the game.
          static member getGame world =
              World.getGameBy id world
  
          /// Get the game hierarchy.
          static member getGameHierarchy world =
              let game = World.getGame world
              let screenMap = World.getScreenMap world
              (game, screenMap)
  
          /// Set the game.
          static member setGame game world =
              let oldWorld = world
              let screenMap = World.getScreenMap world
              let world = { world with Simulants = (game, screenMap) }
              if game.PublishChanges then
                  World.publish4
                      { OldWorld = world; SimulantRep = World.GameRep }
                      (World.GameChangeEventAddress ->>- World.GameAddress)
                      World.GameRep
                      world
              else world
  
          /// Update the game with the given 'updater' procedure.
          static member updateGameAndW updater world =
              let game = World.getGame world
              let (game, world) = updater game world
              World.setGame game world
  
          /// Update the game with the given 'updater' procedure.
          static member updateGameW updater world =
              World.updateGameAndW (fun game world -> (updater game world, world)) world
  
          /// Update the game with the given 'updater' procedure.
          static member updateGame updater world =
              World.updateGameW (fun game _ -> updater game) world
  
          /// Update the world with the given 'updater' procedure that uses the game in its
          /// computation.
          static member updateByGame updater world : World =
              let game = World.getGame world
              updater game world
  
          /// Lens the game.
          static member lensGame =
              { Get = World.getGame
                Set = World.setGame }
  
          /// Register a game when adding it to the world. Note that there is not corresponding
          /// Unregister method due to the inability to remove a game from the world.
          static member registerGame (gameRep : GameRep) (world : World) : World =
              let dispatcher = gameRep.GetDispatcherNp world : GameDispatcher
              dispatcher.Register gameRep world
  
          /// Try to get the address of the currently selected screen.
          static member getOptSelectedScreenRep world =
              let game = World.getGame world
              game.OptSelectedScreenRep
          
          /// Set the address of the currently selected screen to Some Address or None. Be careful
          /// using this function directly as you may be wanting to use the higher-level
          /// World.transitionScreen function.
          static member setOptSelectedScreenRep optScreenRep world =
              World.updateGame (Game.setOptSelectedScreenRep optScreenRep) world
          
          /// Get the address of the currently selected screen (failing with an exception if there
          /// isn't one).
          static member getSelectedScreenRep world =
  
negative.code:                 | None -> world
              | _ -> failwith <| "Invalid group address '" + acstring address + "'."
  
          static member internal getGroupMapInScreen screenRep world =
              match screenRep.ScreenAddress.Names with
              | [screenName] ->
                  let (_, screenMap) = world.Simulants
  