Enum decancer::Translation

pub enum Translation {
    Character(char),
    String(&'static str),
    None,
}

The translation for a single character/codepoint.

Variants

Character(char)

A single unicode character.

String(&'static str)

A multi-character ASCII string.

None

This suggests that the translation is an empty string. You can get this when the input character is a control character, surrogate, combining character, private use character, byte order character, or any invalid unicode value (e.g beyond char::MAX).

Trait Implementations

impl Add<Translation> for CuredString

A helper implementation for appending a Translation to a CuredString.

Examples

Basic usage:

let text = "vＥⓡ𝔂 𝔽𝕌Ňℕｙ ţ乇𝕏𝓣";
let mut cured = decancer::cure(text);

for cured_char in text.chars().map(decancer::cure_char) {
  cured = cured + cured_char;
}

assert_eq!(cured, "very funny textvery funny text");

type Output = CuredString

The resulting type after applying the + operator.

fn add(self, rhs: Translation) -> Self::Output

Performs the + operation.

impl Add<Translation> for String

Available on crate feature std only.

A helper implementation for appending a Translation to a String.

Examples

Basic usage:

let text = "vＥⓡ𝔂 𝔽𝕌Ňℕｙ ţ乇𝕏𝓣";
let mut cured = String::with_capacity(text.len());

for cured_char in text.chars().map(decancer::cure_char) {
  cured = cured + cured_char;
}

assert_eq!(cured, "very funny text");

type Output = String

The resulting type after applying the + operator.

fn add(self, rhs: Translation) -> Self::Output

Performs the + operation.

impl AddAssign<Translation> for CuredString

A helper implementation for appending a Translation to a CuredString.

Examples

Basic usage:

let text = "vＥⓡ𝔂 𝔽𝕌Ňℕｙ ţ乇𝕏𝓣";
let mut cured = decancer::cure(text);

for cured_char in text.chars().map(decancer::cure_char) {
  cured += cured_char;
}

assert_eq!(cured, "very funny textvery funny text");

fn add_assign(&mut self, rhs: Translation)

Performs the += operation.

impl AddAssign<Translation> for String

Available on crate feature std only.

A helper implementation for appending a Translation to a String.

Examples

Basic usage:

let text = "vＥⓡ𝔂 𝔽𝕌Ňℕｙ ţ乇𝕏𝓣";
let mut cured = String::with_capacity(text.len());

for cured_char in text.chars().map(decancer::cure_char) {
  cured += cured_char;
}

assert_eq!(cured, "very funny text");

fn add_assign(&mut self, rhs: Translation)

Performs the += operation.

impl Clone for Translation

fn clone(&self) -> Translation

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Translation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Translation

Available on crate feature serde only.

Deserializes and cures a character.

Examples

Basic usage:

use decancer::Translation;
use serde::Deserialize;

#[derive(Deserialize)]
struct Decancered {
  translation: Translation,
}

let json = r#"{"translation": "ӕ"}"#;
let decancered: Decancered = serde_json::from_str(json).unwrap();

assert!(matches!(decancered.translation, Translation::String("ae")));

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Translation

Formats this Translation. Behaves like formatting your typical String.

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

Formats the value using the given formatter.

impl Extend<Translation> for CuredString

Extends a CuredString with an iterator that yields Translations.

Examples

Basic usage:

let mut text = decancer::cure("vＥⓡ𝔂 𝔽𝕌Ňℕｙ ţ乇𝕏𝓣");
text.extend([decancer::cure_char('Ｅ'), decancer::cure_char('Ｅ')]);

assert_eq!(text, "very funny textee");

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

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 Extend<Translation> for String

Available on crate feature std only.

Extends a String with an iterator that yields Translations.

Examples

Basic usage:

let mut text = String::new();
text.extend([decancer::cure_char('Ｅ'), decancer::cure_char('Ｅ')]);

assert_eq!(text, "ee");

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

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<C> From<C> for Translationwhere C: Into<u32>,

Cures a single character/unicode codepoint.

Examples

Most of the time, this would yield only a single unicode character:

use decancer::Translation;

let cured_e = Translation::from('Ｅ');

assert!(matches!(cured_e, Translation::Character('e')));

However, for several special cases, it would yield an ASCII &'static str:

use decancer::Translation;

let cured_ae = Translation::from('ӕ');

assert!(matches!(cured_ae, Translation::String("ae")));

If your unicode character is a control character, surrogate, combining character, private use character, byte order character, or any invalid unicode value (e.g beyond char::MAX), you would get None:

use decancer::Translation;

let cured_surrogate = Translation::from(0xD800u32);

assert!(matches!(cured_surrogate, Translation::None));

fn from(ch: C) -> Self

Converts to this type from the input type.

impl FromIterator<Translation> for CuredString

A helper implementation for joining several Translations into one CuredString.

Examples

Basic usage:

use decancer::CuredString;

let text = "vＥⓡ𝔂 𝔽𝕌Ňℕｙ ţ乇𝕏𝓣";
let cured: CuredString = text.chars().map(decancer::cure_char).collect();

// cured here is a CuredString struct wrapping over the cured string
// for comparison purposes, it's more recommended to use the methods provided by the CuredString struct.
assert_eq!(cured, "very funny text");
assert!(cured.starts_with("very"));
assert!(cured.contains("funny"));
assert!(cured.ends_with("text"));

// retrieve the String inside and consume the struct.
let _output_str = cured.into_str();

fn from_iter<I>(iter: I) -> Selfwhere I: IntoIterator<Item = Translation>,

Creates a value from an iterator.

impl FromIterator<Translation> for String

Available on crate feature std only.

A helper implementation for joining several Translations into one String.

Examples

Basic usage:

let text = "vＥⓡ𝔂 𝔽𝕌Ňℕｙ ţ乇𝕏𝓣";
let cured: String = text.chars().map(decancer::cure_char).collect();

assert_eq!(cured, "very funny text");

fn from_iter<I>(iter: I) -> Selfwhere I: IntoIterator<Item = Translation>,

Creates a value from an iterator.

impl Into<Option<String>> for Translation

Available on crate feature std only.

Coerces this Translation to an Option<String>.

Examples

A non-Translation::None value would yield a Some(String):

use decancer::Translation;

let cured_e: Option<String> = decancer::cure_char('Ｅ').into();

assert_eq!(cured_e, Some(String::from("e")));

Otherwise, a Translation::None value would yield a None:

use decancer::Translation;

let cured_surrogate: Option<String> = decancer::cure_char(0xD800u32).into();

assert!(cured_surrogate.is_none());

fn into(self) -> Option<String>

Converts this type into the (usually inferred) input type.

impl<S> PartialEq<S> for Translationwhere S: AsRef<str> + ?Sized,

Checks if this Translation is similar to another string.

Examples

Basic usage:

let cured = decancer::cure_char('Ｅ');

assert_eq!(cured, "e");

And since it checks if the strings are similar, please note that this is valid too:

let cured = decancer::cure_char('Ｅ');

// it assumes that e is similar to 3
assert_eq!(cured, "3");

fn eq(&self, other: &S) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Translation> for Translation

fn eq(&self, other: &Translation) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Translation

Available on crate feature serde only.

Serializes this Translation.

• A Translation::Character would serialize into a character.
• A Translation::String would serialize into a string.
• A Translation::None would serialize into a unit.

Examples

Basic usage:

use decancer::Translation;
use serde::Serialize;

#[derive(Serialize)]
struct Decancered {
  translation: Translation,
}

let decancered = Decancered {
  translation: decancer::cure_char('ӕ')
};

assert_eq!(serde_json::to_string(&decancered).unwrap(), r#"{"translation":"ae"}"#);

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Translation

impl Eq for Translation

impl StructuralEq for Translation

impl StructuralPartialEq for Translation