fn main() {
    let s = "hello";
    println!("'hello' bytes:  {}", s.len());         // 5
    println!("'hello' chars:  {}", s.chars().count()); // 5

    let s2 = "héllo";  // é is U+00E9, encoded as 2 bytes in UTF-8
    println!("'héllo' bytes:  {}", s2.len());          // 6
    println!("'héllo' chars:  {}", s2.chars().count()); // 5

    let s3 = "日本語";  // each kanji is 3 bytes
    println!("'日本語' bytes:  {}", s3.len());           // 9
    println!("'日本語' chars:  {}", s3.chars().count()); // 3
}

fn main() {
    let s = "héllo";

    // Bytes — raw UTF-8 encoded bytes
    print!("bytes: ");
    for b in s.bytes() { print!("{} ", b); }
    println!();

    // Chars — Unicode scalar values
    print!("chars: ");
    for c in s.chars() { print!("{:?} ", c); }
    println!();

    // Count each way
    println!("byte count:  {}", s.len());
    println!("char count:  {}", s.chars().count());
}

fn main() {
    // Pre-allocate for 50 bytes
    let mut s = String::with_capacity(50);
    s.push_str("Hello");
    s.push(',');
    s.push(' ');
    s.push_str("world!");
    println!("{}", s);
    println!("len: {}, capacity: {}", s.len(), s.capacity());

    // Collect an iterator of &str into a String
    let words = vec!["Rust", "is", "fast"];
    let sentence: String = words.join(" ");
    println!("{}", sentence);

    // Collect chars after filtering
    let only_letters: String = "h3ll0 w0rld"
        .chars()
        .filter(|c| c.is_alphabetic())
        .collect();
    println!("{}", only_letters);
}

fn main() {
    let csv = "one,two,three,four";

    // split by a char delimiter
    let parts: Vec<&str> = csv.split(',').collect();
    println!("{:?}", parts);

    // split_whitespace — handles multiple spaces, tabs, newlines
    let sentence = "  hello   world  ";
    let words: Vec<&str> = sentence.split_whitespace().collect();
    println!("{:?}", words);

    // lines — split on 
 or 

    let multiline = "line one
line two
line three";
    for line in multiline.lines() {
        println!("  > {}", line);
    }

    // splitn — split into at most n pieces
    let path = "usr/local/bin/cargo";
    let parts2: Vec<&str> = path.splitn(3, '/').collect();
    println!("{:?}", parts2);
}

fn main() {
    // Join a slice of &str
    let fruits = ["apple", "banana", "cherry"];
    println!("{}", fruits.join(", "));
    println!("{}", fruits.join(" | "));

    // Join after mapping
    let numbers = [1, 2, 3, 4, 5];
    let s: String = numbers.iter()
        .map(|n| n.to_string())
        .collect::<Vec<_>>()
        .join(" + ");
    println!("{} = 15", s);
}

fn main() {
    let text = "the quick brown fox jumps over the lazy dog";

    // contains — boolean check
    println!("contains 'fox': {}", text.contains("fox"));

    // find — first byte index of a pattern (returns Option<usize>)
    match text.find("fox") {
        Some(i) => println!("'fox' starts at byte {}", i),
        None    => println!("not found"),
    }

    // rfind — last occurrence
    println!("last 'the' at byte: {:?}", text.rfind("the"));

    // matches + count
    let count = text.matches('o').count();
    println!("letter 'o' appears {} times", count);

    // starts_with / ends_with
    println!("starts with 'the': {}", text.starts_with("the"));
    println!("ends with 'dog':   {}", text.ends_with("dog"));
}

fn main() {
    let s = "I love Rust! Rust is great!";

    // replace — replaces all occurrences
    println!("{}", s.replace("Rust", "Python"));

    // replacen — replaces at most n occurrences
    println!("{}", s.replacen("Rust", "Go", 1));

    // trim — remove leading and trailing whitespace
    let padded = "  hello  ";
    println!("'{}'", padded.trim());
    println!("'{}'", padded.trim_start());
    println!("'{}'", padded.trim_end());

    // to_uppercase / to_lowercase
    let mixed = "Hello World";
    println!("{}", mixed.to_uppercase());
    println!("{}", mixed.to_lowercase());

    // eq_ignore_ascii_case — case-insensitive ASCII comparison
    println!("case-insensitive eq: {}", "Rust".eq_ignore_ascii_case("rust"));
}

fn main() {
    // Valid UTF-8 bytes
    let valid_bytes = vec![104u8, 101, 108, 108, 111]; // "hello"
    match String::from_utf8(valid_bytes) {
        Ok(s)  => println!("valid: {}", s),
        Err(e) => println!("error: {}", e),
    }

    // Invalid UTF-8 bytes — from_utf8 returns Err
    let invalid_bytes = vec![104u8, 255, 108, 108, 111];
    match String::from_utf8(invalid_bytes.clone()) {
        Ok(s)  => println!("valid: {}", s),
        Err(e) => println!("from_utf8 error: {}", e),
    }

    // from_utf8_lossy — replaces invalid bytes with the replacement character U+FFFD
    let lossy = String::from_utf8_lossy(&invalid_bytes);
    println!("lossy: {}", lossy); // h�llo
}