emerging-ezjson Releases (3): 1.3.0.0 0xdab377b48b4edd8247427c10e2120805 indexed https://jend.leeeet.dev/files.txt?path=emerging-ezjson@1.3.0.0 1.2.0.0 0xa81e161008ecc2f297c0a3065cb9b188 unindexed https://jend.leeeet.dev/files.txt?path=emerging-ezjson@1.2.0.0 1.1.0.0 0x81c67699424929b5c44cd8577e18117f unindexed https://jend.leeeet.dev/files.txt?path=emerging-ezjson@1.1.0.0 Definitions (381, 1 to 100 shown): EmergingEzjson.parse (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=parse) # a text as a value, or None when it is not JSON def parse(txt: String) -> Maybe<&2, Value.Json>: EmergingEzjson.print (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=print) # a value as compact JSON def print(val: Value.Json) -> String: EmergingEzjson.pretty (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=pretty) # a value as JSON indented two spaces a level, one element or member a line, # with no newline at the end def pretty(val: Value.Json) -> String: EmergingEzjson.null (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=null) # null def null() -> Value.Json: EmergingEzjson.bool (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=bool) # a boolean def bool(flag: Bool) -> Value.Json: EmergingEzjson.str (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=str) # a string def str(txt: String) -> Value.Json: EmergingEzjson.num (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=num) # a JSON number from its text, or null when that text is not one def num(raw: String) -> Value.Json: EmergingEzjson.obj (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=obj) # an object from pairs def obj(pairs: List<&1, String & Value.Json>) -> Value.Json: EmergingEzjson.arr (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=arr) # an array from a list def arr(items: List<&2, Value.Json>) -> Value.Json: EmergingEzjson.get (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=get) # an object's value at a key; JNull when it is not an object or has no such # key def get(val: Value.Json, key: String) -> Value.Json: EmergingEzjson.at (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=at) # an array's item at an index; JNull when it is not an array or has none def at(val: Value.Json, idx: U32) -> Value.Json: EmergingEzjson.has (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=has) # whether an object has a key; false when the value is not an object. Tells # a missing key from a key whose value is null, which `get` does not def has(val: Value.Json, key: String) -> Bool: EmergingEzjson.len (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=len) # how many elements an array, or members an object, has; 0 for anything else def len(val: Value.Json) -> U32: EmergingEzjson.items (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=items) # an array's elements, in order; [] when the value is not an array. One # walk of the array, where a loop over `at` walks it again for every index def items(val: Value.Json) -> List<&2, Value.Json>: EmergingEzjson.is_arr (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=is_arr) # whether a value is an array def is_arr(val: Value.Json) -> Bool: EmergingEzjson.is_obj (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=is_obj) # whether a value is an object def is_obj(val: Value.Json) -> Bool: EmergingEzjson.as_bool (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=as_bool) # a boolean, or none when the value is not one def as_bool(val: Value.Json) -> Maybe<&2, Bool>: EmergingEzjson.as_str (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=as_str) # a string, or none when the value is not one def as_str(val: Value.Json) -> Maybe<&2, String>: EmergingEzjson.as_num (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=as_num) # a number's text, or none when the value is not a number def as_num(val: Value.Json) -> Maybe<&2, String>: EmergingEzjson.num.fixed (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=num.fixed) # a number's text written with `places` decimals, rounded half to even on # its decimal digits (not through a binary float), as Python's `'%.Nf'` # writes a value whose decimal text is exact; None when the text is not a # JSON number. A `-` is kept even when the result is zero: `-0.04` to one # place is `-0.0` def num.fixed(raw: String, places: Nat) -> Maybe<&2, String>: EmergingEzjson.as_u32 (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=as_u32) # a number as a U32, or none when it is not one or does not fit def as_u32(val: Value.Json) -> Maybe<&2, U32>: EmergingEzjson.as_f32 (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=as_f32) # a number as an F32, or none when it is not one or does not fit def as_f32(val: Value.Json) -> Maybe<&2, F32>: EmergingEzjson.cursor (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=cursor) # a cursor at the start of a JSON text. It holds the unread suffix of that # text. A span event keeps its own suffix, so it stays valid after `next` # moves the cursor, and it is gone when the event is dropped def cursor(src: String) -> Pull.Cur: EmergingEzjson.next (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=next) # the next event. Commas and colons are not events. After the root value, # the next call is the end, or an error if another value follows def next(cur: Pull.Cur) -> (Pull.Ev & Pull.Cur): EmergingEzjson.skip (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=skip) # drop the next value, scalar or container, without building it def skip(cur: Pull.Cur) -> Pull.Cur: EmergingEzjson.text (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/main.bend&name=text) # the text of a string, key, or number event, copying a span. None otherwise def text(ev: Pull.Ev) -> Maybe<&2, String>: Fixed.Dec (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=Dec) # where a number's point is: the digits before it, last digit first, and the # digits after it type Dec is Data: Dec{left: String, right: String} Fixed.mark.e (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=mark.e) # an exponent mark, `e` or `E` def mark.e(+ch: Char) -> Bool: Fixed.mark.dot (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=mark.dot) # a decimal point def mark.dot(+ch: Char) -> Bool: Fixed.cut.put (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=cut.put) # put a character before the first of a pair def cut.put(ch: Char, pair: String & String) -> String & String: Fixed.cut.at (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=cut.at) # at a mark the cut is made; any other character is kept before it def cut.at( hit: Bool, ch: Char, after: String, more: Unit -> String & String ) -> String & String: Fixed.cut.e (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=cut.e) # a text cut at its first exponent mark: what is before it, and after it def cut.e(txt: String) -> String & String: Fixed.cut.dot (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=cut.dot) # a text cut at its first decimal point: what is before it, and after it def cut.dot(txt: String) -> String & String: Fixed.esign.at (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=esign.at) # an exponent's sign and digits: `-` makes it negative, `+` is dropped def esign.at(minus: Bool, plus: Bool, ch: Char, tl: String) -> Bool & String: Fixed.esign (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=esign) # an exponent's sign and digits def esign(txt: String) -> Bool & String: Fixed.parts.of (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=parts.of) # the parts of a text cut at its exponent mark def parts.of(cut: String & String) -> (String & String) & (Bool & String): Fixed.parts (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=parts) # an unsigned number's parts: its integer and fraction digits, and its # exponent's sign and digits def parts(txt: String) -> (String & String) & (Bool & String): Fixed.digit.nat (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=digit.nat) # a digit's value def digit.nat(ch: Char) -> Nat: Fixed.nat.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=nat.go) # decimal digits read onto acc, most significant first def nat.go(txt: String, acc: Nat) -> Nat: Fixed.nat (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=nat) # decimal digits' value def nat(txt: String) -> Nat: Fixed.up (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=up) # the point one place right: the first fraction digit, or a 0 past the # last, moves before the point def up(dec: Dec) -> Dec: Fixed.down (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=down) # the point one place left: the last integer digit, or a 0 before the # first, moves after the point def down(dec: Dec) -> Dec: Fixed.ups (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=ups) # the point `kk` places right def ups(kk: Nat, dec: Dec) -> Dec: Fixed.downs (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=downs) # the point `kk` places left def downs(kk: Nat, dec: Dec) -> Dec: Fixed.move (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=move) # the digits with the point moved by the exponent def move(neg: Bool, kk: Nat, dec: Dec) -> Dec: Fixed.place (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=place) # the parts as digits around the point, the point moved by the exponent def place(pts: (String & String) & (Bool & String)) -> Dec: Fixed.pad (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=pad) # the first `nn` fraction digits, 0s past the last, and the digits dropped def pad(nn: Nat, right: String) -> String & String: Fixed.nonzero.at (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=nonzero.at) # a 0 digit leaves the answer to the rest; any other digit is nonzero def nonzero.at(zero: Bool, more: Unit -> Bool) -> Bool: Fixed.nonzero (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=nonzero) # whether any digit is not 0 def nonzero(txt: String) -> Bool: Fixed.odd (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=odd) # whether the last kept digit is odd; no digit is an even 0 def odd(kept: String) -> Bool: Fixed.tie (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=tie) # a first dropped digit of 5 with no other nonzero digit dropped is a tie, # which goes to the even neighbour def tie(sticky: Bool, kept: String) -> Bool: Fixed.round.at (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=round.at) # the first dropped digit against 5 def round.at(order: Cmp, rest: String, kept: String) -> Bool: Fixed.round.up (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=round.up) # whether the kept digits (last first) go up by one, from the dropped ones def round.up(dropped: String, kept: String) -> Bool: Fixed.inc.at (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=inc.at) # one more on a digit, carried: a 9 is 0 and carries def inc.at(nine: Bool, ch: Char, tl: String, more: Unit -> String) -> String: Fixed.inc (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=inc) # one more on digits written last first def inc(digits: String) -> String: Fixed.bump (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=bump) # the kept digits, one more when they round up def bump(go_up: Bool, kept: String) -> String: Fixed.round.keep (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=round.keep) # the kept digits split at the last place def round.keep(+left: String, pair: String & String) -> String: Fixed.round (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=round) # every digit to the last kept place, last first, rounded half to even def round(+nn: Nat, dec: Dec) -> String: Fixed.trim.at (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=trim.at) # an integer part with its leading 0s dropped; no digit is 0 def trim.at(zero: Bool, ch: Char, tl: String, more: Unit -> String) -> String: Fixed.trim (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=trim) # an integer part with its leading 0s dropped; no digit is 0 def trim(int: String) -> String: Fixed.point (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=point) # the integer part, then a point and the fraction when there is one def point(nn: Nat, int: String, frac: String) -> String: Fixed.write (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=write) # rounded digits, last first, written with `nn` decimals def write(+nn: Nat, +digits: String) -> String: Fixed.unsigned (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=unsigned) # an unsigned number's text with `nn` decimals def unsigned(txt: String, +nn: Nat) -> String: Fixed.text.at (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=text.at) # a sign kept in front of the unsigned rest def text.at(minus: Bool, ch: Char, tl: String, +nn: Nat) -> String: Fixed.text (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=text) # a number's text with `nn` decimals def text(txt: String, +nn: Nat) -> String: Fixed.fixed.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=fixed.go) # Some of the text with `nn` decimals when `ok`, else None def fixed.go(ok: Bool, raw: String, +nn: Nat) -> Maybe<&2, String>: Fixed.fixed (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/fixed.bend&name=fixed) # a JSON number's text with `nn` decimals, or None when it is not one def fixed(+raw: String, +nn: Nat) -> Maybe<&2, String>: Lazy.stop (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lazy.bend&name=stop) # `val` when `cond`, else what rest gives: the early exit of a search def stop(-A: Type, cond: Bool, val: A, rest: Unit -> A) -> A: Lex.Tok (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=Tok) # the tokens: brackets, `:`, `,`, a string (decoded), or a bare word # (a number, true, false, null) type Tok is Data: TOpenArr{} TCloseArr{} TOpenObj{} TCloseObj{} TColon{} TComma{} TStr{s: String} TWord{raw: String} … Lex.Class (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=Class) # what a char is: punctuation (with its token), a quote, whitespace, or a # word char type Class is Data: CPunct{t: Tok} CQuote{} CBack{} CSpace{} COther{} Lex.Mode (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=Mode) # what the machine is inside of: nothing, a bare word, a string, an escape, # a \u escape, a high surrogate waiting for its pair, or a rejected text type Mode is Data: Idle{} Word{} Str{} Esc{} Uni{left: Nat, acc: U32} Hi{hi: U32} HiEsc{hi: U32} Lo{left: Nat, acc: U32, hi: U32} Bad{} Lex.Sur (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=Sur) # a \u code point: an ordinary scalar, a high surrogate, or a low surrogate type Sur is Data: SOk{} SHi{} SLo{} Lex.Lex (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=Lex) # the lexer's state: buf and toks are both reversed type Lex is Data: Lex{mode: Mode, buf: List<&2, Char>, toks: List<&2, Tok>} Lex.classify.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=classify.go) # a char's class, by code point. Written as comparisons rather than as # `case '[':` arms: a character literal in a pattern is a U32 literal inside a # constructor pattern, and bend's C backend pays about 90 MB for each one. def classify.go(+cp: U32) -> Class: Lex.classify (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=classify) # a char's class def classify(ch: Char) -> Class: Lex.text.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=text.go) # the buffer is reversed, so consing each head onto the front yields the text def text.go(buf: List<&2, Char>, acc: String) -> String: Lex.text (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=text) # the buffered chars (reversed) as a string def text(buf: List<&2, Char>) -> String: Lex.unescape.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unescape.go) def unescape.go(+cp: U32) -> Maybe<&2, Char>: Lex.unescape (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unescape) # the char an escape stands for; none when the escape is not one JSON allows def unescape(+ch: Char) -> Maybe<&2, Char>: Lex.escape.put (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=escape.put) def escape.put(mb: Maybe<&2, Char>, buf: List<&2, Char>, toks: List<&2, Tok>) -> Lex: Lex.escape.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=escape.go) # the char after a backslash, once it is known whether it is `u` def escape.go(ch: Char, buf: List<&2, Char>, toks: List<&2, Tok>, is_u: Bool) -> Lex: Lex.escape (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=escape) # the char after a backslash in a string. Tested by code point, not with a # `case 'u':` arm, for the reason `classify` gives def escape(+ch: Char, buf: List<&2, Char>, toks: List<&2, Tok>) -> Lex: Lex.hex.ok (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=hex.ok) def hex.ok(+cp: U32) -> Bool: Lex.hex (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=hex) # a hex digit's value def hex(ch: Char) -> U32: Lex.unicode.sur.lo (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.sur.lo) def unicode.sur.lo(ge: Bool, le: Bool) -> Sur: Lex.unicode.sur.hi (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.sur.hi) def unicode.sur.hi(+cp: U32, ge: Bool, le: Bool) -> Sur: Lex.unicode.sur (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.sur) def unicode.sur(+cp: U32) -> Sur: Lex.unicode.pair (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.pair) def unicode.pair(hi: U32, lo: U32) -> U32: Lex.unicode.end.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.end.go) def unicode.end.go(cp: U32, buf: List<&2, Char>, toks: List<&2, Tok>, key: Sur) -> Lex: Lex.unicode.end (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.end) def unicode.end(+cp: U32, buf: List<&2, Char>, toks: List<&2, Tok>) -> Lex: Lex.unicode.put (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.put) def unicode.put(left: Nat, acc: U32, dig: U32, buf: List<&2, Char>, toks: List<&2, Tok>) -> Lex: Lex.unicode.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.go) def unicode.go(left: Nat, acc: U32, ch: Char, buf: List<&2, Char>, toks: List<&2, Tok>, ok: Bool) -> Lex: Lex.unicode (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode) # one hex digit of a \uXXXX escape; the code point once four are in def unicode(left: Nat, acc: U32, +ch: Char, buf: List<&2, Char>, toks: List<&2, Tok>) -> Lex: Lex.unicode.low.end.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.low.end.go) def unicode.low.end.go(lo: U32, hi: U32, buf: List<&2, Char>, toks: List<&2, Tok>, key: Sur) -> Lex: Lex.unicode.low.end (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.low.end) def unicode.low.end(+lo: U32, hi: U32, buf: List<&2, Char>, toks: List<&2, Tok>) -> Lex: Lex.unicode.low.put (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.low.put) def unicode.low.put(left: Nat, acc: U32, hi: U32, dig: U32, buf: List<&2, Char>, toks: List<&2, Tok>) -> Lex: Lex.unicode.low.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.low.go) def unicode.low.go( left: Nat, acc: U32, hi: U32, ch: Char, buf: List<&2, Char>, toks: List<&2, Tok>, ok: Bool ) -> Lex: Lex.unicode.low (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=unicode.low) def unicode.low(left: Nat, acc: U32, hi: U32, +ch: Char, buf: List<&2, Char>, toks: List<&2, Tok>) -> Lex: Lex.step.str.go (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=step.str.go) def step.str.go(ch: Char, buf: List<&2, Char>, toks: List<&2, Tok>, ctrl: Bool) -> Lex: Lex.step.str (https://jend.leeeet.dev/definition.txt?path=emerging-ezjson@1.3.0.0/src/lex.bend&name=step.str) def step.str(+ch: Char, buf: List<&2, Char>, toks: List<&2, Tok>) -> Lex: More: https://jend.leeeet.dev/packages/emerging-ezjson.txt?definitions_offset=100