deunicode

https://docs.rs/deunicode
Admin
deunicode is a Rust library that transliterates Unicode strings into pure ASCII equivalents,...
Tokens:17,674
Snippets:168
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### fold

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Folds every element of an iterator into a single accumulator value by repeatedly applying a given operation. It starts with an initial value and updates it with each element.

```APIDOC
## fn fold<B, F>(self, init: B, f: F) -> B
where Self: Sized, F: FnMut(B, Self::Item) -> B,
Folds every element into an accumulator by applying an operation, returning the final result.
```

--------------------------------

### Initialize AsciiCharsIter

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

Creates a new `AsciiCharsIter` from a Unicode string slice. This iterator translates Unicode characters to ASCII strings.

```rust
use deunicode::AsciiCharsIter;

let unicode_string = "🐶";
let iter = AsciiCharsIter::new(unicode_string);
```

--------------------------------

### take

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates an iterator that yields the first `n` elements of the underlying iterator. If the underlying iterator yields fewer than `n` elements, the resulting iterator will yield all of them.

```APIDOC
## fn take(self, n: usize) -> Take<Self>
where Self: Sized,
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.
```

--------------------------------

### Ordering Comparison Methods

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Methods for lexicographical comparison based on ordering.

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

### Description
Determines if the elements of this `Iterator` are lexicographically less than those of another.

### Parameters
- `other`: An iterator to compare against.

### Returns
- `bool`: `true` if the iterator is lexicographically less than `other`, `false` otherwise.
```

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

### Description
Determines if the elements of this `Iterator` are lexicographically less than or equal to those of another.

### Parameters
- `other`: An iterator to compare against.

### Returns
- `bool`: `true` if the iterator is lexicographically less than or equal to `other`, `false` otherwise.
```

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

### Description
Determines if the elements of this `Iterator` are lexicographically greater than those of another.

### Parameters
- `other`: An iterator to compare against.

### Returns
- `bool`: `true` if the iterator is lexicographically greater than `other`, `false` otherwise.
```

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

### Description
Determines if the elements of this `Iterator` are lexicographically greater than or equal to those of another.

### Parameters
- `other`: An iterator to compare against.

### Returns
- `bool`: `true` if the iterator is lexicographically greater than or equal to `other`, `false` otherwise.
```

--------------------------------

### product

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Iterates over the entire iterator, multiplying all the elements.

```APIDOC
## fn product<P>(self) -> P
where
    Self: Sized,
    P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements Read more
```

--------------------------------

### Iter Test Cases

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

Unit tests for the `AsciiCharsIter` functionality, demonstrating its behavior with various Unicode characters and expected de-unicoded outputs.

```rust
#[test]
fn iter_test() {
    use alloc::vec::Vec;
    let chars: Vec<_> = AsciiCharsIter::new("🄏中国").flatten().collect();
    assert_eq!(&chars, &["NonCommercial", "Zhong ", "Guo"])
    let chars: Vec<_> = "中国x🅶".ascii_chars().flatten().collect();
    assert_eq!(&chars, &["Zhong ", "Guo ", "x", "G"])
    let chars: Vec<_> = "☃中 国".ascii_chars().flatten().collect();
    assert_eq!(&chars, &["snowman ", "Zhong", " ", "Guo"])
}
```

--------------------------------

### AsciiCharsIter::new

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates a new AsciiCharsIter from a Unicode string slice. Use `.map(|ch| ch.unwrap_or("?"))` to replace invalid characters.

```APIDOC
## AsciiCharsIter::new

### Description
Creates a new iterator that translates Unicode characters to ASCII strings.

### Method Signature
```rust
pub fn new(unicode_string: &'a str) -> Self
```

### Example
```rust
use deunicode::AsciiChars;
let iter = AsciiCharsIter::new("hello 🐶");
```
```

--------------------------------

### AsciiCharsIter Display Implementation

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

AsciiCharsIter implements the Display trait for formatting strings without allocations.

```APIDOC
## Display for AsciiCharsIter

### Description
Formats the value using the given formatter without a temporary string allocation.

### Method Signature
```rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

### Example
```rust
use deunicode::AsciiChars;
format!("what's up {}", "🐶".ascii_chars());
```
```

--------------------------------

### map_windows

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. The windows during mapping overlap.

```APIDOC
## fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,
Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well.
```

--------------------------------

### Partial Comparison Methods

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Methods for lexicographically comparing iterators.

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

### Description
Lexicographically compares the `PartialOrd` elements of this `Iterator` with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

### Parameters
- `other`: An iterator to compare against.

### Returns
- `Option<Ordering>`: The ordering result if determinable, otherwise `None`.
```

```APIDOC
## fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

### Description
Lexicographically compares the elements of this `Iterator` with those of another with respect to the specified comparison function. This is a nightly-only experimental API.

### Parameters
- `other`: An iterator to compare against.
- `partial_cmp`: A closure that takes two elements and returns an `Option<Ordering>`.

### Returns
- `Option<Ordering>`: The ordering result if determinable, otherwise `None`.
```

--------------------------------

### String Implementation of AsciiChars

Source: https://docs.rs/deunicode/latest/deunicode/trait.AsciiChars.html

Illustrates the AsciiChars trait implementation for `String` objects, available when the `alloc` feature is enabled.

```rust
impl AsciiChars for String
```

--------------------------------

### by_ref

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates a "by reference" adapter for an iterator. This allows borrowing the iterator without consuming it, enabling methods that require `&mut self` to be called on a mutable reference.

```APIDOC
## fn by_ref(&mut self) -> &mut Self
where Self: Sized,
Creates a “by reference” adapter for this instance of `Iterator`.
```

--------------------------------

### Efficient Transliteration with Cow

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

This function provides a `Cow` (Clone-on-Write) for efficient transliteration, avoiding unnecessary allocations when the input is already ASCII.

```rust
use deunicode::deunicode_with_tofu_cow;

let s = "hello";
let cow = deunicode_with_tofu_cow(s, "[?]");
assert!(matches!(cow, std::borrow::Cow::Borrowed(_)));

let s = "你好";
let cow = deunicode_with_tofu_cow(s, "[?]");
assert!(matches!(cow, std::borrow::Cow::Owned(_)));
```

--------------------------------

### any

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Tests if any element of the iterator matches a predicate.

```APIDOC
## fn any<F>(&mut self, f: F) -> bool
where
    Self: Sized,
    F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate. Read more
```

--------------------------------

### TryFrom and TryInto Traits

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

These traits facilitate fallible conversions between types. `TryFrom` attempts to convert one type into another, returning a `Result` to handle potential errors, while `TryInto` provides the inverse conversion.

```APIDOC
## impl<T, U> TryFrom<U> for T
where U: Into<T>,

### Associated Types
#### type Error = Infallible
The type returned in the event of a conversion error.

### Methods
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.

## impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

### Associated Types
#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

### Methods
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
```

--------------------------------

### partition

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Consumes an iterator and partitions its elements into two collections based on a predicate. Elements for which the predicate returns true are placed in the first collection, and the rest in the second.

```APIDOC
## fn partition<B, F>(self, f: F) -> (B, B)
where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,
Consumes an iterator, creating two collections from it.
```

--------------------------------

### Using ascii_chars in Formatters

Source: https://docs.rs/deunicode/latest/deunicode/trait.AsciiChars.html

Demonstrates how the `ascii_chars` iterator can be directly used within string formatting to represent Unicode characters as ASCII sequences.

```rust
use deunicode::AsciiChars;
format!("what's up {}", "🐶".ascii_chars());
```

--------------------------------

### copied

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates an iterator that copies all of its elements.

```APIDOC
## fn copied<'a, T>(self) -> Copied<Self>
where
    T: Copy + 'a,
    Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements. Read more
```

--------------------------------

### deunicode_with_tofu_cow

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

An optimized version of `deunicode_with_tofu()` that avoids allocating a new `String` if the input string is already entirely ASCII. It returns a `Cow<'input, str>` which can be either borrowed or owned.

```APIDOC
## deunicode_with_tofu_cow

### Description
Same as [`deunicode_with_tofu()`], but avoids allocating a new `String` if not necessary. You can use `"\u{FFFD}"` to use the usual Unicode Replacement Character. "Tofu" is a nickname for a replacement character, which in Unicode fonts usually looks like a block of tofu.

### Method
`pub fn deunicode_with_tofu_cow<'input>(s: &'input str, custom_placeholder: &str) -> Cow<'input, str>`

### Parameters
- `s` (*&'input str*) - The input Unicode string to transliterate.
- `custom_placeholder` (*&str*) - The string to use for replacing unknown characters.

### Returns
- `Cow<'input, str>` - A borrowed string if the input was ASCII, otherwise an owned `String` with the transliteration.
```

--------------------------------

### Equality Methods

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Methods for determining equality between iterators.

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

### Description
Determines if the elements of this `Iterator` are equal to those of another.

### Parameters
- `other`: An iterator to compare against.

### Returns
- `bool`: `true` if the iterators are equal, `false` otherwise.
```

```APIDOC
## fn eq_by<I, F>(self, other: I, eq: F) -> bool

### Description
Determines if the elements of this `Iterator` are equal to those of another with respect to the specified equality function. This is a nightly-only experimental API.

### Parameters
- `other`: An iterator to compare against.
- `eq`: A closure that takes two elements and returns a `bool` indicating equality.

### Returns
- `bool`: `true` if the iterators are equal according to the closure, `false` otherwise.
```

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

### Description
Determines if the elements of this `Iterator` are not equal to those of another.

### Parameters
- `other`: An iterator to compare against.

### Returns
- `bool`: `true` if the iterators are not equal, `false` otherwise.
```

--------------------------------

### Display Implementation for AsciiCharsIter

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

Implements the `core::fmt::Display` trait for `AsciiCharsIter`. This allows the iterator to be formatted directly into a string, replacing unrenderable characters with U+FFFD.

```rust
impl core::fmt::Display for AsciiCharsIter<'_> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        self.clone().try_for_each(|ch| f.write_str(ch.unwrap_or("\u{FFFD}")))
    }
}
```

--------------------------------

### cloned

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates an iterator that clones all of its elements.

```APIDOC
## fn cloned<'a, T>(self) -> Cloned<Self>
where
    T: Clone + 'a,
    Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which `clone`s all of its elements. Read more
```

--------------------------------

### min

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Returns the minimum element of an iterator.

```APIDOC
## fn min(self) -> Option<Self::Item>
where
    Self: Sized,
    Self::Item: Ord,

Returns the minimum element of an iterator. Read more
```

--------------------------------

### cmp_by

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Lexicographically compares the elements of this Iterator with those of another, using a specified comparison function. This is a nightly-only experimental API.

```APIDOC
## fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

This is a nightly-only experimental API. (`iter_order_by`)
Lexicographically compares the elements of this `Iterator` with those of another with respect to the specified comparison function. Read more
```

--------------------------------

### unzip

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Converts an iterator of pairs into a pair of containers.

```APIDOC
## fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers. Read more
```

--------------------------------

### deunicode_with_tofu_cow

Source: https://docs.rs/deunicode/latest/deunicode/index.html

Same as `deunicode_with_tofu()`, but avoids allocating a new `String` if not necessary.

```APIDOC
## deunicode_with_tofu_cow()

### Description
Same as `deunicode_with_tofu()`, but avoids allocating a new `String` if not necessary.

### Function Signature
`fn deunicode_with_tofu_cow<'a>(s: &'a str, tofu: &str) -> Cow<'a, str>`

### Parameters
* `s` (str) - The input Unicode string.
* `tofu` (str) - The string to replace unknown characters with.

### Returns
* `Cow<'a, str>` - An ASCII transliteration of the input string, or the original string if no changes were made.

### Examples
```rust
use deunicode::deunicode_with_tofu_cow;
use std::borrow::Cow;

let original = "hello world";
let result = deunicode_with_tofu_cow(original, "?");
assert!(matches!(result, Cow::Borrowed(_)));
assert_eq!(result, "hello world");

let original = "你好";
let result = deunicode_with_tofu_cow(original, "?");
assert!(matches!(result, Cow::Owned(_)));
assert_eq!(result, "? ?");
```
```

--------------------------------

### all

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Tests if every element of the iterator matches a predicate.

```APIDOC
## fn all<F>(&mut self, f: F) -> bool
where
    Self: Sized,
    F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate. Read more
```

--------------------------------

### min_by_key

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Returns the element that yields the minimum value based on a specified key function.

```APIDOC
## fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
where
    B: Ord,
    Self: Sized,
    F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function. Read more
```

--------------------------------

### try_reduce

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately. This is a nightly-only experimental API.

```APIDOC
## fn try_reduce<R>(
    &mut self,
    f: impl FnMut(Self::Item, Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
where
    Self: Sized,
    R: Try<Output = Self::Item>,
    <R as Try>::Residual: Residual<Option<Self::Item>>,

This is a nightly-only experimental API. (`iterator_try_reduce`)
Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately. Read more
```

--------------------------------

### inspect

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Performs an action for each element of an iterator, passing the element to a closure, and then yields the element unchanged. This is useful for debugging or logging.

```APIDOC
## fn inspect<F>(self, f: F) -> Inspect<Self, F>
where Self: Sized, F: FnMut(&Self::Item),
Does something with each element of an iterator, passing the value on.
```

--------------------------------

### skip

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates an iterator that skips the first `n` elements of the underlying iterator. If the underlying iterator has fewer than `n` elements, the resulting iterator will be empty.

```APIDOC
## fn skip(self, n: usize) -> Skip<Self>
where Self: Sized,
Creates an iterator that skips the first `n` elements.
```

--------------------------------

### Iterator Blanket Implementations

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Common iterator functionalities implemented for AsciiCharsIter.

```APIDOC
## impl<T> Any for T

### Description
Provides the `type_id` method for any type that is `'static` and `?Sized`.

#### fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.
```

```APIDOC
## impl<T> Borrow<T> for T

### Description
Provides immutable borrowing capabilities.

#### fn borrow(&self) -> &T

### Description
Immutably borrows from an owned value.
```

```APIDOC
## impl<T> BorrowMut<T> for T

### Description
Provides mutable borrowing capabilities.

#### fn borrow_mut(&mut self) -> &mut T

### Description
Mutably borrows from an owned value.
```

```APIDOC
## impl<T> CloneToUninit for T

### Description
Performs copy-assignment from `self` to a destination. This is a nightly-only experimental API.

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.
```

```APIDOC
## impl<T> From<T> for T

### Description
Provides a trivial conversion from a type to itself.

#### fn from(t: T) -> T

### Description
Returns the argument unchanged.
```

```APIDOC
## impl<T, U> Into<U> for T

### Description
Provides conversion capabilities from one type to another if `U` implements `From<T>`.

#### fn into(self) -> U

### Description
Calls `U::from(self)`.
```

```APIDOC
## impl<I> IntoIterator for I

### Description
Enables an iterator to be converted into itself.

#### type Item = <I as Iterator>::Item

### Description
The type of the elements being iterated over.

#### type IntoIter = I

### Description
Which kind of iterator are we turning this into?

#### fn into_iter(self) -> I

### Description
Creates an iterator from a value.
```

--------------------------------

### deunicode_with_tofu Function Signature

Source: https://docs.rs/deunicode/latest/deunicode/fn.deunicode_with_tofu.html

This is the function signature for `deunicode_with_tofu`. It takes a string slice and a custom placeholder string as input and returns a String with unknown characters replaced.

```rust
pub fn deunicode_with_tofu(s: &str, custom_placeholder: &str) -> String
```

--------------------------------

### deunicode_with_tofu_cow Function

Source: https://docs.rs/deunicode/latest/deunicode

Same as `deunicode_with_tofu()`, but avoids allocating a new `String` if not necessary.

```APIDOC
## deunicode_with_tofu_cow()

### Description
Same as `deunicode_with_tofu()`, but avoids allocating a new `String` if not necessary.

### Function Signature
`fn deunicode_with_tofu_cow<'a>(s: &'a str, tofu: &str) -> Cow<'a, str>`

### Parameters
* `s` (string) - The Unicode string to transliterate.
* `tofu` (string) - The string to use for replacing unknown characters.

### Returns
* `Cow<'a, str>` - A `Cow` containing the ASCII transliteration. It will be borrowed if no transliteration was needed, or owned if a new string was allocated.

### Example
```rust
use deunicode::deunicode_with_tofu_cow;
use std::borrow::Cow;

let original = "hello world";
let result = deunicode_with_tofu_cow(original, "?");
assert!(matches!(result, Cow::Borrowed(_)));
assert_eq!(result, "hello world");

let original_unicode = "hello 🦄 world";
let result_unicode = deunicode_with_tofu_cow(original_unicode, "?");
assert!(matches!(result_unicode, Cow::Owned(_)));
assert_eq!(result_unicode, "hello ? world");
```
```

--------------------------------

### cycle

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Repeats an iterator endlessly.

```APIDOC
## fn cycle(self) -> Cycle<Self>
where
    Self: Sized + Clone,

Repeats an iterator endlessly. Read more
```

--------------------------------

### scan

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

An iterator adapter which holds internal state and produces a new iterator. It applies a function to each element, updating the state and yielding a value based on the function's return.

```APIDOC
## fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,
An iterator adapter which, like `fold`, holds internal state, but unlike `fold`, produces a new iterator.
```

--------------------------------

### Zalgo Text De-unification Test

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

Tests the `deunicode_with_tofu` function by providing a heavily modified string (zalgo text) and asserting that it is correctly de-unificoded to a simple string.

```rust
#[test]
fn zalgo() {
    assert_eq!(deunicode_with_tofu("h̵̡̢̛̻̬͔̦͓̥̞̳͇̭̣̪̰̞̲̩̭̤͚͖͓̰̭̝̬̖̭͇͇̰͇͓̠͑͆͐͛̏͒͆̊́̊̂̉̉̈́̿̆̾̌̀͒͌́͗͋͜͝͝͝ͅĕ̷̡̧̡̧̜̮͙̗͙͕͖̩͈͙̞̞̭͙̯͖̰͖̙̹͖͚̦̬̄̀̓̈́͗̆̓̽͛̀͛̄͂̉͒̓̐̃̑́͊̀͋͊͗́̈́͑͗̐̔̈͊͋̓͊̓́̏̍̍̓͘̕͝͝͠ͅl̶̠̮̺̦̩͓̣̪͚͌̊̈́̀̄̈́̉͗̀̏͋̆̈̈́̉̋̊̉̉̌̈́̚̕͠͠l̴̨̡͍͇̝̟̩̙̤̰̬̬͖͙̺̟̯͓̥̯͔̤̠̻̤̮̘̋͑̑̿͗͂̃̓̓̉͒̑͜͠ͅo̸̢̧̨̜͉̜͓͙̰̳̙̖̰͇̺͈̝̬̩̫͛̅̍͌̎̅̿̂̚̕͜ ̵̛̗͍̊̈͋̀̊͒̄̔̔͋͋̆͋̅̀͂͂̍́̀̈́̈́͂̂̂̆̅͗̄̈́̀̈́̅̒̈̋͊̍̈́͂̑̓̽̂̂̓̚̕̚̕̚͠͝w̷̨͍͖̗͔͖͎̩̠̜͖̞͍̘̤͕̮̥̭͛̆̎̋̄͒̓̈́͆̀̆̚ǫ̷̢̢̧̧̨̧̧̨̢̼̮̺̬͇͓̪̯͖̥͙̠͍̭̩̰͎̘̺̝̲̖̮̞̝̠̠͎̻̠͙̫͙̞̫̭͖̱͉̱̮̌͑̈̅̈́́̊̓͌̇͌̏̾̆͗̉͊̐̈́̾́̔̆͐́͘͜͜͝ͅŗ̵̡̛̛̟̭͉̰̮̺̜̼̰̟̲͖͔͕̰͕͇̪̲̫̬͚̱̮͎̭̩̩̉̇̉̀̉͑̔͋͆͌͜͠ļ̴̢̨̢̛͙̳̮̠͔͇͈̟͇̦̯͖̖͚̺̤͈̻͔̤̤̪̫͔͕̻̟̥̤̩͚̟̳͔̘̤͈͍͍̯̻̙̺̪̄̈́́͊̋̊́̅͛̉̊̉̅̋̆̔͑̈́͋̑͂̍̌̓̾̆̕̕͝ͅḏ̶̡̨̢̡̛̙͕̘̜͚̺̬̭̜͖͎͚̹̖͈̖̤͎̙̫͎̜̩̰̬̪̣̎͛̓̏̃͊̈́̽̆̒̈́̎̄̍́͘̚̚͝͠͠ͅ!̶̨̨̨̛̛̟̳̼̘͎͔̜͎͚̖̮̰͕̞̦̩̗̫̠͔͕͎͎͎̦̬̫̩̰̲̈́͋̽̀̒͆̄̑̐̀̐̋͆̈́̊̽̊̅̊̀͆͆͑̈͋̌͆͑̂̊͑̚͝͝ͅͅͅ", "hello world!")
}
```

--------------------------------

### deunicode_with_tofu_cow

Source: https://docs.rs/deunicode

An optimized version of `deunicode_with_tofu` that avoids allocating a new String if the input string does not contain any characters that need replacement.

```APIDOC
## deunicode_with_tofu_cow()

### Description
Same as `deunicode_with_tofu()`, but avoids allocating a new `String` if not necessary.

### Function Signature
`fn deunicode_with_tofu_cow<'a>(s: &'a str, tofu: &str) -> Cow<'a, str>`

### Parameters
* `s` (string slice) - The input Unicode string to transliterate.
* `tofu` (string slice) - The string to use for replacing unknown characters.

### Returns
* `Cow<'a, str>` - A `Cow` (Clone-on-Write) containing the ASCII transliteration. It will be a borrowed slice if no changes were made, or an owned `String` if replacements occurred.

### Example
```rust
use deunicode::deunicode_with_tofu_cow;
use std::borrow::Cow;

let original = "hello";
let result = deunicode_with_tofu_cow(original, "?");
assert!(matches!(result, Cow::Borrowed(_)));
assert_eq!(result, "hello");

let original_with_unknown = "你好";
let result_with_unknown = deunicode_with_tofu_cow(original_with_unknown, "?");
assert!(matches!(result_with_unknown, Cow::Owned(_)));
assert_eq!(result_with_unknown, "? ?");
```
```

--------------------------------

### Custom Placeholder for Unknown Characters

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

Use `deunicode_with_tofu` to specify a custom string for replacing unknown Unicode characters, offering more control over the output.

```rust
use deunicode::deunicode_with_tofu;

assert_eq!(deunicode_with_tofu("你好", "[?]" ), "[?] [?]");
```

--------------------------------

### try_find

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Applies a function to the elements of an iterator and returns the first true result or the first error. This is a nightly-only experimental API.

```APIDOC
## fn try_find<R>(
    &mut self,
    f: impl FnMut(&Self::Item) -> R,
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
where
    Self: Sized,
    R: Try<Output = bool>,
    <R as Try>::Residual: Residual<Option<Self::Item>>,

This is a nightly-only experimental API. (`try_find`)
Applies function to the elements of iterator and returns the first true result or the first error. Read more
```

--------------------------------

### str Implementation of AsciiChars

Source: https://docs.rs/deunicode/latest/deunicode/trait.AsciiChars.html

Shows the AsciiChars trait implementation for string slices (`str`), enabling ASCII conversion methods on them.

```rust
impl AsciiChars for str
```

--------------------------------

### AsciiCharsIter Iterator Methods

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

AsciiCharsIter implements the Iterator trait, providing methods for iteration and collection.

```APIDOC
## Iterator Implementations for AsciiCharsIter

### `Item` Type
```rust
type Item = Option<&'static str>
```

### `next()`
Advances the iterator and returns the next value.

### `count()`
Consumes the iterator, counting the number of iterations and returning it.

### `size_hint()`
Returns the bounds on the remaining length of the iterator.

### `next_chunk()`
Advances the iterator and returns an array containing the next `N` values. (Nightly-only)

### `last()`
Consumes the iterator, returning the last element.

### `advance_by()`
Advances the iterator by `n` elements. (Nightly-only)

### `nth()`
Returns the `n`th element of the iterator.

### `step_by()`
Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

### `chain()`
Takes two iterators and creates a new iterator over both in sequence.

### `zip()`
‘Zips up’ two iterators into a single iterator of pairs.

### `intersperse()`
Creates a new iterator which places a copy of `separator` between adjacent items of the original iterator. (Nightly-only)

### `intersperse_with()`
Creates a new iterator which places an item generated by `separator` between adjacent items of the original iterator. (Nightly-only)

### `map()`
Takes a closure and creates an iterator which calls that closure on each element.

### `for_each()`
Calls a closure on each element of an iterator.

### `filter()`
Creates an iterator which uses a closure to determine if an element should be yielded.

### `filter_map()`
Creates an iterator that both filters and maps.

### `enumerate()`
Creates an iterator which gives the current iteration count as well as the next value.

### `peekable()`
Creates an iterator which can use the `peek` and `peek_mut` methods to look at the next element of the iterator without consuming it.
```

--------------------------------

### map_while

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates an iterator that both yields elements based on a predicate and maps them. The iterator continues as long as the predicate returns Some(value), and the returned value is the mapped value. If the predicate returns None, the iterator stops.

```APIDOC
## fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
where Self: Sized, P: FnMut(Self::Item) -> Option<B>,
Creates an iterator that both yields elements based on a predicate and maps.
```

--------------------------------

### min_by

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Returns the element that yields the minimum value according to a specified comparison function.

```APIDOC
## fn min_by<F>(self, compare: F) -> Option<Self::Item>
where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function. Read more
```

--------------------------------

### cmp

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Lexicographically compares the elements of this Iterator with those of another.

```APIDOC
## fn cmp<I>(self, other: I) -> Ordering
where
    I: IntoIterator<Item = Self::Item>,
    Self::Item: Ord,
    Self: Sized,

Lexicographically compares the elements of this `Iterator` with those of another. Read more
```

--------------------------------

### position

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Searches for an element in an iterator and returns its index.

```APIDOC
## fn position<P>(&mut self, predicate: P) -> Option<usize>
where
    Self: Sized,
    P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index. Read more
```

--------------------------------

### String Implementation for AsciiChars

Source: https://docs.rs/deunicode/latest/deunicode/trait.AsciiChars.html

The `String` type also implements the `AsciiChars` trait (available on `alloc` feature), providing `ascii_chars` and `to_ascii_lossy` methods for owned strings.

```APIDOC
### impl AsciiChars for String

Available on **crate feature`alloc`** only.

#### fn ascii_chars(&self) -> AsciiCharsIter<'_>

#### fn to_ascii_lossy(&self) -> String
```

--------------------------------

### take_while

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates an iterator that yields elements as long as a predicate returns true. Once the predicate returns false, the iterator stops yielding elements.

```APIDOC
## fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
where Self: Sized, P: FnMut(&Self::Item) -> bool,
Creates an iterator that yields elements based on a predicate.
```

--------------------------------

### find

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Searches for an element of an iterator that satisfies a predicate.

```APIDOC
## fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate. Read more
```

--------------------------------

### AsciiCharsIter Iterator Implementation

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

This code implements the `Iterator` trait for `AsciiCharsIter`, handling character de-unification and trimming trailing spaces. It manages the internal state of the iterator, including buffering the next character.

```rust
    fn next(&mut self) -> Option<Option<String>> {
        let dch = self.next_char?;
        self.next_char = self.chars.next().map(deunicode_char);
        let dch = match dch {
            None => return Some(None),
            Some(dch) => dch,
        };
        // ends with space
        let trim_last_char = dch.as_bytes().len() > 1 && dch.as_bytes().last().copied() == Some(b' ') &&
            self.next_char.map_or(true, |ch| { // true if end
            ch.map_or(false, |ch| ch.as_bytes().first().copied() == Some(b' ')) // space next (assume placeholder is not space)
        });
        Some(if !trim_last_char {
            Some(dch)
        } else {
            dch.get(..dch.len()-1)
        })
    }

    #[inline]
    fn count(self) -> usize {
        self.chars.count() + if self.next_char.is_some() {1} else {0}
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        (self.chars.size_hint().0 + if self.next_char.is_some() {1} else {0}, None)
    }
}
```

--------------------------------

### deunicode_with_tofu

Source: https://docs.rs/deunicode/latest/deunicode/index.html

Same as `deunicode()`, but unknown characters can be replaced with a custom string.

```APIDOC
## deunicode_with_tofu()

### Description
Same as `deunicode()`, but unknown characters can be replaced with a custom string.

### Function Signature
`fn deunicode_with_tofu(s: &str, tofu: &str) -> String`

### Parameters
* `s` (str) - The input Unicode string.
* `tofu` (str) - The string to replace unknown characters with.

### Returns
* `String` - An ASCII transliteration of the input string, with unknown characters replaced by `tofu`.

### Examples
```rust
use deunicode::deunicode_with_tofu;

assert_eq!(deunicode_with_tofu("hello world", "?"), "hello world");
assert_eq!(deunicode_with_tofu("你好", "?"), "? ?");
```
```

--------------------------------

### Iterate Over ASCII Characters

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

Provides an iterator over Unicode characters converted to ASCII strings. Use `.map(|ch| ch.unwrap_or("?"))` to replace characters that cannot be converted. This iterator can also be used directly in formatters without extra allocations.

```rust
use deunicode::AsciiChars;

format!("what\'s up {}", "🐶".ascii_chars());
```

--------------------------------

### skip_while

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates an iterator that skips elements based on a predicate. Elements are skipped as long as the predicate returns true. Once the predicate returns false, all remaining elements are yielded.

```APIDOC
## fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
where Self: Sized, P: FnMut(&Self::Item) -> bool,
Creates an iterator that `skip`s elements based on a predicate.
```

--------------------------------

### deunicode_with_tofu Function

Source: https://docs.rs/deunicode/latest/deunicode

Same as `deunicode()`, but unknown characters can be replaced with a custom string.

```APIDOC
## deunicode_with_tofu()

### Description
Same as `deunicode()`, but unknown characters can be replaced with a custom string.

### Function Signature
`fn deunicode_with_tofu(s: &str, tofu: &str) -> String`

### Parameters
* `s` (string) - The Unicode string to transliterate.
* `tofu` (string) - The string to use for replacing unknown characters.

### Returns
* `String` - The ASCII transliteration of the input string with unknown characters replaced.

### Example
```rust
use deunicode::deunicode_with_tofu;

assert_eq!(deunicode_with_tofu("hello 🦄 world", "?"), "hello ? world");
assert_eq!(deunicode_with_tofu("你好", "-"), "--");
```
```

--------------------------------

### Convert String to ASCII Lossily

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

Converts any Unicode string to an ASCII-only string. Characters are replaced with their closest ASCII equivalents. Characters that cannot be converted are replaced with `"[?]"`.

```rust
use deunicode::AsciiChars;

let unicode_string = String::from("你好世界");
let ascii_string = unicode_string.to_ascii_lossy();
assert_eq!(ascii_string, "[?][?][?][?]");
```

--------------------------------

### Transliterate a single Unicode character

Source: https://docs.rs/deunicode/latest/deunicode/fn.deunicode_char.html

Use this function to convert a single Unicode character to its ASCII equivalent. The function returns an Option<&'static str>, where Some contains the transliteration and None indicates no transliteration is available.

```rust
assert_eq!(deunicode_char('Æ'), Some("AE"));
assert_eq!(deunicode_char('北'), Some("Bei "));
```

--------------------------------

### sum

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Sums the elements of an iterator.

```APIDOC
## fn sum<S>(self) -> S
where
    Self: Sized,
    S: Sum<Self::Item>,

Sums the elements of an iterator. Read more
```

--------------------------------

### flat_map

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates an iterator that works like `map`, but flattens nested structures. For each element, it applies a function that returns an iterator, and then concatenates the results of these iterators.

```APIDOC
## fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,
Creates an iterator that works like map, but flattens nested structure.
```

--------------------------------

### AsciiCharsIter

Source: https://docs.rs/deunicode/latest/src/deunicode/lib.rs.html

Iterator that translates Unicode characters to ASCII strings. See [`AsciiChars`] trait's `str.ascii_chars()` method. Additionally, it implements `Display` for formatting strings without allocations.

```APIDOC
## AsciiCharsIter

### Description
An iterator that translates Unicode characters to ASCII strings. It implements `Display` for formatting strings without allocations.

### Methods
#### `new(unicode_string: &'a str) -> Self`

##### Description
Creates a new `AsciiCharsIter` from a Unicode string slice.

##### Parameters
- **unicode_string** (&'a str) - The input Unicode string slice.

##### Returns
- `AsciiCharsIter<'a>` - A new iterator instance.

### Example
```rust
use deunicode::AsciiChars;
let iterator = "你好".ascii_chars();
```
```

--------------------------------

### fuse

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Creates an iterator which ends after the first `None` is encountered. Subsequent calls to `next()` on the fused iterator will always return `None`.

```APIDOC
## fn fuse(self) -> Fuse<Self>
where Self: Sized,
Creates an iterator which ends after the first `None`.
```

--------------------------------

### array_chunks

Source: https://docs.rs/deunicode/latest/deunicode/struct.AsciiCharsIter.html

Returns an iterator over N elements of the iterator at a time. This is a nightly-only experimental API.

```APIDOC
## fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
where
    Self: Sized,

This is a nightly-only experimental API. (`iter_array_chunks`)
Returns an iterator over `N` elements of the iterator at a time. Read more
```

--------------------------------

### deunicode_with_tofu_cow

Source: https://docs.rs/deunicode/latest/deunicode/fn.deunicode_with_tofu_cow.html

Deunicodes a string using a custom placeholder, returning a `Cow<'input, str>` which may be borrowed if no changes are made.

```APIDOC
## Function deunicode_with_tofu_cow

### Description
Same as `deunicode_with_tofu()`, but avoids allocating a new `String` if not necessary. You can use “\u{FFFD}” to use the usual Unicode Replacement Character. “Tofu” is a nickname for a replacement character, which in Unicode fonts usually looks like a block of tofu.

### Signature
```rust
pub fn deunicode_with_tofu_cow<'input>(
    s: &'input str,
    custom_placeholder: &str,
) -> Cow<'input, str>
```

### Parameters
* `s` (*&'input str*) - The input string slice to deunicode.
* `custom_placeholder` (*&str*) - The string to use as a replacement for characters that cannot be deunicoded. For the standard Unicode Replacement Character, use "\u{FFFD}".

### Returns
* `Cow<'input, str>` - A `Cow` containing the deunicoded string. This will be a borrowed slice if no characters were replaced, or an owned `String` if replacements were made.
```
Tokens:
Raw