bend-net-json

Releases (1):
  0.3.0.0  0x16458a2db4f36577294543ec2a6d420c  indexed  https://jend.leeeet.dev/files.txt?path=bend-net-json@0.3.0.0

Definitions (70):
  Json.Val (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=Val)
   # Num keeps the number's exact text, so no precision is lost.
   type Val is Data:
     Null{}
     Flag{on: Bool}
     Num{s: String}
     Str{s: String}
     Arr{xs: List<&2, Val>}
     Obj{m: Map<&2, Val>}
  Json.Next (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=Next)
   type Next is Data:
     Next{v: Val, rest: String}
  Json.Open (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=Open)
   # An open container: array items so far (reversed), or object fields and the
   # key whose value comes next.
   type Open is Data:
     OArr{xs: List<&2, Val>}
     OObj{m: Map<&2, Val>, key: String}
  Json.St (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=St)
   type St is Data:
     SValue{s: String, stack: List<&2, Open>}
     SKey{s: String, stack: List<&2, Open>}
     SColon{key: String, s: String, stack: List<&2, Open>}
     SStr{s: String, acc: String, key: Bool, stack: List<&2, Open>}
     SAfter{v: Val, s: String, stack: List<&2, Open>}
     SDone{v: Val, s: String}
     SFail{}
  Json.is_ws (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=is_ws)
   def is_ws(+c: U32) -> Bool:
  Json.ws.go (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=ws.go)
   # Bool.pick runs both arms, so loops peek: the next char's class is a Bool
   # param and only the matching arm recurses.
   def ws.go(t: String, +c: U32, ws: Bool) -> String:
  Json.skip_ws (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=skip_ws)
   def skip_ws(s: String) -> String:
  Json.digit (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=digit)
   def digit(+c: U32) -> Bool:
  Json.num.trans (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=num.trans)
   def num.trans(+st: U32, +c: U32) -> U32:
  Json.num.accepts (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=num.accepts)
   def num.accepts(+st: U32) -> Bool:
  Json.num.end (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=num.end)
   def num.end(+st: U32, acc: String, rest: String) -> Maybe<&2, Next>:
  Json.num.go (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=num.go)
   def num.go(t: String, +c: U32, +st: U32, acc: String, stop: Bool) -> Maybe<&2, Next>:
  Json.num (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=num)
   def num(s: String) -> Maybe<&2, Next>:
  Json.lit.if (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=lit.if)
   def lit.if(+s: String, v: Val, n: Nat, ok: Bool) -> Maybe<&2, Next>:
  Json.lit (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=lit)
   def lit(+s: String, word: String, v: Val, +n: Nat) -> Maybe<&2, Next>:
  Json.Esc (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=Esc)
   type Esc is Data:
     Esc{cp: U32, rest: String}
  Json.hexd (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=hexd)
   def hexd(+c: U32) -> U32:
  Json.hex4.go (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=hex4.go)
   def hex4.go(s: String, +acc: U32, n: Nat) -> Maybe<&2, Esc>:
  Json.hex4 (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=hex4)
   def hex4(s: String) -> Maybe<&2, Esc>:
  Json.is_hi (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=is_hi)
   def is_hi(+v: U32) -> Bool:
  Json.is_lo (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=is_lo)
   def is_lo(+v: U32) -> Bool:
  Json.pair.lo (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=pair.lo)
   def pair.lo(+hi: U32, +rest: String, lo: Maybe<&2, Esc>) -> Esc:
  Json.pair (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=pair)
   # §8.2: a high surrogate pairs with a following \uDC00-\uDFFF; a lone one is U+FFFD.
   def pair(+hi: U32, +rest: String) -> Esc:
  Json.esc.u (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=esc.u)
   def esc.u(e: Maybe<&2, Esc>) -> Maybe<&2, Esc>:
  Json.esc.simple (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=esc.simple)
   def esc.simple(+e: U32) -> U32:
  Json.esc.one (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=esc.one)
   # One escape after the backslash.
   def esc.one(t: String) -> Maybe<&2, Esc>:
  Json.str.esc (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=str.esc)
   def str.esc(e: Maybe<&2, Esc>, acc: String, key: Bool, stack: List<&2, Open>) -> St:
  Json.str.close (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=str.close)
   def str.close(+acc: String, t: String, key: Bool, stack: List<&2, Open>) -> St:
  Json.str.c (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=str.c)
   def str.c(quote: Bool, ctl: Bool, bs: Bool, c: U32, t: String, acc: String, key: Bool, stack: List<&2, Open>) -> St:
  Json.str.step (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=str.step)
   # §7: unescaped chars below U+0020 are not allowed in a string.
   def str.step(s: String, acc: String, key: Bool, stack: List<&2, Open>) -> St:
  Json.got (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=got)
   def got(m: Maybe<&2, Next>, stack: List<&2, Open>) -> St:
  Json.open.close (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=open.close)
   def open.close(r: String, close: Val, stack: List<&2, Open>, empty: Bool, open: Open) -> St:
  Json.value.step (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=value.step)
   def value.step(+s: String, +c: U32, +t: String, +stack: List<&2, Open>) -> St:
  Json.value (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=value)
   def value(s: String, stack: List<&2, Open>) -> St:
  Json.key (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=key)
   def key(s: String, stack: List<&2, Open>) -> St:
  Json.colon.top (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=colon.top)
   def colon.top(k: String, r: String, stack: List<&2, Open>) -> St:
  Json.colon (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=colon)
   def colon(k: String, s: String, stack: List<&2, Open>) -> St:
  Json.after.arr.c (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=after.arr.c)
   # A finished value joins its container; then "," or the closing bracket.
   def after.arr.c(comma: Bool, close: Bool, t: String, xs: List<&2, Val>, up: List<&2, Open>) -> St:
  Json.after.arr (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=after.arr)
   def after.arr(xs: List<&2, Val>, r: String, up: List<&2, Open>) -> St:
  Json.after.obj.c (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=after.obj.c)
   def after.obj.c(comma: Bool, close: Bool, t: String, m: Map<&2, Val>, up: List<&2, Open>) -> St:
  Json.after.obj (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=after.obj)
   def after.obj(m: Map<&2, Val>, r: String, up: List<&2, Open>) -> St:
  Json.after (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=after)
   def after(v: Val, s: String, stack: List<&2, Open>) -> St:
  Json.step (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=step)
   def step(st: St) -> St:
  Json.done (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=done)
   def done(v: Val, rest: String) -> Maybe<&2, Val>:
  Json.run (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=run)
   # fuel: every step but the last eats at least one char.
   def run(fuel: Nat, st: St) -> Maybe<&2, Val>:
  Json.parse (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=parse)
   # One JSON text: a value with optional whitespace around it.
   def parse(+s: String) -> Maybe<&2, Val>:
  Json.get.hit (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=get.hit)
   def get.hit(r: Map<&2, Val> & Bool) -> Bool:
  Json.get.some (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=get.some)
   def get.some(r: Map<&2, Val> & Val) -> Maybe<&2, Val>:
  Json.get.has (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=get.has)
   def get.has(+m: Map<&2, Val>, +k: String, hit: Bool) -> Maybe<&2, Val>:
  Json.get.of (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=get.of)
   def get.of(+m: Map<&2, Val>, +k: String) -> Maybe<&2, Val>:
  Json.get (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=get)
   # The value under key k of an object.
   def get(v: Val, k: String) -> Maybe<&2, Val>:
  Json.hexc (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=hexc)
   def hexc(+n: U32) -> Char:
  Json.esc.put (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=esc.put)
   # The escaped form of one char, reversed (it is pushed onto a reversed acc).
   def esc.put(+c: U32, +acc: String) -> String:
  Json.esc.go (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=esc.go)
   def esc.go(s: String, acc: String) -> String:
  Json.esc (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=esc)
   def esc(s: String) -> String:
  Json.Item (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=Item)
   type Item is Data:
     ILit{s: String}
     IVal{v: Val}
  Json.items.sep (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=items.sep)
   def items.sep(first: Bool, tail: List<&2, Item>) -> List<&2, Item>:
  Json.items.arr (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=items.arr)
   def items.arr(xs: List<&2, Val>, first: Bool, rest: List<&2, Item>) -> List<&2, Item>:
  Json.items.obj (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=items.obj)
   def items.obj(kvs: List<&2, Sigma<&2, &2, String, _ => Val>>, first: Bool, rest: List<&2, Item>) -> List<&2, Item>:
  Json.put (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=put)
   def put(s: String, racc: String) -> String:
  Json.enc.go (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=enc.go)
   def enc.go(items: List<&2, Item>, racc: String) -> String:
  Json.encode (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=encode)
   # Compact JSON; object keys come out sorted.
   def encode(v: Val) -> String:
  Json.at.go (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=at.go)
   def at.go(xs: List<&2, Val>, n: Nat) -> Maybe<&2, Val>:
  Json.at (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=at)
   def at(v: Val, n: Nat) -> Maybe<&2, Val>:
  Json.u32.over (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=u32.over)
   def u32.over(+acc: U32, +c: U32) -> Bool:
  Json.u32.dig (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=u32.dig)
   def u32.dig(s: String, +acc: U32, bad: Bool) -> Maybe<&2, U32>:
  Json.u32.zero (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=u32.zero)
   def u32.zero(t: String) -> Maybe<&2, U32>:
  Json.u32.lead (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=u32.lead)
   def u32.lead(+c: U32, t: String, zero: Bool) -> Maybe<&2, U32>:
  Json.u32.num (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=u32.num)
   def u32.num(s: String) -> Maybe<&2, U32>:
  Json.u32 (https://jend.leeeet.dev/definition.txt?path=bend-net-json@0.3.0.0/json.bend&name=u32)
   def u32(v: Val) -> Maybe<&2, U32>: