Struct SimpleStringTransform

pub struct SimpleStringTransform<T>(pub PhantomData<T>);

Used when you have a SimpleTransform but need a StringTransform.

Example

// `Identity` is a `SimpleTransform`.
struct Identity<I>(I);

impl<I: Iterator<Item=char>> Iterator for Identity<I> {
    type Item = char;
    fn next(&mut self) -> Option<char> {
        self.0.next()
    }
}

impl<'a> SimpleTransform<'a> for Identity<Chars<'a>> {
    fn transform_chars(chars: Chars<'a>) -> Self {
        Identity(chars)
    }
}

// This function takes a `StringTransform`.
fn apply_transform<'a, T: StringTransform<'a>>(t: T, s: String) -> String {
    t.transform(s).into_owned()
}

// Use `SimpleStringTransform` to bridge the gap.
let t = SimpleStringTransform::<Identity<Chars>>::new();
let s = apply_transform(t, "Hello World".to_string());
assert_eq!(&s, "Hello World");

Tuple Fields

0: PhantomData<T>

Implementations

impl<'a, T: SimpleTransform<'a>> SimpleStringTransform<T>

pub fn new() -> Self

Create a new SimpleStringTransform.

Trait Implementations

impl<'a, T: SimpleTransform<'a>> StringTransform<'a> for SimpleStringTransform<T>

type Iter = T

The type after applying this transform to a Chars iterator.

fn transform_chars(&self, chars: Chars<'a>) -> Self::Iter

Transform the characters of a string.

fn will_modify(&self, val: &str) -> bool

A hint to short-circuit string transformations.

fn transform<'b, T: Into<Cow<'b, str>>>(&self, s: T) -> Cow<'b, str>

Transform a string in-place