emerging-ezjson

Search uses release 1.3.0.0 · 381 definitions

Releases (3)

1.3.0.0 indexed
1.2.0.0 unindexed
1.1.0.0 unindexed

Definitions (381)

src/pull.bend

def place.val.herea value has landed on the suffix in hand
def place.key.herean object key has landed on the suffix in hand
def str.val.herea string value on the suffix in hand.
def str.place.herea finished string whose rest is the suffix the stepper is on
def str.skip.herea skipped string closed on the suffix in hand
def span.kindone character of a string: stay in it, close it, start an escape, or fail
def span.kind.ofclassify one string character.
def close.skip.go`]` or `}` of a skip: depth 1 finishes the value, deeper keeps going.
def close.skip`]` or `}` of a skip, once the frame has been popped
def close.nextthe parent after a container closes, for a reader
def close.outa container closed.
def close.arra `]`.
def close.obja `}`.
def punct.commaa comma between values, or between object members
def punct.colona colon after a key
def punct.arr.go`[` pushed.
def punct.arr.if`[`, once it is known whether a value may start
def punct.arr`[`, when a value may start
def punct.obj.go`{` pushed
def punct.obj.if`{`, once it is known whether a value may start
def punct.obj`{`, when a value may start
def punct.goone punctuation token, once the root is still open.
def punct.onone punctuation token
def idle.spacewhitespace, kept as the same state
def look.quotea `"` may open a string here
def look.worda word's first character.
def look.planone character between tokens.
def idle.eofthe end of the text, between tokens
def word.kind.numa number, when the word is not null, true, or false
def word.kind.gonull, true, false, or a number that kept a legal spelling
def word.kindwhat a bare word is
def word.eof.placea word that ended at the end of the text
def lay.planthe delimiter of a skipped word, once the value is inside the container.
def see.more.onplace the word, then take the delimiter, because the skip is still open
def see.moreplace the word, then take the delimiter
def word.speciala code point that ends a bare word: the same bytes `classify` calls punctuation, a quote, a backslash, or whitespace.
type Wstwhere a plain word run stopped.
def word.stepone more plain byte of a word.
def word.keep.gokeep the byte when it is not a delimiter
def word.digit.goa digit is never a delimiter, so a long number does not walk `classify`
def word.decideone byte of a word: another plain byte, or the delimiter that ends it
def word.runthe suffix after a plain word.
def word.dropdrop an unread suffix.
def word.forgetdrop a word's characters.
def word.burst.erra failed word, once its buffer and the unread suffix are gone
def word.burst.deada failed word drops the buffer after the unread suffix
def jump.keepa finished event already carries its suffix.
def jump.unless.donea state that already stopped drops `rest`.
def word.burst.eof.rawa word that ended because the text did, once its spelling is in hand
def word.burst.eof.atthe empty suffix of an eof is dropped, then the word is placed
def word.burst.skipthe skip is still inside a container, so the delimiter is taken and the stepper continues.
def word.burst.goala value landed on the delimiter.
def word.burst.junkboth the spelling and the unread suffix are dropped when the word is not one
def word.burst.atomplace the word.
def word.burst.rawthe delimiter is classified once, and only when a skip must consume it.
def word.burst.stopa word ended on a delimiter.
def word.burst.failboth the unread suffix and the buffer are dropped when the word cannot finish
def word.burst.at`got` is the suffix after the run, and why it stopped
def word.burstplain digits and letters in one loop.
def span.esca backslash in a span: copy the prefix, or drop it when skipping
def span.advancethe next state after one character of a span.
def quote.gothe first character inside a string.
def quote.firstthe first character inside a string
def sk.advancethe next state after one character of a string being skipped
def copy.hit.goone character of a string that is being decoded
def copy.hitone character of a string that is being decoded
def esc.putthe character after a backslash, once `u` has been noticed
def esc.hit.gothe character after a backslash
def esc.hitthe character after a backslash
def uni.end.goa `\u` code point that is not a surrogate
def uni.endfour hex digits are in
def uni.putone more hex digit, or the code point
def uni.hit.goone hex digit of a `\u` escape
def uni.hitone hex digit of a `\u` escape
def hi.hit.gothe character after a high surrogate, on a live cursor
def hi.hitthe character after a high surrogate: it has to be a backslash
def hiesc.hit.gothe character after the backslash of a pair: it has to be `u`
def hiesc.hitthe character after the backslash of a pair
def lo.end.gothe low surrogate is in, or it is not one
def lo.endfour hex digits of the low surrogate are in
def lo.putone more hex digit of the low surrogate, or the code point
def lo.hit.goone hex digit of the low surrogate
def lo.hitone hex digit of the low surrogate
def sk.esc.puta decoded short escape puts the skip back in the string
def sk.esc.goa short escape, or the start of `\u`, inside a skipped string
def sk.escthe character after a backslash in a skipped string
def sk.uni.end.goa skipped `\u` that is not a surrogate
def sk.uni.endfour hex digits of a skipped `\u` are in
def sk.uni.putone more skipped hex digit, or the code point
def sk.uni.goone hex digit of a skipped `\u`
def sk.unione hex digit of a skipped `\u`
def sk.hithe character after a skipped high surrogate
def sk.hiesc`u` after the backslash of a skipped pair
def sk.lo.endthe low half of a skipped pair is in, or it is not one
def sk.lo.putone more hex digit of a skipped low surrogate, or the code point
def sk.lo.goone hex digit of a skipped low surrogate
def next.levelsthe levels of the walk's budget: next.grow runs levels 0 to 32 of leaves of next.leaf() jumps, so a walk may jump back from a plain word 4 (2^33 - 1) times, more than the 2^32 - 1 it had.
def next.goone character, between events.
def next.leafthe jumps one leaf of the budget allows.
def next.runa walk with a budget of 2^lvl jumps: one step's budget at depth 0, and the budget below it twice otherwise.