Trait pluralize::Pluralize

pub trait Pluralize<T> {
    fn pluralize<'a>(&'a self) -> Iter<'a, T>;
    fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, T>;
}

A trait implemented across both collections and single primitives which exposes an iterator

Required methods

fn pluralize<'a>(&'a self) -> Iter<'a, T>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, T>

Loading content...

Implementations on Foreign Types

impl<T> Pluralize<T> for Vec<T> where
    T: Pluralize<T>, 

fn pluralize<'a>(&'a self) -> Iter<'a, T>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, T>

impl Pluralize<i8> for i8

fn pluralize<'a>(&'a self) -> Iter<'a, i8>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, i8>

impl Pluralize<i16> for i16

fn pluralize<'a>(&'a self) -> Iter<'a, i16>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, i16>

impl Pluralize<i32> for i32

fn pluralize<'a>(&'a self) -> Iter<'a, i32>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, i32>

impl Pluralize<i64> for i64

fn pluralize<'a>(&'a self) -> Iter<'a, i64>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, i64>

impl Pluralize<i128> for i128

fn pluralize<'a>(&'a self) -> Iter<'a, i128>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, i128>

impl Pluralize<isize> for isize

fn pluralize<'a>(&'a self) -> Iter<'a, isize>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, isize>

impl Pluralize<u8> for u8

fn pluralize<'a>(&'a self) -> Iter<'a, u8>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, u8>

impl Pluralize<u16> for u16

fn pluralize<'a>(&'a self) -> Iter<'a, u16>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, u16>

impl Pluralize<u32> for u32

fn pluralize<'a>(&'a self) -> Iter<'a, u32>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, u32>

impl Pluralize<u64> for u64

fn pluralize<'a>(&'a self) -> Iter<'a, u64>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, u64>

impl Pluralize<u128> for u128

fn pluralize<'a>(&'a self) -> Iter<'a, u128>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, u128>

impl Pluralize<usize> for usize

fn pluralize<'a>(&'a self) -> Iter<'a, usize>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, usize>

impl Pluralize<bool> for bool

fn pluralize<'a>(&'a self) -> Iter<'a, bool>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, bool>

impl Pluralize<char> for char

fn pluralize<'a>(&'a self) -> Iter<'a, char>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, char>

impl Pluralize<f32> for f32

fn pluralize<'a>(&'a self) -> Iter<'a, f32>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, f32>

impl Pluralize<f64> for f64

fn pluralize<'a>(&'a self) -> Iter<'a, f64>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, f64>

impl<A> Pluralize<(A,)> for (A,)

fn pluralize<'a>(&'a self) -> Iter<'a, (A,)>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, (A,)>

impl<A, B> Pluralize<(A, B)> for (A, B)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B)>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, (A, B)>

impl<A, B, C> Pluralize<(A, B, C)> for (A, B, C)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B, C)>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, (A, B, C)>

impl<A, B, C, D> Pluralize<(A, B, C, D)> for (A, B, C, D)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B, C, D)>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, (A, B, C, D)>

impl<A, B, C, D, E> Pluralize<(A, B, C, D, E)> for (A, B, C, D, E)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B, C, D, E)>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, (A, B, C, D, E)>

impl<A, B, C, D, E, F> Pluralize<(A, B, C, D, E, F)> for (A, B, C, D, E, F)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B, C, D, E, F)>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, (A, B, C, D, E, F)>

impl<A, B, C, D, E, F, G> Pluralize<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B, C, D, E, F, G)>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, (A, B, C, D, E, F, G)>

impl<A, B, C, D, E, F, G, H> Pluralize<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B, C, D, E, F, G, H)>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, (A, B, C, D, E, F, G, H)>

impl<A, B, C, D, E, F, G, H, I> Pluralize<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B, C, D, E, F, G, H, I)>

fn pluralize_mut<'a>(&'a mut self) -> IterMut<'a, (A, B, C, D, E, F, G, H, I)>

impl<A, B, C, D, E, F, G, H, I, J> Pluralize<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B, C, D, E, F, G, H, I, J)>

fn pluralize_mut<'a>(
    &'a mut self
) -> IterMut<'a, (A, B, C, D, E, F, G, H, I, J)>

impl<A, B, C, D, E, F, G, H, I, J, K> Pluralize<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B, C, D, E, F, G, H, I, J, K)>

fn pluralize_mut<'a>(
    &'a mut self
) -> IterMut<'a, (A, B, C, D, E, F, G, H, I, J, K)>

impl<A, B, C, D, E, F, G, H, I, J, K, L> Pluralize<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L)

fn pluralize<'a>(&'a self) -> Iter<'a, (A, B, C, D, E, F, G, H, I, J, K, L)>

fn pluralize_mut<'a>(
    &'a mut self
) -> IterMut<'a, (A, B, C, D, E, F, G, H, I, J, K, L)>

Loading content...

Implementors

Loading content...