Enum nom::lib::std::ops::ControlFlow [−][src]
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
Used to tell an operation whether it should exit early or go on as usual.
This is used when exposing things (like graph traversals or visitors) where
you want the user to be able to choose whether to exit early.
Having the enum makes it clearer -- no more wondering "wait, what did false
mean again?" -- and allows including a value.
Examples
Early-exiting from Iterator::try_for_each
:
#![feature(control_flow_enum)] use std::ops::ControlFlow; let r = (2..100).try_for_each(|x| { if 403 % x == 0 { return ControlFlow::Break(x) } ControlFlow::Continue(()) }); assert_eq!(r, ControlFlow::Break(13));
A basic tree traversal:
#![feature(control_flow_enum)] use std::ops::ControlFlow; pub struct TreeNode<T> { value: T, left: Option<Box<TreeNode<T>>>, right: Option<Box<TreeNode<T>>>, } impl<T> TreeNode<T> { pub fn traverse_inorder<B>(&self, mut f: impl FnMut(&T) -> ControlFlow<B>) -> ControlFlow<B> { if let Some(left) = &self.left { left.traverse_inorder(&mut f)?; } f(&self.value)?; if let Some(right) = &self.right { right.traverse_inorder(&mut f)?; } ControlFlow::Continue(()) } }
Variants
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
Move on to the next phase of the operation as normal.
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
Exit the operation without running subsequent phases.
Implementations
impl<B, C> ControlFlow<B, C>
[src]
pub fn is_break(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
Returns true
if this is a Break
variant.
Examples
#![feature(control_flow_enum)] use std::ops::ControlFlow; assert!(ControlFlow::<i32, String>::Break(3).is_break()); assert!(!ControlFlow::<String, i32>::Continue(3).is_break());
pub fn is_continue(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
Returns true
if this is a Continue
variant.
Examples
#![feature(control_flow_enum)] use std::ops::ControlFlow; assert!(!ControlFlow::<i32, String>::Break(3).is_continue()); assert!(ControlFlow::<String, i32>::Continue(3).is_continue());
pub fn break_value(self) -> Option<B>
[src]
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
Converts the ControlFlow
into an Option
which is Some
if the
ControlFlow
was Break
and None
otherwise.
Examples
#![feature(control_flow_enum)] use std::ops::ControlFlow; assert_eq!(ControlFlow::<i32, String>::Break(3).break_value(), Some(3)); assert_eq!(ControlFlow::<String, i32>::Continue(3).break_value(), None);
pub fn map_break<T, F>(self, f: F) -> ControlFlow<T, C> where
F: FnOnce(B) -> T,
[src]
F: FnOnce(B) -> T,
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
Maps ControlFlow<B, C>
to ControlFlow<T, C>
by applying a function
to the break value in case it exists.
impl<R> ControlFlow<R, <R as Try>::Ok> where
R: Try,
[src]
R: Try,
pub fn from_try(r: R) -> ControlFlow<R, <R as Try>::Ok>
[src]
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
Create a ControlFlow
from any type implementing Try
.
pub fn into_try(self) -> R
[src]
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
Convert a ControlFlow
into any type implementing Try
;
impl<B> ControlFlow<B, ()>
[src]
pub const CONTINUE: ControlFlow<B, ()>
[src]
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
It's frequently the case that there's no value needed with Continue
,
so this provides a way to avoid typing (())
, if you prefer it.
Examples
#![feature(control_flow_enum)] use std::ops::ControlFlow; let mut partial_sum = 0; let last_used = (1..10).chain(20..25).try_for_each(|x| { partial_sum += x; if partial_sum > 100 { ControlFlow::Break(x) } else { ControlFlow::CONTINUE } }); assert_eq!(last_used.break_value(), Some(22));
impl<C> ControlFlow<(), C>
[src]
pub const BREAK: ControlFlow<(), C>
[src]
🔬 This is a nightly-only experimental API. (control_flow_enum
)
new API
APIs like try_for_each
don't need values with Break
,
so this provides a way to avoid typing (())
, if you prefer it.
Examples
#![feature(control_flow_enum)] use std::ops::ControlFlow; let mut partial_sum = 0; (1..10).chain(20..25).try_for_each(|x| { if partial_sum > 100 { ControlFlow::BREAK } else { partial_sum += x; ControlFlow::CONTINUE } }); assert_eq!(partial_sum, 108);
Trait Implementations
impl<B, C> Clone for ControlFlow<B, C> where
C: Clone,
B: Clone,
[src]
C: Clone,
B: Clone,
pub fn clone(&self) -> ControlFlow<B, C>
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<B, C> Copy for ControlFlow<B, C> where
C: Copy,
B: Copy,
[src]
C: Copy,
B: Copy,
impl<B, C> Debug for ControlFlow<B, C> where
C: Debug,
B: Debug,
[src]
C: Debug,
B: Debug,
impl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
C: PartialEq<C>,
B: PartialEq<B>,
[src]
C: PartialEq<C>,
B: PartialEq<B>,
pub fn eq(&self, other: &ControlFlow<B, C>) -> bool
[src]
pub fn ne(&self, other: &ControlFlow<B, C>) -> bool
[src]
impl<B, C> StructuralPartialEq for ControlFlow<B, C>
[src]
impl<B, C> Try for ControlFlow<B, C>
[src]
type Ok = C
try_trait
)The type of this value when viewed as successful.
type Error = B
try_trait
)The type of this value when viewed as failed.
pub fn into_result(
self
) -> Result<<ControlFlow<B, C> as Try>::Ok, <ControlFlow<B, C> as Try>::Error>
[src]
self
) -> Result<<ControlFlow<B, C> as Try>::Ok, <ControlFlow<B, C> as Try>::Error>
pub fn from_error(v: <ControlFlow<B, C> as Try>::Error) -> ControlFlow<B, C>
[src]
pub fn from_ok(v: <ControlFlow<B, C> as Try>::Ok) -> ControlFlow<B, C>
[src]
Auto Trait Implementations
impl<B, C> RefUnwindSafe for ControlFlow<B, C> where
B: RefUnwindSafe,
C: RefUnwindSafe,
[src]
B: RefUnwindSafe,
C: RefUnwindSafe,
impl<B, C> Send for ControlFlow<B, C> where
B: Send,
C: Send,
[src]
B: Send,
C: Send,
impl<B, C> Sync for ControlFlow<B, C> where
B: Sync,
C: Sync,
[src]
B: Sync,
C: Sync,
impl<B, C> Unpin for ControlFlow<B, C> where
B: Unpin,
C: Unpin,
[src]
B: Unpin,
C: Unpin,
impl<B, C> UnwindSafe for ControlFlow<B, C> where
B: UnwindSafe,
C: UnwindSafe,
[src]
B: UnwindSafe,
C: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut Tⓘ
[src]
impl<T> Conv for T
impl<T> Conv for T
impl<T> FmtForward for T
pub fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Self: Binary,
pub fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Self: Display,
pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Self: LowerExp,
pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Self: LowerHex,
pub fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Self: Octal,
pub fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Self: Pointer,
pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Self: UpperExp,
pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Self: UpperHex,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pipe for T where
T: ?Sized,
T: ?Sized,
pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_ref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_as_mut<'a, U, R>(
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
pub fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
impl<T> Pipe for T
impl<T> PipeAsRef for T
pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Self: AsRef<T>,
T: 'a,
R: 'a,
pub fn pipe_as_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
impl<T> PipeBorrow for T
pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Self: Borrow<T>,
T: 'a,
R: 'a,
pub fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
impl<T> PipeDeref for T
pub fn pipe_deref<'a, R>(
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
pub fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
impl<T> PipeRef for T
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
R: 'a,
impl<T> Tap for T
pub fn tap(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
impl<T> Tap for T
pub fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
impl<T> TapDeref for T
pub fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> TryConv for T
impl<T> TryConv for T
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
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>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,