Trait VecFromOtherType

pub trait VecFromOtherType<T>: Sized {
    // Required method
    fn vec_from_other_type(value: T) -> Vec<Self>;
}

Converts a slice of one type of value to a Vec of another type.

Required Methods

fn vec_from_other_type(value: T) -> Vec<Self>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl VecFromOtherType<u8> for u8

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u8> for u16

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u8> for u32

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u8> for u64

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u8> for u128

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u8> for usize

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for u8

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for u16

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for u32

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for u64

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for u128

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for usize

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for u8

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for u16

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for u32

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for u64

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for u128

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for usize

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a u32 to a Vec of usizes.

Worst-case complexity

Constant time and additional memory.

See here.

impl VecFromOtherType<u64> for u8

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u64> for u16

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u64> for u32

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u64> for u64

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u64> for u128

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u64> for usize

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a u64 to a Vec of usizes.

Worst-case complexity

Constant time and additional memory.

See here.

impl VecFromOtherType<u128> for u8

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u128> for u16

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u128> for u32

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u128> for u64

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u128> for u128

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u128> for usize

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<usize> for u8

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<usize> for u16

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<usize> for u32

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a usize to a Vec of u32s.

Worst-case complexity

Constant time and additional memory.

See here.

impl VecFromOtherType<usize> for u64

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a usize to a Vec of u64s.

Worst-case complexity

Constant time and additional memory.

See here.

impl VecFromOtherType<usize> for u128

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<usize> for usize

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Implementors