anchor.diff:                      world
               else world
   
  +        static member internal updateScreen updater screenRep world =
  +            let screen = World.getScreen screenRep world
  +            let screen = updater screen
  +            World.setScreen screen screenRep world
  +
  +        static member private registerScreen (screenRep : ScreenRep) world =
  +            let dispatcher = screenRep.GetDispatcherNp world : ScreenDispatcher
  +            dispatcher.Register screenRep world
  +
  +        static member private unregisterScreen (screenRep : ScreenRep) world =
  +            let dispatcher = screenRep.GetDispatcherNp world : ScreenDispatcher
  +            dispatcher.Unregister screenRep world
  +
  +        static member private addScreen screenHierarchy screenRep world =
  +            let (screen, groupHierarchies) = screenHierarchy
  +            if not <| World.containsScreen screenRep world then
  +                let world = World.setScreenWithoutEvent screen screenRep world
  +                let world = World.addGroups groupHierarchies screenRep world
  +                let world = World.registerScreen screenRep world
  +                World.publish4 () (World.ScreenAddEventAddress ->>- screenRep.ScreenAddress) screenRep world
  +            else failwith <| "Adding a screen that the world already contains at address '" + acstring screenRep.ScreenAddress + "'."
  +
           /// Query that the world contains a group at the given address.
           static member containsScreen screenRep world =
               Option.isSome <| World.optScreenFinder screenRep.ScreenAddress world
  
positive.code:             File.Move (filePathTmp, filePath)
  
          /// Write multiple screen hierarchies to an xml writer.
          static member writeScreenHierarchies (writer : XmlWriter) screenHierarchies world =
              let screenHierarchies =
                  List.sortBy
                      (fun (screen : Screen, _) -> screen.CreationTimeNp)
                      (Map.toValueList screenHierarchies)
              let screenHierarchies = List.filter (fun (screen : Screen, _) -> screen.Persistent) screenHierarchies
              for screenHierarchy in screenHierarchies do
                  writer.WriteStartElement ScreenNodeName
                  World.writeScreenHierarchy writer screenHierarchy world
                  writer.WriteEndElement ()
  
          /// Read a screen hierarchy from an xml node.
          static member readScreenHierarchy
              (screenNode : XmlNode) defaultDispatcherName defaultGroupDispatcherName defaultEntityDispatcherName world =
              let dispatcherName = Reflection.readDispatcherName defaultDispatcherName screenNode
              let dispatcher =
                  match Map.tryFind dispatcherName world.Components.ScreenDispatchers with
  
negative.code:             Reflection.attachFields dispatcher entity
  
              // apply the entity's overlay
              let entity =
                  match entity.OptOverlayName with
                  | Some overlayName ->
  
                      // OPTIMIZATION: apply overlay only when it will change something (EG - when it's not the intrinsic overlay)
                      if intrinsicOverlayName <> overlayName then
                          let facetNames = Entity.getFacetNamesReflectively entity
                          Overlayer.applyOverlay intrinsicOverlayName overlayName facetNames entity world.State.Overlayer
                          entity
                      else entity
                  | None -> entity
  
              // add entity to world
              let entityRep = { EntityAddress = World.gatoea groupRep.GroupAddress entity.Name }
              let world = World.addEntity entity entityRep world
              (entityRep, world)
  
          /// Write an entity to an xml writer.
          static member writeEntity (writer : XmlWriter) (entityRep : EntityRep) world =
              let entity = World.getEntity entityRep world
              let dispatcher = entity.DispatcherNp
              let dispatcherTypeName = Reflection.getTypeName dispatcher
              writer.WriteAttributeString (DispatcherNameAttributeName, dispatcherTypeName)
              let shouldWriteProperty = fun propertyName propertyType (propertyValue : obj) ->
                  if propertyName = "OptOverlayName" && propertyType = typeof<string option> then
                      let defaultOptOverlayName = Map.find dispatcherTypeName world.State.OverlayRouter
                      defaultOptOverlayName <> (propertyValue :?> string option)
                  else
                      let facetNames = Entity.getFacetNamesReflectively entity
  