bend-kit-bytes

Search uses release 0.3.3.0 · 161 definitions

Releases (5)

0.3.3.0 indexed
0.3.2.0 unindexed
0.3.1.0 unindexed
0.3.0.0 unindexed
0.2.0.0 unindexed

Definitions (161)

bytes.bend

type Bytes
def b8
def shift
def words
def depth.goThe fewest d with 2^d >= w.
def depth
def alloc
def peek.ofUnchecked byte read and write.
def peek
def poke.of
def poke
def copy.gon bytes from src[s..] to dst[d..], one byte at a time.
def copy.bytes
def copy.wordsn words from src[s..] to dst[d..] (word indexes).
def copy.shiftm bytes to a word-aligned d from an unaligned s: each out word joins two source words.
def copy.shift.at
def copy.tail
def copy.pick
def copy.dst
def copym bytes from src[s..] to dst[d..].
def newn zero bytes.
def length
def get.some
def get.if
def getByte i, or None when i >= len.
def set.if
def setByte i becomes v & 255.
def stepThe next index: one forward when up, one back when not.
def fitsDo n bytes from i fit in len?
def uint.gon bytes from j, each shifted in below the ones before: the first byte read is the most significant.
def uint.ifBig-endian reads forward from i; little-endian reads back from the last byte.
def uint
def get.u16beUnsigned integers at byte i, or None when they run past len.
def get.u16le
def get.u32be
def get.u32le
def put.gon bytes of v from j, least significant first.
def put.ifLittle-endian writes forward from i; big-endian writes back from the last byte.
def put
def set.u16bev's low 16 or 32 bits at byte i.
def set.u16le
def set.u32be
def set.u32le
def u64.ofThe U64 whose words, in byte order, are x then y.
def u64.join
def u64.lo
def u64.hi
def u64
def get.u64beA U64 at byte i, or None when its 8 bytes run past len.
def get.u64le
def put64.ifWrites words x then y at byte i, both in the same byte order.
def put64
def set.u64bev at byte i.
def set.u64le
def countString.length counts in Nat, which costs more than the walk itself.
def flushBytes enter at the top of w and shift down, so a full word has byte 0 lowest.
def from.go
def from_stringA byte string (one Char per octet, as Wire and Http use) to Bytes.
def to.go
def to_stringBytes to a byte string, one Char per octet.
def slice.fin
def slice.at
def sliceThe buffer back, and a copy of up to n bytes from start.
def clone.of
def cloneTwo buffers that hold the same bytes.
def dst
def roomDoes a buffer holding len bytes have room for n?
def grow.if
def growbuf, or a copy of its first len bytes in the fewest 2^d words that hold n.
def appenda then b.
def concat.total.con
def concat.total
def concat.go
def concat.of
def concatThe pieces in order, in one new buffer: one copy per byte, however many pieces.
def at.goDoes needle match at j?
def at
def find.goponytail: naive search; a mismatch costs one byte read per position, but a repetitive needle is O(len * needle).
def find.fin
def find.at
def find.fromIndex of the first match of needle (a byte string) at or after start, or None.
def findIndex of the first match of needle (a byte string), or None.
def rfindIndex of the last match of needle, or None.
def at.fin
def at.if
def starts_withDoes b begin with prefix (a byte string)?
def ends_withDoes b end with suffix (a byte string)?
def split.scanMatch positions of sep, latest first, that do not overlap an earlier match.
def snd
def split.cutr holds the buffer and the piece that ends at end; each earlier cut j starts one at j + m.
def split.of
def split.run
def split.if
def splitThe pieces between matches of sep (a byte string), left to right.
def eq.goCompares whole words; same tells whether the previous pair matched.
def eq.fin
def eq.len
def eqBoth buffers back, and whether they hold the same bytes.
def bswapByte 0 of w becomes the most significant, so words compare in byte order.
def cmp.goCompares whole words; c is the previous pair's order.