Adding return impl usage

src/let_else.rs

@@ -11,11 +11,12 @@ fn process_str(s: &str) -> u64 {
         return 42
     }
     let count = res.unwrap();
+
     // ... do_something_with(count)
     count + 1
 }
 
-#[test] 
+#[test]
 fn ex1_simple_works() {
     assert_eq!(process_str("3"), 4);
 }

src/lib.rs

@@ -39,6 +39,7 @@ mod trait_object_vs_struct_obj;
 mod traits;
 mod traits_associated_type_vs_generics;
 mod traits_default_type_parameter;
+mod traits_return_impl; // todo: incomplete
 mod traits_same_name_fn_call;
 mod traits_supertraits;
 mod utils;

src/match_.rs

@@ -1,5 +1,13 @@
 /// 1. Refutability
-// Refutable: able to be proven false
+// Irrefutable: int x = 42; // x always have value, never false
+// Refutable: able to be proven false 
+// e.g. Option<T> can be have value or not
+// pub enum Option<T> {
+//     /// No value.
+//     None,
+//     /// Some value of type `T`.
+//     Some(#[stable(feature = "rust1", since = "1.0.0")] T),
+// }
 
 #[test] fn ex_1() {
   let res = Some(42);

src/multi_threading_par_iter.rs

@@ -42,7 +42,7 @@ fn single_thread_exec(arr: &mut [i32]) {
 
     assert_eq!(32,32);
 }
-//// Lesson: Parallel exec. is more meaningful when we have bigger arrays
+//// Important: Parallel exec. is more meaningful when we have bigger arrays/tasks
 //// StdOut:
 // (1) Arr size: 5_000
 //   (a) Parallel exec: 636 us

src/serde_json.rs

@@ -8,7 +8,7 @@ use serde_json::to_string as to_json;
 use serde_derive::{Serialize};
 
 // Instructs the serde_derive crate to write the necessary code to carry out
-// the conversion from an in-memory City to on-disk City
+// the conversion from an in-memory City obj. to on-disk City obj.
 #[derive(Serialize)]
 struct City {
     name: String,

src/traits_default_type_parameter.rs

@@ -1,6 +1,6 @@
 use std::ops::Add;
 
-// Original Add trait
+// Original Add trait from std
 pub trait Add_<Rhs = Self> { // <Rhs = Self>: default type parameter
     type Output;
     fn add(self, rhs: Rhs) -> Self::Output;

src/traits_return_impl.rs

@@ -0,0 +1,35 @@
+
+// https://blog.rust-lang.org/2018/05/10/Rust-1.26.html#impl-trait
+
+trait Trait { }
+impl Trait for i32 { }
+impl Trait for f32 { }
+
+// Use this
+// Note: This doesn't create a trait object, it's like we had written -> i32, 
+// but instead, we're only mentioning the part about Trait. 
+// We get static dispatch, but we can hide the real type like this.
+fn foo() -> impl Trait {
+    5
+}
+// instead of 
+fn foo_() -> Box<dyn Trait> {
+    Box::new(5) as Box<dyn Trait>
+}
+
+//// Real word usage:
+// before
+fn get_closure() -> Box<dyn Fn(i32) -> i32> {
+    Box::new(|x| x + 1)
+}
+// after
+fn get_closure_() -> impl Fn(i32) -> i32 {
+    |x| x + 1
+}
+
+#[test] 
+fn ex1() {
+    let xx = foo();
+    let yy = foo_();
+    // assert_eq!(xx, 5); // todo
+}