Struct Tuple3 

#[repr(C)]
pub struct Tuple3<T1, T2, T3>(pub T1, pub T2, pub T3);

Tuple Fields

0: T1

1: T2

2: T3

Trait Implementations

impl<T1: Clone, T2: Clone, T3: Clone> Clone for Tuple3<T1, T2, T3>

fn clone(&self) -> Tuple3<T1, T2, T3>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T1, T2, T3> ConstructType for Tuple3<T1, T2, T3>

where T1: ConstructType, T2: ConstructType, T3: ConstructType,

type Static = Tuple3<<T1 as ConstructType>::Static, <T2 as ConstructType>::Static, <T3 as ConstructType>::Static>

Self, but with all lifetimes set to 'static. This ensures Self::Static has a type id.

fn construct_type_uncached<'target, Tgt>( target: Tgt, ) -> ValueData<'target, 'static, Tgt>

where Tgt: Target<'target>,

Constructs the type object associated with this type.

fn construct_type_with_env_uncached<'target, Tgt>( target: Tgt, env: &TypeVarEnv<'_>, ) -> ValueData<'target, 'static, Tgt>

where Tgt: Target<'target>,

Constructs the type object associated with this type.

fn base_type<'target, Tgt>(target: &Tgt) -> Option<Value<'target, 'static>>

where Tgt: Target<'target>,

Returns the base type object associated with this type.

const CACHEABLE: bool = true

Indicates whether the type might be cacheable.

fn type_id() -> TypeId

Returns the TypeId of Self::Static.

fn construct_type<'target, Tgt>(target: Tgt) -> ValueData<'target, 'static, Tgt>

where Tgt: Target<'target>,

Construct the type object and try to cache the result. If a cached entry is available, it is returned.

fn construct_type_with_env<'target, Tgt>( target: Tgt, env: &TypeVarEnv<'_>, ) -> ValueData<'target, 'static, Tgt>

where Tgt: Target<'target>,

Construct the type object with an environment of TypeVars and try to cache the result. If a cached entry is available, it is returned.

impl<T1, T2, T3> Copy for Tuple3<T1, T2, T3>

where T1: IntoJulia + Debug + Copy, T2: IntoJulia + Debug + Copy, T3: IntoJulia + Debug + Copy,

impl<T1: Debug, T2: Debug, T3: Debug> Debug for Tuple3<T1, T2, T3>

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

Formats the value using the given formatter.

impl<T1: Eq, T2: Eq, T3: Eq> Eq for Tuple3<T1, T2, T3>

impl<T1, T2, T3> IntoJulia for Tuple3<T1, T2, T3>

where T1: IntoJulia + ConstructType + Debug + Clone, T2: IntoJulia + ConstructType + Debug + Clone, T3: IntoJulia + ConstructType + Debug + Clone,

fn julia_type<'scope, Tgt>(target: Tgt) -> DataTypeData<'scope, Tgt>

where Tgt: Target<'scope>,

Returns the associated Julia type of the implementor.

impl<T1, T2, T3> IsBits for Tuple3<T1, T2, T3>

where T1: Clone + Debug + IsBits + ValidField, T2: Clone + Debug + IsBits + ValidField, T3: Clone + Debug + IsBits + ValidField,

impl<T1: PartialEq, T2: PartialEq, T3: PartialEq> PartialEq for Tuple3<T1, T2, T3>

fn eq(&self, other: &Tuple3<T1, T2, T3>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T1: PartialEq, T2: PartialEq, T3: PartialEq> StructuralPartialEq for Tuple3<T1, T2, T3>

impl<T1, T2, T3> Typecheck for Tuple3<T1, T2, T3>

where T1: ValidField + Clone + Debug, T2: ValidField + Clone + Debug, T3: ValidField + Clone + Debug,

fn typecheck(t: DataType<'_>) -> bool

Returns whether the property implied by Self holds true.

impl<T1, T2, T3> Unbox for Tuple3<T1, T2, T3>

where T1: ValidField + Clone + Debug, T2: ValidField + Clone + Debug, T3: ValidField + Clone + Debug,

type Output = Tuple3<T1, T2, T3>

The type of the unboxed data. Must be #[repr(C)].

unsafe fn unbox(value: Value<'_, '_>) -> Self::Output

Unbox the value as Self::Output.

impl<T1, T2, T3> ValidField for Tuple3<T1, T2, T3>

where T1: ValidField + Clone + Debug, T2: ValidField + Clone + Debug, T3: ValidField + Clone + Debug,

fn valid_field(v: Value<'_, '_>) -> bool

Returns true if Self is the correct representation for Julia data of type ty when it’s used as a field type.

impl<T1, T2, T3> ValidLayout for Tuple3<T1, T2, T3>

where T1: ValidField + Clone + Debug, T2: ValidField + Clone + Debug, T3: ValidField + Clone + Debug,

const IS_REF: bool = false

Must be true if the Rust type is a managed type.

fn valid_layout(v: Value<'_, '_>) -> bool

Check if the layout of the implementor is compatible with the layout of ty.

fn type_object<'target, Tgt>(_: &Tgt) -> Value<'target, 'static>

where Tgt: Target<'target>,

Returns the type object this layout is associated with.