UUID (Universally Unique Identifier)

Example Code

```rust
// Cargo.toml
// Add the uuid crate to your dependencies. 
// We'll use features for Version 4 (random), Version 7 (time-ordered), 
// and fast-rng for a good random number generator.
// 
// [dependencies]
// uuid = { version = "1.x", features = ["v4", "v7", "fast-rng"] }

use uuid::Uuid;
use std::time::Duration;
use std::thread::sleep;

fn main() {
    println!("-- UUID Generation and Parsing Examples ---");

    // 1. Generate a new Version 4 (random) UUID
    // This is the most common type for general-purpose unique identifiers.
    let uuid_v4 = Uuid::new_v4();
    println!("\nGenerated Version 4 UUID: {}", uuid_v4);
    println!("Version of V4 UUID: {:?}", uuid_v4.get_version());

    // 2. Parse a UUID from a string
    let uuid_string = "f8a4b6c2-d3e1-4a7b-8c9d-0e1f2a3b4c5d";
    match Uuid::parse_str(uuid_string) {
        Ok(parsed_uuid) => {
            println!("\nParsed UUID from string: {}", parsed_uuid);
            // Verify if it's the same string representation
            assert_eq!(parsed_uuid.to_string(), uuid_string);
            println!("Version of parsed UUID: {:?}", parsed_uuid.get_version());
        },
        Err(e) => {
            eprintln!("\nError parsing UUID '{}': {}", uuid_string, e);
        }
    }

    // 3. Generate a Nil UUID (an all-zero UUID)
    // Useful as a placeholder or default value where a UUID is expected but not yet assigned.
    let nil_uuid = Uuid::nil();
    println!("\nNil UUID: {}", nil_uuid);

    // 4. Convert a UUID to its URN (Uniform Resource Name) representation
    // e.g., "urn:uuid:f8a4b6c2-d3e1-4a7b-8c9d-0e1f2a3b4c5d"
    let new_v4_for_urn = Uuid::new_v4();
    println!("\nURN representation of a new V4 UUID: {}", new_v4_for_urn.urn());

    // 5. Demonstrate byte representation
    // UUIDs are 16 bytes (128 bits).
    let bytes = uuid_v4.as_bytes();
    println!("\nUUID as bytes (first 8 bytes): {:?}", &bytes[0..8]);
    let uuid_from_bytes = Uuid::from_slice(bytes).expect("Failed to create UUID from slice");
    println!("UUID recreated from bytes: {}", uuid_from_bytes);
    assert_eq!(uuid_v4, uuid_from_bytes, "UUIDs should match after byte conversion");

    // --- Version 7 UUID Demo (requires 'v7' feature enabled in Cargo.toml) ---
    // Version 7 UUIDs are time-ordered and random, good for database indexing.
    #[cfg(feature = "v7")]
    {
        println!("\n--- Version 7 UUID Demo ---");
        let uuid_v7_a = Uuid::new_v7();
        // Introduce a small delay to ensure subsequent V7 UUIDs have a different timestamp
        sleep(Duration::from_millis(10)); 
        let uuid_v7_b = Uuid::new_v7();
        sleep(Duration::from_millis(10));
        let uuid_v7_c = Uuid::new_v7();

        println!("Generated Version 7 UUID A: {}", uuid_v7_a);
        println!("Generated Version 7 UUID B: {}", uuid_v7_b);
        println!("Generated Version 7 UUID C: {}", uuid_v7_c);

        println!("Version of V7 UUID: {:?}", uuid_v7_a.get_version());

        // V7 UUIDs are designed to be chronologically sortable based on their embedded timestamp.
        // Therefore, `Uuid`'s Ord implementation will sort them by time (approximately).
        if uuid_v7_a < uuid_v7_b && uuid_v7_b < uuid_v7_c {
            println!("V7 UUIDs are chronologically ordered (as expected).");
        } else {
            println!("V7 UUIDs are NOT strictly chronologically ordered (this can happen with extremely fast generation, where random bits might cause minor deviations even with distinct timestamps). However, their primary ordering by timestamp is maintained.");
        }
    }
    #[cfg(not(feature = "v7"))]
    {
        println!("\n--- Version 7 UUID Demo ---");
        println!("To enable V7 UUID generation, add `v7` to the uuid crate features in Cargo.toml:");
        println!("uuid = {{ version = \"1.x\", features = [\"v4\", \"v7\", \"fast-rng\"] }}");
    }
}
```