组件、并发渲染与流式

pub struct ViewFirst {
    pub content: ViewHandle,
    pub live: bool,
}

pub struct ViewSwap {
    pub region: RegionId,
    pub replacement: ViewHandle,
}

pub trait View: Send {
    fn poll_first(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<ViewFirst>>;

    fn poll_swap(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<Option<ViewSwap>>>;
}

fn poll_first(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<ViewFirst>> {
    let mut this = self.project();
    ready!(this.units.as_mut().poll_contents(cx))?;

    let contents = this.units.as_mut().take_contents();
    let burst = this.burst.take().expect("the burst runs once");
    let content = Builder::block(this.cx, |builder| burst(builder, contents));

    Poll::Ready(Ok(ViewFirst {
        content,
        live: this.units.is_live(),
    }))
}

#[component]
async fn slow(name: &str, ms: u64) -> Result<impl View> {
  println!("[{:>4}ms] {name} start, task {:?}, thread {:?}", t(), tokio::task::try_id(), std::thread::current().id());
  tokio::time::sleep(Duration::from_millis(ms)).await;
  println!("[{:>4}ms] {name} done", t());
  Ok(view! { <li>(name)</li> })
}

// 页面：
Ok(view! {
  <ul>
    slow(name: "a", ms: 300)
    slow(name: "b", ms: 100)
    slow(name: "c", ms: 200)
  </ul>
})

[   0ms] handler, task Some(Id(13))
[   0ms] a start, task Some(Id(13)), thread ThreadId(13)
[   0ms] b start, task Some(Id(13)), thread ThreadId(13)
[   0ms] c start, task Some(Id(13)), thread ThreadId(13)
[ 103ms] b done
[ 204ms] c done
[ 303ms] a done

<ul><li>a</li><li>b</li><li>c</li></ul>
[200 0.309197s]

#[component]
pub async fn suspense(
    cx: &Cx,
    #[into]
    fallback: Child<'_>,
    #[default]
    child: Child<'_>,
    #[into]
    #[default]
    mode: Option<SuspenseMode>,
) -> Result<impl View> {
    const SITE: SiteKey = SiteKey::new(file!(), line!(), column!(), 0);
    let region = RegionId::new(identity(cx), SITE);
    let mode = mode.unwrap_or_else(|| suspense_mode(cx));
    let wait = mode == SuspenseMode::Wait;
    Ok(SuspenseView::new(region, fallback, child, wait))
}

[ 204ms] HTTP/1.1 200 OK
content-type: text/html; charset=utf-8
vary: Accept
connection: close
content-length: 23

<h1>Wait</h1><li>a</li>

// /boundary
error_boundary(
  fallback: |error| Ok(view! { <p>"unavailable: " (error.to_string())</p> }),
  failing()
)
// /unbounded
<h1>"Stats"</h1> failing()
// /late
error_boundary(
  fallback: |error| Ok(view! { <p>"unavailable: " (error.to_string())</p> }),
  suspense(fallback: view! { <p>"loading"</p> }, failing())
)

== /boundary
<h1>Stats</h1><p>unavailable: database is down</p>
[200 0.053927s]
== /unbounded
internal server error
[500 0.053159s]

[   6ms] ...
<h1>Stats</h1><!--::topcoat::region::start(5849b1d6...)--><!--::topcoat::region::start(5c904853...)--><p>loading</p><!--::topcoat::region::end(5c904853...)--><!--::topcoat::region::end(5849b1d6...)-->

[  57ms] ...
<script>…swap 脚本…</script><template data-topcoat-swap="5849b1d6..."><p>unavailable: database is down</p></template><script>topcoat.swap("5849b1d6...")</script>

(live! {
  for percent in [0, 50] {
    emit! { <p>"Working " (percent) "%"</p> }?;
    tokio::time::sleep(Duration::from_millis(150)).await;
  }
  emit! { <p>"Done"</p> }?;
  Ok::<_, topcoat::Error>(EmitToken)
})

[   1ms] HTTP/1.1 200 OK
...
transfer-encoding: chunked

A2
<h1>Progress</h1><!--::topcoat::region::start(9f5c2b90...)--><p>Working 0%</p><!--::topcoat::region::end(9f5c2b90...)-->

[ 153ms] 404
<script>…swap 脚本…</script><template data-topcoat-swap="9f5c2b90..."><p>Working 50%</p></template><script>topcoat.swap("9f5c2b90...")</script>

[ 306ms] 96
<template data-topcoat-swap="9f5c2b90..."><p>Done</p></template><script>topcoat.swap("9f5c2b90...")</script>
0

error[E0733]: recursion in an async block requires boxing
  --> src/bin/recur.rs:5:6
   |
 5 |     Ok(view! {
   |  ______^
 6 | |     <li>(n)</li>
 7 | |     if n > 0 {
 8 | |       countdown(n: n - 1)
 9 | |     }
10 | |   })
   | |   ^ recursive call here