   test "Passing functions as arguments" do
     times_2 = fn (x) -> 2 * x end
     apply = fn (fun, value) -> fun.(value) end
-    
+
     assert apply.(times_2, 8) == 16
   end
-  
+
   test "The & notation" do
     times_2 = &(&1 * 2)
     assert times_2.(9) == 18
-    
+
     multiply = &(&1 * &2)
     assert multiply.(20, 10) == 200
-    
+
     # Elixir will remove the indirection here
     # &(IO.puts(&1))
   end
-  
+
   test "Tuples functions" do
     divrem = fn (a, b) -> { div(a, b), rem(a, b) } end
     assert divrem.(10, 3) == { 3, 1 }
-    
+
     short_divrem = &{div(&1, &2), rem(&1, &2)}
     assert short_divrem.(10, 3) == { 3, 1 }
   end
-  
+
   test "Exercise: Functions-5" do
     original = Enum.map [1,2,3,4], fn x -> x + 2 end
     rewritten = Enum.map [1,2,3,4], &(&1 + 2)
     assert original == rewritten
-    
+
 #    original = Enum.map [1,2,3,4], fn x -> IO.inspect(x) end
 #    rewritten = Enum.map [1,2,3,4], &(IO.inspect(&1))
 #    rewritten = Enum.map [1,2,3,4], &IO.inspect/1
 #    assert original == rewritten
   end
-  
+
   test "Module" do
     # woot, I can define a module here?
     defmodule Times do

      { :ok, opened_file } -> IO.read(opened_file, :all)
      { _, error } -> :file.format_error(error)
    end
    
    output = handle_open.(File.open("koans_test.exs"))
    assert String.contains?(output, "KoansTest")



  # @tag :pending
  test "function declaration and invocation" do
    # declare an anonymous function
    # a and b are /not/ assigned (this doesn't exist in Elixir)
    # but rather, pattern matched
    sum = fn (a, b) -> a + b end
    # use a dot to call anonymous function
    assert sum.(2, 10) == 12

    # the fact that pattern matching is used allows for more complex calls
    tuple_sum = fn { a, b, c, d } -> a + b + c + d end
    assert tuple_sum.({ 10, 100, 1000, 10000 }) == 11110
  end

  test "Function-1 exercise" do
    list_concat = fn (a, b) -> a ++ b end
    assert list_concat.([:a , :b], [:c, :d]) == [:a, :b, :c, :d]

    sum = fn (a, b, c) -> a + b + c end
    assert sum.(1, 2, 3) == 6

    pair_tuple_to_list = fn { a, b } -> [a, b] end
    assert pair_tuple_to_list.({ 1234, 5678 }) == [1234, 5678]
  end

#  @tag :pending
  test "Multiple bodies" do
    # here we have multiple bodies for the same function
