Struct Sub

pub struct Sub<L, R> { /* private fields */ }

Trait Implementations

impl<L: Clone, R: Clone> Clone for Sub<L, R>

fn clone(&self) -> Sub<L, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L, R> Signal for Sub<L, R>

where L: Signal, R: Signal, L::Type: Sub<R::Type>,

type Type = <<L as Signal>::Type as Sub<<R as Signal>::Type>>::Output

The type of the signal.

fn next(&mut self) -> Self::Type

Returns the next value of this signal.

fn add<S>(self, other: S) -> Add<Self, S>

where Self: Sized, S: Signal, Self::Type: Add<S::Type>,

Performs the + operation.

fn sub<S>(self, other: S) -> Sub<Self, S>

where Self: Sized, S: Signal, Self::Type: Sub<S::Type>,

Performs the - operation.

fn mul<S>(self, other: S) -> Mul<Self, S>

where Self: Sized, S: Signal, Self::Type: Mul<S::Type>,

Performs the * operation.

fn div<S>(self, other: S) -> Div<Self, S>

where Self: Sized, S: Signal, Self::Type: Div<S::Type>,

Performs the / operation.

fn rem<S>(self, other: S) -> Rem<Self, S>

where Self: Sized, S: Signal, Self::Type: Rem<S::Type>,

Performs the % operation.

fn bitand<S>(self, other: S) -> BitAnd<Self, S>

where Self: Sized, S: Signal, Self::Type: BitAnd<S::Type>,

Performs the & operation.

fn bitor<S>(self, other: S) -> BitOr<Self, S>

where Self: Sized, S: Signal, Self::Type: BitOr<S::Type>,

Performs the | operation.

fn bitxor<S>(self, other: S) -> BitXor<Self, S>

where Self: Sized, S: Signal, Self::Type: BitXor<S::Type>,

Performs the ^ operation.

fn shr<S>(self, other: S) -> Shr<Self, S>

where Self: Sized, S: Signal, Self::Type: Shr<S::Type>,

Performs the >> operation.

fn shl<S>(self, other: S) -> Shl<Self, S>

where Self: Sized, S: Signal, Self::Type: Shl<S::Type>,

Performs the << operation.

fn neg(self) -> Neg<Self>

where Self: Sized, Self::Type: Neg,

Negates this signal.

fn min<S>(self, other: S) -> Min<Self, S>

where Self: Sized, S: Signal<Type = Self::Type>, Self::Type: Ord,

Returns the minimum of this signal and the other.

fn max<S>(self, other: S) -> Max<Self, S>

where Self: Sized, S: Signal<Type = Self::Type>, Self::Type: Ord,

Returns the maximum of this signal and the other.

fn clamp<Min, Max>(self, min: Min, max: Max) -> Clamp<Self, Min, Max>

where Self: Sized, Min: Signal<Type = Self::Type>, Max: Signal<Type = Self::Type>, Self::Type: Ord,

Clamps this signal between min and max. This result of this function is the same as .max(min).min(max).

fn map<F, T>(self, map: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Type) -> T,

Maps this signal to another using the given function.

fn filter<F>(self, predicate: F) -> Filter<Self, F>

where Self: Sized, F: FnMut(&Self::Type) -> bool,

Filters values of the signal with the given predicate.

fn filter_map<F, T>(self, predicate: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Type) -> Option<T>,

Filters and maps a signal to another using the given predicate.

fn cloned<'a, T>(self) -> Cloned<Self>

where Self: Sized + Signal<Type = &'a T>, T: 'a + Clone,

Clones the values of this signal. This is useful to turn a Signal<Type = &T> into a Signal<Type = T>.

fn inspect<F>(self, inspect: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Type),

Inspects the values of this signal by calling a function before yielding the value.

fn zip<S>(self, other: S) -> Zip<Self, S>

where Self: Sized, S: Signal,

Zips this signal with another.

fn into<T>(self) -> Into<Self, T>

where Self: Sized, Self::Type: Into<T>,

Turns this signal into another using the Into trait.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Skips n values of the signal.

fn into_iter(self) -> IntoIter<Self>

where Self: Sized,

Creates an iterator that yields the values of this signal.

fn ease(self, amount: Self::Type) -> Ease<Self>

where Self: Sized, Self::Type: Float,

Eases this signal with the given amount. A greater amount will make the the signal smoother and any amount lower than 0.0 will give wierd results.

fn lerp<S>(self, other: S, amount: Self::Type) -> Lerp<Self, S>

where Self: Sized, S: Signal<Type = Self::Type>, Self::Type: Float,

Linearly interpolates between this signal and another.

fn wrapping_add<S, RefL, RefR, T>(self, other: S) -> WrappingAdd<T, Self, S>

where T: WrappingAdd, RefL: AsRef<T>, RefR: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = RefR>,

fn wrapping_sub<S, RefL, RefR, T>(self, other: S) -> WrappingSub<T, Self, S>

where T: WrappingSub, RefL: AsRef<T>, RefR: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = RefR>,

fn wrapping_mul<S, RefL, RefR, T>(self, other: S) -> WrappingMul<T, Self, S>

where T: WrappingMul, RefL: AsRef<T>, RefR: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = RefR>,

fn wrapping_shr<S, RefL, T>(self, other: S) -> WrappingShr<T, Self, S>

where T: WrappingShr, RefL: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = u32>,

fn wrapping_shl<S, RefL, T>(self, other: S) -> WrappingShl<T, Self, S>

where T: WrappingShl, RefL: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = u32>,

fn saturating_add<S, RefL, RefR, T>(self, other: S) -> SaturatingAdd<T, Self, S>

where T: SaturatingAdd, RefL: AsRef<T>, RefR: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = RefR>,

fn saturating_sub<S, RefL, RefR, T>(self, other: S) -> SaturatingSub<T, Self, S>

where T: SaturatingSub, RefL: AsRef<T>, RefR: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = RefR>,

fn saturating_mul<S, RefL, RefR, T>(self, other: S) -> SaturatingMul<T, Self, S>

where T: SaturatingMul, RefL: AsRef<T>, RefR: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = RefR>,

fn checked_add<S, RefL, RefR, T>(self, other: S) -> CheckedAdd<T, Self, S>

where T: CheckedAdd, RefL: AsRef<T>, RefR: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = RefR>,

fn checked_sub<S, RefL, RefR, T>(self, other: S) -> CheckedSub<T, Self, S>

where T: CheckedSub, RefL: AsRef<T>, RefR: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = RefR>,

fn checked_mul<S, RefL, RefR, T>(self, other: S) -> CheckedMul<T, Self, S>

where T: CheckedMul, RefL: AsRef<T>, RefR: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = RefR>,

fn checked_shr<S, RefL, T>(self, other: S) -> CheckedShr<T, Self, S>

where T: CheckedShr, RefL: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = u32>,

fn checked_shl<S, RefL, T>(self, other: S) -> CheckedShl<T, Self, S>

where T: CheckedShr, RefL: AsRef<T>, Self: Sized + Signal<Type = RefL>, S: Signal<Type = u32>,

fn inv(self) -> Inv<Self>

where Self: Sized, Self::Type: Inv,

fn mul_add<M, A>(self, mul: M, add: A) -> MulAdd<Self, M, A>

where Self: Sized, M: Signal, A: Signal, Self::Type: MulAdd<M::Type, A::Type>,

fn pow<E>(self, exp: E) -> Pow<Self, E>

where Self: Sized, E: Signal, Self::Type: Pow<E::Type>,

fn interpolate<F>(self, length: usize, interpolate: F) -> Interpolate<Self, F>

where Self: Sized, Self::Type: Float + FromPrimitive, F: FnMut(Self::Type, Self::Type, Self::Type) -> Self::Type,

Creates a signal that interpolates new values using the given interpolation function.