yaml-for-bend Releases (2): 0.1.1.0 0x856d414a32087762da315b6efc605eaa indexed https://jend.leeeet.dev/files.txt?path=yaml-for-bend@0.1.1.0 0.1.0.0 0x36754ca959c7683aed7402df6aa2fca0 unindexed https://jend.leeeet.dev/files.txt?path=yaml-for-bend@0.1.0.0 Definitions (583, 1 to 100 shown): Compose.Schema (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=Schema) # How scalars resolve: the YAML 1.2 Core schema, or the YAML 1.1 types. type Schema is Data: Core{} Yaml11{} Compose.Limits (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=Limits) # What a load may take, so a hostile text can't make it slow or huge: the # characters in the text, how deep its collections may nest, how many nodes # aliases may copy into a document, and how long a number may be when it is # written in a base other than ten (converting one takes time that grows # with the square of its length). type Limits is Data: Limits{size: Nat, depth: Nat, aliases: Nat, digits: Nat} Compose.Caps (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=Caps) # The limits the composer checks: the size is checked before it runs. type Caps is Data: Caps{depth: Nat, aliases: Nat, digits: Nat} Compose.Item (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=Item) # A finished node, and whether it is the merge key "<<". type Item is Data: Item{val: V.Yaml, merge: Bool} Compose.Open (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=Open) # A collection still open: its anchor and tag, its items so far (newest # first; a mapping's alternate keys and values), how many nodes came before # it, and where it starts. type Open is Data: OSeq{anchor: Maybe<&2, String>, tag: P.Tag, items: List<&2, V.Yaml>, start: Nat, at: T.Mark} OMap{anchor: Maybe<&2, String>, tag: P.Tag, items: List<&2, Item>, start: Nat, at: T.Mark} Compose.Anchored (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=Anchored) # An anchored node and how many nodes it holds. type Anchored is Data: Anchored{val: V.Yaml, size: Nat} Compose.Doc (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=Doc) # A document and where it starts. type Doc is Data: Doc{val: V.Yaml, at: T.Mark} Compose.Co (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=Co) # The composer: the open collections, the anchors, how many nodes the # document has (aliases counted in full), the document's value once it has # one, the documents so far (newest first), where the document started, # how deep its collections nest here, and how many nodes aliases copied. type Co is Data: Co{stack: List<&2, Open>, anchors: Map<&2, Anchored>, count: Nat, root: Maybe<&2, V.Yaml>, docs: List<&2, Doc>, opened: T.Mark, depth: Nat, copied: Nat} Compose.Ord (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=Ord) # Keys in order, and each key's entry, looked up by its canon text. type Ord is Data: Ord{index: Map<&2, V.Entry>, order: List<&2, String>} Compose.when (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=when) def when(-A: Type, hit: Bool, yes: Unit -> A, no: Unit -> A) -> A: Compose.content (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=content) def content(why: String, at: T.Mark) -> T.Error: Compose.ord.new (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=ord.new) def ord.new() -> Ord: Compose.ord.has (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=ord.has) def ord.has(o: Ord, +key: V.Yaml) -> Bool: Compose.ord.put.at (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=ord.put.at) def ord.put.at(hm: Map<&2, V.Entry> & Bool, +order: List<&2, String>, +c: String, key: V.Yaml, val: V.Yaml) -> Ord: Compose.ord.put (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=ord.put) # Puts +key+'s value: in its place when it's there, else at the end. def ord.put(o: Ord, +key: V.Yaml, val: V.Yaml) -> Ord: Compose.ord.merge (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=ord.merge) # Each entry put in turn. def ord.merge(es: List<&2, V.Entry>, o: Ord) -> Ord: Compose.ord.fill (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=ord.fill) # The entries whose keys aren't there yet. def ord.fill(es: List<&2, V.Entry>, +o: Ord) -> Ord: Compose.ord.list (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=ord.list) def ord.list(order: List<&2, String>, +m: Map<&2, V.Entry>) -> List<&2, V.Entry>: Compose.ord.entries (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=ord.entries) def ord.entries(o: Ord) -> List<&2, V.Entry>: Compose.key.full (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=key.full) def key.full(v: V.Yaml) -> String: Compose.item.val (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=item.val) def item.val(i: Item) -> V.Yaml: Compose.item.merge (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=item.merge) def item.merge(i: Item) -> Bool: Compose.merge.list (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=merge.list) # A list of mappings merged, the earlier winning. def merge.list(xs: List<&2, V.Yaml>, +o: Ord) -> Result<&2, &2, String, Ord>: Compose.merge.value (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=merge.value) # What a "<<" brings in: a mapping's entries, or each of a list's. def merge.value(v: V.Yaml, +o: Ord) -> Result<&2, &2, String, Ord>: Compose.merge.step (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=merge.step) def merge.step(r: Result<&2, &2, String, Ord>, +k: Item, v: Item, +seen: Bool) -> Result<&2, &2, String, Ord>: Compose.merges (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=merges) # The merged entries, from the mapping's "<<" (it may have one). def merges(items: List<&2, Item>, r: Result<&2, &2, String, Ord>, +seen: Bool) -> Result<&2, &2, String, Ord>: Compose.joined (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=joined) def joined(merged: Result<&2, &2, String, Ord>, own: Result<&2, &2, String, Ord>) -> Result<&2, &2, String, V.Yaml>: Compose.longer (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=longer) # Whether +s+ has more than +n+ characters, looking at no more than that. def longer(s: String, n: Nat) -> Bool: Compose.key.text (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=key.text) # A key as an error shows it: its first 80 characters. def key.text(v: V.Yaml) -> String: Compose.own.step (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=own.step) def own.step(r: Result<&2, &2, String, Ord>, +k: Item, v: Item) -> Result<&2, &2, String, Ord>: Compose.owns (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=owns) # The mapping's own entries, each key once. def owns(items: List<&2, Item>, r: Result<&2, &2, String, Ord>) -> Result<&2, &2, String, Ord>: Compose.map.value (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=map.value) # A mapping from its keys and values, oldest first: merged entries first, # then its own, which replace any merged ones with the same key. def map.value(+items: List<&2, Item>) -> Result<&2, &2, String, V.Yaml>: Compose.is_plain (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=is_plain) def is_plain(s: T.Style) -> Bool: Compose.scalar.value (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=scalar.value) def scalar.value(s: Schema, t: P.Tag, +text: String, +plain: Bool) -> Result<&2, &2, String, V.Yaml>: Compose.is_merge (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=is_merge) # Whether a scalar is YAML 1.1's merge key: "<<" plain, or tagged !!merge. def is_merge(s: Schema, t: P.Tag, +text: String, +plain: Bool) -> Bool: Compose.as.number (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=as.number) # Whether a scalar's text is read as a number: plain without a tag, or # tagged !!int or !!float. def as.number(t: P.Tag, +plain: Bool) -> Bool: Compose.in.base (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=in.base) def in.base(s: Schema, +text: String) -> Bool: Compose.too.long (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=too.long) # Whether a scalar is a number in another base longer than +limit+. def too.long(+s: Schema, t: P.Tag, +text: String, +plain: Bool, +limit: Nat) -> Bool: Compose.collection (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=collection) def collection(t: P.Tag, v: V.Yaml) -> V.Yaml: Compose.co.count (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.count) def co.count(co: Co) -> Nat: Compose.co.docs (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.docs) def co.docs(co: Co) -> List<&2, Doc>: Compose.attach (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=attach) # A finished node goes to the collection it's in, or is the document. def attach(co: Co, item: Item) -> Co: Compose.name.anchor (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=name.anchor) def name.anchor(m: Map<&2, Anchored>, anchor: Maybe<&2, String>, v: V.Yaml, size: Nat) -> Map<&2, Anchored>: Compose.finish (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=finish) # A node of +size+ nodes is finished: its anchor names it, and the count # grows by +more+ (the nodes not counted yet: a collection's items were). def finish(co: Co, anchor: Maybe<&2, String>, +item: Item, +size: Nat, more: Nat) -> Co: Compose.node.done (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=node.done) def node.done(r: Result<&2, &2, String, V.Yaml>, co: Co, anchor: Maybe<&2, String>, +merge: Bool, +size: Nat, more: Nat, at: T.Mark) -> Result<&2, &2, T.Error, Co>: Compose.is_name (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=is_name) def is_name(m: Maybe<&2, String>, +name: String) -> Bool: Compose.opens (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=opens) # Whether a collection still open has the anchor +name+. def opens(stack: List<&2, Open>, +name: String) -> Bool: Compose.found (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=found) def found(hm: Map<&2, Anchored> & Bool) -> Bool: Compose.co.copied (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.copied) def co.copied(co: Co, +more: Nat) -> Co: Compose.co.copied.count (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.copied.count) def co.copied.count(co: Co) -> Nat: Compose.co.doc.start (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.doc.start) def co.doc.start(co: Co, at: T.Mark) -> Co: Compose.co.doc.end (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.doc.end) def co.doc.end(co: Co) -> Co: Compose.map.tagged (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=map.tagged) def map.tagged(r: Result<&2, &2, String, V.Yaml>, t: P.Tag) -> Result<&2, &2, String, V.Yaml>: Compose.co.close (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.close) # The collection on top ends. def co.close(co: Co) -> Result<&2, &2, T.Error, Co>: Compose.limits (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=limits) # The default limits: a text of at most 1048576 characters (1 MiB), nesting # at most 256 deep, aliases copying at most 100000 nodes into a document, # and numbers in other bases at most 1000 characters long. def limits() -> Limits: Compose.limits.size (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=limits.size) def limits.size(l: Limits) -> Nat: Compose.limits.depth (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=limits.depth) def limits.depth(l: Limits) -> Nat: Compose.limits.aliases (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=limits.aliases) def limits.aliases(l: Limits) -> Nat: Compose.limits.digits (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=limits.digits) def limits.digits(l: Limits) -> Nat: Compose.caps (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=caps) def caps(+l: Limits) -> Caps: Compose.caps.depth (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=caps.depth) def caps.depth(c: Caps) -> Nat: Compose.caps.aliases (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=caps.aliases) def caps.aliases(c: Caps) -> Nat: Compose.caps.digits (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=caps.digits) def caps.digits(c: Caps) -> Nat: Compose.limit.error (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=limit.error) def limit.error(why: String, at: T.Mark) -> T.Error: Compose.co.push (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.push) # A collection opens, unless collections already nest as deep as allowed. def co.push(co: Co, o: Open, +limit: Nat, at: T.Mark) -> Result<&2, &2, T.Error, Co>: Compose.alias.got (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=alias.got) def alias.got(ma: Map<&2, Anchored> & Anchored, +co: Co, +limit: Nat, at: T.Mark) -> Result<&2, &2, T.Error, Co>: Compose.co.alias (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.alias) # An alias: a copy of its node, counted at the node's full size. An alias # inside the node it names would make a cycle, which a tree can't hold. def co.alias(co: Co, +name: String, +limit: Nat, +at: T.Mark) -> Result<&2, &2, T.Error, Co>: Compose.co.step (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.step) def co.step(e: P.Evt, +co: Co, +s: Schema, +c: Caps) -> Result<&2, &2, T.Error, Co>: Compose.co.run (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.run) def co.run(evs: List<&2, P.Evt>, +s: Schema, +c: Caps, r: Result<&2, &2, T.Error, Co>) -> Result<&2, &2, T.Error, Co>: Compose.co.new (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=co.new) def co.new() -> Co: Compose.composed.ok (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=composed.ok) def composed.ok(r: Result<&2, &2, T.Error, Co>) -> Result<&2, &2, T.Error, List<&2, Doc>>: Compose.composed (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=composed) # A text that isn't YAML is a syntax error, before anything its values do # wrong. def composed(r: Result<&2, &2, T.Error, Co>, error: Maybe<&2, T.Error>) -> Result<&2, &2, T.Error, List<&2, Doc>>: Compose.compose (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/compose.bend&name=compose) # The documents the events hold, through schema +s+, within limits +lim+. def compose(p: P.Parsed, +s: Schema, +lim: Limits) -> Result<&2, &2, T.Error, List<&2, Doc>>: Core.yaml.tag (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=yaml.tag) def yaml.tag(name: String) -> String: Core.when (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=when) def when(-A: Type, hit: Bool, yes: Unit -> A, no: Unit -> A) -> A: Core.is_null (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=is_null) def is_null(+s: String) -> Bool: Core.is_true (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=is_true) def is_true(+s: String) -> Bool: Core.is_false (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=is_false) def is_false(+s: String) -> Bool: Core.dec.pat (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=dec.pat) def dec.pat() -> List<&2, R.Pat>: Core.oct.pat (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=oct.pat) def oct.pat() -> List<&2, R.Pat>: Core.hex.pat (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=hex.pat) def hex.pat() -> List<&2, R.Pat>: Core.float.pat (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=float.pat) # [-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)? def float.pat() -> List<&2, R.Pat>: Core.is_inf (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=is_inf) def is_inf(+s: String) -> Bool: Core.is_nan (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=is_nan) def is_nan(+s: String) -> Bool: Core.unsigned (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=unsigned) def unsigned(s: String) -> String: Core.is_neg (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=is_neg) def is_neg(s: String) -> Bool: Core.int.of (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=int.of) # An integer's decimal text, if +s+ is one. def int.of(+s: String) -> Maybe<&2, String>: Core.in.base (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=in.base) # Whether +s+ is an integer in a base other than ten, which takes time # that grows with the square of its length to read. def in.base(+s: String) -> Bool: Core.float.of (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=float.of) # A float's text, if +s+ is one: as written, or ".inf", "-.inf", ".nan". def float.of(+s: String) -> Maybe<&2, String>: Core.or.int (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=or.int) def or.int(m: Maybe<&2, String>, s: String, rest: Unit -> V.Yaml) -> V.Yaml: Core.or.float (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=or.float) def or.float(m: Maybe<&2, String>, rest: Unit -> V.Yaml) -> V.Yaml: Core.plain (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=plain) # An untagged plain scalar. def plain(+s: String) -> V.Yaml: Core.must (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=must) def must(m: Maybe<&2, V.Yaml>, +tag: String, +s: String) -> Result<&2, &2, String, V.Yaml>: Core.int.yaml (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=int.yaml) def int.yaml(m: Maybe<&2, String>) -> Maybe<&2, V.Yaml>: Core.float.yaml (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=float.yaml) # !!float: a float, or an integer written as one ("3" is 3.0). def float.yaml(m: Maybe<&2, String>, i: Maybe<&2, String>) -> Maybe<&2, V.Yaml>: Core.known (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=known) # The tags whose text the Core schema reads: "!", !!str, !!null, !!bool, # !!int and !!float. def known(+tag: String) -> Bool: Core.read (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=read) # A scalar's text read by a known tag: "!" and !!str are a string, and # !!null, !!bool, !!int and !!float must be one. def read(+tag: String, +s: String) -> Result<&2, &2, String, V.Yaml>: Core.read.or.keep (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=read.or.keep) # A tag that isn't known is kept with the text, as data: no tag runs code. def read.or.keep(hit: Bool, +tag: String, +s: String) -> Result<&2, &2, String, V.Yaml>: Core.tagged (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=tagged) # A scalar with a tag. def tagged(+tag: String, +s: String) -> Result<&2, &2, String, V.Yaml>: Core.known.collection (https://jend.leeeet.dev/definition.txt?path=yaml-for-bend@0.1.1.0/core.bend&name=known.collection) # The tags that leave a collection as it is: "!", !!seq and !!map. def known.collection(+tag: String) -> Bool: More: https://jend.leeeet.dev/packages/yaml-for-bend.txt?definitions_offset=100