update project structure

src/basic-types/char-bool-unit.md

@@ -0,0 +1,90 @@
+# Char, Bool and Unit
+
+### Char
+🌟
+```rust, editable
+
+// make it work
+use std::mem::size_of_val;
+fn main() {
+    let c1 = 'a';
+    assert_eq!(size_of_val(&c1),1); 
+
+    let c2 = '中';
+    assert_eq!(size_of_val(&c2),3); 
+} 
+```
+
+🌟
+```rust, editable
+
+// make it work
+fn main() {
+    let c1 = "中";
+    print_char(c1);
+} 
+
+fn print_char(c : char) {
+    println!("{}", c);
+}
+```
+
+### Bool
+🌟
+```rust, editable
+
+// make the println! work
+fn main() {
+    let _f: bool = false;
+
+    let t = true;
+    if !t {
+        println!("hello, world");
+    }
+} 
+```
+
+🌟
+```rust, editable
+
+// make it work
+fn main() {
+    let f = true;
+    let t = true && false;
+    assert_eq!(t, f);
+}
+```
+
+
+### Unit type
+🌟🌟
+```rust,editable
+
+// make it work, don't modify `implicitly_ret_unit` !
+fn main() {
+    let _v: () = ();
+
+    let v = (2, 3);
+    assert_eq!(v, implicitly_ret_unit())
+}
+
+fn implicitly_ret_unit() {
+    println!("I will returen a ()")
+}
+
+// don't use this one
+fn explicitly_ret_unit() -> () {
+    println!("I will returen a ()")
+}
+```
+
+🌟🌟 what's the size of the unit type?
+```rust,editable
+
+// modify `4` in assert to make it work
+use std::mem::size_of_val;
+fn main() {
+    let unit: () = ();
+    assert!(size_of_val(&unit) == 4);
+}
+```

src/basic-types/functions.md

@@ -0,0 +1,43 @@
+# Functions
+🌟🌟🌟
+```rust,editable
+
+fn main() {
+    // don't modify the following two lines!
+    let (x, y) = (1, 2);
+    let s = sum(1, 2);
+
+    assert_eq!(s, 3);
+}
+
+fn sum(x, y: i32) {
+    x + y;
+}
+```
+
+
+🌟🌟
+```rust,editable
+fn main() {
+   print();
+}
+
+// replace i32 with another type
+fn print() -> i32 {
+   println!("hello,world");
+}
+```
+
+
+🌟🌟
+
+```rust,editable
+fn main() {
+    never_return();
+}
+
+fn never_return() -> ! {
+    // implement this function, don't modify fn signatures
+    
+}
+```

src/basic-types/intro.md

@@ -0,0 +1,5 @@
+# Basic Types
+Learning resources: 
+- English: [Rust Book 3.2 and 3.3](https://doc.rust-lang.org/book/ch03-02-data-types.html)
+- 简体中文: [Rust语言圣经 - 基本类型](https://course.rs/basic/base-type/index.html)
+

src/basic-types/numbers.md

@@ -0,0 +1,165 @@
+# Numbers
+
+### Integer
+
+🌟 
+
+> Tips: If we don't explicitly give one type to a varible, then the compiler will infer one for us
+
+```rust,editable
+
+// remove something to make it work
+fn main() {
+    let x: i32 = 5;
+    let mut y: u32 = 5;
+
+    y = x;
+    
+    let z = 10; // type of z ? 
+}
+```
+
+🌟
+```rust,editable
+
+//  fill the blank
+fn main() {
+    let v: u16 = 38_u8 as __;
+}
+```
+
+🌟🌟🌟  
+
+> Tips: If we don't explicitly give one type to a varible, then the compiler will infer one for us
+
+```rust,editable
+
+// modify `assert_eq!` to make it work
+fn main() {
+    let x = 5;
+    assert_eq!("u32".to_string(), type_of(&x));
+}
+
+// get the type of given variable, return a string representation of the type  , e.g "i8", "u8", "i32", "u32"
+fn type_of<T>(_: &T) -> String {
+    format!("{}", std::any::type_name::<T>())
+}
+```
+
+🌟🌟 
+```rust,editable
+
+// fill the blanks to make it work
+fn main() {
+    assert_eq!(i8::MAX, __); 
+    assert_eq!(u8::MAX, __); 
+}
+```
+
+🌟🌟 
+```rust,editable
+
+// fix errors and panics to make it work
+fn main() {
+   let v1 = 251_u8 + 8;
+   let v2 = i8::checked_add(251, 8).unwrap();
+   println!("{},{}",v1,v2);
+}
+```
+
+🌟🌟🌟 
+```rust,editable
+
+// modify `assert!` to make it work
+fn main() {
+    let v = 1_024 + 0xff + 0o77 + 0b1111_1111;
+    assert!(v == 1579);
+}
+```
+
+
+### Floating-Point
+🌟
+
+```rust,editable
+
+//  replace ? with your answer
+fn main() {
+    let x = 1_000.000_1; // ?
+    let y: f32 = 0.12; // f32
+    let z = 0.01_f64; // f64
+}
+```
+🌟🌟🌟 use two ways to make it work
+
+> Tips: 1. abs 2. f32
+
+```rust,editable
+
+fn main() {
+    assert!(0.1+0.2==0.3);
+}
+```
+
+### Range
+🌟🌟 two targets: 1. modify `assert!` to make it work 2. make `println!` output: 97 - 122
+
+> Tips: use `as u8` to convert a char to u8
+```rust,editable
+fn main() {
+    let mut sum = 0;
+    for i in -3..2 {
+        sum += i
+    }
+
+    assert!(sum == -3);
+
+    for c in 'a'..='Z' {
+        println!("{}",c);
+    }
+}
+```
+
+🌟🌟 
+```rust,editable
+
+// fill the blanks
+use std::ops::{Range, RangeInclusive};
+fn main() {
+    assert_eq!((1..__), Range{ start: 1, end: 5 });
+    assert_eq!((1..__), RangeInclusive::new(1, 5));
+}
+```
+
+### Computations
+
+🌟 
+```rust,editable
+
+// fill the blanks
+fn main() {
+    // Integer addition
+    assert!(1u32 + 2 == __);
+
+    // Integer subtraction
+    assert!(1i32 - 2 == __);
+    assert!(1u8 - 2 == -1); // change u8 to another type to make it work
+    
+    assert!(3 * 50 == __);
+
+    assert!(9.6 / 3.2 == 3.0); // error ! make it work
+
+    assert!(24 % 5 == __);
+    // Short-circuiting boolean logic
+    assert!(true && false == __);
+    assert!(true || false == __);
+    assert!(!true == __);
+
+    // Bitwise operations
+    println!("0011 AND 0101 is {:04b}", 0b0011u32 & 0b0101);
+    println!("0011 OR 0101 is {:04b}", 0b0011u32 | 0b0101);
+    println!("0011 XOR 0101 is {:04b}", 0b0011u32 ^ 0b0101);
+    println!("1 << 5 is {}", 1u32 << 5);
+    println!("0x80 >> 2 is 0x{:x}", 0x80u32 >> 2);
+}
+```

src/basic-types/statements-expressions.md

@@ -0,0 +1,59 @@
+# Statements and Expressions
+
+### Examples
+```rust,editable
+fn main() {
+    let x = 5u32;
+
+    let y = {
+        let x_squared = x * x;
+        let x_cube = x_squared * x;
+
+        // This expression will be assigned to `y`
+        x_cube + x_squared + x
+    };
+
+    let z = {
+        // The semicolon suppresses this expression and `()` is assigned to `z`
+        2 * x;
+    };
+
+    println!("x is {:?}", x);
+    println!("y is {:?}", y);
+    println!("z is {:?}", z);
+}
+```
+
+### Exercises
+🌟🌟
+```rust,editable
+// make it work with two ways: both modify the inner {}
+fn main() {
+   let v = {
+       let mut x = 1;
+       x += 2
+   };
+
+   assert_eq!(v, 3);
+}
+```
+
+🌟
+```rust,editable
+
+fn main() {
+   let v = (let x = 3);
+
+   assert!(v == 3);
+}
+```
+
+🌟
+```rust,editable
+
+fn main() {}
+
+fn sum(x: i32, y: i32) -> i32 {
+    x + y;
+}
+```