Improve the wording in the function koans

lib/koans/09_functions.ex

@@ -5,57 +5,36 @@ defmodule Functions do
     "Hello, #{name}!"
   end
 
-  koan "Functions take arguments and return values" do
+  koan "Functions map arguments to outputs" do
     assert greet("World") == :__
   end
 
-  def quick_inline_product(a, b), do: a * b
-
-  koan "Short functions can be defined in a single line, but mind the comman and colon" do
-    assert quick_inline_product(2,:__) == 6
-  end
-
-  def will_change(choice) do
-    if choice do
-      :it_was_truthy
-    else
-      "It really wasn't"
-    end
-  end
-
-  koan "Functions can return different things" do
-    assert will_change(true) == :__
-    assert will_change(false) == :__
-  end
-
-  def repeat(times, message) do
-    String.duplicate(message, times)
-  end
-
-  koan "Functions can have more than one arguement" do
-    assert repeat(3, "Hello ") == :__
-  end
-
-  def repeat_again(times \\ 5, message) do
-    String.duplicate(message, times)
-  end
-
-  koan "But sometimes, you may want to default some arguments" do
-    assert repeat_again("Hello ") == :__
+  def multiply(a, b), do: a * b
+  koan "Single line functions are cool, but mind the command and the colon!" do
+    assert multiply(2, :__) == 6
   end
 
   def first(foo, bar), do: "#{foo} and #{bar}"
-  def first(foo), do: "only #{foo}"
+  def first(foo), do: "Only #{foo}"
 
   koan "Functions with the same name are distinguished by the number of arguments they take" do
     assert first("One", "Two") == :__
     assert first("One") == :__
   end
 
+  def repeat_again(message, times \\ 5) do
+    String.duplicate(message, times)
+  end
+
+  koan "Not all arguments are always needed" do
+    assert repeat_again("Hello ") == :__
+    assert repeat_again("Hello ", 2) == :__
+  end
+
   def sum_up(thing) when is_list(thing), do: :entire_list
   def sum_up(_thing), do: :single_thing
 
-  koan "You can 'guard' functions from their arguments" do
+  koan "Functions can be picky and apply to only certain types" do
     assert sum_up([1,2,3]) == :__
     assert sum_up(1) == :__
   end
@@ -63,7 +42,7 @@ defmodule Functions do
   def bigger(a,b) when a >  b, do: "#{a} is bigger than #{b}"
   def bigger(a,b) when a <= b, do: "#{a} is not bigger than #{b}"
 
-  koan "You can also create intricate guards based on the values" do
+  koan "Intricate guards are possible, but be mindful of the reader" do
     assert bigger(10, 5) == :__
     assert bigger(4, 27) == :__
   end
@@ -71,15 +50,12 @@ defmodule Functions do
   def the_length(0), do: "It was zero"
   def the_length(number), do: "The length was #{number}"
 
-  koan "You can also 'guard' with concrete values" do
+  koan "For those individual one-offs, you can even guard on the arguments themselves" do
     assert the_length(0) == :__
-  end
-
-  koan "Or just let the argument roll" do
     assert the_length(5) == :__
   end
 
-  koan "You can also define inline functions and call them with .()" do
+  koan "Little anonymous functions are common, and called with a dot" do
     multiply = fn (a,b) -> a * b end
     assert multiply.(2,3) == :__
   end
@@ -89,16 +65,11 @@ defmodule Functions do
     assert multiply.(2,3) == :__
   end
 
-  def two_arguments(_first, second), do: second
-  koan "You can also show that certain arguments are ignored in the body by adding an underscore" do
-    assert two_arguments(:hi_there, "the other one") == :__
-  end
-
-  def multiply_then_call(number, fun), do: fun.(number*5)
+  def times_five_and_then(number, fun), do: fun.(number*5)
   def square(number), do: number * number
 
-  koan "You can 'capture' functions if you want to pass them around as values. Mind the ampersand '&' and the slash followed by the number of args" do
-    assert multiply_then_call(2, &square/1) == :__
+  koan "You can pass functions around as arguments. Place and '&' before the name and state the arity" do
+    assert times_five_and_then(2, &square/1) == :__
   end
 
   koan "Functions can be combined elegantly with the pipe operator" do