Struct FirstArgumentProvided

pub struct FirstArgumentProvided<F: CallableWithFixedArguments, A: ProvideArgument<ProvideArgumentType = <F::FixedArgumentTypes as ArgumentTypes>::First>> { /* private fields */ }

Trait Implementations§

Returns a duplicate of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Equality operator ==. Read more

Inequality operator !=. Read more

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

A shortcut for Callable::call_fn with exactly one argument.

Provide input with another callable. Read more

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

FirstArgumentProvided

Struct FirstArgumentProvided Copy item path

Trait Implementations§

type Output = Out

fn call_fn( &self, args: ArgumentsOfTypes<'_, <F::FixedArgumentTypes as ArgumentTypes>::FirstTrimmed>, ) -> Self::Output

impl<Out, F: CallableWithFixedArguments<Output = Out>, A: ProvideArgument<ProvideArgumentType = <F::FixedArgumentTypes as ArgumentTypes>::First>> CallableWithFixedArguments for FirstArgumentProvided<F, A>

type FixedArgumentTypes = <<F as CallableWithFixedArguments>::FixedArgumentTypes as ArgumentTypes>::FirstTrimmed

impl<F: Clone + CallableWithFixedArguments, A: Clone + ProvideArgument<ProvideArgumentType = <F::FixedArgumentTypes as ArgumentTypes>::First>> Clone for FirstArgumentProvided<F, A>

fn clone(&self) -> FirstArgumentProvided<F, A>

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

impl<F: Copy + CallableWithFixedArguments, A: Copy + ProvideArgument<ProvideArgumentType = <F::FixedArgumentTypes as ArgumentTypes>::First>> Copy for FirstArgumentProvided<F, A>

impl<F: Debug + CallableWithFixedArguments, A: Debug + ProvideArgument<ProvideArgumentType = <F::FixedArgumentTypes as ArgumentTypes>::First>> Debug for FirstArgumentProvided<F, A>

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

impl<F: Eq + CallableWithFixedArguments, A: Eq + ProvideArgument<ProvideArgumentType = <F::FixedArgumentTypes as ArgumentTypes>::First>> Eq for FirstArgumentProvided<F, A>

impl<F: CallableWithFixedArguments, A: ProvideArgument<ProvideArgumentType = <F::FixedArgumentTypes as ArgumentTypes>::First>> IsCallable for FirstArgumentProvided<F, A>

fn accept_anything(self) -> AcceptAnything<Self>where Self: Sized + Callable<()>,

fn provide_last_argument<A: ProvideArgument<ProvideArgumentType = <Self::FixedArgumentTypes as ArgumentTypes>::Last>>( self, last_argument: A, ) -> LastArgumentProvided<Self, A>where Self: Sized + CallableWithFixedArguments,

fn provide_first_argument<A: ProvideArgument<ProvideArgumentType = <Self::FixedArgumentTypes as ArgumentTypes>::First>>( self, first_argument: A, ) -> FirstArgumentProvided<Self, A>where Self: Sized + CallableWithFixedArguments,

fn provide_last_argument_refed<T>( self, last_argument: T, ) -> LastArgumentProvided<Self, Refed<T>>where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<Last = ByRef<T>>,

fn provide_first_argument_refed<T>( self, first_argument: T, ) -> FirstArgumentProvided<Self, Refed<T>>where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<First = ByRef<T>>,

fn provide_first_argument_copied<T: Copy>( self, first_argument: T, ) -> FirstArgumentProvided<Self, Copied<T>>where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<First = Value<T>>,

fn provide_last_argument_copied<T: Copy>( self, last_argument: T, ) -> LastArgumentProvided<Self, Copied<T>>where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<Last = Value<T>>,

fn provide_last_argument_cloned<T: Clone>( self, last_argument: T, ) -> LastArgumentProvided<Self, Cloned<T>>where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<Last = Value<T>>,

fn provide_first_argument_cloned<T: Clone>( self, first_argument: T, ) -> FirstArgumentProvided<Self, Cloned<T>>where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<First = Value<T>>,

fn provide_first_argument_with<F: Callable<()>>( self, get_first_argument: F, ) -> FirstArgumentProvided<Self, With<F>>where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<First = Value<<F as Callable<()>>::Output>>,

fn provide_last_argument_with<F: Callable<()>>( self, get_first_argument: F, ) -> LastArgumentProvided<Self, With<F>>where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<Last = Value<<F as Callable<()>>::Output>>,

impl<F: PartialEq + CallableWithFixedArguments, A: PartialEq + ProvideArgument<ProvideArgumentType = <F::FixedArgumentTypes as ArgumentTypes>::First>> PartialEq for FirstArgumentProvided<F, A>

fn eq(&self, other: &FirstArgumentProvided<F, A>) -> bool

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

impl<F: PartialEq + CallableWithFixedArguments, A: PartialEq + ProvideArgument<ProvideArgumentType = <F::FixedArgumentTypes as ArgumentTypes>::First>> StructuralPartialEq for FirstArgumentProvided<F, A>

Auto Trait Implementations§

impl<F, A> Freeze for FirstArgumentProvided<F, A>where F: Freeze, A: Freeze,

impl<F, A> RefUnwindSafe for FirstArgumentProvided<F, A>where F: RefUnwindSafe, A: RefUnwindSafe,

impl<F, A> Send for FirstArgumentProvided<F, A>where F: Send, A: Send,

impl<F, A> Sync for FirstArgumentProvided<F, A>where F: Sync, A: Sync,

impl<F, A> Unpin for FirstArgumentProvided<F, A>where F: Unpin, A: Unpin,

impl<F, A> UnsafeUnpin for FirstArgumentProvided<F, A>where F: UnsafeUnpin, A: UnsafeUnpin,

impl<F, A> UnwindSafe for FirstArgumentProvided<F, A>where F: UnwindSafe, A: UnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<A1, F> CallableOne<A1> for Fwhere F: Callable<(A1,)>,

fn emit(&self, input: IN) -> Self::Output

fn chain<F: CallableOne<Self::Output>>(self, f: F) -> Chain<Self, F>where Self: Sized,

fn reform<NewInput, F: CallableOne<NewInput, Output = IN>>( self, f: F, ) -> Chain<F, Self>where Self: Sized,

fn reform_ref<NewInput: ?Sized, F: for<'i> CallableOne<&'i NewInput, Output = IN>>( self, f: F, ) -> Chain<F, Self>where Self: Sized,

fn reform_mut<NewInput: ?Sized, F: for<'input> CallableOne<&'input mut NewInput, Output = IN>>( self, f: F, ) -> Chain<F, Self>where Self: Sized,

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<E, C> MaybeHandleEvent<E> for Cwhere E: StatedEvent + ?Sized, C: PartialEq + for<'e> Callable<(&'e E,)>,

type State = (<E as StatedEvent>::State, C)

type Callable = C

fn initialize_handle_event_state( this: C, new_event_state: impl FnOnce(&<C as MaybeHandleEvent<E>>::Callable) -> <E as StatedEvent>::State, ) -> <C as MaybeHandleEvent<E>>::State

fn update_handle_event_state( this: C, state: &mut <C as MaybeHandleEvent<E>>::State, new_event_state: impl FnOnce(&<C as MaybeHandleEvent<E>>::Callable) -> <E as StatedEvent>::State, )

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = !

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Struct FirstArgumentProvided

fn accept_anything(self) -> AcceptAnything<Self>
where Self: Sized + Callable<()>,

fn provide_last_argument<A: ProvideArgument<ProvideArgumentType = <Self::FixedArgumentTypes as ArgumentTypes>::Last>>( self, last_argument: A, ) -> LastArgumentProvided<Self, A>
where Self: Sized + CallableWithFixedArguments,

fn provide_first_argument<A: ProvideArgument<ProvideArgumentType = <Self::FixedArgumentTypes as ArgumentTypes>::First>>( self, first_argument: A, ) -> FirstArgumentProvided<Self, A>
where Self: Sized + CallableWithFixedArguments,

fn provide_last_argument_refed<T>( self, last_argument: T, ) -> LastArgumentProvided<Self, Refed<T>>
where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<Last = ByRef<T>>,

fn provide_first_argument_refed<T>( self, first_argument: T, ) -> FirstArgumentProvided<Self, Refed<T>>
where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<First = ByRef<T>>,

fn provide_first_argument_copied<T: Copy>( self, first_argument: T, ) -> FirstArgumentProvided<Self, Copied<T>>
where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<First = Value<T>>,

fn provide_last_argument_copied<T: Copy>( self, last_argument: T, ) -> LastArgumentProvided<Self, Copied<T>>
where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<Last = Value<T>>,

fn provide_last_argument_cloned<T: Clone>( self, last_argument: T, ) -> LastArgumentProvided<Self, Cloned<T>>
where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<Last = Value<T>>,

fn provide_first_argument_cloned<T: Clone>( self, first_argument: T, ) -> FirstArgumentProvided<Self, Cloned<T>>
where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<First = Value<T>>,

fn provide_first_argument_with<F: Callable<()>>( self, get_first_argument: F, ) -> FirstArgumentProvided<Self, With<F>>
where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<First = Value<<F as Callable<()>>::Output>>,

fn provide_last_argument_with<F: Callable<()>>( self, get_first_argument: F, ) -> LastArgumentProvided<Self, With<F>>
where Self: Sized + CallableWithFixedArguments, Self::FixedArgumentTypes: ArgumentTypes<Last = Value<<F as Callable<()>>::Output>>,

impl<F, A> Freeze for FirstArgumentProvided<F, A>
where F: Freeze, A: Freeze,

impl<F, A> RefUnwindSafe for FirstArgumentProvided<F, A>
where F: RefUnwindSafe, A: RefUnwindSafe,

impl<F, A> Send for FirstArgumentProvided<F, A>
where F: Send, A: Send,

impl<F, A> Sync for FirstArgumentProvided<F, A>
where F: Sync, A: Sync,

impl<F, A> Unpin for FirstArgumentProvided<F, A>
where F: Unpin, A: Unpin,

impl<F, A> UnsafeUnpin for FirstArgumentProvided<F, A>
where F: UnsafeUnpin, A: UnsafeUnpin,

impl<F, A> UnwindSafe for FirstArgumentProvided<F, A>
where F: UnwindSafe, A: UnwindSafe,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<A1, F> CallableOne<A1> for F
where F: Callable<(A1,)>,

fn chain<F: CallableOne<Self::Output>>(self, f: F) -> Chain<Self, F>
where Self: Sized,

fn reform<NewInput, F: CallableOne<NewInput, Output = IN>>( self, f: F, ) -> Chain<F, Self>
where Self: Sized,

fn reform_ref<NewInput: ?Sized, F: for<'i> CallableOne<&'i NewInput, Output = IN>>( self, f: F, ) -> Chain<F, Self>
where Self: Sized,

fn reform_mut<NewInput: ?Sized, F: for<'input> CallableOne<&'input mut NewInput, Output = IN>>( self, f: F, ) -> Chain<F, Self>
where Self: Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

impl<E, C> MaybeHandleEvent<E> for C
where E: StatedEvent + ?Sized, C: PartialEq + for<'e> Callable<(&'e E,)>,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,