Struct 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 as Calc<QH>>::Result as Call>::Conv as CalcImpl<<H as Calc<QH>>::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 as Calc<QH>>::Result, <T as CalcList<QT>>::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 duplicate 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 as CollateStep<Test, H, T>>::Passed

type Failed = <Step as CollateStep<Test, H, T>>::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 as Eval>::Result as Call>::Conv as CallImpl<<H as Eval>::Result, T>>::Result

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

type Result = HCons<<H as Eval>::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 as List>::Tail>, HCons<HCons<If, HCons<HCons<Is, HCons<Missing, HCons<HCons<Find, HCons<Quote<<A as List>::Head>, HCons<Quote<B>, HNil>>>, HNil>>>, HCons<HCons<Cons, HCons<Quote<<A as List>::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 as List>::Tail, HCons<HCons<(), HCons<HCons<(), HCons<(), HCons<HCons<(), HCons<(), HCons<(), HNil>>>, HNil>>>, HCons<HCons<(), HCons<<A as List>::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<B1>, HNil>> as Calc<HCons<(), HCons<B1, 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<B0>, HNil>> as Calc<HCons<(), HCons<B0, 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 as List>::Head>, HNil>>, HCons<HCons<MapRef, HCons<Func, HCons<Quote<&'a <L as List>::Tail>, HNil>>>, HNil>>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<&'a <L as List>::Head, HNil>>, HCons<HCons<(), HCons<(), HCons<&'a <L as List>::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 as List>::Head>, HNil>>>, HCons<Quote<<L as List>::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 as List>::Head, HNil>>>, HCons<<L as List>::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 as List>::Head>, HCons<HCons<FoldR, HCons<Func, HCons<Quote<<L as List>::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 as List>::Head, HCons<HCons<(), HCons<(), HCons<<L as List>::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 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 as List>::Head>, HNil>>, HCons<Quote<Prepend<<L as List>::Head>>, HCons<Ret, HNil>>>>, HCons<HCons<Filter, HCons<Func, HCons<Quote<<L as List>::Tail>, HNil>>>, HNil>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<HCons<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<Prepend<<L as List>::Head>, HCons<(), HNil>>>>, HCons<HCons<(), HCons<(), HCons<<L as List>::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 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 as List>::Head>, HNil>>, HCons<HCons<Map, HCons<Func, HCons<Quote<<L as List>::Tail>, HNil>>>, HNil>>>, HNil>>>> as Calc<HCons<(), HCons<HCons<(), HCons<(), HNil>>, HCons<(), HCons<HCons<(), HCons<HCons<(), HCons<<L as List>::Head, HNil>>, HCons<HCons<(), HCons<(), HCons<<L as List>::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 as Add<R>>::Output>, HNil>> as Calc<HCons<(), HCons<<L as Add<R>>::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 as Sub<R>>::Output>, HNil>> as Calc<HCons<(), HCons<<L as Sub<R>>::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 as List>::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 Head

where HCons<Ret, HCons<Quote<L::Head>, HNil>>: Calc<HCons<(), HCons<L::Head, HNil>>>,

type Result = <HCons<Ret, HCons<Quote<<L as List>::Head>, HNil>> as Calc<HCons<(), HCons<<L as List>::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<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 as List>::Tail>, HNil>> as Calc<HCons<(), HCons<<L as List>::Tail, 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 as List>::Tail>, HCons<HCons<Cons, HCons<Quote<<Old as List>::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 as List>::Tail, HCons<HCons<(), HCons<<Old as List>::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 as List>::Tail>, HCons<HCons<Cons, HCons<Quote<<In as List>::Head>, HCons<Quote<Out>, HNil>>>, HNil>>> as Calc<HCons<(), HCons<<In as List>::Tail, HCons<HCons<(), HCons<<In as List>::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 as CollatedBy<Test>>::Passed>, HCons<Quote<<L as CollatedBy<Test>>::Failed>, HNil>>> as Calc<HCons<(), HCons<<L as CollatedBy<Test>>::Passed, HCons<<L as CollatedBy<Test>>::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: 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, 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, 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: 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 as List>::Tail>, HCons<HCons<If, HCons<HCons<Is, HCons<Missing, HCons<HCons<Find, HCons<Quote<<A as List>::Head>, HCons<Quote<B>, HNil>>>, HNil>>>, HCons<HCons<Cons, HCons<Quote<<A as List>::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<B1>, 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<B0>, 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 as List>::Head>, HNil>>, HCons<HCons<MapRef, HCons<Func, HCons<Quote<&'a <L as List>::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 as List>::Head>, HNil>>>, HCons<Quote<<L as List>::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 as List>::Head>, HCons<HCons<FoldR, HCons<Func, HCons<Quote<<L as List>::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 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 as List>::Head>, HNil>>, HCons<Quote<Prepend<<L as List>::Head>>, HCons<Ret, HNil>>>>, HCons<HCons<Filter, HCons<Func, HCons<Quote<<L as List>::Tail>, 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 as List>::Head>, HNil>>, HCons<HCons<Map, HCons<Func, HCons<Quote<<L as List>::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<B1>, 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<B1>, 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<B1>, 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<B0>, 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 as Add<R>>::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 as LispId>::Id as IsEqual<<R as LispId>::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: 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 as Sub<R>>::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 as Sub<UInt<UTerm, B1>>>::Output>, 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 as List>::IsEOL>, 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 as List>::Head>, 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 as Add<UInt<UTerm, B1>>>::Output>, 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: List> FunCall<HCons<L, HNil>> for Tail

where HCons<Ret, HCons<Quote<L::Tail>, HNil>>: Eval,

type Result = <HCons<Ret, HCons<Quote<<L as List>::Tail>, 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 as List>::Tail>, HCons<HCons<Cons, HCons<Quote<<Old as List>::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 as List>::Tail>, HCons<HCons<Cons, HCons<Quote<<In as List>::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<UTerm, 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 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, 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> 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 as CollatedBy<Test>>::Passed>, HCons<Quote<<L as CollatedBy<Test>>::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, Self: Sized,

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 as ListOf<X>>::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.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

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

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<H: PartialOrd, T: PartialOrd> PartialOrd 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.

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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 as Eval>::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 as Eval>::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 as Eval>::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 as Eval>::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<B0>, 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<B1>, 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> StructuralPartialEq for HCons<H, T>