Struct EncodeUtf16 

pub struct EncodeUtf16<'s> { /* private fields */ }

Represents non-empty iterators over the UTF-16 encoding of non-empty strings.

This struct is created by the encode_utf16 method on NonEmptyStr.

Implementations

impl<'s> EncodeUtf16<'s>

pub const fn new(string: &'s NonEmptyStr) -> Self

Constructs Self.

Trait Implementations

impl<'s> Debug for EncodeUtf16<'s>

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

Formats the value using the given formatter.

impl<'s> IntoIterator for EncodeUtf16<'s>

type Item = u16

The type of the elements being iterated over.

type IntoIter = EncodeUtf16<'s>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl NonEmptyIterator for EncodeUtf16<'_>

fn consume(self) -> (Self::Item, Self::IntoIter)

Consumes the non-empty iterator, returning the next item along with the possibly empty iterator.

fn count(self) -> NonZero<usize>

Consumes the non-empty iterator, returning the item count.

fn enumerate(self) -> Enumerate<Self>

Creates non-empty iterators that yield the current count and the item during iteration.

fn peeked(self) -> Peeked<Self::IntoIter>

Peeks at the next item of the non-empty iterator, returning it along with the possibly empty iterator.

fn chain<I>(self, other: I) -> Chain<Self, <I as IntoIterator>::IntoIter>

where I: IntoIterator<Item = Self::Item>,

Links the non-empty iterator with the provided possibly empty iterator.

fn cloned<'a, T>(self) -> Cloned<Self>

where Self: NonEmptyIterator<Item = &'a T>, T: Clone + 'a,

Creates non-empty iterators that clone the items of the underlying non-empty iterator.

fn copied<'a, T>(self) -> Copied<Self>

where Self: NonEmptyIterator<Item = &'a T>, T: Copy + 'a,

Creates non-empty iterators that copy the items of the underlying non-empty iterator.

fn zip<I>( self, other: I, ) -> Zip<Self, <I as IntoNonEmptyIterator>::IntoNonEmptyIter>

where I: IntoNonEmptyIterator,

Zips the non-empty iterator with the provided non-empty iterator.

fn sum<S>(self) -> S

where S: Sum<Self::Item>,

Sums the items of the non-empty iterator together.

fn product<P>(self) -> P

where P: Product<Self::Item>,

Multiplies the items of the non-empty iterator together.

fn all<P>(self, predicate: P) -> bool

where P: FnMut(Self::Item) -> bool,

Tests whether all items of the non-empty iterator match the predicate.

fn any<P>(self, predicate: P) -> bool

where P: FnMut(Self::Item) -> bool,

Tests whether any items of the non-empty iterator match the predicate.

fn none<P>(self, predicate: P) -> bool

where P: FnMut(Self::Item) -> bool,

Tests whether no items of the non-empty iterator match the predicate.

fn reduce<F>(self, function: F) -> Self::Item

where F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the items of the non-empty iterator into the single one by repeatedly applying the given function.

fn unzip<T, U, C, D>(self) -> (C, D)

where C: Default + Extend<T>, D: Default + Extend<U>, Self: NonEmptyIterator<Item = (T, U)>,

Converts the non-empty iterator of pairs into the pair of collections.

fn collect<C>(self) -> C

where C: FromIterator<Self::Item>,

Equivalent to collect on Iterator.

fn collect_non_empty<C>(self) -> C

where C: FromNonEmptyIterator<Self::Item>,

Collects the items of the non-empty iterator into the collection.

fn flat_map<J, F>(self, function: F) -> FlatMap<Self, J, F>

where J: IntoNonEmptyIterator, F: FnMut(Self::Item) -> J,

Similar to map, but flattens produced non-empty iterators.

fn flatten(self) -> Flatten<Self>

where Self::Item: IntoNonEmptyIterator,

Flattens one level of nesting in self non-empty iterator.

fn filter<P>(self, predicate: P) -> Filter<Self::IntoIter, P>

where P: FnMut(&Self::Item) -> bool,

Equivalent to filter on Iterator.

fn find<P>(self, predicate: P) -> Option<Self::Item>

where P: FnMut(&Self::Item) -> bool,

Equivalent to find on Iterator.

fn filter_map<T, F>(self, function: F) -> FilterMap<Self::IntoIter, F>

where F: FnMut(Self::Item) -> Option<T>,

Equivalent to filter_map on Iterator.

fn fold<A, F>(self, initial: A, function: F) -> A

where F: FnMut(A, Self::Item) -> A,

Equivalent to fold on Iterator.

fn map<U, F>(self, function: F) -> Map<Self, F>

where F: FnMut(Self::Item) -> U,

Creates non-empty iterators that map the items of the non-empty iterator with the function.

fn max(self) -> Self::Item

where Self::Item: Ord,

Returns the maximum item of the non-empty iterator.

fn max_by<F>(self, function: F) -> Self::Item

where F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the maximum item of the non-empty iterator with respect to the comparison function.

fn max_by_key<K, F>(self, function: F) -> Self::Item

where K: Ord, F: FnMut(&Self::Item) -> K,

Returns the maximum item of the non-empty iterator with respect to the key function.

fn min(self) -> Self::Item

where Self::Item: Ord,

Returns the minimum item of the non-empty iterator.

fn min_by<F>(self, function: F) -> Self::Item

where F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the minimum item of the non-empty iterator with respect to the comparison function.

fn min_by_key<K, F>(self, function: F) -> Self::Item

where K: Ord, F: FnMut(&Self::Item) -> K,

Returns the minimum item of the non-empty iterator with respect to the key function.

fn nth(self, n: NonZero<usize>) -> Option<Self::Item>

Returns the n-th item of the non-empty iterator.

fn skip(self, count: NonZero<usize>) -> Skip<Self::IntoIter>

Skips the first given number of items in the non-empty iterator.

fn take(self, count: NonZero<usize>) -> Take<Self>

Takes only the first given number of items from the non-empty iterator.

fn last(self) -> Self::Item

Returns the last item of the non-empty iterator.

fn step_by(self, step: NonZero<usize>) -> StepBy<Self>

Steps the non-empty iterator by the given custom amount.

fn for_each<F>(self, function: F)

where F: FnMut(Self::Item),

Equivalent to for_each on Iterator.

fn exhaust(self)

Consumes the iterator, exhausting it by dropping all of its items.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self::IntoIter, P>

where P: FnMut(&Self::Item) -> bool,

Equivalent to skip_while on Iterator.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self::IntoIter, P>

where P: FnMut(&Self::Item) -> bool,

Equivalent to take_while on Iterator.

fn map_while<T, P>(self, predicate: P) -> MapWhile<Self::IntoIter, P>

where P: FnMut(Self::Item) -> Option<T>,

Equivalent to map_while on Iterator.

fn scan<S, T, F>(self, initial: S, function: F) -> Scan<Self::IntoIter, S, F>

where F: FnMut(&mut S, Self::Item) -> Option<T>,

Equivalent to scan on Iterator.

fn inspect<F>(self, function: F) -> Inspect<Self, F>

where F: FnMut(&Self::Item),

Creates non-empty iterators that call the provided function with references to each item.

fn partition<C, F>(self, function: F) -> (C, C)

where C: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Equivalent to partition on Iterator.

fn position<P>(self, predicate: P) -> Option<usize>

where P: FnMut(Self::Item) -> bool,

Equivalent to position on Iterator.

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord,

Equivalent to cmp on Iterator.

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

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>,

Equivalent to partial_cmp on Iterator.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>,

Equivalent to eq on Iterator.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>,

Equivalent to ne on Iterator.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>,

Equivalent to lt on Iterator.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>,

Equivalent to le on Iterator.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>,

Equivalent to gt on Iterator.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>,

Equivalent to ge on Iterator.

fn is_sorted(self) -> bool

where Self::Item: PartialOrd,

Equivalent to is_sorted on Iterator.

fn is_sorted_by<F>(self, function: F) -> bool

where F: FnMut(&Self::Item, &Self::Item) -> bool,

Equivalent to is_sorted_by on Iterator.

fn is_sorted_by_key<K, F>(self, function: F) -> bool

where K: PartialOrd, F: FnMut(Self::Item) -> K,

Equivalent to is_sorted_by_key on Iterator.

fn collect_into<C>(self, collection: &mut C) -> &mut C

where C: Extend<Self::Item>,

Similar to collect, but extends the provided collection instead of creating new ones.

fn find_map<T, F>(self, function: F) -> Option<T>

where F: FnMut(Self::Item) -> Option<T>,

Equivalent to find_map on Iterator.

fn fuse(self) -> Fuse<Self>

Fuses the non-empty iterator, ensuring that once it returns None, it will return None forever afterwards.

fn rev(self) -> Rev<Self>

where Self::IntoIter: DoubleEndedIterator,

Reverses the iteration in non-empty iterators.

fn cycle(self) -> Cycle<Self>

where Self::IntoIter: Clone,

Repeats the non-empty iterator endlessly.