Enum std::ops::ControlFlow[][src]

pub enum ControlFlow<B, C = ()> {
    Continue(C),
    Break(B),
}
🔬 This is a nightly-only experimental API. (control_flow_enum #75744)

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));
Run

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(())
    }
}
Run

Variants

Continue(C)
🔬 This is a nightly-only experimental API. (control_flow_enum #75744)

new API

Move on to the next phase of the operation as normal.

Break(B)
🔬 This is a nightly-only experimental API. (control_flow_enum #75744)

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 #75744)

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());
Run

pub fn is_continue(&self) -> bool[src]

🔬 This is a nightly-only experimental API. (control_flow_enum #75744)

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());
Run

pub fn break_value(self) -> Option<B>[src]

🔬 This is a nightly-only experimental API. (control_flow_enum #75744)

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);
Run

pub fn map_break<T, F>(self, f: F) -> ControlFlow<T, C> where
    F: FnOnce(B) -> T, 
[src]

🔬 This is a nightly-only experimental API. (control_flow_enum #75744)

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]

pub fn from_try(r: R) -> ControlFlow<R, <R as Try>::Ok>[src]

🔬 This is a nightly-only experimental API. (control_flow_enum #75744)

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 #75744)

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 #75744)

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));
Run

impl<C> ControlFlow<(), C>[src]

pub const BREAK: ControlFlow<(), C>[src]

🔬 This is a nightly-only experimental API. (control_flow_enum #75744)

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);
Run

Trait Implementations

impl<B, C> Clone for ControlFlow<B, C> where
    C: Clone,
    B: Clone
[src]

impl<B, C> Copy for ControlFlow<B, C> where
    C: Copy,
    B: Copy
[src]

impl<B, C> Debug for ControlFlow<B, C> where
    C: Debug,
    B: Debug
[src]

impl<B, C> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C> where
    C: PartialEq<C>,
    B: PartialEq<B>, 
[src]

impl<B, C> StructuralPartialEq for ControlFlow<B, C>[src]

impl<B, C> Try for ControlFlow<B, C>[src]

type Ok = C

🔬 This is a nightly-only experimental API. (try_trait #42327)

The type of this value when viewed as successful.

type Error = B

🔬 This is a nightly-only experimental API. (try_trait #42327)

The type of this value when viewed as failed.

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

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.