bikkuriの内部構造

pub macro fn view(v: view::View): SynExpr ! {macro_error, Div, overflow} {  let d := HtmlView::html()  match v.tree_input {    Some(input) => View::child(d, input, v.child)    // The tree is taken from `ui` once, so the closures the view makes (of `@if`, `@for`,    // events) hold the tree and do not perform `ui` themselves.    None => {      let build := HtmlView::from_ui(d, v.child, v.span)      quote { view_in($build) }    }  }}

// Writes the signal and runs again, once each, the watchers that read it.pub fn set<T: Shared>(s: bikkuri::src::signal::Signal(T), v: T): Unit ! {rt, Div} {  let r := perform access_runtime()  Ref::set(s.cell, v)  queue(r, live_readers(r, s.id))  if Ref::get(r.flushing) { #() } else {    Ref::set(r.flushing, true)    flush(r)    end_flush(r)  }}// Writes only when the value changes, without subscribing the current watcher.pub fn set_eq<T: Shared>(s: bikkuri::src::signal::Signal(T), v: T): Unit ! {rt, Div} where DecEq(T) {  if peek(s) == v { #() } else { set(s, v) }}

// Text that follows the signals `f` reads.pub fn text_dyn<K: Shared, P: Shared>(t: Tree(K, P), f: () -> Text ! {rt, Div}): Node ! {rt, Div, overflow} {  let n := node_of(t)  let v := memo_eq(() => f())  emit(t, CreateText(n, peek(v)))  // The first run only subscribes: the text was created with the value.  let first := Ref::new(true)  watch(() => {    let s := get(v)    if Ref::get(first) { Ref::set(first, false) } else { emit(t, SetText(n, s)) }  })  n}

): Node ! {rt, Div, overflow} {  let g := node_of(t)  emit(t, CreateGroup(g))  let rows := Ref::new(Nil)  // The rows belong to the owner `keyed_each` was made in, not to the watcher, so a change of  // `items` keeps the rows it keeps.  let home := scope(() => #())  watch(() => {    let xs := items()    let old := Ref::get(rows)    var keys: HashMap(u64, u64) := HashMap::new()    keys_of(&mut keys, xs, key)    end_missing(t, old, &keys)    let fresh := reverse_rows(in_owner(home.owner, () => {      var by_key: HashMap(u64, KeyedRow) := HashMap::new()      rows_by_key(&mut by_key, old)      var seen: HashMap(u64, u64) := HashMap::new()      rows_for(&by_key, xs, key, row, t.duplicate_keys, &mut seen, Nil)    }), Nil)    Ref::set(rows, fresh)    match old {      Nil => append_rows(t, g, fresh)      Cons(o, more) => {        let keep := staying(old, fresh)        place_rows(t, g, reverse_indexed(fresh, 0, Nil), &keep, None)      }    }  })  on_cleanup(() => dispose(home.owner))  g

// Whatever the tree holds, `html_safe` accepts what is written.theorem write_safe(t: HTree): html_safe(write(t)) = true {  Eq::congr((s: Scan) => Scan::done(s), write_keeps_text(t))}// The tree as trusted HTML.fn written(t: HTree): TrustedHtml { TrustedHtml::Mk(write(t), write_safe(t)) }

export const setText = (d, n, s) => {  node(d, n).data = s;};

// while another of its resources still loads.fn settle(w: Want, l: Load): Unit ! {rt, Div} {  if Ref::get(w.settled) { #() } else {    Ref::set(w.settled, true)    batch(() => {      set(w.state, l)      match w.boundary {        None => #()        Some(c) => update(c, (n: u64) => handle { n - 1 } with { overflow() => 0 })      }    })  }}pub fn resolve(w: Want, v: Text): Unit ! {rt, Div} { settle(w, Loaded(v)) }pub fn reject(w: Want, why: Text): Unit ! {rt, Div} { settle(w, LoadFailed(why)) }

pub fn page_at<R: Shared>(router: Router(R), target: Text): Option(Page) ! {overflow, Div} {  match route_of(router, target) {    None => None    Some(r) => Some((router.page)(r))  }}

    let request;    try { request = requestOf(key); } catch { return failure('decode'); }    if (request.failed) return request.failed;    let delay = retryDelayMs;    for (let attempt = 0; ; attempt++) {      const { result, retry } = await once(request, signal);      if (request.rpc || !retry || attempt >= retries || signal?.aborted) return result;      await pause(delay, signal);      if (signal?.aborted) return failure('cancelled');      delay *= 2;    }  };