### Full Unicode Case Folding Examples

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.unicode_full_turkic_case_eq.html

Illustrates compatibility with full Unicode case folding rules.

```rust
assert!(unicode_full_turkic_case_eq("MASSE", "Maße"));
assert!(!unicode_full_turkic_case_eq("São Paulo", "Sao Paulo"));
```

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

### Constructing a CaseFold instance

Source: https://docs.rs/focaccia/2.0.0/focaccia/enum.CaseFold.html

Demonstrates creating a new CaseFold instance using the default Full strategy.

```rust
const FOLD: CaseFold = CaseFold::new();

assert_eq!(CaseFold::new(), CaseFold::Full);

assert!(CaseFold::new().case_eq("MASSE", "Maße"));
assert!(!CaseFold::new().case_eq("São Paulo", "Sao Paulo"));
```

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

### Basic Turkic Case Equality Usage

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.unicode_full_turkic_case_eq.html

Demonstrates basic string comparison using Turkic case folding rules.

```rust
assert!(unicode_full_turkic_case_eq("İstanbul", "istanbul"));
assert!(!unicode_full_turkic_case_eq("İstanbul", "Istanbul"));
```

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

### Basic Turkic Case Comparison

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.unicode_full_turkic_casecmp.html

Demonstrates comparing strings with Turkic-specific case folding rules.

```rust
assert_eq!(unicode_full_turkic_casecmp("İstanbul", "istanbul"), Ordering::Equal);
assert_ne!(unicode_full_turkic_casecmp("İstanbul", "Istanbul"), Ordering::Equal);
```

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

### Comparing byte strings with ascii_case_eq

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.ascii_case_eq.html

Demonstrates how to use ascii_case_eq to compare byte strings for case-insensitive equality.

```rust
assert!(ascii_case_eq(b"Artichoke Ruby", b"artichoke ruby"));
assert!(!ascii_case_eq(b"artichoke ruby", b"Artichoke"));
```

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

### Compare byte strings with ascii_casecmp

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.ascii_casecmp.html

Demonstrates comparing byte strings for equality and ordering using ASCII case folding.

```rust
assert_eq!(ascii_casecmp(b"Artichoke Ruby", b"artichoke ruby"), Ordering::Equal);
assert_eq!(ascii_casecmp(b"artichoke ruby", b"Artichoke"), Ordering::Greater);
```

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

### Handling Case Folding Resolution

Source: https://docs.rs/focaccia/2.0.0/focaccia/struct.NoSuchCaseFoldingScheme.html

Demonstrates using TryFrom to resolve case folding schemes and handling the error case.

```rust
assert_eq!(CaseFold::try_from(None::<&str>), Ok(CaseFold::Full));
assert_eq!(CaseFold::try_from(Some("ascii")), Ok(CaseFold::Ascii));
assert_eq!(CaseFold::try_from(Some("turkic")), Ok(CaseFold::Turkic));
assert_eq!(CaseFold::try_from(Some("lithuanian")), Ok(CaseFold::Lithuanian));
assert_eq!(CaseFold::try_from(Some("xxx")), Err(NoSuchCaseFoldingScheme::new()));
```

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

### Compare strings with Unicode full case folding

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.unicode_full_case_eq.html

Demonstrates how to use unicode_full_case_eq to compare strings where case folding affects equality, such as handling the German sharp s.

```rust
assert!(unicode_full_case_eq("MASSE", "Maße"));
assert!(!unicode_full_case_eq("São Paulo", "Sao Paulo"));
```

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

### Default CaseFold Usage

Source: https://docs.rs/focaccia/2.0.0/focaccia/enum.CaseFold.html

Demonstrates the default behavior of CaseFold, which defaults to full Unicode case folding.

```rust
assert_eq!(CaseFold::default(), CaseFold::Full);

assert!(CaseFold::default().case_eq("MASSE", "Maße"));
assert!(!CaseFold::default().case_eq("São Paulo", "Sao Paulo"));
```

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

### Full Unicode Case Folding Comparison

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.unicode_full_turkic_casecmp.html

Shows compatibility with full Unicode case folding alongside Turkic-specific behavior.

```rust
assert_eq!(unicode_full_turkic_casecmp("MASSE", "Maße"), Ordering::Equal);
assert_eq!(unicode_full_turkic_casecmp("São Paulo", "Sao Paulo"), Ordering::Greater);
```

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

### CaseFold::new()

Source: https://docs.rs/focaccia/2.0.0/focaccia/enum.CaseFold.html

Constructs a new CaseFold instance using the default Full Unicode case folding strategy.

```APIDOC
## pub const fn new() -> Self

### Description
Constructs a new full Unicode case folding instance, equivalent to `CaseFold::Full`.

### Signature
`pub const fn new() -> Self`
```

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

### Compare strings with unicode_full_casecmp

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.unicode_full_casecmp.html

Demonstrates comparing strings using Full Unicode case folding, where 'MASSE' is equivalent to 'Maße'.

```rust
assert_eq!(unicode_full_casecmp("MASSE", "Maße"), Ordering::Equal);
assert_eq!(unicode_full_casecmp("São Paulo", "Sao Paulo"), Ordering::Greater);
```

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

### Constructing NoSuchCaseFoldingScheme

Source: https://docs.rs/focaccia/2.0.0/focaccia/struct.NoSuchCaseFoldingScheme.html

Shows how to manually instantiate the error type using the new constructor.

```rust
const ERR: NoSuchCaseFoldingScheme = NoSuchCaseFoldingScheme::new();
```

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

### Unicode Case Comparison Functions

Source: https://docs.rs/focaccia/2.0.0/focaccia/index.html

Free functions for performing case-insensitive comparisons on strings using Full or Turkic Unicode rules.

```APIDOC
## unicode_full_case_eq / unicode_full_casecmp

### Description
Check two strings for equality or compare them using Full Unicode case folding.

## unicode_full_turkic_case_eq / unicode_full_turkic_casecmp

### Description
Check two strings for equality or compare them using Full Unicode case folding specifically for Turkic languages.
```

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

### pub fn ascii_case_eq(left: &[u8], right: &[u8]) -> bool

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.ascii_case_eq.html

Compares two byte slices for equality using ASCII case folding.

```APIDOC
## Function: ascii_case_eq

### Description
Checks two byte strings for equality with ASCII case folding. This function is implemented using ASCII folding functions from the Rust core library.

### Signature
`pub fn ascii_case_eq(left: &[u8], right: &[u8]) -> bool`

### Parameters
- **left** (&[u8]) - The first byte slice to compare.
- **right** (&[u8]) - The second byte slice to compare.

### Returns
- **bool** - Returns true if the byte slices are equal under ASCII case-insensitive comparison, false otherwise.

### Examples
```rust
assert!(ascii_case_eq(b"Artichoke Ruby", b"artichoke ruby"));
assert!(!ascii_case_eq(b"artichoke ruby", b"Artichoke"));
```
```

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

### unicode_full_turkic_casecmp(left: &str, right: &str) -> Ordering

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.unicode_full_turkic_casecmp.html

Compares two strings using Full Unicode case folding for Turkic languages. Returns an Ordering enum indicating the relationship between the two strings.

```APIDOC
## Function: unicode_full_turkic_casecmp

### Description
Compares two strings with Full Unicode case folding for Turkic languages. This function utilizes a lookup table generated from Unicode case folding tables.

### Signature
`pub fn unicode_full_turkic_casecmp(left: &str, right: &str) -> Ordering`

### Parameters
- **left** (&str) - The first string to compare.
- **right** (&str) - The second string to compare.

### Returns
- **Ordering** - Returns `Ordering::Less`, `Ordering::Equal`, or `Ordering::Greater` based on the comparison.

### Examples
```rust
use std::cmp::Ordering;

// Turkic case folding example
assert_eq!(unicode_full_turkic_casecmp("İstanbul", "istanbul"), Ordering::Equal);

// Full Unicode case folding compatibility
assert_eq!(unicode_full_turkic_casecmp("MASSE", "Maße"), Ordering::Equal);
```
```

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

### ASCII Case Comparison Functions

Source: https://docs.rs/focaccia/2.0.0/focaccia/index.html

Functions for performing case-insensitive comparisons on byte slices using ASCII rules.

```APIDOC
## ascii_case_eq

### Description
Check two byte strings for equality with ASCII case folding.

### Signature
`fn ascii_case_eq(a: &[u8], b: &[u8]) -> bool`

## ascii_casecmp

### Description
Compare two byte strings with ASCII case folding.

### Signature
`fn ascii_casecmp(a: &[u8], b: &[u8]) -> Ordering`
```

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

### Perform Full Unicode Case Folding

Source: https://docs.rs/focaccia

Use the Full folding scheme for general Unicode text comparisons.

```rust
let fold = CaseFold::Full;
assert_eq!(fold.casecmp("MASSE", "Maße"), Ordering::Equal);
assert_eq!(fold.casecmp("São Paulo", "Sao Paulo"), Ordering::Greater);

assert!(fold.case_eq("MASSE", "Maße"));
assert!(!fold.case_eq("São Paulo", "Sao Paulo"));
```

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

### fn ascii_casecmp

Source: https://docs.rs/focaccia/2.0.0/focaccia/fn.ascii_casecmp.html

Compares two byte slices for equality using ASCII case-insensitive comparison.

```APIDOC
## fn ascii_casecmp

### Description
Compares two byte strings with ASCII case folding. This function is implemented using ASCII folding functions from the Rust core library.

### Signature
`pub fn ascii_casecmp(left: &[u8], right: &[u8]) -> Ordering`

### Parameters
- **left** (&[u8]) - The first byte slice to compare.
- **right** (&[u8]) - The second byte slice to compare.

### Returns
- **Ordering** - Returns `Ordering::Equal`, `Ordering::Less`, or `Ordering::Greater` based on the comparison.

### Example
```rust
use std::cmp::Ordering;
assert_eq!(ascii_casecmp(b"Artichoke Ruby", b"artichoke ruby"), Ordering::Equal);
assert_eq!(ascii_casecmp(b"artichoke ruby", b"Artichoke"), Ordering::Greater);
```
```

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

### Comparing strings with casecmp

Source: https://docs.rs/focaccia/2.0.0/focaccia/enum.CaseFold.html

Performs case-insensitive string comparisons using different folding strategies.

```rust
let fold = CaseFold::Full;
assert_eq!(fold.casecmp("MASSE", "Maße"), Ordering::Equal);
assert_eq!(fold.casecmp("São Paulo", "Sao Paulo"), Ordering::Greater);
```

```rust
let fold = CaseFold::Ascii;
assert_eq!(fold.casecmp("Crate: focaccia", "Crate: FOCACCIA"), Ordering::Equal);
assert_eq!(fold.casecmp("Fabled", "failed"), Ordering::Less);
```

```rust
let fold = CaseFold::Turkic;
assert_eq!(fold.casecmp("İstanbul", "istanbul"), Ordering::Equal);
assert_ne!(fold.casecmp("İstanbul", "Istanbul"), Ordering::Equal);
```

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

### CaseFold::casecmp

Source: https://docs.rs/focaccia/2.0.0/focaccia/index.html

Compares two strings using the selected case folding strategy and returns an Ordering.

```APIDOC
## CaseFold::casecmp

### Description
Compares two strings using the selected case folding strategy (Full, Ascii, or Turkic) and returns an Ordering (Equal, Less, or Greater).

### Signature
`fn casecmp(&self, a: &str, b: &str) -> Ordering`

### Example
```rust
let fold = CaseFold::Full;
assert_eq!(fold.casecmp("MASSE", "Maße"), Ordering::Equal);
```
```

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

### Perform Turkic Case Folding

Source: https://docs.rs/focaccia

Use the Turkic folding scheme for languages requiring specific mappings for dotted and dotless I.

```rust
let fold = CaseFold::Turkic;
assert_eq!(fold.casecmp("İstanbul", "istanbul"), Ordering::Equal);
assert_ne!(fold.casecmp("İstanbul", "Istanbul"), Ordering::Equal);

assert!(fold.case_eq("İstanbul", "istanbul"));
assert!(!fold.case_eq("İstanbul", "Istanbul"));
```

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

### ascii_casecmp

Source: https://docs.rs/focaccia/2.0.0/focaccia/all.html

Performs a case-insensitive comparison of two strings using ASCII rules.

```APIDOC
## ascii_casecmp

### Description
Performs a case-insensitive comparison of two strings using ASCII rules.

### Signature
`pub fn ascii_casecmp(a: &str, b: &str) -> Ordering`
```

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

### unicode_full_turkic_case_eq

Source: https://docs.rs/focaccia/2.0.0/focaccia/all.html

Performs a case-insensitive equality check for two strings using Unicode full case folding with Turkic locale rules.

```APIDOC
## unicode_full_turkic_case_eq

### Description
Performs a case-insensitive equality check for two strings using Unicode full case folding with Turkic locale rules.

### Signature
`pub fn unicode_full_turkic_case_eq(a: &str, b: &str) -> bool`
```

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

### unicode_full_turkic_casecmp

Source: https://docs.rs/focaccia/2.0.0/focaccia/all.html

Performs a case-insensitive comparison of two strings using Unicode full case folding with Turkic locale rules.

```APIDOC
## unicode_full_turkic_casecmp

### Description
Performs a case-insensitive comparison of two strings using Unicode full case folding with Turkic locale rules.

### Signature
`pub fn unicode_full_turkic_casecmp(a: &str, b: &str) -> Ordering`
```

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

### Checking string equality with case_eq

Source: https://docs.rs/focaccia/2.0.0/focaccia/enum.CaseFold.html

Performs case-insensitive string equality checks using different folding strategies.

```rust
let fold = CaseFold::Full;
assert!(fold.case_eq("MASSE", "Maße"));
assert!(!fold.case_eq("São Paulo", "Sao Paulo"));
```

```rust
let fold = CaseFold::Ascii;
assert!(fold.case_eq("Crate: focaccia", "Crate: FOCACCIA"));
assert!(!fold.case_eq("Fabled", "failed"));
```

```rust
let fold = CaseFold::Turkic;
assert!(fold.case_eq("İstanbul", "istanbul"));
assert!(!fold.case_eq("İstanbul", "Istanbul"));
```

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

### unicode_full_casecmp

Source: https://docs.rs/focaccia/2.0.0/focaccia/all.html

Performs a case-insensitive comparison of two strings using Unicode full case folding.

```APIDOC
## unicode_full_casecmp

### Description
Performs a case-insensitive comparison of two strings using Unicode full case folding.

### Signature
`pub fn unicode_full_casecmp(a: &str, b: &str) -> Ordering`
```

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

### Perform ASCII Case Folding on Byte Slices

Source: https://docs.rs/focaccia

Directly compare byte slices using ASCII case folding functions.

```rust
assert_eq!(ascii_casecmp(b"Artichoke Ruby", b"artichoke ruby"), Ordering::Equal);
assert!(ascii_case_eq(b"Artichoke Ruby", b"artichoke ruby"));
```

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

### CaseFold::case_eq

Source: https://docs.rs/focaccia/2.0.0/focaccia/index.html

Checks two strings for equality using the selected case folding strategy.

```APIDOC
## CaseFold::case_eq

### Description
Checks two strings for equality using the selected case folding strategy (Full, Ascii, or Turkic).

### Signature
`fn case_eq(&self, a: &str, b: &str) -> bool`

### Example
```rust
let fold = CaseFold::Full;
assert!(fold.case_eq("MASSE", "Maße"));
```
```

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

### Perform ASCII Case Folding

Source: https://docs.rs/focaccia

Use the Ascii folding scheme for performant comparisons on text known to be ASCII.

```rust
let fold = CaseFold::Ascii;
assert_eq!(fold.casecmp("Crate: focaccia", "Crate: FOCACCIA"), Ordering::Equal);
assert_eq!(fold.casecmp("Fabled", "failed"), Ordering::Less);

assert!(fold.case_eq("Crate: focaccia", "Crate: FOCACCIA"));
assert!(!fold.case_eq("Fabled", "failed"));
```

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

### ascii_case_eq

Source: https://docs.rs/focaccia/2.0.0/focaccia/all.html

Performs a case-insensitive equality check for two strings using ASCII rules.

```APIDOC
## ascii_case_eq

### Description
Performs a case-insensitive equality check for two strings using ASCII rules.

### Signature
`pub fn ascii_case_eq(a: &str, b: &str) -> bool`
```

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

### unicode_full_case_eq

Source: https://docs.rs/focaccia/2.0.0/focaccia/all.html

Performs a case-insensitive equality check for two strings using Unicode full case folding.

```APIDOC
## unicode_full_case_eq

### Description
Performs a case-insensitive equality check for two strings using Unicode full case folding.

### Signature
`pub fn unicode_full_case_eq(a: &str, b: &str) -> bool`
```

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

### ASCII Case Folding Functions

Source: https://docs.rs/focaccia

Functions for performing case-insensitive comparisons on byte slices using ASCII rules.

```APIDOC
## ascii_case_eq

### Description
Checks two byte strings for equality with ASCII case folding.

## ascii_casecmp

### Description
Compares two byte strings with ASCII case folding, returning an Ordering.
```

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

### Unicode Case Folding Functions

Source: https://docs.rs/focaccia

Functions for performing case-insensitive comparisons on strings using Full or Turkic Unicode rules.

```APIDOC
## unicode_full_case_eq / unicode_full_casecmp

### Description
Check equality or compare two strings using Full Unicode case folding.

## unicode_full_turkic_case_eq / unicode_full_turkic_casecmp

### Description
Check equality or compare two strings using Full Unicode case folding specifically for Turkic languages (handling dotted/dotless I).
```

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

### CaseFold Enum

Source: https://docs.rs/focaccia

The CaseFold enum is the primary entry point for performing case-insensitive comparisons using different Unicode folding strategies.

```APIDOC
## CaseFold

### Description
An enum representing Unicode case folding strategies (Full, Ascii, Turkic). It provides methods for case-insensitive equality checks and ordering comparisons.

### Methods
- **case_eq(a: &str, b: &str) -> bool**: Checks if two strings are equal under the chosen folding scheme.
- **casecmp(a: &str, b: &str) -> Ordering**: Compares two strings under the chosen folding scheme.
```

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

### Define CaseFold Enum

Source: https://docs.rs/focaccia/2.0.0/focaccia/enum.CaseFold.html

The definition of the CaseFold enum showing available folding strategies.

```rust
pub enum CaseFold {
    Full,
    Ascii,
    Turkic,
    Lithuanian,
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.