wip [ci skip]

Author: iamvery

lib/koans/12_pattern_matching.ex

@@ -166,4 +166,42 @@ defmodule PatternMatching do
       ^a = ___
     end
   end
+
+  koan "Pattern matching works with nested data structures" do
+    user = %{
+      profile: %{
+        personal: %{name: "Alice", age: 30},
+        settings: %{theme: "dark", notifications: true}
+      }
+    }
+
+    %{profile: %{personal: %{name: name}, settings: %{theme: theme}}} = user
+    assert name == ___
+    assert theme == ___
+  end
+
+  koan "Lists can be pattern matched with head and tail" do
+    numbers = [1, 2, 3, 4, 5]
+
+    [first, second | rest] = numbers
+    assert first == ___
+    assert second == ___
+    assert rest == ___
+
+    [head | _tail] = numbers
+    assert head == ___
+  end
+
+  koan "Pattern matching can extract values from function return tuples" do
+    divide = fn
+      _, 0 -> {:error, :division_by_zero}
+      x, y -> {:ok, x / y}
+    end
+
+    {:ok, result} = divide.(10, 2)
+    assert result == ___
+
+    {:error, reason} = divide.(10, 0)
+    assert reason == ___
+  end
 end

lib/koans/13_functions.ex

@@ -110,6 +110,30 @@ defmodule Functions do
     assert result == ___
   end
 
+  koan "Pipes make data transformation pipelines readable" do
+    numbers = [1, 2, 3, 4, 5]
+
+    result =
+      numbers
+      |> Enum.filter(&(&1 > 2))
+      |> Enum.map(&(&1 * 2))
+      |> Enum.sum()
+
+    assert result == ___
+  end
+
+  koan "The pipe operator works with any function that takes the piped value as first argument" do
+    user_input = "  Hello World  "
+
+    cleaned =
+      user_input
+      |> String.trim()
+      |> String.downcase()
+      |> String.replace(" ", "_")
+
+    assert cleaned == ___
+  end
+
   koan "Conveniently keyword lists can be used for function options" do
     transform = fn str, opts ->
       if opts[:upcase] do
@@ -122,4 +146,16 @@ defmodule Functions do
     assert transform.("good", upcase: true) == ___
     assert transform.("good", upcase: false) == ___
   end
+
+  koan "Anonymous functions can use the & capture syntax for very concise definitions" do
+    add_one = &(&1 + 1)
+    multiply_by_two = &(&1 * 2)
+
+    result = 5 |> add_one.() |> multiply_by_two.()
+    assert result == ___
+
+    # You can also capture existing functions
+    string_length = &String.length/1
+    assert string_length.("hello") == ___
+  end
 end

lib/koans/14_enums.ex

@@ -83,4 +83,38 @@ defmodule Enums do
   koan "Collapse an entire list of elements down to a single one by repeating a function." do
     assert Enum.reduce([1, 2, 3], 0, fn element, accumulator -> element + accumulator end) == ___
   end
+
+  koan "Enum.chunk_every splits lists into smaller lists of fixed size" do
+    assert Enum.chunk_every([1, 2, 3, 4, 5, 6], 2) == ___
+    assert Enum.chunk_every([1, 2, 3, 4, 5], 3) == ___
+  end
+
+  koan "Enum.flat_map transforms and flattens in one step" do
+    result =
+      [1, 2, 3]
+      |> Enum.flat_map(&[&1, &1 * 10])
+
+    assert result == ___
+  end
+
+  koan "Enum.group_by organizes elements by a grouping function" do
+    words = ["apple", "banana", "cherry", "apricot", "blueberry"]
+    grouped = Enum.group_by(words, &String.first/1)
+
+    assert grouped["a"] == ___
+    assert grouped["b"] == ___
+  end
+
+  koan "Stream provides lazy enumeration for large datasets" do
+    # Streams are lazy - they don't execute until you call Enum on them
+    stream =
+      1..1_000_000
+      |> Stream.filter(&(rem(&1, 2) == 0))
+      |> Stream.map(&(&1 * 2))
+      |> Stream.take(3)
+
+    # Nothing has been computed yet!
+    result = Enum.to_list(stream)
+    assert result == ___
+  end
 end

lib/koans/18_genservers.ex

@@ -160,4 +160,83 @@ defmodule GenServers do
 
     :ok = Laptop.stop()
   end
+
+  koan "GenServers can handle info messages and timeouts" do
+    defmodule TimeoutServer do
+      use GenServer
+
+      def start_link(timeout) do
+        GenServer.start_link(__MODULE__, timeout, name: __MODULE__)
+      end
+
+      def init(timeout) do
+        {:ok, %{count: 0}, timeout}
+      end
+
+      def get_count do
+        GenServer.call(__MODULE__, :get_count)
+      end
+
+      def handle_call(:get_count, _from, state) do
+        {:reply, state.count, state}
+      end
+
+      def handle_info(:timeout, state) do
+        new_state = %{state | count: state.count + 1}
+        # Reset timeout
+        {:noreply, new_state, 1000}
+      end
+    end
+
+    TimeoutServer.start_link(100)
+    # Wait for timeouts to occur
+    :timer.sleep(250)
+    count = TimeoutServer.get_count()
+    assert count >= 2 == ___
+
+    GenServer.stop(TimeoutServer)
+  end
+
+  koan "GenServers can be supervised and restarted" do
+    defmodule CrashableServer do
+      use GenServer
+
+      def start_link(_) do
+        GenServer.start_link(__MODULE__, 0, name: __MODULE__)
+      end
+
+      def init(initial) do
+        {:ok, initial}
+      end
+
+      def crash do
+        GenServer.cast(__MODULE__, :crash)
+      end
+
+      def get_state do
+        GenServer.call(__MODULE__, :get_state)
+      end
+
+      def handle_call(:get_state, _from, state) do
+        {:reply, state, state}
+      end
+
+      def handle_cast(:crash, _state) do
+        raise "Intentional crash for testing"
+      end
+    end
+
+    # Start under a supervisor
+    {:ok, supervisor} =
+      Supervisor.start_link(
+        [{CrashableServer, []}],
+        strategy: :one_for_one
+      )
+
+    # Server should be running
+    initial_state = CrashableServer.get_state()
+    assert initial_state == ___
+
+    Supervisor.stop(supervisor)
+  end
 end

lib/koans/21_control_flow.ex

@@ -0,0 +1,162 @@
+defmodule ControlFlow do
+  @moduledoc false
+  use Koans
+
+  @intro "Control Flow - Making decisions and choosing paths"
+
+  koan "If statements evaluate conditions" do
+    result = if true, do: "yes", else: "no"
+    assert result == ___
+  end
+
+  koan "If can be written in block form" do
+    result =
+      if 1 + 1 == 2 do
+        "math works"
+      else
+        "math is broken"
+      end
+
+    assert result == ___
+  end
+
+  koan "Unless is the opposite of if" do
+    result = unless false, do: "will execute", else: "will not execute"
+    assert result == ___
+  end
+
+  koan "Nil and false are falsy, everything else is truthy" do
+    assert if(nil, do: "truthy", else: "falsy") == ___
+    assert if(false, do: "truthy", else: "falsy") == ___
+    assert if(0, do: "truthy", else: "falsy") == ___
+    assert if("", do: "truthy", else: "falsy") == ___
+    assert if([], do: "truthy", else: "falsy") == ___
+  end
+
+  koan "Case matches against patterns" do
+    result =
+      case {1, 2, 3} do
+        {4, 5, 6} -> "no match"
+        {1, x, 3} -> "matched with x = #{x}"
+      end
+
+    assert result == ___
+  end
+
+  koan "Case can have multiple clauses with different patterns" do
+    check_number = fn x ->
+      case x do
+        0 -> "zero"
+        n when n > 0 -> "positive"
+        n when n < 0 -> "negative"
+      end
+    end
+
+    assert check_number.(5) == ___
+    assert check_number.(0) == ___
+    assert check_number.(-3) == ___
+  end
+
+  koan "Case clauses are tried in order until one matches" do
+    check_list = fn list ->
+      case list do
+        [] -> "empty"
+        [_] -> "one element"
+        [_, _] -> "two elements"
+        _ -> "many elements"
+      end
+    end
+
+    assert check_list.([]) == ___
+    assert check_list.([:a]) == ___
+    assert check_list.([:a, :b]) == ___
+    assert check_list.([:a, :b, :c, :d]) == ___
+  end
+
+  koan "Cond evaluates conditions until one is truthy" do
+    temperature = 25
+
+    weather =
+      cond do
+        temperature < 0 -> "freezing"
+        temperature < 10 -> "cold"
+        temperature < 25 -> "cool"
+        temperature < 30 -> "warm"
+        true -> "hot"
+      end
+
+    assert weather == ___
+  end
+
+  koan "Cond requires at least one clause to be true" do
+    safe_divide = fn x, y ->
+      cond do
+        y == 0 -> {:error, "division by zero"}
+        true -> {:ok, x / y}
+      end
+    end
+
+    assert safe_divide.(10, 2) == ___
+    assert safe_divide.(10, 0) == ___
+  end
+
+  koan "If/unless can be used as statement modifiers" do
+    x = 5
+    message = if x > 0, do: "x is positive"
+    assert message == ___
+  end
+
+  koan "Case can destructure complex patterns" do
+    parse_response = fn response ->
+      case response do
+        {:ok, %{status: 200, body: body}} -> "Success: #{body}"
+        {:ok, %{status: status}} when status >= 400 -> "Client error: #{status}"
+        {:ok, %{status: status}} when status >= 500 -> "Server error: #{status}"
+        {:error, reason} -> "Request failed: #{reason}"
+      end
+    end
+
+    assert parse_response.({:ok, %{status: 200, body: "Hello"}}) == ___
+    assert parse_response.({:ok, %{status: 404}}) == ___
+    assert parse_response.({:error, :timeout}) == ___
+  end
+
+  koan "Guards in case can use complex expressions" do
+    categorize = fn number ->
+      case number do
+        n when is_integer(n) and n > 0 and rem(n, 2) == 0 -> "positive even integer"
+        n when is_integer(n) and n > 0 and rem(n, 2) == 1 -> "positive odd integer"
+        n when is_integer(n) and n < 0 -> "negative integer"
+        n when is_float(n) -> "float"
+        _ -> "other"
+      end
+    end
+
+    assert categorize.(4) == ___
+    assert categorize.(3) == ___
+    assert categorize.(-5) == ___
+    assert categorize.(3.14) == ___
+    assert categorize.("hello") == ___
+  end
+
+  koan "Multiple conditions can be checked in sequence" do
+    process_user = fn user ->
+      if user.active do
+        if user.verified do
+          if user.premium do
+            "premium verified active user"
+          else
+            "verified active user"
+          end
+        else
+          "unverified active user"
+        end
+      else
+        "inactive user"
+      end
+    end
+
+    user = %{active: true, verified: true, premium: false}
+    assert process_user.(user) == ___
+  end
+end