Enhanced functions for Option

[orenbenkiki]

I found that defining the following made my code cleaner and shorter, something along these lins would be welcome in the standard library:

/// More operations for options.
pub trait WhenOption<T> {
    /// Call a function that borrows the value, if there is one.
    fn when_some(&self, action: &fn(&T));

    /// Call a function that borrows the mutable value, if there is one.
    fn mut_when_some(&mut self, action: &fn(&mut T));

    /// Call a function that takes the value, if there is one.
    fn take_some(self, action: &fn(T));

    /// Call a function that borrows the value, if there is one; otherwise
    /// return a default.
    fn when_some_or<U>(&self, default: U, action: &fn(&T) -> U) -> U;

    /// Call a function that borrows the mutable value, if there is one;
    /// otherwise return a default.
    fn mut_when_some_or<U>(&mut self, default: U, action: &fn(&mut T) -> U) -> U;

    /// Call a function that takes the value, if there is one; otherwise
    /// return a default.
    fn take_some_or<U>(self, default: U, action: &fn(T) -> U) -> U;

    /// Maps an `Option<T>` to `Option<U>` by applying a function to a contained value.
    fn when_map<U>(&self, f: &fn(&T) -> U) -> Option<U>;
}

/// More operations for options.
impl<T> WhenOption<T> for Option<T> {
    /// Call a function that borrows the value, if there is one.
    fn when_some(&self, action: &fn(&T)) {
        match self {
            &None => (),
            &Some(ref value) => action(value),
        }
    }

    /// Call a function that borrows the mutable value, if there is one.
    fn mut_when_some(&mut self, action: &fn(&mut T)) {
        match self {
            &None => (),
            &Some(ref mut value) => action(value),
        }
    }

    /// Call a function that takes the value, if there is one.
    fn take_some(self, action: &fn(T)) {
        match self {
            None => (),
            Some(value) => action(value),
        }
    }

    /// Call a function that borrows the value, if there is one; otherwise
    /// return a default.
    fn when_some_or<U>(&self, default: U, action: &fn(&T) -> U) -> U {
        match self {
            &None => default,
            &Some(ref value) => action(value),
        }
    }

    /// Call a function that borrows the mutable value, if there is one;
    /// otherwise return a default.
    fn mut_when_some_or<U>(&mut self, default: U, action: &fn(&mut T) -> U) -> U {
        match self {
            &None => default,
            &Some(ref mut value) => action(value),
        }
    }

    /// Call a function that takes the value, if there is one; otherwise
    /// return a default.
    fn take_some_or<U>(self, default: U, action: &fn(T) -> U) -> U {
        match self {
            None => default,
            Some(value) => action(value),
        }
    }

    /// Maps an `Option<T>` to `Option<U>` by applying a function to a contained value.
    fn when_map<U>(&self, f: &fn(&T) -> U) -> Option<U> {
        match self {
            &Some(ref value) => Some(f(value)),
            &None => None,
        }
    }
}

[orenbenkiki]

This is a good example of why issue #10296 is relevant. All the actions used by the methods are invoked exactly once, are not sent to another task, and should allow access to borrowed pointers, moving values, mutating environment variables, etc.

That is, basically anything written as:

match option {
    &None => (),
    &Some(ref value) => { ... stuff here ... },
}

Should be able to be written as:

option.when_some |value| { ... stuff here ... }

Well, except for return statements, anyway (but that's a whole different discussion :-).

[thestinger]

I don't really understand how these are different from the existing methods. when_some, mut_when_some and take_some look like as_ref().map, as_mut().map and map.

[orenbenkiki]

Oops, you are absolutely right. Withdrawn.

[orenbenkiki]

Fixing the code I found this edge case:

do option.map |value| { fail!("unexpected value: {} ...", value, ...); }

This doesn't compile because the compiler can't decide what the return type of the block is. What is needed here is a function like map but that returns () and insists the function returns ().

I worked around the problem by writing:

do option.map_default(()) |value| { fail!("unexpected value: {} ...", value, ...); }

That's "not very nice", though.

[thestinger]

Ah, this seems like it could be considered a bug. If we used a Void type, it would be able to say the function returns Option<Void>.

[thestinger]

I opened #10352 about this.