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)

main.bend

def parsea text as a value, or None when it is not JSON
def printa value as compact JSON
def prettya value as JSON indented two spaces a level, one element or member a line, with no newline at the end
def nullnull
def boola boolean
def stra string
def numa JSON number from its text, or null when that text is not one
def objan object from pairs
def arran array from a list
def getan object's value at a key; JNull when it is not an object or has no such key
def atan array's item at an index; JNull when it is not an array or has none
def haswhether an object has a key; false when the value is not an object.
def lenhow many elements an array, or members an object, has; 0 for anything else
def itemsan array's elements, in order; [] when the value is not an array.
def is_arrwhether a value is an array
def is_objwhether a value is an object
def as_boola boolean, or none when the value is not one
def as_stra string, or none when the value is not one
def as_numa number's text, or none when the value is not a number
def num.fixeda number's text written with `places` decimals, rounded half to even on its decimal digits (not through a binary float), as Python's `'%.Nf'` writes a value whose decimal text is exact; None when the text is not a JSON number.
def as_u32a number as a U32, or none when it is not one or does not fit
def as_f32a number as an F32, or none when it is not one or does not fit
def cursora cursor at the start of a JSON text.
def nextthe next event.
def skipdrop the next value, scalar or container, without building it
def textthe text of a string, key, or number event, copying a span.

src/fixed.bend

type Decwhere a number's point is: the digits before it, last digit first, and the digits after it
def mark.ean exponent mark, `e` or `E`
def mark.dota decimal point
def cut.putput a character before the first of a pair
def cut.atat a mark the cut is made; any other character is kept before it
def cut.ea text cut at its first exponent mark: what is before it, and after it
def cut.dota text cut at its first decimal point: what is before it, and after it
def esign.atan exponent's sign and digits: `-` makes it negative, `+` is dropped
def esignan exponent's sign and digits
def parts.ofthe parts of a text cut at its exponent mark
def partsan unsigned number's parts: its integer and fraction digits, and its exponent's sign and digits
def digit.nata digit's value
def nat.godecimal digits read onto acc, most significant first
def natdecimal digits' value
def upthe point one place right: the first fraction digit, or a 0 past the last, moves before the point
def downthe point one place left: the last integer digit, or a 0 before the first, moves after the point
def upsthe point `kk` places right
def downsthe point `kk` places left
def movethe digits with the point moved by the exponent
def placethe parts as digits around the point, the point moved by the exponent
def padthe first `nn` fraction digits, 0s past the last, and the digits dropped
def nonzero.ata 0 digit leaves the answer to the rest; any other digit is nonzero
def nonzerowhether any digit is not 0
def oddwhether the last kept digit is odd; no digit is an even 0
def tiea first dropped digit of 5 with no other nonzero digit dropped is a tie, which goes to the even neighbour
def round.atthe first dropped digit against 5
def round.upwhether the kept digits (last first) go up by one, from the dropped ones
def inc.atone more on a digit, carried: a 9 is 0 and carries
def incone more on digits written last first
def bumpthe kept digits, one more when they round up
def round.keepthe kept digits split at the last place
def roundevery digit to the last kept place, last first, rounded half to even
def trim.atan integer part with its leading 0s dropped; no digit is 0
def triman integer part with its leading 0s dropped; no digit is 0
def pointthe integer part, then a point and the fraction when there is one
def writerounded digits, last first, written with `nn` decimals
def unsignedan unsigned number's text with `nn` decimals
def text.ata sign kept in front of the unsigned rest
def texta number's text with `nn` decimals
def fixed.goSome of the text with `nn` decimals when `ok`, else None
def fixeda JSON number's text with `nn` decimals, or None when it is not one

src/lazy.bend

def stop`val` when `cond`, else what rest gives: the early exit of a search

src/lex.bend

type Tokthe tokens: brackets, `:`, `,`, a string (decoded), or a bare word (a number, true, false, null)
type Classwhat a char is: punctuation (with its token), a quote, whitespace, or a word char
type Modewhat the machine is inside of: nothing, a bare word, a string, an escape, a \u escape, a high surrogate waiting for its pair, or a rejected text
type Sura \u code point: an ordinary scalar, a high surrogate, or a low surrogate
type Lexthe lexer's state: buf and toks are both reversed
def classify.goa char's class, by code point.
def classifya char's class
def text.gothe buffer is reversed, so consing each head onto the front yields the text
def textthe buffered chars (reversed) as a string
def unescape.go
def unescapethe char an escape stands for; none when the escape is not one JSON allows
def escape.put
def escape.gothe char after a backslash, once it is known whether it is `u`
def escapethe char after a backslash in a string.
def hex.ok
def hexa hex digit's value
def unicode.sur.lo
def unicode.sur.hi
def unicode.sur
def unicode.pair
def unicode.end.go
def unicode.end
def unicode.put
def unicode.go
def unicodeone hex digit of a \uXXXX escape; the code point once four are in
def unicode.low.end.go
def unicode.low.end
def unicode.low.put
def unicode.low.go
def unicode.low
def step.str.go
def step.str