Extract answers from PatternMatching module

lib/koans/09_pattern_matching.ex

@@ -2,56 +2,60 @@ defmodule PatternMatching do
   use Koans
 
   koan "one matches one" do
-    assert match?(1, 1)
+    assert match?(1, :__)
   end
 
   koan "a pattern can change" do
     a = 1
-    assert a = 2
+    assert a = :__
   end
 
+  # TODO not sure about this koan?
   koan "a pattern can also be strict" do
     a = 1
-    assert ^a = 2
+    assert ^a = :__
   end
 
   koan "patterns can be used to pull things apart" do
-    [head | tail] = [1,2,3,4]
+    [head | _tail] = [1,2,3,4]
 
-    assert head == 1
-    assert tail == [2,3,4]
+    assert head == :__
   end
 
-  koan "or put them back together" do
+  koan "...whichever side you actually need" do
+    [_head | tail] = [1,2,3,4]
+
+    assert tail == :__
+  end
+
+
+  koan "and then put them back together" do
     head = 1
     tail = [2,3,4]
 
-    assert [1,2,3,4] == [head | tail]
+    assert :__ == [head | tail]
   end
 
   koan "Some values can be irrelevant" do
     [_first, _second, third, _fourth] = [1,2,3,4]
 
-    assert third == 3
+    assert third == :__
   end
 
   koan "strings come apart just a easily" do
     "Shopping list: " <> items = "Shopping list: eggs, milk"
 
-    assert items == "eggs, milk"
+    assert items == :__
   end
 
   koan "patterns show what you really care about" do
     %{make: make} = %{type: "car", year: 2016, make: "Honda", color: "black"}
 
-    assert make == "Honda"
+    assert make == :__
   end
 
   koan "the pattern can make assertions about what it expects" do
-    the_list = [1, 2, 3]
-
-    assert match?([1, _, _], the_list)
-    refute match?([2, _, _], the_list)
+    assert match?([1, _, _], :__)
   end
 
   def make_noise(%{type: "cat"}), do: "Meow"
@@ -60,20 +64,26 @@ defmodule PatternMatching do
 
   koan "functions can declare what kind of arguments they accept" do
     dog = %{type: "dog", legs: 4, age: 9, color: "brown"}
-    cat = %{type: "cat", legs: 4, age: 3, color: "grey"}
-    snake = %{type: "snake", legs: 0, age: 20, color: "black"}
 
-    assert make_noise(dog) == "Woof"
-    assert make_noise(cat) == "Meow"
-    assert make_noise(snake) == "Eh?"
+    assert make_noise(dog) == :__
+  end
+
+  koan "...and for cats..." do
+    cat = %{type: "cat", legs: 4, age: 3, color: "grey"}
+    assert make_noise(cat) == :__
+  end
+
+  koan "...and for snakes..." do
+    snake = %{type: "snake", legs: 0, age: 20, color: "black"}
+    assert make_noise(snake) == :__
   end
 
   koan "errors are shaped differently than sucessful results" do
     result = case Map.fetch(%{}, :obviously_not_a_key) do
-      {:ok, val} -> val
       :error -> "not present"
+      _ -> flunk("I should not happen")
     end
 
-    assert result == "not present"
+    assert result == :__
   end
 end