fix: sentences

Author: novalagung

docs/basic/array.md

@@ -145,23 +145,23 @@ Array lebih mudah dideklarasikan dengan metode *type inference*. Namun tak menut
 ```rust
 let angka_integer = [24, 12, 32, 7];
 println!("{angka_integer:?}");
-// output: [24, 12, 32, 7]
+// output ➜ [24, 12, 32, 7]
 
 let angka_float = [24.2, 12.5, 32.00002, 7.2];
 println!("{angka_float:?}");
-// output: [24.2, 12.5, 32.00002, 7.2]
+// output ➜ [24.2, 12.5, 32.00002, 7.2]
 ```
 
 ### ◉ Deklarasi array dengan metode *manifest typing* disertai *predefined value*
 
 ```rust
 let data_boolean: [bool; 2] = [false, true];
 println!("{data_boolean:?}");
-// output: [false, true]
+// output ➜ [false, true]
 
 let angka_unsigned_integer: [u32; 3] = [24, 0, 12];
 println!("{angka_unsigned_integer:?}");
-// output: [24, 0, 12]
+// output ➜ [24, 0, 12]
 ```
 
 ### ◉ Deklarasi array dengan notasi penulisan `[T; N]`
@@ -171,15 +171,15 @@ Pada contoh berikut, `data_numerik1` dideklarasikan bertipe array dengan tipe da
 ```rust
 let data_numerik1: [i32; 10] = [0; 10];
 println!("{data_numerik1:?}");
-// output: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+// output ➜ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 ```
 
 Pada contoh ke-dua ini, `data_numerik2` dideklarasikan dengan *predefined value* adalah array yang size-nya `5` dan nilai default tiap elemen adalah angka `4`.
 
 ```rust
 let data_numerik2 = [4; 5];
 println!("{data_numerik2:?}");
-// output: [4, 4, 4, 4, 4]
+// output ➜ [4, 4, 4, 4, 4]
 ```
 
 Tambahan penjelasan mengenai notasi penulisan `[T; N]`:

docs/basic/datetime.md

@@ -76,7 +76,7 @@ Pembuatan object datetime dengan isi informasi waktu spesifik bisa dilakukan men
 ```rust
 let sample_date2_in_utc = Utc.with_ymd_and_hms(2023, 3, 1, 1, 2, 3).unwrap();
 println!("sample date 2 (in utc): {sample_date2_in_utc}");
-// output: sample date 2 (in utc): 2023-03-01 01:02:03 UTC
+// output ➜ sample date 2 (in utc): 2023-03-01 01:02:03 UTC
 ```
 
 Statement di atas menghasilkan data datetime dengan isi `2023-03-01 01:02:03 UTC`.
@@ -88,7 +88,7 @@ Cara ini pas digunakan pada situasi di mana kita perlu membuat object datetime d
 ```rust
 let sample_date3_in_utc = DateTime::<Utc>::from(UNIX_EPOCH + Duration::from_secs(1524885322));
 println!("sample date 3 (in utc): {sample_date3_in_utc}");
-// output: sample date 3 (in utc): 2018-04-28 03:15:22 UTC
+// output ➜ sample date 3 (in utc): 2018-04-28 03:15:22 UTC
 ```
 
 Statement `DateTime::<Utc>::from()` di atas menghasilkan data datetime `2018-04-28 03:15:22 UTC`, karena nilai `1524885322` adalah representasi UNIX time untuk waktu tersebut.
@@ -100,7 +100,7 @@ Tipe data string bisa langsung dikonversi ke bentuk datetime menggunakan method
 ```rust
 let sample_date4_in_utc = "2023-03-01 01:02:03 UTC".parse::<DateTime<Utc>>().unwrap();
 println!("sample date 4 (in utc): {sample_date4_in_utc}");
-// output: sample date 4 (in utc): 2023-03-01 01:02:03 UTC
+// output ➜ sample date 4 (in utc): 2023-03-01 01:02:03 UTC
 ```
 
 Statement parsing di atas menghasilkan data datetime `2023-03-01 01:02:03 UTC`, sesuai dengan isi data string.
@@ -186,7 +186,7 @@ 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 +215,7 @@ 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

docs/basic/slice.md

@@ -100,15 +100,15 @@ Gunakan method `len` untuk mencari tau size dari slice.
 ```rust
 let numbers = [12, 16, 8, 3];
 println!("{}", numbers.len());
-// output: 4
+// output ➜ 4
 
 let slice_a = &numbers[0..3];
 println!("{}", slice_a.len());
-// output: 3
+// output ➜ 3
 
 let slice_b = &slice_a[1..=2];
 println!("{}", slice_b.len());
-// output: 2
+// output ➜ 2
 ```
 
 ## A.14.3. Slice *range syntax*

docs/basic/traits.md

@@ -82,14 +82,10 @@ Pemakaiannya di `main` bisa seperti ini:
 ```rust
 fn main() {
     let v = Wrapper(vec![String::from("a"), String::from("b")]);
-    println!("{}", v);
+    println!("{}", v); // output ➜ ["a", "b"]
 }
 ```
 
-Output:
-
-> ["a", "b"]
-
 ### ◉ Contoh local trait
 
 Sekarang kita coba kebalikannya: membuat trait sendiri, lalu mengimplementasikannya ke type yang sudah ada.
@@ -119,14 +115,10 @@ Pemakaiannya di `main` akan terlihat seperti ini:
 ```rust
 fn main() {
     let s = String::from("hello");
-    s.log();
+    s.log(); // output ➜ hello
 }
 ```
 
-Output:
-
-> hello
-
 ## A.36.2. Implementasi trait
 
 Kita pilih trait `std::fmt::Debug` milik Rust standard library untuk belajar cara implementasi trait pada tipe data.

docs/basic/variabel.md

@@ -209,8 +209,8 @@ Di Rust memungkinkan untuk mendefinisikan banyak variabel dalam 1 baris statemen
 
 ```rust
 let (var1, var2) = (24, "hello");
-println!("var1: {0}", var1); // hasilnya => var1: 24
-println!("var2: {0}", var2); // hasilnya => var2: hello
+println!("var1: {0}", var1); // output ➜ var1: 24
+println!("var2: {0}", var2); // output ➜ var2: hello
 ```
 
 Pendefinisian banyak variabel dalam 1 statement dilakukan dengan menuliskan semua variabelnya dengan separator tanda `,` dan diapit tanda kurung `()`.
@@ -221,19 +221,19 @@ Bisa juga saat definisi variabel sekaligus ditentukan tipe data variabel, notasi
 
 ```rust
 let (var3, var4): (i8, i8) = (32, 12);
-println!("var3: {0}", var3); // hasilnya => var3: 32
-println!("var4: {0}", var4); // hasilnya => var4: 12
+println!("var3: {0}", var3); // output ➜ var3: 32
+println!("var4: {0}", var4); // output ➜ var4: 12
 ```
 
 Dengan notasi ini bisa juga untuk definisi variabel *mutable*. Cukup tambahkan keyword `mut` pada variabel yang ingin bisa diubah nilainya.
 
 ```rust
 let (var5, mut var6, var7): (i8, i8, i8) = (64, 12, 4);
-println!("var5: {0}", var5); // hasilnya => var5: 64
-println!("var6: {0}", var6); // hasilnya => var6: 12
+println!("var5: {0}", var5); // output ➜ var5: 64
+println!("var6: {0}", var6); // output ➜ var6: 12
 var6 = 24;
-println!("var6: {0}", var6); // hasilnya => var6: 24
-println!("var7: {0}", var7); // hasilnya => var7: 4
+println!("var6: {0}", var6); // output ➜ var6: 24
+println!("var7: {0}", var7); // output ➜ var7: 4
 ```
 
 ## A.4.7. Deklarasi variabel dengan tipe data ditentukan dari value
@@ -242,7 +242,7 @@ Ini merupakan salah satu alternatif cara penulisan untuk men-specify tipe data v
 
 ```rust
 let data1 = 24i8;
-println!("data1: {0}", data1); // hasilnya => data1: 24
+println!("data1: {0}", data1); // output ➜ data1: 24
 ```
 
 Variabel `data` didefinisikan dengan predefined value adalah numerik `24` dengan tipe data `i8`, penulisan value nya menjadi `24i8`.
@@ -251,7 +251,7 @@ Boleh juga menggunakan separator `_` dalam penulisan value-nya sebagai pembatas
 
 ```rust
 let data1 = 24_i8;
-println!("data1: {0}", data1); // hasilnya => data1: 24
+println!("data1: {0}", data1); // output ➜ data1: 24
 ```
 
 ## A.4.8. Variable *Shadowing*
@@ -262,10 +262,10 @@ Contoh shadowing bisa dilihat pada kode berikut:
 
 ```rust
 let x = 5;
-println!("x: {}", x); // hasilnya => x: 5
+println!("x: {}", x); // output ➜ x: 5
 
 let x = x + 1;
-println!("x: {}", x); // hasilnya => x: 6
+println!("x: {}", x); // output ➜ x: 6
 ```
 
 Lebih jelasnya akan kita bahas pada chapter terpisah, yaitu [Shadowing](/basic/shadowing).