bend-kit-netip Releases (1): 0.1.0.0 0x2997b34519267605d9e11af48ae387c7 indexed https://jend.leeeet.dev/files.txt?path=bend-kit-netip@0.1.0.0 Definitions (67): Netip.Addr (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=Addr) # V4: the address as one big-endian word. V6: four network-order words, a first. type Addr is Data: V4{word: U32} V6{a: U32, b: U32, c: U32, d: U32} Netip.hexval (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hexval) # A hex digit's value, or 16 when c is not one. def hexval(+c: U32) -> U32: Netip.hex.step (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hex.step) def hex.step(+d: U32, acc: Maybe<&2, U32>) -> Maybe<&2, U32>: Netip.hex.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hex.go) def hex.go(s: String, acc: Maybe<&2, U32>) -> Maybe<&2, U32>: Netip.hextet.ok (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hextet.ok) def hextet.ok(ok: Bool, s: String) -> Maybe<&2, U32>: Netip.hextet (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hextet) # One IPv6 group: 1 to 4 hex digits, either case. def hextet(+s: String) -> Maybe<&2, U32>: Netip.dec.step (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=dec.step) # A non-digit wraps past 9 in (c - 48), so it fails the digit test. def dec.step(+d: U32, acc: Maybe<&2, U32>) -> Maybe<&2, U32>: Netip.dec.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=dec.go) def dec.go(s: String, acc: Maybe<&2, U32>) -> Maybe<&2, U32>: Netip.octet.lead (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=octet.lead) # 1 to 3 characters, and no leading zero unless the octet is "0". def octet.lead(s: String) -> Bool: Netip.octet.max (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=octet.max) def octet.max(m: Maybe<&2, U32>) -> Maybe<&2, U32>: Netip.octet.ok (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=octet.ok) def octet.ok(ok: Bool, s: String) -> Maybe<&2, U32>: Netip.octet (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=octet) def octet(+s: String) -> Maybe<&2, U32>: Netip.v4.parts (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v4.parts) def v4.parts(ps: List<&2, String>) -> Maybe<&2, U32>: Netip.v4.word (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v4.word) # Dotted-decimal IPv4 as its big-endian word. def v4.word(s: String) -> Maybe<&2, U32>: Netip.v4.wrap (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v4.wrap) def v4.wrap(m: Maybe<&2, U32>) -> Maybe<&2, Addr>: Netip.v4 (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v4) def v4(s: String) -> Maybe<&2, Addr>: Netip.Walk (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=Walk) # Groups read so far, each list newest first. Gap: "::" was seen; post holds the groups after it. type Walk is Data: NoGap{pre: List<&2, U32>} Gap{pre: List<&2, U32>, post: List<&2, U32>} Netip.walk.push (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=walk.push) def walk.push(st: Walk, +g: U32) -> Walk: Netip.v6.hex (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.hex) def v6.hex(w: Walk, m: Maybe<&2, U32>) -> Maybe<&2, Walk>: Netip.v6.gap (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.gap) # An empty inner segment is the one "::". def v6.gap(w: Walk) -> Maybe<&2, Walk>: Netip.v6.mid.seg (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.mid.seg) def v6.mid.seg(h: String, w: Walk) -> Maybe<&2, Walk>: Netip.v6.mid (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.mid) def v6.mid(st: Maybe<&2, Walk>, h: String) -> Maybe<&2, Walk>: Netip.v6.trail (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.trail) # An empty last segment is the second colon of a trailing "::". def v6.trail(w: Walk) -> Maybe<&2, Walk>: Netip.v6.dot (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.dot) # Embedded dotted IPv4 fills the last two groups. def v6.dot(w: Walk, m: Maybe<&2, U32>) -> Maybe<&2, Walk>: Netip.v6.last.kind (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.last.kind) def v6.last.kind(dot: Bool, w: Walk, s: String) -> Maybe<&2, Walk>: Netip.v6.last.text (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.last.text) def v6.last.text(w: Walk, +s: String) -> Maybe<&2, Walk>: Netip.v6.last.seg (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.last.seg) def v6.last.seg(h: String, w: Walk) -> Maybe<&2, Walk>: Netip.v6.last (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.last) def v6.last(st: Maybe<&2, Walk>, h: String) -> Maybe<&2, Walk>: Netip.v6.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.go) # h: the current segment; t: the segments after it. def v6.go(t: List<&2, String>, h: String, st: Maybe<&2, Walk>) -> Maybe<&2, Walk>: Netip.v6.words (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.words) def v6.words(gs: List<&2, U32>) -> Maybe<&2, Addr>: Netip.v6.pad (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.pad) # "::" stands for at least one zero group. def v6.pad(ok: Bool, pre: List<&2, U32>, post: List<&2, U32>, n: Nat) -> Maybe<&2, Addr>: Netip.v6.fill (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.fill) def v6.fill(w: Walk) -> Maybe<&2, Addr>: Netip.v6.fin (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.fin) def v6.fin(m: Maybe<&2, Walk>) -> Maybe<&2, Addr>: Netip.v6 (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6) # The ":"-split segments. Only a leading "::" may start with an empty segment. def v6(ps: List<&2, String>) -> Maybe<&2, Addr>: Netip.parse.fam (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=parse.fam) def parse.fam(colon: Bool, s: String) -> Maybe<&2, Addr>: Netip.parse (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=parse) # Strict address text: 4 dotted-decimal octets, or RFC 4291 IPv6 with at most one "::" and an optional # trailing dotted IPv4. No brackets, zones, ports, or surrounding space. def parse(+s: String) -> Maybe<&2, Addr>: Netip.hex.char (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hex.char) # Hex fields contain no leading zeros. def hex.char(+n: U32) -> String: Netip.hex.two (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hex.two) def hex.two(+n: U32) -> String: Netip.hex.three (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hex.three) def hex.three(+n: U32) -> String: Netip.hex.four (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hex.four) def hex.four(+n: U32) -> String: Netip.hex.many (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hex.many) def hex.many(n: U32, small: Bool) -> String: Netip.hex.more (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hex.more) def hex.more(+n: U32, small: Bool) -> String: Netip.hex.group.small (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hex.group.small) def hex.group.small(+n: U32, small: Bool) -> String: Netip.hex.group (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=hex.group) def hex.group(+n: U32) -> String: Netip.groups (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=groups) def groups(+a: U32, +b: U32, +c: U32, +d: U32) -> List<&2, U32>: Netip.zeros.best (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=zeros.best) # Keep the first run when two longest zero runs tie. def zeros.best(xs: List<&2, U32>, +i: U32, +run: U32, +start: U32, +best: U32, +length: U32) -> U32 & U32: Netip.v6.field.if (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.field.if) def v6.field.if(inside: Bool, n: U32, +i: U32, start: U32, end: U32) -> String: Netip.v6.field (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.field) def v6.field(n: U32, +i: U32, +start: U32, +length: U32) -> String: Netip.v6.render (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.render) def v6.render(xs: List<&2, U32>, +i: U32, +start: U32, +length: U32) -> String: Netip.v6.show.run (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.show.run) def v6.show.run(+a: U32, +b: U32, +c: U32, +d: U32, run: U32 & U32) -> String: Netip.v4.show (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v4.show) def v4.show(+w: U32) -> String: Netip.v6.show.mapped (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=v6.show.mapped) def v6.show.mapped(mapped: Bool, +a: U32, +b: U32, +c: U32, +d: U32) -> String: Netip.show (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=show) # RFC 5952: lowercase, shortest hex groups, longest leftmost "::" run. def show(addr: Addr) -> String: Netip.eq (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=eq) def eq(x: Addr, y: Addr) -> Bool: Netip.Prefix (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=Prefix) type Prefix is Data: Prefix{addr: Addr, bits: U32} Netip.prefix.digits (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=prefix.digits) def prefix.digits(s: String) -> Bool: Netip.prefix.limit (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=prefix.limit) def prefix.limit(addr: Addr, +bits: U32) -> Maybe<&2, Prefix>: Netip.prefix.valid (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=prefix.valid) def prefix.valid(addr: Addr, bits: U32, valid: Bool) -> Maybe<&2, Prefix>: Netip.prefix.number (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=prefix.number) def prefix.number(addr: Addr, +text: String, parsed: Maybe<&2, U32>) -> Maybe<&2, Prefix>: Netip.prefix.addr (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=prefix.addr) def prefix.addr(text: String, +suffix: String, parsed: Maybe<&2, Addr>) -> Maybe<&2, Prefix>: Netip.prefix.parts (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=prefix.parts) def prefix.parts(parts: List<&2, String>) -> Maybe<&2, Prefix>: Netip.prefix.parse (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=prefix.parse) def prefix.parse(s: String) -> Maybe<&2, Prefix>: Netip.prefix.show (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=prefix.show) def prefix.show(p: Prefix) -> String: Netip.mask (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=mask) def mask(bits: U32) -> U32: Netip.leading (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=leading) def leading(+bits: U32, +offset: U32) -> U32: Netip.word.contains (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=word.contains) def word.contains(+a: U32, +b: U32, bits: U32) -> Bool: Netip.contains (https://jend.leeeet.dev/definition.txt?path=bend-kit-netip@0.1.0.0/netip.bend&name=contains) # Address and prefix families must match. The supplied prefix address keeps its host bits. def contains(p: Prefix, addr: Addr) -> Bool: