anchor.diff:          
       /// Take the tail of an address.
       let tail<'a> address =
  -        Address<'a>.makeFromKeys <| List.tail address.NameKeys
  +        Address<'a>.makeFromNameKeys <| List.tail address.NameKeys
   
       /// Take a name key of an address.
       let at index address =
           List.at index address.NameKeys
   
  -    /// Take an address composed of the names of an address minus a skipped amount of names.
  +    /// Take an address composed of the name keys of an address minus a skipped amount of name keys.
       let skip<'a, 'b> n (address : 'a Address) =
  -        Address<'b>.makeFromKeys <| List.skip n address.NameKeys
  -
  -    /// Take an address composed of the given number of names of an address.
  +        Address<'b>.makeFromNameKeys <| List.skip n address.NameKeys
  +
  +    /// Take an address composed of the given number of name keys of an address.
       let take<'a, 'b> n (address : 'a Address) =
  -        Address<'b>.makeFromKeys <| List.take n address.NameKeys
  -
  -    /// Take the last name of an address.
  +        Address<'b>.makeFromNameKeys <| List.take n address.NameKeys
  +
  +    /// Take the last name key of an address.
       let last address =
           List.last address.NameKeys
   
       /// Take an address composed of all but the last name of an address.
       let allButLast<'a, 'b> (address : 'a Address) =
  -        Address<'b>.makeFromKeys <| List.allButLast address.NameKeys
  -
  -    /// Get the length of an address by its names.
  +        Address<'b>.makeFromNameKeys <| List.allButLast address.NameKeys
  +
  +    /// Get the length of an address by its name keys.
       let length address =
           List.length address.NameKeys
   
  -    /// Query that an address is devoid of names.
  +    /// Query that an address is devoid of name keys.
       let isEmpty address =
           List.isEmpty address.NameKeys
positive.code:         static member internal split (str : string) =
              List.ofArray <| str.Split '/'
  
          /// Make an address from a list of names.
          static member makeFromKeys keys =
              { NameKeys = keys; OptNamesStr = None; OptHashCode = None; TypeCarrier = fun (_ : 'a) -> () }
  
          /// Make an address from a list of names.
          static member makeFromList list =
              let keys = List.map NameKey.make list
              Address<'a>.makeFromKeys keys
  
          /// Make an address from a list of names.
          static member makeFromStrAndKeys str keys =
              { NameKeys = keys; OptNamesStr = Some str; OptHashCode = None; TypeCarrier = fun (_ : 'a) -> () }
  
          /// Make an address from a '/' delimited string.
          static member makeFromString str =
              let list = Address<'a>.split str
              let keys = List.map NameKey.make list
              { NameKeys = keys; OptNamesStr = Some str; OptHashCode = None; TypeCarrier = fun (_ : 'a) -> () }
  
          /// Convert a string into a list.
          static member stoa (str : string) =
              Address<'a>.makeFromString str
  
          /// The empty address.
          static member empty =
              { NameKeys = []; OptNamesStr = Some String.Empty; OptHashCode = Some 0; TypeCarrier = fun (_ : 'a) -> () }
  
          /// TODO: document!
          static member getNamesStr (address : 'a Address) =
  
negative.code:                 if targetType.IsInstanceOfType source then source
                  else failwith "Invalid AddressConverter conversion from source."
  
      /// Convert a names string into an address.
      let stoa<'a> namesStr =
          Address<'a>.stoa namesStr
  
      /// Convert a name keys into an address.
      let ktoa<'a> nameKeys =
          Address<'a>.makeFromNameKeys nameKeys
  
      /// Convert a names list into an address.
      let ltoa<'a> namesList =
          Address<'a>.makeFromNamesList namesList
  
      /// Convert a name string into an address.
      let ntoa<'a> nameStr =
          ltoa<'a> [nameStr]
  
      /// Convert any address to an obj Address.
      let atooa<'a> (address : 'a Address) =
  