// IP address lengths (bytes).
const (
	IPv4len = 4
	IPv6len = 16
)

// An IP is a single IP address, a slice of bytes.
// Functions in this package accept either 4-byte (IPv4)
// or 16-byte (IPv6) slices as input.
//
// Note that in this documentation, referring to an
// IP address as an IPv4 address or an IPv6 address
// is a semantic property of the address, not just the
// length of the byte slice: a 16-byte slice can still
// be an IPv4 address.
type IP []byte

type Addr struct {
	// addr is the hi and lo 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:
	//  addr.hi = 0x0011223344556677
	//  addr.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.
	addr uint128

	// z is a combination of the address family and the IPv6 zone.
	//
	// nil means invalid IP address (for a zero Addr).
	// z4 means an IPv4 address.
	// z6noz means an IPv6 address without a zone.
	//
	// Otherwise it's the interned zone name string.
	z *intern.Value
}

// uint128 represents a uint128 using two uint64s.
//
// When the methods below mention a bit number, bit 0 is the most
// significant bit (in hi) and bit 127 is the lowest (lo&1).
type uint128 struct {
	hi uint64
	lo uint64
}

// z0, z4, and z6noz are sentinel IP.z values.
// See the IP type's field docs.
var (
	z0    = (*intern.Value)(nil)
	z4    = new(intern.Value)
	z6noz = new(intern.Value)
)

// Zone returns ip's IPv6 scoped addressing zone, if any.
func (ip Addr) Zone() string {
	if ip.z == nil {
		return ""
	}
	zone, _ := ip.z.Get().(string)
	return zone

// WithZone returns an IP that's the same as ip but with the provided
// zone. If zone is empty, the zone is removed. If ip is an IPv4
// address, WithZone is a no-op and returns ip unchanged.
func (ip Addr) WithZone(zone string) Addr {
	if !ip.Is6() {
		return ip
	}
	if zone == "" {
		ip.z = z6noz
		return ip
	}
	ip.z = intern.GetByString(zone)
	return ip
}

// parseIPv6 parses s as an IPv6 address (in form "2001:db8::68").
func parseIPv6(in string) (Addr, error) {

...省略...
return AddrFrom16(ip).WithZone(zone), nil
}

package main

import (
	"fmt"
	"net/netip"
)

func main() {
	ip0, _ := netip.ParseAddr("")
	ip1, _ := netip.ParseAddr("fe80::2%eth0")
	fmt.Println(ip0.IsValid())
	fmt.Println(ip1.IsValid())
}

package main

import (
	"fmt"
	"net/netip"
)

func main() {
	ip1, _ := netip.ParseAddr("fe80::2%eth0")
	ip2, _ := netip.ParseAddr("fe80::2%eth0")
    ip3, _ := netip.ParseAddr("192.0.2.1")
	fmt.Println(ip1 == ip2)
	fmt.Println(ip1 != ip2)
    fmt.Println(ip1 == ip3)
}

package main

import (
	"fmt"
	"net/netip"
)

func main() {
	ip1, _ := netip.ParseAddr("fe80::2%eth0")
	expIp1 := ip1.StringExpanded()
	fmt.Println(expIp1)
	fmt.Printf("%T\n", ip1)
	fmt.Printf("%T\n", expIp1)
}

package main

import (
	"fmt"
	"net/netip"
)

func main() {
	ip1, _ := netip.ParseAddr("fe80::2%eth0")
	ip3, _ := netip.ParseAddr("192.0.2.1")
	fmt.Println(ip1.BitLen())
	fmt.Println(ip3.BitLen())
}