Enum core::ops::ControlFlow

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

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

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>

pub fn is_break(&self) -> bool

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

pub fn is_continue(&self) -> bool

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

pub fn break_value(self) -> Option<B>

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

pub 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 #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: Try> ControlFlow<R, R::Ok>

pub fn from_try(r: R) -> Self

🔬 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

🔬 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, ()>

pub const CONTINUE: Self

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

impl<C> ControlFlow<(), C>

pub const BREAK: Self

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

Trait Implementations

impl<B: Clone, C: Clone> Clone for ControlFlow<B, C>

fn clone(&self) -> ControlFlow<B, C>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Debug, C: Debug> Debug for ControlFlow<B, C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B, C> FromResidual<<ControlFlow<B, C> as Try>::Residual> for ControlFlow<B, C>

fn from_residual(residual: ControlFlow<B, Infallible>) -> Self

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

Constructs the type from a compatible Residual type.

impl<B: PartialEq, C: PartialEq> PartialEq<ControlFlow<B, C>> for ControlFlow<B, C>

fn eq(&self, other: &ControlFlow<B, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ControlFlow<B, C>) -> bool

This method tests for !=.

impl<B, C> Try for ControlFlow<B, C>

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.

fn into_result(self) -> Result<Self::Ok, Self::Error>

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

Applies the “?” operator. A return of Ok(t) means that the execution should continue normally, and the result of ? is the value t. A return of Err(e) means that execution should branch to the innermost enclosing catch, or return from the function.

fn from_error(v: Self::Error) -> Self

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

Wrap an error value to construct the composite result. For example, Result::Err(x) and Result::from_error(x) are equivalent.

fn from_ok(v: Self::Ok) -> Self

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

Wrap an OK value to construct the composite result. For example, Result::Ok(x) and Result::from_ok(x) are equivalent.

impl<B, C> Try for ControlFlow<B, C>

type Output = C

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

The type of the value produced by ? when not short-circuiting.

type Residual = ControlFlow<B, Infallible>

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

The type of the value passed to FromResidual::from_residual as part of ? when short-circuiting.

fn from_output(output: Self::Output) -> Self

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

Constructs the type from its Output type.

fn branch(self) -> ControlFlow<Self::Residual, Self::Output>

🔬 This is a nightly-only experimental API. (try_trait_v2 #84277)

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).

impl<B: Copy, C: Copy> Copy for ControlFlow<B, C>

impl<B, C> StructuralPartialEq for ControlFlow<B, C>