Struct verified::vec::Vec

pub struct Vec<Size: Unsigned, Element>(_, _);

Implementations

impl<Element> Vec<U0, Element>

pub fn new() -> Self

impl<Size: Unsigned, Element> Vec<Size, Element>

pub fn append<OtherSize: Unsigned>(
    self,
    other: Vec<OtherSize, Element>
) -> Vec<<Size as Add<OtherSize>>::Output, Element> where
    <Size as Add<OtherSize>>::Output: Unsigned,
    <Size as Add<OtherSize>>::Output: Cmp,
    <Size as Add<OtherSize>>::Output: IsEqual<<Size as Add<OtherSize>>::Output>,
    Size: Add<OtherSize>, 

pub fn pop(self) -> (Vec<<Size as Sub<U1>>::Output, Element>, Element) where
    <Size as Sub<U1>>::Output: Unsigned,
    <Size as Sub<U1>>::Output: Cmp,
    <Size as Sub<U1>>::Output: IsEqual<<Size as Sub<U1>>::Output>,
    Size: Sub<U1>,
    Size: IsGreater<U0, Output = B1>,
    Size: Cmp<U0>,
    Size: IsGreaterOrEqual<U0>,
    Size: IsGreater<U0>, 

pub fn push(self, e: Element) -> Vec<<Size as Add<U1>>::Output, Element> where
    <Size as Add<U1>>::Output: Unsigned,
    <Size as Add<U1>>::Output: Cmp,
    <Size as Add<U1>>::Output: IsEqual<<Size as Add<U1>>::Output>,
    Size: Add<U1>, 

pub fn insert<Index: Unsigned>(
    self,
    _: Index,
    e: Element
) -> Vec<<Size as Add<U1>>::Output, Element> where
    <Size as Add<U1>>::Output: Unsigned,
    <Size as Add<U1>>::Output: Cmp,
    <Size as Add<U1>>::Output: IsEqual<<Size as Add<U1>>::Output>,
    Size: Add<U1>, 

pub fn remove<Index: Unsigned>(
    self,
    _: Index
) -> (Vec<<Size as Sub<U1>>::Output, Element>, Element) where
    <Size as Sub<U1>>::Output: Unsigned,
    <Size as Sub<U1>>::Output: Cmp,
    <Size as Sub<U1>>::Output: IsEqual<<Size as Sub<U1>>::Output>,
    Size: Sub<U1>,
    Size: IsGreater<U0, Output = B1>,
    Size: Cmp<U0>,
    Size: IsGreaterOrEqual<U0>,
    Size: IsGreater<U0>, 

pub fn truncate<NewSize: Unsigned>(self, _: NewSize) -> Vec<NewSize, Element> where
    NewSize: IsLess<Size, Output = B1>,
    NewSize: Cmp<Size>,
    NewSize: IsLessOrEqual<Size>,
    NewSize: IsLess<Size>, 

impl<Size: Unsigned, Element: Clone> Vec<Size, Element>

pub fn resize<NewSize: Unsigned>(
    self,
    _: NewSize,
    default: Element
) -> Vec<NewSize, Element>

Trait Implementations

impl<SizeL: Unsigned, SizeR: Unsigned, Element> Add<Vec<SizeR, Element>> for Vec<SizeL, Element> where
    <SizeL as Add<SizeR>>::Output: Unsigned,
    <SizeL as Add<SizeR>>::Output: Cmp,
    <SizeL as Add<SizeR>>::Output: IsEqual<<SizeL as Add<SizeR>>::Output>,
    SizeL: Add<SizeR>, 

type Output = Vec<<SizeL as Add<SizeR>>::Output, Element>

The resulting type after applying the + operator.

fn add(self, Vec: Vec<SizeR, Element>) -> Self::Output

Performs the + operation.

impl<Size: Clone + Unsigned, Element: Clone> Clone for Vec<Size, Element>

fn clone(&self) -> Vec<Size, Element>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Size: Debug + Unsigned, Element: Debug> Debug for Vec<Size, Element>

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

Formats the value using the given formatter.

impl<Size: Default + Unsigned, Element: Default> Default for Vec<Size, Element>

fn default() -> Vec<Size, Element>

Returns the "default value" for a type.

impl<Size: Eq + Unsigned, Element: Eq> Eq for Vec<Size, Element>

impl<Size: Unsigned, Element> From<(Vec<Size, Element>, Element)> for Vec<<Size as Add<U1>>::Output, Element> where
    <Size as Add<U1>>::Output: Unsigned,
    <Size as Add<U1>>::Output: Cmp,
    <Size as Add<U1>>::Output: IsEqual<<Size as Add<U1>>::Output>,
    Size: Add<U1>, 

fn from((Vec, e): (Vec<Size, Element>, Element)) -> Self

Performs the conversion.

impl<Size: Unsigned, Element> From<Vec<Size, Element>> for (Vec<<Size as Sub<U1>>::Output, Element>, Element) where
    <Size as Sub<U1>>::Output: Unsigned,
    <Size as Sub<U1>>::Output: Cmp,
    <Size as Sub<U1>>::Output: IsEqual<<Size as Sub<U1>>::Output>,
    Size: Sub<U1>,
    Size: IsGreater<U0, Output = B1>,
    Size: Cmp<U0>,
    Size: IsGreaterOrEqual<U0>,
    Size: IsGreater<U0>, 

fn from(Vec: Vec<Size, Element>) -> Self

Performs the conversion.

impl<Size: Unsigned, Element, I: Unsigned> Index<I> for Vec<Size, Element> where
    I: IsLess<Size, Output = B1>,
    I: Cmp<Size>,
    I: IsLessOrEqual<Size>,
    I: IsLess<Size>, 

type Output = Element

The returned type after indexing.

fn index(&self, _: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<Size: Unsigned, Element, I: Unsigned> IndexMut<I> for Vec<Size, Element> where
    I: IsLess<Size, Output = B1>,
    I: Cmp<Size>,
    I: IsLessOrEqual<Size>,
    I: IsLess<Size>, 

fn index_mut(&mut self, _: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<Size: Ord + Unsigned, Element: Ord> Ord for Vec<Size, Element>

fn cmp(&self, other: &Vec<Size, Element>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<Size: PartialEq + Unsigned, Element: PartialEq> PartialEq<Vec<Size, Element>> for Vec<Size, Element>

fn eq(&self, other: &Vec<Size, Element>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Vec<Size, Element>) -> bool

This method tests for !=.

impl<Size: PartialOrd + Unsigned, Element: PartialOrd> PartialOrd<Vec<Size, Element>> for Vec<Size, Element>

fn partial_cmp(&self, other: &Vec<Size, Element>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Vec<Size, Element>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Vec<Size, Element>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Vec<Size, Element>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Vec<Size, Element>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Size: Unsigned, Element> StructuralEq for Vec<Size, Element>

impl<Size: Unsigned, Element> StructuralPartialEq for Vec<Size, Element>

impl<Size: Unsigned, Element> TryFrom<Vec<Element>> for Vec<Size, Element>

type Error = String

The type returned in the event of a conversion error.

fn try_from(raw: Raw<Element>) -> Result<Self, Self::Error>

Performs the conversion.