### Serializing and Deserializing with Serde

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

Enable the serde feature to serialize and deserialize language tags, useful for web services and configuration files.

```rust
// Cargo.toml: langtag = { version = "1.1", features = ["serde"] }

use langtag::LangTagBuf;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct LocalizedContent {
    language: LangTagBuf,
    content: String,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let content = LocalizedContent {
        language: LangTagBuf::new("en-US".to_string())?,
        content: "Hello, World!".to_string(),
    };

    // Serialize to JSON
    let json = serde_json::to_string(&content)?;
    println!("{}", json);
    // Output: {"language":"en-US","content":"Hello, World!"}

    // Deserialize from JSON
    let parsed: LocalizedContent = serde_json::from_str(&json)?;
    assert_eq!(parsed.language.language().unwrap().primary(), "en");

    Ok(())
}
```

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

### Accessing Extension Subtags in Rust

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

Illustrates how to work with extension subtags, which provide extra language-related information identified by a singleton character. Supports iteration and specific retrieval.

```rust
use langtag::LangTag;
use std::convert::TryInto;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Tag with multiple extensions
    let tag = LangTag::new("fr-a-ext1-ext2-b-ext3-ext4-c-ext5-ext6")?;

    // Get all extensions as a string
    assert_eq!(tag.extensions(), "a-ext1-ext2-b-ext3-ext4-c-ext5-ext6");

    // Iterate over individual extensions
    let mut ext_iter = tag.extensions().iter();
    assert_eq!(ext_iter.next().unwrap(), "a-ext1-ext2");
    assert_eq!(ext_iter.next().unwrap(), "b-ext3-ext4");
    assert_eq!(ext_iter.next().unwrap(), "c-ext5-ext6");

    // Access a specific extension by singleton
    let ext_a = tag.extensions().get('a'.try_into()?);
    assert_eq!(ext_a.unwrap(), "a-ext1-ext2");

    // Iterate over subtags of a specific extension
    let mut subtag_iter = tag.extensions().iter_extension('a'.try_into()?);
    assert_eq!(subtag_iter.next().unwrap(), "ext1");
    assert_eq!(subtag_iter.next().unwrap(), "ext2");
    assert!(subtag_iter.next().is_none());

    Ok(())
}
```

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

### Accessing Private Use Subtags in Rust

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

Demonstrates how to handle private use subtags (prefixed with 'x-') for custom language variations. Includes checking for private use tags and iterating over subtags.

```rust
use langtag::LangTag;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Tag with private use subtags
    let tag = LangTag::new("en-US-x-custom-variant-app1")?;

    // Access the full private use section
    let private_use = tag.private_use().unwrap();
    assert_eq!(private_use.as_str(), "x-custom-variant-app1");

    // Iterate over private use subtags
    let mut iter = tag.private_use_subtags();
    assert_eq!(iter.next().unwrap(), "custom");
    assert_eq!(iter.next().unwrap(), "variant");
    assert_eq!(iter.next().unwrap(), "app1");
    assert!(iter.next().is_none());

    // Private use only tag
    let private_only = LangTag::new("x-private-tag")?;
    assert!(private_only.is_private_use());

    Ok(())
}
```

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

### Create Language Tags at Compile Time with langtag! Macro

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

The `langtag!` macro validates and creates language tags during compilation, preventing runtime errors from invalid tags. Use it for compile-time constants.

```rust
use langtag::langtag;

// These are validated at compile time
const ENGLISH: &langtag::LangTag = langtag!("en");
const FRENCH_FRANCE: &langtag::LangTag = langtag!("fr-FR");
const CHINESE_SIMPLIFIED: &langtag::LangTag = langtag!("zh-Hans-CN");

fn main() {
    println!("English tag: {}", ENGLISH);
    println!("French tag: {}", FRENCH_FRANCE);
    println!("Chinese tag: {}", CHINESE_SIMPLIFIED);

    // Invalid tags would fail at compile time:
    // const INVALID: &langtag::LangTag = langtag!("not-a-valid-tag-12345");
}
```

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

### Accessing Region Subtags in Rust

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

Demonstrates how to retrieve region subtags (e.g., country codes) from language tags. Handles cases with and without a region subtag.

```rust
use langtag::NormalLangTag;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // English variants by region
    let en_us = NormalLangTag::new("en-US")?;
    let en_gb = NormalLangTag::new("en-GB")?;
    let en_au = NormalLangTag::new("en-AU")?;

    assert_eq!(en_us.region().unwrap(), "US");
    assert_eq!(en_gb.region().unwrap(), "GB");
    assert_eq!(en_au.region().unwrap(), "AU");

    // Spanish variants
    let es_es = NormalLangTag::new("es-ES")?;
    let es_mx = NormalLangTag::new("es-MX")?;
    let es_419 = NormalLangTag::new("es-419")?;

    assert_eq!(es_es.region().unwrap(), "ES");
    assert_eq!(es_mx.region().unwrap(), "MX");
    assert_eq!(es_419.region().unwrap(), "419");

    // Tag without region
    let french = NormalLangTag::new("fr")?;
    assert!(french.region().is_none());

    Ok(())
}
```

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

### Managing Owned Language Tags with LangTagBuf

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

Use LangTagBuf for scenarios requiring owned memory, such as dynamically generated tags.

```rust
use langtag::LangTagBuf;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create an owned language tag
    let owned = LangTagBuf::new("en-US".to_string())?;

    // Can be used like the borrowed version
    assert_eq!(owned.language().unwrap().primary(), "en");
    assert_eq!(owned.region().unwrap(), "US");

    // Useful when building tags dynamically
    fn create_localized_tag(lang: &str, region: &str) -> Result<LangTagBuf, Box<dyn std::error::Error>> {
        let tag_string = format!("{}-{}", lang, region);
        Ok(LangTagBuf::new(tag_string)?)
    }

    let french_canada = create_localized_tag("fr", "CA")?;
    assert_eq!(french_canada.language().unwrap().primary(), "fr");
    assert_eq!(french_canada.region().unwrap(), "CA");

    Ok(())
}
```

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

### Accessing Variant Subtags in Rust

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

Shows how to access and iterate over variant subtags, which specify additional language variations. Supports single and multiple variants.

```rust
use langtag::NormalLangTag;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // German with traditional orthography variant
    let tag = NormalLangTag::new("de-CH-1996")?;

    let variants = tag.variants();
    assert_eq!(variants.as_str(), "1996");

    // Iterate over variants
    for variant in variants.iter() {
        println!("Variant: {}", variant);
    }

    // Access first and last variants
    assert_eq!(variants.first().unwrap(), "1996");
    assert_eq!(variants.last().unwrap(), "1996");

    // Multiple variants
    let complex = NormalLangTag::new("sl-rozaj-biske")?;
    let mut iter = complex.variants().iter();
    assert_eq!(iter.next().unwrap(), "rozaj");
    assert_eq!(iter.next().unwrap(), "biske");

    Ok(())
}
```

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

### Handling Grandfathered Tags

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

Access details of legacy grandfathered tags and iterate through the predefined list of supported grandfathered tags.

```rust
use langtag::{LangTag, GrandfatheredLangTag, GRANDFATHERED};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Parse a grandfathered tag
    let klingon = LangTag::new("i-klingon")?;
    assert!(klingon.is_grandfathered());

    // Access grandfathered tag details
    let gf = klingon.as_grandfathered().unwrap();
    println!("Grandfathered tag: {}", gf);

    // Regular grandfathered tags have language info
    let zh_hakka = LangTag::new("zh-hakka")?;
    if let Some(gf) = zh_hakka.as_grandfathered() {
        if let Some(lang) = gf.language() {
            assert_eq!(lang.primary(), "zh");
        }
    }

    // List all grandfathered tags
    println!("All grandfathered tags:");
    for tag in &GRANDFATHERED {
        println!("  {}", tag);
    }

    Ok(())
}
```

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

### Access Script Subtags

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

Retrieve script subtags (e.g., Latin, Cyrillic, Han) from a language tag. The `script()` method returns an `Option<&str>` containing the script subtag if present.

```rust
use langtag::NormalLangTag;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Chinese written in Simplified script
    let simplified = NormalLangTag::new("zh-Hans")?;
    assert_eq!(simplified.script().unwrap(), "Hans");

    // Chinese written in Traditional script
    let traditional = NormalLangTag::new("zh-Hant")?;
    assert_eq!(traditional.script().unwrap(), "Hant");

    // Serbian in Latin script
    let serbian_latin = NormalLangTag::new("sr-Latn")?;
    assert_eq!(serbian_latin.script().unwrap(), "Latn");

    // Serbian in Cyrillic script
    let serbian_cyrillic = NormalLangTag::new("sr-Cyrl")?;
    assert_eq!(serbian_cyrillic.script().unwrap(), "Cyrl");

    // Tag without script returns None
    let english = NormalLangTag::new("en-US")?;
    assert!(english.script().is_none());

    Ok(())
}
```

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

### Parse and Validate Language Tag

Source: https://github.com/timothee-haudebourg/langtag/blob/main/README.md

Use `LangTag::new` to parse a language tag from a string slice. The comparison is case-insensitive. This function borrows the input string.

```rust
use langtag::LangTag;

fn main() -> Result<(), langtag::InvalidLangTag<&'static str>> {
  let tag = LangTag::new("fr-FR")?;
  assert_eq!(tag.language().unwrap().primary(), "fr");
  assert!(tag == "Fr-fr"); // comparison is case-insensitive.
  Ok(())
}
```

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

### Detecting Language Tag Kinds

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

Identify if a language tag is normal, private use, or grandfathered using the Kind enum and TypedLangTag for pattern matching.

```rust
use langtag::{LangTag, Kind, TypedLangTag};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Normal language tag
    let normal = LangTag::new("en-US")?;
    assert!(normal.is_normal());
    assert!(!normal.is_private_use());
    assert!(!normal.is_grandfathered());
    assert_eq!(normal.kind(), Kind::Normal);

    // Private use tag
    let private = LangTag::new("x-custom")?;
    assert!(private.is_private_use());
    assert_eq!(private.kind(), Kind::PrivateUse);

    // Grandfathered tag
    let grandfathered = LangTag::new("i-klingon")?;
    assert!(grandfathered.is_grandfathered());
    assert_eq!(grandfathered.kind(), Kind::Grandfathered);

    // Use TypedLangTag for pattern matching
    match normal.as_typed() {
        TypedLangTag::Normal(n) => {
            println!("Normal tag with language: {}", n.language());
        }
        TypedLangTag::PrivateUse(p) => {
            println!("Private use tag: {}", p);
        }
        TypedLangTag::Grandfathered(g) => {
            println!("Grandfathered tag: {}", g);
        }
    }

    Ok(())
}
```

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

### Access Language Subtags

Source: https://context7.com/timothee-haudebourg/langtag/llms.txt

Extract primary and extended language subtags from a parsed language tag. The `language()` method returns a `Language` struct, which can provide the full language subtag string, the primary subtag, and any extended subtags.

```rust
use langtag::{LangTag, NormalLangTag};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Parse a tag with extended language subtags
    let tag = NormalLangTag::new("fr-abc-def-ghi-FR")?;

    // Get the complete language subtags (primary + extended)
    let language = tag.language();
    assert_eq!(language.as_str(), "fr-abc-def-ghi");

    // Get just the primary language
    assert_eq!(language.primary(), "fr");

    // Get the extended language subtags
    if let Some(ext) = language.extension() {
        assert_eq!(ext.as_str(), "abc-def-ghi");

        // Iterate over individual extended language subtags
        for subtag in language.extension_subtags() {
            println!("Extended subtag: {}", subtag);
        }
    }

    Ok(())
}
```

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