fix: typo

Author: novalagung

docs/basic/basic-memory-management.md

@@ -62,7 +62,7 @@ Nilai variabel tersebut adalah `25`, yang jika dikonversi ke bentuk binary adala
 
 Hasilnya adalah angka biner berikut:
 
-```rust
+```text
 00000000000000000000000000011001
 ```
 

docs/basic/borrowing.md

@@ -167,7 +167,7 @@ fn change_value(txt: &mut String) {
 
 Pada kode di atas, ada satu buah mutable string bernama `fact_one`. String tersebut dipinjam menggunakan `&mut` (yang berarti adalah mutable borrow) sebagai argumen pemanggilan fungsi `change_value` yang isinya kurang lebih adalah perubahan isi data string pada variabel pointer.
 
-Kemudian, ada operasi peminjaman lagi (yang juga mutable borrow) dari variabel `fact_one` ke `fact_one`.
+Kemudian, ada operasi peminjaman lagi (yang juga mutable borrow) dari variabel `fact_one` ke `fact_two`.
 
 Ketika program di-run, hasilnya sukses. Kok bisa? padahal jelas di aturan tertulis bahwa dalam waktu yang sama tidak boleh ada lebih dari satu mutable borrow.
 

docs/basic/closures.md

@@ -259,20 +259,14 @@ fn do_something() -> impl Fn() {
 }
 ```
 
-Tipe `impl Fn()` adalah ekuvalen dengan closure `|| { }`.
+Tipe `impl Fn()` adalah ekuvalen dengan closure `|| { }`. Contoh penerapannya pada `main`:
 
 ```rust
 fn main() {
     let my_closure = do_something();
     println!("hello (from main)");
     my_closure();
 }
-
-fn main() {
-    let my_closure = do_something_v2();
-    let message = my_closure(123, "hello rust".to_owned());
-    println!("{message} (from main)");
-}
 ```
 
 ![Closure](img/closures-4.png)
@@ -283,7 +277,7 @@ Sedangkan fungsi `do_something` sendiri juga menampilkan pesan string lainnya, y
 
 ### ◉ Praktik ke-2
 
-Pada contoh di atas, closure yang dikembalikan fungsi memiliki skema sangat sederhana, tanpa parameter dan argument. Mari coba praktik dengan contoh yang lebih kompleks.
+Pada contoh sebelumnya, closure yang dikembalikan fungsi memiliki skema sangat sederhana, tanpa parameter dan argument. Mari coba praktik dengan contoh yang lebih kompleks.
 
 ```rust
 fn do_something_v2() -> impl Fn(i32, String) -> String {
@@ -304,12 +298,14 @@ Pada kode di atas fungsi `do_something_v2` mengembalikan closure dengan skema `F
 
 Di dalam closure tersebut, data parameter digabung menjadi sebuah pesan string yang kemudian dijadikan nilai balik.
 
-Sekarang jalankan fungsi `do_something_v2` di atas, kemudian lihat hasilnya.
+Berikut adalah contoh penerapan fungsi `do_something_v2` pada `main`:
 
 ```rust
-let my_closure = do_something_v2();
-let message = my_closure(123, "hello rust".to_owned());
-println!("{message} (from main)");
+fn main() {
+    let my_closure = do_something_v2();
+    let message = my_closure(123, "hello rust".to_owned());
+    println!("{message} (from main)");
+}
 ```
 
 ![Closure](img/closures-5.png)

docs/basic/hello-rust.md

@@ -47,9 +47,9 @@ Bisa dilihat pada gambar di atas pesan `Hello, world!` yang ada dalam file `main
 
 Command `cargo run` digunakan untuk menjalankan aplikasi saat proses development. Perlu diingat bahwa Rust merupakan bahasa pemrograman yang kategorinya `compiled language` yang artinya kode program akan dikompilasi terlebih dahulu untuk menghasilkan file binary, dan kemudian file binary itulah yang dijalankan.
 
-Command `cargo run` merupakan shorthand untuk memperpendek proses kompilasi dan eksekusi. Dalam command tersebut, kode program akan di-compile terlebih dahulu, dan hasilnya adalah file executable binary bernama `hello_rust.exe` (karena penulis menggunakan windows). File binary tersebut berada dalam project dalam path `hello_rust/target/debug/hello_rust.exe`. Setelah proses kompilasi, file binary tersebut dijalankan, dan hasilnya adalah pesan `Hello, world!` yang muncul di layar
+Command `cargo run` merupakan shorthand untuk memperpendek proses kompilasi dan eksekusi. Dalam command tersebut, kode program akan di-compile terlebih dahulu, dan hasilnya adalah file executable binary (misalnya `hello_rust` di Linux/Mac, atau `hello_rust.exe` di Windows). File binary tersebut berada dalam project dalam path `hello_rust/target/debug/`. Setelah proses kompilasi, file binary tersebut dijalankan, dan hasilnya adalah pesan `Hello, world!` yang muncul di layar
 
-> Untuk pengguna windows, file binary akan ber-ekstensi `.exe` seperti pada contoh yaitu `hello_rust.exe`. Sedangkan untuk non-windows, file tidak mempunyai ekstensi, `hello_rust`.
+> Untuk pengguna Windows, file binary akan ber-ekstensi `.exe` seperti pada contoh yaitu `hello_rust.exe`. Sedangkan untuk non-Windows, file tidak mempunyai ekstensi, `hello_rust`.
 
 Command `cargo run` akan sering kita pakai dalam proses development.
 

docs/basic/konstanta.md

@@ -11,18 +11,18 @@ Chapter ini membahas tentang konstanta di bahasa Rust.
 Berbeda dengan variabel yang dideklarasikan menggunakan keyword `let`, konstanta dibuat dengan keyword `const`. Contoh:
 
 ```rust
-const LABEL: &str = "nilai pi adalah:";
-const PI: f32 = 22.0/7.0;
-println!("{} {}", LABEL, PI);
+const LABEL: &str = "nilai hasil pembagian adalah:";
+const RESULT: f32 = 22.0 / 7.0;
+println!("{} {}", LABEL, RESULT);
 ```
 
-Bisa dilihat di kode di atas, konstanta `LABEL` merupakan string dengan nilai `"nilai pi adalah:"`, sedang `PI` memiliki nilai bertipe float hasil dari operasi `22.0/7.0`.
+Bisa dilihat di kode di atas, konstanta `LABEL` merupakan string dengan nilai `"nilai hasil pembagian adalah:"`, sedang `RESULT` memiliki nilai bertipe float hasil dari operasi `22.0 / 7.0`.
 
 Dalam pendefinisian konstanta, tipe data harus dituliskan secara eksplisit. Deklarasi seperti `const DATA = "x"` akan menghasilkan error saat proses kompilasi. Dan aturan ini berlaku untuk semua tipe data yang dipergunakan untuk pendefinisian konstanta.
 
-Nilai sebuah konstanta bisa dari konstanta lain atau dari ekspresi konstan, misalnya operasi aritmatika `22.0/7.0`.
+Nilai sebuah konstanta bisa dari konstanta lain atau dari ekspresi konstan, misalnya operasi aritmatika `22.0 / 7.0`.
 
-Di sini penulis tidak menggunakan `22/7` karena hasilnya akan bertipe integer. Di Rust operasi aritmatika harus dilakukan dengan tipe data yang sama, dan hasilnya akan memiliki tipe data sesuai operand. Lebih jelasnya akan kita bahas pada chapter selanjutnya.
+Di sini penulis tidak menggunakan `22 / 7` karena hasilnya akan bertipe integer. Di Rust operasi aritmatika harus dilakukan dengan tipe data yang sama, dan hasilnya akan memiliki tipe data sesuai operand. Lebih jelasnya akan kita bahas pada chapter selanjutnya.
 
 > Keyword `mut` tidak bisa diterapkan pada konstanta. Jika dipaksa akan menghasilkan error.
 

docs/basic/lifetime.md

@@ -67,10 +67,10 @@ Setelah ini kita akan praktik penerapan pembuatan lifetime, namun sebelum itu ma
 ```rust
 fn main() {
     let message = String::from("darkspear is better than zandalari");
-    print_mesage(&message)
+    print_message(&message)
 }
 
-fn print_mesage(m: &String) {
+fn print_message(m: &String) {
     println!("the message: {m}")
 }
 ```

docs/basic/operator.md

@@ -129,17 +129,19 @@ Berikut merupakan list operator untuk operasi logika `bool` beserta contoh pener
 
 ```rust
 let (bool_left, bool_right) = (false, true);
-println!("AND result \t: {}", bool_left && bool_right);
-println!("OR result \t: {}", bool_left || bool_right);
+println!("AND result: {}", bool_left && bool_right);
+println!("OR result: {}", bool_left || bool_right);
+// output ==> AND result: false
+// output ==> OR result: true
 ```
 
 ### ◉ *Whitespace character* tab `\t`
 
-Rust mendukung karakter standar whitespace seperti `\t` yang kegunaannya adalah untuk horizontal tab. Contoh penerapannya seperti pada kode di atas, tulis saja `\t` dalam string literal, hasilnya bisa dilihat saat di-print.
+Rust mendukung karakter standar whitespace seperti `\t` yang kegunaannya adalah untuk horizontal tab. Contoh penerapannya, gunakan `\t` dalam string literal:
 
 ```rust
-println!("AND result \t: {}", bool_left && bool_right);
-println!("OR result \t: {}", bool_left || bool_right);
+println!("AND result\t: {}", bool_left && bool_right);
+println!("OR result\t: {}", bool_left || bool_right);
 ```
 
 ![operator boolean](img/operator-1.png)

docs/basic/pattern-matching.md

@@ -241,17 +241,17 @@ Dari sini cukup jelas kegunaan dari `if let`. Meskipun menggunakan operator `=`
 Tambahan contoh, 2 block kode berikut adalah juga ekuivalen.
 
 ```rust
-let value = 6;
+let value = Some(6);
 match value {
-    1 | 2 => println!("one or two"),
-    3..=5 => println!("three through five"),
-    6     => println!("six"),
-    _     => println!("other number"),
+    Some(1 | 2) => println!("one or two"),
+    Some(3..=5) => println!("three through five"),
+    Some(6)     => println!("six"),
+    _           => println!("other number"),
 }
 
 // ... vs ...
 
-let value = Some(5);
+let value = Some(6);
 if let Some(1 | 2) = value {
     println!("one or two");
 } else if let Some(3..=5) = value {

docs/basic/slice-memory-management.md

@@ -6,7 +6,7 @@ sidebar_label: A.45. Slice Memory Management
 
 Kita telah mempelajari tipe data [Array](/basic/array) dan [Vector](/basic/vector), serta sudah beberapa kali menggunakan tipe data `String`. Ketiga tipe data tersebut bisa menghasilkan slice via operasi borrowing.
 
-> Ciri khas dari tipe data yang termasuk dalam kategori slice adalah jika diakses reference-nya menghasilkan data bertipe `&[T]` yang mana `T` adalah tipe data elemen.
+> Ciri khas dari tipe yang bisa menghasilkan slice adalah jika diakses reference-nya menghasilkan data bertipe `&[T]` yang mana `T` adalah tipe data elemen. Contohnya array, vector, dan `String`.
 
 Pada chapter ini, kita akan bahas lebih dalam lagi tentang apa itu slice terutama bagian memory management-nya.
 

docs/basic/tipe-data-primitive-scalar.md

@@ -134,6 +134,8 @@ println!("min_f32={} | max_f32={}", min_f32, max_f32);
 // output ==> min_f32=-340282350000000000000000000000000000000 | max_f32=340282350000000000000000000000000000000
 ```
 
+> Angka di atas adalah representasi desimal dari `f32::MIN` dan `f32::MAX`. Nilai aslinya kira-kira `-3.40282347e+38` dan `3.40282347e+38`, namun saat di-print menggunakan `{}` hasilnya terpotong.
+
 Catatan saja, variabel yang dideklarasikan dengan predefined value numerik yang ada titiknya (`3.10`) adalah floating point, by default tipe datanya adalah `f64`.
 
 ## A.5.4. Bool