yaml-for-bend

Search uses release 0.1.1.0 · 583 definitions

Releases (2)

type PosWhere a node is written: at the start of a line, right after "- ", right after a key's ":" (or a tag), or as the later items of a collection, each on a line of its own.
def when
def code
def is_in
def hex.digit
def hex.text+n+ in +width+ hex digits.
def is_plain.charWhat YAML may hold as it is: printable characters but the ones double quotes escape.
def escape.other
def escape
def escaped
def quoted
def all.plain
def last.char
def first.char
def is_str
def is_safe.plainWhether +s+ reads back as itself when written plain: it isn't empty, has no blank at either end, starts with no indicator, holds no ": ", " #" or character that needs escaping, and the Core schema reads it as a string.
def str.text
def tag.text
def spaces
def leadWhat goes before a node's first line: indentation at a line's start, a break and indentation after a key, nothing after "- ".
def scalar.leadA scalar after its key gets a space; at a line's start, indentation.
def is_more
def is_collection
def scalar.textA scalar's text, or an empty collection's.
def is_tagged
def emit+v+ written at +p+, its lines indented +ind+.
def dump+v+ as a YAML document.
def dump.allValues as a stream of documents, each after "---".

type ExpThe exponent after "e": its sign and digits, as an offset point shift.
def when
def code
def digitA digit's value, for digits up to base 36 ("a" and "A" are 10).
def digit.char
def big.chars
def big.trim.go
def big.trim
def big.of.natA Nat that fits, as a big number.
def big.mul.add+ds+ times +base+, plus +carry+.
def big.readThe digits of +s+ in +base+ (each a digit of that base) as a big number.
def big.digits
def big.show
def signedAn integer's text: "-" when negative and not zero.
def zeros
def drop.zeros
def decimalDecimal digits as they'd be written, without zeros in front.
def int.text+s+, digits of +base+, as decimal text with the sign.
def take.digits
def dec.placeThe decimal whose digits are +ds+ (no zeros at either end) with the point +point+ places from their left, written "12.5", "0.001" or "300.0".
def dec.offWhere a decimal's point is counted from, so it can go left of the digits; an exponent is capped below it.
def big.small
def exp.natExponent digits as a Nat, capped past where a double ends (about 308).
def exp.read
def after.e
def after.dot
def point.at
def strip.end.zeros
def dec.exactThe value of a decimal literal ("1_000.5" without the "_", ".5", "1.", "2.5e-3"), written exactly: "1000.5", "0.5", "1.0", "0.0025".

type TagA node's tag, resolved: none, or its full name ("!" when non-specific).
type EvAn event, as libyaml's are.
type EvtAn event and where its node starts.
type WrittenA tag as written: its handle and suffix.
type PrefixA %TAG directive: a handle and the prefix it stands for.
type StThe parser's states.
type PsThe parser: the tokens left, the state, the states to return to, the document's tag prefixes, and the events so far (newest first).
type PStep
type ParsedThe events, and the error that ended them early, if one did.
type DirsThe directives before a document: its %TAG prefixes (over the defaults), checking that %YAML comes at most once and is 1.x and that no handle repeats.
def when
def ps.out
def ps.tags
def ps.state
def takeTakes the next token.
def emit
def goto
def push
def popReturns to the state on the stack.
def with.tags
def fail
def empty
def tok.kind
def tok.start
def tok.end
def kind.indexA token's kind as a number, to test it against a few.
def tok.is
def tok.any
def STREAM_END
def VERSION
def TAG_DIR
def DOC_START
def DOC_END
def BEND
def FSEQ_END
def FMAP_END
def BENTRY
def FENTRY
def KEY
def VALUE
def defaults