Struct Lazy 

pub struct Lazy<T>(/* private fields */);

A lazy evaluated Semigroup with nonempty buffer that is implemented by Vec.

Properties

	crate::Annotate	crate::Monoid	crate::Commutative
impl	❌	❌	✅
where			T: crate::Commutative

Examples

use semigroup::{op::Coalesce, Lazy, Semigroup};

let a = Coalesce(Some(1));
let b = Coalesce(Some(2));
let c = Coalesce(Some(3));

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());

assert_eq!(lazy.first(), &Coalesce(Some(1)));
assert_eq!(lazy.last(), &Coalesce(Some(3)));
assert_eq!(lazy.combine(), Coalesce(Some(1)));

Implementations

impl<T: Semigroup> Lazy<T>

pub fn combine(self) -> T

Evaluates Lazy buffer.

Examples

use semigroup::{op::Coalesce, Lazy, Semigroup};
let a = Coalesce(Some(1));
let b = Coalesce(Some(2));
let c = Coalesce(Some(3));

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());
assert_eq!(lazy.combine(), Coalesce(Some(1)));

pub fn combine_cloned(&self) -> T

where T: Clone,

Evaluates Lazy buffer like Lazy::combine by cloning each element.

Examples

use semigroup::{op::Coalesce, Lazy, Semigroup};
let a = Coalesce(Some(1));
let b = Coalesce(Some(2));
let c = Coalesce(Some(3));

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());
assert_eq!(lazy.combine_cloned(), Coalesce(Some(1)));

pub fn combine_rev(self) -> T

Evaluates Lazy buffer in reverse order.

Examples

use semigroup::{op::Coalesce, Lazy, Semigroup};
let a = Coalesce(Some(1));
let b = Coalesce(Some(2));
let c = Coalesce(Some(3));

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());
assert_eq!(lazy.combine_rev(), Coalesce(Some(3)));

pub fn combine_rev_cloned(&self) -> T

where T: Clone,

Evaluates Lazy buffer in reverse order like Lazy::combine_rev by cloning each element.

Examples

use semigroup::{op::Coalesce, Lazy, Semigroup};
let a = Coalesce(Some(1));
let b = Coalesce(Some(2));
let c = Coalesce(Some(3));

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());
assert_eq!(lazy.combine_rev_cloned(), Coalesce(Some(3)));

impl<T> Lazy<T>

pub fn from_iterator<I: IntoIterator<Item = T>>(iter: I) -> Option<Self>

Create Lazy from iterator. Used by crate::CombineIterator::collect_lazy.

pub fn is_empty(&self) -> bool

Returns true if the Lazy buffer contains no elements. It is nonempty, so always returns false.

pub fn is_single(&self) -> bool

Returns true if the Lazy buffer contains exactly one element.

pub fn len(&self) -> usize

Returns the number of elements in the Lazy buffer. It is nonempty, so always returns 1 or more.

pub fn first(&self) -> &T

Returns a reference to the first element of the Lazy buffer.

pub fn split_first(&self) -> (&T, &[T])

Returns the reference to the first element and all the rest elements of the Lazy buffer.

pub fn split_off_first(self) -> (T, Vec<T>)

Returns the first element and all the rest elements of the Lazy buffer.

pub fn last(&self) -> &T

Returns a reference to the last element of the Lazy buffer.

pub fn split_last(&self) -> (&T, &[T])

Returns the reference to the last element and all the rest elements of the Lazy buffer.

pub fn split_off_last(self) -> (T, Vec<T>)

Returns the last element and all the rest elements of the Lazy buffer.

pub fn get<I: SliceIndex<[T]>>(&self, index: I) -> Option<&I::Output>

Returns an element or slice like Vec.

pub fn iter(&self) -> <&[T] as IntoIterator>::IntoIter

Returns an iterator over of the Lazy buffer.

pub fn map<U, F: Fn(T) -> U>(self, f: F) -> Lazy<U>

Maps each element of the Lazy buffer with a function, and returns a new Lazy buffer.

impl<T, A: PartialEq> Lazy<Annotated<T, A>>

pub fn find_annotated(&self, annotation: &A) -> Option<&Annotated<T, A>>

O(n), searches for a value that has the given annotation.

Examples

use semigroup::{op::Coalesce, Annotate, Lazy, Semigroup};

let a = Coalesce(Some(1)).annotated("edge");
let b = Coalesce(Some(2)).annotated("middle");
let c = Coalesce(Some(3)).annotated("edge");

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());

assert_eq!(lazy.find_annotated(&"edge"), Some(&a));
assert_eq!(lazy.find_annotated(&"middle"), Some(&b));
assert_eq!(lazy.find_annotated(&"where"), None);
assert_eq!(lazy.combine(), Coalesce(Some(1)).annotated("edge"));

pub fn position_annotated(&self, annotation: &A) -> Option<usize>

O(n), searches for a value’s index that has the given annotation.

Examples

use semigroup::{op::Coalesce, Annotate, Lazy, Semigroup};

let a = Coalesce(Some(1)).annotated("edge");
let b = Coalesce(Some(2)).annotated("middle");
let c = Coalesce(Some(3)).annotated("edge");

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());

assert_eq!(lazy.position_annotated(&"edge"), Some(0));
assert_eq!(lazy.position_annotated(&"middle"), Some(1));
assert_eq!(lazy.position_annotated(&"where"), None);
assert_eq!(lazy.combine(), Coalesce(Some(1)).annotated("edge"));

pub fn rfind_annotated(&self, annotation: &A) -> Option<&Annotated<T, A>>

O(n), searches for a value that has the given annotation from the end.

Examples

use semigroup::{op::Coalesce, Annotate, Lazy, Semigroup};

let a = Coalesce(Some(1)).annotated("edge");
let b = Coalesce(Some(2)).annotated("middle");
let c = Coalesce(Some(3)).annotated("edge");

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());

assert_eq!(lazy.rfind_annotated(&"edge"), Some(&c));
assert_eq!(lazy.rfind_annotated(&"middle"), Some(&b));
assert_eq!(lazy.rfind_annotated(&"where"), None);
assert_eq!(lazy.combine(), Coalesce(Some(1)).annotated("edge"));

pub fn rposition_annotated(&self, annotation: &A) -> Option<usize>

O(n), searches for a value’s index that has the given annotation from the end.

Examples

use semigroup::{op::Coalesce, Annotate, Lazy, Semigroup};

let a = Coalesce(Some(1)).annotated("edge");
let b = Coalesce(Some(2)).annotated("middle");
let c = Coalesce(Some(3)).annotated("edge");

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());

assert_eq!(lazy.rposition_annotated(&"edge"), Some(2));
assert_eq!(lazy.rposition_annotated(&"middle"), Some(1));
assert_eq!(lazy.rposition_annotated(&"where"), None);
assert_eq!(lazy.combine(), Coalesce(Some(1)).annotated("edge"));

pub fn find_annotated_all<'a>( &'a self, annotation: &'a A, ) -> impl 'a + Iterator<Item = &'a Annotated<T, A>>

O(n), searches for all values that have the given annotation.

Examples

use semigroup::{op::Coalesce, Annotate, Lazy, Semigroup};

let a = Coalesce(Some(1)).annotated("edge");
let b = Coalesce(Some(2)).annotated("middle");
let c = Coalesce(Some(3)).annotated("edge");

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());

assert_eq!(lazy.find_annotated_all(&"edge").collect::<Vec<_>>(), vec![&a, &c]);
assert_eq!(lazy.find_annotated_all(&"middle").collect::<Vec<_>>(), vec![&b]);
assert_eq!(lazy.find_annotated_all(&"where").collect::<Vec<_>>(), vec![&a; 0]);
assert_eq!(lazy.combine(), Coalesce(Some(1)).annotated("edge"));

pub fn position_annotated_all<'a>( &'a self, annotation: &'a A, ) -> impl 'a + Iterator<Item = usize>

O(n), searches for all values’ indices that have the given annotation.

Examples

use semigroup::{op::Coalesce, Annotate, Lazy, Semigroup};

let a = Coalesce(Some(1)).annotated("edge");
let b = Coalesce(Some(2)).annotated("middle");
let c = Coalesce(Some(3)).annotated("edge");

let lazy = Lazy::from(a).semigroup(b.into()).semigroup(c.into());

assert_eq!(lazy.position_annotated_all(&"edge").collect::<Vec<_>>(), vec![0, 2]);
assert_eq!(lazy.position_annotated_all(&"middle").collect::<Vec<_>>(), vec![1]);
assert_eq!(lazy.position_annotated_all(&"where").collect::<Vec<_>>(), vec![0; 0]);
assert_eq!(lazy.combine(), Coalesce(Some(1)).annotated("edge"));

Trait Implementations

impl<T: Clone> Clone for Lazy<T>

fn clone(&self) -> Lazy<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Lazy<T>

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

Formats the value using the given formatter.

impl<T> Extend<T> for Lazy<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T> From<T> for Lazy<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for Lazy<T>

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<T, I: SliceIndex<[T]>> Index<I> for Lazy<T>

type Output = <I as SliceIndex<[T]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IntoIterator for Lazy<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = <Vec<T> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord> Ord for Lazy<T>

fn cmp(&self, other: &Lazy<T>) -> 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<T: PartialEq> PartialEq for Lazy<T>

fn eq(&self, other: &Lazy<T>) -> 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<T: PartialOrd> PartialOrd for Lazy<T>

fn partial_cmp(&self, other: &Lazy<T>) -> 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<T> Semigroup for Lazy<T>

fn op(base: Self, other: Self) -> Self

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

where Self: Sized,

impl<T> Commutative for Lazy<T>

where T: Commutative,

impl<T: Eq> Eq for Lazy<T>

impl<T> StructuralPartialEq for Lazy<T>