Struct tylisp::HCons

pub struct HCons<H, T> {
    pub head: H,
    pub tail: T,
}

Fields

head: H

tail: T

Trait Implementations

impl<H: Calc<QH>, T, QH, QT> Calc<HCons<QH, QT>> for HCons<H, T> where
    H::Result: Call,
    <H::Result as Call>::Conv: CalcImpl<H::Result, T, QT>, 

type Result = <<H::Result as Call>::Conv as CalcImpl<H::Result, T, QT>>::Result

fn calc(q: HCons<QH, QT>) -> Self::Result

impl<QH, QT, H, T> CalcList<HCons<QH, QT>> for HCons<H, T> where
    H: Calc<QH>,
    T: CalcList<QT>, 

type Result = HCons<H::Result, T::Result>

fn calc_list(q: HCons<QH, QT>) -> HCons<H::Result, T::Result>

impl<H: Clone, T: Clone> Clone for HCons<H, T>

fn clone(&self) -> HCons<H, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<H, T, Test, Step> CollatedBy<Test> for HCons<H, T> where
    HCons<Test, HCons<Quote<H>, HNil>>: Eval<Result = Step>,
    Step: CollateStep<Test, H, T>, 

type Passed = Step::Passed

type Failed = Step::Failed

fn collate(self) -> (Self::Passed, Self::Failed)

impl<H: Debug, T: Debug> Debug for HCons<H, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<H: Default, T: Default> Default for HCons<H, T>

fn default() -> HCons<H, T>

Returns the “default value” for a type.

impl<H: Eval, T> Eval for HCons<H, T> where
    H::Result: Call,
    <H::Result as Call>::Conv: CallImpl<H::Result, T>, 

type Result = <<H::Result as Call>::Conv as CallImpl<H::Result, T>>::Result

impl<H: Eval, T: EvalList> EvalList for HCons<H, T>

type Result = HCons<H::Result, <T as EvalList>::Result>

impl<A: List, B: List> FunCalc<HCons<A, HCons<B, HNil>>> for Concat where
    HCons<HCons<If, HCons<HCons<EmptyP, HCons<Quote<A>, HNil>>, HCons<Ret, HCons<Quote<ConcatCont<A>>, HNil>>>>, HCons<Quote<B>, HNil>>: Calc<HCons<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<ConcatCont<A>, HNil>>>>, HCons<B, HNil>>>, 

type Result = <HCons<HCons<If, HCons<HCons<EmptyP, HCons<Quote<A>, HNil>>, HCons<Ret, HCons<Quote<ConcatCont<A>>, HNil>>>>, HCons<Quote<B>, HNil>> as Calc<HCons<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<ConcatCont<A>, HNil>>>>, HCons<B, HNil>>>>::Result

fn calc(self, args: HCons<A, HCons<B, HNil>>) -> Self::Result

impl<A: List, B: List> FunCalc<HCons<A, HCons<B, HNil>>> for Union where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<A>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HCons<HCons<Union, HCons<Quote<A::Tail>, HCons<HCons<If, HCons<HCons<Is, HCons<Missing, HCons<HCons<Find, HCons<Quote<A::Head>, HCons<Quote<B>, HNil>>>, HNil>>>, HCons<HCons<Cons, HCons<Quote<A::Head>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HNil>>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HNil>>>>, HNil>>>, HNil>>>>: Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<HCons<(), HCons<Rc<B>, HNil>>, HCons<HCons<(), HCons<A::Tail, HCons<HCons<(), HCons<HCons<(), HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HNil>>>, HCons<HCons<(), HCons<A::Head, HCons<HCons<(), HCons<Rc<B>, HNil>>, HNil>>>, HCons<HCons<(), HCons<Rc<B>, HNil>>, HNil>>>>, HNil>>>, HNil>>>>>, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<A>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HCons<HCons<Union, HCons<Quote<A::Tail>, HCons<HCons<If, HCons<HCons<Is, HCons<Missing, HCons<HCons<Find, HCons<Quote<A::Head>, HCons<Quote<B>, HNil>>>, HNil>>>, HCons<HCons<Cons, HCons<Quote<A::Head>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HNil>>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HNil>>>>, HNil>>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<HCons<(), HCons<Rc<B>, HNil>>, HCons<HCons<(), HCons<A::Tail, HCons<HCons<(), HCons<HCons<(), HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HNil>>>, HCons<HCons<(), HCons<A::Head, HCons<HCons<(), HCons<Rc<B>, HNil>>, HNil>>>, HCons<HCons<(), HCons<Rc<B>, HNil>>, HNil>>>>, HNil>>>, HNil>>>>>>::Result

fn calc(self, args: HCons<A, HCons<B, HNil>>) -> Self::Result

impl<H, T, Accum> FunCalc<HCons<Accum, HNil>> for ConcatCont<HCons<H, T>> where
    HCons<Cons, HCons<Quote<H>, HCons<HCons<Concat, HCons<Quote<T>, HCons<Quote<Accum>, HNil>>>, HNil>>>: Calc<HCons<(), HCons<H, HCons<HCons<(), HCons<T, HCons<Accum, HNil>>>, HNil>>>>, 

type Result = <HCons<Cons, HCons<Quote<H>, HCons<HCons<Concat, HCons<Quote<T>, HCons<Quote<Accum>, HNil>>>, HNil>>> as Calc<HCons<(), HCons<H, HCons<HCons<(), HCons<T, HCons<Accum, HNil>>>, HNil>>>>>::Result

fn calc(self, args: HCons<Accum, HNil>) -> Self::Result

impl FunCalc<HCons<B0, HNil>> for Not where
    HCons<Ret, HCons<Quote<True>, HNil>>: Calc<HCons<(), HCons<True, HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<True>, HNil>> as Calc<HCons<(), HCons<True, HNil>>>>::Result

fn calc(self, args: HCons<False, HNil>) -> Self::Result

impl FunCalc<HCons<B1, HNil>> for Not where
    HCons<Ret, HCons<Quote<False>, HNil>>: Calc<HCons<(), HCons<False, HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<False>, HNil>> as Calc<HCons<(), HCons<False, HNil>>>>::Result

fn calc(self, args: HCons<True, HNil>) -> Self::Result

impl<'a, Func, L: List> FunCalc<HCons<Func, HCons<&'a L, HNil>>> for MapRef where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<Cons, HCons<HCons<Func, HCons<Quote<&'a L::Head>, HNil>>, HCons<HCons<MapRef, HCons<Func, HCons<Quote<&'a L::Tail>, HNil>>>, HNil>>>, HNil>>>>: Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<&'a L::Head, HNil>>, HCons<HCons<(), HCons<(), HCons<&'a L::Tail, HNil>>>, HNil>>>, HNil>>>>>, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<Cons, HCons<HCons<Func, HCons<Quote<&'a L::Head>, HNil>>, HCons<HCons<MapRef, HCons<Func, HCons<Quote<&'a L::Tail>, HNil>>>, HNil>>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<&'a L::Head, HNil>>, HCons<HCons<(), HCons<(), HCons<&'a L::Tail, HNil>>>, HNil>>>, HNil>>>>>>::Result

fn calc(self, args: HCons<Func, HCons<&'a L, HNil>>) -> Self::Result

impl<Func, Acc, L: List> FunCalc<HCons<Func, HCons<Acc, HCons<L, HNil>>>> for FoldL where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Acc>>, HNil>>, HCons<HCons<FoldL, HCons<Func, HCons<HCons<Func, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Acc>>, HNil>>, HCons<Quote<L::Head>, HNil>>>, HCons<Quote<L::Tail>, HNil>>>>, HNil>>>>: Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<HCons<(), HCons<Rc<Acc>, HNil>>, HCons<HCons<(), HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<Rc<Acc>, HNil>>, HCons<L::Head, HNil>>>, HCons<L::Tail, HNil>>>>, HNil>>>>>, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Acc>>, HNil>>, HCons<HCons<FoldL, HCons<Func, HCons<HCons<Func, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Acc>>, HNil>>, HCons<Quote<L::Head>, HNil>>>, HCons<Quote<L::Tail>, HNil>>>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<HCons<(), HCons<Rc<Acc>, HNil>>, HCons<HCons<(), HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<Rc<Acc>, HNil>>, HCons<L::Head, HNil>>>, HCons<L::Tail, HNil>>>>, HNil>>>>>>::Result

fn calc(self, args: HCons<Func, HCons<Acc, HCons<L, HNil>>>) -> Self::Result

impl<Func, L: List, Init> FunCalc<HCons<Func, HCons<L, HCons<Init, HNil>>>> for FoldR where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Init>>, HNil>>, HCons<HCons<Func, HCons<Quote<L::Head>, HCons<HCons<FoldR, HCons<Func, HCons<Quote<L::Tail>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Init>>, HNil>>, HNil>>>>, HNil>>>, HNil>>>>: Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<HCons<(), HCons<Rc<Init>, HNil>>, HCons<HCons<(), HCons<L::Head, HCons<HCons<(), HCons<(), HCons<L::Tail, HCons<HCons<(), HCons<Rc<Init>, HNil>>, HNil>>>>, HNil>>>, HNil>>>>>, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Init>>, HNil>>, HCons<HCons<Func, HCons<Quote<L::Head>, HCons<HCons<FoldR, HCons<Func, HCons<Quote<L::Tail>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Init>>, HNil>>, HNil>>>>, HNil>>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<HCons<(), HCons<Rc<Init>, HNil>>, HCons<HCons<(), HCons<L::Head, HCons<HCons<(), HCons<(), HCons<L::Tail, HCons<HCons<(), HCons<Rc<Init>, HNil>>, HNil>>>>, HNil>>>, HNil>>>>>>::Result

fn calc(self, args: HCons<Func, HCons<L, HCons<Init, HNil>>>) -> Self::Result

impl<Func, L: List> FunCalc<HCons<Func, HCons<L, HNil>>> for Map where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<Cons, HCons<HCons<Func, HCons<Quote<L::Head>, HNil>>, HCons<HCons<Map, HCons<Func, HCons<Quote<L::Tail>, HNil>>>, HNil>>>, HNil>>>>: Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<L::Head, HNil>>, HCons<HCons<(), HCons<(), HCons<L::Tail, HNil>>>, HNil>>>, HNil>>>>>, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<Cons, HCons<HCons<Func, HCons<Quote<L::Head>, HNil>>, HCons<HCons<Map, HCons<Func, HCons<Quote<L::Tail>, HNil>>>, HNil>>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<L::Head, HNil>>, HCons<HCons<(), HCons<(), HCons<L::Tail, HNil>>>, HNil>>>, HNil>>>>>>::Result

fn calc(self, args: HCons<Func, HCons<L, HNil>>) -> Self::Result

impl<Func, L: List> FunCalc<HCons<Func, HCons<L, HNil>>> for Filter where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<HCons<If, HCons<HCons<Func, HCons<Quote<L::Head>, HNil>>, HCons<Quote<Prepend<L::Head>>, HCons<Ret, HNil>>>>, HCons<HCons<Filter, HCons<Func, HCons<Quote<L::Tail>, HNil>>>, HNil>>, HNil>>>>: Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<HCons<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<Prepend<L::Head>, HCons<(), HNil>>>>, HCons<HCons<(), HCons<(), HCons<L::Tail, HNil>>>, HNil>>, HNil>>>>>, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<HCons<If, HCons<HCons<Func, HCons<Quote<L::Head>, HNil>>, HCons<Quote<Prepend<L::Head>>, HCons<Ret, HNil>>>>, HCons<HCons<Filter, HCons<Func, HCons<Quote<L::Tail>, HNil>>>, HNil>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<HCons<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<Prepend<L::Head>, HCons<(), HNil>>>>, HCons<HCons<(), HCons<(), HCons<L::Tail, HNil>>>, HNil>>, HNil>>>>>>::Result

fn calc(self, args: HCons<Func, HCons<L, HNil>>) -> Self::Result

impl<H, T> FunCalc<HCons<H, HCons<T, HNil>>> for Cons where
    HCons<Ret, HCons<Quote<HCons<H, T>>, HNil>>: Calc<HCons<(), HCons<HCons<H, T>, HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<HCons<H, T>>, HNil>> as Calc<HCons<(), HCons<HCons<H, T>, HNil>>>>::Result

fn calc(self, args: HCons<H, HCons<T, HNil>>) -> Self::Result

impl<L: Add<R>, R> FunCalc<HCons<L, HCons<R, HNil>>> for Add where
    HCons<Ret, HCons<Quote<L::Output>, HNil>>: Calc<HCons<(), HCons<L::Output, HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<L::Output>, HNil>> as Calc<HCons<(), HCons<L::Output, HNil>>>>::Result

fn calc(self, args: HCons<L, HCons<R, HNil>>) -> Self::Result

impl<L: Sub<R>, R> FunCalc<HCons<L, HCons<R, HNil>>> for Sub where
    HCons<Ret, HCons<Quote<L::Output>, HNil>>: Calc<HCons<(), HCons<L::Output, HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<L::Output>, HNil>> as Calc<HCons<(), HCons<L::Output, HNil>>>>::Result

fn calc(self, args: HCons<L, HCons<R, HNil>>) -> Self::Result

impl<L: List> FunCalc<HCons<L, HNil>> for EmptyP where
    HCons<Ret, HCons<Quote<L::IsEOL>, HNil>>: Calc<HCons<(), HCons<(), HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<L::IsEOL>, HNil>> as Calc<HCons<(), HCons<(), HNil>>>>::Result

fn calc(self, args: HCons<L, HNil>) -> Self::Result

impl<L: List> FunCalc<HCons<L, HNil>> for Tail where
    HCons<Ret, HCons<Quote<L::Tail>, HNil>>: Calc<HCons<(), HCons<L::Tail, HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<L::Tail>, HNil>> as Calc<HCons<(), HCons<L::Tail, HNil>>>>::Result

fn calc(self, args: HCons<L, HNil>) -> Self::Result

impl<L: List> FunCalc<HCons<L, HNil>> for Head where
    HCons<Ret, HCons<Quote<L::Head>, HNil>>: Calc<HCons<(), HCons<L::Head, HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<L::Head>, HNil>> as Calc<HCons<(), HCons<L::Head, HNil>>>>::Result

fn calc(self, args: HCons<L, HNil>) -> Self::Result

impl<L: List> FunCalc<HCons<L, HNil>> for Rev4 where
    HCons<Rev4, HCons<Quote<L>, HCons<HNil, HNil>>>: Calc<HCons<(), HCons<L, HCons<HNil, HNil>>>>, 

type Result = <HCons<Rev4, HCons<Quote<L>, HCons<HNil, HNil>>> as Calc<HCons<(), HCons<L, HCons<HNil, HNil>>>>>::Result

fn calc(self, args: HCons<L, HNil>) -> Self::Result

impl<L: List> FunCalc<HCons<L, HNil>> for Rev5 where
    HCons<Rev5, HCons<Quote<L>, HCons<HNil, HNil>>>: Calc<HCons<(), HCons<L, HCons<HNil, HNil>>>>, 

type Result = <HCons<Rev5, HCons<Quote<L>, HCons<HNil, HNil>>> as Calc<HCons<(), HCons<L, HCons<HNil, HNil>>>>>::Result

fn calc(self, args: HCons<L, HNil>) -> Self::Result

impl<Needle, H, T> FunCalc<HCons<Needle, HCons<HCons<H, T>, HNil>>> for Find where
    HCons<If, HCons<HCons<Is, HCons<Needle, HCons<Quote<H>, HNil>>>, HCons<Here, HCons<HCons<WrapMissing, HCons<HCons<Find, HCons<Needle, HCons<Quote<T>, HNil>>>, HNil>>, HNil>>>>: Calc<HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HNil>>, HNil>>>>>, 

type Result = <HCons<If, HCons<HCons<Is, HCons<Needle, HCons<Quote<H>, HNil>>>, HCons<Here, HCons<HCons<WrapMissing, HCons<HCons<Find, HCons<Needle, HCons<Quote<T>, HNil>>>, HNil>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HNil>>, HNil>>>>>>::Result

fn calc(self, args: HCons<Needle, HCons<HCons<H, T>, HNil>>) -> Self::Result

impl<Needle> FunCalc<HCons<Needle, HCons<HNil, HNil>>> for Find where
    HCons<Ret, HCons<Missing, HNil>>: Calc<HCons<(), HCons<(), HNil>>>, 

type Result = <HCons<Ret, HCons<Missing, HNil>> as Calc<HCons<(), HCons<(), HNil>>>>::Result

fn calc(self, args: HCons<Needle, HCons<HNil, HNil>>) -> Self::Result

impl<L: List, Needle: LispId> FunCalc<HCons<Needle, HCons<L, HNil>>> for Without where
    HCons<Filter, HCons<HCons<Partial, HCons<IsNot, HCons<Quote<Needle>, HNil>>>, HCons<Quote<L>, HNil>>>: Calc<HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HCons<L, HNil>>>>, 

type Result = <HCons<Filter, HCons<HCons<Partial, HCons<IsNot, HCons<Quote<Needle>, HNil>>>, HCons<Quote<L>, HNil>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HCons<L, HNil>>>>>::Result

fn calc(self, args: HCons<Needle, HCons<L, HNil>>) -> Self::Result

impl<Old: List, New: List> FunCalc<HCons<Old, HCons<New, HNil>>> for Rev4 where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<Old>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<New>>, HNil>>, HCons<HCons<Rev4, HCons<Quote<Old::Tail>, HCons<HCons<Cons, HCons<Quote<Old::Head>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<New>>, HNil>>, HNil>>>, HNil>>>, HNil>>>>: Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<HCons<(), HCons<Rc<New>, HNil>>, HCons<HCons<(), HCons<Old::Tail, HCons<HCons<(), HCons<Old::Head, HCons<HCons<(), HCons<Rc<New>, HNil>>, HNil>>>, HNil>>>, HNil>>>>>, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<Old>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<New>>, HNil>>, HCons<HCons<Rev4, HCons<Quote<Old::Tail>, HCons<HCons<Cons, HCons<Quote<Old::Head>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<New>>, HNil>>, HNil>>>, HNil>>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<HCons<(), HCons<Rc<New>, HNil>>, HCons<HCons<(), HCons<Old::Tail, HCons<HCons<(), HCons<Old::Head, HCons<HCons<(), HCons<Rc<New>, HNil>>, HNil>>>, HNil>>>, HNil>>>>>>::Result

fn calc(self, args: HCons<Old, HCons<New, HNil>>) -> Self::Result

impl<Old: List, New: List> FunCalc<HCons<Old, HCons<New, HNil>>> for Rev5 where
    HCons<HCons<If, HCons<HCons<EmptyP, HCons<Quote<Old>, HNil>>, HCons<Ret, HCons<Quote<RevCont<Old>>, HNil>>>>, HCons<Quote<New>, HNil>>: Calc<HCons<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<RevCont<Old>, HNil>>>>, HCons<New, HNil>>>, 

type Result = <HCons<HCons<If, HCons<HCons<EmptyP, HCons<Quote<Old>, HNil>>, HCons<Ret, HCons<Quote<RevCont<Old>>, HNil>>>>, HCons<Quote<New>, HNil>> as Calc<HCons<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<RevCont<Old>, HNil>>>>, HCons<New, HNil>>>>::Result

fn calc(self, args: HCons<Old, HCons<New, HNil>>) -> Self::Result

impl<T> FunCalc<HCons<Option<T>, HNil>> for Unwrap where
    HCons<Ret, HCons<Quote<T>, HNil>>: Calc<HCons<(), HCons<T, HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<T>, HNil>> as Calc<HCons<(), HCons<T, HNil>>>>::Result

fn calc(self, args: HCons<Option<T>, HNil>) -> Self::Result

impl<In: List, Out> FunCalc<HCons<Out, HNil>> for RevCont<In> where
    HCons<Rev5, HCons<Quote<In::Tail>, HCons<HCons<Cons, HCons<Quote<In::Head>, HCons<Quote<Out>, HNil>>>, HNil>>>: Calc<HCons<(), HCons<In::Tail, HCons<HCons<(), HCons<In::Head, HCons<Out, HNil>>>, HNil>>>>, 

type Result = <HCons<Rev5, HCons<Quote<In::Tail>, HCons<HCons<Cons, HCons<Quote<In::Head>, HCons<Quote<Out>, HNil>>>, HNil>>> as Calc<HCons<(), HCons<In::Tail, HCons<HCons<(), HCons<In::Head, HCons<Out, HNil>>>, HNil>>>>>::Result

fn calc(self, args: HCons<Out, HNil>) -> Self::Result

impl<A, B> FunCalc<HCons<PhantomData<A>, HCons<B, HNil>>> for Intersect where
    HCons<Filter, HCons<HCons<Partial, HCons<Contains, HCons<Quote<A>, HNil>>>, HCons<Quote<B>, HNil>>>: Calc<HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HCons<B, HNil>>>>, 

type Result = <HCons<Filter, HCons<HCons<Partial, HCons<Contains, HCons<Quote<A>, HNil>>>, HCons<Quote<B>, HNil>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HCons<B, HNil>>>>>::Result

fn calc(self, args: HCons<PhantomData<A>, HCons<B, HNil>>) -> Self::Result

impl<A, B> FunCalc<HCons<PhantomData<A>, HCons<B, HNil>>> for Remove where
    HCons<Head, HCons<HCons<Tail, HCons<HCons<Collate, HCons<HCons<Partial, HCons<Contains, HCons<Quote<A>, HNil>>>, HCons<Quote<B>, HNil>>>, HNil>>, HNil>>: Calc<HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HCons<B, HNil>>>, HNil>>, HNil>>>, 

type Result = <HCons<Head, HCons<HCons<Tail, HCons<HCons<Collate, HCons<HCons<Partial, HCons<Contains, HCons<Quote<A>, HNil>>>, HCons<Quote<B>, HNil>>>, HNil>>, HNil>> as Calc<HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HCons<B, HNil>>>, HNil>>, HNil>>>>::Result

fn calc(self, args: HCons<PhantomData<A>, HCons<B, HNil>>) -> Self::Result

impl<T> FunCalc<HCons<Rc<T>, HNil>> for UnwrapRc where
    HCons<Ret, HCons<Quote<T>, HNil>>: Calc<HCons<(), HCons<T, HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<T>, HNil>> as Calc<HCons<(), HCons<T, HNil>>>>::Result

fn calc(self, args: HCons<Rc<T>, HNil>) -> Self::Result

impl<T> FunCalc<HCons<T, HNil>> for WrapRc where
    HCons<Ret, HCons<Quote<Rc<T>>, HNil>>: Calc<HCons<(), HCons<Rc<T>, HNil>>>, 

type Result = <HCons<Ret, HCons<Quote<Rc<T>>, HNil>> as Calc<HCons<(), HCons<Rc<T>, HNil>>>>::Result

fn calc(self, args: HCons<T, HNil>) -> Self::Result

impl<T, U> FunCalc<HCons<T, U>> for Ret

type Result = T

fn calc(self, _: HCons<T, U>) -> T

impl<X, Tail> FunCalc<HCons<Tail, HNil>> for Prepend<X> where
    HCons<Cons, HCons<Quote<X>, HCons<Quote<Tail>, HNil>>>: Calc<HCons<(), HCons<X, HCons<Tail, HNil>>>>, 

type Result = <HCons<Cons, HCons<Quote<X>, HCons<Quote<Tail>, HNil>>> as Calc<HCons<(), HCons<X, HCons<Tail, HNil>>>>>::Result

fn calc(self, args: HCons<Tail, HNil>) -> Self::Result

impl<Test, L: CollatedBy<Test>> FunCalc<HCons<Test, HCons<L, HNil>>> for Collate where
    HCons<BuildList, HCons<Quote<L::Passed>, HCons<Quote<L::Failed>, HNil>>>: Calc<HCons<(), HCons<L::Passed, HCons<L::Failed, HNil>>>>, 

type Result = <HCons<BuildList, HCons<Quote<L::Passed>, HCons<Quote<L::Failed>, HNil>>> as Calc<HCons<(), HCons<L::Passed, HCons<L::Failed, HNil>>>>>::Result

fn calc(self, args: HCons<Test, HCons<L, HNil>>) -> Self::Result

impl<X: LispId, L: List> FunCalc<HCons<X, HCons<L, HNil>>> for SetInsert where
    HCons<HCons<If, HCons<HCons<Is, HCons<Missing, HCons<HCons<Find, HCons<Quote<X>, HCons<Quote<L>, HNil>>>, HNil>>>, HCons<Quote<Prepend<X>>, HCons<Ret, HNil>>>>, HCons<Quote<L>, HNil>>: Calc<HCons<HCons<(), HCons<HCons<(), HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HNil>>>, HCons<Prepend<X>, HCons<(), HNil>>>>, HCons<L, HNil>>>, 

type Result = <HCons<HCons<If, HCons<HCons<Is, HCons<Missing, HCons<HCons<Find, HCons<Quote<X>, HCons<Quote<L>, HNil>>>, HNil>>>, HCons<Quote<Prepend<X>>, HCons<Ret, HNil>>>>, HCons<Quote<L>, HNil>> as Calc<HCons<HCons<(), HCons<HCons<(), HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HNil>>>, HCons<Prepend<X>, HCons<(), HNil>>>>, HCons<L, HNil>>>>::Result

fn calc(self, args: HCons<X, HCons<L, HNil>>) -> Self::Result

impl<A, B> FunCall<HCons<A, HCons<B, HNil>>> for SupersetP where
    HCons<All, HCons<HCons<Partial, HCons<Contains, HCons<Quote<A>, HNil>>>, HCons<Quote<B>, HNil>>>: Eval, 

type Result = <HCons<All, HCons<HCons<Partial, HCons<Contains, HCons<Quote<A>, HNil>>>, HCons<Quote<B>, HNil>>> as Eval>::Result

impl<A, B> FunCall<HCons<A, HCons<B, HNil>>> for SubsetP where
    HCons<SupersetP, HCons<Quote<B>, HCons<Quote<A>, HNil>>>: Eval, 

type Result = <HCons<SupersetP, HCons<Quote<B>, HCons<Quote<A>, HNil>>> as Eval>::Result

impl<A: List, B: List> FunCall<HCons<A, HCons<B, HNil>>> for Concat where
    HCons<HCons<If, HCons<HCons<EmptyP, HCons<Quote<A>, HNil>>, HCons<Ret, HCons<Quote<ConcatCont<A>>, HNil>>>>, HCons<Quote<B>, HNil>>: Eval, 

type Result = <HCons<HCons<If, HCons<HCons<EmptyP, HCons<Quote<A>, HNil>>, HCons<Ret, HCons<Quote<ConcatCont<A>>, HNil>>>>, HCons<Quote<B>, HNil>> as Eval>::Result

impl<A: List, B: List> FunCall<HCons<A, HCons<B, HNil>>> for Union where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<A>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HCons<HCons<Union, HCons<Quote<A::Tail>, HCons<HCons<If, HCons<HCons<Is, HCons<Missing, HCons<HCons<Find, HCons<Quote<A::Head>, HCons<Quote<B>, HNil>>>, HNil>>>, HCons<HCons<Cons, HCons<Quote<A::Head>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HNil>>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HNil>>>>, HNil>>>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<A>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HCons<HCons<Union, HCons<Quote<A::Tail>, HCons<HCons<If, HCons<HCons<Is, HCons<Missing, HCons<HCons<Find, HCons<Quote<A::Head>, HCons<Quote<B>, HNil>>>, HNil>>>, HCons<HCons<Cons, HCons<Quote<A::Head>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HNil>>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<B>>, HNil>>, HNil>>>>, HNil>>>, HNil>>>> as Eval>::Result

impl<H, T, Accum> FunCall<HCons<Accum, HNil>> for ConcatCont<HCons<H, T>> where
    HCons<Cons, HCons<Quote<H>, HCons<HCons<Concat, HCons<Quote<T>, HCons<Quote<Accum>, HNil>>>, HNil>>>: Eval, 

type Result = <HCons<Cons, HCons<Quote<H>, HCons<HCons<Concat, HCons<Quote<T>, HCons<Quote<Accum>, HNil>>>, HNil>>> as Eval>::Result

impl<Arg> FunCall<HCons<Arg, HNil>> for Quote where
    HCons<Ret, HCons<Quote<Quote<Arg>>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<Quote<Arg>>, HNil>> as Eval>::Result

impl FunCall<HCons<B0, HNil>> for Not where
    HCons<Ret, HCons<Quote<True>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<True>, HNil>> as Eval>::Result

impl FunCall<HCons<B1, HNil>> for Not where
    HCons<Ret, HCons<Quote<False>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<False>, HNil>> as Eval>::Result

impl<'a, Func, L: List> FunCall<HCons<Func, HCons<&'a L, HNil>>> for MapRef where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<Cons, HCons<HCons<Func, HCons<Quote<&'a L::Head>, HNil>>, HCons<HCons<MapRef, HCons<Func, HCons<Quote<&'a L::Tail>, HNil>>>, HNil>>>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<Cons, HCons<HCons<Func, HCons<Quote<&'a L::Head>, HNil>>, HCons<HCons<MapRef, HCons<Func, HCons<Quote<&'a L::Tail>, HNil>>>, HNil>>>, HNil>>>> as Eval>::Result

impl<Func, Acc, L: List> FunCall<HCons<Func, HCons<Acc, HCons<L, HNil>>>> for FoldL where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Acc>>, HNil>>, HCons<HCons<FoldL, HCons<Func, HCons<HCons<Func, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Acc>>, HNil>>, HCons<Quote<L::Head>, HNil>>>, HCons<Quote<L::Tail>, HNil>>>>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Acc>>, HNil>>, HCons<HCons<FoldL, HCons<Func, HCons<HCons<Func, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Acc>>, HNil>>, HCons<Quote<L::Head>, HNil>>>, HCons<Quote<L::Tail>, HNil>>>>, HNil>>>> as Eval>::Result

impl<Func, L: List, Init> FunCall<HCons<Func, HCons<L, HCons<Init, HNil>>>> for FoldR where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Init>>, HNil>>, HCons<HCons<Func, HCons<Quote<L::Head>, HCons<HCons<FoldR, HCons<Func, HCons<Quote<L::Tail>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Init>>, HNil>>, HNil>>>>, HNil>>>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Init>>, HNil>>, HCons<HCons<Func, HCons<Quote<L::Head>, HCons<HCons<FoldR, HCons<Func, HCons<Quote<L::Tail>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<Init>>, HNil>>, HNil>>>>, HNil>>>, HNil>>>> as Eval>::Result

impl<Func, L: List> FunCall<HCons<Func, HCons<L, HNil>>> for Map where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<Cons, HCons<HCons<Func, HCons<Quote<L::Head>, HNil>>, HCons<HCons<Map, HCons<Func, HCons<Quote<L::Tail>, HNil>>>, HNil>>>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<Cons, HCons<HCons<Func, HCons<Quote<L::Head>, HNil>>, HCons<HCons<Map, HCons<Func, HCons<Quote<L::Tail>, HNil>>>, HNil>>>, HNil>>>> as Eval>::Result

impl<Func, L: List> FunCall<HCons<Func, HCons<L, HNil>>> for Filter where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<HCons<If, HCons<HCons<Func, HCons<Quote<L::Head>, HNil>>, HCons<Quote<Prepend<L::Head>>, HCons<Ret, HNil>>>>, HCons<HCons<Filter, HCons<Func, HCons<Quote<L::Tail>, HNil>>>, HNil>>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<L>, HNil>>, HCons<HNil, HCons<HCons<HCons<If, HCons<HCons<Func, HCons<Quote<L::Head>, HNil>>, HCons<Quote<Prepend<L::Head>>, HCons<Ret, HNil>>>>, HCons<HCons<Filter, HCons<Func, HCons<Quote<L::Tail>, HNil>>>, HNil>>, HNil>>>> as Eval>::Result

impl<H, T> FunCall<HCons<H, HCons<T, HNil>>> for Cons where
    HCons<Ret, HCons<Quote<HCons<H, T>>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<HCons<H, T>>, HNil>> as Eval>::Result

impl<H, T: List> FunCall<HCons<HCons<H, T>, HCons<HNil, HNil>>> for DifferP where
    HCons<Ret, HCons<Quote<True>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<True>, HNil>> as Eval>::Result

impl<H1, T1: List, H2, T2: List> FunCall<HCons<HCons<H1, T1>, HCons<HCons<H2, T2>, HNil>>> for DifferP where
    HCons<If, HCons<HCons<Is, HCons<Quote<H1>, HCons<Quote<H2>, HNil>>>, HCons<HCons<DifferP, HCons<Quote<T1>, HCons<Quote<T2>, HNil>>>, HCons<Quote<True>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<HCons<Is, HCons<Quote<H1>, HCons<Quote<H2>, HNil>>>, HCons<HCons<DifferP, HCons<Quote<T1>, HCons<Quote<T2>, HNil>>>, HCons<Quote<True>, HNil>>>> as Eval>::Result

impl<H, T: List> FunCall<HCons<HNil, HCons<HCons<H, T>, HNil>>> for DifferP where
    HCons<Ret, HCons<Quote<True>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<True>, HNil>> as Eval>::Result

impl FunCall<HCons<HNil, HCons<HNil, HNil>>> for DifferP where
    HCons<Ret, HCons<Quote<False>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<False>, HNil>> as Eval>::Result

impl<Haystack, Item> FunCall<HCons<Haystack, HCons<Item, HNil>>> for Contains where
    HCons<Any, HCons<HCons<Partial, HCons<Is, HCons<Quote<Item>, HNil>>>, HCons<Quote<Haystack>, HNil>>>: Eval, 

type Result = <HCons<Any, HCons<HCons<Partial, HCons<Is, HCons<Quote<Item>, HNil>>>, HCons<Quote<Haystack>, HNil>>> as Eval>::Result

impl<L: Add<R>, R> FunCall<HCons<L, HCons<R, HNil>>> for Add where
    HCons<Ret, HCons<Quote<L::Output>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<L::Output>, HNil>> as Eval>::Result

impl<L: Sub<R>, R> FunCall<HCons<L, HCons<R, HNil>>> for Sub where
    HCons<Ret, HCons<Quote<L::Output>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<L::Output>, HNil>> as Eval>::Result

impl<L, R> FunCall<HCons<L, HCons<R, HNil>>> for Is where
    L: LispId,
    R: LispId,
    L::Id: IsEqual<R::Id>,
    <L::Id as IsEqual<R::Id>>::Output: Default, 

type Result = <L::Id as IsEqual<R::Id>>::Output

impl<L, R> FunCall<HCons<L, HCons<R, HNil>>> for IsNot where
    HCons<Not, HCons<HCons<Is, HCons<Quote<L>, HCons<Quote<R>, HNil>>>, HNil>>: Eval, 

type Result = <HCons<Not, HCons<HCons<Is, HCons<Quote<L>, HCons<Quote<R>, HNil>>>, HNil>> as Eval>::Result

impl<L: List> FunCall<HCons<L, HNil>> for EmptyP where
    HCons<Ret, HCons<Quote<L::IsEOL>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<L::IsEOL>, HNil>> as Eval>::Result

impl<L: List> FunCall<HCons<L, HNil>> for Tail where
    HCons<Ret, HCons<Quote<L::Tail>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<L::Tail>, HNil>> as Eval>::Result

impl<L: List> FunCall<HCons<L, HNil>> for Head where
    HCons<Ret, HCons<Quote<L::Head>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<L::Head>, HNil>> as Eval>::Result

impl<L: List> FunCall<HCons<L, HNil>> for Rev4 where
    HCons<Rev4, HCons<Quote<L>, HCons<HNil, HNil>>>: Eval, 

type Result = <HCons<Rev4, HCons<Quote<L>, HCons<HNil, HNil>>> as Eval>::Result

impl<L: List> FunCall<HCons<L, HNil>> for Rev5 where
    HCons<Rev5, HCons<Quote<L>, HCons<HNil, HNil>>>: Eval, 

type Result = <HCons<Rev5, HCons<Quote<L>, HCons<HNil, HNil>>> as Eval>::Result

impl<L: Add<U1>> FunCall<HCons<L, HNil>> for Inc where
    HCons<Ret, HCons<Quote<L::Output>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<L::Output>, HNil>> as Eval>::Result

impl<L: Sub<U1>> FunCall<HCons<L, HNil>> for Dec where
    HCons<Ret, HCons<Quote<L::Output>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<L::Output>, HNil>> as Eval>::Result

impl<Needle, H, T> FunCall<HCons<Needle, HCons<HCons<H, T>, HNil>>> for Find where
    HCons<If, HCons<HCons<Is, HCons<Needle, HCons<Quote<H>, HNil>>>, HCons<Here, HCons<HCons<WrapMissing, HCons<HCons<Find, HCons<Needle, HCons<Quote<T>, HNil>>>, HNil>>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<HCons<Is, HCons<Needle, HCons<Quote<H>, HNil>>>, HCons<Here, HCons<HCons<WrapMissing, HCons<HCons<Find, HCons<Needle, HCons<Quote<T>, HNil>>>, HNil>>, HNil>>>> as Eval>::Result

impl<Needle> FunCall<HCons<Needle, HCons<HNil, HNil>>> for Find where
    HCons<Ret, HCons<Missing, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Missing, HNil>> as Eval>::Result

impl<L: List, Needle: LispId> FunCall<HCons<Needle, HCons<L, HNil>>> for Without where
    HCons<Filter, HCons<HCons<Partial, HCons<IsNot, HCons<Quote<Needle>, HNil>>>, HCons<Quote<L>, HNil>>>: Eval, 

type Result = <HCons<Filter, HCons<HCons<Partial, HCons<IsNot, HCons<Quote<Needle>, HNil>>>, HCons<Quote<L>, HNil>>> as Eval>::Result

impl<Old: List, New: List> FunCall<HCons<Old, HCons<New, HNil>>> for Rev4 where
    HCons<If, HCons<HCons<EmptyP, HCons<Quote<Old>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<New>>, HNil>>, HCons<HCons<Rev4, HCons<Quote<Old::Tail>, HCons<HCons<Cons, HCons<Quote<Old::Head>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<New>>, HNil>>, HNil>>>, HNil>>>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<HCons<EmptyP, HCons<Quote<Old>, HNil>>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<New>>, HNil>>, HCons<HCons<Rev4, HCons<Quote<Old::Tail>, HCons<HCons<Cons, HCons<Quote<Old::Head>, HCons<HCons<UnwrapRc, HCons<Quote<Rc<New>>, HNil>>, HNil>>>, HNil>>>, HNil>>>> as Eval>::Result

impl<Old: List, New: List> FunCall<HCons<Old, HCons<New, HNil>>> for Rev5 where
    HCons<HCons<If, HCons<HCons<EmptyP, HCons<Quote<Old>, HNil>>, HCons<Ret, HCons<Quote<RevCont<Old>>, HNil>>>>, HCons<Quote<New>, HNil>>: Eval, 

type Result = <HCons<HCons<If, HCons<HCons<EmptyP, HCons<Quote<Old>, HNil>>, HCons<Ret, HCons<Quote<RevCont<Old>>, HNil>>>>, HCons<Quote<New>, HNil>> as Eval>::Result

impl<T> FunCall<HCons<Option<T>, HNil>> for Unwrap where
    HCons<Ret, HCons<Quote<T>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<T>, HNil>> as Eval>::Result

impl<In: List, Out> FunCall<HCons<Out, HNil>> for RevCont<In> where
    HCons<Rev5, HCons<Quote<In::Tail>, HCons<HCons<Cons, HCons<Quote<In::Head>, HCons<Quote<Out>, HNil>>>, HNil>>>: Eval, 

type Result = <HCons<Rev5, HCons<Quote<In::Tail>, HCons<HCons<Cons, HCons<Quote<In::Head>, HCons<Quote<Out>, HNil>>>, HNil>>> as Eval>::Result

impl<A, B> FunCall<HCons<PhantomData<A>, HCons<B, HNil>>> for Intersect where
    HCons<Filter, HCons<HCons<Partial, HCons<Contains, HCons<Quote<A>, HNil>>>, HCons<Quote<B>, HNil>>>: Eval, 

type Result = <HCons<Filter, HCons<HCons<Partial, HCons<Contains, HCons<Quote<A>, HNil>>>, HCons<Quote<B>, HNil>>> as Eval>::Result

impl<A, B> FunCall<HCons<PhantomData<A>, HCons<B, HNil>>> for Remove where
    HCons<Head, HCons<HCons<Tail, HCons<HCons<Collate, HCons<HCons<Partial, HCons<Contains, HCons<Quote<A>, HNil>>>, HCons<Quote<B>, HNil>>>, HNil>>, HNil>>: Eval, 

type Result = <HCons<Head, HCons<HCons<Tail, HCons<HCons<Collate, HCons<HCons<Partial, HCons<Contains, HCons<Quote<A>, HNil>>>, HCons<Quote<B>, HNil>>>, HNil>>, HNil>> as Eval>::Result

impl<Pred, H, T> FunCall<HCons<Pred, HCons<HCons<H, T>, HNil>>> for FindPred where
    HCons<If, HCons<HCons<Quote<Pred>, HCons<Quote<H>, HNil>>, HCons<U0, HCons<HCons<WrapMissing, HCons<HCons<FindPred, HCons<Quote<Pred>, HCons<Quote<T>, HNil>>>, HNil>>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<HCons<Quote<Pred>, HCons<Quote<H>, HNil>>, HCons<U0, HCons<HCons<WrapMissing, HCons<HCons<FindPred, HCons<Quote<Pred>, HCons<Quote<T>, HNil>>>, HNil>>, HNil>>>> as Eval>::Result

impl<Pred> FunCall<HCons<Pred, HCons<HNil, HNil>>> for FindPred where
    HCons<Ret, HCons<Missing, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Missing, HNil>> as Eval>::Result

impl<Pred, Haystack> FunCall<HCons<Pred, HCons<Haystack, HNil>>> for Any where
    HCons<Not, HCons<HCons<Is, HCons<Missing, HCons<HCons<FindPred, HCons<Quote<Pred>, HCons<Quote<Haystack>, HNil>>>, HNil>>>, HNil>>: Eval, 

type Result = <HCons<Not, HCons<HCons<Is, HCons<Missing, HCons<HCons<FindPred, HCons<Quote<Pred>, HCons<Quote<Haystack>, HNil>>>, HNil>>>, HNil>> as Eval>::Result

impl<Pred, Haystack> FunCall<HCons<Pred, HCons<Haystack, HNil>>> for All where
    HCons<Not, HCons<HCons<Any, HCons<HCons<Invert, HCons<Pred, HNil>>, HCons<Quote<Haystack>, HNil>>>, HNil>>: Eval, 

type Result = <HCons<Not, HCons<HCons<Any, HCons<HCons<Invert, HCons<Pred, HNil>>, HCons<Quote<Haystack>, HNil>>>, HNil>> as Eval>::Result

impl<Pred> FunCall<HCons<Pred, HNil>> for Invert where
    HCons<Ret, HCons<Quote<Inverted<Pred>>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<Inverted<Pred>>, HNil>> as Eval>::Result

impl<T> FunCall<HCons<Rc<T>, HNil>> for UnwrapRc where
    HCons<Ret, HCons<Quote<T>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<T>, HNil>> as Eval>::Result

impl<T> FunCall<HCons<T, HNil>> for WrapRc where
    HCons<Ret, HCons<Quote<Rc<T>>, HNil>>: Eval, 

type Result = <HCons<Ret, HCons<Quote<Rc<T>>, HNil>> as Eval>::Result

impl<T, U> FunCall<HCons<T, U>> for Ret

type Result = T

impl<X, Tail> FunCall<HCons<Tail, HNil>> for Prepend<X> where
    HCons<Cons, HCons<Quote<X>, HCons<Quote<Tail>, HNil>>>: Eval, 

type Result = <HCons<Cons, HCons<Quote<X>, HCons<Quote<Tail>, HNil>>> as Eval>::Result

impl<Test, L: CollatedBy<Test>> FunCall<HCons<Test, HCons<L, HNil>>> for Collate where
    HCons<BuildList, HCons<Quote<L::Passed>, HCons<Quote<L::Failed>, HNil>>>: Eval, 

type Result = <HCons<BuildList, HCons<Quote<L::Passed>, HCons<Quote<L::Failed>, HNil>>> as Eval>::Result

impl<X: LispId, L: List> FunCall<HCons<X, HCons<L, HNil>>> for SetInsert where
    HCons<HCons<If, HCons<HCons<Is, HCons<Missing, HCons<HCons<Find, HCons<Quote<X>, HCons<Quote<L>, HNil>>>, HNil>>>, HCons<Quote<Prepend<X>>, HCons<Ret, HNil>>>>, HCons<Quote<L>, HNil>>: Eval, 

type Result = <HCons<HCons<If, HCons<HCons<Is, HCons<Missing, HCons<HCons<Find, HCons<Quote<X>, HCons<Quote<L>, HNil>>>, HNil>>>, HCons<Quote<Prepend<X>>, HCons<Ret, HNil>>>>, HCons<Quote<L>, HNil>> as Eval>::Result

impl<H: Hash, T: Hash> Hash for HCons<H, T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<H, T, X> ListOf<X> for HCons<H, T> where
    T: ListOf<X>,
    H: Into<X>, 

type ListIter = Chain<Once<X>, T::ListIter>

fn list_of_iter(self) -> Self::ListIter

impl<H, T, X: ?Sized> ListOfRefs<X> for HCons<H, T> where
    T: ListOfRefs<X>,
    H: AsRef<X>, 

fn head_ref(&self) -> Option<&X>

fn tail_ref(&self) -> &dyn ListOfRefs<X>

fn iter(&self) -> RefIter<'_, X> where
    Self: Sized, 

impl<H: Ord, T: Ord> Ord for HCons<H, T>

fn cmp(&self, other: &HCons<H, T>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<H: PartialEq, T: PartialEq> PartialEq<HCons<H, T>> for HCons<H, T>

fn eq(&self, other: &HCons<H, T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &HCons<H, T>) -> bool

This method tests for !=.

impl<H: PartialOrd, T: PartialOrd> PartialOrd<HCons<H, T>> for HCons<H, T>

fn partial_cmp(&self, other: &HCons<H, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Arg: Eval, QArg> SynCalc<HCons<Arg, HNil>, QArg> for Phantom

type Result = PhantomData<Arg::Result>

fn syn_calc(self, _: QArg) -> Self::Result

impl<Cond: Eval, T, F, CQ, TQ, FQ> SynCalc<HCons<Cond, HCons<T, HCons<F, HNil>>>, HCons<CQ, HCons<TQ, HCons<FQ, HNil>>>> for If where
    Cond::Result: IfCalcImpl<T, F, TQ, FQ>, 

type Result = <Cond::Result as IfCalcImpl<T, F, TQ, FQ>>::Result

fn syn_calc(self, _: HCons<CQ, HCons<TQ, HCons<FQ, HNil>>>) -> Self::Result

impl<Test, Res, Else, QTest, QRes, QElse> SynCalc<HCons<HCons<Test, HCons<Res, HNil>>, Else>, HCons<HCons<QTest, HCons<QRes, HNil>>, QElse>> for Cond where
    HCons<If, HCons<Test, HCons<Res, HCons<HCons<Cond, Else>, HNil>>>>: Calc<HCons<If, HCons<QTest, HCons<QRes, HCons<HCons<Cond, QElse>, HNil>>>>>, 

type Result = <HCons<If, HCons<Test, HCons<Res, HCons<HCons<Cond, Else>, HNil>>>> as Calc<HCons<If, HCons<QTest, HCons<QRes, HCons<HCons<Cond, QElse>, HNil>>>>>>::Result

fn syn_calc(
    self,
    _: HCons<HCons<QTest, HCons<QRes, HNil>>, QElse>
) -> Self::Result

impl<Arg: Eval> SynCall<HCons<Arg, HNil>> for Phantom

type Result = PhantomData<Arg::Result>

impl<Cond: Eval, T, F> SynCall<HCons<Cond, HCons<T, HCons<F, HNil>>>> for If where
    Cond::Result: IfImpl<T, F>, 

type Result = <Cond::Result as IfImpl<T, F>>::Result

impl<H, T> SynCall<HCons<H, T>> for And where
    HCons<If, HCons<H, HCons<HCons<And, T>, HCons<Quote<False>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<H, HCons<HCons<And, T>, HCons<Quote<False>, HNil>>>> as Eval>::Result

impl<H, T> SynCall<HCons<H, T>> for Or where
    HCons<If, HCons<H, HCons<Quote<True>, HCons<HCons<Or, T>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<H, HCons<Quote<True>, HCons<HCons<Or, T>, HNil>>>> as Eval>::Result

impl<Test, Res, Else> SynCall<HCons<HCons<Test, HCons<Res, HNil>>, Else>> for Cond where
    HCons<If, HCons<Test, HCons<Res, HCons<HCons<Cond, Else>, HNil>>>>: Eval, 

type Result = <HCons<If, HCons<Test, HCons<Res, HCons<HCons<Cond, Else>, HNil>>>> as Eval>::Result

impl<H: Copy, T: Copy> Copy for HCons<H, T>

impl<H: Eq, T: Eq> Eq for HCons<H, T>

impl<H, T> StructuralEq for HCons<H, T>

impl<H, T> StructuralPartialEq for HCons<H, T>