Touch up slides, add links to open issues

Author: hdoordt

slides/A-foundations/basic-syntax.md

@@ -1,3 +1,10 @@
+
+---
+layout: section
+---
+
+# Basic Syntax
+
 ---
 
 # Variables
@@ -84,6 +91,7 @@ that variable
 ```rust
 fn main() {
     let x: i32 = 20;
+    //   ^^^^^  Type annotation
 }
 ```
 
@@ -98,7 +106,7 @@ layout: two-cols
 # Integers
 
 | Length        | Signed  | Unsigned |
-|---------------|---------|----------|
+| ------------- | ------- | -------- |
 | 8 bits        | `i8`    | `u8`     |
 | 16 bits       | `i16`   | `u16`    |
 | 32 bits       | `i32`   | `u32`    |
@@ -242,14 +250,14 @@ then the code for b is not executed
 
 ```rust
 fn main() {
-    let c = 'z';
+    let c: char = 'z';
     let z = 'ℤ';
     let heart_eyed_cat = '😻';
 }
 ```
 
-- A character is a 32-bit unicode scalar value
-- Very much unlike C/C++ where char is 8 bits
+- A `char` is a 32-bit unicode scalar value
+- Very much unlike C/C++ where `char is 8 bits
 
 <!--
 - The final scalar type is the character, but it isn't often seen.
@@ -261,16 +269,22 @@ instead.
 
 ---
 
-# Strings
+# `String`s
 ```rust
-    // Owned, heap-allocated string *slice*
-    let s1: String = String::new("Hello, 🌍!");
+    
+    let s1 = String::new("Hello, 🌍!");
+    //       ^^^^^^ Owned, heap-allocated string
 ```
 
-- Rust strings are UTF-8-encoded
+- Rust `String`s are UTF-8-encoded
 - Unlike C/C++: *Not null-terminated*
 - Cannot be indexed like C strings
+- `String` is heap-allocated
 - Actually many types of strings in Rust
+    - `CString`
+    - `PathBuf`
+    - `OsString`
+    - ...
 
 <!--
 - Rusts strings are complicated, because all strings are complicated
@@ -294,7 +308,7 @@ fn main() {
 - Group multiple values into a single compound type
 - Fixed size
 - Different types per element
-- Create a tuple by writing a comma-separated list of values inside parentheses
+- Create by writing a comma-separated list of values inside parentheses
 
 ::right::
 
@@ -406,9 +420,9 @@ fn also_returns_nothing() {
 ```
 
 - The function boundary must always be explicitly annotated with types
-- Within the function body type inference may be used
+- Type inference may be used in function body
 - A function that returns nothing has the return type *unit* (`()`)
-- The function body contains a series of statements optionally ending with an
+- Function body contains a series of statements optionally ending with an
 expression
 
 <!--
@@ -440,6 +454,10 @@ fn my_fun() {
 let x = 10;
 ```
 
+```rust
+return 42;
+```
+
 <v-click>
 
 ```rust
@@ -465,9 +483,9 @@ statements
 
 - Expressions evaluate to a resulting value
 - Expressions make up most of the Rust code you write
-- Includes all control flow such as `if` and `while`
+- Includes all control flow such as `if` and `loop`
 - Includes scoping braces (`{` and `}`)
-- An expression can be turned into a statement by adding a semicolon (`;`)
+- Semicolon (`;`) turns expression into statement
 
 ```rust {all|2-5}
 fn main() {

slides/A-foundations/closures.md

@@ -1,7 +1,14 @@
+
+---
+layout: section
+---
+
+# Closures
+
 ---
 layout: default
 ---
-# Intermezzo: Closures
+# Closures
 
 - Closures are anonymous (unnamed) functions
 - they can capture ("close over") values in their scope
@@ -28,3 +35,8 @@ fn bar() -> i64 {
 let evens: Vec<_> = some_iterator.filter(|x| x % 2 == 0).collect();
 ```
 
+---
+
+# To do
+
+Issue: [tweedegolf/101-rs#66](https://github.com/tweedegolf/101-rs/issues/66)

slides/A-foundations/composite-types.md

@@ -1,3 +1,10 @@
+
+---
+layout: section
+---
+
+# Composite types
+
 ---
 
 # Types redux
@@ -144,23 +151,21 @@ fn main() {
 }
 ```
 
-* Note: an enum always is as large as the largest variant
-
-<!--<div class="relative">-->
+* An enum always is as large as the largest variant + tag
 
-<div style="margin-left:auto; margin-right:auto; display:block; width:50%;">
+<div style="margin-left:auto; margin-right:auto; display:block; width:100%;">
 
 <LightOrDark>
     <template #dark>
-        <center>
+        <div style="padding: 20px; background-color:#1b1b1b; border-radius: var(--slidev-code-radius) !important;">
             <img src="/images/A2-enum-memory-dark.svg"/>
-        </center>
+        </div>
     </template>
     <template #light>
-        <img src="/images/A2-enum-memory-light.svg"/>
+        <div style="padding: 20px; background-color:#F8F8F8; border-radius: var(--slidev-code-radius) !important;">
+          <img src="/images/A2-enum-memory-light.svg"/>
+        </div>
     </template>
 </LightOrDark>
 
 </div>
-
-<!--</div>-->

slides/A-foundations/entry.md

@@ -3,13 +3,13 @@ theme: default
 class: text-center
 highlighter: shiki
 lineNumbers: true
-info: "Rust - A1: Language basics"
+info: "Rust - A: Foundation"
 drawings:
     persist: false
 fonts:
     mono: Fira Mono
 layout: cover
-title: "Rust - A1: Language basics"
+title: "Rust - A: Foundation"
 ---
 
 # Rust programming

slides/A-foundations/first-project.md

@@ -1,3 +1,9 @@
+
+---
+layout: section
+---
+# Meeting Rust
+
 ---
 layout: default
 ---

slides/A-foundations/images

@@ -0,0 +1 @@
+../images

slides/A-foundations/impl-blocks.md

@@ -1,7 +1,14 @@
+
+---
+layout: section
+---
+
+# `impl` blocks
+
 ---
 
-# Intermission: Impl blocks
-In the past few slides we saw a syntax which wasn't explained before:
+# `impl` blocks
+To associate functions to `structs` and `enums`, we use `impl` blocks
 
 ```rust {3}
 fn main() {
@@ -17,7 +24,7 @@ fn main() {
 
 ---
 
-# Intermission: Impl blocks
+# `impl` blocks
 
 ```rust {all|6,13|7-12|7|17}
 enum IpAddress {
@@ -50,7 +57,7 @@ fn main() {
 
 ---
 
-# Intermission: Impl blocks, self and Self
+# `self` and `Self`
 
 - The `self` parameter defines how the method can be used.
 - The `Self` type is a shorthand for the type on which the current
@@ -60,35 +67,35 @@ fn main() {
 struct Foo(i32);
 
 impl Foo {
-  fn consume(self) -> Self {
+  fn consume(self) -> Self {            // Takes `Foo` by value, returns `Foo`
     Self(self.0 + 1)
   }
 
-  fn borrow(&self) -> &i32 {
+  fn borrow(&self) -> &i32 {            // Takes immutable reference of `Foo`
     &self.0
   }
 
-  fn borrow_mut(&mut self) -> &mut i32 {
+  fn borrow_mut(&mut self) -> &mut i32 { // Takes mutable reference of `Foo`
     &mut self.0
   }
 
-  fn new() -> Self {
+  fn new() -> Self {                     // Associated function, returns `Foo`
     Self(0)
   }
 }
 ```
 
 ---
 
-# Intermission: Impl blocks, the self parameter
+# `impl` blocks, the `self` parameter
 The self parameter is called the *receiver*.
 
-* The self parameter is always the first and it always has the type on which it
+* The `self` parameter is always the first and it always has the type on which it
   was defined
-* We never specify the type of the self parameter
-* We can optionally prepend `&` or `&mut ` to self to indicate that we take
+* We never specify the type of the `self` parameter
+* We can optionally prepend `&` or `&mut ` to `self` to indicate that we take
   a value by reference
-* Absence of a self parameter means that the function is an associated function
+* Absence of a `self` parameter means that the function is an associated function
   instead
 
 ```rust

slides/A-foundations/interior-mutability.md

@@ -0,0 +1,12 @@
+
+---
+layout: section
+---
+
+# Interior mutability
+
+---
+
+# To do:
+
+Issue: [tweedegolf/101-rs#67](https://github.com/tweedegolf/101-rs/issues/67)