lib.bend source
lib.bend on the hub · documented module
# Bytes — foundational byte-buffer for Bend.# Publish entry for this package. Depends only on Base (does not reimplement List).## Encoding: newtype over List<&2, U32>, matching File.read_bytes payload.# Each element is a raw U32 "byte" (callers conventionally keep 0..255).# Quantity: Bytes is Data (U32 elements are Data / Kind(&2)).## Does not duplicate Base List algorithms: wrappers specialize List ops to the# byte buffer type. Base has no Bytes type (bend base Bytes → missing).import Basetype Bytes is Data: B{data: List<&2, U32>}# ---- constructors ---------------------------------------------------------def Bytes.empty() -> Bytes: B{Nil{}}def Bytes.singleton(+b: U32) -> Bytes: B{b <> Nil{}}def Bytes.from_list(xs: List<&2, U32>) -> Bytes: B{xs}def Bytes.to_list(bs: Bytes) -> List<&2, U32>: match bs: case B{xs}: xs# ---- queries / combinators (thin List facades) ----------------------------def Bytes.length(bs: Bytes) -> Nat: match bs: case B{xs}: List.length(&2, U32, xs)def Bytes.append(xs: Bytes, ys: Bytes) -> Bytes: match xs ys: case B{a} B{b}: B{List.append(&2, U32, a, b)}def Bytes.reverse(bs: Bytes) -> Bytes: match bs: case B{xs}: B{List.reverse(&2, U32, xs)}def Bytes.get(bs: Bytes, n: Nat) -> Maybe<&2, U32>: match bs: case B{xs}: List.get(&2, U32, xs, n)# ---- equality -------------------------------------------------------------def Bytes.eq.go(xs: List<&2, U32>, ys: List<&2, U32>) -> Bool: match xs ys: case Nil{} Nil{}: True{} case Nil{} _ <> _: False{} case _ <> _ Nil{}: False{} case x <> xt y <> yt: Bool.and(U32.is_eq(x, y), Bytes.eq.go(xt, yt))def Bytes.eq(a: Bytes, b: Bytes) -> Bool: match a b: case B{xs} B{ys}: Bytes.eq.go(xs, ys)# ---- hex encode (small subset; nibble + byte + buffer) --------------------# Digits 0..15 → '0'..'9' / 'a'..'f'. Byte encode uses the low 8 bits only.def Bytes.hex.digit(+n: U32) -> Char: Bool.pick(Char, U32.is_lt(n, 10), Chr{U32.add(48, n)}, Chr{U32.add(87, n)})def Bytes.hex.byte(+b: U32) -> String: +lo8 = U32.and(b, 255) +hi = U32.div(lo8, 16) +lo = U32.mod(lo8, 16) SCon{Bytes.hex.digit(hi), SCon{Bytes.hex.digit(lo), SNil{}}}def Bytes.hex.go(xs: List<&2, U32>) -> String: match xs: case Nil{}: SNil{} case h <> t: String.append(Bytes.hex.byte(h), Bytes.hex.go(t))def Bytes.hex(bs: Bytes) -> String: match bs: case B{xs}: Bytes.hex.go(xs)