bend-toon-codec Releases (1): 0.1.0.0 0x12996a27cbeef5e5ba1e8cd909be0e05 indexed https://jend.leeeet.dev/files.txt?path=bend-toon-codec@0.1.0.0 Definitions (412, 1 to 100 shown): BendToonCodec.Json (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=Json) # JSON values. Arrays and objects are chains inside Json itself: an array is # JArr{JCons{a, JCons{b, JNil{}}}}, an object is # JObj{JField{"k", v, JField{"k2", v2, JNil{}}}}. Numbers keep their decimal # text (JNum{"1.50"}); encode writes the canonical form. type Json is Data: JNull{} JBool{b: Bool} JNum{text: String} JStr{s: String} JArr{items: Json} JObj{fields: Json} … BendToonCodec.Delim (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=Delim) # Delimiter of arrays and tabular rows. type Delim is Data: Comma{} Tab{} Pipe{} BendToonCodec.EncodeOpts (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=EncodeOpts) # Spaces per indent level, the document delimiter, and key folding: 0 is off # (the default), n of 2 or more folds chains of single-key objects into dotted # keys of at most n segments (`a.b.c: 1`), 4294967295 folds whole chains. type EncodeOpts is Data: EncodeOpts{indent: U32, delim: Delim, fold: U32} BendToonCodec.DecodeOpts (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=DecodeOpts) # Spaces per indent level (used to compute line depth), strict mode (counts, # indentation, blank lines, duplicate keys), and path expansion (an unquoted # key `a.b.c` becomes nested objects; quoted keys stay literal). type DecodeOpts is Data: DecodeOpts{indent: U32, strict: Bool, expand: Bool} BendToonCodec.encode_default (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=encode_default) # Indent 2, comma. def encode_default() -> EncodeOpts: BendToonCodec.decode_default (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=decode_default) # Indent 2, strict. def decode_default() -> DecodeOpts: BendToonCodec.to_inner (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=to_inner) def to_inner(j: Json) -> I.Json: BendToonCodec.of_inner (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=of_inner) def of_inner(j: I.Json) -> Json: BendToonCodec.of_inner_result (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=of_inner_result) def of_inner_result(r: Result<&2, &2, String, I.Json>) -> Result<&2, &2, String, Json>: BendToonCodec.inner_delim (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=inner_delim) def inner_delim(d: Delim) -> Enc.Delim: BendToonCodec.encode (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=encode) # TOON text of a value, LF line endings, no trailing newline. NaN and Infinity # (a JNum whose text is not a number) encode as null. def encode(j: Json, o: EncodeOpts) -> String: BendToonCodec.decode (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=decode) # The value of TOON text, or the first error with its line number. def decode(s: String, o: DecodeOpts) -> Result<&2, &2, String, Json>: BendToonCodec.eq (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/main.bend&name=eq) # JSON-model equality: numbers by value (`1.0` equals `1`), objects by ordered # keys. def eq(a: Json, b: Json) -> Bool: Decode.DOpts (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=DOpts) # Decoder options: spaces per indent level, strict mode, and path expansion # (section 13.4: unquoted dotted keys become nested objects). type DOpts is Data: DOpts{indent: U32, strict: Bool, expand: Bool} Decode.ddefaults (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=ddefaults) def ddefaults() -> DOpts: Decode.fold (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=fold) # Apply every line in order, stopping at the first error. def fold(+ls: List<&2, D.DL>, +sr: Result<&2, &2, String, F.St>, +strict: Bool) -> Result<&2, &2, String, F.St>: Decode.root.value (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=root.value) def root.value(+r: Result<&2, &2, String, F.St>) -> Result<&2, &2, String, J.Json>: Decode.fuel (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=fuel) # The stack height: enough steps to close every frame. def fuel(+r: Result<&2, &2, String, F.St>) -> Nat: Decode.finish (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=finish) # Close what is still open and take the root. def finish(+r: Result<&2, &2, String, F.St>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.all_blank (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=all_blank) def all_blank(+ls: List<&2, D.DL>) -> Bool: Decode.skip_blank (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=skip_blank) def skip_blank(+ls: List<&2, D.DL>) -> List<&2, D.DL>: Decode.init (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=init) def init(+stk: List<&2, F.Fr>, +root: Maybe<&2, J.Json>) -> Result<&2, &2, String, F.St>: Decode.object.root (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=object.root) def object.root() -> Result<&2, &2, String, F.St>: Decode.array.root (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=array.root) # The root is an array: its header started a value or an open frame. def array.root(+r: Result<&2, &2, String, T.Start>) -> Result<&2, &2, String, F.St>: Decode.run.object (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=run.object) def run.object(+ls: List<&2, D.DL>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.run.array (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=run.array) def run.array(+ls: List<&2, D.DL>, +r: Result<&2, &2, String, T.Start>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.single.pick (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=single.pick) # A one-line document that is no entry is a primitive. def single.pick(+r: Result<&2, &2, String, E.Ent>, +text: String, +ls: List<&2, D.DL>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.single.if (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=single.if) def single.if(+empty: Bool, +text: String, +ls: List<&2, D.DL>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.single (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=single) def single(+text: String, +ls: List<&2, D.DL>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.root.other (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=root.other) # Section 5 root form discovery, after the header of a root array failed. def root.other(+one: Bool, +text: String, +ls: List<&2, D.DL>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.root.hdr (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=root.hdr) def root.hdr(+r: Result<&2, &2, String, H.Hdr>, +one: Bool, +text: String, +all: List<&2, D.DL>, +rest: List<&2, D.DL>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.header.try.pick (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=header.try.pick) def header.try.pick(+root: Bool, +text: String) -> Result<&2, &2, String, H.Hdr>: Decode.header.try (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=header.try) def header.try(+depth: U32, +text: String) -> Result<&2, &2, String, H.Hdr>: Decode.start.first (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=start.first) def start.first(+l: D.DL, +rest: List<&2, D.DL>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.start.skipped (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=start.skipped) def start.skipped(+ls: List<&2, D.DL>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.start (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=start) def start(+ls: List<&2, D.DL>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.run (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=run) def run(+r: Result<&2, &2, String, List<&2, D.DL>>, +strict: Bool) -> Result<&2, &2, String, J.Json>: Decode.post.pick (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=post.pick) def post.pick(+expand: Bool, +strict: Bool, +v: J.Json) -> Result<&2, &2, String, J.Json>: Decode.post (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=post) # Quoted-key markers come off; with path expansion the dotted keys unfold. def post(+expand: Bool, +strict: Bool, +r: Result<&2, &2, String, J.Json>) -> Result<&2, &2, String, J.Json>: Decode.decode (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/decode.bend&name=decode) # Decode TOON text. def decode(+src: String, +o: DOpts) -> Result<&2, &2, String, J.Json>: Dline.DL (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=DL) type DL is Data: DL{no: U32, depth: U32, text: String, blank: Bool} Dline.Ld (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=Ld) # Leading spaces and tabs counted, and what follows them. type Ld is Data: Ld{sp: U32, tabs: U32, rest: String} Dline.lead.pick (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=lead.pick) def lead.pick(+go: Bool, +s: String, +sp: U32, +tabs: U32, +r: Ld) -> Ld: Dline.inc (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=inc) def inc(+b: Bool) -> U32: Dline.lead (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=lead) # Count the leading spaces and tabs. `live` is true until the first other # character; the recursion runs to the end of the line but only counts # while live. def lead(+s: String, +sp: U32, +tabs: U32, +live: Bool) -> Ld: Dline.at (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=at) def at(+no: U32, +m: String) -> String: Dline.blank (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=blank) def blank(+no: U32) -> Result<&2, &2, String, DL>: Dline.depth.pick (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=depth.pick) # Depth is spaces divided by the indent size. Strict mode refuses tabs in the # indentation and a count that is not a multiple. Lenient mode floors the # count and reads each leading tab as one indent level. def depth.pick(+bad_tab: Bool, +bad_mult: Bool, +no: U32, +depth: U32, +text: String) -> Result<&2, &2, String, DL>: Dline.make.nonblank (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=make.nonblank) def make.nonblank(+no: U32, +l: Ld, +size: U32, +strict: Bool) -> Result<&2, &2, String, DL>: Dline.make.pick (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=make.pick) def make.pick(+isblank: Bool, +no: U32, +l: Ld, +size: U32, +strict: Bool) -> Result<&2, &2, String, DL>: Dline.make.of (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=make.of) def make.of(+no: U32, +l: Ld, +size: U32, +strict: Bool) -> Result<&2, &2, String, DL>: Dline.make (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=make) def make(+no: U32, +line: String, +size: U32, +strict: Bool) -> Result<&2, &2, String, DL>: Dline.prep.cons (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=prep.cons) def prep.cons(+r: Result<&2, &2, String, DL>, +rest: Result<&2, &2, String, List<&2, DL>>) -> Result<&2, &2, String, List<&2, DL>>: Dline.prep.go (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=prep.go) def prep.go(+lines: List<&2, String>, +no: U32, +size: U32, +strict: Bool) -> Result<&2, &2, String, List<&2, DL>>: Dline.size.of (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=size.of) def size.of(+n: U32) -> U32: Dline.prep (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/dline.bend&name=prep) # Split on LF and number the lines from 1. def prep(+src: String, +size: U32, +strict: Bool) -> Result<&2, &2, String, List<&2, DL>>: Encode.Delim (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=Delim) type Delim is Data: Comma{} Tab{} Pipe{} Encode.EOpts (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=EOpts) # Encoder options: spaces per indent level, the document delimiter, and key # folding (section 13.4): 0 is off, n of 2 or more folds chains of single-key # objects into dotted keys of at most n segments, 4294967295 folds whole chains. type EOpts is Data: EOpts{indent: U32, delim: Delim, fold: U32} Encode.defaults (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=defaults) def defaults() -> EOpts: Encode.code (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=code) # The delimiter as a code point. def code(+d: Delim) -> U32: Encode.sym (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=sym) # What a header writes inside the brackets for this delimiter. def sym(+d: Delim) -> String: Encode.delim.text (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=delim.text) def delim.text(+d: Delim) -> String: Encode.bool.text (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=bool.text) def bool.text(+b: Bool) -> String: Encode.num.text (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=num.text) def num.text(+m: Maybe<&2, String>) -> String: Encode.is_prim (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=is_prim) def is_prim(+j: J.Json) -> Bool: Encode.prim.text (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=prim.text) # The text of a primitive, quoted as `d` (a code point) requires. def prim.text(+j: J.Json, +d: U32) -> String: Encode.count (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=count) def count(+items: J.Json) -> U32: Encode.all_prim (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=all_prim) def all_prim(+items: J.Json) -> Bool: Encode.join.prims (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=join.prims) # Primitives joined by the delimiter. def join.prims(+items: J.Json, +d: Delim) -> String: Encode.fields.len (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=fields.len) def fields.len(+fs: J.Json) -> U32: Encode.fields.prim (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=fields.prim) def fields.prim(+fs: J.Json) -> Bool: Encode.field.pick (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=field.pick) def field.pick(+hit: Bool, +v: J.Json, +rest: J.Json) -> J.Json: Encode.field.get (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=field.get) def field.get(+k: String, +fs: J.Json) -> J.Json: Encode.has_key (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=has_key) def has_key(+k: String, +fs: J.Json) -> Bool: Encode.keys.of (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=keys.of) # The keys of an object. def keys.of(+fs: J.Json) -> List<&2, String>: Encode.has_all (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=has_all) def has_all(+ks: List<&2, String>, +fs: J.Json) -> Bool: Encode.list.len (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=list.len) def list.len(+ks: List<&2, String>) -> U32: Encode.row.fits (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=row.fits) # One element fits the header's keys: an object of primitives with exactly # those keys. def row.fits(+ks: List<&2, String>, +e: J.Json) -> Bool: Encode.tab.ok (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=tab.ok) def tab.ok(+ks: List<&2, String>, +items: J.Json) -> Bool: Encode.first.keys (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=first.keys) # Keys of the first element when it is a non-empty object, else none. def first.keys(+items: J.Json) -> List<&2, String>: Encode.tabular.keys (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=tabular.keys) def tabular.keys(+ks: List<&2, String>, +items: J.Json) -> Bool: Encode.tabular (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=tabular) def tabular(+items: J.Json) -> Bool: Encode.fields.text (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=fields.text) def fields.text(+ks: List<&2, String>, +d: Delim) -> String: Encode.row.cells (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=row.cells) def row.cells(+ks: List<&2, String>, +fs: J.Json, +d: Delim) -> String: Encode.row.of (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=row.of) def row.of(+ks: List<&2, String>, +e: J.Json, +d: Delim) -> String: Encode.rows (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=rows) def rows(+ks: List<&2, String>, +items: J.Json, +d: Delim) -> List<&2, R.Ln>: Encode.head (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=head) def head(+items: J.Json, +d: Delim) -> String: Encode.tab.rep (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=tab.rep) def tab.rep(+items: J.Json, +d: Delim) -> R.Rep: Encode.arr.pick (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=arr.pick) def arr.pick(+empty: Bool, +prims: Bool, +tab: Bool, +items: J.Json, +d: Delim, +ls: R.Rep) -> R.Rep: Encode.arr.rep (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=arr.rep) # An array's rep. `elem` is true for an element of another array, where the # tabular form is not available (section 9.4); `ls` is the encoding of the # elements as list items. def arr.rep(+elem: Bool, +items: J.Json, +d: Delim, +ls: R.Rep) -> R.Rep: Encode.enc (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=enc) # One def for values, object fields and list items. `elem` says the value is an # array element (no tabular form). `j` shrinks on every call. def enc(j: J.Json, +elem: Bool, +d: Delim) -> R.Rep: Encode.encode (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/encode.bend&name=encode) # Encode a value as TOON text. def encode(j: J.Json, o: EOpts) -> String: Entry.Ent (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/entry.bend&name=Ent) type Ent is Data: ENot{} EVal{k: String, v: J.Json} EOpen{k: String} EArr{k: Maybe<&2, String>, h: H.Hdr} Entry.val.done (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/entry.bend&name=val.done) def val.done(+k: String, +r: Result<&2, &2, String, J.Json>) -> Result<&2, &2, String, Ent>: Entry.val.pick (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/entry.bend&name=val.pick) def val.pick(+blank: Bool, +arr: Bool, +k: String, +t: String) -> Result<&2, &2, String, Ent>: Entry.val (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/entry.bend&name=val) # The text after the colon of `key:`. def val(+k: String, +v: String) -> Result<&2, &2, String, Ent>: Entry.hdr.done (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/entry.bend&name=hdr.done) def hdr.done(+k: Maybe<&2, String>, +r: Result<&2, &2, String, H.Hdr>) -> Result<&2, &2, String, Ent>: Entry.quoted.pick (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/entry.bend&name=quoted.pick) def quoted.pick(+colon: Bool, +brack: Bool, +k: String, +rest: String) -> Result<&2, &2, String, Ent>: Entry.quoted.rest (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/entry.bend&name=quoted.rest) # quoted key, then what follows its closing quote def quoted.rest(+k: String, +rest: String) -> Result<&2, &2, String, Ent>: Entry.quoted (https://jend.leeeet.dev/definition.txt?path=bend-toon-codec@0.1.0.0/src/entry.bend&name=quoted) def quoted(+r: Result<&2, &2, String, T.Cut>) -> Result<&2, &2, String, Ent>: More: https://jend.leeeet.dev/packages/bend-toon-codec.txt?definitions_offset=100