Struct OptionBrand 

pub struct OptionBrand;

Brand for Option.

Trait Implementations

impl ApplyFirst for OptionBrand

fn apply_first<'a, A: 'a + Clone, B: 'a + Clone>( fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, fb: <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>

Combines two contexts, keeping the value from the first context.

impl ApplySecond for OptionBrand

fn apply_second<'a, A: 'a + Clone, B: 'a + Clone>( fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, fb: <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>

Combines two contexts, keeping the value from the second context.

impl Clone for OptionBrand

fn clone(&self) -> OptionBrand

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Compactable for OptionBrand

fn compact<'a, A: 'a>( fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, <OptionBrand as Kind_cdc7cd43dac7585f>::Of<'a, A>>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>

Compacts a nested option.

This method flattens a nested option.

Type Signature

forall self a. Compactable self => self (Option a) -> self a

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the elements.

Parameters

• fa: The nested option.

Returns

The flattened option.

Examples

use fp_library::functions::*;
use fp_library::brands::OptionBrand;

let x = Some(Some(5));
let y = compact::<OptionBrand, _>(x);
assert_eq!(y, Some(5));

fn separate<'a, O: 'a, E: 'a>( fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, Result<O, E>>, ) -> Pair<<Self as Kind_cdc7cd43dac7585f>::Of<'a, O>, <Self as Kind_cdc7cd43dac7585f>::Of<'a, E>>

Separates an option of result.

This method separates an option of result into a pair of options.

Type Signature

forall self o e. Compactable self => self (Result o e) -> Pair (self o) (self e)

Type Parameters

• 'a: The lifetime of the values.
• O: The type of the success value.
• E: The type of the error value.

Parameters

• fa: The option of result.

Returns

A pair of options.

Examples

use fp_library::{brands::*, functions::*, types::*};

let x: Option<Result<i32, &str>> = Some(Ok(5));
let Pair(oks, errs) = separate::<OptionBrand, _, _>(x);
assert_eq!(oks, Some(5));
assert_eq!(errs, None);

impl Debug for OptionBrand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for OptionBrand

fn default() -> OptionBrand

Returns the “default value” for a type.

impl Filterable for OptionBrand

fn partition_map<'a, A: 'a, O: 'a, E: 'a, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> Pair<<Self as Kind_cdc7cd43dac7585f>::Of<'a, O>, <Self as Kind_cdc7cd43dac7585f>::Of<'a, E>>

where Func: Fn(A) -> Result<O, E> + 'a,

Partitions an option based on a function that returns a result.

This method partitions an option based on a function that returns a result.

Type Signature

forall self a o e. Filterable self => (a -> Result o e, self a) -> Pair (self o) (self e)

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the input value.
• O: The type of the success value.
• E: The type of the error value.
• Func: The type of the function to apply.

Parameters

• func: The function to apply.
• fa: The option to partition.

Returns

A pair of options.

Examples

use fp_library::{brands::*, functions::*, types::*};

let x = Some(5);
let Pair(oks, errs) = partition_map::<OptionBrand, _, _, _, _>(|a| if a > 2 { Ok(a) } else { Err(a) }, x);
assert_eq!(oks, Some(5));
assert_eq!(errs, None);

fn partition<'a, A: 'a + Clone, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> Pair<<Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>>

where Func: Fn(A) -> bool + 'a,

Partitions an option based on a predicate.

This method partitions an option based on a predicate.

Type Signature

forall self a. Filterable self => (a -> bool, self a) -> Pair (self a) (self a)

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the elements.
• Func: The type of the predicate.

Parameters

• func: The predicate.
• fa: The option to partition.

Returns

A pair of options.

Examples

use fp_library::{brands::*, functions::*, types::*};

let x = Some(5);
let Pair(satisfied, not_satisfied) = partition::<OptionBrand, _, _>(|a| a > 2, x);
assert_eq!(satisfied, Some(5));
assert_eq!(not_satisfied, None);

fn filter_map<'a, A: 'a, B: 'a, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>

where Func: Fn(A) -> Option<B> + 'a,

Maps a function over an option and filters out None results.

This method maps a function over an option and filters out None results.

Type Signature

forall self a b. Filterable self => (a -> Option b, self a) -> self b

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the input value.
• B: The type of the result of applying the function.
• Func: The type of the function to apply.

Parameters

• func: The function to apply.
• fa: The option to filter and map.

Returns

The filtered and mapped option.

Examples

use fp_library::functions::*;
use fp_library::brands::OptionBrand;

let x = Some(5);
let y = filter_map::<OptionBrand, _, _, _>(|a| if a > 2 { Some(a * 2) } else { None }, x);
assert_eq!(y, Some(10));

fn filter<'a, A: 'a + Clone, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>

where Func: Fn(A) -> bool + 'a,

Filters an option based on a predicate.

This method filters an option based on a predicate.

Type Signature

forall self a. Filterable self => (a -> bool, self a) -> self a

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the elements.
• Func: The type of the predicate.

Parameters

• func: The predicate.
• fa: The option to filter.

Returns

The filtered option.

Examples

use fp_library::functions::*;
use fp_library::brands::OptionBrand;

let x = Some(5);
let y = filter::<OptionBrand, _, _>(|a| a > 2, x);
assert_eq!(y, Some(5));

impl Foldable for OptionBrand

fn fold_right<'a, FnBrand, A: 'a, B: 'a, Func>( func: Func, initial: B, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> B

where Func: Fn(A, B) -> B + 'a, FnBrand: CloneableFn + 'a,

Folds the option from the right.

This method performs a right-associative fold of the option. If the option is Some(a), it applies the function to a and the initial value. If None, it returns the initial value.

Type Signature

forall self a b. Foldable self => ((a, b) -> b, b, self a) -> b

Type Parameters

• 'a: The lifetime of the values.
• FnBrand: The brand of the cloneable function to use.
• A: The type of the elements in the structure.
• B: The type of the accumulator.
• Func: The type of the folding function.

Parameters

• func: The folding function.
• initial: The initial value.
• fa: The option to fold.

Returns

func(a, initial) if fa is Some(a), otherwise initial.

Examples

use fp_library::{brands::*, functions::*};

let x = Some(5);
let y = fold_right::<RcFnBrand, OptionBrand, _, _, _>(|a, b| a + b, 10, x);
assert_eq!(y, 15);

fn fold_left<'a, FnBrand, A: 'a, B: 'a, Func>( func: Func, initial: B, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> B

where Func: Fn(B, A) -> B + 'a, FnBrand: CloneableFn + 'a,

Folds the option from the left.

This method performs a left-associative fold of the option. If the option is Some(a), it applies the function to the initial value and a. If None, it returns the initial value.

Type Signature

forall self a b. Foldable self => ((b, a) -> b, b, self a) -> b

Type Parameters

• 'a: The lifetime of the values.
• FnBrand: The brand of the cloneable function to use.
• A: The type of the elements in the structure.
• B: The type of the accumulator.
• Func: The type of the folding function.

Parameters

• func: The function to apply to the accumulator and each element.
• initial: The initial value of the accumulator.
• fa: The option to fold.

Returns

f(initial, a) if fa is Some(a), otherwise initial.

Examples

use fp_library::{brands::*, functions::*};

let x = Some(5);
let y = fold_left::<RcFnBrand, OptionBrand, _, _, _>(|b, a| b + a, 10, x);
assert_eq!(y, 15);

fn fold_map<'a, FnBrand, A: 'a, M, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> M

where M: Monoid + 'a, Func: Fn(A) -> M + 'a, FnBrand: CloneableFn + 'a,

Maps the value to a monoid and returns it, or returns empty.

This method maps the element of the option to a monoid. If the option is None, it returns the monoid’s identity element.

Type Signature

forall self a m. (Foldable self, Monoid m) => (a -> m, self a) -> m

Type Parameters

• 'a: The lifetime of the values.
• FnBrand: The brand of the cloneable function to use.
• A: The type of the elements in the structure.
• M: The type of the monoid.
• Func: The type of the mapping function.

Parameters

• func: The mapping function.
• fa: The option to fold.

Returns

func(a) if fa is Some(a), otherwise M::empty().

Examples

use fp_library::{brands::*, functions::*};

let x = Some(5);
let y = fold_map::<RcFnBrand, OptionBrand, _, _, _>(|a: i32| a.to_string(), x);
assert_eq!(y, "5".to_string());

impl Functor for OptionBrand

fn map<'a, A: 'a, B: 'a, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>

where Func: Fn(A) -> B + 'a,

Maps a function over the value in the option.

This method applies a function to the value inside the option, producing a new option with the transformed value. If the option is None, it returns None.

Type Signature

forall self a b. Functor self => (a -> b, self a) -> self b

Type Parameters

• 'a: The lifetime of the value.
• A: The type of the value inside the option.
• B: The type of the result of applying the function.
• Func: The type of the function to apply.

Parameters

• func: The function to apply to the value.
• fa: The option to map over.

Returns

A new option containing the result of applying the function, or None.

Examples

use fp_library::{brands::*, functions::*};

let x = Some(5);
let y = map::<OptionBrand, _, _, _>(|i| i * 2, x);
assert_eq!(y, Some(10));

impl Hash for OptionBrand

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Kind_cdc7cd43dac7585f for OptionBrand

Generated implementation of Kind_cdc7cd43dac7585f for OptionBrand.

type Of<'a, A: 'a> = Option<A>

The applied type.

impl Lift for OptionBrand

fn lift2<'a, A, B, C, Func>( func: Func, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, fb: <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, C>

where Func: Fn(A, B) -> C + 'a, A: 'a, B: 'a, C: 'a,

Lifts a binary function into the option context.

This method lifts a binary function to operate on values within the option context.

Type Signature

forall self a b c. Lift self => ((a, b) -> c, self a, self b) -> self c

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the first option’s value.
• B: The type of the second option’s value.
• C: The return type of the function.
• Func: The type of the binary function.

Parameters

• func: The binary function to apply.
• fa: The first option.
• fb: The second option.

Returns

Some(f(a, b)) if both options are Some, otherwise None.

Examples

use fp_library::{brands::*, functions::*};

let x = Some(1);
let y = Some(2);
let z = lift2::<OptionBrand, _, _, _, _>(|a, b| a + b, x, y);
assert_eq!(z, Some(3));

impl Ord for OptionBrand

fn cmp(&self, other: &OptionBrand) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl ParFoldable for OptionBrand

fn par_fold_map<'a, FnBrand, A, M>( func: <FnBrand as SendCloneableFn>::SendOf<'a, A, M>, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> M

where FnBrand: 'a + SendCloneableFn, A: 'a + Clone + Send + Sync, M: Monoid + Send + Sync + 'a,

Maps the value to a monoid and returns it, or returns empty, in parallel.

This method maps the element of the option to a monoid. Since Option contains at most one element, no actual parallelism occurs, but the interface is satisfied.

Type Signature

forall self a m. (ParFoldable self, Monoid m) => (a -> m, self a) -> m

Type Parameters

• 'a: The lifetime of the values.
• FnBrand: The brand of the cloneable function wrapper.
• A: The element type.
• M: The monoid type.

Parameters

• func: The mapping function.
• fa: The option to fold.

Returns

The combined monoid value.

Examples

use fp_library::{brands::*, functions::*};

let x = Some(1);
let f = send_cloneable_fn_new::<ArcFnBrand, _, _>(|x: i32| x.to_string());
let y = par_fold_map::<ArcFnBrand, OptionBrand, _, _>(f, x);
assert_eq!(y, "1".to_string());

fn par_fold_right<'a, FnBrand, A, B>( func: <FnBrand as SendCloneableFn>::SendOf<'a, (A, B), B>, init: B, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> B

where A: 'a + Clone + Send + Sync, B: Send + Sync + 'a, FnBrand: 'a + SendCloneableFn,

Parallel version of fold_right.

impl PartialEq for OptionBrand

fn eq(&self, other: &OptionBrand) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for OptionBrand

fn partial_cmp(&self, other: &OptionBrand) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Pointed for OptionBrand

fn pure<'a, A: 'a>(a: A) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>

Wraps a value in an option.

This method wraps a value in an option context.

Type Signature

forall self a. Pointed self => a -> self a

Type Parameters

• 'a: The lifetime of the value.
• A: The type of the value to wrap.

Parameters

• a: The value to wrap.

Returns

Some(a).

Examples

use fp_library::functions::*;
use fp_library::brands::OptionBrand;

let x = pure::<OptionBrand, _>(5);
assert_eq!(x, Some(5));

impl Semiapplicative for OptionBrand

fn apply<'a, FnBrand: 'a + CloneableFn, A: 'a + Clone, B: 'a>( ff: <Self as Kind_cdc7cd43dac7585f>::Of<'a, <FnBrand as CloneableFn>::Of<'a, A, B>>, fa: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>

Applies a wrapped function to a wrapped value.

This method applies a function wrapped in an option to a value wrapped in an option.

Type Signature

forall self a b. Semiapplicative self => (self (a -> b), self a) -> self b

Type Parameters

• 'a: The lifetime of the values.
• FnBrand: The brand of the cloneable function wrapper.
• A: The type of the input value.
• B: The type of the output value.

Parameters

• ff: The option containing the function.
• fa: The option containing the value.

Returns

Some(f(a)) if both are Some, otherwise None.

Examples

use fp_library::{brands::*, classes::*, functions::*};

let f = Some(cloneable_fn_new::<RcFnBrand, _, _>(|x: i32| x * 2));
let x = Some(5);
let y = apply::<RcFnBrand, OptionBrand, _, _>(f, x);
assert_eq!(y, Some(10));

impl Semimonad for OptionBrand

fn bind<'a, A: 'a, B: 'a, Func>( ma: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, func: Func, ) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>

where Func: Fn(A) -> <Self as Kind_cdc7cd43dac7585f>::Of<'a, B> + 'a,

Chains option computations.

This method chains two option computations, where the second computation depends on the result of the first.

Type Signature

forall self a b. Semimonad self => (self a, a -> self b) -> self b

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the result of the first computation.
• B: The type of the result of the second computation.
• Func: The type of the function to apply.

Parameters

• ma: The first option.
• func: The function to apply to the value inside the option.

Returns

The result of applying f to the value if ma is Some, otherwise None.

Examples

use fp_library::functions::*;
use fp_library::brands::OptionBrand;

let x = Some(5);
let y = bind::<OptionBrand, _, _, _>(x, |i| Some(i * 2));
assert_eq!(y, Some(10));

impl Traversable for OptionBrand

fn traverse<'a, A: 'a + Clone, B: 'a + Clone, F: Applicative, Func>( func: Func, ta: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>>

where Func: Fn(A) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, B> + 'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>: Clone,

Traverses the option with an applicative function.

This method maps the element of the option to a computation, evaluates it, and wraps the result in the applicative context. If None, it returns pure(None).

Type Signature

forall self a b f. (Traversable self, Applicative f) => (a -> f b, self a) -> f (self b)

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the elements in the traversable structure.
• B: The type of the elements in the resulting traversable structure.
• F: The applicative context.
• Func: The type of the function to apply.

Parameters

• func: The function to apply to each element, returning a value in an applicative context.
• ta: The option to traverse.

Returns

The option wrapped in the applicative context.

Examples

use fp_library::functions::*;
use fp_library::brands::OptionBrand;

let x = Some(5);
let y = traverse::<OptionBrand, _, _, OptionBrand, _>(|a| Some(a * 2), x);
assert_eq!(y, Some(Some(10)));

fn sequence<'a, A: 'a + Clone, F: Applicative>( ta: <Self as Kind_cdc7cd43dac7585f>::Of<'a, <F as Kind_cdc7cd43dac7585f>::Of<'a, A>>, ) -> <F as Kind_cdc7cd43dac7585f>::Of<'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>>

where <F as Kind_cdc7cd43dac7585f>::Of<'a, A>: Clone, <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>: Clone,

Sequences an option of applicative.

This method evaluates the computation inside the option and wraps the result in the applicative context. If None, it returns pure(None).

Type Signature

forall self a f. (Traversable self, Applicative f) => self (f a) -> f (self a)

Type Parameters

• 'a: The lifetime of the values.
• A: The type of the elements in the traversable structure.
• F: The applicative context.

Parameters

• ta: The option containing the applicative value.

Returns

The option wrapped in the applicative context.

Examples

use fp_library::functions::*;
use fp_library::brands::OptionBrand;

let x = Some(Some(5));
let y = sequence::<OptionBrand, _, OptionBrand>(x);
assert_eq!(y, Some(Some(5)));

impl Witherable for OptionBrand

fn wilt<'a, M: Applicative, A: 'a + Clone, O: 'a + Clone, E: 'a + Clone, Func>( func: Func, ta: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <M as Kind_cdc7cd43dac7585f>::Of<'a, Pair<<Self as Kind_cdc7cd43dac7585f>::Of<'a, O>, <Self as Kind_cdc7cd43dac7585f>::Of<'a, E>>>

where Func: Fn(A) -> <M as Kind_cdc7cd43dac7585f>::Of<'a, Result<O, E>> + 'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, Result<O, E>>: Clone, <M as Kind_cdc7cd43dac7585f>::Of<'a, Result<O, E>>: Clone,

Partitions an option based on a function that returns a result in an applicative context.

This method partitions an option based on a function that returns a result in an applicative context.

Type Signature

forall self m a o e. (Witherable self, Applicative m) => (a -> m (Result o e), self a) -> m (Pair (self o) (self e))

Type Parameters

• 'a: The lifetime of the values.
• M: The applicative context.
• A: The type of the elements in the input structure.
• O: The type of the success values.
• E: The type of the error values.
• Func: The type of the function to apply.

Parameters

• func: The function to apply to each element, returning a Result in an applicative context.
• ta: The option to partition.

Returns

The partitioned option wrapped in the applicative context.

Examples

use fp_library::{functions::*, brands::*, types::*};

let x = Some(5);
let y = wilt::<OptionBrand, OptionBrand, _, _, _, _>(|a| Some(if a > 2 { Ok(a) } else { Err(a) }), x);
assert_eq!(y, Some(Pair(Some(5), None)));

fn wither<'a, M: Applicative, A: 'a + Clone, B: 'a + Clone, Func>( func: Func, ta: <Self as Kind_cdc7cd43dac7585f>::Of<'a, A>, ) -> <M as Kind_cdc7cd43dac7585f>::Of<'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, B>>

where Func: Fn(A) -> <M as Kind_cdc7cd43dac7585f>::Of<'a, Option<B>> + 'a, <Self as Kind_cdc7cd43dac7585f>::Of<'a, Option<B>>: Clone, <M as Kind_cdc7cd43dac7585f>::Of<'a, Option<B>>: Clone,

Maps a function over an option and filters out None results in an applicative context.

This method maps a function over an option and filters out None results in an applicative context.

Type Signature

forall self m a b. (Witherable self, Applicative m) => (a -> m (Option b), self a) -> m (self b)

Type Parameters

• 'a: The lifetime of the values.
• M: The applicative context.
• A: The type of the elements in the input structure.
• B: The type of the result of applying the function.
• Func: The type of the function to apply.

Parameters

• func: The function to apply to each element, returning an Option in an applicative context.
• ta: The option to filter and map.

Returns

The filtered and mapped option wrapped in the applicative context.

Examples

use fp_library::{functions::*, brands::*};

let x = Some(5);
let y = wither::<OptionBrand, OptionBrand, _, _, _>(|a| Some(if a > 2 { Some(a * 2) } else { None }), x);
assert_eq!(y, Some(Some(10)));

impl Copy for OptionBrand

impl Eq for OptionBrand

impl StructuralPartialEq for OptionBrand