Enum std::option::Option
pub enum Option<T> { None, Some(T), }
The Option
type. See the module level documentation for more.
Variants
None
No value
Some(T)
Some value T
Tuple Fields of Some
0: T
Implementations
impl<T> Option<T>
pub const fn is_some(&self) -> bool
Returns true
if the option is a Some
value.
Examples
let x: Option<u32> = Some(2); assert_eq!(x.is_some(), true); let x: Option<u32> = None; assert_eq!(x.is_some(), false);
pub const fn is_none(&self) -> bool
Returns true
if the option is a None
value.
Examples
let x: Option<u32> = Some(2); assert_eq!(x.is_none(), false); let x: Option<u32> = None; assert_eq!(x.is_none(), true);
Returns true
if the option is a Some
value containing the given value.
Examples
#![feature(option_result_contains)] let x: Option<u32> = Some(2); assert_eq!(x.contains(&2), true); let x: Option<u32> = Some(3); assert_eq!(x.contains(&2), false); let x: Option<u32> = None; assert_eq!(x.contains(&2), false);
pub const fn as_ref(&self) -> Option<&T>
Converts from &Option<T>
to Option<&T>
.
Examples
Converts an Option<
String
>
into an Option<
usize
>
, preserving the original. The map
method takes the self
argument by value, consuming the original, so this technique uses as_ref
to first take an Option
to a reference to the value inside the original.
let text: Option<String> = Some("Hello, world!".to_string()); // First, cast `Option<String>` to `Option<&String>` with `as_ref`, // then consume *that* with `map`, leaving `text` on the stack. let text_length: Option<usize> = text.as_ref().map(|s| s.len()); println!("still can print text: {:?}", text);
pub fn as_mut(&mut self) -> Option<&mut T>
Converts from &mut Option<T>
to Option<&mut T>
.
Examples
let mut x = Some(2); match x.as_mut() { Some(v) => *v = 42, None => {}, } assert_eq!(x, Some(42));
pub fn as_pin_ref(self: Pin<&Option<T>>) -> Option<Pin<&T>>
pub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>
pub fn expect(self, msg: &str) -> T
Returns the contained Some
value, consuming the self
value.
Panics
Panics if the value is a None
with a custom panic message provided by msg
.
Examples
let x = Some("value"); assert_eq!(x.expect("fruits are healthy"), "value");
let x: Option<&str> = None; x.expect("fruits are healthy"); // panics with `fruits are healthy`
Returns the contained Some
value, consuming the self
value.
Because this function may panic, its use is generally discouraged. Instead, prefer to use pattern matching and handle the None
case explicitly, or call unwrap_or
, unwrap_or_else
, or unwrap_or_default
.
Panics
Panics if the self value equals None
.
Examples
let x = Some("air"); assert_eq!(x.unwrap(), "air");
let x: Option<&str> = None; assert_eq!(x.unwrap(), "air"); // fails
pub fn unwrap_or(self, default: T) -> T
Returns the contained Some
value or a provided default.
Arguments passed to unwrap_or
are eagerly evaluated; if you are passing the result of a function call, it is recommended to use unwrap_or_else
, which is lazily evaluated.
Examples
assert_eq!(Some("car").unwrap_or("bike"), "car"); assert_eq!(None.unwrap_or("bike"), "bike");
Returns the contained Some
value or computes it from a closure.
Examples
let k = 10; assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4); assert_eq!(None.unwrap_or_else(|| 2 * k), 20);
pub unsafe fn unwrap_unchecked(self) -> T
option_result_unwrap_unchecked
#81383)newly added
Returns the contained Some
value, consuming the self
value, without checking that the value is not None
.
Safety
Calling this method on None
is undefined behavior.
Examples
#![feature(option_result_unwrap_unchecked)] let x = Some("air"); assert_eq!(unsafe { x.unwrap_unchecked() }, "air");
#![feature(option_result_unwrap_unchecked)] let x: Option<&str> = None; assert_eq!(unsafe { x.unwrap_unchecked() }, "air"); // Undefined behavior!
Maps an Option<T>
to Option<U>
by applying a function to a contained value.
Examples
Converts an Option<
String
>
into an Option<
usize
>
, consuming the original:
let maybe_some_string = Some(String::from("Hello, World!")); // `Option::map` takes self *by value*, consuming `maybe_some_string` let maybe_some_len = maybe_some_string.map(|s| s.len()); assert_eq!(maybe_some_len, Some(13));
Returns the provided default result (if none), or applies a function to the contained value (if any).
Arguments passed to map_or
are eagerly evaluated; if you are passing the result of a function call, it is recommended to use map_or_else
, which is lazily evaluated.
Examples
let x = Some("foo"); assert_eq!(x.map_or(42, |v| v.len()), 3); let x: Option<&str> = None; assert_eq!(x.map_or(42, |v| v.len()), 42);
Computes a default function result (if none), or applies a different function to the contained value (if any).
Examples
let k = 21; let x = Some("foo"); assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 3); let x: Option<&str> = None; assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 42);
pub fn ok_or<E>(self, err: E) -> Result<T, E>
Transforms the Option<T>
into a Result<T, E>
, mapping Some(v)
to Ok(v)
and None
to Err(err)
.
Arguments passed to ok_or
are eagerly evaluated; if you are passing the result of a function call, it is recommended to use ok_or_else
, which is lazily evaluated.
Examples
let x = Some("foo"); assert_eq!(x.ok_or(0), Ok("foo")); let x: Option<&str> = None; assert_eq!(x.ok_or(0), Err(0));
Transforms the Option<T>
into a Result<T, E>
, mapping Some(v)
to Ok(v)
and None
to Err(err())
.
Examples
let x = Some("foo"); assert_eq!(x.ok_or_else(|| 0), Ok("foo")); let x: Option<&str> = None; assert_eq!(x.ok_or_else(|| 0), Err(0));
impl<'a, A> Iterator for Iter<'a, A> type Item = &'a A;
Returns an iterator over the possibly contained value.
Examples
let x = Some(4); assert_eq!(x.iter().next(), Some(&4)); let x: Option<u32> = None; assert_eq!(x.iter().next(), None);
pub fn iter_mut(&mut self) -> IterMut<'_, T>
impl<'a, A> Iterator for IterMut<'a, A> type Item = &'a mut A;
Returns a mutable iterator over the possibly contained value.
Examples
let mut x = Some(4); match x.iter_mut().next() { Some(v) => *v = 42, None => {}, } assert_eq!(x, Some(42)); let mut x: Option<u32> = None; assert_eq!(x.iter_mut().next(), None);
pub fn and<U>(self, optb: Option<U>) -> Option<U>
Returns None
if the option is None
, otherwise returns optb
.
Examples
let x = Some(2); let y: Option<&str> = None; assert_eq!(x.and(y), None); let x: Option<u32> = None; let y = Some("foo"); assert_eq!(x.and(y), None); let x = Some(2); let y = Some("foo"); assert_eq!(x.and(y), Some("foo")); let x: Option<u32> = None; let y: Option<&str> = None; assert_eq!(x.and(y), None);
Returns None
if the option is None
, otherwise calls f
with the wrapped value and returns the result.
Some languages call this operation flatmap.
Examples
fn sq(x: u32) -> Option<u32> { Some(x * x) } fn nope(_: u32) -> Option<u32> { None } assert_eq!(Some(2).and_then(sq).and_then(sq), Some(16)); assert_eq!(Some(2).and_then(sq).and_then(nope), None); assert_eq!(Some(2).and_then(nope).and_then(sq), None); assert_eq!(None.and_then(sq).and_then(sq), None);
Returns None
if the option is None
, otherwise calls predicate
with the wrapped value and returns:
-
Some(t)
ifpredicate
returnstrue
(wheret
is the wrapped value), and -
None
ifpredicate
returnsfalse
.
This function works similar to Iterator::filter()
. You can imagine the Option<T>
being an iterator over one or zero elements. filter()
lets you decide which elements to keep.
Examples
fn is_even(n: &i32) -> bool { n % 2 == 0 } assert_eq!(None.filter(is_even), None); assert_eq!(Some(3).filter(is_even), None); assert_eq!(Some(4).filter(is_even), Some(4));
pub fn or(self, optb: Option<T>) -> Option<T>
Returns the option if it contains a value, otherwise returns optb
.
Arguments passed to or
are eagerly evaluated; if you are passing the result of a function call, it is recommended to use or_else
, which is lazily evaluated.
Examples
let x = Some(2); let y = None; assert_eq!(x.or(y), Some(2)); let x = None; let y = Some(100); assert_eq!(x.or(y), Some(100)); let x = Some(2); let y = Some(100); assert_eq!(x.or(y), Some(2)); let x: Option<u32> = None; let y = None; assert_eq!(x.or(y), None);
Returns the option if it contains a value, otherwise calls f
and returns the result.
Examples
fn nobody() -> Option<&'static str> { None } fn vikings() -> Option<&'static str> { Some("vikings") } assert_eq!(Some("barbarians").or_else(vikings), Some("barbarians")); assert_eq!(None.or_else(vikings), Some("vikings")); assert_eq!(None.or_else(nobody), None);
pub fn xor(self, optb: Option<T>) -> Option<T>
Returns Some
if exactly one of self
, optb
is Some
, otherwise returns None
.
Examples
let x = Some(2); let y: Option<u32> = None; assert_eq!(x.xor(y), Some(2)); let x: Option<u32> = None; let y = Some(2); assert_eq!(x.xor(y), Some(2)); let x = Some(2); let y = Some(2); assert_eq!(x.xor(y), None); let x: Option<u32> = None; let y: Option<u32> = None; assert_eq!(x.xor(y), None);
pub fn insert(&mut self, value: T) -> &mut T
Inserts value
into the option then returns a mutable reference to it.
If the option already contains a value, the old value is dropped.
See also Option::get_or_insert
, which doesn’t update the value if the option already contains Some
.
Example
let mut opt = None; let val = opt.insert(1); assert_eq!(*val, 1); assert_eq!(opt.unwrap(), 1); let val = opt.insert(2); assert_eq!(*val, 2); *val = 3; assert_eq!(opt.unwrap(), 3);
pub fn get_or_insert(&mut self, value: T) -> &mut T
Inserts value
into the option if it is None
, then returns a mutable reference to the contained value.
See also Option::insert
, which updates the value even if the option already contains Some
.
Examples
let mut x = None; { let y: &mut u32 = x.get_or_insert(5); assert_eq!(y, &5); *y = 7; } assert_eq!(x, Some(7));
Inserts the default value into the option if it is None
, then returns a mutable reference to the contained value.
Examples
#![feature(option_get_or_insert_default)] let mut x = None; { let y: &mut u32 = x.get_or_insert_default(); assert_eq!(y, &0); *y = 7; } assert_eq!(x, Some(7));
Inserts a value computed from f
into the option if it is None
, then returns a mutable reference to the contained value.
Examples
let mut x = None; { let y: &mut u32 = x.get_or_insert_with(|| 5); assert_eq!(y, &5); *y = 7; } assert_eq!(x, Some(7));
pub fn take(&mut self) -> Option<T>
Takes the value out of the option, leaving a None
in its place.
Examples
let mut x = Some(2); let y = x.take(); assert_eq!(x, None); assert_eq!(y, Some(2)); let mut x: Option<u32> = None; let y = x.take(); assert_eq!(x, None); assert_eq!(y, None);
pub fn replace(&mut self, value: T) -> Option<T>
Replaces the actual value in the option by the value given in parameter, returning the old value if present, leaving a Some
in its place without deinitializing either one.
Examples
let mut x = Some(2); let old = x.replace(5); assert_eq!(x, Some(5)); assert_eq!(old, Some(2)); let mut x = None; let old = x.replace(3); assert_eq!(x, Some(3)); assert_eq!(old, None);
pub fn zip<U>(self, other: Option<U>) -> Option<(T, U)>
Zips self
with another Option
.
If self
is Some(s)
and other
is Some(o)
, this method returns Some((s, o))
. Otherwise, None
is returned.
Examples
let x = Some(1); let y = Some("hi"); let z = None::<u8>; assert_eq!(x.zip(y), Some((1, "hi"))); assert_eq!(x.zip(z), None);
pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R> where
F: FnOnce(T, U) -> R,
Zips self
and another Option
with function f
.
If self
is Some(s)
and other
is Some(o)
, this method returns Some(f(s, o))
. Otherwise, None
is returned.
Examples
#![feature(option_zip)] #[derive(Debug, PartialEq)] struct Point { x: f64, y: f64, } impl Point { fn new(x: f64, y: f64) -> Self { Self { x, y } } } let x = Some(17.5); let y = Some(42.7); assert_eq!(x.zip_with(y, Point::new), Some(Point { x: 17.5, y: 42.7 })); assert_eq!(x.zip_with(None, Point::new), None);
impl<T, U> Option<(T, U)>
pub const fn unzip(self) -> (Option<T>, Option<U>)
unzip_option
#87800)recently added
Unzips an option containing a tuple of two options
If self
is Some((a, b))
this method returns (Some(a), Some(b))
. Otherwise, (None, None)
is returned.
Examples
#![feature(unzip_option)] let x = Some((1, "hi")); let y = None::<(u8, u32)>; assert_eq!(x.unzip(), (Some(1), Some("hi"))); assert_eq!(y.unzip(), (None, None));
pub fn copied(self) -> Option<T>
Maps an Option<&T>
to an Option<T>
by copying the contents of the option.
Examples
let x = 12; let opt_x = Some(&x); assert_eq!(opt_x, Some(&12)); let copied = opt_x.copied(); assert_eq!(copied, Some(12));
pub fn copied(self) -> Option<T>
Maps an Option<&mut T>
to an Option<T>
by copying the contents of the option.
Examples
let mut x = 12; let opt_x = Some(&mut x); assert_eq!(opt_x, Some(&mut 12)); let copied = opt_x.copied(); assert_eq!(copied, Some(12));
pub fn cloned(self) -> Option<T>
Maps an Option<&T>
to an Option<T>
by cloning the contents of the option.
Examples
let x = 12; let opt_x = Some(&x); assert_eq!(opt_x, Some(&12)); let cloned = opt_x.cloned(); assert_eq!(cloned, Some(12));
pub fn cloned(self) -> Option<T>
Maps an Option<&mut T>
to an Option<T>
by cloning the contents of the option.
Examples
let mut x = 12; let opt_x = Some(&mut x); assert_eq!(opt_x, Some(&mut 12)); let cloned = opt_x.cloned(); assert_eq!(cloned, Some(12));
pub fn unwrap_or_default(self) -> T
Returns the contained Some
value or a default
Consumes the self
argument then, if Some
, returns the contained value, otherwise if None
, returns the default value for that type.
Examples
Converts a string to an integer, turning poorly-formed strings into 0 (the default value for integers). parse
converts a string to any other type that implements FromStr
, returning None
on error.
let good_year_from_input = "1909"; let bad_year_from_input = "190blarg"; let good_year = good_year_from_input.parse().ok().unwrap_or_default(); let bad_year = bad_year_from_input.parse().ok().unwrap_or_default(); assert_eq!(1909, good_year); assert_eq!(0, bad_year);
pub fn as_deref(&self) -> Option<&<T as Deref>::Target>
Converts from Option<T>
(or &Option<T>
) to Option<&T::Target>
.
Leaves the original Option in-place, creating a new one with a reference to the original one, additionally coercing the contents via Deref
.
Examples
let x: Option<String> = Some("hey".to_owned()); assert_eq!(x.as_deref(), Some("hey")); let x: Option<String> = None; assert_eq!(x.as_deref(), None);
pub fn as_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target>
Converts from Option<T>
(or &mut Option<T>
) to Option<&mut T::Target>
.
Leaves the original Option
in-place, creating a new one containing a mutable reference to the inner type’s Deref::Target
type.
Examples
let mut x: Option<String> = Some("hey".to_owned()); assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), Some("HEY".to_owned().as_mut_str()));
impl<T, E> Option<Result<T, E>>
Transposes an Option
of a Result
into a Result
of an Option
.
None
will be mapped to Ok
(
None
)
. Some
(
Ok
(_))
and Some
(
Err
(_))
will be mapped to Ok
(
Some
(_))
and Err
(_)
.
Examples
#[derive(Debug, Eq, PartialEq)] struct SomeErr; let x: Result<Option<i32>, SomeErr> = Ok(Some(5)); let y: Option<Result<i32, SomeErr>> = Some(Ok(5)); assert_eq!(x, y.transpose());
impl<T> Option<Option<T>>
Converts from Option<Option<T>>
to Option<T>
Examples
Basic usage:
let x: Option<Option<u32>> = Some(Some(6)); assert_eq!(Some(6), x.flatten()); let x: Option<Option<u32>> = Some(None); assert_eq!(None, x.flatten()); let x: Option<Option<u32>> = None; assert_eq!(None, x.flatten());
Flattening only removes one level of nesting at a time:
let x: Option<Option<Option<u32>>> = Some(Some(Some(6))); assert_eq!(Some(Some(6)), x.flatten()); assert_eq!(Some(6), x.flatten().flatten());
Trait Implementations
pub fn clone(&self) -> Option<T>
Returns a copy of the value. Read more
pub fn clone_from(&mut self, source: &Option<T>)
Performs copy-assignment from source
. Read more
pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter. Read more
pub fn default() -> Option<T>
impl<'a, T> From<&'a Option<T>> for Option<&'a T>
pub fn from(o: &'a Option<T>) -> Option<&'a T>
Converts from &Option<T>
to Option<&T>
.
Examples
Converts an Option<
String
>
into an Option<
usize
>
, preserving the original. The map
method takes the self
argument by value, consuming the original, so this technique uses from
to first take an Option
to a reference to the value inside the original.
let s: Option<String> = Some(String::from("Hello, Rustaceans!")); let o: Option<usize> = Option::from(&s).map(|ss: &String| ss.len()); println!("Can still print s: {:?}", s); assert_eq!(o, Some(18));
impl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T>
pub fn from(o: &'a mut Option<T>) -> Option<&'a mut T>
Converts from &mut Option<T>
to Option<&mut T>
Examples
let mut s = Some(String::from("Hello")); let o: Option<&mut String> = Option::from(&mut s); match o { Some(t) => *t = String::from("Hello, Rustaceans!"), None => (), } assert_eq!(s, Some(String::from("Hello, Rustaceans!")));
impl<T> From<T> for Option<T>
pub fn from(val: T) -> Option<T>
Copies val
into a new Some
.
Examples
let o: Option<u8> = Option::from(67); assert_eq!(Some(67), o);
impl<A, V> FromIterator<Option<A>> for Option<V> where
V: FromIterator<A>,
pub fn from_iter<I>(iter: I) -> Option<V> where
I: IntoIterator<Item = Option<A>>,
Takes each element in the Iterator
: if it is None
, no further elements are taken, and the None
is returned. Should no None
occur, a container with the values of each Option
is returned.
Examples
Here is an example which increments every integer in a vector. We use the checked variant of add
that returns None
when the calculation would result in an overflow.
let items = vec![0_u16, 1, 2]; let res: Option<Vec<u16>> = items .iter() .map(|x| x.checked_add(1)) .collect(); assert_eq!(res, Some(vec![1, 2, 3]));
As you can see, this will return the expected, valid items.
Here is another example that tries to subtract one from another list of integers, this time checking for underflow:
let items = vec![2_u16, 1, 0]; let res: Option<Vec<u16>> = items .iter() .map(|x| x.checked_sub(1)) .collect(); assert_eq!(res, None);
Since the last element is zero, it would underflow. Thus, the resulting value is None
.
Here is a variation on the previous example, showing that no further elements are taken from iter
after the first None
.
let items = vec![3_u16, 2, 1, 10]; let mut shared = 0; let res: Option<Vec<u16>> = items .iter() .map(|x| { shared += x; x.checked_sub(2) }) .collect(); assert_eq!(res, None); assert_eq!(shared, 6);
Since the third element caused an underflow, no further elements were taken, so the final value of shared
is 6 (= 3 + 2 + 1
), not 16.
impl<T> FromResidual<<Option<T> as Try>::Residual> for Option<T>
pub fn from_residual(residual: Option<Infallible>) -> Option<T>
Constructs the type from a compatible Residual
type. Read more
impl<'a, T> IntoIterator for &'a mut Option<T>
type Item = &'a mut T
The type of the elements being iterated over.
type IntoIter = IterMut<'a, T>
Which kind of iterator are we turning this into?
pub fn into_iter(self) -> IterMut<'a, T>
impl<'a, A> Iterator for IterMut<'a, A> type Item = &'a mut A;
Creates an iterator from a value. Read more
impl<T> IntoIterator for Option<T>
pub fn into_iter(self) -> IntoIter<T>
impl<A> Iterator for IntoIter<A> type Item = A;
Returns a consuming iterator over the possibly contained value.
Examples
let x = Some("string"); let v: Vec<&str> = x.into_iter().collect(); assert_eq!(v, ["string"]); let x = None; let v: Vec<&str> = x.into_iter().collect(); assert!(v.is_empty());
type Item = T
The type of the elements being iterated over.
type IntoIter = IntoIter<T>
Which kind of iterator are we turning this into?
impl<'a, T> IntoIterator for &'a Option<T>
type Item = &'a T
The type of the elements being iterated over.
type IntoIter = Iter<'a, T>
Which kind of iterator are we turning this into?
pub fn into_iter(self) -> Iter<'a, T>
impl<'a, A> Iterator for Iter<'a, A> type Item = &'a A;
Creates an iterator from a value. Read more
pub fn cmp(&self, other: &Option<T>) -> Ordering
fn max(self, other: Self) -> Self
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
Compares and returns the minimum of two values. Read more
fn clamp(self, min: Self, max: Self) -> Self
Restrict a value to a certain interval. Read more
pub fn eq(&self, other: &Option<T>) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
pub fn ne(&self, other: &Option<T>) -> bool
This method tests for !=
.
impl<T> PartialOrd<Option<T>> for Option<T> where
T: PartialOrd<T>,
pub fn partial_cmp(&self, other: &Option<T>) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
Takes each element in the Iterator
: if it is a None
, no further elements are taken, and the None
is returned. Should no None
occur, the sum of all elements is returned.
Examples
This sums up the position of the character ‘a’ in a vector of strings, if a word did not have the character ‘a’ the operation returns None
:
let words = vec!["have", "a", "great", "day"]; let total: Option<usize> = words.iter().map(|w| w.find('a')).sum(); assert_eq!(total, Some(5));
impl<T> Try for Option<T>
type Output = T
The type of the value produced by ?
when not short-circuiting.
type Residual = Option<Infallible>
The type of the value passed to FromResidual::from_residual
as part of ?
when short-circuiting. Read more
pub fn from_output(output: <Option<T> as Try>::Output) -> Option<T>
Constructs the type from its Output
type. Read more
pub fn branch(
self
) -> ControlFlow<<Option<T> as Try>::Residual, <Option<T> as Try>::Output>
Used in ?
to decide whether the operator should produce a value (because this returned ControlFlow::Continue
) or propagate a value back to the caller (because this returned ControlFlow::Break
). Read more
impl<T> StructuralEq for Option<T>
impl<T> StructuralPartialEq for Option<T>
Auto Trait Implementations
impl<T> RefUnwindSafe for Option<T> where
T: RefUnwindSafe,
impl<T> Send for Option<T> where
T: Send,
impl<T> Sync for Option<T> where
T: Sync,
impl<T> Unpin for Option<T> where
T: Unpin,
impl<T> UnwindSafe for Option<T> where
T: UnwindSafe,
Blanket Implementations
impl<T> From<!> for T
pub fn from(t: !) -> T
Performs the conversion.
impl<T> From<T> for T
pub fn from(t: T) -> T
Performs the conversion.
pub fn into(self) -> U
Performs the conversion.
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
toowned_clone_into
#41263)recently added
Uses borrowed data to replace owned data, usually by cloning. Read more
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/option/enum.Option.html