Go 1.18 将引入新的网络地址包

// 内部使用 IPv6 格式。
// IPv4 地址使用 IPv4-in-IPv6 语法。
type IP struct {
  Addr [16]byte
}

type IP struct {
  ipImpl
}

type ipImpl interface {
  is4() bool
  is6() bool
  String() string
}

type v4Addr [4]byte
type v6Addr [16]byte
type v6AddrZone struct {
  v6Addr
  zone string
}

type IP struct {
   addr          [16]byte
   zoneAndFamily uint64
}

type IP struct {
    addr          [16]byte
    zoneAndFamily *T
}

var (
  z0 *T        // nil 表示空值
  z4 = new(T)  // 表示 IPv4
  z6 = new(T)  // 表示 IPv6（没有 zone 信息）
)

ip1, _ := netaddr.ParseIP("fe80::2%eth0")
ip2, _ := netaddr.ParseIP("fe80::2%eth0")
fmt.Println(ip1 == ip2) // true

var (
  mu      sync.Mutex
  valMap  = map[key]uintptr{} // to uintptr(*Value)
)

// Value 保存底层可比较的值
type Value struct {
  _      [0]func() // 禁止比较 Value 对象
  cmpVal interface{}
  // resurrected 由 mu 保护并发读写。
  // 只要有地方引用 cmpVal 就会被设为 true
  resurrected bool
}

func GetByString(s string) *Value {
  return get(key{s: s, isString: true})
}

// get 方法违返了 unsafe 的使用规则，所以要添加 nocheckptr 指令
//go:nocheckptr
func get(k key) *Value {
  mu.Lock()
  defer mu.Unlock()
  
  var v *Value
  if addr, ok := valMap[k]; ok {
  // 如果是已经存在的值，则标记并发访问
  	v = (*Value)((unsafe.Pointer)(addr))
  	v.resurrected = true
  }
  if v != nil {
  	return v
  }
  v = k.Value()
  // 设置垃圾回收回调函数
  // Go 在回收 v 之前如果发现有 finalize 函数，
  // 会清空并调用 finalize，期望在下一个周期回收。
  runtime.SetFinalizer(v, finalize)
  // 参考 https://pkg.go.dev/unsafe#Pointer
  // Go 语言要求 unsafe.Pointer 转成 uintptr 之后
  // 要在同一个表达式中转回 unsafe.Pointer
  // 但此处将其保存到 valMap
  valMap[k] = uintptr(unsafe.Pointer(v))
  return v
}

func finalize(v *Value) {
  mu.Lock()
  defer mu.Unlock()
  if v.resurrected {
    // 进入本分支说明在垃圾回收过程中有别的协程
    // 引用了当前 v，所以不能删除
    v.resurrected = false
    runtime.SetFinalizer(v, finalize)
    return
  }
  delete(valMap, keyFor(v.cmpVal))
}

intern.GetByString("eth0") == intern.GetByString("eth0")

type IP struct {
  addr [16]byte
  z    *intern.Value // 区域和类型
}

var (
  z0    *intern.Value        // nil 表示空值
  z4    = new(intern.Value)  // 表示 IPv4
  z6noz = new(intern.Value)  // 表示 IPv6 （没有区域）
)

func (ip IP) Zone() string {
  if ip.z == nil {
    return ""
  }
  zone, _ := ip.z.Get().(string)
  return zone
}

func (ip IP) WithZone(zone string) IP {
  if !ip.Is6() {
    return ip
  }
  if zone == "" {
    ip.z = z6noz
    return ip
  }
  ip.z = intern.GetByString(zone)
  return ip
}

type IP struct {
  // hi and lo are the bits of an IPv6 address. If z==z4, hi and lo
  // contain the IPv4-mapped IPv6 address.
  //
  // hi and lo are constructed by interpreting a 16-byte IPv6
  // address as a big-endian 128-bit number. The most significant
  // bits of that number go into hi, the rest into lo.
  //
  // For example, 0011:2233:4455:6677:8899:aabb:ccdd:eeff is stored as:
  //  hi = 0x0011223344556677
  //  lo = 0x8899aabbccddeeff
  //
  // We store IPs like this, rather than as [16]byte, because it
  // turns most operations on IPs into arithmetic and bit-twiddling
  // operations on 64-bit registers, which is much faster than
  // bytewise processing.
  hi, lo uint64
  
  // z is a combination of the address family and the IPv6 zone.
  z *intern.Value
}

type uint128 [2]uint64

type IP struct {
  addr uint128
  z    *intern.Value
}

type uint128 struct {
  hi uint64
  lo uint64
}