Struct Splat 

pub struct Splat<T> { /* private fields */ }

Splat argument.

This is a marker trait that is used as a wrapper around tuples of arguments allowing to invoke a function with multiple arguments as if it were a single argument. Its purpose is to make writing operators with multiple arguments more ergonomic, which is particularly useful for joins.

All function traits implement variations of Splat for tuples of up to 8 elements, which is likely to be sufficient for most use cases. Please note that most of the time, this type is only ever needed for creating flexible operator functions, so you’ll rarely want to use it directly. Additionally, note that Splat itself doesn’t impose any trait bounds in order to not require even more trait bounds in the signature of implementors. Moreover, it doesn’t implement Value, meaning it can only be used temporarily inside operators, but never returned.

Examples

use zrx_stream::function::Splat;

// Create splat from tuple
let splat = Splat::from((1, 2));

Implementations

impl<T> Splat<T>

pub fn inner(&self) -> &T

Returns the inner tuple of arguments.

Examples

use zrx_stream::function::Splat;

// Create splat from tuple
let splat = Splat::from((1, 2));
assert_eq!(splat.inner(), &(1, 2));

pub fn into_inner(self) -> T

Returns the inner tuple of arguments, consuming the splat.

Examples

use zrx_stream::function::Splat;

// Create splat from tuple
let splat = Splat::from((1, 2));
assert_eq!(splat.into_inner(), (1, 2));

impl<T> Splat<T>

pub fn from_ref(inner: &T) -> &Self

Creates a splat argument from a reference to a tuple.

This method converts &T to &Splat<T>, which allows us to use splat arguments in any function that takes a reference to a value T without cloning the value. While the conversion mandates the use of unsafe, it’s safe due to identical memory layout guarantees.

Examples

use zrx_stream::function::Splat;

// Create splat from tuple reference
let splat = Splat::from_ref(&(1, 2));

Trait Implementations

impl<T: Clone> Clone for Splat<T>

fn clone(&self) -> Splat<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Splat<T>

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

Formats the value using the given formatter.

impl<F, I, T1> FilterFn<I, Splat<(T1,)>> for F

where F: Fn(&T1) -> Result<bool> + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1,)>) -> Result<bool>

Executes the filter function.

impl<F, I, T1, T2> FilterFn<I, Splat<(T1, T2)>> for F

where F: Fn(&T1, &T2) -> Result<bool> + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1, T2)>) -> Result<bool>

Executes the filter function.

impl<F, I, T1, T2, T3> FilterFn<I, Splat<(T1, T2, T3)>> for F

where F: Fn(&T1, &T2, &T3) -> Result<bool> + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1, T2, T3)>) -> Result<bool>

Executes the filter function.

impl<F, I, T1, T2, T3, T4> FilterFn<I, Splat<(T1, T2, T3, T4)>> for F

where F: Fn(&T1, &T2, &T3, &T4) -> Result<bool> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4)>, ) -> Result<bool>

Executes the filter function.

impl<F, I, T1, T2, T3, T4, T5> FilterFn<I, Splat<(T1, T2, T3, T4, T5)>> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5) -> Result<bool> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5)>, ) -> Result<bool>

Executes the filter function.

impl<F, I, T1, T2, T3, T4, T5, T6> FilterFn<I, Splat<(T1, T2, T3, T4, T5, T6)>> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6) -> Result<bool> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6)>, ) -> Result<bool>

Executes the filter function.

impl<F, I, T1, T2, T3, T4, T5, T6, T7> FilterFn<I, Splat<(T1, T2, T3, T4, T5, T6, T7)>> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6, &T7) -> Result<bool> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6, T7)>, ) -> Result<bool>

Executes the filter function.

impl<F, I, T1, T2, T3, T4, T5, T6, T7, T8> FilterFn<I, Splat<(T1, T2, T3, T4, T5, T6, T7, T8)>> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6, &T7, &T8) -> Result<bool> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6, T7, T8)>, ) -> Result<bool>

Executes the filter function.

impl<F, I, T1, U> FilterMapFn<I, Splat<(T1,)>, U> for F

where F: Fn(&T1) -> Result<Option<U>> + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1,)>) -> Result<Option<U>>

Executes the filter map function.

impl<F, I, T1, T2, U> FilterMapFn<I, Splat<(T1, T2)>, U> for F

where F: Fn(&T1, &T2) -> Result<Option<U>> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2)>, ) -> Result<Option<U>>

Executes the filter map function.

impl<F, I, T1, T2, T3, U> FilterMapFn<I, Splat<(T1, T2, T3)>, U> for F

where F: Fn(&T1, &T2, &T3) -> Result<Option<U>> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3)>, ) -> Result<Option<U>>

Executes the filter map function.

impl<F, I, T1, T2, T3, T4, U> FilterMapFn<I, Splat<(T1, T2, T3, T4)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4) -> Result<Option<U>> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4)>, ) -> Result<Option<U>>

Executes the filter map function.

impl<F, I, T1, T2, T3, T4, T5, U> FilterMapFn<I, Splat<(T1, T2, T3, T4, T5)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5) -> Result<Option<U>> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5)>, ) -> Result<Option<U>>

Executes the filter map function.

impl<F, I, T1, T2, T3, T4, T5, T6, U> FilterMapFn<I, Splat<(T1, T2, T3, T4, T5, T6)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6) -> Result<Option<U>> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6)>, ) -> Result<Option<U>>

Executes the filter map function.

impl<F, I, T1, T2, T3, T4, T5, T6, T7, U> FilterMapFn<I, Splat<(T1, T2, T3, T4, T5, T6, T7)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6, &T7) -> Result<Option<U>> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6, T7)>, ) -> Result<Option<U>>

Executes the filter map function.

impl<F, I, T1, T2, T3, T4, T5, T6, T7, T8, U> FilterMapFn<I, Splat<(T1, T2, T3, T4, T5, T6, T7, T8)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6, &T7, &T8) -> Result<Option<U>> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6, T7, T8)>, ) -> Result<Option<U>>

Executes the filter map function.

impl<T> From<T> for Splat<T>

fn from(inner: T) -> Self

Creates a splat from a tuple of arguments.

Examples

use zrx_stream::function::Splat;

// Create splat from tuple
let splat = Splat::from((1, 2));

impl<F, I, T1, U> InspectFn<I, Splat<(T1,)>, U> for F

where F: Fn(&T1) -> Result + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1,)>) -> Result

Executes the inspect function.

impl<F, I, T1, T2, U> InspectFn<I, Splat<(T1, T2)>, U> for F

where F: Fn(&T1, &T2) -> Result + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1, T2)>) -> Result

Executes the inspect function.

impl<F, I, T1, T2, T3, U> InspectFn<I, Splat<(T1, T2, T3)>, U> for F

where F: Fn(&T1, &T2, &T3) -> Result + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1, T2, T3)>) -> Result

Executes the inspect function.

impl<F, I, T1, T2, T3, T4, U> InspectFn<I, Splat<(T1, T2, T3, T4)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4) -> Result + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4)>) -> Result

Executes the inspect function.

impl<F, I, T1, T2, T3, T4, T5, U> InspectFn<I, Splat<(T1, T2, T3, T4, T5)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5) -> Result + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5)>, ) -> Result

Executes the inspect function.

impl<F, I, T1, T2, T3, T4, T5, T6, U> InspectFn<I, Splat<(T1, T2, T3, T4, T5, T6)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6) -> Result + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6)>, ) -> Result

Executes the inspect function.

impl<F, I, T1, T2, T3, T4, T5, T6, T7, U> InspectFn<I, Splat<(T1, T2, T3, T4, T5, T6, T7)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6, &T7) -> Result + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6, T7)>, ) -> Result

Executes the inspect function.

impl<F, I, T1, T2, T3, T4, T5, T6, T7, T8, U> InspectFn<I, Splat<(T1, T2, T3, T4, T5, T6, T7, T8)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6, &T7, &T8) -> Result + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6, T7, T8)>, ) -> Result

Executes the inspect function.

impl<F, I, T1, U> MapFn<I, Splat<(T1,)>, U> for F

where F: Fn(&T1) -> Result<U> + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1,)>) -> Result<U>

Executes the map function.

impl<F, I, T1, T2, U> MapFn<I, Splat<(T1, T2)>, U> for F

where F: Fn(&T1, &T2) -> Result<U> + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1, T2)>) -> Result<U>

Executes the map function.

impl<F, I, T1, T2, T3, U> MapFn<I, Splat<(T1, T2, T3)>, U> for F

where F: Fn(&T1, &T2, &T3) -> Result<U> + Send + 'static, I: Display,

fn execute(&self, scope: &Scope<I>, value: &Splat<(T1, T2, T3)>) -> Result<U>

Executes the map function.

impl<F, I, T1, T2, T3, T4, U> MapFn<I, Splat<(T1, T2, T3, T4)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4) -> Result<U> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4)>, ) -> Result<U>

Executes the map function.

impl<F, I, T1, T2, T3, T4, T5, U> MapFn<I, Splat<(T1, T2, T3, T4, T5)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5) -> Result<U> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5)>, ) -> Result<U>

Executes the map function.

impl<F, I, T1, T2, T3, T4, T5, T6, U> MapFn<I, Splat<(T1, T2, T3, T4, T5, T6)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6) -> Result<U> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6)>, ) -> Result<U>

Executes the map function.

impl<F, I, T1, T2, T3, T4, T5, T6, T7, U> MapFn<I, Splat<(T1, T2, T3, T4, T5, T6, T7)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6, &T7) -> Result<U> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6, T7)>, ) -> Result<U>

Executes the map function.

impl<F, I, T1, T2, T3, T4, T5, T6, T7, T8, U> MapFn<I, Splat<(T1, T2, T3, T4, T5, T6, T7, T8)>, U> for F

where F: Fn(&T1, &T2, &T3, &T4, &T5, &T6, &T7, &T8) -> Result<U> + Send + 'static, I: Display,

fn execute( &self, scope: &Scope<I>, value: &Splat<(T1, T2, T3, T4, T5, T6, T7, T8)>, ) -> Result<U>

Executes the map function.

impl<T: Ord> Ord for Splat<T>

fn cmp(&self, other: &Splat<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<T: PartialEq> PartialEq for Splat<T>

fn eq(&self, other: &Splat<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<T: PartialOrd> PartialOrd for Splat<T>

fn partial_cmp(&self, other: &Splat<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<T: Eq> Eq for Splat<T>

impl<T> StructuralPartialEq for Splat<T>