use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

I'm learning rust, why do we instantiate a variable with `String::new();` only to append something to it afterwards, is it functional or for legibility, reply concisely.

In Rust, `String::new()` is the common “start with an empty owned buffer” pattern. read_line(&mut guess) needs a String you can mutate (grow) as input arrives, so you create an empty one first.

It’s functional (you need an owned, mutable String to pass to read_line), and also idiomatic/legible because it makes the intent—“this will hold the user’s input”—clear.

fn main() {
    for n in 1..u32::MAX {
        let c: char = match char::from_u32(n) {
            Some(j) => j,
            None => {
                // println!("Can't get number for char value {n}");
                continue;
            }
        };
        // print!(" {n} {c}");
        print!("{c}");
    }
}

fn main() {
    for n in 1.. {
        let c: char = char::from_u32(n).expect(&format!("Can't get number for char value {n}"));
        print!("{c}");
    }
}

thread 'main' (177732) panicked at src/main.rs:6:17:
Can't get number for char value 55296

fn print(char: u32) {
    let char: char = char::from_u32(char).expect(&format!("Can't get number for char value {char}"));
    print!("{char}");
}

fn main() {
    for n in 0..0xD7FF {
        print(n);
    }
    for n in 0xE000..0x10FFFF {
        print(n);
    }

}

use std::io;

fn celsius_to_fahrenheit(celsius: f64) -> f64 {
    (celsius * 1.8) + 32.0
}

fn fahrenheit_to_celsius(fahrenheit: f64) -> f64 {
    (fahrenheit - 32.0) / 1.8
}

fn main() {
    println!("Input temperature in the format: <number><unit> e.g: 22C or 30.4F");

    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");

    let (temp, unit) = input.trim().split_at(input.len() - 2);
    let unit = unit.to_uppercase();

    let temp: f64 = temp.parse().expect(&format!("Couldn't parse number from: {temp}"));
    println!("temp: {temp}, unit: {unit}");

    let result_unit: char;
    let result: f64 = match unit.as_str() {
        "F" => {
            result_unit = 'C';
            fahrenheit_to_celsius(temp)
        }
        "C" => {
            result_unit = 'F';
            celsius_to_fahrenheit(temp)
        }
        _ => panic!("Unknown unit {unit}"),
    };
    println!("{temp}°{unit} = {result}°{result_unit}")

}

I'm learning rust, coming from python and some C programming, I've read the first 3 chapters of the rust book, which covers:
...

Your code is solid Rust and it mostly avoids common beginner pitfalls from the book—but there are a few correctness/robustness issues and a couple “Rust-idiomatic” improvements.

1. split_at(input.len() - 2) is brittle and can be incorrect because you compute the index from the untrimmed string length (so whitespace/newline can break the split).
2. Slicing by byte index is unsafe for general cases; indexing must land on a valid char boundary (your current approach assumes a fixed layout).
3. Parsing by “last 2 characters” assumes the unit is always exactly one character and located at a fixed position; inputs like 22 C, missing unit, etc., will fail or behave unexpectedly.
4. Your match works, but using result_unit + mutation in match arms is less idiomatic; returning both values directly is cleaner.
5. Using panic!/expect for invalid user input is fine for an exercise, but for real programs you’d prefer returning Result and printing a friendly error.

If you want a robust fix: parse from let trimmed = input.trim(); and take the last non-whitespace character as the unit, then parse the remaining prefix as the number.

fn main() {
    const iterations: usize = 20;

    let mut prev: usize = 0;
    let mut cur: usize = 1;

    for _ in 0..iterations - 1 {
        let temp: usize = cur;
        cur = cur + prev;
        println!("{prev} + {temp} = {cur}");
        prev = temp;
    }
    println!("{iterations}'th fibonacci number is: {cur}");
}

fn main() {
    const ITERATIONS: usize = 20;

    let mut prev: usize = 0;
    let mut cur: usize = 1;

    for _ in 0..ITERATIONS - 1 {
        let temp: usize = cur;
        cur = cur + prev;
        println!("{prev} + {temp} = {cur}");
        prev = temp;
    }
    println!("{ITERATIONS}'th fibonacci number is: {cur}");
}

$ cargo run
0 + 1 = 1
1 + 1 = 2
1 + 2 = 3
2 + 3 = 5
3 + 5 = 8
5 + 8 = 13
8 + 13 = 21
13 + 21 = 34
21 + 34 = 55
34 + 55 = 89
55 + 89 = 144
89 + 144 = 233
144 + 233 = 377
233 + 377 = 610
377 + 610 = 987
610 + 987 = 1597
987 + 1597 = 2584
1597 + 2584 = 4181
2584 + 4181 = 6765
20'th fibonacci number is: 6765

89 1779979416004714189 + 2880067194370816120 = 4660046610375530309
90 2880067194370816120 + 4660046610375530309 = 7540113804746346429
91 4660046610375530309 + 7540113804746346429 = 12200160415121876738

thread 'main' (266042) panicked at src/main.rs:9:15:
attempt to add with overflow
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

>>> 7540113804746346429 + 12200160415121876738
19740274219868223167

const DAYS: [&str; 12] = ["first", "second", "third", "fourth", "fifth", "sixth",
                          "seventh","eighth", "ninth", "tenth", "eleventh", "twelfth"];

const THINGS: [&str; 12] = [
    "A partridge in a pear tree",
    "Two turtle doves and",
    "Three french hens",
    "Four calling birds",
    "Five golden rings",
    "Six geese a-laying",
    "Seven swans a-swimming",
    "Eight maids a-milking",
    "Nine ladies dancing",
    "Ten lords a-leaping",
    "Eleven pipers piping",
    "Twelve drummers drumming"
];

fn main() {
    for i in 0..12 {
        println!("On the {} day of Christmas, my true love sent to me", DAYS[i]);
        for j in (0..i + 1).rev() {
            println!("{}", THINGS[j]);
        }
        println!();
    }
}

On the first day of Christmas, my true love sent to me
A partridge in a pear tree

On the second day of Christmas, my true love sent to me
Two turtle doves and
A partridge in a pear tree

On the third day of Christmas, my true love sent to me
Three french hens
Two turtle doves and
A partridge in a pear tree

On the fourth day of Christmas, my true love sent to me
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree

On the fifth day of Christmas, my true love sent to me
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree

On the sixth day of Christmas, my true love sent to me
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree

On the seventh day of Christmas, my true love sent to me
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree

On the eighth day of Christmas, my true love sent to me
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree

On the ninth day of Christmas, my true love sent to me
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree

On the tenth day of Christmas, my true love sent to me
Ten lords a-leaping
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree

On the eleventh day of Christmas, my true love sent to me
Eleven pipers piping
Ten lords a-leaping
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree

On the twelfth day of Christmas, my true love sent to me
Twelve drummers drumming
Eleven pipers piping
Ten lords a-leaping
Nine ladies dancing
Eight maids a-milking
Seven swans a-swimming
Six geese a-laying
Five golden rings
Four calling birds
Three french hens
Two turtle doves and
A partridge in a pear tree

    let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    let r3 = &mut s; // BIG PROBLEM

    println!("{r1}, {r2}, and {r3}");

    let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    println!("{r1} and {r2}");
    // Variables r1 and r2 will not be used after this point.

    let r3 = &mut s; // no problem
    println!("{r3}");

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mut s = String::from("hello world");

    let word = first_word(&s);

    s.clear(); // error!

    println!("the first word is: {word}");
}

    let user2 = User {
        email: String::from("another@example.com"),
        ..user1
    };

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

struct Color(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
}

SELECT id, nickname, comment, page_url, visitor_url, (CASE WHEN show_contact THEN contact ELSE NULL END) as contact_info, created_at
FROM comment WHERE approved AND public AND page_url = '/misc/Learning rust' ORDER BY created_at DESC;