Trait shades::ToFun

pub trait ToFun<R, A> {
    fn build_fn(self) -> FunDef<R, A>;
}

Function definition injection.

This trait represents function definition injection, i.e. types that can provide a function definition — see FunDef. Ideally, only a very small number of types can do this: polymorphic types implementing the FnOnce trait with different number of arguments. Namely, closures / lambdas with various numbers of arguments.

You are not supposed to implement this type by yourself. Instead, when creating functions in the EDSL, you just have to pass lambdas to automatically get the proper function definition lifted into the EDSL.

See the ShaderBuilder::fun for further information.

Caveats

This way of doing currently comes with a price: type inference is bad. You will — most of the time — have to annotate the closure’s arguments. This is currently working on but progress on that matter is slow.

Required methods

fn build_fn(self) -> FunDef<R, A>

Loading content...

Implementors

impl<F, R> ToFun<R, ()> for F where
    Self: FnOnce(&mut Scope<R>) -> R,
    Return: From<R>, 

fn build_fn(self) -> FunDef<R, ()>

impl<F, R, A0, A1> ToFun<R, (Expr<A0>, Expr<A1>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType, 

fn build_fn(self) -> FunDef<R, (Expr<A0>, Expr<A1>)>

impl<F, R, A0, A1, A2> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType, 

fn build_fn(self) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>)>

impl<F, R, A0, A1, A2, A3> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType, 

fn build_fn(self) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>)>

impl<F, R, A0, A1, A2, A3, A4> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>)>

impl<F, R, A0, A1, A2, A3, A4, A5> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6, A7> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType,
    A7: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6, A7, A8> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType,
    A7: ToType,
    A8: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType,
    A7: ToType,
    A8: ToType,
    A9: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType,
    A7: ToType,
    A8: ToType,
    A9: ToType,
    A10: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType,
    A7: ToType,
    A8: ToType,
    A9: ToType,
    A10: ToType,
    A11: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType,
    A7: ToType,
    A8: ToType,
    A9: ToType,
    A10: ToType,
    A11: ToType,
    A12: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType,
    A7: ToType,
    A8: ToType,
    A9: ToType,
    A10: ToType,
    A11: ToType,
    A12: ToType,
    A13: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>, Expr<A14>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>, Expr<A14>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType,
    A7: ToType,
    A8: ToType,
    A9: ToType,
    A10: ToType,
    A11: ToType,
    A12: ToType,
    A13: ToType,
    A14: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>, Expr<A14>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>, Expr<A14>, Expr<A15>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>, Expr<A14>, Expr<A15>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType,
    A7: ToType,
    A8: ToType,
    A9: ToType,
    A10: ToType,
    A11: ToType,
    A12: ToType,
    A13: ToType,
    A14: ToType,
    A15: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>, Expr<A14>, Expr<A15>)>

impl<F, R, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16> ToFun<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>, Expr<A14>, Expr<A15>, Expr<A16>)> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>, Expr<A14>, Expr<A15>, Expr<A16>) -> R,
    Return: From<R>,
    A0: ToType,
    A1: ToType,
    A2: ToType,
    A3: ToType,
    A4: ToType,
    A5: ToType,
    A6: ToType,
    A7: ToType,
    A8: ToType,
    A9: ToType,
    A10: ToType,
    A11: ToType,
    A12: ToType,
    A13: ToType,
    A14: ToType,
    A15: ToType,
    A16: ToType, 

fn build_fn(
    self
) -> FunDef<R, (Expr<A0>, Expr<A1>, Expr<A2>, Expr<A3>, Expr<A4>, Expr<A5>, Expr<A6>, Expr<A7>, Expr<A8>, Expr<A9>, Expr<A10>, Expr<A11>, Expr<A12>, Expr<A13>, Expr<A14>, Expr<A15>, Expr<A16>)>

impl<F, R, A> ToFun<R, Expr<A>> for F where
    Self: FnOnce(&mut Scope<R>, Expr<A>) -> R,
    Return: From<R>,
    A: ToType, 

fn build_fn(self) -> FunDef<R, Expr<A>>

Loading content...