///|
#valtype
struct Html {
  f : async (async (String) -> Unit) -> Unit
}

///|
pub trait WriteToHtmlBuilder {
  async fn write_to(Self, HtmlBuilder) -> Unit
}

///|
#valtype
struct HtmlBuilder {
  k : async (String) -> Unit
}

///|
pub fn Html::Html(raw~ : String) -> Html {
  { f: k => k(raw) }
}

///|
pub fn Html::escape(str : String) -> Html {
  Html(raw=html_escape(str))
}

///|
pub fn Html::thunk(f : async (HtmlBuilder) -> Unit) -> Html {
  Html::{ f: k => f({ k, }) }
}

///|
pub async fn HtmlBuilder::write_string(
  self : HtmlBuilder,
  str : String,
) -> Unit {
  (self.k)(str)
}

///|
pub async fn[T : WriteToHtmlBuilder] HtmlBuilder::write(
  self : HtmlBuilder,
  value : T,
) -> Unit {
  value.write_to(self)
}

///|
pub impl WriteToHtmlBuilder for String with fn write_to(
  self : String,
  builder : HtmlBuilder,
) {
  builder.write_string(html_escape(self))
}

///|
pub impl WriteToHtmlBuilder for Html with fn write_to(
  self : Html,
  builder : HtmlBuilder,
) {
  (self.f)(raw => builder.write_string(raw))
}

///|
fn html_escape(s : String) -> String {
  // TODO: Use lexmatch
  let b = StringBuilder()
  for ch in s {
    match ch {
      '&' => b.write_string("&")
      '<' => b.write_string("<")
      '>' => b.write_string(">")
      '"' => b.write_string(""")
      '\'' => b.write_string("'")
      _ => b.write_char(ch)
    }
  }
  b.to_string()
}