anchor.diff:  
       /// Concatenate two addresses, taking the type of the second address.
       let acats<'a> (address : obj Address) (address2 : 'a Address) =
  -        Address<'a>.makeFromKeys (address.NameKeys @ address2.NameKeys)
  +        Address<'a>.makeFromNameKeys (address.NameKeys @ address2.NameKeys)
       
       /// Concatenate two addresses, forcing the type of second address.
       let acatsf<'a, 'b> (address : 'a Address) (address2 : 'b Address) =
  
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:         
      /// Take the tail of an address.
      let tail<'a> address =
          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 name keys of an address minus a skipped amount of name keys.
      let skip<'a, 'b> n (address : 'a 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>.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>.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 name keys.
      let isEmpty address =
          List.isEmpty address.NameKeys