anchor.diff:          Name.split [|'/'|] name
   
       static member internal getFullName (address : 'a Address) =
  -        match address.OptFullName with
  -        | Some fullName -> fullName
  -        | None ->
  -            let fullName = Address<'a>.join address.Names
  -            address.OptFullName <- Some fullName
  -            fullName
  +        Address<'a>.join address.Names
   
       /// Make an address from a '/' delimited string.
       /// NOTE: do not move this function as the AddressConverter's reflection code relies on it being exactly here!
       static member makeFromFullName fullName =
           let names = Address<'a>.split fullName |> List.ofSeq
  -        { Names = names; OptFullName = Some fullName; OptHashCode = None; TypeCarrier = fun (_ : 'a) -> () }
  +        { Names = names; HashCode = Name.hashNames names; TypeCarrier = fun (_ : 'a) -> () }
   
       /// Hash an Address.
       static member hash (address : 'a Address) =
  -        match address.OptHashCode with
  -        | Some hashCode -> hashCode
  -        | None ->
  -            let hashCode = Name.hashNames address.Names
  -            address.OptHashCode <- Some hashCode
  -            hashCode
  +        address.HashCode
               
       /// Equate Addresses.
       static member equals address address2 =
  
positive.code: 
      /// The empty address.
      let empty<'a> =
          { Names = []; OptFullName = Some Name.empty; OptHashCode = Some 0; TypeCarrier = fun (_ : 'a) -> () }
  
      /// Make an address from names.
      let makeFromNames<'a> names =
          { Names = names |> List.ofSeq; OptFullName = None; OptHashCode = None; TypeCarrier = fun (_ : 'a) -> () }
  
      /// Make an address from a '/' delimited string.
      let makeFromFullName<'a> fullName =
  
negative.code: 
      /// Convert any address to an obj Address.
      let atooa<'a> (address : 'a Address) =
          { Names = address.Names; HashCode = address.HashCode; TypeCarrier = fun (_ : obj) -> () }
  
      /// Concatenate two addresses of the same type.
      let acat<'a> (address : 'a Address) (address2 : 'a Address) =
  