# 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]

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

Returns a copy of the value. Read more

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

Performs copy-assignment from `source`. Read more

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

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

Formats the value using the given formatter. Read more

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

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

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

This method tests for `!=`.

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

#### `pub fn into_result(
self
) -> Result<<ControlFlow<B, C> as Try>::Ok, <ControlFlow<B, C> as Try>::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

#### `pub fn from_error(v: <ControlFlow<B, C> as Try>::Error) -> ControlFlow<B, C>`[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

#### `pub fn from_ok(v: <ControlFlow<B, C> as Try>::Ok) -> ControlFlow<B, C>`[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

## Auto Trait Implementations

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

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

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

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

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

## 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ⓘ

### Notable traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for &mut Rimpl<W: Write + ?Sized> Write for &mut W`
`[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ⓘ

### Notable traits for &'_ mut I

`impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for &mut Rimpl<W: Write + ?Sized> Write for &mut W`
`[src]

Mutably borrows from an owned value. Read more

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

#### `pub fn from(t: 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> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)`[src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into` #41263)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `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(value: 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.