bend-schema-lib

Search uses release 0.4.1.0 · 126 definitions

Releases (3)

0.4.1.0 indexed
0.3.0.0 unindexed
0.1.0.0 unindexed

Definitions (126)

core.bend

type NumberBits
type Json
type JMember
type IntA whole number of either sign: IPos{n} is n, INeg{n} is -(n+1), so every integer has exactly one form (there is no -0).
type Raw
type Schema
type StepA step of a path.
type Why
type Err
def finite_numberJSON numbers use IEEE-754 binary64 bits.
def valid_jsonA value is valid when every number in it is finite.
def pick_raw
def lookupThe value under `name` in an object, or RMissing.
def pick_bool
def is_rnil
def is_missing
def in_names
def none_presentNone of the keys of a variant chain is in the object r.
def key_names---- a strict object: its keys ----
def no_extraEvery key of the object r is one of ns (anything but an object has none).
def drop_keyThe object r without its first key k (what lookup(k, r) reads).
def is_str
def is_tagThe tag under k is the string n.
def in_err
def str_len_ok
def num_ok
def int_lea <= b on integers.
def int_ok
def int_rawHow an integer is written: a non-negative as RNum, a negative as RNeg.
def len_okr is a string whose length is in the bounds: what conforms reads at an SStrLen, and what len_err refuses exactly when it fails.
def str_len_inThe same bounds as ready-made rules: a project's rule calls them by tag (`case 0n: str_len_in(1n, 64n, r)`), since a tag carries no numbers.
def nat_in
def is_bool
def raw_list
def raw_len
def count_ok
def list_len_ok
def has_keyk is a key of the object r.
def key_once_atname appears at most once among the keys of the object r.
def key_oncename appears at most once among the keys of the object r: nothing has been read yet.
def key_errThe repeated key as check reports it: at the key's own name, with no step after it (the second occurrence is not a place in the schema).
type JKind
def kind_eq
def kind_of
def has_kind
def apartNo value of kind k is claimed by both.
def disjoint
def alt_okAn alternative is a value that is present and has a kind of its own: not an absent field (the host writes no key, so no kind is there to pick by), and not s.json(), which takes every kind.
def no_altWhat an SEither would have taken, for the host to say.
def conforms
def here
def underAn error found under a step gets the step in front of its path.
def len_errAt an SStrLen the shape comes first, as everywhere else: a value that is not a string is NotString, a string out of its bounds is LengthNotIn, and a node the codec refused to build or that is absent reads as it does at every kind.
def later_l_pathAn error found further along a list is one element further: its first step, if it counts elements, counts one more.
def later_l
def later_i_path
def later_i
def later_f_pathAn error found in a later field is one field further.
def later_f
def firstThe first of two: the second counts only when the first found nothing.
def missing_orThe reason a value that is not the shape is refused, at the place it was found: an absent slot is Missing, a node the host refused to build (RTooBig) is TooLarge, anything else is the schema kind's own reason.
def pick_err
def true_err
def enum_err
def dup_errA second key of a variant chain in the object r: the first one found.
def extra_errThe first key of r that is not one of ns, at its own name.
def tag_errAt the end of a tagged chain no case matched: the value is not an object, or its tag is missing, or it names no case.
def count_errThe count, as an error: at an SListLen the count is read before any element, so a list out of bounds is CountNotIn at the list's own path.
def check
def guard
def nat_in_defectThe same two reasons at an SNatIn and an SBool, replayed along a path: the value's own kind is the defect when the path ends here, and it is not a defect at all further along (the walk passed it).
def int_defectThe same two reasons at an SInt and an SIntIn: a number of either sign is not the defect, and its bound is the defect only where the path ends.
def int_in_defect
def bool_defect
def no_rule
def first_why
def step_eq
def path_eq
def rule_defect
def not_list
def not_object
def nat_defect
def str_defect
def pick_why
def true_defect
def enum_defect
def no_variant
def dup_defectThe claim about a second key: every key passed is absent, and the key the path names is there.
def at_end
def extra_defectAt a strict object the path is one key, and the replay checks it on its own: the key is there, and it is not one of the names.
def tag_defect
def tag_key_defectThe tag key of a tagged case, taken twice, as defect replays it.
def defect
def check0
def conforms0
def is_chain
def is_object
def one_if_there
def count_present
def present_conform