fix: typo

Author: novalagung

docs/basic/advanced-traits.md

@@ -142,7 +142,7 @@ fn calculate_and_print_result(name: String, item: &impl Area) {
 }
 ```
 
-Manfaat penerapan trait sebagai tipe data parameter fungsi adalah saat pemanggilan fungsi, parameter tersebut bisa diisi dengan argument data bertipe apapun dengan catatan tipe dari data tersebut mengimplementasikan trait yang sama dengan yang digunakan pada parameter.
+Manfaat penerapan trait sebagai tipe data parameter fungsi adalah saat pemanggilan fungsi, parameter tersebut bisa diisi dengan argument data bertipe apa pun dengan catatan tipe dari data tersebut mengimplementasikan trait yang sama dengan yang digunakan pada parameter.
 
 Contohnya seperti pada fungsi `calculate_and_print_result` di atas yang parameter ke-2 bertipe `&impl Area`, nantinya saat fungsi tersebut dipanggil, kita bisa sisipi parameter ke-2 dengan object `circle_one` ataupun `circle_two`.
 
@@ -211,7 +211,7 @@ Mari praktikkan. Lakukan modifikasi berikut pada beberapa kode yang telah di tul
     }
     ```
 
-Dengan perubahan kode yang telah dilakukan di atas, parameter `item` milik fungsi `calculate_and_print_result()` bisa diisi dengan nilai argument apapun asalkan memenuhi kriteria tipe yang ditentukan, yaitu: haruse meng-implement trait `Area` dan trait `Circumference`.
+Dengan perubahan kode yang telah dilakukan di atas, parameter `item` milik fungsi `calculate_and_print_result()` bisa diisi dengan nilai argument apa saja asalkan memenuhi kriteria tipe yang ditentukan, yaitu: harus meng-implement trait `Area` dan trait `Circumference`.
 
 Notasi penulisan tipe-datanya `&(impl Trait1 + Trait2 + Trait3 + ...)`.
 
@@ -278,7 +278,7 @@ Trait bisa juga digunakan sebagai tipe data return value. Caranya gunakan notasi
 Contohnya bisa dilihat pada kode berikut. Ada dua fungsi baru dideklarasikan:
 
 1. Fungsi `new_circle` dengan return type adalah `impl Area`, dan data yang dikembalikan adalah bertipe `two_dimensional::Circle`.
-1. Fungsi `new_square` dengan return type adalah `impl Area + Circumference`, dan data yang dikembalikan adalah bertipe `two_dimensional::Square`.
+2. Fungsi `new_square` dengan return type adalah `impl Area + Circumference`, dan data yang dikembalikan adalah bertipe `two_dimensional::Square`.
 
 ```rust
 fn main() {

docs/basic/array.md

@@ -306,12 +306,14 @@ for sub_arr in data_arr {
     println!();
 }
 
+// output ⬇️
+//
 // salad, fried rice,
 // apple, coconut,
 // spinach, jalapeno,
 ```
 
-Variabel `data_arr` pada contoh di atas bertipe data`[[&str; 2]; 3]`, yang artinya adalah sebuah array dengan size 3, dengan isi elemen adalah juga array dengan size 2. Selalu ingat bahwa size array adalah fixed.
+Variabel `data_arr` pada contoh di atas bertipe data `[[&str; 2]; 3]`, yang artinya adalah sebuah array dengan size 3, dengan isi elemen adalah juga array dengan size 2. Selalu ingat bahwa size array adalah fixed.
 
 ---
 

docs/basic/associated-function.md

@@ -4,7 +4,7 @@ title: A.24. Associated Function
 sidebar_label: A.24. Associated Function
 ---
 
-Chapter ini membahas tentang *associated function*. Kita akan belajar apa itu associated function dan apa perbedannya dengan fungsi biasa.
+Chapter ini membahas tentang *associated function*. Kita akan belajar apa itu associated function dan apa perbedaannya dengan fungsi biasa.
 
 ## A.24.1. *Associated item* & *associated function*
 
@@ -216,7 +216,7 @@ Struct adalah salah satu dari beberapa item yang ada di Rust. Struct bisa saja b
 
 Sekarang, kode yang sudah dipraktikkan di atas akan kita refactor. Struct `LegoSet` beserta associated items-nya dipindah ke module file bernama `lego`, dengan itu maka pemanggilan struct tersebut harus menggunakan path `lego::LegoSet`.
 
-Kurang lebih struktur package mendi seperti ini:
+Kurang lebih struktur package menjadi seperti ini:
 
 ```bash title="package source code structure"
 my_package

docs/basic/attributes.md

@@ -482,7 +482,7 @@ Pada contoh di atas, tempat di mana enum dideklarasikan dan digunakan adalah mas
 
 ## A.51.6. Attribute *modules*
 
-Aturan manajemen di Rust cukup ketat, dan sudah dibahas secara mendetal pada chapter [Module System ➜ Module](/basic/module-basic), yang intinya adalah ada dua cara pembuatan module:
+Aturan manajemen di Rust cukup ketat, dan sudah dibahas secara mendetail pada chapter [Module System ➜ Module](/basic/module-basic), yang intinya adalah ada dua cara pembuatan module:
 
 - Cara ke-1: dengan mendefinisikan module pada file bernama `nama_module.rs`
 - Cara ke-2: dengan mendefinisikan module pada file bernama `nama_module/mod.rs`
@@ -548,7 +548,7 @@ Lebih detailnya mengenai attribute testing dibahas pada chapter [Testing](#/wip/
 
 Lebih detailnya mengenai attribute macros dibahas pada chapter [Macro](#/wip/macro).
 
-## A.51.9 Attribute lainnya
+## A.51.9. Attribute lainnya
 
 Rust memiliki cukup banyak attribute yang list-nya bisa dilihat pada link ini https://doc.rust-lang.org/reference/attributes.html.
 

docs/basic/basic-memory-management.md

@@ -20,15 +20,15 @@ GC adalah metode manajemen memori otomatis pada bahasa pemrograman. GC memiliki
 
 Proses dealokasi pada GC terjadi di belakang layar secara asynchronous.
 
-Beberapa bahasa pemrograman yang menerapkan GC di antara adalah Java, C#, Go, Lisp, dan banyak bahasa lainnya.
+Beberapa bahasa pemrograman yang menerapkan GC di antaranya adalah Java, C#, Go, Lisp, dan banyak bahasa lainnya.
 
 ### ◉ Automatic reference counting (ARC)
 
-ARC adalah metode manajemen memori yang diterapkan pada bahasa Objective-C dan Swift. Cara ARC me-manage memory adalah dengan mencatat *reference* object dan segala aktifitas yang terjadi pada object tersebut.
+ARC adalah metode manajemen memori yang diterapkan pada bahasa Objective-C dan Swift. Cara ARC me-manage memory adalah dengan mencatat *reference* object dan segala aktivitas yang terjadi pada object tersebut.
 
 Di ARC, ada satuan yang disebut dengan *retain count* yang merupakan representasi jumlah banyaknya variabel atau object yang memegang suatu *reference*. Ketika *reference* sudah pindah ke luar scope atau dihapus isinya dan dilihat pada catatan rupanya tidak ada variabel yang memegang *reference* tersebut, maka dilakukan proses dealokasi memory.
 
-Dalam bahasa yang menerapkan ARC, programmer dianjurkan untuk perhatian dan bijak dalam pengalokasian variabel beserta nilainya. Mana data yang diperlukan untuk di-retain secara *strong* dan mana yang tidak, harus pas sesuai dengan kebutuhan. Jika tidak hati-hati maka program mempunyai resiko lebih tinggi untuk menemui error *deadlocks* ataupun *memory leaks* (yang juga akan dibahas pada chapter ini).
+Dalam bahasa yang menerapkan ARC, programmer dianjurkan untuk berhati-hati dan bijak dalam pengalokasian variabel beserta nilainya. Mana data yang diperlukan untuk di-retain secara *strong* dan mana yang tidak, harus pas sesuai dengan kebutuhan. Jika tidak hati-hati maka program mempunyai resiko lebih tinggi untuk menemui error *deadlock* ataupun *memory leaks* (yang juga akan dibahas pada chapter ini).
 
 ### ◉ Manual memory management
 
@@ -169,7 +169,7 @@ Ok, lanjut ke block fungsi `main` berikutnya, yaitu `let a = 4`. Saat dipanggil
 | <span style={{color: '#2e8555'}}>**3**</span> | <span style={{color: '#2e8555'}}>**a**</span> | <span style={{color: '#2e8555'}}>**4**</span> | <span style={{color: '#2e8555'}}>**milik fungsi `main()`**</span> |
 | 0 | x | 24 | milik fungsi `main()` |
 
-Kemudian sampai di statement terakhir fungsi `main`. Ketika `let b = 14` dipanggil maka ada penambahan data baru pada stack frame pertama.
+Kemudian sampai di statement terakhir fungsi `main`. Ketika `let b = 18` dipanggil maka ada penambahan data baru pada stack frame pertama.
 
 | No. | Variabel | Nilai | *Stack frame* |
 |:-:|:-:|:-:|:-|

docs/basic/block-expression.md

@@ -45,14 +45,16 @@ Kemudian ada beberapa variabel baru yang didefinisikan di dalam block, yaitu `y`
 Sebagai contoh, kode berikut menghasilkan error:
 
 ```rust
-let x = 24;
+fn main() {
+    let x = 24;
 
-{
-    let y = 12;
-    let z = x + y;
-};
+    {
+        let y = 12;
+        let z = x + y;
+    };
 
-println!("z: {}", z); // <------ error
+    println!("z: {}", z); // <------ error
+}
 ```
 
 O iya, dalam penulisannya, statement block harus diikuti tanda semicolon `;` sebagai penanda akhir statement, dengan beberapa pengecualian yang akan ikut dibahas pada section setelah ini.
@@ -164,7 +166,7 @@ Pembahasan mengenai unsafe block expression ada pada chapter [Safe & Unsafe](#/w
 
 Block biasa diterapkan untuk isolasi sebuah proses yang tidak perlu di-reuse. Jika proses adalah di-reuse, dianjurkan untuk menggunakan fungsi dalam penerapannya.
 
-Di bahasa pemrograman lain juga ada block yang penerapannya kurang lebih adalah sama. Namun perlu diketahui, di Rust block memiliki berbedaan yang bisa dibilang signifikan, yaitu dalam hal manajemen memory.
+Di bahasa pemrograman lain juga ada block yang penerapannya kurang lebih adalah sama. Namun perlu diketahui, di Rust block memiliki perbedaan yang bisa dibilang signifikan, yaitu dalam hal manajemen memory.
 
 Rust menerapkan konsep memory management bernama **ownership**. Setiap kali Rust selesai mengeksekusi block kode, baik itu fungsi, block expression, atau jenis block lainnya; akan dilakukan evaluasi pengecekan ownership yang ada dalam block tersebut. Untuk data yang owner-nya tidak berpindah ke luar scope, maka akan dilakukan proses dealokasi memory untuk data tersebut. Dengan approach ini penggunaan memory menjadi efisien.
 

docs/basic/borrowing.md

@@ -307,7 +307,7 @@ let d = &false;
 let e = &String::from("rust");
 ```
 
-Ketiga variabel, semuanya adalah *borrower* atau peminjam data. Lalu siapa *owner*-nya? jawabannya adalah tidak ada, atau silakan juga simpulkan bawah data tersebut owner-nya adalah program.
+Ketiga variabel, semuanya adalah *borrower* atau peminjam data. Lalu siapa *owner*-nya? jawabannya adalah tidak ada, atau silakan juga simpulkan bahwa data tersebut owner-nya adalah program.
 
 Yang lebih penting untuk diurusi pada contoh di atas bukan siapa owner-nya, melainkan bagaimana caranya agar data pinjaman tersebut tidak di-dealokasi saat block kode selesai.
 

docs/basic/build-dan-run-program-rust.md

@@ -44,7 +44,7 @@ cargo build --release
 
 ![Optimized build](img/build-dan-run-program-rust-2.png)
 
-Untuk release, file binary berada dalam path `target/release`. File binary nya adalah optimized, size nya lebih kecil. Mungkin untuk program `hello world` tidak akan signifikan bedanya, tapi untuk project real sangat dianjurkan untuk menggunakan optimized build.
+Untuk release, file binary berada dalam path `target/release`. File binary nya adalah optimized, size-nya lebih kecil. Mungkin untuk program `hello world` tidak akan signifikan bedanya, tapi untuk project real sangat dianjurkan untuk menggunakan optimized build.
 
 ## A.2.3. Command `rustc`
 

docs/basic/closures.md

@@ -4,7 +4,7 @@ title: A.48. Closures
 sidebar_label: A.48. Closures
 ---
 
-Chapter ini membahas tentang closures. Closures sendiri merupakan block fungsi anonimus (anonymous function) yang memiliki kelebihan bisa mengakses item-item yang posisinya berada di luar block closure tersebut tetapi masih dalam current block scope.
+Chapter ini membahas tentang closures. Closures sendiri merupakan block fungsi anonim (anonymous function) yang memiliki kelebihan bisa mengakses item-item yang posisinya berada di luar block closure tersebut tetapi masih dalam current block scope.
 
 Topik closures sangat erat hubungannya dengan [Trait ➜ Function](/basic/trait-function), namun pada chapter ini pembahasan hanya difokuskan pada bagian penerapan closures saja. Penulis anjurkan untuk lanjut ke chapter berikutnya setelah selesai dengan chapter ini.
 
@@ -57,8 +57,8 @@ Sebagai contoh, variabel `pi` berikut memiliki 0 digit angka dibelakang koma. Un
 ```rust
 let pi = 3.1415926535;
 
-println!("{:.4}", pi); // 3.1416
-println!("{pi:.4}");   // 3.1416
+println!("{:.4}", pi); // output ➜ 3.1416
+println!("{pi:.4}");   // output ➜ 3.1416
 ```
 
 ## A.48.2. Notasi penulisan closure
@@ -127,8 +127,8 @@ Tidak ada yang spesial mengenai cara mengakses item yang berada di luar block cl
 let num = 5;
 let display = || println!("{num}");
 
-println!("{num}");  // 5
-display();          // 5
+println!("{num}");  // output ➜ 5
+display();          // output ➜ 5
 ```
 
 Beda lagi jika data di luar block closure adalah diubah (di-mutate) nilainya dari dalam closure, jika seperti itu maka ada beberapa hal yang perlu diperhatikan.
@@ -143,7 +143,7 @@ let increase_by = |x: i32| {
 };
 
 increase_by(10);
-println!("{num}"); // 15
+println!("{num}"); // output ➜ 15
 ```
 
 ![Closure](img/closures-1.png)
@@ -177,7 +177,7 @@ let mut increase_by = |x: i32| num += x;
 num += 5;
 increase_by(10);
 
-println!("{num}"); // 20
+println!("{num}"); // output ➜ 20
 ```
 
 ![Closure](img/closures-2.png)
@@ -197,7 +197,7 @@ num += 5;
     increase_by(10);
 }
 
-println!("{num}"); // 20
+println!("{num}"); // output ➜ 20
 ```
 
 Solusi di atas efektif untuk menghilangkan error borrowing yang sebelumnya muncul, tapi setelah d-refactor kode menjadi tidak sesuai spesifikasi awal. Pada kode yang baru di atas, deklarasi closure `increase_by` terjadi di dalam block expression, artinya closure ini hanya akan bisa digunakan pada block kode tersebut saja, tidak bisa di-reuse di luar block.
@@ -211,7 +211,7 @@ let increase_by = |num: &mut i32, x: i32| *num += x;
 num += 5;
 increase_by(&mut num, 10);
 
-println!("{num}"); // 20
+println!("{num}"); // output ➜ 20
 ```
 
 Pada contoh di atas, closure `increase_by` ditambahi parameter baru. Sekarang ada 2 parameter, yaitu `num` yang tipe-nya adalah pointer `&mut i32` dan parameter `x`. Di dalam block closure, `num` di-dereference (menggunakan operator `*`) kemudian diubah nilainya. Setelah eksekusi statement selesai, data pinjaman tersebut langsung dikembalikan ke pemilik. Inilah kenapa kode di atas tidak menghasilkan error.
@@ -228,11 +228,11 @@ Contohnya bisa dilihat berikut ini:
 let mut num = 5;
 let mut increase_by = move |x: i32| {
     num += x;
-    println!("{num} (from closure)"); // 15
+    println!("{num} (from closure)"); // output ➜ 15
 };
 
 increase_by(10);
-println!("{num}"); // 5
+println!("{num}"); // output ➜ 5
 ```
 
 Closure `increase_by` di atas memiliki keyword `move` dalam pendefinisiannya. Dengan ini maka semua variabel di luar scope closure jika diakses dari dalam closure, maka variabel tersebut berpindah owner-nya (*move semantics*).
@@ -259,7 +259,7 @@ fn do_something() -> impl Fn() {
 }
 ```
 
-Tipe `impl Fn()` adalah ekuvalen dengan closure `|| { }`. Contoh penerapannya pada `main`:
+Tipe `impl Fn()` adalah ekuivalen dengan closure `|| { }`. Contoh penerapannya pada `main`:
 
 ```rust
 fn main() {

docs/basic/datetime.md

@@ -22,6 +22,8 @@ edition = "2021"
 chrono = "0.4.44"
 ```
 
+> Silakan gunakan versi terbaru crate `chrono` yang tersedia di [crates.io](https://crates.io/crates/chrono)
+
 ## A.52.2. Tipe data `DateTime`
 
 `chrono` menyediakan cukup banyak tipe data untuk merepresentasikan informasi tanggal dan waktu, tetapi yang paling penting untuk diketahui dan dipahami ada dua, yaitu:
@@ -186,7 +188,8 @@ let sample_date_in_local_tz = Local.from_local_datetime(&naive_date_time).unwrap
 println!("sample date 1 (in utc):      {sample_date_in_utc}");
 println!("sample date 2 (in local_tz): {sample_date_in_local_tz}");
 
-// output ➜
+// output ⬇️
+//
 // sample date 1 (in utc):      2018-04-28 03:15:22 UTC
 // sample date 2 (in local_tz): 2018-04-28 03:15:22 +07:00
 ```
@@ -215,7 +218,8 @@ println!("date (in utc):   {date_in_utc}");
 let date2_in_local_tz = DateTime::<Local>::from(date_in_utc);
 println!("date (in local): {date2_in_local_tz}");
 
-// output ➜
+// output ⬇️
+//
 // date (in local): 2023-03-02 17:33:37.750279900 +07:00
 // date (in utc):   2023-03-02 10:33:37.750279900 UTC
 // date (in local): 2023-03-02 17:33:37.750279900 +07:00
@@ -275,23 +279,23 @@ Contoh pengaplikasian keduanya bisa dilihat pada kode berikut:
 ```rust
 let date1: DateTime<Local> = Local::now();
 println!("date1 (in local):  {}", date1);
-// date1 (in local):  2023-03-02 18:13:39.954831600 +07:00
+// output ➜ date1 (in local):  2023-03-02 18:13:39.954831600 +07:00
 
 let str_from_date1 = date1.format("%Y-%m-%d %H:%M:%S %z").to_string();
 println!("date1 (in string): {}", str_from_date1);
-// date1 (in string): 2023-03-02 18:13:39 +0700
+// output ➜ date1 (in string): 2023-03-02 18:13:39 +0700
 
 let date1_from_str = Local.datetime_from_str(&str_from_date1, "%Y-%m-%d %H:%M:%S %z").unwrap();
 println!("date1 (in local):  {}", date1_from_str);
-// date1 (in local):  2023-03-02 18:13:39 +07:00
+// output ➜ date1 (in local):  2023-03-02 18:13:39 +07:00
 
 let date2_from_str = Utc.datetime_from_str("03/01/2023 13:04 +0000", "%m/%d/%Y %H:%M %z").unwrap();
 println!("date2 (in utc):    {}", date2_from_str);
-// date2 (in utc):    2023-03-01 13:04:00 UTC
+// output ➜ date2 (in utc):    2023-03-01 13:04:00 UTC
 
 let str_from_date2 = date2_from_str.format("%Y-%m-%d %H:%M:%S %z").to_string();
 println!("date2 (in string): {}", str_from_date2);
-// date2 (in string): 2023-03-01 13:04:00 +0000
+// output ➜ date2 (in string): 2023-03-01 13:04:00 +0000
 ```
 
 ## A.52.9. DateTime formatting syntax