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: Apply1L1T<'a, Self, A>, fb: Apply1L1T<'a, Self, B>, ) -> Apply1L1T<'a, Self, 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: Apply1L1T<'a, Self, A>, fb: Apply1L1T<'a, Self, B>, ) -> Apply1L1T<'a, Self, 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 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 Foldable for OptionBrand

fn fold_right<'a, A: 'a, B: 'a, F>( f: F, init: B, fa: Apply1L1T<'a, Self, A>, ) -> B

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

Folds the option from the right.

Type Signature

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

Parameters

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

Returns

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

Examples

use fp_library::classes::foldable::fold_right;
use fp_library::brands::OptionBrand;

assert_eq!(fold_right::<OptionBrand, _, _, _>(|x: i32, acc| x + acc, 0, Some(5)), 5);
assert_eq!(fold_right::<OptionBrand, _, _, _>(|x: i32, acc| x + acc, 0, None), 0);

fn fold_left<'a, A: 'a, B: 'a, F>( f: F, init: B, fa: Apply1L1T<'a, Self, A>, ) -> B

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

Folds the option from the left.

Type Signature

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

Parameters

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

Returns

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

Examples

use fp_library::classes::foldable::fold_left;
use fp_library::brands::OptionBrand;

assert_eq!(fold_left::<OptionBrand, _, _, _>(|acc, x: i32| acc + x, 0, Some(5)), 5);

fn fold_map<'a, A: 'a, M, F>(f: F, fa: Apply1L1T<'a, Self, A>) -> M

where M: Monoid + 'a, F: Fn(A) -> M + 'a,

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

Type Signature

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

Parameters

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

Returns

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

Examples

use fp_library::classes::foldable::fold_map;
use fp_library::brands::OptionBrand;
use fp_library::types::string; // Import to bring Monoid impl for String into scope

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

impl Functor for OptionBrand

fn map<'a, A: 'a, B: 'a, F>( f: F, fa: Apply1L1T<'a, Self, A>, ) -> Apply1L1T<'a, Self, B>

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

Maps a function over the value in the option.

Type Signature

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

Parameters

• f: 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::classes::functor::map;
use fp_library::brands::OptionBrand;

assert_eq!(map::<OptionBrand, _, _, _>(|x: i32| x * 2, Some(5)), Some(10));
assert_eq!(map::<OptionBrand, _, _, _>(|x: i32| x * 2, None), None);

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 Kind1L1T for OptionBrand

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

impl Lift for OptionBrand

fn lift2<'a, A, B, C, F>( f: F, fa: Apply1L1T<'a, Self, A>, fb: Apply1L1T<'a, Self, B>, ) -> Apply1L1T<'a, Self, C>

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

Lifts a binary function into the option context.

Type Signature

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

Parameters

• f: 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::classes::lift::lift2;
use fp_library::brands::OptionBrand;

assert_eq!(lift2::<OptionBrand, _, _, _, _>(|x: i32, y: i32| x + y, Some(1), Some(2)), Some(3));
assert_eq!(lift2::<OptionBrand, _, _, _, _>(|x: i32, y: i32| x + y, Some(1), None), None);

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 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) -> Apply1L1T<'a, Self, A>

Wraps a value in an option.

Type Signature

forall a. Pointed Option => a -> Option a

Parameters

• a: The value to wrap.

Returns

Some(a).

Examples

use fp_library::classes::pointed::pure;
use fp_library::brands::OptionBrand;

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

impl Semiapplicative for OptionBrand

fn apply<'a, A: 'a + Clone, B: 'a, FnBrand: 'a + ClonableFn>( ff: Apply1L1T<'a, Self, ApplyClonableFn<'a, FnBrand, A, B>>, fa: Apply1L1T<'a, Self, A>, ) -> Apply1L1T<'a, Self, B>

Applies a wrapped function to a wrapped value.

Type Signature

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

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::classes::semiapplicative::apply;
use fp_library::classes::clonable_fn::ClonableFn;
use fp_library::brands::{OptionBrand};
use fp_library::brands::RcFnBrand;
use std::rc::Rc;

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

impl Semimonad for OptionBrand

fn bind<'a, A: 'a, B: 'a, F>( ma: Apply1L1T<'a, Self, A>, f: F, ) -> Apply1L1T<'a, Self, B>

where F: Fn(A) -> Apply1L1T<'a, Self, B> + 'a,

Chains option computations.

Type Signature

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

Parameters

• ma: The first option.
• f: 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::classes::semimonad::bind;
use fp_library::brands::OptionBrand;

assert_eq!(bind::<OptionBrand, _, _, _>(Some(5), |x| Some(x * 2)), Some(10));
assert_eq!(bind::<OptionBrand, _, _, _>(None, |x: i32| Some(x * 2)), None);

impl Traversable for OptionBrand

fn traverse<'a, F: Applicative, A: 'a + Clone, B: 'a + Clone, Func>( f: Func, ta: Apply1L1T<'a, Self, A>, ) -> Apply1L1T<'a, F, Apply1L1T<'a, Self, B>>

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

Traverses the option with an applicative function.

Type Signature

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

Parameters

• f: The function to apply.
• ta: The option to traverse.

Returns

The option wrapped in the applicative context.

Examples

use fp_library::classes::traversable::traverse;
use fp_library::brands::OptionBrand;

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

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

where Apply1L1T<'a, F, A>: Clone, Apply1L1T<'a, Self, A>: Clone,

Sequences an option of applicative.

Type Signature

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

Parameters

• ta: The option containing the applicative value.

Returns

The option wrapped in the applicative context.

Examples

use fp_library::classes::traversable::sequence;
use fp_library::brands::OptionBrand;

assert_eq!(sequence::<OptionBrand, OptionBrand, _>(Some(Some(5))), Some(Some(5)));

impl Copy for OptionBrand

impl Eq for OptionBrand

impl StructuralPartialEq for OptionBrand