admin/soda
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial

Browse Source
This commit is contained in:
Tyler Clarke
2025-02-12 09:47:32 -05:00
commit d2e6c51073
13 changed files with 1332 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
/target

86
Cargo.lock generated Normal file
View File

@@ -0,0 +1,86 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "borrow-or-share"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3eeab4423108c5d7c744f4d234de88d18d636100093ae04caf4825134b9c3a32"
[[package]]
name = "fluent-uri"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1918b65d96df47d3591bed19c5cca17e3fa5d0707318e4b5ef2eae01764df7e5"
dependencies = [
"borrow-or-share",
"ref-cast",
]
[[package]]
name = "proc-macro2"
version = "1.0.93"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.38"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
dependencies = [
"proc-macro2",
]
[[package]]
name = "ref-cast"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ccf0a6f84d5f1d581da8b41b47ec8600871962f2a528115b542b362d4b744931"
dependencies = [
"ref-cast-impl",
]
[[package]]
name = "ref-cast-impl"
version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bcc303e793d3734489387d205e9b186fac9c6cfacedd98cbb2e8a5943595f3e6"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "soda"
version = "0.1.0"
dependencies = [
"fluent-uri",
"soda_macros",
]
[[package]]
name = "soda_macros"
version = "0.1.0"
[[package]]
name = "syn"
version = "2.0.98"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "unicode-ident"
version = "1.0.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a210d160f08b701c8721ba1c726c11662f877ea6b7094007e1ca9a1041945034"

7
Cargo.toml Normal file
View File

@@ -0,0 +1,7 @@
[package]
name = "soda"
version = "0.1.0"
edition = "2021"
[dependencies]
fluent-uri = "0.3.2"

14
examples/hello.rs Normal file
View File

@@ -0,0 +1,14 @@
// A very, very simple static composer example.
extern crate soda;
use soda::prelude::*;
#[tokio::main]
fn main() {
let app = PageBase("Test Page",
Tag::Heading1("hi!")
);
Server::new((0.0.0.0, 3000)).unwrap().serve(app).await;
}

26
generate-composer-impls.py Normal file
View File

@@ -0,0 +1,26 @@
# generates impls for compose tuples
def tp(n):
return "T" + str(n + 1)
def nprint(s):
print(s, end="")
print("use crate::compose::Compose;")
print("use crate::output::Output;")
for x in range(1, 32):
nprint("impl<State,")
nprint(", ".join([tp(n) + " : Compose<State>" for n in range(0, x)]))
nprint("> Compose<State> for (")
nprint("".join([tp(n) + "," for n in range(0, x)]))
print(") {")
print("\tfn render(&self, output : &mut impl Output, state : &mut State) {")
for n in range(0, x):
nprint("\t\tself.")
nprint(n)
print(".render(output, state);")
print("\t}")
print("}")

41
src/compose.rs Normal file
View File

@@ -0,0 +1,41 @@
// Compose trait.
use crate::output::Output;
use crate::router::{ self, RouteTerminate, Router };
pub trait Compose<State> {
fn render(&self, output : &mut impl Output, state : &mut State);
fn route(self, r : &'static str) -> impl Router<State, Self> where Self : Sized {
router::route(r).then(RouteTerminate::build(self))
}
}
impl<State> Compose<State> for () {
fn render(&self, _output : &mut impl Output, _state : &mut State) {
}
}
impl<State> Compose<State> for &'static str {
fn render(&self, output : &mut impl Output, _state : &mut State) {
output.write(self);
}
}
impl<State> Compose<State> for String {
fn render(&self, output : &mut impl Output, _state : &mut State) {
output.write(self.as_str());
}
}
impl<St, S : Compose<St>, T : Fn(&mut St) -> S> Compose<St> for T {
fn render(&self, output : &mut impl Output, state : &mut St) {
self(state).render(output, state);
}
}

187
src/html.rs Normal file
View File

@@ -0,0 +1,187 @@
use crate::compose::Compose;
use crate::output::Output;
use std::marker::PhantomData;
pub trait HTMLTag<State> : Compose<State> {
fn get_tagname(&self) -> &'static str;
fn does_self_close(&self) -> bool;
fn render_properties(&self, _out : &mut impl Output, _state : &mut State) {}
fn render_content(&self, _out : &mut impl Output, _state : &mut State) {}
fn with_property(self, name : &'static str, value : &'static str) -> WithProperty<State, Self> where Self: Sized {
WithProperty {
name, value, lower_tag : self, _phantom : Default::default()
}
}
fn charset(self, v : &'static str) -> WithProperty<State, Self> where Self: Sized {
self.with_property("charset", v)
}
fn helpful_provided_render_function(&self, out : &mut impl Output, state : &mut State) {
out.write("<");
out.write(self.get_tagname());
self.render_properties(out, state);
if self.does_self_close() {
out.write("/>");
}
else {
out.write(">");
self.render_content(out, state);
out.write("</");
out.write(self.get_tagname());
out.write(">");
}
}
}
pub struct WithProperty<State, T : HTMLTag<State> + Sized> {
name : &'static str,
value : &'static str,
lower_tag : T,
_phantom : PhantomData<State>
}
impl<State, T : HTMLTag<State>> HTMLTag<State> for WithProperty<State, T> {
fn get_tagname(&self) -> &'static str {
self.lower_tag.get_tagname()
}
fn does_self_close(&self) -> bool {
self.lower_tag.does_self_close()
}
fn render_properties(&self, out : &mut impl Output, state : &mut State) {
out.write(" ");
out.write(self.name);
out.write("=\"");
out.write(self.value);
out.write("\"");
self.lower_tag.render_properties(out, state);
}
fn render_content(&self, out : &mut impl Output, state : &mut State) {
self.lower_tag.render_content(out, state);
}
}
impl<T : HTMLTag<State> + Sized, State> Compose<State> for WithProperty<State, T> {
fn render(&self, out : &mut impl Output, state : &mut State) {
self.helpful_provided_render_function(out, state);
}
}
impl<T : Compose<State>, State> Compose<State> for StandardTags<T> {
fn render(&self, out : &mut impl Output, state : &mut State) {
self.helpful_provided_render_function(out, state);
}
}
impl<State> Compose<State> for SelfClosingTags {
fn render(&self, out : &mut impl Output, state : &mut State) {
self.helpful_provided_render_function(out, state);
}
}
pub enum StandardTags<T> {
Html(T),
Head(T),
Body(T),
Title(T),
Paragraph(T),
Div(T),
Heading1(T)
}
pub enum SelfClosingTags {
Meta
}
impl<State> HTMLTag<State> for SelfClosingTags {
fn get_tagname(&self) -> &'static str {
match self {
Self::Meta => "meta"
}
}
fn does_self_close(&self) -> bool {
true
}
}
impl<T> StandardTags<T> {
fn contents<'a>(&'a self) -> &'a T {
match self {
Self::Html(c) => c,
Self::Head(c) => c,
Self::Body(c) => c,
Self::Title(c) => c,
Self::Paragraph(c) => c,
Self::Div(c) => c,
Self::Heading1(c) => c
}
}
}
impl<State, T : Compose<State>> HTMLTag<State> for StandardTags<T> {
fn get_tagname(&self) -> &'static str {
match self {
Self::Html(_) => "html",
Self::Head(_) => "head",
Self::Body(_) => "body",
Self::Title(_) => "title",
Self::Paragraph(_) => "p",
Self::Div(_) => "div",
Self::Heading1(_) => "h1"
}
}
fn does_self_close(&self) -> bool {
false
}
fn render_content(&self, out : &mut impl Output, state : &mut State) {
self.contents().render(out, state);
}
}
#[allow(non_snake_case)]
pub mod Tag {
pub use super::StandardTags::*;
pub use super::SelfClosingTags::*;
}
#[allow(non_snake_case)]
pub fn Doctype() -> &'static str {
"<!DOCTYPE html>"
}
#[allow(non_snake_case)]
pub fn PageBase<State>(title : &'static str, body : impl Compose<State>) -> impl Compose<State> {
(
Doctype(),
Tag::Html((
Tag::Head((
Tag::Meta.charset("utf-8"),
Tag::Title(title)
)),
Tag::Body(body)
))
)
}

97
src/lib.rs Normal file
View File

@@ -0,0 +1,97 @@
/* Soda
by Tyler Clarke
Soda is a convenient frontend framework... written in backend rust.
It allows you to turn a complicated webpage design into a single server-side executable that runs on any Linux system.
A core element of soda's philosophy is the idea of staying fully static: this allows the optimizing compiler to reduce potentially thousands of lines
of frontend code to a few dozen inlined socket writes, which is *enormously* fast.
Soda provides a set of powerful dynamic features atop the static rendering ones as well.
Soda is built atop Hyper, the fastest correct HTTP server implementation in rust.
*/
pub mod compose;
pub mod output;
pub mod html;
pub mod tuples;
pub mod router;
pub mod prelude;
pub mod server;
#[cfg(test)]
mod tests {
use super::prelude::*;
#[test]
fn render_composer() { // simplest example: renders a composer with DummyOutput
let page = PageBase (
"Test Webpage",
Tag::Paragraph("Hello, World!")
);
let mut output = output::DummyOutput::new();
page.render(&mut output, &mut ());
assert_eq!(output.spool(), r#"<!DOCTYPE html><html><head><meta charset="utf-8"/><title>Test Webpage</title></head><body><p>Hello, World!</p></body></html>"#);
}
#[test]
fn routing_test() {
fn template<State>(content : impl Compose<State>) -> impl Compose<State> {
PageBase (
"My Webpage",
Tag::Div((
Tag::Heading1("My Test Website"),
content
))
)
}
let page1 = template("this is the first page");
let page2 = template("this is the second page");
let page3 = template("this is the third page");
let app = page1.route("page1") // route GET /page1
.or(page2.route("page2")) // route GET /page2
.or(router::route("page_num").then(page3.route("3"))); // route GET /page_num/3
let mut output = output::DummyOutput::new();
app.get("https://web.app/page1").unwrap().render(&mut output, &mut ());
assert_eq!(output.spool(), r#"<!DOCTYPE html><html><head><meta charset="utf-8"/><title>My Webpage</title></head><body><div><h1>My Test Website</h1>this is the first page</div></body></html>"#);
output = output::DummyOutput::new();
app.get("https://web.app/page2").unwrap().render(&mut output, &mut ());
assert_eq!(output.spool(), r#"<!DOCTYPE html><html><head><meta charset="utf-8"/><title>My Webpage</title></head><body><div><h1>My Test Website</h1>this is the second page</div></body></html>"#);
output = output::DummyOutput::new();
app.get("https://web.app/page_num/3").unwrap().render(&mut output, &mut ());
assert_eq!(output.spool(), r#"<!DOCTYPE html><html><head><meta charset="utf-8"/><title>My Webpage</title></head><body><div><h1>My Test Website</h1>this is the third page</div></body></html>"#);
}
#[test]
fn closure_test() {
// you can use embedded blocks to procedurally generate outputs
let app = Tag::Div(("Hello, ", {
"World!"
}));
let mut output = output::DummyOutput::new();
app.render(&mut output, &mut ());
assert_eq!(output.spool(), r#"<div>Hello, World!</div>"#);
}
#[test]
fn dynamic_globalstate_test() {
// composers must always be immutable. however, you can produce dynamic mutable behavior with State
// it's literally just a generic of Component
// you can pass pretty much whatever you want in there.
let app_with_state = (
"this page has been visited ",
|state : &mut u32 | {
*state += 1;
state.to_string()
},
" times."
);
let mut state : u32 = 0;
for x in 0..5 {
let mut output = output::DummyOutput::new();
app_with_state.render(&mut output, &mut state);
assert_eq!(output.spool(), format!("this page has been visited {} times.", x + 1));
}
}
}

33
src/output.rs Normal file
View File

@@ -0,0 +1,33 @@
// output trait and some possibilities for outputs
pub trait Output {
fn write(&mut self, data : &str);
}
pub struct DummyOutput {
out : String
}
impl Output for DummyOutput {
fn write(&mut self, data : &str) {
self.out += data;
}
}
impl DummyOutput {
pub fn print(&mut self) {
println!("{}", self.out);
}
pub fn spool(self) -> String {
self.out
}
pub fn new() -> DummyOutput {
DummyOutput {
out : String::new()
}
}
}

8
src/prelude.rs Normal file
View File

@@ -0,0 +1,8 @@
// all the useful re-exports to get an app online without worrying too much about modules
pub use crate::{
html::*,
compose::Compose,
output,
router::{ Router, self },
server::*
};

157
src/router.rs Normal file
View File

@@ -0,0 +1,157 @@
// router definitions
use crate::compose::Compose;
use fluent_uri::{ Uri };
use std::marker::PhantomData;
pub trait Router<State, Out : Compose<State>> { // routers match paths and return a
fn or<T : Router<State, Out>>(self, other : T) -> OrRouter<State, Out, Self, T> where Self : Sized { // route EITHER this router or another router, tries this router first
OrRouter {
one : self,
two : other,
_phantom : Default::default()
}
}
fn then<O : Compose<State>, T : Router<State, O>>(self, other : T) -> ThenRouter<State, O, impl Router<State, ()>, T> where Self : Sized { // route this router, THEN route another router if routing this router succeeded (ignores any output this router produces)
ThenRouter {
one : self.unitize(),
two : other,
_phantom : Default::default()
}
}
fn unitize(self) -> impl Router<State, ()>; // convert this router into a unit router
fn route<'a, T : AsRef<str>>(&'a self, path : &mut (impl Iterator<Item=T> + Clone)) -> Option<&'a Out>; // should return None on route failure
fn get<'a>(&'a self, uri : &str) -> Option<&'a Out> {
let mut path = Uri::parse(uri).unwrap().path().split('/').peekable();
while let Some(p) = path.peek() { // strip off the empty strings at the start of the iterator [why is this a thing?]
if p.len() != 0 {
break;
}
path.next();
}
self.route(&mut path)
}
}
pub struct PathRouter {
path : &'static str
}
impl<State> Router<State, ()> for PathRouter {
fn unitize(self) -> impl Router<State, ()> {
self
}
fn route<'a, T : AsRef<str>>(&'a self, path : &mut (impl Iterator<Item=T> + Clone)) -> Option<&'a ()> {
if let Some(p) = path.next() {
if p.as_ref() == self.path {
return Some(&());
}
}
return None;
}
}
pub struct ThenRouter<State, Out : Compose<State>, FirstRouter : Router<State, ()>, SecondRouter : Router<State, Out>> {
one : FirstRouter,
two : SecondRouter,
_phantom : PhantomData<(Out, State)>
}
impl<State, Out : Compose<State>, FirstRouter : Router<State, ()>, SecondRouter : Router<State, Out>> Router<State, Out> for ThenRouter<State, Out, FirstRouter, SecondRouter> {
fn unitize(self) -> impl Router<State, ()> {
ThenRouter {
one : self.one,
two : self.two.unitize(),
_phantom : Default::default()
}
}
fn route<'a, T : AsRef<str>>(&'a self, path : &mut (impl Iterator<Item = T> + Clone)) -> Option<&'a Out> {
if let Some(()) = self.one.route(path) {
self.two.route(path)
}
else {
None
}
}
}
pub struct OrRouter<State, Out : Compose<State>, FirstRouter : Router<State, Out>, SecondRouter : Router<State, Out>> {
one : FirstRouter,
two : SecondRouter,
_phantom : PhantomData<(State, Out)>
}
impl<State, Out : Compose<State>, FirstRouter : Router<State, Out>, SecondRouter : Router<State, Out>> Router<State, Out> for OrRouter<State, Out, FirstRouter, SecondRouter> {
fn unitize(self) -> impl Router<State, ()> {
OrRouter {
one : self.one.unitize(),
two : self.two.unitize(),
_phantom : Default::default()
}
}
fn route<'a, T : AsRef<str>>(&'a self, path : &mut (impl Iterator<Item = T> + Clone)) -> Option<&'a Out> {
let mut cl = path.clone(); // TODO: debug the performance characteristics of this (in theory it should be nearly costless, but we need to check!)
if let Some(v) = self.one.route(&mut cl) {
Some(v)
}
else {
cl = path.clone();
if let Some(v) = self.two.route(&mut cl) {
Some(v)
}
else {
None
}
}
}
}
pub struct RouteTerminate<State, Out : Compose<State>> { // terminate a route in a composer. cannot fail; this is not a filter.
output : Out,
_phantom : PhantomData<State>
}
impl<State, Out : Compose<State> + Sized> RouteTerminate<State, Out> {
pub fn build(thing : Out) -> RouteTerminate<State, Out> {
RouteTerminate {
output : thing,
_phantom : Default::default()
}
}
}
impl <State, Out : Compose<State> + Sized> Router<State, Out> for RouteTerminate<State, Out> {
fn unitize(self) -> impl Router<State, ()> {
RouteTerminate::<State, ()> {
output : (),
_phantom : Default::default()
}
}
fn route<'a, T : AsRef<str>>(&'a self, _path : &mut (impl Iterator<Item = T> + Clone)) -> Option<&'a Out> {
Some(&self.output)
}
}
pub fn route(path : &'static str) -> PathRouter {
PathRouter {
path
}
}

53
src/server.rs Normal file
View File

@@ -0,0 +1,53 @@
// webserver that forwards requests to Routes
// based on Hyper
use std::convert::Infallible;
use std::net::SocketAddr;
use http_body_util::Full;
use hyper::body::Bytes;
use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::{Request, Response};
use hyper_util::rt::TokioIo;
use tokio::net::TcpListener;
use std::sync::{ Arc, Mutex };
use crate::router::Router;
struct Server {
addr : SocketAddr,
listener : TcpListener
}
impl Server {
pub fn new(addr : ([u8; 4], u16)) -> Result<Server, Box<dyn std::error::Error + Send + Sync>> {
let addr = SocketAddr::from(addr);
Ok(Server {
addr,
listener : TcpListener::bind(addr).await?
})
}
pub async fn serve<T>(&self, rt : impl Router<T>, state : T) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let state = Arc::new(Mutex::new(state));
loop {
let (stream, _) = self.listener.accept().await?;
let io = TokioIo::new(stream);
let state = state.clone();
let service = service_fn(move |req| {
async move {
}
});
tokio::task::spawn(async move {
if let Err(e) = http1::Builder::new().serve_connection(io, service).await {
eprintln!("Error serving connection: {:?}", e);
}
});
}
}
}

622
src/tuples.rs Normal file
View File

@@ -0,0 +1,622 @@
use crate::compose::Compose;
use crate::output::Output;
impl<State,T1 : Compose<State>> Compose<State> for (T1,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>> Compose<State> for (T1,T2,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>> Compose<State> for (T1,T2,T3,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>> Compose<State> for (T1,T2,T3,T4,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>, T22 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
self.21.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>, T22 : Compose<State>, T23 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
self.21.render(output, state);
self.22.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>, T22 : Compose<State>, T23 : Compose<State>, T24 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
self.21.render(output, state);
self.22.render(output, state);
self.23.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>, T22 : Compose<State>, T23 : Compose<State>, T24 : Compose<State>, T25 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
self.21.render(output, state);
self.22.render(output, state);
self.23.render(output, state);
self.24.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>, T22 : Compose<State>, T23 : Compose<State>, T24 : Compose<State>, T25 : Compose<State>, T26 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
self.21.render(output, state);
self.22.render(output, state);
self.23.render(output, state);
self.24.render(output, state);
self.25.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>, T22 : Compose<State>, T23 : Compose<State>, T24 : Compose<State>, T25 : Compose<State>, T26 : Compose<State>, T27 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
self.21.render(output, state);
self.22.render(output, state);
self.23.render(output, state);
self.24.render(output, state);
self.25.render(output, state);
self.26.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>, T22 : Compose<State>, T23 : Compose<State>, T24 : Compose<State>, T25 : Compose<State>, T26 : Compose<State>, T27 : Compose<State>, T28 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
self.21.render(output, state);
self.22.render(output, state);
self.23.render(output, state);
self.24.render(output, state);
self.25.render(output, state);
self.26.render(output, state);
self.27.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>, T22 : Compose<State>, T23 : Compose<State>, T24 : Compose<State>, T25 : Compose<State>, T26 : Compose<State>, T27 : Compose<State>, T28 : Compose<State>, T29 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
self.21.render(output, state);
self.22.render(output, state);
self.23.render(output, state);
self.24.render(output, state);
self.25.render(output, state);
self.26.render(output, state);
self.27.render(output, state);
self.28.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>, T22 : Compose<State>, T23 : Compose<State>, T24 : Compose<State>, T25 : Compose<State>, T26 : Compose<State>, T27 : Compose<State>, T28 : Compose<State>, T29 : Compose<State>, T30 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
self.21.render(output, state);
self.22.render(output, state);
self.23.render(output, state);
self.24.render(output, state);
self.25.render(output, state);
self.26.render(output, state);
self.27.render(output, state);
self.28.render(output, state);
self.29.render(output, state);
}
}
impl<State,T1 : Compose<State>, T2 : Compose<State>, T3 : Compose<State>, T4 : Compose<State>, T5 : Compose<State>, T6 : Compose<State>, T7 : Compose<State>, T8 : Compose<State>, T9 : Compose<State>, T10 : Compose<State>, T11 : Compose<State>, T12 : Compose<State>, T13 : Compose<State>, T14 : Compose<State>, T15 : Compose<State>, T16 : Compose<State>, T17 : Compose<State>, T18 : Compose<State>, T19 : Compose<State>, T20 : Compose<State>, T21 : Compose<State>, T22 : Compose<State>, T23 : Compose<State>, T24 : Compose<State>, T25 : Compose<State>, T26 : Compose<State>, T27 : Compose<State>, T28 : Compose<State>, T29 : Compose<State>, T30 : Compose<State>, T31 : Compose<State>> Compose<State> for (T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,) {
fn render(&self, output : &mut impl Output, state : &mut State) {
self.0.render(output, state);
self.1.render(output, state);
self.2.render(output, state);
self.3.render(output, state);
self.4.render(output, state);
self.5.render(output, state);
self.6.render(output, state);
self.7.render(output, state);
self.8.render(output, state);
self.9.render(output, state);
self.10.render(output, state);
self.11.render(output, state);
self.12.render(output, state);
self.13.render(output, state);
self.14.render(output, state);
self.15.render(output, state);
self.16.render(output, state);
self.17.render(output, state);
self.18.render(output, state);
self.19.render(output, state);
self.20.render(output, state);
self.21.render(output, state);
self.22.render(output, state);
self.23.render(output, state);
self.24.render(output, state);
self.25.render(output, state);
self.26.render(output, state);
self.27.render(output, state);
self.28.render(output, state);
self.29.render(output, state);
self.30.render(output, state);
}
}