tek/output/src/reduce.rs

use crate::*;

pub struct Reduce<A, B, I, F, G>(pub PhantomData<A>, pub F, pub G) where
    A: Send + Sync, B: Send + Sync,
    I: Iterator<Item = B> + Send + Sync,
    F: Fn() -> I + Send + Sync,
    G: Fn(A, B, usize)->A + Send + Sync;

impl<A, B, I, F, G> Reduce<A, B, I, F, G> where
    A: Send + Sync, B: Send + Sync,
    I: Iterator<Item = B> + Send + Sync,
    F: Fn() -> I + Send + Sync,
    G: Fn(A, B, usize)->A + Send + Sync
{
    pub fn new (f: F, g: G) -> Self { Self(Default::default(), f, g) }
}

impl<E: Output, A, B, I, F, G> Content<E> for Reduce<A, B, I, F, G> where
    A: Send + Sync, B: Send + Sync,
    I: Iterator<Item = B> + Send + Sync,
    F: Fn() -> I + Send + Sync,
    G: Fn(A, B, usize)->A + Send + Sync
{
    fn content (&self) -> impl Render<E> {
    }
}

/*

    //pub fn reduce <E, T, I, R, F>(iterator: I, callback: F) -> Reduce<E, T, I, R, F> where
        //E: Output,
        //I: Iterator<Item = T> + Send + Sync,
        //R: Render<E>,
        //F: Fn(R, T, usize) -> R + Send + Sync
    //{
        //Reduce(Default::default(), iterator, callback)
    //}
pub struct Reduce<E, T, I, R, F>(PhantomData<(E, R)>, I, F) where
    E: Output,
    I: Iterator<Item = T> + Send + Sync,
    R: Render<E>,
    F: Fn(R, T, usize) -> R + Send + Sync;
impl<E, T, I, R, F> Content<E> for Reduce<E, T, I, R, F> where
    E: Output,
    I: Iterator<Item = T> + Send + Sync,
    R: Render<E>,
    F: Fn(R, T, usize) -> R + Send + Sync
{
    fn render (&self, to: &mut E) {
        todo!()
    }
}
*/

//macro_rules! define_ops {
    //($Trait:ident<$E:ident:$Output:path> { $(
        //$(#[$attr:meta $($attr_args:tt)*])*
        //(
            //$fn:ident
            //$(<$($G:ident$(:$Gen:path)?, )+>)?
            //$Op:ident
            //($($arg:ident:$Arg:ty),*)
        //)
    //)* }) => {
        //impl<$E: $Output> $Trait<E> for E {}
        //pub trait $Trait<$E: $Output> {
            //$(
                //$(#[$attr $($attr_args)*])*
                //fn $fn $(<$($G),+>)?
                //($($arg:$Arg),*)-> $Op<$($(, $G)+)?> 
                //$(where $($G: $($Gen + Send + Sync)?),+)?
                //{ $Op($($arg),*) }
            //)*
        //}
    //}
//}

//define_ops! {
    //Layout<E: Output> {
        //(when <A: Render<E>,>
            //When(cond: bool, item: A))
        ///// When `cond` is `true`, render `a`, otherwise render `b`.
        //(either <A: Render<E>, B: Render<E>,>
            //Either(cond: bool, a: A, b: B))
        ///// If `opt` is `Some(T)` renders `cb(t)`, otherwise nothing.
        //(opt <A, F: Fn(A) -> B, B: Render<E>,>
            //Opt(option: Option<A>, cb: F))
        ///// Maps items of iterator through callback.
        //(map <A, B: Render<E>, I: Iterator<Item = A>, F: Fn() -> I, G: Fn(A, usize)->B,>
            //Map(get_iterator: F, callback: G))
    //}
//}