yaml-for-bend

Releases (2)

• 0.1.1.0 indexed
• 0.1.0.0 unindexed

Definitions (583)

compose.bend

• type SchemaHow scalars resolve: the YAML 1.2 Core schema, or the YAML 1.1 types.
• type LimitsWhat 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 CapsThe limits the composer checks: the size is checked before it runs.
• type ItemA finished node, and whether it is the merge key "<<".
• type OpenA 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 AnchoredAn anchored node and how many nodes it holds.
• type DocA document and where it starts.
• type CoThe 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 OrdKeys in order, and each key's entry, looked up by its canon text.
• def when
• def content
• def ord.new
• def ord.has
• def ord.put.at
• def ord.putPuts +key+'s value: in its place when it's there, else at the end.
• def ord.mergeEach entry put in turn.
• def ord.fillThe entries whose keys aren't there yet.
• def ord.list
• def ord.entries
• def key.full
• def item.val
• def item.merge
• def merge.listA list of mappings merged, the earlier winning.
• def merge.valueWhat a "<<" brings in: a mapping's entries, or each of a list's.
• def merge.step
• def mergesThe merged entries, from the mapping's "<<" (it may have one).
• def joined
• def longerWhether +s+ has more than +n+ characters, looking at no more than that.
• def key.textA key as an error shows it: its first 80 characters.
• def own.step
• def ownsThe mapping's own entries, each key once.
• def map.valueA mapping from its keys and values, oldest first: merged entries first, then its own, which replace any merged ones with the same key.
• def is_plain
• def scalar.value
• def is_mergeWhether a scalar is YAML 1.1's merge key: "<<" plain, or tagged !!merge.
• def as.numberWhether a scalar's text is read as a number: plain without a tag, or tagged !!int or !!float.
• def in.base
• def too.longWhether a scalar is a number in another base longer than +limit+.
• def collection
• def co.count
• def co.docs
• def attachA finished node goes to the collection it's in, or is the document.
• def name.anchor
• def finishA 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 node.done
• def is_name
• def opensWhether a collection still open has the anchor +name+.
• def found
• def co.copied
• def co.copied.count
• def co.doc.start
• def co.doc.end
• def map.tagged
• def co.closeThe collection on top ends.
• def limitsThe 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.size
• def limits.depth
• def limits.aliases
• def limits.digits
• def caps
• def caps.depth
• def caps.aliases
• def caps.digits
• def limit.error
• def co.pushA collection opens, unless collections already nest as deep as allowed.
• def alias.got
• def co.aliasAn alias: a copy of its node, counted at the node's full size.
• def co.step
• def co.run
• def co.new
• def composed.ok
• def composedA text that isn't YAML is a syntax error, before anything its values do wrong.
• def composeThe documents the events hold, through schema +s+, within limits +lim+.

core.bend

• def yaml.tag
• def when
• def is_null
• def is_true
• def is_false
• def dec.pat
• def oct.pat
• def hex.pat
• def float.pat[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?
• def is_inf
• def is_nan
• def unsigned
• def is_neg
• def int.ofAn integer's decimal text, if +s+ is one.
• def in.baseWhether +s+ is an integer in a base other than ten, which takes time that grows with the square of its length to read.
• def float.ofA float's text, if +s+ is one: as written, or ".inf", "-.inf", ".nan".
• def or.int
• def or.float
• def plainAn untagged plain scalar.
• def must
• def int.yaml
• def float.yaml!!float: a float, or an integer written as one ("3" is 3.0).
• def knownThe tags whose text the Core schema reads: "!", !!str, !!null, !!bool, !!int and !!float.
• def readA scalar's text read by a known tag: "!" and !!str are a string, and !!null, !!bool, !!int and !!float must be one.
• def read.or.keepA tag that isn't known is kept with the text, as data: no tag runs code.
• def taggedA scalar with a tag.
• def known.collectionThe tags that leave a collection as it is: "!", !!seq and !!map.