Switch and recursion

Author: bowbahdoe

src/SUMMARY.md

@@ -538,15 +538,36 @@ Make them do one. -->
   - [Loop over items](./array_list/loop_over_items.md)
   - [Set an item](./array_list/set_an_item.md)
   - [Remove an item](./array_list/remove_an_item.md)
-<!--- [HashMap](./hash_map.md)
-- [Multi-Dimensional Arrays](./multi_dimensional_arrays.md)
-- [Iterable and Iterator](./iterable_and_iterator.md)
+
 # Concepts II
 - [Hyrum's Law](./hyrums_law.md)
   - [Authority](./hyrums_law/authority.md)
   - [Validity](./hyrums_law/validity.md)
   - [Emergent Properties](./hyrums_law/emergent_properties.md)
   - [Importance](./hyrums_law/importance.md)
+
+# Control Flow V
+
+- [Switch III](./switch_iii.md)
+  - [break](./switch_iii/break.md)
+  - [fallthrough](./switch_iii/fallthrough.md)
+  - [return](./switch_iii/return.md)
+  - [default](./switch_iii/default.md)
+  - [yield](./switch_iii/yield.md)
+- [Recursion](./recursion.md)
+  - [Disclaimer](./recursion/disclaimer.md)
+  - [Base Case](./recursion/base_case.md)
+  - [Comparison to Delegation](./recursion/comparison_to_delegation.md)
+  - [Comparison to Loops](./recursion/comparison_to_loops.md)
+  - [Counting Down](./recursion/counting_down.md)
+  - [Accumulators](./recursion/accumulators.md)
+  - [Recurse Over a String](./recursion/recursing_over_strings.md)
+  - [Recurse Over an Array](./recursion/recursing_over_arrays.md)
+
+<!--- [HashMap](./hash_map.md)
+- [Multi-Dimensional Arrays](./multi_dimensional_arrays.md)
+- [Iterable and Iterator](./iterable_and_iterator.md)
+
 - [Encapsulation](./encapsulation.md)
   - [Implementation Details](./encapsulation/implementation_details.md)
   - [Methods](./encapsulation/methods.md)
@@ -556,29 +577,15 @@ Make them do one. -->
   - [Leaky Abstractions](./encapsulation/leaky_abstractions.md)
   - [Information Hiding](./encapsulation/information_hiding.md)
 
-# Control Flow V
+
 - [Loops III](./loops_iii.md)
   - [For-each loops](./loops_iii/for_each_loops.md)
   - [Arrays]()
   - [Iterable]()
   - [ArrayList]()
   - [Concurrent Modifications](./loops_iii/concurrent_modifications.md)
   - [Reasons to go back]() <!-- 
-- [Switch III](./switch_iii.md)
-  - [Fallthrough](./switch_iii/fallthrough.md)
-  - [break](./switch_iii/break.md)
-  - [default](./switch_iii/default.md)
-  - [return](./switch_iii/return.md)
-  - [yield](./switch_iii/yield.md)
-- [Recursion](./recursion.md)
-  - [Disclaimer](./recursion/disclaimer.md)
-  - [Base Case](./recursion/base_case.md)
-  - [Comparison to Delegation](./recursion/comparison_to_delegation.md)
-  - [Comparison to Loops](./recursion/comparison_to_loops.md)
-  - [Counting Down](./recursion/counting_down.md)
-  - [Accumulators](./recursion/accumulators.md)
-  - [Recurse Over a String](./recursion/recursing_over_strings.md)
-  - [Recurse Over an Array](./recursion/recursing_over_arrays.md)
+
 
 # Code Structure V
 - [Interface Extension](./interface_extension.md)

src/recursion/accumulators.md

@@ -46,7 +46,7 @@ class Main {
     }
 
     int timesTwo(int x) {
-        timesTwo(x, 0);
+        return timesTwo(x, 0);
     }
 
     void main() {

src/recursion/comparison_to_delegation.md

@@ -2,7 +2,7 @@
 
 A related technique to recursion is "delegation."
 
-This is when you have one method call a different airity
+This is when you have one method call a different arity
 version of itself.
 
 ```java

src/recursion/recursing_over_arrays.md

@@ -1 +1,27 @@
 # Recurse Over an Array
+
+To write a recursive function which acts over each element
+of an array, the technique is the same as with you need to do much the same task as with regular loops,
+just by having your "current index" be a parameter to the function.
+
+```java
+class Main {
+    void printEachTimesEight(int[] nums, int i) {
+        if (i < nums.length) {
+            System.out.println(nums[i] * 8);
+            printEachTimesEight(nums, i + 1);
+        }
+    }
+
+    void printEachTimesEight(int[] nums) {
+        printEachTimesEight(nums, 0);
+    }
+
+    void main() {
+        printEachTimesEight(new int[] { 1, 2, 3 });
+    }
+}
+```
+
+This same general technique can be used to loop over other sorts of collections, like `ArrayList`. In that
+case you would use `.get()` and `.size()` instead of `[]` and `.length`, but the concept is the same.

src/recursion/recursing_over_strings.md

@@ -2,4 +2,25 @@
 
 To write a recursive function which acts over each character
 of a `String` you need to do much the same task as with regular loops,
-just by having your "current index" be a parameter to the 
+just by having your "current index" be a parameter to the function.
+
+```java
+class Main {
+    void printEachUpperCase(String s, int i) {
+        if (i < s.length()) {
+            System.out.println(Character.toUpperCase(s.charAt(i)));
+            printEachUpperCase(s, i + 1);
+        }
+    }
+
+    void printEachUpperCase(String s) {
+        printEachUpperCase(s, 0);
+    }
+    
+    void main() {
+        printEachUpperCase("hello");
+    }
+}
+```
+
+This overload with the index is an example of a function taking an accumulator.

src/switch_iii.md

@@ -8,24 +8,25 @@ But, due to this history, there is another kind of switch that doesn't use arrow
 and instead uses a colon (`:`).
 
 ```java
-boolean shouldBeMainCharacter(String name) {
-    switch (name) {
-        case "Gohan":
-            return true;
-        case "Goku":
-        default:
-            return false;
+class Main {
+    boolean shouldBeMainCharacter(String name) {
+        switch (name) {
+            case "Gohan":
+                return true;
+            case "Goku":
+            default:
+                return false;
+        }
+    }
+
+    void main() {
+        System.out.println(
+            shouldBeMainCharacter("Goku")
+        );
     }
-}
-void main() {
-    System.out.println(
-        shouldBeMainCharacter("Goku")
-    );
 }
 ```
 
 This "C-Style Switch" is important to learn chiefly because, for a long time,
 it was the only switch in Java. Therefore in your coding life you are very likely to
-run into it when reading old code.
-
-It also might be uniquely useful for you once in a blue moon. Who knows.
+run into it.

src/switch_iii/break.md

@@ -1 +1,78 @@
 # break
+
+After each case label in a C-style switch, you should write `break;`.[^cookout]
+
+```java
+class Main {
+    void main() {
+        String name = "Piccolo";
+        switch (name) {
+            case "Squidward":
+                System.out.println("Invited, but not coming.");
+                break;
+
+            case "Piccolo":
+                System.out.println("Coming to the cookout.");
+                break;
+
+            case "Spider-Man":
+                System.out.println("Not coming");
+                break;
+        }
+    }
+}
+```
+
+This is different from breaking out of a loop and won't break out of any surrounding loops.
+
+```java
+class Main {
+    void main() {
+        for (int i = 0; i < 3; i++) {
+            // Will still run 3 times
+            String name = "Piccolo";
+            switch (name) {
+                case "Squidward":
+                    System.out.println("Invited, but not coming.");
+                    break;
+
+                case "Piccolo":
+                    System.out.println("Coming to the cookout.");
+                    break;
+
+                case "Spider-Man":
+                    System.out.println("Not coming");
+                    break;
+            }
+        }
+    }
+}
+```
+
+To break out of surrounding loops you can use a labeled break.
+
+```java
+class Main {
+    void main() {
+        outerLoop:
+        for (int i = 0; i < 3; i++) {
+            String name = "Piccolo";
+            switch (name) {
+                case "Squidward":
+                    System.out.println("Invited, but not coming.");
+                    break;
+
+                case "Piccolo":
+                    System.out.println("Coming to the cookout.");
+                    break outerLoop; // Will break out of the loop
+
+                case "Spider-Man":
+                    System.out.println("Not coming");
+                    break;
+            }
+        }
+    }
+}
+```
+
+[^cookout]: [Who should be invited to the cookout?](https://www.youtube.com/watch?v=64SoFWJHSd8)

src/switch_iii/default.md

@@ -1 +1,65 @@
 # default
+
+Just like with normal switches, C-style switches can have a `default` label
+that matches when no other label does.
+
+```java
+class Main {
+    boolean shouldBeMainCharacter(String name) {
+        switch (name) {
+            case "Gohan":
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    void main() {
+        System.out.println(
+                shouldBeMainCharacter("Goku")
+        );
+    }
+}
+```
+
+If you have a C-style switch over an enum you need this `default` case for exhaustiveness. Java does not
+otherwise accept that you have covered all the cases.
+
+```java,does_not_compile
+enum Technique {
+    KAMEHAMEHA,
+    INSTANT_TRANSMISSION,
+    KAIOKEN,
+    ULTRA_INSTINCT
+}
+
+class Main {
+    boolean didGokuStealItFromSomeoneElse(Technique technique) {
+        switch (technique) {
+            case KAMEHAMEHA:
+                System.out.println("Master Roshi Taught it to him");
+                return true;
+            case INSTANT_TRANSMISSION:
+                System.out.println("Space aliens");
+                return true;
+            case KAIOKEN:
+                System.out.println("King Kai's name is in it!");
+                return true;
+            case ULTRA_INSTINCT:
+                System.out.println("I'd say not");
+                return false;
+            // Even though we covered every option, Java doesn't trust us.
+            // You need a default label or to return later in the function
+            //
+            // default: 
+            //    throw new IllegalStateException("Unexpected: " + technique);
+        }
+    }
+
+    void main() {
+        System.out.println(
+                didGokuStealItFromSomeoneElse(Technique.INSTANT_TRANSMISSION)
+        );
+    }
+}
+```

src/switch_iii/fallthrough.md

@@ -1,4 +1,31 @@
 # Fallthrough
 
-If the code for a given label does not `break`
-or `return` then 
+If the code for a given label does not have a `break` then it will "fall through"
+to the cases below.
+
+This is what makes C-style switches strange. It can occasionaly be useful if the same code should
+run for some or all cases.[^history] 
+
+```java
+class Main {
+    void sayWhoTheyFought(String name) {
+        switch (name) {
+            case "Goku":
+                System.out.println("Fought Pilaf");
+                System.out.println("Fought The Red Ribbon Army");
+            case "Gohan": // "Goku" will fall through to this case
+                System.out.println("Fought Frieza");
+                System.out.println("Fought Cell");
+                System.out.println("Fought Majin Buu");
+        }
+    }
+    
+    void main() {
+        sayWhoTheyFought("Gohan");
+        System.out.println("----------------------");
+        sayWhoTheyFought("Goku");
+    }
+}
+```
+
+[^history]: [This StackExchange Post](https://softwareengineering.stackexchange.com/questions/162615/why-dont-languages-use-explicit-fall-through-on-switch-statements) explains how this came about. I don't have a primary source on the "The reason that C did it that way is that the creators of C intended switch statements to be easy to optimize into a jump table." claim, but it lines up with my biases and preconceptions. Therefore it must be true!