fn pub static parse(address: String) -> Option[IpAddress] {
  if address.contains?(':') {
    Ipv6Address.parse(address).map(fn (v) { V6(v) })
  } else {
    Ipv4Address.parse(address).map(fn (v) { V4(v) })
  }
}

fn pub static v4(a: Int, b: Int, c: Int, d: Int) -> IpAddress {
  V4(Ipv4Address.new(a, b, c, d))
}

fn pub static v6(
  a: Int,
  b: Int,
  c: Int,
  d: Int,
  e: Int,
  f: Int,
  g: Int,
  h: Int,
) -> IpAddress {
  V6(Ipv6Address.new(a, b, c, d, e, f, g, h))
}

fn pub !=(other: T) -> Bool {
  (self == other).false?
}

fn pub ==(other: ref IpAddress) -> Bool {
  match self {
    case V4(a) -> {
      match other {
        case V4(b) -> a == b
        case _ -> false
      }
    }
    case V6(a) -> {
      match other {
        case V6(b) -> a == b
        case _ -> false
      }
    }
  }
}

fn pub clone -> IpAddress {
  match self {
    case V4(ip) -> IpAddress.V4(ip.clone)
    case V6(ip) -> IpAddress.V6(ip.clone)
  }
}

fn pub documentation? -> Bool {
  match self {
    case V4(ip) -> ip.documentation?
    case V6(ip) -> ip.documentation?
  }
}

fn pub fmt(formatter: mut Formatter) {
  formatter.write(to_string)
}

fn pub move into_string -> String {
  match self {
    case V4(ip) -> ip.into_string
    case V6(ip) -> ip.into_string
  }
}

fn pub loopback? -> Bool {
  match self {
    case V4(ip) -> ip.loopback?
    case V6(ip) -> ip.loopback?
  }
}

fn pub multicast? -> Bool {
  match self {
    case V4(ip) -> ip.multicast?
    case V6(ip) -> ip.multicast?
  }
}

fn pub to_string -> String {
  match self {
    case V4(ip) -> ip.to_string
    case V6(ip) -> ip.to_string
  }
}

fn pub unspecified? -> Bool {
  match self {
    case V4(ip) -> ip.unspecified?
    case V6(ip) -> ip.unspecified?
  }
}

fn pub v4? -> Bool {
  match self {
    case V4(_) -> true
    case _ -> false
  }
}

fn pub v6? -> Bool {
  match self {
    case V6(_) -> true
    case _ -> false
  }
}