use typle::typle;
trait Process {
type State;
type Output;
fn process(state: Self::State) -> Result<Self::Output, Error>;
}
pub enum ProcessState<T0, T1>
where
T0: Process<Output = u64>,
T1: Process<Output = u64>,
{
S0(Option<T0::State>, [u64; 0]),
S1(Option<T1::State>, [u64; 1]),
U0 { u: [u32; 0] },
U1 { u: [u32; 1] },
V0,
V1,
Done([u64; 2]),
}
impl Default for ProcessState<!, !, !> {
fn default() -> Self {
{ Self::Done([0; 3]) }
}
}
impl<T0> Default for ProcessState<T0, !, !>
where
T0: Process<Output = u64>,
{
fn default() -> Self {
{ Self::S0(None, []) }
}
}
impl<T0, T1> Default for ProcessState<T0, T1, !>
where
T0: Process<Output = u64>,
T1: Process<Output = u64>,
{
fn default() -> Self {
{ Self::S0(None, []) }
}
}
impl<T0, T1, T2> Default for ProcessState<T0, T1, T2>
where
T0: Process<Output = u64>,
T1: Process<Output = u64>,
T2: Process<Output = u64>,
{
fn default() -> Self {
{ Self::S0(None, []) }
}
}
impl Process for () {
type State = ProcessState<!, !, !>;
type Output = [u64; 0];
fn process(state: Self::State) -> Result<Self::Output, Error> {
if let Self::State::Done(output) = state {
return output;
}
::core::panicking::panic("internal error: entered unreachable code");
}
}
impl Process for (T0,)
where
T0: Process<Output = u64>,
{
type State = ProcessState<T0, !, !>;
type Output = [u64; 1];
fn process(state: Self::State) -> Result<Self::Output, Error> {
loop {
{
if let Self::State::S0(inner_state, output) = state {
match self.tuple.0.process(inner_state) {
Err(e) => {
return Err(e);
}
Ok(value) => {
let mut new_output = <[u64; 0 + 1]>::default();
output
.into_iter()
.chain(std::iter::once(value))
.enumerate()
.for_each(|(j, bs)| new_output[j] = bs);
{
state = Self::State::Done(new_output);
}
}
}
}
}
break;
}
if let Self::State::Done(output) = state {
return output;
}
::core::panicking::panic("internal error: entered unreachable code");
}
}
impl Process for (T0, T1)
where
T0: Process<Output = u64>,
T1: Process<Output = u64>,
{
type State = ProcessState<T0, T1, !>;
type Output = [u64; 2];
fn process(state: Self::State) -> Result<Self::Output, Error> {
loop {
{
if let Self::State::S0(inner_state, output) = state {
match self.tuple.0.process(inner_state) {
Err(e) => {
return Err(e);
}
Ok(value) => {
let mut new_output = <[u64; 0 + 1]>::default();
output
.into_iter()
.chain(std::iter::once(value))
.enumerate()
.for_each(|(j, bs)| new_output[j] = bs);
{
state = Self::State::S1(None, new_output);
}
}
}
}
}
{
if let Self::State::S1(inner_state, output) = state {
match self.tuple.1.process(inner_state) {
Err(e) => {
return Err(e);
}
Ok(value) => {
let mut new_output = <[u64; 1 + 1]>::default();
output
.into_iter()
.chain(std::iter::once(value))
.enumerate()
.for_each(|(j, bs)| new_output[j] = bs);
{
state = Self::State::Done(new_output);
}
}
}
}
}
break;
}
if let Self::State::Done(output) = state {
return output;
}
::core::panicking::panic("internal error: entered unreachable code");
}
}
impl Process for (T0, T1, T2)
where
T0: Process<Output = u64>,
T1: Process<Output = u64>,
T2: Process<Output = u64>,
{
type State = ProcessState<T0, T1, T2>;
type Output = [u64; 3];
fn process(state: Self::State) -> Result<Self::Output, Error> {
loop {
{
if let Self::State::S0(inner_state, output) = state {
match self.tuple.0.process(inner_state) {
Err(e) => {
return Err(e);
}
Ok(value) => {
let mut new_output = <[u64; 0 + 1]>::default();
output
.into_iter()
.chain(std::iter::once(value))
.enumerate()
.for_each(|(j, bs)| new_output[j] = bs);
{
state = Self::State::S1(None, new_output);
}
}
}
}
}
{
if let Self::State::S1(inner_state, output) = state {
match self.tuple.1.process(inner_state) {
Err(e) => {
return Err(e);
}
Ok(value) => {
let mut new_output = <[u64; 1 + 1]>::default();
output
.into_iter()
.chain(std::iter::once(value))
.enumerate()
.for_each(|(j, bs)| new_output[j] = bs);
{
state = Self::State::S2(None, new_output);
}
}
}
}
}
{
if let Self::State::S2(inner_state, output) = state {
match self.tuple.2.process(inner_state) {
Err(e) => {
return Err(e);
}
Ok(value) => {
let mut new_output = <[u64; 2 + 1]>::default();
output
.into_iter()
.chain(std::iter::once(value))
.enumerate()
.for_each(|(j, bs)| new_output[j] = bs);
{
state = Self::State::Done(new_output);
}
}
}
}
}
break;
}
if let Self::State::Done(output) = state {
return output;
}
::core::panicking::panic("internal error: entered unreachable code");
}
}
impl Process for (T0, T1, T2)
where
T0: Process<Output = u64>,
T1: Process<Output = u64>,
T2: Process<Output = u64>,
{
type State = ProcessState;
type Output = ProcessState<T1, T2>;
fn process(state: Self::State) -> Result<Self::Output, Error> {
let x = Self::State::S0((), None);
::core::panicking::panic("internal error: entered unreachable code");
}
}