Enum frunk_core::coproduct::Coproduct[][src]

pub enum Coproduct<H, T> {
    Inl(H),
    Inr(T),
}
Expand description

Enum type representing a Coproduct. Think of this as a Result, but capable of supporting any arbitrary number of types instead of just 2.

To construct a Coproduct, you would typically declare a type using the Coprod! type macro and then use the inject method.

Examples

type I32Bool = Coprod!(i32, bool);
let co1 = I32Bool::inject(3);
let get_from_1a: Option<&i32> = co1.get();
let get_from_1b: Option<&bool> = co1.get();
assert_eq!(get_from_1a, Some(&3));
assert_eq!(get_from_1b, None);
Run

Variants

Inl(H)

Coproduct is either H or T, in this case, it is H

Tuple Fields of Inl

0: H
Inr(T)

Coproduct is either H or T, in this case, it is T

Tuple Fields of Inr

0: T

Implementations

Instantiate a coproduct from an element.

This is generally much nicer than nested usage of Coproduct::{Inl, Inr}. The method uses a trick with type inference to automatically build the correct variant according to the input type.

In standard usage, the Index type parameter can be ignored, as it will typically be solved for using type inference.

Rules

If the type does not appear in the coproduct, the conversion is forbidden.

If the type appears multiple times in the coproduct, type inference will fail.

Example
use frunk::Coproduct;

type I32F32 = Coprod!(i32, f32);

// Constructing coproducts using inject:
let co1_nice: I32F32 = Coproduct::inject(1i32);
let co2_nice: I32F32 = Coproduct::inject(42f32);

// Compare this to the "hard way":
let co1_ugly: I32F32 = Coproduct::Inl(1i32);
let co2_ugly: I32F32 = Coproduct::Inr(Coproduct::Inl(42f32));

assert_eq!(co1_nice, co1_ugly);
assert_eq!(co2_nice, co2_ugly);

// Feel free to use `inject` on a type alias, or even directly on the
// `Coprod!` macro. (the latter requires wrapping the type in `<>`)
let _ = I32F32::inject(42f32);
let _ = <Coprod!(i32, f32)>::inject(42f32);

// You can also use a turbofish to specify the type of the input when
// it is ambiguous (e.g. an empty `vec![]`).
// The Index parameter should be left as `_`.
type Vi32Vf32 = Coprod!(Vec<i32>, Vec<f32>);
let _: Vi32Vf32 = Coproduct::inject::<Vec<i32>, _>(vec![]);
Run

Borrow an element from a coproduct by type.

Example
type I32F32 = Coprod!(i32, f32);

// You can let type inference find the desired type:
let co1 = I32F32::inject(42f32);
let co1_as_i32: Option<&i32> = co1.get();
let co1_as_f32: Option<&f32> = co1.get();
assert_eq!(co1_as_i32, None);
assert_eq!(co1_as_f32, Some(&42f32));

// You can also use turbofish syntax to specify the type.
// The Index parameter should be left as `_`.
let co2 = I32F32::inject(1i32);
assert_eq!(co2.get::<i32, _>(), Some(&1));
assert_eq!(co2.get::<f32, _>(), None);
Run

Retrieve an element from a coproduct by type, ignoring all others.

Example
type I32F32 = Coprod!(i32, f32);

// You can let type inference find the desired type:
let co1 = I32F32::inject(42f32);
let co1_as_i32: Option<i32> = co1.take();
let co1_as_f32: Option<f32> = co1.take();
assert_eq!(co1_as_i32, None);
assert_eq!(co1_as_f32, Some(42f32));

// You can also use turbofish syntax to specify the type.
// The Index parameter should be left as `_`.
let co2 = I32F32::inject(1i32);
assert_eq!(co2.take::<i32, _>(), Some(1));
assert_eq!(co2.take::<f32, _>(), None);
Run

Attempt to extract a value from a coproduct (or get the remaining possibilities).

By chaining calls to this, one can exhaustively match all variants of a coproduct.

Examples

Basic usage:

type I32F32 = Coprod!(i32, f32);
type I32 = Coprod!(i32); // remainder after uninjecting f32
type F32 = Coprod!(f32); // remainder after uninjecting i32

let co1 = I32F32::inject(42f32);

// You can let type inference find the desired type.
let co1 = I32F32::inject(42f32);
let co1_as_i32: Result<i32, F32> = co1.uninject();
let co1_as_f32: Result<f32, I32> = co1.uninject();
assert_eq!(co1_as_i32, Err(F32::inject(42f32)));
assert_eq!(co1_as_f32, Ok(42f32));

// It is not necessary to annotate the type of the remainder:
let res: Result<i32, _> = co1.uninject();
assert!(res.is_err());

// You can also use turbofish syntax to specify the type.
// The Index parameter should be left as `_`.
let co2 = I32F32::inject(1i32);
assert_eq!(co2.uninject::<i32, _>(), Ok(1));
assert_eq!(co2.uninject::<f32, _>(), Err(I32::inject(1)));
Run

Chaining calls for an exhaustive match:

type I32F32 = Coprod!(i32, f32);

// Be aware that this particular example could be
// written far more succinctly using `fold`.
fn handle_i32_f32(co: I32F32) -> &'static str {
    // Remove i32 from the coproduct
    let co = match co.uninject::<i32, _>() {
        Ok(x) => return "integer!",
        Err(co) => co,
    };

    // Remove f32 from the coproduct
    let co = match co.uninject::<f32, _>() {
        Ok(x) => return "float!",
        Err(co) => co,
    };

    // Now co is empty
    match co { /* unreachable */ }
}

assert_eq!(handle_i32_f32(I32F32::inject(3)), "integer!");
assert_eq!(handle_i32_f32(I32F32::inject(3.0)), "float!");
Run

Extract a subset of the possible types in a coproduct (or get the remaining possibilities)

This is basically uninject on steroids. It lets you remove a number of types from a coproduct at once, leaving behind the remainder in an Err. For instance, one can extract Coprod!(C, A) from Coprod!(A, B, C, D) to produce Result<Coprod!(C, A), Coprod!(B, D)>.

Each type in the extracted subset is required to be part of the input coproduct.

Example

Basic usage:

use ::frunk::Coproduct;

type I32BoolF32 = Coprod!(i32, bool, f32);
type I32F32 = Coprod!(i32, f32);

let co1 = I32BoolF32::inject(42_f32);
let co2 = I32BoolF32::inject(true);

let sub1: Result<Coprod!(i32, f32), _> = co1.subset();
let sub2: Result<Coprod!(i32, f32), _> = co2.subset();
assert!(sub1.is_ok());
assert!(sub2.is_err());

// Turbofish syntax for specifying the target subset is also supported.
// The Indices parameter should be left to type inference using `_`.
assert!(co1.subset::<Coprod!(i32, f32), _>().is_ok());
assert!(co2.subset::<Coprod!(i32, f32), _>().is_err());

// Order doesn't matter.
assert!(co1.subset::<Coprod!(f32, i32), _>().is_ok());
Run

Like uninject, subset can be used for exhaustive matching, with the advantage that it can remove more than one type at a time:

use frunk::Coproduct;

fn handle_stringly_things(co: Coprod!(&'static str, String)) -> String {
    co.fold(hlist![
        |s| format!("&str {}", s),
        |s| format!("String {}", s),
    ])
}

fn handle_countly_things(co: Coprod!(u32)) -> String {
    co.fold(hlist![
        |n| vec!["."; n as usize].concat(),
    ])
}

fn handle_all(co: Coprod!(String, u32, &'static str)) -> String {
    // co is currently Coprod!(String, u32, &'static str)
    let co = match co.subset().map(handle_stringly_things) {
        Ok(s) => return s,
        Err(co) => co,
    };

    // Now co is Coprod!(u32).
    let co = match co.subset().map(handle_countly_things) {
        Ok(s) => return s,
        Err(co) => co,
    };

    // Now co is empty.
    match co { /* unreachable */ }
}

assert_eq!(handle_all(Coproduct::inject("hello")), "&str hello");
assert_eq!(handle_all(Coproduct::inject(String::from("World!"))), "String World!");
assert_eq!(handle_all(Coproduct::inject(4)), "....");
Run

Convert a coproduct into another that can hold its variants.

This converts a coproduct into another one which is capable of holding each of its types. The most well-supported use-cases (i.e. those where type inference is capable of solving for the indices) are:

  • Reordering variants: Coprod!(C, A, B) -> Coprod!(A, B, C)
  • Embedding into a superset: Coprod!(B, D) -> Coprod!(A, B, C, D, E)
  • Coalescing duplicate inputs: Coprod!(B, B, B, B) -> Coprod!(A, B, C)

and of course any combination thereof.

Rules

If any type in the input does not appear in the output, the conversion is forbidden.

If any type in the input appears multiple times in the output, type inference will fail.

All of these rules fall naturally out of its fairly simple definition, which is equivalent to:

coprod.fold(hlist![
    |x| Coproduct::inject(x),
    |x| Coproduct::inject(x),
            ...
    |x| Coproduct::inject(x),
])
Example
type I32BoolF32 = Coprod!(i32, bool, f32);
type BoolI32 = Coprod!(bool, i32);

let co = BoolI32::inject(true);
let embedded: I32BoolF32 = co.embed();
assert_eq!(embedded, I32BoolF32::inject(true));

// Turbofish syntax for specifying the output type is also supported.
// The Indices parameter should be left to type inference using `_`.
let embedded = co.embed::<I32BoolF32, _>();
assert_eq!(embedded, I32BoolF32::inject(true));
Run

Borrow each variant of the Coproduct.

Example

Composing with subset to match a subset of variants without consuming the coproduct:

use frunk::Coproduct;

let co: Coprod!(i32, bool, String) = Coproduct::inject(true);

assert!(co.to_ref().subset::<Coprod!(&bool, &String), _>().is_ok());
Run

Borrow each variant of the Coproduct mutably.

Example

Composing with subset to match a subset of variants without consuming the coproduct:

use frunk::Coproduct;

let mut co: Coprod!(i32, bool, String) = Coproduct::inject(true);

assert!(co.to_mut().subset::<Coprod!(&mut bool, &mut String), _>().is_ok());
Run

Use functions to transform a Coproduct into a single value.

A variety of types are supported for the Folder argument:

  • An hlist![] of closures (one for each type, in order).
  • A single closure (for a Coproduct that is homogenous).
  • A single Poly.
Example
type I32F32StrBool = Coprod!(i32, f32, bool);

let co1 = I32F32StrBool::inject(3);
let co2 = I32F32StrBool::inject(true);
let co3 = I32F32StrBool::inject(42f32);

let folder = hlist![|&i| format!("int {}", i),
                    |&f| format!("float {}", f),
                    |&b| (if b { "t" } else { "f" }).to_string()];

assert_eq!(co1.to_ref().fold(folder), "int 3".to_string());
Run

Using a polymorphic function type has the advantage of not forcing you to care about the order in which you declare handlers for the types in your Coproduct.

use frunk::{Poly, Func};

type I32F32StrBool = Coprod!(i32, f32, bool);

impl Func<i32> for P {
    type Output = bool;
    fn call(args: i32) -> Self::Output {
        args > 100
    }
}
impl Func<bool> for P {
    type Output = bool;
    fn call(args: bool) -> Self::Output {
        args
    }
}
impl Func<f32> for P {
    type Output = bool;
    fn call(args: f32) -> Self::Output {
        args > 9000f32
    }
}
struct P;

let co1 = I32F32StrBool::inject(3);
let folded = co1.fold(Poly(P));
Run

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Instantiate a coproduct from an element. Read more

Instantiate a coproduct from an element. Read more

Attempt to extract a value from a coproduct (or get the remaining possibilities). Read more

Attempt to extract a value from a coproduct (or get the remaining possibilities). Read more

Convert a coproduct into another that can hold its variants. Read more

Convert a coproduct into another that can hold its variants. Read more

Use functions to fold a coproduct into a single value. Read more

Use functions to fold a coproduct into a single value. Read more

Borrow an element from a coproduct by type. Read more

Borrow an element from a coproduct by type. Read more

Attempt to extract a value from a subset of the types.

Retrieve an element from a coproduct by type, ignoring all others. Read more

Retrieve an element from a coproduct by type, ignoring all others. Read more

Formats the value using the given formatter. Read more

Feeds this value into the given Hasher. Read more

Feeds a slice of this type into the given Hasher. Read more

This method returns an Ordering between self and other. Read more

Compares and returns the maximum of two values. Read more

Compares and returns the minimum of two values. Read more

Restrict a value to a certain interval. Read more

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

This method tests for !=.

This method returns an ordering between self and other values if one exists. Read more

This method tests less than (for self and other) and is used by the < operator. Read more

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

This method tests greater than (for self and other) and is used by the > operator. Read more

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Extract a subset of the possible types in a coproduct (or get the remaining possibilities) Read more

Attempt to extract a value from a subset of the types.

Performs the conversion.

Performs the conversion.

Performs the indexed conversion.

Consumes the current HList and returns an HList with the requested shape. Read more

The resulting type after obtaining ownership.

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

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

recently added

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

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.