Oxilangtag

https://docs.rs/oxilangtag/0.1.6/oxilangtag/
Admin
OxiLangTag is a Rust library allowing to validate and normalize language tags following RFC 5646...
Tokens:27,148
Snippets:364
Trust Score:9.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Trim Start Example

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Demonstrates trimming leading whitespace from a string.

```rust
let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());
```

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

### Trim Start Matches Example

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Demonstrates trimming characters from the start of a string slice.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

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

### Trim Start Matches Usage

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Demonstrates removing prefixes that match a pattern.

```rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
```

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

### Check string prefix

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Determines if the string starts with a given pattern.

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

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

### starts_with<P>(pat: P)

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Checks if the string starts with the given pattern.

```APIDOC
## starts_with<P>(pat: P)

### Description
Returns `true` if the given pattern matches a prefix of this string slice.
```

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

### Using rsplit

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Examples of splitting a string in reverse order using various patterns.

```rust
let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect();
assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]);

let v: Vec<&str> = "".rsplit('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect();
assert_eq!(v, ["leopard", "tiger", "", "lion"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect();
assert_eq!(v, ["leopard", "tiger", "lion"]);
```

```rust
let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "def", "abc"]);
```

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

### Using split_inclusive

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Examples of splitting a string while keeping the matched pattern as a terminator.

```rust
let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb."
    .split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);
```

```rust
let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb.\n"
    .split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);
```

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

### Using split_terminator

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Examples of splitting a string where the trailing empty substring is skipped.

```rust
let v: Vec<&str> = "A.B.".split_terminator('.').collect();
assert_eq!(v, ["A", "B"]);

let v: Vec<&str> = "A..B..".split_terminator(".").collect();
assert_eq!(v, ["A", "", "B", ""]);

let v: Vec<&str> = "A.B:C.D".split_terminator(&['.', ':'][..]).collect();
assert_eq!(v, ["A", "B", "C", "D"]);
```

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

### Check prefix and suffix

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Verifies if a string slice starts or ends with a given pattern.

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

```rust
let bananas = "bananas";

assert!(bananas.ends_with("anas"));
assert!(!bananas.ends_with("nana"));
```

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

### Trim string prefixes and suffixes

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Demonstrates method chaining to trim specific characters from the start and end of a string.

```rust
assert_eq!("<https://example.com/>".trim_prefix('<').trim_suffix('>'), "https://example.com/");
```

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

### Using rsplit_terminator

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Examples of splitting a string in reverse order while skipping the trailing empty substring.

```rust
let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect();
assert_eq!(v, ["B", "A"]);

let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect();
assert_eq!(v, ["", "B", "", "A"]);
```

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

### Check character boundaries

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Verifies if a byte index corresponds to the start of a UTF-8 character or the end of the string.

```rust
let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// second byte of `ö`
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));
```

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

### Split string with rsplitn

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Splits a string into at most n substrings starting from the end.

```rust
let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
assert_eq!(v, ["lamb", "little", "Mary had a"]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
assert_eq!(v, ["leopard", "tiger", "lionX"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
assert_eq!(v, ["leopard", "lion::tiger"]);
```

```rust
let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "abc1def"]);
```

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

### Trim ASCII whitespace from start

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Remove leading ASCII whitespace characters from a string slice.

```rust
assert_eq!(" \t \u{3000}hello world\n".trim_ascii_start(), "\u{3000}hello world\n");
assert_eq!("  ".trim_ascii_start(), "");
assert_eq!("".trim_ascii_start(), "");
```

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

### Get raw pointer

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns a raw pointer to the first byte of the string slice.

```rust
let s = "Hello";
let ptr = s.as_ptr();
```

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

### Remove leading whitespace with trim_start

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Removes leading whitespace from a string slice, respecting byte-level start position.

```rust
let s = "\n Hello\tworld\t\n";
assert_eq!("Hello\tworld\t\n", s.trim_start());
```

```rust
let s = "  English  ";
assert!(Some('E') == s.trim_start().chars().next());
```

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

### Configure Serde for no_std

Source: https://docs.rs/oxilangtag

Shows how to configure the Serde dependency for no_std environments by disabling default features.

```toml
serde = { version = "*", default-features = false }
```

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

### pub fn repeat(&self, n: usize) -> String

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Creates a new String by repeating a string n times.

```APIDOC
## pub fn repeat(&self, n: usize) -> String

### Description
Creates a new String by repeating a string n times.

### Parameters
- **n** (usize) - The number of times to repeat the string.

### Panics
This function will panic if the capacity would overflow.
```

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

### pub fn repeat(&self, n: usize) -> String

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new String by repeating a string n times.

```APIDOC
## pub fn repeat(&self, n: usize) -> String

### Description
Creates a new String by repeating a string n times. This function will panic if the capacity would overflow.
```

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

### Retrieve match indices with match_indices

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns an iterator over disjoint matches and their starting indices.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);

let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

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

### trim_start

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns a string slice with leading whitespace removed.

```APIDOC
## pub fn trim_start(&self) -> &str

### Description
Returns a string slice with leading whitespace removed. 'Start' refers to the first position of the byte string.
```

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

### trim_start(&self) -> &str

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=std%3A%3Avec

Returns a string slice with leading whitespace removed.

```APIDOC
## trim_start(&self)

### Description
Returns a string slice with leading whitespace removed. Whitespace is defined according to the Unicode Derived Core Property White_Space.
```

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

### Get subslice safely

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns a subslice if the indices are valid, otherwise returns None.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

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

### pub fn trim_prefix<P>(&self, prefix: P) -> &str

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Removes the prefix if present, otherwise returns the original string.

```APIDOC
## trim_prefix

### Description
Removes the specified prefix if it exists at the start of the string. Returns the modified string or the original string if no match is found, facilitating method chaining.

### Parameters
- **prefix** (P) - Required - The pattern to match at the start.
```

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

### trim_ascii_start

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns a string slice with leading ASCII whitespace removed.

```APIDOC
## pub fn trim_ascii_start(&self) -> &str

### Description
Returns a string slice with leading ASCII whitespace removed. The definition of whitespace follows `u8::is_ascii_whitespace`, which excludes the U+000B code point.
```

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

### Trim Matches with Patterns

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Demonstrates removing prefixes and suffixes that match specific patterns, characters, or closures.

```rust
assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");
```

```rust
assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");
```

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

### Get subslice unchecked

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns a subslice without performing bounds or UTF-8 boundary checks. Use with caution.

```rust
let v = "🗻∈🌏";
unsafe {
    assert_eq!("🗻", v.get_unchecked(0..4));
    assert_eq!("∈", v.get_unchecked(4..7));
    assert_eq!("🌏", v.get_unchecked(7..11));
}
```

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

### pub fn strip_prefix<P>(&self, prefix: P) -> Option<&str>

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a string slice with the prefix removed if it matches, otherwise returns None.

```APIDOC
## strip_prefix

### Description
Removes the specified prefix from the string exactly once if it exists. Returns the remaining substring wrapped in `Some`, or `None` if the prefix is not found.

### Parameters
- **prefix** (P) - Required - The pattern to match at the start of the string (e.g., &str, char, or closure).
```

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

### match_indices<P>

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns an iterator over the disjoint matches of a pattern within this string slice as well as the index that the match starts at.

```APIDOC
## pub fn match_indices<P>(&self, pat: P) -> MatchIndices<'_, P>

### Description
Returns an iterator over the disjoint matches of a pattern within this string slice as well as the index that the match starts at. For overlapping matches, only the indices corresponding to the first match are returned.
```

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

### match_indices<P>(&self, pat: P) -> MatchIndices<'_, P>

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=std%3A%3Avec

Returns an iterator over the disjoint matches of a pattern within this string slice as well as the index that the match starts at.

```APIDOC
## match_indices<P>(&self, pat: P)

### Description
Returns an iterator over the disjoint matches of a pattern within this string slice as well as the index that the match starts at. For overlapping matches, only the indices corresponding to the first match are returned.

### Parameters
- **pat** (P) - The pattern to search for.
```

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

### pub fn to_lowercase(&self) -> String

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=

Returns the lowercase equivalent of the string slice.

```APIDOC
## pub fn to_lowercase(&self) -> String

### Description
Returns the lowercase equivalent of this string slice, as a new String. Lowercase is defined according to the Unicode standard.
```

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

### pub fn replace<P>(&self, from: P, to: &str) -> String

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=

Replaces all matches of a pattern with another string.

```APIDOC
## pub fn replace<P>(&self, from: P, to: &str) -> String

### Description
Replaces all matches of a pattern with another string. It creates a new String and copies the data from the string slice, replacing matches found.
```

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

### Retrieve subslice safely and unsafely

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=

Methods for slicing strings, with get providing safe Option-based access and get_unchecked providing high-performance access requiring manual boundary validation.

```rust
let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// indices not on UTF-8 sequence boundaries
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// out of bounds
assert!(v.get(..42).is_none());
```

```rust
let v = "🗻∈🌏";
unsafe {
    assert_eq!("🗻", v.get_unchecked(0..4));
    assert_eq!("∈", v.get_unchecked(4..7));
    assert_eq!("🌏", v.get_unchecked(7..11));
}
```

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

### repeat

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html

Creates a new String by repeating the string slice n times.

```APIDOC
## pub fn repeat(&self, n: usize) -> String

### Description
Creates a new String by repeating a string n times.

### Parameters
- **&self** - The string slice to repeat.
- **n** (usize) - The number of times to repeat the string.

### Panics
This function will panic if the resulting capacity would overflow.

### Response
- **String** - The new string containing the repeated content.
```

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

### Repeat string

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Creates a new String by repeating the original string n times. Panics if the resulting capacity overflows.

```rust
assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));
```

```rust
// this will panic at runtime
let huge = "0123456789abcdef".repeat(usize::MAX);
```

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

### Trim End Usage and Directionality

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Shows basic usage of trim_end and how it behaves with different text directions.

```rust
let s = "\n Hello\tworld\t\n";
assert_eq!("\n Hello\tworld", s.trim_end());
```

```rust
let s = "  English  ";
assert!(Some('h') == s.trim_end().chars().rev().next());

let s = "  עברית  ";
assert!(Some('ת') == s.trim_end().chars().rev().next());
```

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

### Parse and inspect language tags

Source: https://docs.rs/oxilangtag

Demonstrates parsing a language tag string and accessing its individual components like primary language, script, and region.

```rust
use oxilangtag::LanguageTag;

// Parsing and validation
let language_tag = LanguageTag::parse("zh-cmn-Hans-CN-x-test").unwrap();
assert_eq!(language_tag.as_str(), "zh-cmn-Hans-CN-x-test");

// Language tag components
assert_eq!(language_tag.primary_language(), "zh");
assert_eq!(language_tag.extended_language(), Some("cmn"));
assert_eq!(language_tag.full_language(), "zh-cmn");
assert_eq!(language_tag.script(), Some("Hans"));
assert_eq!(language_tag.region(), Some("CN"));
assert_eq!(language_tag.extension(), None);
assert_eq!(language_tag.private_use_subtags().collect::<Vec<_>>(), vec!["test"]);
```

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

### to_uppercase

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html

Returns the uppercase equivalent of the string slice as a new String, following Unicode standard conformance.

```APIDOC
## pub fn to_uppercase(&self) -> String

### Description
Returns the uppercase equivalent of this string slice, as a new String. This method does not handle language-specific casing.

### Parameters
- **&self** - The string slice to convert to uppercase.

### Response
- **String** - The uppercase version of the input string.
```

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

### Strip Prefix Method

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Removes a prefix exactly once if it exists, returning an Option.

```rust
assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
assert_eq!("foo:bar".strip_prefix("bar"), None);
assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));
```

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

### Find floor and ceil character boundaries

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=

Methods to find the nearest valid UTF-8 character boundaries for safe string truncation.

```rust
let s = "❤️🧡💛💚💙💜";
assert_eq!(s.len(), 26);
assert!(!s.is_char_boundary(13));

let closest = s.floor_char_boundary(13);
assert_eq!(closest, 10);
assert_eq!(&s[..closest], "❤️🧡");
```

```rust
let s = "❤️🧡💛💚💙💜";
assert_eq!(s.len(), 26);
assert!(!s.is_char_boundary(13));

let closest = s.ceil_char_boundary(13);
assert_eq!(closest, 14);
assert_eq!(&s[..closest], "❤️🧡💛");
```

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

### find<P>(pat: P)

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Finds the byte index of the first character matching the pattern.

```APIDOC
## find<P>(pat: P)

### Description
Returns the byte index of the first character of this string slice that matches the pattern. Returns `None` if the pattern doesn’t match.
```

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

### trim_ascii_start

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=std%3A%3Avec

Removes leading ASCII whitespace from a string slice.

```APIDOC
## pub fn trim_ascii_start(&self) -> &str

### Description
Returns a string slice with leading ASCII whitespace removed, based on the definition in `u8::is_ascii_whitespace`.
```

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

### Titlecase string transformation

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the word_to_titlecase method, noting that it does not perform word segmentation and handles specific Unicode characters like Greek sigma.

```rust
assert_eq!(new_year, new_year.word_to_titlecase());
```

```rust
#![feature(titlecase)]
let georgian = "ერთობაშია";

assert_eq!(georgian, georgian.word_to_titlecase());
```

```rust
#![feature(titlecase)]
let blazingly_fast = "ferris and I";

assert_eq!("Ferris and i", blazingly_fast.word_to_titlecase());
```

```rust
#![feature(titlecase)]
let odysseus = "ὈΔΥΣΣΕΎΣ";

assert_eq!("Ὀδυσσεύς", odysseus.word_to_titlecase());

let odysseus_king_of_ithaca = "Ο ΟΔΥΣΣΈΑΣ ΒΑΣΙΛΙΆΣ ΤΗΣ ΙΘΆΚΗΣ";

assert_eq!("Ο οδυσσέας βασιλιάς της ιθάκης", odysseus_king_of_ithaca.word_to_titlecase());
```

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

### to_lowercase

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the lowercase equivalent of the string slice.

```APIDOC
## pub fn to_lowercase(&self) -> String

### Description
Returns the lowercase equivalent of this string slice as a new String, following Unicode standard definitions.
```

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

### Iterate extension subtags

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Iterate over extension subtags as key-value pairs.

```rust
use oxilangtag::LanguageTag;

let language_tag = LanguageTag::parse("de-DE-u-co-phonebk").unwrap();
assert_eq!(
    language_tag.extension_subtags().collect::<Vec<_>>(),
    vec![('u', "co-phonebk")]
);
```

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

### Asserting split behavior

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Demonstrates an assertion for a split operation.

```rust
assert_eq!(d, &["a", "b", "c"]);
```

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

### as_str

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the string slice as a &str. This is useful for dereferencing string-like types.

```APIDOC
## pub fn as_str(&self) -> &str

### Description
Returns the same string as a string slice &str. This method is redundant when used directly on &str, but it helps dereferencing other string-like types to string slices, for example references to Box<str> or Arc<str>.
```

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

### Trim Prefix Method

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Experimental API that returns the string slice without the prefix if present, or the original string if not. Requires the trim_prefix_suffix feature gate.

```rust
#![feature(trim_prefix_suffix)]

// Prefix present - removes it
assert_eq!("foo:bar".trim_prefix("foo:"), "bar");
assert_eq!("foofoo".trim_prefix("foo"), "foo");

// Prefix absent - returns original string
assert_eq!("foo:bar".trim_prefix("bar"), "foo:bar");

// Method chaining example
assert_eq!("<https://example.com/>".trim_prefix('<').trim_suffix('>'), "https://example.com/");
```

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

### pub fn trim_suffix<P>(&self, suffix: P) -> &str

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Removes the suffix if present, otherwise returns the original string.

```APIDOC
## trim_suffix

### Description
Removes the specified suffix if it exists at the end of the string. Returns the modified string or the original string if no match is found, facilitating method chaining.

### Parameters
- **suffix** (P) - Required - The pattern to match at the end.
```

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

### Trim Right Usage and Directionality

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Demonstrates the deprecated trim_right method and its behavior regarding text directionality.

```rust
let s = " Hello\tworld\t";

assert_eq!(" Hello\tworld", s.trim_right());
```

```rust
let s = "English  ";
assert!(Some('h') == s.trim_right().chars().rev().next());

let s = "עברית  ";
assert!(Some('ת') == s.trim_right().chars().rev().next());
```

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

### word_to_titlecase

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the titlecase equivalent of the string slice, assuming it represents a single word.

```APIDOC
## pub fn word_to_titlecase(&self) -> String

### Description
Returns the titlecase equivalent of this string slice, which is assumed to represent a single word, as a new String. It uppercases the first cased letter and lowercases everything that follows.
```

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

### Extract full language

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Retrieve the primary language and extended language subtags combined.

```rust
use oxilangtag::LanguageTag;

let language_tag = LanguageTag::parse("zh-cmn-Hans-CN").unwrap();
assert_eq!(language_tag.full_language(), "zh-cmn");
```

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

### LanguageTag::parse_and_normalize

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Parses a language tag according to RFC 5646 and normalizes its case, performing heap allocation.

```APIDOC
## pub fn parse_and_normalize(tag: &str) -> Result<Self, LanguageTagParseError>

### Description
Parses a language tag according to RFC 5646 and normalizes its case. This parser accepts language tags that are well-formed according to RFC 5646 and performs heap allocation.

### Parameters
- **tag** (&str) - Required - The language tag string to parse and normalize.
```

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

### Trim left matches (Deprecated)

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Removes prefixes matching a pattern. Superseded by trim_start_matches.

```rust
assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");
```

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

### trim

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns a string slice with leading and trailing whitespace removed.

```APIDOC
## pub fn trim(&self) -> &str

### Description
Returns a string slice with leading and trailing whitespace removed, as defined by the Unicode Derived Core Property White_Space.
```

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

### Convert string to lowercase

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns a new String with the lowercase equivalent of the input string slice.

```rust
let s = "HELLO WORLD";

assert_eq!("hello world", s.to_lowercase());
```

```rust
let sigma = "Σ";

assert_eq!("σ", sigma.to_lowercase());

// but at the end of a word, it's ς, not σ:
let odysseus = "ὈΔΥΣΣΕΎΣ";

assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());

let odysseus_king_of_ithaca = "Ο ΟΔΥΣΣΈΑΣ ΒΑΣΙΛΙΆΣ ΤΗΣ ΙΘΆΚΗΣ";

assert_eq!("ο οδυσσέας βασιλιάς της ιθάκης", odysseus_king_of_ithaca.to_lowercase());
```

```rust
let new_year = "农历新年";

assert_eq!(new_year, new_year.to_lowercase());
```

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

### Find pattern index

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns the byte index of the first occurrence of a pattern.

```rust
let s = "Löwe 老虎 Léopard Gepardi";

assert_eq!(s.find('L'), Some(0));
assert_eq!(s.find('é'), Some(14));
assert_eq!(s.find("pard"), Some(17));
```

```rust
let s = "Löwe 老虎 Léopard";

assert_eq!(s.find(char::is_whitespace), Some(5));
assert_eq!(s.find(char::is_lowercase), Some(1));
assert_eq!(s.find(|c: char| c.is_whitespace() || c.is_lowercase()), Some(1));
assert_eq!(s.find(|c: char| (c < 'o') && (c > 'a')), Some(4));
```

```rust
let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];

assert_eq!(s.find(x), None);
```

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

### pub fn strip_circumfix<P, S>(&self, prefix: P, suffix: S) -> Option<&str>

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Removes both a prefix and a suffix from the string if both match.

```APIDOC
## strip_circumfix

### Description
Removes the specified prefix and suffix from the string exactly once. Returns the middle substring wrapped in `Some` if both match, otherwise returns `None`.

### Parameters
- **prefix** (P) - Required - The pattern to match at the start.
- **suffix** (S) - Required - The pattern to match at the end.
```

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

### Splitting string slices with split_at

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Divides a string slice into two at a given byte offset. Panics if the index is not on a UTF-8 boundary or is out of bounds.

```rust
let s = "Per Martin-Löf";

let (first, last) = s.split_at(3);

assert_eq!("Per", first);
assert_eq!(" Martin-Löf", last);
```

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

### Parse and normalize language tag

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Parse a language tag and normalize its case, which involves heap allocation.

```rust
use oxilangtag::LanguageTag;

let language_tag = LanguageTag::parse_and_normalize("en-us").unwrap();
assert_eq!(language_tag.into_inner(), "en-US")
```

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

### replace

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Replaces all matches of a pattern with another string.

```APIDOC
## pub fn replace<P>(&self, from: P, to: &str) -> String

### Description
Replaces all matches of a pattern with another string. It creates a new String and copies the data from the string slice into it, replacing matches found.
```

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

### Strip Circumfix Method

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Experimental API to remove both a prefix and a suffix exactly once. Requires the strip_circumfix feature gate.

```rust
#![feature(strip_circumfix)]

assert_eq!("bar:hello:foo".strip_circumfix("bar:", ":foo"), Some("hello"));
assert_eq!("bar:foo".strip_circumfix("foo", "foo"), None);
assert_eq!("foo:bar;".strip_circumfix("foo:", ';'), Some("bar"));
```

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

### Strip Suffix Method

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Removes a suffix exactly once if it exists, returning an Option.

```rust
assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));
assert_eq!("bar:foo".strip_suffix("bar"), None);
assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));
```

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

### split_at

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Divides one string slice into two at a specified byte index. Panics if the index is not on a UTF-8 boundary or is out of bounds.

```APIDOC
## split_at(mid: usize) -> (&str, &str)

### Description
Divides one string slice into two at an index. The argument, `mid`, should be a byte offset from the start of the string and must be on the boundary of a UTF-8 code point.

### Parameters
- **mid** (usize) - Required - The byte offset at which to split the string.

### Response
- **Returns** ((&str, &str)) - A tuple containing the two resulting string slices.
```

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

### Trim Left Usage and Directionality

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Demonstrates the deprecated trim_left method and its behavior regarding text directionality.

```rust
let s = " Hello\tworld\t";

assert_eq!("Hello\tworld\t", s.trim_left());
```

```rust
let s = "  English";
assert!(Some('E') == s.trim_left().chars().next());

let s = "  עברית";
assert!(Some('ע') == s.trim_left().chars().next());
```

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

### Parse and access LanguageTag

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Basic usage of parsing a language tag and retrieving the inner string.

```rust
use oxilangtag::LanguageTag;

let language_tag = LanguageTag::parse("en-us").unwrap();
assert_eq!(language_tag.into_inner(), "en-us")
```

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

### trim(&self) -> &str

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=std%3A%3Avec

Returns a string slice with leading and trailing whitespace removed.

```APIDOC
## trim(&self)

### Description
Returns a string slice with leading and trailing whitespace removed. Whitespace is defined according to the Unicode Derived Core Property White_Space.
```

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

### Convert to byte slice

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Converts a string slice into a byte slice.

```rust
let bytes = "bors".as_bytes();
assert_eq!(b"bors", bytes);
```

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

### pub fn strip_suffix<P>(&self, suffix: P) -> Option<&str>

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a string slice with the suffix removed if it matches, otherwise returns None.

```APIDOC
## strip_suffix

### Description
Removes the specified suffix from the string exactly once if it exists. Returns the remaining substring wrapped in `Some`, or `None` if the suffix is not found.

### Parameters
- **suffix** (P) - Required - The pattern to match at the end of the string.
```

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

### Trim Suffix Method

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Experimental API that returns the string slice without the suffix if present, or the original string if not. Requires the trim_prefix_suffix feature gate.

```rust
#![feature(trim_prefix_suffix)]

// Suffix present - removes it
assert_eq!("bar:foo".trim_suffix(":foo"), "bar");
assert_eq!("foofoo".trim_suffix("foo"), "foo");

// Suffix absent - returns original string
assert_eq!("bar:foo".trim_suffix("bar"), "bar:foo");
```

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

### to_ascii_uppercase

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html

Returns a copy of the string where each ASCII character is mapped to its uppercase equivalent.

```APIDOC
## pub fn to_ascii_uppercase(&self) -> String

### Description
Returns a copy of this string where each character is mapped to its ASCII upper case equivalent. Non-ASCII letters are unchanged.

### Parameters
- **&self** - The string slice to convert.

### Response
- **String** - The ASCII-uppercased string.
```

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

### Convert word to titlecase

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Experimental API that converts a single word to titlecase by uppercasing the first cased letter and lowercasing the rest.

```rust
#![feature(titlecase)]
let s = "HELLO WORLD";

assert_eq!("Hello world", s.word_to_titlecase());
```

```rust
#![feature(titlecase)]
let the_night_before_christmas = "'twas";

assert_eq!("'Twas", the_night_before_christmas.word_to_titlecase());
```

```rust
#![feature(titlecase)]
let new_year = "农历新年";
```

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

### Split string into substrings

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Use split to create an iterator of substrings separated by a pattern. Contiguous separators result in empty strings.

```rust
let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

let v: Vec<&str> = "AABBCC".split("DD").collect();
assert_eq!(v, ["AABBCC"]);

let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);
```

```rust
let v: Vec<&str> = "2020-11-03 23:59".split(&['-', ' ', ':', '@'][..]).collect();
assert_eq!(v, ["2020", "11", "03", "23", "59"]);
```

```rust
let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "def", "ghi"]);
```

```rust
let x = "||||a||b|c".to_string();
let d: Vec<_> = x.split('|').collect();

assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
```

```rust
let x = "(///)".to_string();
let d: Vec<_> = x.split('/').collect();

assert_eq!(d, &["(", "", "", ")"]);
```

```rust
let d: Vec<_> = "010".split("0").collect();
assert_eq!(d, &["", "1", ""]);
```

```rust
let f: Vec<_> = "rust".split("").collect();
assert_eq!(f, &["", "r", "u", "s", "t", ""]);
```

```rust
let x = "    a  b c".to_string();
let d: Vec<_> = x.split(' ').collect();

assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
```

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

### replacen

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Replaces the first N matches of a pattern with another string.

```APIDOC
## pub fn replacen<P>(&self, pat: P, to: &str, count: usize) -> String

### Description
Replaces the first N matches of a pattern with another string. It creates a new String and performs the replacement at most count times.
```

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

### lines()

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns an iterator over the lines of a string, as string slices.

```APIDOC
## lines()

### Description
Returns an iterator over the lines of a string, as string slices. Lines are split at line endings that are either newlines (\n) or sequences of a carriage return followed by a line feed (\r\n).
```

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

### Uppercase string conversion

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns a new String with all characters converted to uppercase according to Unicode standards. Does not handle language-specific casing rules.

```rust
let s = "hello world";

assert_eq!("HELLO WORLD", s.to_uppercase());
```

```rust
let new_year = "农历新年";

assert_eq!(new_year, new_year.to_uppercase());
```

```rust
let s = "tschüß";

assert_eq!("TSCHÜSS", s.to_uppercase());
```

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

### Split string with splitn

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Splits a string into at most n substrings from the front.

```rust
let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect();
assert_eq!(v, ["Mary", "had", "a little lambda"]);

let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect();
assert_eq!(v, ["lion", "", "tigerXleopard"]);

let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect();
assert_eq!(v, ["abcXdef"]);

let v: Vec<&str> = "".splitn(1, 'X').collect();
assert_eq!(v, [""]);
```

```rust
let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "defXghi"]);
```

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

### Split string once

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Splits a string on the first occurrence of a delimiter.

```rust
assert_eq!("cfg".split_once('='), None);
assert_eq!("cfg=".split_once('='), Some(("cfg", "")));
assert_eq!("cfg=foo".split_once('='), Some(("cfg", "foo")));
assert_eq!("cfg=foo=bar".split_once('='), Some(("cfg", "foo=bar")));
```

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

### to_ascii_lowercase

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html

Returns a copy of the string where each ASCII character is mapped to its lowercase equivalent.

```APIDOC
## pub fn to_ascii_lowercase(&self) -> String

### Description
Returns a copy of this string where each character is mapped to its ASCII lower case equivalent. Non-ASCII letters are unchanged.

### Parameters
- **&self** - The string slice to convert.

### Response
- **String** - The ASCII-lowercased string.
```

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

### Escape default characters

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Escape characters using default representation.

```rust
for c in "❤\n!".escape_default() {
    print!("{c}");
}
println!();
```

```rust
println!("{}", "❤\n!".escape_default());
```

```rust
println!("\\u{{2764}}\\n!");
```

```rust
assert_eq!("❤\n!".escape_default().to_string(), "\\u{2764}\\n!");
```

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

### parse

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Parses this string slice into another type that implements the FromStr trait.

```APIDOC
## pub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err>

### Description
Parses this string slice into another type. This method can parse into any type that implements the `FromStr` trait. It may return an `Err` if parsing is not possible.
```

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

### Find ceiling character boundary

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Finds the smallest character boundary index greater than or equal to the provided index.

```rust
let s = "❤️🧡💛💚💙💜";
assert_eq!(s.len(), 26);
assert!(!s.is_char_boundary(13));

let closest = s.ceil_char_boundary(13);
assert_eq!(closest, 14);
assert_eq!(&s[..closest], "❤️🧡💛");
```

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

### Iterate extended language subtags

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Iterate over extended language subtags.

```rust
use oxilangtag::LanguageTag;

let language_tag = LanguageTag::parse("zh-cmn-Hans-CN").unwrap();
assert_eq!(
    language_tag.extended_language_subtags().collect::<Vec<_>>(),
    vec!["cmn"]
);
```

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

### LanguageTag::parse

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/index.html

Parses and validates a language tag string into a LanguageTag instance.

```APIDOC
## LanguageTag::parse(tag: &str) -> Result<LanguageTag, LanguageTagParseError>

### Description
Parses a string into a LanguageTag, validating it against RFC 5646 standards.

### Parameters
- **tag** (&str) - Required - The language tag string to parse.

### Returns
- **Result<LanguageTag, LanguageTagParseError>** - Returns a LanguageTag instance on success, or a LanguageTagParseError if validation fails.
```

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

### Check string suffix

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Determines if the string ends with a given pattern.

```rust
let bananas = "bananas";

assert!(bananas.ends_with("anas"));
assert!(!bananas.ends_with("nana"));
```

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

### LanguageTag::parse

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html

Parses a language tag string into a LanguageTag instance without heap allocation.

```APIDOC
## pub fn parse(tag: T) -> Result<Self, LanguageTagParseError>

### Description
Parses a language tag according to RFC 5646 and checks if the tag is well-formed. This operation keeps the tag parameter internally and does not allocate on the heap.

### Parameters
- **tag** (T) - Required - The language tag string to parse.
```

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

### Calculate string length

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns the length of the string in bytes, which may differ from the number of characters.

```rust
let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);
```

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

### Check if string is empty

Source: https://docs.rs/oxilangtag/0.1.6/oxilangtag/struct.LanguageTag.html?search=u32+-%3E+bool

Returns true if the string length is zero bytes.

```rust
let s = "";
assert!(s.is_empty());

let s = "not empty";
assert!(!s.is_empty());
```
Tokens:
Raw