anchor.diff:            LayerProperties = Map.empty
             Entities = [] }
   
  +    /// Derive a name from the dispatcher.
  +    static member getNameOpt dispatcher =
  +        dispatcher.LayerProperties |>
  +        Map.tryFind (Property? Name) |>
  +        Option.map symbolToValue<string>
  +
       interface SimulantDescriptor with
           member this.Children =
               this.Entities |> enumerable<SimulantDescriptor> |> List.ofSeq
  
positive.code:     static member empty =
          { EntityDispatcher = String.Empty
            EntityProperties = Map.empty }
  
      interface SimulantDescriptor with
          member this.Children = []
  
negative.code: module Describe =
  
      /// Describe a game with the given properties values and contained screens.
      let game<'d when 'd :> GameDispatcher> (properties : (World PropertyTag * obj) seq) (screens : ScreenDescriptor seq) =
          let properties = properties |> Seq.map (fun (tag : World PropertyTag, value) -> (tag.Name, valueToSymbol value)) |> Map.ofSeq
          { GameDispatcher = typeof<'d>.Name
            GameProperties = properties
            Screens = List.ofSeq screens }
  
      /// Describe a screen with the given properties values and contained layers.
      let screen<'d when 'd :> ScreenDispatcher> (properties : (World PropertyTag * obj) seq) (layers : LayerDescriptor seq) =
          let properties = properties |> Seq.map (fun (tag : World PropertyTag, value) -> (tag.Name, valueToSymbol value)) |> Map.ofSeq
          { ScreenDispatcher = typeof<'d>.Name
            ScreenProperties = properties
            Layers = List.ofSeq layers }
  
      /// Describe a layer with the given properties values and contained entities.
      let layer<'d when 'd :> LayerDispatcher> (properties : (World PropertyTag * obj) seq) (entities : EntityDescriptor seq) =
          let properties = properties |> Seq.map (fun (tag : World PropertyTag, value) -> (tag.Name, valueToSymbol value)) |> Map.ofSeq
          { LayerDispatcher = typeof<'d>.Name
            LayerProperties = properties
            Entities = List.ofSeq entities }
  
      /// Describe an entity with the given properties values.
      let entity<'d when 'd :> EntityDispatcher> (properties : (World PropertyTag * obj) seq) =
          let properties = properties |> Seq.map (fun (tag : World PropertyTag, value) -> (tag.Name, valueToSymbol value)) |> Map.ofSeq
          { EntityDispatcher = typeof<'d>.Name
            EntityProperties = properties }
  
      let prop (p : PropertyTag<'a, World>) (v : 'a) =
          (p :> PropertyTag<World>, v :> obj)
  