Update docs

docs/tut/crash-course/9-control-flow.md

@@ -1,56 +1,105 @@
 # Control Flow
 
 Eventually you will need a way to dynamically create and destroy UI elements
-resulting from state changes. Vide provides functions to help you do this,
+resulting from source updates. Vide provides functions to help you do this,
 known as *control flow* functions.
 
-These functions return a new source, which holds the instances to be displayed.
+These functions return new sources, which hold the instances to be displayed.
 These sources can be assigned as children, meaning the displayed children
 will update when the input source updates.
 
-One of these functions is `switch()`, used to conditionally show one of a set of
-components.
+Control flow functions are special, because they run their components in a new
+reactive scope, which can be destroyed independently of the reactive scope that
+called the control flow function itself. This means that parts of your app can
+be independently created then destroyed and cleaned.
+
+## show()
+
+The most basic control flow function is `show()`, which is used to conditionally
+show a component.
+
+```lua
+local source = vide.source
+local show = vide.show
+
+local function JoinMenu()
+    local joined = source(false)
+
+    local function JoinButton()
+        return Button {
+            Activated = function() joined(true) end
+        }
+    end
+
+    return create "Frame" {
+        show(function() return not joined() end, JoinButton)
+    }
+end
+```
+
+This will make a button to join if you have not joined already.
+
+You can also pass a third argument, a fallback to show if the condition is falsey.
+
+```lua
+local function JoinMenu()
+    local joined = source(false)
+
+    local function JoinButton()
+        return Button {
+            Activated = function() joined(true) end
+        }
+    end
+
+    local function LeaveButton()
+        return Button {
+            Activated = function() joined(false) end
+        }
+    end
+
+    return create "Frame" {
+        show(joined, LeaveButton, JoinButton)
+    }
+end
+```
+
+## switch()
+
+Similar to `show()`, `switch()`, also condtionally displays one instance at a
+time. It is more flexible since it can show one of many components, based on a
+table used to map a source value to a component.
 
 ```lua
-local vide = require(vide)
 local source = vide.source
 local switch = vide.switch
 
-local function ToggleButton(p: {
-    Text: string,
-    Toggle: (boolean) -> boolean
-})
-    return create "TextButton" {
-        Size = UDim2.fromOffset(300, 300),
-        Text = p.Text,
-        Activated = function()
-            p.Toggle(not p.Toggle())
-        end
-    }
-end
+local function JoinMenu()
+    local joined = source(false)
 
-local loggedIn = source(false)
+    local function JoinButton()
+        return Button {
+            Activated = function() joined(true) end
+        }
+    end
 
-local function LoginMenu()
-    return Frame {
-        switch(loggedIn) {
-            [true] = function()
-                return ToggleButton { Text = "Log out", Toggle = loggedIn }
-            end,
+    local function LeaveButton()
+        return Button {
+            Activated = function() joined(false) end
+        }
+    end
 
-            [false] = function()
-                return ToggleButton { Text = "Log in",  Toggle = loggedIn }
-            end
+    return create "Frame" {
+        switch(joined) {
+            [true] = LeaveButton,
+            [false] = JoinButton
         }
     }
 end
-
-mount(function() return create "ScreenGui" { LoginMenu {} } end, game.StarterGui)
 ```
 
-Above is an example of using a switch to create a login menu. Each time
-`loggedIn` toggles, the current button will be destroyed, and a new button
-created, which the text to represent the current action, to log in or log out.
+Above is an example of using a switch to create a join menu. Each time
+`joined` toggles, the current button will be destroyed, and a new button
+created, which the text to represent the current action, to join or leave.
 
 The callbacks given to control flow functions are ran in a new reactive-scope,
 so any cleanups registered will be ran when the input is changed and a new