burn::module

Struct Param

pub struct Param<T>
where
    T: Parameter,
{
    pub id: ParamId,
    /* private fields */
}
Expand description

Parameters are the fundamental building blocks of modules where they serve as containers for tensors that can be updated during training, and loaded during inference. If you don’t want to save the tensors and/or don’t want to update it during training, you don’t need this type to wrap your tensor.

§Core Lazy Initialization Architecture

Param<T> has a dual-state design using OnceCell<T>:

§State Management

Two possible states:

  1. Initialized: state: OnceCell<T> contains value, initialization: None
  2. Uninitialized (Lazy): state is empty, initialization: Some(RwLock<Option<Uninitialized<T>>>)

Fields§

§id: ParamId

The unique ID of this parameter. This is used by eg. optimizers to associate a gradient with a specific parameter.

Implementations§

§

impl<T> Param<T>
where T: Parameter,

pub fn initialized(id: ParamId, value: T) -> Param<T>

Create a new parameter that is already initialized.

pub fn uninitialized<F>( id: ParamId, init: F, device: <T as Parameter>::Device, is_require_grad: bool, shape: Shape, ) -> Param<T>
where F: FnOnce(&<T as Parameter>::Device, bool) -> T + Send + 'static,

Create a new parameter that is not already initialized.

pub fn val(&self) -> T

Gets the parameter value, initializing it lazily if needed.

For initialized parameters, this returns a clone of the cached value. For uninitialized parameters, this triggers initialization:

pub fn is_initialized(&self) -> bool

Check if the parameter has been initialized.

Returns true if the parameter’s value has been computed and cached, false if it’s still lazy and will be initialized on first access.

pub fn into_value(self) -> T

Gets the parameter’s value while consuming the parameter.

pub fn consume(self) -> (ParamId, T, ParamMapper<T>)

Gets the parameter id and value while consuming the parameter.

pub fn map<F>(self, func: F) -> Param<T>
where F: FnOnce(T) -> T,

Execute the given function on the inner value.

pub fn from_mapped_value( id: ParamId, value: T, param_mapper: ParamMapper<T>, ) -> Param<T>

Create an initialized parameter with the given id, value, and param mapper.

This is a helper method for creating parameters while preserving the param mapper, typically used in ModuleMapper implementations.

pub fn load_mapper<F>(self, func: F) -> Param<T>
where F: Fn(T) -> T + Send + Sync + 'static,

Runs a transformation on the parameter when loading.

pub fn save_mapper<F>(self, func: F) -> Param<T>
where F: Fn(T) -> T + Send + Sync + 'static,

Runs a transformation on the parameter when saving.

pub fn init_mapper<F>(self, func: F) -> Param<T>
where F: FnOnce(T) -> T + Send + 'static, T: 'static,

Execute the given function on the inner value.

pub fn lazy_device(&self) -> <T as Parameter>::Device

The device on which the parameter is or will be initialized, without triggering initialization.

This is critical for the load optimization: when loading tensors into an uninitialized parameter, we need to know the target device to move the loaded tensor appropriately, but we don’t want to trigger the initialization function (which would allocate an unnecessary tensor).

Use this instead of crate::tensor::Tensor::device when you need the device but want to preserve lazy initialization.

pub fn set_require_grad(self, require_grad: bool) -> Param<T>

Override the gradient requirement for the current parameter.

§

impl<B, const D: usize> Param<Tensor<B, D>>
where B: Backend,

pub fn from_tensor(value: Tensor<B, D>) -> Param<Tensor<B, D>>

Create a new parameter from a float tensor.

§Warnings

We strongly recommend using Param::uninitialized if you are using this method to initialize parameters inside a module, since the tensor initialization will be lazy, making the loading of weights more performant.

pub fn lazy_shape(&self) -> Shape

The shape of the parameter, without triggering initialization.

This is critical for shape validation during loading: when applying tensors to an uninitialized parameter, we need to validate the shape without triggering the initialization function (which would allocate an unnecessary tensor).

Use this instead of crate::tensor::Tensor::shape when you need the shape but want to preserve lazy initialization.

pub fn from_data<T>( data: T, device: &<B as Backend>::Device, ) -> Param<Tensor<B, D>>
where T: Into<TensorData>,

Create a new parameter from data.

pub fn transform_for_load( self, tensor: Tensor<B, D>, param_id: ParamId, ) -> Param<Tensor<B, D>>

Transform a parameter for loading by applying load transformations.

This method is used to restore a parameter from a tensor (typically during deserialization). It ensures the tensor is moved to the expected device, applies the param mapper’s on_load transformation, and preserves the autodiff settings (require_grad).

pub fn transform_for_save(&self) -> Param<Tensor<B, D>>

Transform a parameter for saving by applying save transformations.

This method is used to prepare a parameter for saving (typically during serialization). It applies the param mapper’s on_save transformation, which can be used to modify the tensor before serialization (e.g., quantization, precision conversion).

§

impl<B, const D: usize> Param<Tensor<B, D, Int>>
where B: Backend,

pub fn lazy_shape(&self) -> Shape

The shape of the parameter, without triggering initialization.

This is critical for shape validation during loading: when applying tensors to an uninitialized parameter, we need to validate the shape without triggering the initialization function (which would allocate an unnecessary tensor).

Use this instead of crate::tensor::Tensor::shape when you need the shape but want to preserve lazy initialization.

pub fn transform_for_load( self, tensor: Tensor<B, D, Int>, param_id: ParamId, ) -> Param<Tensor<B, D, Int>>

Transform a parameter for loading by applying load transformations.

This method is used to restore a parameter from a tensor (typically during deserialization). It ensures the tensor is moved to the expected device and applies the param mapper’s on_load transformation.

pub fn transform_for_save(&self) -> Param<Tensor<B, D, Int>>

Transform a parameter for saving by applying save transformations.

This method is used to prepare a parameter for saving (typically during serialization). It applies the param mapper’s on_save transformation, which can be used to modify the tensor before serialization (e.g., quantization, precision conversion).

§

impl<B, const D: usize> Param<Tensor<B, D, Bool>>
where B: Backend,

pub fn lazy_shape(&self) -> Shape

The shape of the parameter, without triggering initialization.

This is critical for shape validation during loading: when applying tensors to an uninitialized parameter, we need to validate the shape without triggering the initialization function (which would allocate an unnecessary tensor).

Returns:

  • For uninitialized params: the shape from the Uninitialized struct
  • For initialized params: the actual shape from the tensor

Use this instead of crate::tensor::Tensor::shape when you need the shape but want to preserve lazy initialization.

pub fn transform_for_load( self, tensor: Tensor<B, D, Bool>, param_id: ParamId, ) -> Param<Tensor<B, D, Bool>>

Transform a parameter for loading by applying load transformations.

This method is used to restore a parameter from a tensor (typically during deserialization). It ensures the tensor is moved to the expected device and applies the param mapper’s on_load transformation.

pub fn transform_for_save(&self) -> Param<Tensor<B, D, Bool>>

Transform a parameter for saving by applying save transformations.

This method is used to prepare a parameter for saving (typically during serialization). It applies the param mapper’s on_save transformation, which can be used to modify the tensor before serialization (e.g., quantization, precision conversion).

Trait Implementations§

§

impl<const D: usize, B> AutodiffModule<B> for Param<Tensor<B, D>>
where B: AutodiffBackend,

§

type InnerModule = Param<Tensor<<B as AutodiffBackend>::InnerBackend, D>>

Inner module without auto-differentiation.
§

fn valid(&self) -> <Param<Tensor<B, D>> as AutodiffModule<B>>::InnerModule

Get the same module, but on the inner backend without auto-differentiation.
§

impl<const D: usize, B> AutodiffModule<B> for Param<Tensor<B, D, Bool>>
where B: AutodiffBackend,

§

type InnerModule = Param<Tensor<<B as AutodiffBackend>::InnerBackend, D, Bool>>

Inner module without auto-differentiation.
§

fn valid(&self) -> <Param<Tensor<B, D, Bool>> as AutodiffModule<B>>::InnerModule

Get the same module, but on the inner backend without auto-differentiation.
§

impl<const D: usize, B> AutodiffModule<B> for Param<Tensor<B, D, Int>>
where B: AutodiffBackend,

§

type InnerModule = Param<Tensor<<B as AutodiffBackend>::InnerBackend, D, Int>>

Inner module without auto-differentiation.
§

fn valid(&self) -> <Param<Tensor<B, D, Int>> as AutodiffModule<B>>::InnerModule

Get the same module, but on the inner backend without auto-differentiation.
§

impl<T> Clone for Param<T>
where T: Parameter,

§

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

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
§

impl<T> Debug for Param<T>
where T: Parameter,

§

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

Formats the value using the given formatter. Read more
§

impl<T> Deref for Param<T>
where T: Parameter,

§

type Target = T

The resulting type after dereferencing.
§

fn deref(&self) -> &<Param<T> as Deref>::Target

Dereferences the value.
§

impl<T> Display for Param<T>
where T: Parameter,

§

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

Formats the value using the given formatter. Read more
§

impl<const D: usize, B> Module<B> for Param<Tensor<B, D>>
where B: Backend,

§

type Record = Param<Tensor<B, D>>

Type to save and load the module.
§

fn visit<V>(&self, visitor: &mut V)
where V: ModuleVisitor<B>,

Visit each tensor parameter in the module with a visitor.
§

fn map<M>(self, mapper: &mut M) -> Param<Tensor<B, D>>
where M: ModuleMapper<B>,

Map each tensor parameter in the module with a mapper.
§

fn into_record(self) -> <Param<Tensor<B, D>> as Module<B>>::Record

Convert the module into a record containing the state.
§

fn load_record( self, record: <Param<Tensor<B, D>> as Module<B>>::Record, ) -> Param<Tensor<B, D>>

Load the module state from a record.
§

fn to_device(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D>>

Move the module and all of its sub-modules to the given device. Read more
§

fn fork(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D>>

Fork the module and all of its sub-modules to the given device. Read more
§

fn collect_devices( &self, devices: Vec<<B as Backend>::Device>, ) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree added to the given vector without duplicates.
§

fn devices(&self) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree without duplicates.
§

fn no_grad(self) -> Self

Each tensor in the module tree will not require grad. Read more
§

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules.
§

fn save_file<FR, PB>( self, file_path: PB, recorder: &FR, ) -> Result<(), RecorderError>
where FR: FileRecorder<B>, PB: Into<PathBuf>,

Save the module to a file using the provided file recorder. Read more
§

fn load_file<FR, PB>( self, file_path: PB, recorder: &FR, device: &<B as Backend>::Device, ) -> Result<Self, RecorderError>
where FR: FileRecorder<B>, PB: Into<PathBuf>,

Load the module from a file using the provided file recorder. Read more
§

fn quantize_weights(self, quantizer: &mut Quantizer) -> Self

Quantize the weights of the module.
§

impl<const D: usize, B> Module<B> for Param<Tensor<B, D, Bool>>
where B: Backend,

§

type Record = Param<Tensor<B, D, Bool>>

Type to save and load the module.
§

fn visit<V>(&self, visitor: &mut V)
where V: ModuleVisitor<B>,

Visit each tensor parameter in the module with a visitor.
§

fn map<M>(self, mapper: &mut M) -> Param<Tensor<B, D, Bool>>
where M: ModuleMapper<B>,

Map each tensor parameter in the module with a mapper.
§

fn into_record(self) -> <Param<Tensor<B, D, Bool>> as Module<B>>::Record

Convert the module into a record containing the state.
§

fn load_record( self, record: <Param<Tensor<B, D, Bool>> as Module<B>>::Record, ) -> Param<Tensor<B, D, Bool>>

Load the module state from a record.
§

fn to_device(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D, Bool>>

Move the module and all of its sub-modules to the given device. Read more
§

fn fork(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D, Bool>>

Fork the module and all of its sub-modules to the given device. Read more
§

fn collect_devices( &self, devices: Vec<<B as Backend>::Device>, ) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree added to the given vector without duplicates.
§

fn devices(&self) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree without duplicates.
§

fn no_grad(self) -> Self

Each tensor in the module tree will not require grad. Read more
§

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules.
§

fn save_file<FR, PB>( self, file_path: PB, recorder: &FR, ) -> Result<(), RecorderError>
where FR: FileRecorder<B>, PB: Into<PathBuf>,

Save the module to a file using the provided file recorder. Read more
§

fn load_file<FR, PB>( self, file_path: PB, recorder: &FR, device: &<B as Backend>::Device, ) -> Result<Self, RecorderError>
where FR: FileRecorder<B>, PB: Into<PathBuf>,

Load the module from a file using the provided file recorder. Read more
§

fn quantize_weights(self, quantizer: &mut Quantizer) -> Self

Quantize the weights of the module.
§

impl<const D: usize, B> Module<B> for Param<Tensor<B, D, Int>>
where B: Backend,

§

type Record = Param<Tensor<B, D, Int>>

Type to save and load the module.
§

fn visit<V>(&self, visitor: &mut V)
where V: ModuleVisitor<B>,

Visit each tensor parameter in the module with a visitor.
§

fn map<M>(self, mapper: &mut M) -> Param<Tensor<B, D, Int>>
where M: ModuleMapper<B>,

Map each tensor parameter in the module with a mapper.
§

fn into_record(self) -> <Param<Tensor<B, D, Int>> as Module<B>>::Record

Convert the module into a record containing the state.
§

fn load_record( self, record: <Param<Tensor<B, D, Int>> as Module<B>>::Record, ) -> Param<Tensor<B, D, Int>>

Load the module state from a record.
§

fn to_device(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D, Int>>

Move the module and all of its sub-modules to the given device. Read more
§

fn fork(self, device: &<B as Backend>::Device) -> Param<Tensor<B, D, Int>>

Fork the module and all of its sub-modules to the given device. Read more
§

fn collect_devices( &self, devices: Vec<<B as Backend>::Device>, ) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree added to the given vector without duplicates.
§

fn devices(&self) -> Vec<<B as Backend>::Device>

Return all the devices found in the underneath module tree without duplicates.
§

fn no_grad(self) -> Self

Each tensor in the module tree will not require grad. Read more
§

fn num_params(&self) -> usize

Get the number of parameters the module has, including all of its sub-modules.
§

fn save_file<FR, PB>( self, file_path: PB, recorder: &FR, ) -> Result<(), RecorderError>
where FR: FileRecorder<B>, PB: Into<PathBuf>,

Save the module to a file using the provided file recorder. Read more
§

fn load_file<FR, PB>( self, file_path: PB, recorder: &FR, device: &<B as Backend>::Device, ) -> Result<Self, RecorderError>
where FR: FileRecorder<B>, PB: Into<PathBuf>,

Load the module from a file using the provided file recorder. Read more
§

fn quantize_weights(self, quantizer: &mut Quantizer) -> Self

Quantize the weights of the module.
§

impl<const D: usize, B> ModuleDisplay for Param<Tensor<B, D>>
where B: Backend,

§

fn format(&self, passed_settings: DisplaySettings) -> String

Formats the module with provided display settings. Read more
§

fn custom_settings(&self) -> Option<DisplaySettings>

Custom display settings for the module. Read more
§

fn custom_content(&self, _content: Content) -> Option<Content>

Custom attributes for the module. Read more
§

impl<const D: usize, B> ModuleDisplay for Param<Tensor<B, D, Bool>>
where B: Backend,

§

fn format(&self, passed_settings: DisplaySettings) -> String

Formats the module with provided display settings. Read more
§

fn custom_settings(&self) -> Option<DisplaySettings>

Custom display settings for the module. Read more
§

fn custom_content(&self, _content: Content) -> Option<Content>

Custom attributes for the module. Read more
§

impl<const D: usize, B> ModuleDisplay for Param<Tensor<B, D, Int>>
where B: Backend,

§

fn format(&self, passed_settings: DisplaySettings) -> String

Formats the module with provided display settings. Read more
§

fn custom_settings(&self) -> Option<DisplaySettings>

Custom display settings for the module. Read more
§

fn custom_content(&self, _content: Content) -> Option<Content>

Custom attributes for the module. Read more
§

impl<const D: usize, B> ModuleDisplayDefault for Param<Tensor<B, D>>
where B: Backend,

§

fn content(&self, content: Content) -> Option<Content>

Attributes of the module used for display purposes. Read more
§

fn num_params(&self) -> usize

Gets the number of the parameters of the module.
§

impl<const D: usize, B> ModuleDisplayDefault for Param<Tensor<B, D, Bool>>
where B: Backend,

§

fn content(&self, content: Content) -> Option<Content>

Attributes of the module used for display purposes. Read more
§

fn num_params(&self) -> usize

Gets the number of the parameters of the module.
§

impl<const D: usize, B> ModuleDisplayDefault for Param<Tensor<B, D, Int>>
where B: Backend,

§

fn content(&self, content: Content) -> Option<Content>

Attributes of the module used for display purposes. Read more
§

fn num_params(&self) -> usize

Gets the number of the parameters of the module.
§

impl<B, const D: usize> Record<B> for Param<Tensor<B, D>>
where B: Backend,

§

type Item<S: PrecisionSettings> = ParamSerde<FloatTensorSerde<S>>

Type of the item that can be serialized and deserialized.
§

fn into_item<S>(self) -> <Param<Tensor<B, D>> as Record<B>>::Item<S>
where S: PrecisionSettings,

Convert the current record into the corresponding item that follows the given settings.
§

fn from_item<S>( item: <Param<Tensor<B, D>> as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> Param<Tensor<B, D>>
where S: PrecisionSettings,

Convert the given item into a record.
§

impl<B, const D: usize> Record<B> for Param<Tensor<B, D, Bool>>
where B: Backend,

§

type Item<S: PrecisionSettings> = ParamSerde<BoolTensorSerde>

Type of the item that can be serialized and deserialized.
§

fn into_item<S>(self) -> <Param<Tensor<B, D, Bool>> as Record<B>>::Item<S>
where S: PrecisionSettings,

Convert the current record into the corresponding item that follows the given settings.
§

fn from_item<S>( item: <Param<Tensor<B, D, Bool>> as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> Param<Tensor<B, D, Bool>>
where S: PrecisionSettings,

Convert the given item into a record.
§

impl<B, const D: usize> Record<B> for Param<Tensor<B, D, Int>>
where B: Backend,

§

type Item<S: PrecisionSettings> = ParamSerde<IntTensorSerde<S>>

Type of the item that can be serialized and deserialized.
§

fn into_item<S>(self) -> <Param<Tensor<B, D, Int>> as Record<B>>::Item<S>
where S: PrecisionSettings,

Convert the current record into the corresponding item that follows the given settings.
§

fn from_item<S>( item: <Param<Tensor<B, D, Int>> as Record<B>>::Item<S>, device: &<B as Backend>::Device, ) -> Param<Tensor<B, D, Int>>
where S: PrecisionSettings,

Convert the given item into a record.

Auto Trait Implementations§

§

impl<T> !Freeze for Param<T>

§

impl<T> !RefUnwindSafe for Param<T>

§

impl<T> Send for Param<T>
where <T as Parameter>::Device: Send,

§

impl<T> !Sync for Param<T>

§

impl<T> Unpin for Param<T>
where T: Unpin, <T as Parameter>::Device: Unpin,

§

impl<T> !UnwindSafe for Param<T>

Blanket Implementations§

§

impl<T> Adaptor<()> for T

§

fn adapt(&self)

Adapt the type to be passed to a metric.
Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

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

Source§

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

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

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

Source§

fn into(self) -> U

Calls U::from(self).

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

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
§

impl<T> ToCompactString for T
where T: Display,

§

fn try_to_compact_string(&self) -> Result<CompactString, ToCompactStringError>

Fallible version of [ToCompactString::to_compact_string()] Read more
§

fn to_compact_string(&self) -> CompactString

Converts the given value to a [CompactString]. Read more
§

impl<T> ToLine for T
where T: Display,

§

fn to_line(&self) -> Line<'_>

Converts the value to a [Line].
Source§

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

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

impl<T> ToSpan for T
where T: Display,

§

fn to_span(&self) -> Span<'_>

Converts the value to a [Span].
Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

fn to_string(&self) -> String

Converts the given value to a String. Read more
§

impl<T> ToText for T
where T: Display,

§

fn to_text(&self) -> Text<'_>

Converts the value to a [Text].
Source§

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

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
Source§

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

Source§

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

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> Formattable for T
where T: Deref, <T as Deref>::Target: Formattable,

§

impl<T> Parsable for T
where T: Deref, <T as Deref>::Target: Parsable,

§

impl<T> WasmNotSend for T
where T: Send,