Trait UnitExt

pub trait UnitExt: Sized {
    // Provided methods
    fn ret<T>(self, value: T) -> T { ... }
    fn ret_default<T: Default>(self) -> T { ... }
    fn ret_none<T>(self) -> Option<T> { ... }
    fn ret_some<T>(self, value: T) -> Option<T> { ... }
    fn ret_some_default<T: Default>(self) -> Option<T> { ... }
    fn ret_err<T, E>(self, value: E) -> Result<T, E> { ... }
    fn ret_err_default<T, E: Default>(self) -> Result<T, E> { ... }
    fn ret_ok<T, E>(self, value: T) -> Result<T, E> { ... }
    fn ret_ok_default<T: Default, E>(self) -> Result<T, E> { ... }
}

Extension methods for the unit type () that construct common wrapper values without explicit boiler-plate.

Import unit_ext to bring the trait into scope.

Examples

use unit_ext::*;

let ok:  Result<_, ()> = ().ret_ok(1);
let err: Result<u8, _> = ().ret_err("boom");

let some = ().ret_some("hi");
let none: Option<i32> = ().ret_none();

let vec: Vec<u8> = ().ret_default();

Provided Methods

fn ret<T>(self, value: T) -> T

Returns value.

This is mainly useful when syntactic symmetry with the other ret_* helpers is desired.

Examples

use unit_ext::*;
assert_eq!(().ret(42), 42);
assert_eq!({ 24; }.ret(42), 42); // Can cause a Clippy warning/error.
assert_eq!(println!("24").ret(42), 42);

Examples found in repository

examples/example.rs (line 11)

fn main() {
    Some(10)
        .filter(|n| n > &5)
        .map(|n| n * 2)
        .or_else(|| println!("Value too small").ret_none());

    Some(10)
        .map(|v| println!("Some({v})").ret(v + 10))
        .or_else(|| println!("Default value").ret_default());

    Some([1, 2, 3, 4])
        .map(|mut arr| arr.clone_from_slice(&[4, 3, 2, 1]).ret(arr));

    "10".parse::<u8>().map_or_else(
        |e| eprintln!("{e}").ret_none(),
        |v| println!("Got here").ret_some(v.add(10)),
    );

    match "15".parse::<u8>() {
        Ok(v) => v.add(15).into(),
        Err(e) => eprintln!("{e}").ret_none(),
    };

    // One can also use do something like this:
    "15".parse::<u8>()
        .inspect_err(|e| eprintln!("{e}"))
        .ok()
        .map(|v| v + 15);
}

fn ret_default<T: Default>(self) -> T

Returns T::default().

Examples

use unit_ext::*;
let v: Vec<u8> = println!("Creating empty vec").ret_default();
assert!(v.is_empty());

Examples found in repository

examples/example.rs (line 12)

fn main() {
    Some(10)
        .filter(|n| n > &5)
        .map(|n| n * 2)
        .or_else(|| println!("Value too small").ret_none());

    Some(10)
        .map(|v| println!("Some({v})").ret(v + 10))
        .or_else(|| println!("Default value").ret_default());

    Some([1, 2, 3, 4])
        .map(|mut arr| arr.clone_from_slice(&[4, 3, 2, 1]).ret(arr));

    "10".parse::<u8>().map_or_else(
        |e| eprintln!("{e}").ret_none(),
        |v| println!("Got here").ret_some(v.add(10)),
    );

    match "15".parse::<u8>() {
        Ok(v) => v.add(15).into(),
        Err(e) => eprintln!("{e}").ret_none(),
    };

    // One can also use do something like this:
    "15".parse::<u8>()
        .inspect_err(|e| eprintln!("{e}"))
        .ok()
        .map(|v| v + 15);
}

fn ret_none<T>(self) -> Option<T>

Returns None.

Examples

use unit_ext::*;
let none = ().ret_none::<u8>();
assert_eq!(none, None);

Examples found in repository

examples/example.rs (line 8)

fn main() {
    Some(10)
        .filter(|n| n > &5)
        .map(|n| n * 2)
        .or_else(|| println!("Value too small").ret_none());

    Some(10)
        .map(|v| println!("Some({v})").ret(v + 10))
        .or_else(|| println!("Default value").ret_default());

    Some([1, 2, 3, 4])
        .map(|mut arr| arr.clone_from_slice(&[4, 3, 2, 1]).ret(arr));

    "10".parse::<u8>().map_or_else(
        |e| eprintln!("{e}").ret_none(),
        |v| println!("Got here").ret_some(v.add(10)),
    );

    match "15".parse::<u8>() {
        Ok(v) => v.add(15).into(),
        Err(e) => eprintln!("{e}").ret_none(),
    };

    // One can also use do something like this:
    "15".parse::<u8>()
        .inspect_err(|e| eprintln!("{e}"))
        .ok()
        .map(|v| v + 15);
}

fn ret_some<T>(self, value: T) -> Option<T>

Wraps value in Some and returns it.

value is passed through Into, matching the behaviour of Option::from.

Examples

use unit_ext::*;
let opt = ().ret_some(5);
assert_eq!(opt, Some(5));

Examples found in repository

examples/example.rs (line 19)

fn main() {
    Some(10)
        .filter(|n| n > &5)
        .map(|n| n * 2)
        .or_else(|| println!("Value too small").ret_none());

    Some(10)
        .map(|v| println!("Some({v})").ret(v + 10))
        .or_else(|| println!("Default value").ret_default());

    Some([1, 2, 3, 4])
        .map(|mut arr| arr.clone_from_slice(&[4, 3, 2, 1]).ret(arr));

    "10".parse::<u8>().map_or_else(
        |e| eprintln!("{e}").ret_none(),
        |v| println!("Got here").ret_some(v.add(10)),
    );

    match "15".parse::<u8>() {
        Ok(v) => v.add(15).into(),
        Err(e) => eprintln!("{e}").ret_none(),
    };

    // One can also use do something like this:
    "15".parse::<u8>()
        .inspect_err(|e| eprintln!("{e}"))
        .ok()
        .map(|v| v + 15);
}

fn ret_some_default<T: Default>(self) -> Option<T>

Returns Some(T::default()).

Examples

use unit_ext::*;
let s: Option<String> = ().ret_some_default();
assert_eq!(s, Some(String::new()));

fn ret_err<T, E>(self, value: E) -> Result<T, E>

Returns Err(value).

Examples

use unit_ext::*;
let e: Result<(), &str> = ().ret_err("nope");
assert!(e.is_err());

fn ret_err_default<T, E: Default>(self) -> Result<T, E>

Returns Err(E::default()).

Examples

use unit_ext::*;
let e: Result<i32, &str> = ().ret_err_default();
assert!(e.is_err());

fn ret_ok<T, E>(self, value: T) -> Result<T, E>

Returns Ok(value).

Examples

use unit_ext::*;
let ok = ().ret_ok::<_, ()>("yes");
assert_eq!(ok, Ok("yes"));

fn ret_ok_default<T: Default, E>(self) -> Result<T, E>

Returns Ok(T::default()).

Examples

use unit_ext::*;
let ok: Result<Vec<u8>, ()> = ().ret_ok_default();
assert_eq!(ok, Ok(Vec::new()));

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl UnitExt for ()

Implementors