Enum otter_api_tests::inventory::core::ops::ControlFlow
1.55.0 · source · [−]pub enum ControlFlow<B, C = ()> {
Continue(C),
Break(B),
}
Expand description
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.
Similar to Option
and Result
, this enum can be used with the ?
operator
to return immediately if the Break
variant is present or otherwise continue normally
with the value inside the Continue
variant.
Examples
Early-exiting from Iterator::try_for_each
:
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:
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, f: &mut impl FnMut(&T) -> ControlFlow<B>) -> ControlFlow<B> {
if let Some(left) = &self.left {
left.traverse_inorder(f)?;
}
f(&self.value)?;
if let Some(right) = &self.right {
right.traverse_inorder(f)?;
}
ControlFlow::Continue(())
}
fn leaf(value: T) -> Option<Box<TreeNode<T>>> {
Some(Box::new(Self { value, left: None, right: None }))
}
}
let node = TreeNode {
value: 0,
left: TreeNode::leaf(1),
right: Some(Box::new(TreeNode {
value: -1,
left: TreeNode::leaf(5),
right: TreeNode::leaf(2),
}))
};
let mut sum = 0;
let res = node.traverse_inorder(&mut |val| {
if *val < 0 {
ControlFlow::Break(*val)
} else {
sum += *val;
ControlFlow::Continue(())
}
});
assert_eq!(res, ControlFlow::Break(-1));
assert_eq!(sum, 6);
Variants
Continue(C)
Move on to the next phase of the operation as normal.
Break(B)
Exit the operation without running subsequent phases.
Implementations
sourceimpl<B, C> ControlFlow<B, C>
impl<B, C> ControlFlow<B, C>
1.59.0 · sourcepub fn is_break(&self) -> bool
pub fn is_break(&self) -> bool
Returns true
if this is a Break
variant.
Examples
use std::ops::ControlFlow;
assert!(ControlFlow::<i32, String>::Break(3).is_break());
assert!(!ControlFlow::<String, i32>::Continue(3).is_break());
1.59.0 · sourcepub fn is_continue(&self) -> bool
pub fn is_continue(&self) -> bool
Returns true
if this is a Continue
variant.
Examples
use std::ops::ControlFlow;
assert!(!ControlFlow::<i32, String>::Break(3).is_continue());
assert!(ControlFlow::<String, i32>::Continue(3).is_continue());
sourcepub fn break_value(self) -> Option<B>
🔬 This is a nightly-only experimental API. (control_flow_enum
)
pub fn break_value(self) -> Option<B>
control_flow_enum
)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);
sourcepub fn map_break<T, F>(self, f: F) -> ControlFlow<T, C> where
F: FnOnce(B) -> T,
🔬 This is a nightly-only experimental API. (control_flow_enum
)
pub fn map_break<T, F>(self, f: F) -> ControlFlow<T, C> where
F: FnOnce(B) -> T,
control_flow_enum
)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>::Output> where
R: Try,
These are used only as part of implementing the iterator adapters. They have mediocre names and non-obvious semantics, so aren’t currently on a path to potential stabilization.
sourceimpl<B> ControlFlow<B, ()>
impl<B> ControlFlow<B, ()>
sourcepub const CONTINUE: ControlFlow<B, ()> = ControlFlow::Continue(())
🔬 This is a nightly-only experimental API. (control_flow_enum
)
pub const CONTINUE: ControlFlow<B, ()> = ControlFlow::Continue(())
control_flow_enum
)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));
sourceimpl<C> ControlFlow<(), C>
impl<C> ControlFlow<(), C>
sourcepub const BREAK: ControlFlow<(), C> = ControlFlow::Break(())
🔬 This is a nightly-only experimental API. (control_flow_enum
)
pub const BREAK: ControlFlow<(), C> = ControlFlow::Break(())
control_flow_enum
)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
sourceimpl<B, C> Clone for ControlFlow<B, C> where
B: Clone,
C: Clone,
impl<B, C> Clone for ControlFlow<B, C> where
B: Clone,
C: Clone,
sourcefn clone(&self) -> ControlFlow<B, C>
fn clone(&self) -> ControlFlow<B, C>
Returns a copy of the value. Read more
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl<B, C> Debug for ControlFlow<B, C> where
B: Debug,
C: Debug,
impl<B, C> Debug for ControlFlow<B, C> where
B: Debug,
C: Debug,
sourceimpl<B, C> FromResidual<<ControlFlow<B, C> as Try>::Residual> for ControlFlow<B, C>
impl<B, C> FromResidual<<ControlFlow<B, C> as Try>::Residual> for ControlFlow<B, C>
sourcefn from_residual(residual: ControlFlow<B, Infallible>) -> ControlFlow<B, C>
fn from_residual(residual: ControlFlow<B, Infallible>) -> ControlFlow<B, C>
try_trait_v2
)Constructs the type from a compatible Residual
type. Read more
sourceimpl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
B: PartialEq<B>,
C: PartialEq<C>,
impl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
B: PartialEq<B>,
C: PartialEq<C>,
sourcefn eq(&self, other: &ControlFlow<B, C>) -> bool
fn eq(&self, other: &ControlFlow<B, C>) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
sourcefn ne(&self, other: &ControlFlow<B, C>) -> bool
fn ne(&self, other: &ControlFlow<B, C>) -> bool
This method tests for !=
.
sourceimpl<B, C> Residual<C> for ControlFlow<B, Infallible>
impl<B, C> Residual<C> for ControlFlow<B, Infallible>
type TryType = ControlFlow<B, C>
type TryType = ControlFlow<B, C>
try_trait_v2_residual
)The “return” type of this meta-function.
sourceimpl<B, C> Try for ControlFlow<B, C>
impl<B, C> Try for ControlFlow<B, C>
type Output = C
type Output = C
try_trait_v2
)The type of the value produced by ?
when not short-circuiting.
type Residual = ControlFlow<B, Infallible>
type Residual = ControlFlow<B, Infallible>
try_trait_v2
)The type of the value passed to FromResidual::from_residual
as part of ?
when short-circuiting. Read more
sourcefn from_output(output: <ControlFlow<B, C> as Try>::Output) -> ControlFlow<B, C>
fn from_output(output: <ControlFlow<B, C> as Try>::Output) -> ControlFlow<B, C>
try_trait_v2
)Constructs the type from its Output
type. Read more
sourcefn branch(
self
) -> ControlFlow<<ControlFlow<B, C> as Try>::Residual, <ControlFlow<B, C> as Try>::Output>
fn branch(
self
) -> ControlFlow<<ControlFlow<B, C> as Try>::Residual, <ControlFlow<B, C> as Try>::Output>
try_trait_v2
)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<B, C> Copy for ControlFlow<B, C> where
B: Copy,
C: Copy,
impl<B, C> StructuralPartialEq for ControlFlow<B, C>
Auto Trait Implementations
impl<B, C> RefUnwindSafe for ControlFlow<B, C> where
B: RefUnwindSafe,
C: RefUnwindSafe,
impl<B, C> Send for ControlFlow<B, C> where
B: Send,
C: Send,
impl<B, C> Sync for ControlFlow<B, C> where
B: Sync,
C: Sync,
impl<B, C> Unpin for ControlFlow<B, C> where
B: Unpin,
C: Unpin,
impl<B, C> UnwindSafe for ControlFlow<B, C> where
B: UnwindSafe,
C: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<T> Downcast for T where
T: Any,
impl<T> Downcast for T where
T: Any,
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>ⓘNotable traits for Box<W, Global>impl<W> Write for Box<W, Global> where
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
W: Write + ?Sized, impl<R> Read for Box<R, Global> where
R: Read + ?Sized, impl<F, A> Future for Box<F, A> where
F: Future + Unpin + ?Sized,
A: Allocator + 'static, type Output = <F as Future>::Output;impl<I, A> Iterator for Box<I, A> where
I: Iterator + ?Sized,
A: Allocator, type Item = <I as Iterator>::Item;
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<A> DynCastExt for A
impl<A> DynCastExt for A
fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
A: DynCastExtHelper<T>,
T: ?Sized,
fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
A: DynCastExtHelper<T>,
T: ?Sized,
Use this to cast from one trait object type to another. Read more
fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
T: ?Sized,
fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
T: ?Sized,
Use this to upcast a trait to one of its supertraits. Read more
fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
T: ?Sized,
fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
A: DynCastExtAdvHelper<F, T>,
F: ?Sized,
T: ?Sized,
fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
Use this to cast from one trait object type to another. With this method the type parameter is a config type that uniquely specifies which cast should be preformed. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn instrument(self, span: Span) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
sourcefn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
fn in_current_span(self) -> Instrumented<Self>ⓘNotable traits for Instrumented<T>impl<T> Future for Instrumented<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
where
S: Into<Dispatch>,
T: Future, type Output = <T as Future>::Output;
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
fn with_current_subscriber(self) -> WithDispatch<Self>ⓘNotable traits for WithDispatch<T>impl<T> Future for WithDispatch<T> where
T: Future, type Output = <T as Future>::Output;
T: Future, type Output = <T as Future>::Output;
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more