bend-kit-regex Releases (10): 0.8.0.0 0x1eb8d12d796afc9ee9a52f5812d014a8 indexed https://jend.leeeet.dev/files.txt?path=bend-kit-regex@0.8.0.0 0.7.0.0 0xf73292a4762e6d899c1536ca091a9818 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-regex@0.7.0.0 0.6.0.4 0x1300b2d5b9aa6d75cbf3892ade71bfa5 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-regex@0.6.0.4 0.6.0.3 0xd3961674608b520ca10445dbe0033776 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-regex@0.6.0.3 0.6.0.2 0x8e3e63eb9684869e3e7a2073837d2e82 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-regex@0.6.0.2 0.6.0.0 0x6fa820747435b3188e7e4f3d1ffc0325 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-regex@0.6.0.0 0.5.0.0 0x17c8efd9e5bee7a80fc7f191868b90f3 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-regex@0.5.0.0 0.4.0.0 0x1a53d6ec10a4300c106d83bbfb08e2ba unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-regex@0.4.0.0 0.3.0.0 0x34608bdcdd8721ab70b875a54ae9beca unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-regex@0.3.0.0 0.2.1.0 0x9a5b3462268cdd3d008e096064b6c4a9 unindexed https://jend.leeeet.dev/files.txt?path=bend-kit-regex@0.2.1.0 Definitions (316, 1 to 100 shown): Regex.Item (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Item) # A set member: a code point range, or a Unicode general category ("L", "Lu", ...). type Item is Data: Rng{lo: U32, hi: U32} Prop{neg: Bool, name: String} Regex.Node (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Node) # Assertion kinds: 0 start of text, 1 end of text, 2 word boundary, 3 not a word boundary. type Node is Data: NEmpty{} NSet{neg: Bool, items: List<&2, Item>} NAssert{k: U32} NCat{a: Node, b: Node} NAlt{a: Node, b: Node} NPlus{greedy: Bool, a: Node} NQuest{greedy: Bool, a: Node} NGroup{i: U32, a: Node} Regex.Tok (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Tok) type Tok is Data: TAtom{n: Node} TOpen{cap: Bool} TClose{} TBar{} TRep{min: U32, max: Maybe<&2, U32>, greedy: Bool} Regex.lit (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=lit) def lit(+c: U32) -> Node: Regex.is_digit (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=is_digit) def is_digit(+c: U32) -> Bool: Regex.is_word (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=is_word) def is_word(+c: U32) -> Bool: Regex.is_alnum (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=is_alnum) def is_alnum(+c: U32) -> Bool: Regex.perl.d (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=perl.d) # \d \w \s are ASCII, as in RE2. def perl.d() -> List<&2, Item>: Regex.perl.D (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=perl.D) def perl.D() -> List<&2, Item>: Regex.perl.w (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=perl.w) def perl.w() -> List<&2, Item>: Regex.perl.W (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=perl.W) def perl.W() -> List<&2, Item>: Regex.perl.s (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=perl.s) def perl.s() -> List<&2, Item>: Regex.perl.S (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=perl.S) def perl.S() -> List<&2, Item>: Regex.cats (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=cats) def cats() -> List<&2, String>: Regex.Esc (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Esc) type Esc is Data: EPoint{c: U32, rest: String} EItems{items: List<&2, Item>, rest: String} EAssert{k: U32, rest: String} EBad{} Regex.prop.if (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=prop.if) def prop.if(ok: Bool, neg: Bool, name: String, t: String) -> Esc: Regex.prop.ok (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=prop.ok) def prop.ok(neg: Bool, +name: String, t: String) -> Esc: Regex.prop.name (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=prop.name) def prop.name(s: String, neg: Bool, acc: String) -> Esc: Regex.prop (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=prop) # \pL or \p{Lu}; \P negates. def prop(neg: Bool, s: String) -> Esc: Regex.esc.other (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=esc.other) # An escaped letter or digit with no meaning is an error, as in RE2. def esc.other(alnum: Bool, +c: U32, t: String) -> Esc: Regex.esc (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=esc) # The text after a backslash. def esc(s: String) -> Esc: Regex.Cs (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Cs) type Cs is Data: CsGo{s: String, first: Bool, items: List<&2, Item>} CsDone{items: List<&2, Item>, rest: String} CsFail{} Regex.class.range (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=class.range) def class.range(ok: Bool, +c: U32, +d: U32, u: String, items: List<&2, Item>) -> Cs: Regex.class.hi (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=class.hi) def class.hi(e: Esc, +c: U32, items: List<&2, Item>) -> Cs: Regex.class.lo (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=class.lo) # c is one member; a "-" and a code point after it make a range. def class.lo(+c: U32, t: String, items: List<&2, Item>) -> Cs: Regex.class.esc (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=class.esc) def class.esc(e: Esc, items: List<&2, Item>) -> Cs: Regex.class.step (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=class.step) # A "]" right after "[" or "[^" is a member. def class.step(s: String, first: Bool, items: List<&2, Item>) -> Cs: Regex.class.run (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=class.run) # fuel: every step eats at least one char. def class.run(fuel: Nat, st: Cs) -> Cs: Regex.class (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=class) def class(+s: String, first: Bool) -> Cs: Regex.Lx (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Lx) type Lx is Data: LGo{s: String, toks: List<&2, Tok>} LDone{toks: List<&2, Tok>} LFail{} Regex.Num (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Num) # A run of decimal digits: its value (capped at 100000), its length, and the rest. type Num is Data: Num{v: U32, n: U32, rest: String} Regex.num.add (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=num.add) def num.add(+acc: U32, +c: U32) -> U32: Regex.num.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=num.go) def num.go(t: String, +c: U32, +acc: U32, +n: U32, dig: Bool) -> Num: Regex.num (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=num) def num(s: String) -> Num: Regex.lex.rep (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=lex.rep) # A trailing "?" makes a repetition lazy. def lex.rep(+min: U32, max: Maybe<&2, U32>, t: String, toks: List<&2, Tok>) -> Lx: Regex.Num.n (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Num.n) def Num.n(m: Num) -> U32: Regex.lex.brace.max (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=lex.brace.max) # A "{" that does not start {n}, {n,} or {n,m} is a literal, as in RE2. def lex.brace.max(none: Bool, +min: U32, m: Num, orig: String, toks: List<&2, Tok>) -> Lx: Regex.lex.brace.min (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=lex.brace.min) def lex.brace.min(none: Bool, m: Num, +orig: String, toks: List<&2, Tok>) -> Lx: Regex.lex.class (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=lex.class) def lex.class(neg: Bool, r: Cs, toks: List<&2, Tok>) -> Lx: Regex.lex.esc (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=lex.esc) def lex.esc(e: Esc, toks: List<&2, Tok>) -> Lx: Regex.lex.step (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=lex.step) def lex.step(s: String, toks: List<&2, Tok>) -> Lx: Regex.lex (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=lex) # fuel: every step but the last eats at least one char. def lex(fuel: Nat, st: Lx) -> Maybe<&2, List<&2, Tok>>: Regex.Frame (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Frame) # An open group: its capture index (None for (?:...)), and the enclosing alternatives and sequence. type Frame is Data: Frame{cap: Maybe<&2, U32>, alts: List<&2, Node>, cur: List<&2, Node>} Regex.Ps (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Ps) # n: the next capture index. rep: the last token was a repetition. alts and cur are reversed. type Ps is Data: Ps{n: U32, rep: Bool, stack: List<&2, Frame>, alts: List<&2, Node>, cur: List<&2, Node>} PsFail{} Regex.cat (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=cat) def cat(a: Node, b: Node) -> Node: Regex.seq.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=seq.go) def seq.go(xs: List<&2, Node>, acc: Node) -> Node: Regex.seq (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=seq) def seq(xs: List<&2, Node>) -> Node: Regex.alt.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=alt.go) def alt.go(xs: List<&2, Node>, acc: Node) -> Node: Regex.group (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=group) def group(cap: Maybe<&2, U32>, a: Node) -> Node: Regex.rep.copies (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=rep.copies) def rep.copies(k: Nat, +h: Node, acc: Node) -> Node: Regex.rep.opt (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=rep.opt) def rep.opt(k: Nat, +g: Bool, +h: Node) -> Node: Regex.rep.inf (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=rep.inf) # x* is (x+)?, so an empty x cannot loop; x{n,} is n-1 copies then x+; x{n,m} is n copies then (x(x...)?)?, as RE2 builds them. def rep.inf(k: Nat, +g: Bool, +h: Node) -> Node: Regex.rep.fin (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=rep.fin) def rep.fin(max: Maybe<&2, U32>, +min: U32, +g: Bool, +h: Node) -> Node: Regex.rep (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=rep) def rep(+h: Node, +min: U32, max: Maybe<&2, U32>, +g: Bool) -> Node: Regex.rep.ok (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=rep.ok) # Counts go up to 1000, and a repetition cannot repeat, as in RE2. def rep.ok(+min: U32, max: Maybe<&2, U32>) -> Bool: Regex.parse.rep (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=parse.rep) def parse.rep(ok: Bool, cur: List<&2, Node>, +min: U32, max: Maybe<&2, U32>, +g: Bool, +n: U32, stack: List<&2, Frame>, alts: List<&2, Node>) -> Ps: Regex.parse.open (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=parse.open) def parse.open(cap: Bool, +n: U32, stack: List<&2, Frame>, alts: List<&2, Node>, cur: List<&2, Node>) -> Ps: Regex.parse.close (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=parse.close) def parse.close(stack: List<&2, Frame>, +n: U32, alts: List<&2, Node>, cur: List<&2, Node>) -> Ps: Regex.parse.tok (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=parse.tok) def parse.tok(tok: Tok, +n: U32, rep: Bool, stack: List<&2, Frame>, alts: List<&2, Node>, cur: List<&2, Node>) -> Ps: Regex.parse.step (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=parse.step) def parse.step(st: Ps, tok: Tok) -> Ps: Regex.parse (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=parse) def parse(toks: List<&2, Tok>, st: Ps) -> Ps: Regex.Inst (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Inst) type Inst is Data: ISet{neg: Bool, items: List<&2, Item>} IAssert{k: U32} ISplit{x: U32, y: U32} IJmp{x: U32} ISave{k: U32} IMatch{} Regex.required.right (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=required.right) # A byte that every match must contain. Optional branches and character classes have none. def required.right(b: Maybe<&2, U32>, a: Maybe<&2, U32>) -> Maybe<&2, U32>: Regex.required (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=required) def required(n: Node) -> Maybe<&2, U32>: Regex.required.join (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=required.join) def required.join(right: Maybe<&2, Node>, left: Maybe<&2, Node>, a: Node) -> Maybe<&2, Node>: Regex.required.prefix (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=required.prefix) # The first iteration contains the selected literal; every occurrence is inspected. def required.prefix(n: Node) -> Maybe<&2, Node>: Regex.reverse.ok (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=reverse.ok) def reverse.ok(n: Node) -> Bool: Regex.reverse.node (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=reverse.node) def reverse.node(n: Node) -> Node: Regex.size (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=size) def size(n: Node) -> U32: Regex.emit (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=emit) # The instructions of n, placed at pc, in front of rest. ISplit tries x first. def emit(n: Node, +pc: U32, rest: List<&2, Inst>) -> List<&2, Inst>: Regex.Trie (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Trie) # A binary trie keyed by n >= 1: the path is the bits of n below its top bit, low bit # first, so key n costs log2(n) steps and small keys stay near the root. type Trie<-V: Data> is Data: TTip{} TNode{val: Maybe<&2, V>, lo: Trie, hi: Trie} Regex.trie.get (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=trie.get) # here: n is 1. left: n is even. def trie.get(-V: Data, t: Trie, here: Bool, left: Bool, +n: U32) -> Maybe<&2, V>: Regex.trie.put (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=trie.put) # fuel: a U32 key has at most 32 bits. def trie.put(-V: Data, fuel: Nat, t: Trie, here: Bool, left: Bool, +n: U32, v: V) -> Trie: Regex.trie.at (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=trie.at) # The value at key k, stored as n = k + 1. def trie.at(-V: Data, t: Trie, +k: U32) -> Maybe<&2, V>: Regex.trie.set (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=trie.set) def trie.set(-V: Data, t: Trie, +k: U32, v: V) -> Trie: Regex.trie.from (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=trie.from) def trie.from(-V: Data, xs: List<&2, V>, +k: U32, t: Trie) -> Trie: Regex.Fs (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Fs) # The walk from pc 0 over the instructions that consume no char: the sets it reaches, or # FsAny when it reaches an assertion or a match, so that any char may start a match. type Fs is Data: Fs{stack: List<&2, U32>, seen: List<&2, U32>, sets: List<&2, Inst>} FsAny{} Regex.first.inst (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=first.inst) def first.inst(i: Maybe<&2, Inst>, +pc: U32, stack: List<&2, U32>, seen: List<&2, U32>, sets: List<&2, Inst>) -> Fs: Regex.first.seen (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=first.seen) def first.seen(hit: Bool, +prog: List<&2, Inst>, +pc: U32, stack: List<&2, U32>, seen: List<&2, U32>, sets: List<&2, Inst>) -> Fs: Regex.first (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=first) # fuel: each pc expands once and pushes at most two pcs. def first(fuel: Nat, +prog: List<&2, Inst>, st: Fs) -> Maybe<&2, List<&2, Inst>>: Regex.Ew (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Ew) # Bit-parallel NFA for is_match: bit pc stands for the set at pc, waiting on the next char. # The epsilon walk from a pc: the sets it reaches and whether it reaches the match, where at0 # says the position is the start of the text and at1 the end. type Ew is Data: Ew{stack: List<&2, U32>, seen: List<&2, U32>, mask: U32, hit: Bool} Regex.eps.ctx (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=eps.ctx) def eps.ctx(k: U32, +at0: Bool, +at1: Bool) -> Bool: Regex.eps.assert (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=eps.assert) def eps.assert(ok: Bool, +pc: U32, stack: List<&2, U32>, seen: List<&2, U32>, mask: U32, hit: Bool) -> Ew: Regex.eps.inst (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=eps.inst) def eps.inst(i: Maybe<&2, Inst>, +pc: U32, +at0: Bool, +at1: Bool, stack: List<&2, U32>, seen: List<&2, U32>, +mask: U32, hit: Bool) -> Ew: Regex.eps.seen (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=eps.seen) def eps.seen(hit: Bool, +prog: List<&2, Inst>, +pc: U32, +at0: Bool, +at1: Bool, w: Ew) -> Ew: Regex.eps.go (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=eps.go) # fuel: each pc expands once and pushes at most two pcs. def eps.go(fuel: Nat, +prog: List<&2, Inst>, +at0: Bool, +at1: Bool, w: Ew) -> Ew: Regex.eps (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=eps) def eps(+fuel: Nat, +prog: List<&2, Inst>, +pc: U32, +at0: Bool, +at1: Bool) -> Ew: Regex.Ew.mask (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Ew.mask) def Ew.mask(w: Ew) -> U32: Regex.Ew.hit (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Ew.hit) def Ew.hit(w: Ew) -> Bool: Regex.Bit (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Bit) # The set at bit mask; follow: the sets live after it takes a char; fin, end: whether the match # is then reached inside the text, or at its end. type Bit is Data: Bit{mask: U32, neg: Bool, items: List<&2, Item>, follow: U32, fin: Bool, end: Bool} Regex.Bits (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Bits) # at0: the sets live at the start of the text, and hit0 whether the empty match is there; # hit01 the same for the empty text; atn and hitn the same inside the text, hit1 at its end. type Bits is Data: Bits{sets: List<&2, Bit>, at0: U32, hit0: Bool, hit01: Bool, atn: U32, hit1: Bool} Regex.bits.set (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=bits.set) def bits.set(+fuel: Nat, +prog: List<&2, Inst>, +pc: U32, neg: Bool, items: List<&2, Item>) -> Bit: Regex.bits.sets (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=bits.sets) def bits.sets(xs: List<&2, Inst>, +fuel: Nat, +prog: List<&2, Inst>, +pc: U32) -> List<&2, Bit>: Regex.bits.plain (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=bits.plain) # Word boundaries depend on the chars on both sides, which one mask per set cannot track. def bits.plain(xs: List<&2, Inst>) -> Bool: Regex.bits.if (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=bits.if) def bits.if(ok: Bool, +fuel: Nat, +prog: List<&2, Inst>) -> Maybe<&2, Bits>: Regex.bits (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=bits) def bits(+fuel: Nat, +prog: List<&2, Inst>) -> Maybe<&2, Bits>: Regex.item.has (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=item.has) def item.has(i: Item, +c: U32) -> Bool: Regex.items.has (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=items.has) def items.has(xs: List<&2, Item>, +c: U32) -> Bool: Regex.starts (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=starts) def starts(xs: List<&2, Inst>, +c: U32) -> Bool: Regex.Asc (https://jend.leeeet.dev/definition.txt?path=bend-kit-regex@0.8.0.0/regex.bend&name=Asc) # The ASCII bytes that may start a match, one bit per byte, 32 to a word. type Asc is Data: Asc{m0: U32, m1: U32, m2: U32, m3: U32} More: https://jend.leeeet.dev/packages/bend-kit-regex.txt?definitions_offset=100