# Enum core::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: Try> ControlFlow<R, R::Ok>`[src]

#### `pub fn from_try(r: R) -> Self`[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: Self`[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: Self`[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: Clone, C: Clone> Clone for ControlFlow<B, C>`[src]

#### `fn clone(&self) -> ControlFlow<B, C>`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

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

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result`[src]

Formats the value using the given formatter. Read more

### `impl<B, C> FromResidual<<ControlFlow<B, C> as Try>::Residual> for ControlFlow<B, C>`[src]

#### `fn from_residual(residual: ControlFlow<B, Infallible>) -> Self`[src]

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

Constructs the type from a compatible `Residual` type. Read more

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

#### `fn eq(&self, other: &ControlFlow<B, C>) -> bool`[src]

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

#### `fn ne(&self, other: &ControlFlow<B, C>) -> bool`[src]

This method tests for `!=`.

### `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.

#### `fn into_result(self) -> Result<Self::Ok, Self::Error>`[src]

🔬 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. Read more

#### `fn from_error(v: Self::Error) -> Self`[src]

🔬 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. Read more

#### `fn from_ok(v: Self::Ok) -> Self`[src]

🔬 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. Read more

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

#### `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. Read more

#### `fn from_output(output: Self::Output) -> Self`[src]

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

Constructs the type from its `Output` type. Read more

#### `fn branch(self) -> ControlFlow<Self::Residual, Self::Output>`[src]

🔬 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`). Read more

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

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

## Auto Trait Implementations

### `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,`

## Blanket Implementations

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

#### `pub fn type_id(&Self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

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

#### `pub fn borrow(&Self) -> &T`[src]

Immutably borrows from an owned value. Read more

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

#### `pub fn borrow_mut(&mut Self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

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

#### `pub fn from(T) -> T`[src]

Performs the conversion.

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

#### `pub fn into(Self) -> U`[src]

Performs the conversion.

### `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.

#### `pub fn try_from(U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `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.

#### `pub fn try_into(Self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.