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
impl<F> Future for Box<F> where F: Unpin + Future + ?Sized
impl<G> Generator for Box<G> where G: Unpin + Generator + ?Sized
impl DoubleEndedIterator for Box where I: DoubleEndedIterator + ?Sized
impl ExactSizeIterator for Box where I: ExactSizeIterator + ?Sized
impl FusedIterator for Box where I: FusedIterator + ?Sized
impl Iterator for Box 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> for Box<T> where T: Unsize + ?Sized, U: ?Sized
impl<T, U> DispatchFromDyn<Box> for Box<T> where T: Unsize + ?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> for RefCell<T> where T: CoerceUnsized
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 + ?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 + ?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(&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(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool
find_map<B, F>(&mut self, f: F) -> Option where F: FnMut(Self::Item) -> Option
nth(&mut self, n: usize) -> Option<Self::Item>
position(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool
rposition(&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(self, other: U) -> Chain<Self, ::IntoIter> where U: IntoIterator<Item = Self::Item>
cloned<'a, T>(self) -> Cloned<Self> where Self: Iterator<Item = &'a T>, T: 'a + Clone
cmp(self, other: I) -> Ordering where I: IntoIterator<Item = Self::Item>, Self::Item: Ord
collect(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(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<::Item>
filter(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
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(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::Item>
gt(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::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(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::Item>
lt(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::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(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<::Item>
partial_cmp(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<::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(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
skip(self, n: usize) -> Skip<Self>
skip_while(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(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, Self: Iterator<Item = (A, B)>
zip(self, other: U) -> Zip<Self, ::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(self, optb: Option) -> Option
and_then<U, F>(self, f: F) -> Option where F: FnOnce(T) -> Option
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(self, predicate: P) -> Option<T> where P: FnOnce(&T) -> bool
map<U, F>(self, f: F) -> Option 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(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
impl<T, U, E> Sum<Result<U, E>> for Result<T, E> where T: Sum

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
new_unchecked(pointer: P) -> Pin
as_ref(&self) -> Pin<&::Target>
as_mut(&mut self) -> Pin<&mut ::Target>
set(&mut self, value: ::Target) where ::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> for Pin where P: DispatchFromDyn
impl<G> Generator for Pin<Box<G>> where G: Generator + ?Sized
impl<P, Q> PartialEq<Pin<Q>> for Pin where P: PartialEq<Q>
impl<P, Q> PartialOrd<Pin<Q>> for Pin where P: PartialOrd<Q>
impl<P, U> CoerceUnsized<Pin> for Pin where P: CoerceUnsized
impl Clone for Pin where P: Clone
impl Copy for Pin where P: Copy
impl Debug for Pin where P: Debug
impl Deref for Pin where P: Deref
impl DerefMut for Pin where P: DerefMut, ::Target: Unpin
impl Display for Pin where P: Display
impl Eq for Pin where P: Eq
impl Future for Pin where P: Unpin + DerefMut, ::Target: Future
impl Hash for Pin where P: Hash
impl Ord for Pin where P: Ord
impl Pointer for Pin where P: Pointer
impl Send for Pin where P: Send
impl Sync for Pin 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(self) -> NonNull

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> for NonNull<T> where T: Unsize + ?Sized, U: ?Sized
impl<T, U> DispatchFromDyn<NonNull> for NonNull<T> where T: Unsize + ?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>, >::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(&self, i: I) -> Option<&>::Output> where I: SliceIndex<str>
get_unchecked(&self, i: I) -> &>::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>, >::Searcher: ReverseSearcher<'a>
rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> where P: Pattern<'a>, >::Searcher: ReverseSearcher<'a>
rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> where P: Pattern<'a>, >::Searcher: ReverseSearcher<'a>
rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> where P: Pattern<'a>, >::Searcher: ReverseSearcher<'a>
rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> where P: Pattern<'a>, >::Searcher: ReverseSearcher<'a>
rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> where P: 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>, >::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>, >::Searcher: DoubleEndedSearcher<'a>
trim_right(&self) -> &str
trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str where P: 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( &mut self, i: I ) -> Option<&mut >::Output> where I: SliceIndex<str>
get_unchecked_mut( &mut self, i: I ) -> &mut >::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(&self, index: I) -> Option<&>::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(&self) -> (&[T], &[U], &[T])
get_unchecked( &self, index: I ) -> &>::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(&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( &mut self, index: I ) -> Option<&mut >::Output> where I: SliceIndex<[T]>
get_unchecked_mut( &mut self, index: I ) -> &mut >::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<::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
impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for Vec<A> where A: PartialEq
impl<'a, 'b, A, B> PartialEq<Vec> for Cow<'a, [A]> where A: Clone + PartialEq
impl<'a, 'b, A, B> PartialEq<Vec> for Vec<A> where A: PartialEq
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> for VecDeque<A> where A: PartialEq
impl<T, I> Index for Vec<T> where I: SliceIndex<[T]>
impl<T, I> IndexMut 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

jcoglan/rust-types.md

Rust types reference

Prelude

std::any::Any

std::any::TypeId

std::borrow::Borrow

std::borrow::ToOwned (prelude)

std::boxed::Box (prelude)

std::cell::RefCell

std::cell::Ref

std::cell::RefMut

std::clone::Clone (prelude)

std::cmp::Eq (prelude)

std::cmp::Ord (prelude)

std::cmp::Ordering

std::cmp::PartialEq (prelude)

std::cmp::PartialOrd (prelude)

std::convert::AsMut (prelude)

std::convert::AsRef (prelude)

std::convert::From (prelude)

std::convert::Into (prelude)

std::default::Default (prelude)

std::iter::DoubleEndedIterator (prelude)

std::iter::ExactSizeIterator (prelude)

std::iter::Extend (prelude)

std::iter::IntoIterator (prelude)

std::iter::Iterator (prelude)

std::option::Option (prelude)

std::result::Result (prelude)

std::ops::Deref

std::ops::Drop (prelude)

std::ops::Fn (prelude)

std::ops::FnMut (prelude)

std::ops::FnOnce (prelude)

std::pin::Pin

std::ptr::NonNull

std::string::String (prelude)

std::string::ToString (prelude)

std::vec::Vec (prelude)