jcoglan/rust-types.md

## rust-types.md

      
    Raw
  

              rust-types.md
            
          
    Rust types reference

Prelude


std::borrow::ToOwned
std::boxed::Box
std::clone::Clone
std::cmp::{PartialEq, PartialOrd, Eq, Ord}
std::convert::{AsRef, AsMut, Into, From}
std::default::Default
std::iter::{Iterator, Extend, IntoIterator, DoubleEndedIterator, ExactSizeIterator}
std::marker::{Copy, Send, Sized, Sync, Unpin}
std::mem::drop
std::ops::{Drop, Fn, FnMut, FnOnce}
std::option::Option::{self, Some, None}
std::result::Result::{self, Ok, Err}
std::slice::SliceConcatExt
std::string::{String, ToString}
std::vec::Vec

std::any::Any

trait Any: 'static

Requires:

type_id(&self) -> TypeId

Provides:


downcast_ref<T>(&self) -> Option<&T> where T: Any


is<T>(&self) -> bool where T: Any


downcast_mut<T>(&mut self) -> Option<&mut T> where T: Any


Implements:

impl Debug for dyn Any + 'static + Send + Sync
impl Debug for dyn Any + 'static + Send
impl Debug for dyn Any + 'static

std::any::TypeId

Methods:

of<T>() -> TypeId where T: 'static + ?Sized

Implements:

impl Clone for TypeId
impl Copy for TypeId
impl Debug for TypeId
impl Eq for TypeId
impl Hash for TypeId
impl Ord for TypeId
impl PartialEq<TypeId> for TypeId
impl PartialOrd<TypeId> for TypeId
impl Send for TypeId
impl Sync for TypeId

std::borrow::Borrow

trait Borrow<Borrowed>
where
    Borrowed: ?Sized

Requires:

borrow(&self) -> &Borrowed

std::borrow::ToOwned (prelude)

trait ToOwned {
    type Owned: Borrow<Self>;
}

Requires:

to_owned(&self) -> Self::Owned

Provides:

clone_into(&self, target: &mut Self::Owned)

std::boxed::Box (prelude)

struct Box<T>(_)
where
    T: ?Sized

Methods:


from_raw(raw: *mut T) -> Box<T>


new(x: T) -> Box<T>


pin(x: T) -> Pin<Box<T>>


into_pin(boxed: Box<T>) -> Pin<Box<T>>


into_raw(b: Box<T>) -> *mut T


into_raw_non_null(b: Box<T>) -> NonNull<T>


leak<'a>(b: Box<T>) -> &'a mut T where T: 'a


downcast<T>(self) -> Result<Box<T>, Box<dyn Any + 'static + Send>> where T: Any


downcast<T>(self) -> Result<Box<T>, Box<dyn Any + 'static>> where T: Any


Implements:

impl Clone for Box<CStr>
impl Clone for Box<OsStr>
impl Clone for Box<Path>
impl Clone for Box<str>
impl Default for Box<CStr>
impl Default for Box<OsStr>
impl Default for Box<str>
impl From<Box<CStr>> for CString
impl From<Box<OsStr>> for OsString
impl From<Box<Path>> for PathBuf
impl From<Box<str>> for Box<[u8]>
impl From<Box<str>> for String
impl From<CString> for Box<CStr>
impl From<OsString> for Box<OsStr>
impl From<PathBuf> for Box<Path>
impl From<String> for Box<dyn Error + Send + Sync>
impl From<String> for Box<dyn Error>
impl From<String> for Box<str>
impl<'_, A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + '_ + Send>
impl<'_, A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + '_>
impl<'a, 'b> From<&'b str> for Box<dyn Error + Send + Sync + 'a>
impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>
impl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a>
impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a>
impl<'a, T> From<&'a [T]> for Box<[T]> where T: Copy
impl<'a> From<&'a CStr> for Box<CStr>
impl<'a> From<&'a OsStr> for Box<OsStr>
impl<'a> From<&'a Path> for Box<Path>
impl<'a> From<&'a str> for Box<dyn Error>
impl<'a> From<&'a str> for Box<str>
impl<'a> From<Cow<'a, str>> for Box<dyn Error>
impl<A> FromIterator<A> for Box<[A]>
impl<B: BufRead + ?Sized> BufRead for Box<B>
impl<F> Future for Box<F> where F: Unpin + Future + ?Sized
impl<G> Generator for Box<G> where G: Unpin + Generator + ?Sized
impl<I> DoubleEndedIterator for Box<I> where I: DoubleEndedIterator + ?Sized
impl<I> ExactSizeIterator for Box<I> where I: ExactSizeIterator + ?Sized
impl<I> FusedIterator for Box<I> where I: FusedIterator + ?Sized
impl<I> Iterator for Box<I> where I: Iterator + ?Sized
impl<R: Read + ?Sized> Read for Box<R>
impl<S: Seek + ?Sized> Seek for Box<S>
impl<T, U> CoerceUnsized<Box<U>> for Box<T> where T: Unsize<U> + ?Sized, U: ?Sized
impl<T, U> DispatchFromDyn<Box<U>> for Box<T> where T: Unsize<U> + ?Sized, U: ?Sized
impl<T: ?Sized> Send for Box<T> where T: Send
impl<T: ?Sized> Sync for Box<T> where T: Sync
impl<T: Error> Error for Box<T>
impl<T> AsMut<T> for Box<T> where T: ?Sized
impl<T> AsRef<T> for Box<T> where T: ?Sized
impl<T> Borrow<T> for Box<T> where T: ?Sized
impl<T> BorrowMut<T> for Box<T> where T: ?Sized
impl<T> Clone for Box<T> where T: Clone
impl<T> Clone for Box<[T]> where T: Clone
impl<T> Debug for Box<T> where T: Debug + ?Sized
impl<T> Default for Box<T> where T: Default
impl<T> Default for Box<[T]>
impl<T> Deref for Box<T> where T: ?Sized
impl<T> DerefMut for Box<T> where T: ?Sized
impl<T> Display for Box<T> where T: Display + ?Sized
impl<T> Drop for Box<T> where T: ?Sized
impl<T> Eq for Box<T> where T: Eq + ?Sized
impl<T> From<Box<T>> for Arc<T> where T: ?Sized
impl<T> From<Box<T>> for Pin<Box<T>> where T: ?Sized
impl<T> From<Box<T>> for Rc<T> where T: ?Sized
impl<T> From<Box<[T]>> for Vec<T>
impl<T> From<T> for Box<T>
impl<T> From<Vec<T>> for Box<[T]>
impl<T> Hash for Box<T> where T: Hash + ?Sized
impl<T> Hasher for Box<T> where T: Hasher + ?Sized
impl<T> Ord for Box<T> where T: Ord + ?Sized
impl<T> PartialEq<Box<T>> for Box<T> where T: PartialEq<T> + ?Sized
impl<T> PartialOrd<Box<T>> for Box<T> where T: PartialOrd<T> + ?Sized
impl<T> Pointer for Box<T> where T: ?Sized
impl<T> Unpin for Box<T> where T: ?Sized
impl<W: Write + ?Sized> Write for Box<W>

std::cell::RefCell

struct RefCell<T>
where
    T: ?Sized

Methods:


new(value: T) -> RefCell<T>


as_ptr(&self) -> *mut T


borrow(&self) -> Ref<T>


borrow_mut(&self) -> RefMut<T>


replace(&self, t: T) -> T


replace_with<F>(&self, f: F) -> T where F: FnOnce(&mut T) -> T


swap(&self, other: &RefCell<T>)


try_borrow(&self) -> Result<Ref<T>, BorrowError>


try_borrow_mut(&self) -> Result<RefMut<T>, BorrowMutError>


get_mut(&mut self) -> &mut T


into_inner(self) -> T


Implements:

impl<T, U> CoerceUnsized<RefCell<U>> for RefCell<T> where T: CoerceUnsized<U>
impl<T> !Sync for RefCell<T> where T: ?Sized
impl<T> Clone for RefCell<T> where T: Clone
impl<T> Debug for RefCell<T> where T: Debug + ?Sized
impl<T> Default for RefCell<T> where T: Default
impl<T> Eq for RefCell<T> where T: Eq + ?Sized
impl<T> From<T> for RefCell<T>
impl<T> Ord for RefCell<T> where T: Ord + ?Sized
impl<T> PartialEq<RefCell<T>> for RefCell<T> where T: PartialEq<T> + ?Sized
impl<T> PartialOrd<RefCell<T>> for RefCell<T> where T: PartialOrd<T> + ?Sized
impl<T> RefCell<T> where T: ?Sized
impl<T> RefCell<T>
impl<T> Send for RefCell<T> where T: Send + ?Sized

std::cell::Ref

struct Ref<'b, T>
where
    T: 'b + 'b + ?Sized

Methods:

clone(orig: &Ref<'b, T>) -> Ref<'b, T>
map<U, F>(orig: Ref<'b, T>, f: F) -> Ref<'b, U> where F: FnOnce(&T) -> &U, U: ?Sized
map_split<U, V, F>(orig: Ref<'b, T>, f: F) -> (Ref<'b, U>, Ref<'b, V>) where F: FnOnce(&T) -> (&U, &V), U: ?Sized, V: ?Sized

Implements:

impl<'_, T> Debug for Ref<'_, T> where T: Debug + ?Sized
impl<'_, T> Deref for Ref<'_, T> where T: ?Sized
impl<'_, T> Display for Ref<'_, T> where T: Display + ?Sized
impl<'b, T, U> CoerceUnsized<Ref<'b, U>> for Ref<'b, T> where T: Unsize<U> + ?Sized, U: ?Sized
impl<'b, T> !Send for Ref<'b, T>
impl<'b, T> !Sync for Ref<'b, T>
impl<'b, T> Ref<'b, T> where T: ?Sized

std::cell::RefMut

struct RefMut<'b, T>
where
    T: 'b + 'b + ?Sized

Methods:

map<U, F>(orig: RefMut<'b, T>, f: F) -> RefMut<'b, U> where F: FnOnce(&mut T) -> &mut U, U: ?Sized
map_split<U, V, F>( orig: RefMut<'b, T>, f: F ) -> (RefMut<'b, U>, RefMut<'b, V>) where F: FnOnce(&mut T) -> (&mut U, &mut V), U: ?Sized, V: ?Sized

Implements:

impl<'_, T> Debug for RefMut<'_, T> where T: Debug + ?Sized
impl<'_, T> Deref for RefMut<'_, T> where T: ?Sized
impl<'_, T> DerefMut for RefMut<'_, T> where T: ?Sized
impl<'_, T> Display for RefMut<'_, T> where T: Display + ?Sized
impl<'b, T, U> CoerceUnsized<RefMut<'b, U>> for RefMut<'b, T> where T: Unsize<U> + ?Sized, U: ?Sized
impl<'b, T> !Send for RefMut<'b, T>
impl<'b, T> !Sync for RefMut<'b, T>
impl<'b, T> RefMut<'b, T> where T: ?Sized

std::clone::Clone (prelude)

trait Clone

Requires:

clone(&self) -> Self

Provides:

clone_from(&mut self, source: &Self)

std::cmp::Eq (prelude)

trait Eq: PartialEq<Self>

std::cmp::Ord (prelude)

trait Ord: Eq + PartialOrd<Self>

Requires:

cmp(&self, other: &Self) -> Ordering

Provides:

max(self, other: Self) -> Self
min(self, other: Self) -> Self

std::cmp::Ordering

enum Ordering {
    Less,
    Equal,
    Greater,
}

Methods:

reverse(self) -> Ordering
then(self, other: Ordering) -> Ordering
then_with<F>(self, f: F) -> Ordering where F: FnOnce() -> Ordering

Implements:

impl Clone for Ordering
impl Copy for Ordering
impl Debug for Ordering
impl Eq for Ordering
impl Hash for Ordering
impl Ord for Ordering
impl Ordering
impl PartialEq<Ordering> for Ordering
impl PartialOrd<Ordering> for Ordering
impl Send for Ordering
impl Sync for Ordering

std::cmp::PartialEq (prelude)

trait PartialEq<Rhs = Self>
where
    Rhs: ?Sized

Requires:

eq(&self, other: &Rhs) -> bool

Provides:

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

std::cmp::PartialOrd (prelude)

trait PartialOrd<Rhs = Self>: PartialEq<Rhs>
where
    Rhs: ?Sized

Requires:

partial_cmp(&self, other: &Rhs) -> Option<Ordering>

Provides:

ge(&self, other: &Rhs) -> bool
gt(&self, other: &Rhs) -> bool
le(&self, other: &Rhs) -> bool
lt(&self, other: &Rhs) -> bool

std::convert::AsMut (prelude)

trait AsMut<T>
where
    T: ?Sized

Requires:

as_mut(&mut self) -> &mut T

std::convert::AsRef (prelude)

trait AsRef<T>
where
    T: ?Sized

Requires:

as_ref(&self) -> &T

std::convert::From (prelude)

trait From<T>

Requires:

from(T) -> Self

std::convert::Into (prelude)

trait Into<T>

Requires:

into(self) -> T

std::default::Default (prelude)

trait Default

Requires:

default() -> Self

std::iter::DoubleEndedIterator (prelude)

trait DoubleEndedIterator: Iterator

Requires:

next_back(&mut self) -> Option<Self::Item>

Provides:


nth_back(&mut self, n: usize) -> Option<Self::Item>


rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool


try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, Self::Item) -> R, R: Try<Ok = B>


rfold<B, F>(self, accum: B, f: F) -> B where F: FnMut(B, Self::Item) -> B


std::iter::ExactSizeIterator (prelude)

trait ExactSizeIterator: Iterator

Provides:

is_empty(&self) -> bool
len(&self) -> usize

std::iter::Extend (prelude)

trait Extend<A>

Requires:

extend<T>(&mut self, iter: T) where T: IntoIterator<Item = A>

std::iter::IntoIterator (prelude)

trait IntoIterator
where
    <Self::IntoIter as Iterator>::Item == Self::Item
{
    type Item;
    type IntoIter: Iterator;
}

Requires:

into_iter(self) -> Self::IntoIter

std::iter::Iterator (prelude)

trait Iterator {
    type Item;
}

Requires:

next(&mut self) -> Option<Self::Item>

Provides:


size_hint(&self) -> (usize, Option<usize>)


all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool


any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool


by_ref(&mut self) -> &mut Self


find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool


find_map<B, F>(&mut self, f: F) -> Option<B> where F: FnMut(Self::Item) -> Option<B>


nth(&mut self, n: usize) -> Option<Self::Item>


position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool


rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator


try_fold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, Self::Item) -> R, R: Try<Ok = B>


try_for_each<F, R>(&mut self, f: F) -> R where F: FnMut(Self::Item) -> R, R: Try<Ok = ()>


chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where U: IntoIterator<Item = Self::Item>


cloned<'a, T>(self) -> Cloned<Self> where Self: Iterator<Item = &'a T>, T: 'a + Clone


cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item = Self::Item>, Self::Item: Ord


collect<B>(self) -> B where B: FromIterator<Self::Item>


copied<'a, T>(self) -> Copied<Self> where Self: Iterator<Item = &'a T>, T: 'a + Copy


count(self) -> usize


cycle(self) -> Cycle<Self> where Self: Clone


enumerate(self) -> Enumerate<Self>


eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>


filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool


filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>


flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator


flatten(self) -> Flatten<Self> where Self::Item: IntoIterator


fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B


for_each<F>(self, f: F) where F: FnMut(Self::Item)


fuse(self) -> Fuse<Self>


ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>


gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>


inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item)


is_sorted(self) -> bool where Self::Item: PartialOrd<Self::Item>


is_sorted_by<F>(self, compare: F) -> bool where F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>


is_sorted_by_key<F, K>(self, f: F) -> bool where F: FnMut(&Self::Item) -> K, K: PartialOrd<K>


last(self) -> Option<Self::Item>


le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>


lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>


map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B


max(self) -> Option<Self::Item> where Self::Item: Ord


max_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering


max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B


min(self) -> Option<Self::Item> where Self::Item: Ord


min_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering


min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B


ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>


partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>


partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool


peekable(self) -> Peekable<Self>


product<P>(self) -> P where P: Product<Self::Item>


rev(self) -> Rev<Self> where Self: DoubleEndedIterator


scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>


skip(self, n: usize) -> Skip<Self>


skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool


step_by(self, step: usize) -> StepBy<Self>


sum<S>(self) -> S where S: Sum<Self::Item>


take(self, n: usize) -> Take<Self>


take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool


unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Iterator<Item = (A, B)>


zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where U: IntoIterator


std::option::Option (prelude)

enum Option<T> {
    Some(T),
    None,
}

Methods:


as_ref(&self) -> Option<&T>


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


is_none(&self) -> bool


is_some(&self) -> bool


iter(&self) -> Iter<T>


as_mut(&mut self) -> Option<&mut T>


get_or_insert(&mut self, v: T) -> &mut T


get_or_insert_with<F>(&mut self, f: F) -> &mut T where F: FnOnce() -> T


iter_mut(&mut self) -> IterMut<T>


replace(&mut self, value: T) -> Option<T>


take(&mut self) -> Option<T>


and<U>(self, optb: Option<U>) -> Option<U>


and_then<U, F>(self, f: F) -> Option<U> where F: FnOnce(T) -> Option<U>


as_pin_mut(self: Pin<&'a mut Option<T>>) -> Option<Pin<&'a mut T>>


as_pin_ref(self: Pin<&'a Option<T>>) -> Option<Pin<&'a T>>


cloned(self) -> Option<T>


copied(self) -> Option<T>


expect(self, msg: &str) -> T


filter<P>(self, predicate: P) -> Option<T> where P: FnOnce(&T) -> bool


map<U, F>(self, f: F) -> Option<U> where F: FnOnce(T) -> U


map_or<U, F>(self, default: U, f: F) -> U where F: FnOnce(T) -> U


map_or_else<U, D, F>(self, default: D, f: F) -> U where D: FnOnce() -> U, F: FnOnce(T) -> U


ok_or<E>(self, err: E) -> Result<T, E>


ok_or_else<E, F>(self, err: F) -> Result<T, E> where F: FnOnce() -> E


or(self, optb: Option<T>) -> Option<T>


or_else<F>(self, f: F) -> Option<T> where F: FnOnce() -> Option<T>


transpose(self) -> Result<Option<T>, E>


unwrap(self) -> T


unwrap_or(self, def: T) -> T


unwrap_or_default(self) -> T


unwrap_or_else<F>(self, f: F) -> T where F: FnOnce() -> T


xor(self, optb: Option<T>) -> Option<T>


Implements:

impl<'_, T> Option<&'_ T> where T: Clone
impl<'_, T> Option<&'_ T> where T: Copy
impl<'_, T> Option<&'_ mut T> where T: Clone
impl<'_, T> Option<&'_ mut T> where T: Copy
impl<'a, T> From<&'a Option<T>> for Option<&'a T>
impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T>
impl<'a, T> IntoIterator for &'a Option<T>
impl<'a, T> IntoIterator for &'a mut Option<T>
impl<A, V> FromIterator<Option<A>> for Option<V> where V: FromIterator<A>
impl<T, E> Option<Result<T, E>>
impl<T> Clone for Option<T> where T: Clone
impl<T> Copy for Option<T> where T: Copy
impl<T> Debug for Option<T> where T: Debug
impl<T> Default for Option<T>
impl<T> Eq for Option<T> where T: Eq
impl<T> From<T> for Option<T>
impl<T> Hash for Option<T> where T: Hash
impl<T> IntoIterator for Option<T>
impl<T> Option<T> where T: Default
impl<T> Option<T> where T: Deref
impl<T> Option<T>
impl<T> Ord for Option<T> where T: Ord
impl<T> PartialEq<Option<T>> for Option<T> where T: PartialEq<T>
impl<T> PartialOrd<Option<T>> for Option<T> where T: PartialOrd<T>
impl<T> Send for Option<T> where T: Send
impl<T> Sync for Option<T> where T: Sync
impl<T> Try for Option<T>

std::result::Result (prelude)

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Methods:


as_ref(&self) -> Result<&T, &E>


deref(&self) -> Result<&<T as Deref>::Target, &<E as Deref>::Target>


deref_err(&self) -> Result<&T, &<E as Deref>::Target>


deref_ok(&self) -> Result<&<T as Deref>::Target, &E>


is_err(&self) -> bool


is_ok(&self) -> bool


iter(&self) -> Iter<T>


as_mut(&mut self) -> Result<&mut T, &mut E>


iter_mut(&mut self) -> IterMut<T>


and<U>(self, res: Result<U, E>) -> Result<U, E>


and_then<U, F>(self, op: F) -> Result<U, E> where F: FnOnce(T) -> Result<U, E>


err(self) -> Option<E>


expect(self, msg: &str) -> T


expect_err(self, msg: &str) -> E


map<U, F>(self, op: F) -> Result<U, E> where F: FnOnce(T) -> U


map_err<F, O>(self, op: O) -> Result<T, F> where O: FnOnce(E) -> F


map_or_else<U, M, F>(self, fallback: F, map: M) -> U where F: FnOnce(E) -> U, M: FnOnce(T) -> U


ok(self) -> Option<T>


or<F>(self, res: Result<T, F>) -> Result<T, F>


or_else<F, O>(self, op: O) -> Result<T, F> where O: FnOnce(E) -> Result<T, F>


transpose(self) -> Option<Result<T, E>>


unwrap(self) -> T


unwrap_err(self) -> E


unwrap_or(self, optb: T) -> T


unwrap_or_default(self) -> T


unwrap_or_else<F>(self, op: F) -> T where F: FnOnce(E) -> T


Implements:

impl<'a, T, E> IntoIterator for &'a Result<T, E>
impl<'a, T, E> IntoIterator for &'a mut Result<T, E>
impl<A, E, V> FromIterator<Result<A, E>> for Result<V, E> where V: FromIterator<A>
impl<E: Debug> Termination for Result<!, E>
impl<E: Debug> Termination for Result<(), E>
impl<T, E> Clone for Result<T, E> where E: Clone, T: Clone
impl<T, E> Copy for Result<T, E> where E: Copy, T: Copy
impl<T, E> Debug for Result<T, E> where E: Debug, T: Debug
impl<T, E> Eq for Result<T, E> where E: Eq, T: Eq
impl<T, E> Hash for Result<T, E> where E: Hash, T: Hash
impl<T, E> IntoIterator for Result<T, E>
impl<T, E> Ord for Result<T, E> where E: Ord, T: Ord
impl<T, E> PartialEq<Result<T, E>> for Result<T, E> where E: PartialEq<E>, T: PartialEq<T>
impl<T, E> PartialOrd<Result<T, E>> for Result<T, E> where E: PartialOrd<E>, T: PartialOrd<T>
impl<T, E> Result<Option<T>, E>
impl<T, E> Result<T, E> where E: Debug
impl<T, E> Result<T, E> where E: Deref, T: Deref
impl<T, E> Result<T, E> where E: Deref
impl<T, E> Result<T, E> where T: Debug
impl<T, E> Result<T, E> where T: Default
impl<T, E> Result<T, E> where T: Deref
impl<T, E> Result<T, E>
impl<T, E> Send for Result<T, E> where E: Send, T: Send
impl<T, E> Sync for Result<T, E> where E: Sync, T: Sync
impl<T, E> Try for Result<T, E>
impl<T, U, E> Product<Result<U, E>> for Result<T, E> where T: Product<U>
impl<T, U, E> Sum<Result<U, E>> for Result<T, E> where T: Sum<U>

std::ops::Deref

trait Deref {
    type Target: ?Sized;
}

Requires:

deref(&self) -> &Self::Target

std::ops::Drop (prelude)

trait Drop

Requires:

drop(&mut self)

std::ops::Fn (prelude)

trait Fn<Args>: FnMut<Args>

Requires:

call(&self, args: Args) -> Self::Output

std::ops::FnMut (prelude)

trait FnMut<Args>: FnOnce<Args>

Requires:

call_mut(&mut self, args: Args) -> Self::Output

std::ops::FnOnce (prelude)

trait FnOnce<Args> {
    type Output;
}

Requires:

call_once(self, args: Args) -> Self::Output

std::pin::Pin

struct Pin<P> { /* ... */ }

Methods:


new(pointer: P) -> Pin<P>


new_unchecked(pointer: P) -> Pin<P>


as_ref(&self) -> Pin<&<P as Deref>::Target>


as_mut(&mut self) -> Pin<&mut <P as Deref>::Target>


set(&mut self, value: <P as Deref>::Target) where <P as Deref>::Target: Sized


get_mut(self) -> &'a mut T where T: Unpin


get_ref(self) -> &'a T


into_ref(self) -> Pin<&'a T>


get_unchecked_mut(self) -> &'a mut T


map_unchecked<U, F>(self, func: F) -> Pin<&'a U> where F: FnOnce(&T) -> &U


map_unchecked_mut<U, F>(self, func: F) -> Pin<&'a mut U> where F: FnOnce(&mut T) -> &mut U


Implements:

impl<'_, G> Generator for Pin<&'_ mut G> where G: Generator + ?Sized
impl<'a, P, U> DispatchFromDyn<Pin<U>> for Pin<P> where P: DispatchFromDyn<U>
impl<G> Generator for Pin<Box<G>> where G: Generator + ?Sized
impl<P, Q> PartialEq<Pin<Q>> for Pin<P> where P: PartialEq<Q>
impl<P, Q> PartialOrd<Pin<Q>> for Pin<P> where P: PartialOrd<Q>
impl<P, U> CoerceUnsized<Pin<U>> for Pin<P> where P: CoerceUnsized<U>
impl<P> Clone for Pin<P> where P: Clone
impl<P> Copy for Pin<P> where P: Copy
impl<P> Debug for Pin<P> where P: Debug
impl<P> Deref for Pin<P> where P: Deref
impl<P> DerefMut for Pin<P> where P: DerefMut, <P as Deref>::Target: Unpin
impl<P> Display for Pin<P> where P: Display
impl<P> Eq for Pin<P> where P: Eq
impl<P> Future for Pin<P> where P: Unpin + DerefMut, <P as Deref>::Target: Future
impl<P> Hash for Pin<P> where P: Hash
impl<P> Ord for Pin<P> where P: Ord
impl<P> Pointer for Pin<P> where P: Pointer
impl<P> Send for Pin<P> where P: Send
impl<P> Sync for Pin<P> where P: Sync
impl<T> From<Box<T>> for Pin<Box<T>> where T: ?Sized

std::ptr::NonNull

struct NonNull<T>
where
    T: ?Sized

Methods:


new_unchecked(ptr: *mut T) -> NonNull<T>


dangling() -> NonNull<T>


new(ptr: *mut T) -> Option<NonNull<T>>


as_ref(&self) -> &T


as_mut(&mut self) -> &mut T


as_ptr(self) -> *mut T


cast<U>(self) -> NonNull<U>


Implements:

impl<'a, T> From<&'a T> for NonNull<T> where T: ?Sized
impl<'a, T> From<&'a mut T> for NonNull<T> where T: ?Sized
impl<T, U> CoerceUnsized<NonNull<U>> for NonNull<T> where T: Unsize<U> + ?Sized, U: ?Sized
impl<T, U> DispatchFromDyn<NonNull<U>> for NonNull<T> where T: Unsize<U> + ?Sized, U: ?Sized
impl<T: RefUnwindSafe + ?Sized> UnwindSafe for NonNull<T>
impl<T> !Send for NonNull<T> where T: ?Sized
impl<T> !Sync for NonNull<T> where T: ?Sized
impl<T> Clone for NonNull<T> where T: ?Sized
impl<T> Copy for NonNull<T> where T: ?Sized
impl<T> Debug for NonNull<T> where T: ?Sized
impl<T> Eq for NonNull<T> where T: ?Sized
impl<T> From<Unique<T>> for NonNull<T> where T: ?Sized
impl<T> Hash for NonNull<T> where T: ?Sized
impl<T> Ord for NonNull<T> where T: ?Sized
impl<T> PartialEq<NonNull<T>> for NonNull<T> where T: ?Sized
impl<T> PartialOrd<NonNull<T>> for NonNull<T> where T: ?Sized
impl<T> Pointer for NonNull<T> where T: ?Sized

std::string::String (prelude)

struct String

Methods:


from_raw_parts( buf: *mut u8, length: usize, capacity: usize ) -> String


from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>


from_utf16_lossy(v: &[u16]) -> String


from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>


from_utf8_lossy(v: &'a [u8]) -> Cow<'a, str>


from_utf8_unchecked(bytes: Vec<u8>) -> String


new() -> String


with_capacity(capacity: usize) -> String


as_bytes(&self) -> &[u8]


as_ptr(&self) -> *const u8


as_str(&self) -> &str


bytes(&self) -> Bytes


capacity(&self) -> usize


char_indices(&self) -> CharIndices


chars(&self) -> Chars


contains<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>


encode_utf16(&self) -> EncodeUtf16


ends_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>


eq_ignore_ascii_case(&self, other: &str) -> bool


escape_debug(&self) -> EscapeDebug


escape_default(&self) -> EscapeDefault


escape_unicode(&self) -> EscapeUnicode


find<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>


get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output> where I: SliceIndex<str>


get_unchecked<I>(&self, i: I) -> &<I as SliceIndex<str>>::Output where I: SliceIndex<str>


is_ascii(&self) -> bool


is_char_boundary(&self, index: usize) -> bool


is_empty(&self) -> bool


len(&self) -> usize


lines(&self) -> Lines


lines_any(&self) -> LinesAny


match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> where P: Pattern<'a>


matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> where P: Pattern<'a>


parse<F>(&self) -> Result<F, <F as FromStr>::Err> where F: FromStr


repeat(&self, n: usize) -> String


replace<'a, P>(&'a self, from: P, to: &str) -> String where P: Pattern<'a>


replacen<'a, P>(&'a self, pat: P, to: &str, count: usize) -> String where P: Pattern<'a>


rfind<'a, P>(&'a self, pat: P) -> Option<usize> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>


rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>


rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>


rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>


rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>


rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>


slice_unchecked(&self, begin: usize, end: usize) -> &str


split<'a, P>(&'a self, pat: P) -> Split<'a, P> where P: Pattern<'a>


split_ascii_whitespace(&self) -> SplitAsciiWhitespace


split_at(&self, mid: usize) -> (&str, &str)


split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> where P: Pattern<'a>


split_whitespace(&self) -> SplitWhitespace


splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P> where P: Pattern<'a>


starts_with<'a, P>(&'a self, pat: P) -> bool where P: Pattern<'a>


to_ascii_lowercase(&self) -> String


to_ascii_uppercase(&self) -> String


to_lowercase(&self) -> String


to_uppercase(&self) -> String


trim(&self) -> &str


trim_end(&self) -> &str


trim_end_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>


trim_left(&self) -> &str


trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>


trim_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>


trim_right(&self) -> &str


trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>


trim_start(&self) -> &str


trim_start_matches<'a, P>(&'a self, pat: P) -> &'a str where P: Pattern<'a>


as_bytes_mut(&mut self) -> &mut [u8]


as_mut_ptr(&mut self) -> *mut u8


as_mut_str(&mut self) -> &mut str


as_mut_vec(&mut self) -> &mut Vec<u8>


clear(&mut self)


drain<R>(&mut self, range: R) -> Drain where R: RangeBounds<usize>


get_mut<I>( &mut self, i: I ) -> Option<&mut <I as SliceIndex<str>>::Output> where I: SliceIndex<str>


get_unchecked_mut<I>( &mut self, i: I ) -> &mut <I as SliceIndex<str>>::Output where I: SliceIndex<str>


insert(&mut self, idx: usize, ch: char)


insert_str(&mut self, idx: usize, string: &str)


make_ascii_lowercase(&mut self)


make_ascii_uppercase(&mut self)


pop(&mut self) -> Option<char>


push(&mut self, ch: char)


push_str(&mut self, string: &str)


remove(&mut self, idx: usize) -> char


replace_range<R>(&mut self, range: R, replace_with: &str) where R: RangeBounds<usize>


reserve(&mut self, additional: usize)


reserve_exact(&mut self, additional: usize)


retain<F>(&mut self, f: F) where F: FnMut(char) -> bool


shrink_to(&mut self, min_capacity: usize)


shrink_to_fit(&mut self)


slice_mut_unchecked( &mut self, begin: usize, end: usize ) -> &mut str


split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str)


split_off(&mut self, at: usize) -> String


truncate(&mut self, new_len: usize)


try_reserve( &mut self, additional: usize ) -> Result<(), CollectionAllocErr>


try_reserve_exact( &mut self, additional: usize ) -> Result<(), CollectionAllocErr>


into_boxed_str(self) -> Box<str>


into_bytes(self) -> Vec<u8>


Implements:

impl AsRef<OsStr> for String
impl AsRef<Path> for String
impl AsRef<[u8]> for String
impl AsRef<str> for String
impl Borrow<str> for String
impl Clone for String
impl Debug for String
impl Default for String
impl Deref for String
impl DerefMut for String
impl Display for String
impl Eq for String
impl Extend<String> for String
impl Extend<char> for String
impl From<Box<str>> for String
impl From<String> for Arc<str>
impl From<String> for Box<dyn Error + Send + Sync>
impl From<String> for Box<dyn Error>
impl From<String> for Box<str>
impl From<String> for OsString
impl From<String> for PathBuf
impl From<String> for Rc<str>
impl From<String> for Vec<u8>
impl FromIterator<String> for String
impl FromIterator<char> for String
impl FromStr for String
impl Hash for String
impl Index<Range<usize>> for String
impl Index<RangeFrom<usize>> for String
impl Index<RangeFull> for String
impl Index<RangeInclusive<usize>> for String
impl Index<RangeTo<usize>> for String
impl Index<RangeToInclusive<usize>> for String
impl IndexMut<Range<usize>> for String
impl IndexMut<RangeFrom<usize>> for String
impl IndexMut<RangeFull> for String
impl IndexMut<RangeInclusive<usize>> for String
impl IndexMut<RangeTo<usize>> for String
impl IndexMut<RangeToInclusive<usize>> for String
impl Ord for String
impl PartialEq<String> for String
impl PartialOrd<String> for String
impl Send for String
impl String
impl Sync for String
impl ToSocketAddrs for String
impl ToString for String
impl Write for String
impl<'_> Add<&'_ str> for String
impl<'_> AddAssign<&'_ str> for String
impl<'a, 'b> PartialEq<&'a str> for String
impl<'a, 'b> PartialEq<Cow<'a, str>> for String
impl<'a, 'b> PartialEq<String> for &'a str
impl<'a, 'b> PartialEq<String> for Cow<'a, str>
impl<'a, 'b> PartialEq<String> for str
impl<'a, 'b> PartialEq<str> for String
impl<'a, 'b> Pattern<'a> for &'b String
impl<'a> Extend<&'a char> for String
impl<'a> Extend<&'a str> for String
impl<'a> Extend<Cow<'a, str>> for String
impl<'a> From<&'a String> for Cow<'a, str>
impl<'a> From<&'a str> for String
impl<'a> From<Cow<'a, str>> for String
impl<'a> From<String> for Cow<'a, str>
impl<'a> FromIterator<&'a char> for String
impl<'a> FromIterator<&'a str> for String
impl<'a> FromIterator<Cow<'a, str>> for String
impl<'a> FromIterator<String> for Cow<'a, str>

std::string::ToString (prelude)

trait ToString

Requires:

to_string(&self) -> String

std::vec::Vec (prelude)

struct Vec<T>

Methods:


from_raw_parts( ptr: *mut T, length: usize, capacity: usize ) -> Vec<T>


new() -> Vec<T>


with_capacity(capacity: usize) -> Vec<T>


as_ptr(&self) -> *const T


as_slice(&self) -> &[T]


binary_search(&self, x: &T) -> Result<usize, usize> where T: Ord


binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize> where F: FnMut(&'a T) -> Ordering


binary_search_by_key<'a, B, F>( &'a self, b: &B, f: F ) -> Result<usize, usize> where B: Ord, F: FnMut(&'a T) -> B


capacity(&self) -> usize


chunks(&self, chunk_size: usize) -> Chunks<T>


chunks_exact(&self, chunk_size: usize) -> ChunksExact<T>


contains(&self, x: &T) -> bool where T: PartialEq<T>


ends_with(&self, needle: &[T]) -> bool where T: PartialEq<T>


eq_ignore_ascii_case(&self, other: &[u8]) -> bool


first(&self) -> Option<&T>


get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output> where I: SliceIndex<[T]>


is_ascii(&self) -> bool


is_empty(&self) -> bool


is_sorted(&self) -> bool where T: PartialOrd<T>


is_sorted_by<F>(&self, compare: F) -> bool where F: FnMut(&T, &T) -> Option<Ordering>


is_sorted_by_key<F, K>(&self, f: F) -> bool where F: FnMut(&T) -> K, K: PartialOrd<K>


iter(&self) -> Iter<T>


last(&self) -> Option<&T>


len(&self) -> usize


align_to<U>(&self) -> (&[T], &[U], &[T])


get_unchecked<I>( &self, index: I ) -> &<I as SliceIndex<[T]>>::Output where I: SliceIndex<[T]>


rchunks(&self, chunk_size: usize) -> RChunks<T>


rchunks_exact(&self, chunk_size: usize) -> RChunksExact<T>


repeat(&self, n: usize) -> Vec<T> where T: Copy


rsplit<F>(&self, pred: F) -> RSplit<T, F> where F: FnMut(&T) -> bool


rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F> where F: FnMut(&T) -> bool


split<F>(&self, pred: F) -> Split<T, F> where F: FnMut(&T) -> bool


split_at(&self, mid: usize) -> (&[T], &[T])


split_first(&self) -> Option<(&T, &[T])>


split_last(&self) -> Option<(&T, &[T])>


splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F> where F: FnMut(&T) -> bool


starts_with(&self, needle: &[T]) -> bool where T: PartialEq<T>


to_ascii_lowercase(&self) -> Vec<u8>


to_ascii_uppercase(&self) -> Vec<u8>


to_vec(&self) -> Vec<T> where T: Clone


windows(&self, size: usize) -> Windows<T>


align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T])


append(&mut self, other: &mut Vec<T>)


as_mut_ptr(&mut self) -> *mut T


as_mut_slice(&mut self) -> &mut [T]


chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<T>


chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T>


clear(&mut self)


clone_from_slice(&mut self, src: &[T]) where T: Clone


copy_from_slice(&mut self, src: &[T]) where T: Copy


copy_within<R>(&mut self, src: R, dest: usize) where R: RangeBounds<usize>, T: Copy


dedup(&mut self)


dedup_by<F>(&mut self, same_bucket: F) where F: FnMut(&mut T, &mut T) -> bool


dedup_by_key<F, K>(&mut self, key: F) where F: FnMut(&mut T) -> K, K: PartialEq<K>


drain<R>(&mut self, range: R) -> Drain<T> where R: RangeBounds<usize>


drain_filter<F>(&mut self, filter: F) -> DrainFilter<T, F> where F: FnMut(&mut T) -> bool


extend_from_slice(&mut self, other: &[T])


first_mut(&mut self) -> Option<&mut T>


get_mut<I>( &mut self, index: I ) -> Option<&mut <I as SliceIndex<[T]>>::Output> where I: SliceIndex<[T]>


get_unchecked_mut<I>( &mut self, index: I ) -> &mut <I as SliceIndex<[T]>>::Output where I: SliceIndex<[T]>


insert(&mut self, index: usize, element: T)


iter_mut(&mut self) -> IterMut<T>


last_mut(&mut self) -> Option<&mut T>


make_ascii_lowercase(&mut self)


make_ascii_uppercase(&mut self)


partition_dedup(&mut self) -> (&mut [T], &mut [T]) where T: PartialEq<T>


partition_dedup_by<F>(&mut self, same_bucket: F) -> (&mut [T], &mut [T]) where F: FnMut(&mut T, &mut T) -> bool


partition_dedup_by_key<K, F>(&mut self, key: F) -> (&mut [T], &mut [T]) where F: FnMut(&mut T) -> K, K: PartialEq<K>


pop(&mut self) -> Option<T>


push(&mut self, value: T)


rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<T>


rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<T>


remove(&mut self, index: usize) -> T


remove_item(&mut self, item: &T) -> Option<T>


reserve(&mut self, additional: usize)


reserve_exact(&mut self, additional: usize)


resize(&mut self, new_len: usize, value: T)


resize_default(&mut self, new_len: usize)


resize_with<F>(&mut self, new_len: usize, f: F) where F: FnMut() -> T


retain<F>(&mut self, f: F) where F: FnMut(&T) -> bool


reverse(&mut self)


rotate_left(&mut self, mid: usize)


rotate_right(&mut self, k: usize)


rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<T, F> where F: FnMut(&T) -> bool


rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<T, F> where F: FnMut(&T) -> bool


set_len(&mut self, new_len: usize)


shrink_to(&mut self, min_capacity: usize)


shrink_to_fit(&mut self)


sort(&mut self) where T: Ord


sort_by<F>(&mut self, compare: F) where F: FnMut(&T, &T) -> Ordering


sort_by_cached_key<K, F>(&mut self, f: F) where F: FnMut(&T) -> K, K: Ord


sort_by_key<K, F>(&mut self, f: F) where F: FnMut(&T) -> K, K: Ord


sort_unstable(&mut self) where T: Ord


sort_unstable_by<F>(&mut self, compare: F) where F: FnMut(&T, &T) -> Ordering


sort_unstable_by_key<K, F>(&mut self, f: F) where F: FnMut(&T) -> K, K: Ord


splice<R, I>( &mut self, range: R, replace_with: I ) -> Splice<<I as IntoIterator>::IntoIter> where I: IntoIterator<Item = T>, R: RangeBounds<usize>


split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])


split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>


split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>


split_mut<F>(&mut self, pred: F) -> SplitMut<T, F> where F: FnMut(&T) -> bool


split_off(&mut self, at: usize) -> Vec<T>


splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F> where F: FnMut(&T) -> bool


swap(&mut self, a: usize, b: usize)


swap_remove(&mut self, index: usize) -> T


swap_with_slice(&mut self, other: &mut [T])


truncate(&mut self, len: usize)


try_reserve( &mut self, additional: usize ) -> Result<(), CollectionAllocErr>


try_reserve_exact( &mut self, additional: usize ) -> Result<(), CollectionAllocErr>


into_boxed_slice(self) -> Box<[T]>


Implements:

impl From<CString> for Vec<u8>
impl From<String> for Vec<u8>
impl Write for Vec<u8>
impl<'a, 'b, A, B> PartialEq<&'b [B]> for Vec<A> where A: PartialEq<B>
impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for Vec<A> where A: PartialEq<B>
impl<'a, 'b, A, B> PartialEq<Vec<B>> for Cow<'a, [A]> where A: Clone + PartialEq<B>
impl<'a, 'b, A, B> PartialEq<Vec<B>> for Vec<A> where A: PartialEq<B>
impl<'a, T> Extend<&'a T> for Vec<T> where T: 'a + Copy
impl<'a, T> From<&'a Vec<T>> for Cow<'a, [T]> where T: Clone
impl<'a, T> From<&'a [T]> for Vec<T> where T: Clone
impl<'a, T> From<&'a mut [T]> for Vec<T> where T: Clone
impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where [T]: ToOwned, <[T] as ToOwned>::Owned == Vec<T>
impl<'a, T> From<Vec<T>> for Cow<'a, [T]> where T: Clone
impl<'a, T> IntoIterator for &'a Vec<T>
impl<'a, T> IntoIterator for &'a mut Vec<T>
impl<'a> From<&'a str> for Vec<u8>
impl<A, B> PartialEq<Vec<B>> for VecDeque<A> where A: PartialEq<B>
impl<T, I> Index<I> for Vec<T> where I: SliceIndex<[T]>
impl<T, I> IndexMut<I> for Vec<T> where I: SliceIndex<[T]>
impl<T> AsMut<Vec<T>> for Vec<T>
impl<T> AsMut<[T]> for Vec<T>
impl<T> AsRef<Vec<T>> for Vec<T>
impl<T> AsRef<[T]> for Vec<T>
impl<T> Borrow<[T]> for Vec<T>
impl<T> BorrowMut<[T]> for Vec<T>
impl<T> Clone for Vec<T> where T: Clone
impl<T> Debug for Vec<T> where T: Debug
impl<T> Default for Vec<T>
impl<T> Deref for Vec<T>
impl<T> DerefMut for Vec<T>
impl<T> Drop for Vec<T>
impl<T> Eq for Vec<T> where T: Eq
impl<T> Extend<T> for Vec<T>
impl<T> From<BinaryHeap<T>> for Vec<T>
impl<T> From<Box<[T]>> for Vec<T>
impl<T> From<Vec<T>> for Arc<[T]>
impl<T> From<Vec<T>> for BinaryHeap<T> where T: Ord
impl<T> From<Vec<T>> for Box<[T]>
impl<T> From<Vec<T>> for Rc<[T]>
impl<T> From<Vec<T>> for VecDeque<T>
impl<T> From<VecDeque<T>> for Vec<T>
impl<T> FromIterator<T> for Vec<T>
impl<T> Hash for Vec<T> where T: Hash
impl<T> IntoIterator for Vec<T>
impl<T> Ord for Vec<T> where T: Ord
impl<T> PartialOrd<Vec<T>> for Vec<T> where T: PartialOrd<T>
impl<T> Send for Vec<T> where T: Send
impl<T> Sync for Vec<T> where T: Sync