Beginner

defmodule Hello do
  # Define a public function using `def`
  def world do
    # IO.puts writes to standard output and returns :ok
    IO.puts("Hello, World!") # => :ok (printed output: "Hello, World!")
  end
end

Hello.world() # => :ok

x = 1 # => 1
x # => 1

x = 2 # => 2
x # => 2

y = 1 # => 1
x = 2 # => 2

user_name = "Alice" # => "Alice"
user_age = 30 # => 30

a = b = c = 5 # => 5
a # => 5
b # => 5
c # => 5

list = [1, 2, 3] # => [1, 2, 3]
new_list = [0 | list] # => [0, 1, 2, 3]
list # => [1, 2, 3] (unchanged!)
new_list # => [0, 1, 2, 3]

integer = 42 # => 42
large_integer = 1_000_000_000_000 # => 1000000000000 (underscores for readability)
hex = 0x1F # => 31 (hexadecimal)
binary = 0b1010 # => 10 (binary)

float = 3.14 # => 3.14
scientific = 1.0e-10 # => 1.0e-10

bool_true = true # => true
bool_false = false # => false

atom = :hello # => :hello
atom_with_spaces = :"hello world" # => :"hello world"

string = "Hello, 世界!" # => "Hello, 世界!"
multiline = """
This is a
multiline string
""" # => "This is a\nmultiline string\n"

name = "Alice" # => "Alice"
greeting = "Hello, #{name}!" # => "Hello, Alice!"

is_integer(42) # => true
is_float(3.14) # => true
is_boolean(true) # => true
is_atom(:hello) # => true
is_binary("hello") # => true (strings are binaries)

i 42 # In IEx, shows: Term: 42, Data type: Integer

x = 42 # => 42 (x holds an integer)
x = "hello" # => "hello" (x now holds a string, no error!)
x = :atom # => :atom (x now holds an atom)


defmodule TypeChecker do
  def process_number(value) when is_number(value) do
    value * 2
  end

  # Guards provide runtime type checking in function clauses
  def format_value(val) when is_binary(val) do
    "String: #{val}"
  end

  def format_value(val) when is_integer(val) do
    "Number: #{val}"
  end
end

TypeChecker.process_number(21) # => 42 (works - is_number(21) is true)
TypeChecker.format_value("hello") # => "String: hello"
TypeChecker.format_value(42) # => "Number: 42"

x = 1 # => 1

1 = x # => 1 (works! 1 equals 1)


{a, b, c} = {1, 2, 3} # => {1, 2, 3}
a # => 1
b # => 2
c # => 3

[first, second, third] = [1, 2, 3] # => [1, 2, 3]
first # => 1
second # => 2
third # => 3

{:ok, result} = {:ok, 42} # => {:ok, 42}
result # => 42


{:ok, _} = {:ok, 42} # => {:ok, 42} (42 is ignored)

{_, _, third} = {1, 2, 3} # => {1, 2, 3}
third # => 3

x = 1 # => 1
x = 2 # => 2 (x is now 2)
x # => 2

x = 1 # => 1
^x = 1 # => 1 (works! 1 matches 1)

status = :ok # => :ok

{^status, result} = {:ok, 42} # => {:ok, 42} (works!)
result # => 42


expected_status = :ok # => :ok

defmodule Matcher do
  def match_value(^expected_status, result) do
    # ^ pins expected_status from outer scope - only matches if first arg is :ok
    result
  end
end

Matcher.match_value(:ok, 42) # => 42 (works - first arg matches pinned :ok)

list = [1, 2, 3] # => [1, 2, 3]
[first | _] = list # => [1, 2, 3]
first # => 1

[^first | _] = list # => [1, 2, 3] (works - first element matches pinned value)

[head | tail] = [1, 2, 3, 4, 5] # => [1, 2, 3, 4, 5]
head # => 1
tail # => [2, 3, 4, 5]

[first, second | rest] = [1, 2, 3, 4, 5] # => [1, 2, 3, 4, 5]
first # => 1
second # => 2
rest # => [3, 4, 5]

[head | tail] = [1] # => [1]
head # => 1
tail # => [] (empty list)

user = {"Alice", 30, {:address, "123 Main St", "NYC"}} # => {...}
{name, age, {:address, street, city}} = user # => {...}
name # => "Alice"
age # => 30
street # => "123 Main St"
city # => "NYC"

user_map = %{name: "Bob", age: 25, city: "SF"} # => %{...}
%{name: user_name, city: user_city} = user_map # => %{...}
user_name # => "Bob"
user_city # => "SF"

nested = [[1, 2], [3, 4], [5, 6]] # => [[1, 2], [3, 4], [5, 6]]
[[a, b], [c, d], [e, f]] = nested # => [[1, 2], [3, 4], [5, 6]]
a # => 1
c # => 3
e # => 5

response = {:ok, %{status: 200, body: "Success"}} # => {...}
{:ok, %{status: status_code, body: body}} = response # => {...}
status_code # => 200
body # => "Success"

list = [1, 2, 3] # => [1, 2, 3]

new_list = [0 | list] # => [0, 1, 2, 3]
list # => [1, 2, 3] (unchanged, immutability!)

[1, 2] ++ [3, 4] # => [1, 2, 3, 4]

[1, 2, 3, 2, 1] -- [2] # => [1, 3, 2, 1] (removes first 2)
[1, 2, 3] -- [3, 2] # => [1]

Enum.at([1, 2, 3], 0) # => 1
Enum.at([1, 2, 3], 2) # => 3

length([1, 2, 3, 4, 5]) # => 5

tuple = {1, 2, 3} # => {1, 2, 3}

elem(tuple, 0) # => 1
elem(tuple, 2) # => 3

new_tuple = put_elem(tuple, 1, 999) # => {1, 999, 3}
tuple # => {1, 2, 3} (unchanged!)

tuple_size(tuple) # => 3


{:ok, result} = {:ok, 42} # => {:ok, 42}
{:error, reason} = {:error, "not found"} # => {:error, "not found"}

map = %{"name" => "Alice", "age" => 30} # => %{"age" => 30, "name" => "Alice"}

map["name"] # => "Alice"
map["age"] # => 30
map["missing"] # => nil

user = %{name: "Bob", age: 25, city: "NYC"} # => %{age: 25, city: "NYC", name: "Bob"}

%{name: "Bob"} === %{:name => "Bob"} # => true

user.name # => "Bob"
user.age # => 25

Map.get(user, :name) # => "Bob"
Map.get(user, :missing) # => nil
Map.get(user, :missing, "N/A") # => "N/A" (default)

updated_user = %{user | age: 26} # => %{age: 26, city: "NYC", name: "Bob"}
user # => %{age: 25, city: "NYC", name: "Bob"} (unchanged!)


with_country = Map.put(user, :country, "USA")

without_age = Map.delete(user, :age) # => %{city: "NYC", name: "Bob"}

%{name: person_name} = user # => %{age: 25, city: "NYC", name: "Bob"}
person_name # => "Bob"

%{name: n, age: a} = user # => %{...}

nested = %{user: %{profile: %{bio: "Hello"}}} # => %{...}
updated_nested = put_in(nested, [:user, :profile, :bio], "Hi there!")

keyword = [name: "Alice", age: 30] # => [name: "Alice", age: 30]

keyword === [{:name, "Alice"}, {:age, 30}] # => true

options = [timeout: 1000, timeout: 2000] # => [timeout: 1000, timeout: 2000]

Keyword.get(keyword, :name) # => "Alice"
Keyword.get(keyword, :missing) # => nil
Keyword.get(keyword, :missing, "default") # => "default"

Keyword.get(options, :timeout) # => 1000

Keyword.get_values(options, :timeout) # => [1000, 2000]

defmodule Server do
  def start(name, opts \\ []) do
    # Extract options with defaults
    port = Keyword.get(opts, :port, 8080) # => 8080 if not provided
    timeout = Keyword.get(opts, :timeout, 5000) # => 5000 if not provided
    {name, port, timeout}
  end
end

Server.start("MyServer") # => {"MyServer", 8080, 5000}
Server.start("MyServer", port: 3000) # => {"MyServer", 3000, 5000}
Server.start("MyServer", port: 3000, timeout: 10000) # => {"MyServer", 3000, 10000}

[name: n, age: a] = [name: "Bob", age: 25] # => [name: "Bob", age: 25]
n # => "Bob"
a # => 25

add = fn a, b -> a + b end # => #Function<...>

add.(5, 3) # => 8

fizzbuzz = fn
  0, 0, _ -> "FizzBuzz"
  0, _, _ -> "Fizz"
  _, 0, _ -> "Buzz"
  _, _, x -> x
end

fizzbuzz.(0, 0, 1) # => "FizzBuzz"
fizzbuzz.(0, 1, 2) # => "Fizz"
fizzbuzz.(1, 0, 3) # => "Buzz"
fizzbuzz.(1, 1, 4) # => 4

multiply = &(&1 * &2) # => #Function<...>
multiply.(4, 5) # => 20

int_to_string = &Integer.to_string/1 # => &Integer.to_string/1
int_to_string.(42) # => "42"

apply_twice = fn f, x -> f.(f.(x)) end # => #Function<...>
increment = fn x -> x + 1 end # => #Function<...>
apply_twice.(increment, 5) # => 7 (5 + 1 + 1)

multiplier = fn factor ->
  fn x -> x * factor end
end
double = multiplier.(2) # => #Function<...>
triple = multiplier.(3) # => #Function<...>
double.(5) # => 10
triple.(5) # => 15

numbers = [1, 2, 3, 4, 5] # => [1, 2, 3, 4, 5]

Enum.map(numbers, fn x -> x * 2 end) # => [2, 4, 6, 8, 10]
Enum.filter(numbers, fn x -> rem(x, 2) == 0 end) # => [2, 4]
Enum.reduce(numbers, 0, fn x, acc -> x + acc end) # => 15

Enum.map(numbers, &(&1 * 2)) # => [2, 4, 6, 8, 10]
Enum.filter(numbers, &(rem(&1, 2) == 0)) # => [2, 4]

defmodule Math do
  # Public function with def
  def add(a, b) do
    a + b
  end

  # Single-line syntax for simple functions
  def subtract(a, b), do: a - b

  # Private function with defp (only callable within module)
  defp internal_multiply(a, b), do: a * b

  # Multi-clause functions (pattern matching)
  def describe(0), do: "zero"
  def describe(n) when n > 0, do: "positive"
  def describe(n) when n < 0, do: "negative"

  # Default arguments with \\
  def greet(name, greeting \\ "Hello") do
    "#{greeting}, #{name}!"
  end

  # Recursive functions
  def factorial(0), do: 1
  def factorial(n) when n > 0, do: n * factorial(n - 1)

  # Pattern matching in function heads
  def sum_list([]), do: 0
  def sum_list([head | tail]), do: head + sum_list(tail)

  # Guards for validation
  def divide(_, 0), do: {:error, "division by zero"}
  def divide(a, b) when is_number(a) and is_number(b) do
    {:ok, a / b}
  end
end

Math.add(5, 3) # => 8
Math.subtract(10, 4) # => 6

Math.describe(0) # => "zero"
Math.describe(5) # => "positive"
Math.describe(-3) # => "negative"

Math.greet("Alice") # => "Hello, Alice!" (default greeting)
Math.greet("Bob", "Hi") # => "Hi, Bob!" (custom greeting)

Math.factorial(5) # => 120
Math.sum_list([1, 2, 3, 4]) # => 10

Math.divide(10, 2) # => {:ok, 5.0}
Math.divide(10, 0) # => {:error, "division by zero"}

defmodule Example do
  def func(a), do: a
  def func(a, b), do: a + b
end

Example.func(5) # => 5
Example.func(3, 4) # => 7

result = String.upcase(String.trim("  hello  ")) # => "HELLO"

result = "  hello  "
         |> String.trim()      # => "hello"
         |> String.upcase()    # => "HELLO"

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

sum = Enum.reduce(
  Enum.filter(
    Enum.map(numbers, fn x -> x * x end),
    fn x -> rem(x, 2) == 0 end
  ),
  0,
  fn x, acc -> x + acc end
) # => 220 (4 + 16 + 36 + 64 + 100)

sum = numbers
      |> Enum.map(fn x -> x * x end)           # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
      |> Enum.filter(fn x -> rem(x, 2) == 0 end) # => [4, 16, 36, 64, 100]
      |> Enum.reduce(0, fn x, acc -> x + acc end) # => 220

"hello" |> String.upcase() # => "HELLO"

5 |> (&(&1 * 2)).() # => 10
"world" |> String.duplicate(3) # => "worldworldworld"

user_names = [
  "  Alice  ",
  "  bob  ",
  " CHARLIE ",
  "  dave  "
]

formatted_names = user_names
                  |> Enum.map(&String.trim/1)           # => ["Alice", "bob", "CHARLIE", "dave"]
                  |> Enum.map(&String.capitalize/1)     # => ["Alice", "Bob", "Charlie", "Dave"]
                  |> Enum.sort()                        # => ["Alice", "Bob", "Charlie", "Dave"]
                  |> Enum.join(", ")                    # => "Alice, Bob, Charlie, Dave"

{:ok, value} = {:ok, 42}
result = value
         |> (&(&1 * 2)).() # => 84
         |> Integer.to_string() # => "84"

user_status = {:ok, "Alice"}

result = case user_status do
  {:ok, name} -> "Welcome, #{name}!"           # => "Welcome, Alice!"
  {:error, reason} -> "Error: #{reason}"
  _ -> "Unknown status"
end
result # => "Welcome, Alice!"

number = 15

classification = case number do
  n when n < 0 -> "negative"
  0 -> "zero"
  n when n > 0 and n <= 10 -> "small positive"
  n when n > 10 and n <= 100 -> "medium positive"
  n when n > 100 -> "large positive"
end
classification # => "medium positive"


age = 25

description = cond do
  age < 13 -> "child"
  age < 20 -> "teenager"
  age < 60 -> "adult"
  age >= 60 -> "senior"
  true -> "unknown" # Default case (always true)
end
description # => "adult"

score = 85

grade = cond do
  score >= 90 -> "A"
  score >= 80 -> "B"
  score >= 70 -> "C"
  score >= 60 -> "D"
  true -> "F"
end
grade # => "B"


http_response = {:ok, 200, "Success"}

message = case http_response do
  {:ok, 200, body} -> "OK: #{body}"
  {:ok, 404, _} -> "Not Found"
  {:ok, 500, _} -> "Server Error"
  {:error, reason} -> "Failed: #{reason}"
  _ -> "Unknown response"
end
message # => "OK: Success"

income = 50000
has_debt = false

loan_status = cond do
  income < 20000 -> "Not eligible - income too low"
  has_debt -> "Not eligible - existing debt"
  income >= 20000 and income < 50000 -> "Eligible for $10k loan"
  income >= 50000 -> "Eligible for $50k loan"
  true -> "Unknown status"
end
loan_status # => "Eligible for $50k loan"

defmodule Recursion do
  # Basic recursion - factorial
  def factorial(0), do: 1  # Base case
  def factorial(n) when n > 0 do
    n * factorial(n - 1)   # Recursive case
  end

  # Tail-recursive factorial (optimized)
  def factorial_tail(n), do: factorial_tail(n, 1)

  defp factorial_tail(0, acc), do: acc  # Base case with accumulator
  defp factorial_tail(n, acc) when n > 0 do
    factorial_tail(n - 1, n * acc)  # Tail call - last operation is recursive call
  end

  # Sum list recursively
  def sum([]), do: 0  # Base case - empty list
  def sum([head | tail]) do
    head + sum(tail)  # Recursive case - process head, recurse on tail
  end

  # Length of list
  def length([]), do: 0
  def length([_ | tail]), do: 1 + length(tail)

  # Reverse list (not tail-recursive)
  def reverse([]), do: []
  def reverse([head | tail]) do
    reverse(tail) ++ [head]  # Inefficient - appends to end each time
  end

  # Reverse list (tail-recursive, efficient)
  def reverse_tail(list), do: reverse_tail(list, [])

  defp reverse_tail([], acc), do: acc
  defp reverse_tail([head | tail], acc) do
    reverse_tail(tail, [head | acc])  # Prepend to accumulator (O(1))
  end

  # Map function - transform each element
  def map([], _func), do: []
  def map([head | tail], func) do
    [func.(head) | map(tail, func)]
  end

  # Filter function - keep elements matching predicate
  def filter([], _func), do: []
  def filter([head | tail], func) do
    if func.(head) do
      [head | filter(tail, func)]
    else
      filter(tail, func)
    end
  end
end

Recursion.factorial(5) # => 120 (5 * 4 * 3 * 2 * 1)

Recursion.factorial_tail(5) # => 120
Recursion.factorial_tail(10000) # => huge number (works without stack overflow!)

Recursion.sum([1, 2, 3, 4, 5]) # => 15

Recursion.length([1, 2, 3]) # => 3

Recursion.reverse([1, 2, 3]) # => [3, 2, 1]
Recursion.reverse_tail([1, 2, 3]) # => [3, 2, 1] (faster for large lists)

Recursion.map([1, 2, 3], fn x -> x * 2 end) # => [2, 4, 6]

Recursion.filter([1, 2, 3, 4, 5], fn x -> rem(x, 2) == 0 end) # => [2, 4]

numbers = [1, 2, 3, 4, 5]

doubled = Enum.map(numbers, fn x -> x * 2 end) # => [2, 4, 6, 8, 10]

evens = Enum.filter(numbers, fn x -> rem(x, 2) == 0 end) # => [2, 4]
odds = Enum.filter(numbers, fn x -> rem(x, 2) != 0 end) # => [1, 3, 5]

sum = Enum.reduce(numbers, 0, fn x, acc -> x + acc end) # => 15
product = Enum.reduce(numbers, 1, fn x, acc -> x * acc end) # => 120

Enum.each(numbers, fn x -> IO.puts(x) end) # Prints 1\n2\n3\n4\n5\n, returns :ok

first_even = Enum.find(numbers, fn x -> rem(x, 2) == 0 end) # => 2
missing = Enum.find(numbers, fn x -> x > 10 end) # => nil

count = Enum.count(numbers) # => 5
count_evens = Enum.count(numbers, fn x -> rem(x, 2) == 0 end) # => 2

sum = Enum.sum(numbers) # => 15
product = Enum.product(numbers) # => 120

sorted = Enum.sort([3, 1, 4, 1, 5, 9]) # => [1, 1, 3, 4, 5, 9]
sorted_desc = Enum.sort([3, 1, 4], fn a, b -> a > b end) # => [4, 3, 1]

first_three = Enum.take(numbers, 3) # => [1, 2, 3]
last_two = Enum.drop(numbers, 3) # => [4, 5]

names = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]
zipped = Enum.zip(names, ages) # => [{"Alice", 30}, {"Bob", 25}, {"Charlie", 35}]

nested = [[1, 2], [3, 4], [5, 6]]
flattened = Enum.flat_map(nested, fn x -> x end) # => [1, 2, 3, 4, 5, 6]

words = ["apple", "ant", "banana", "bear", "cherry"]
grouped = Enum.group_by(words, fn word -> String.first(word) end)

result = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
         |> Enum.filter(fn x -> rem(x, 2) == 0 end)  # => [2, 4, 6, 8, 10]
         |> Enum.map(fn x -> x * x end)              # => [4, 16, 36, 64, 100]
         |> Enum.sum()                               # => 220

Enum.to_list(1..10) # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Enum.map(1..5, fn x -> x * x end) # => [1, 4, 9, 16, 25]

user_map = %{name: "Alice", age: 30, city: "NYC"}
Enum.map(user_map, fn {k, v} -> {k, v} end) # => [age: 30, city: "NYC", name: "Alice"]
Enum.filter(user_map, fn {_k, v} -> is_number(v) end) # => [age: 30]

# Create ranges
range1 = 1..10 # => 1..10 (includes both endpoints)
range2 = 1..10//1 # => 1..10//1 (explicit step of 1)
range3 = 10..1//-1 # => 10..1//-1 (descending range, step -1)

# Check if value in range
5 in 1..10 # => true
15 in 1..10 # => false
0 in 1..10 # => false

# Convert to list
Enum.to_list(1..5) # => [1, 2, 3, 4, 5]
Enum.to_list(10..1//-1) # => [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

# Ranges with steps
evens = 0..10//2 # => 0..10//2
Enum.to_list(evens) # => [0, 2, 4, 6, 8, 10]

odds = 1..10//2 # => 1..10//2
Enum.to_list(odds) # => [1, 3, 5, 7, 9]

# Range size
Enum.count(1..100) # => 100
Enum.count(1..10//2) # => 5

# Use ranges with Enum
Enum.map(1..5, fn x -> x * x end) # => [1, 4, 9, 16, 25]
Enum.filter(1..20, fn x -> rem(x, 3) == 0 end) # => [3, 6, 9, 12, 15, 18]
Enum.sum(1..10) # => 55 (1+2+3+...+10)

# Pattern matching with ranges
case 5 do
  x when x in 1..10 -> "In range" # => "In range" (matches!)
  _ -> "Out of range"
end

# Ranges in for comprehensions
for x <- 1..5, do: x * 2 # => [2, 4, 6, 8, 10]

# Character ranges
Enum.to_list(?a..?z) # => [97, 98, 99, ..., 122] (ASCII codes)
Enum.map(?a..?z, fn c -> <<c>> end) # => ["a", "b", "c", ..., "z"]

# Reverse a range
Enum.reverse(1..5) # => [5, 4, 3, 2, 1]

# Take from range
Enum.take(1..100, 5) # => [1, 2, 3, 4, 5]
Enum.take(1..100, -3) # => [98, 99, 100] (last 3)

# Random from range
Enum.random(1..100) # => 42 (varies - random number between 1 and 100)

# Basic interpolation
name = "Alice" # => "Alice"
"Hello, #{name}!" # => "Hello, Alice!"

# Multiple variables
first = "Bob" # => "Bob"
last = "Smith" # => "Smith"
"Full name: #{first} #{last}" # => "Full name: Bob Smith"

# Expressions in interpolation
x = 10 # => 10
y = 20 # => 20
"Sum: #{x + y}" # => "Sum: 30"
"Product: #{x * y}" # => "Product: 200"

# Function calls in interpolation
"Uppercase: #{String.upcase("hello")}" # => "Uppercase: HELLO"
"Length: #{String.length("Elixir")}" # => "Length: 6"

# Nested interpolation
user = %{name: "Charlie", age: 25} # => %{age: 25, name: "Charlie"}
"User: #{user.name}, Age: #{user.age}" # => "User: Charlie, Age: 25"

# Conditional expressions
status = :active # => :active
"Status: #{if status == :active, do: "Active", else: "Inactive"}" # => "Status: Active"

# Case expressions
level = 5 # => 5
"Level: #{case level do
  n when n < 5 -> "Beginner"
  n when n < 10 -> "Intermediate"
  _ -> "Advanced"
end}" # => "Level: Intermediate"

# List interpolation (inspect required)
numbers = [1, 2, 3] # => [1, 2, 3]
"Numbers: #{inspect(numbers)}" # => "Numbers: [1, 2, 3]"

# Map interpolation
data = %{a: 1, b: 2} # => %{a: 1, b: 2}
"Data: #{inspect(data)}" # => "Data: %{a: 1, b: 2}"

# Multiline string with interpolation
greeting = """
Hello, #{name}!
Welcome to Elixir.
Your age is #{user.age}.
""" # => "Hello, Alice!\nWelcome to Elixir.\nYour age is 25.\n"

# Pipe operator in interpolation
result = "Result: #{1..10 |> Enum.filter(&(rem(&1, 2) == 0)) |> Enum.sum()}"
result # => "Result: 30"

# Escaping interpolation
"The syntax is: \#{variable}" # => "The syntax is: #{variable}"

# Empty interpolation
"Value: #{nil}" # => "Value: " (nil converts to empty string)
"Value: #{[]}" # => "Value: []"

# Boolean interpolation
"Active: #{true}" # => "Active: true"
"Inactive: #{false}" # => "Inactive: false"

# Atom interpolation
"Status: #{:ok}" # => "Status: ok"

# Prepend with | operator (O(1) - constant time)
list = [2, 3, 4] # => [2, 3, 4]
new_list = [1 | list] # => [1, 2, 3, 4]
list # => [2, 3, 4] (unchanged - immutability!)

# Multiple prepends
[0 | [1 | [2 | [3]]]] # => [0, 1, 2, 3]

# Destructure with pattern matching
[head | tail] = [1, 2, 3, 4, 5] # => [1, 2, 3, 4, 5]
head # => 1
tail # => [2, 3, 4, 5]

# Extract multiple elements
[first, second | rest] = [1, 2, 3, 4, 5] # => [1, 2, 3, 4, 5]
first # => 1
second # => 2
rest # => [3, 4, 5]

# Single element list
[head | tail] = [42] # => [42]
head # => 42
tail # => []

# Empty list pattern
[head | tail] = [] # => ** (MatchError) - can't match empty list

# List concatenation ++ (O(n) - linear time)
[1, 2] ++ [3, 4] # => [1, 2, 3, 4]
[1] ++ [2] ++ [3] # => [1, 2, 3]

# List subtraction -- (removes first occurrence)
[1, 2, 3, 2, 1] -- [2] # => [1, 3, 2, 1] (first 2 removed)
[1, 2, 3, 4, 5] -- [2, 4] # => [1, 3, 5]

# Membership check
1 in [1, 2, 3] # => true
5 in [1, 2, 3] # => false

# Build list with prepends (efficient)
defmodule ListBuilder do
  def build_reverse(0, acc), do: acc
  def build_reverse(n, acc) when n > 0 do
    build_reverse(n - 1, [n | acc]) # => Prepend is O(1)
  end
end

ListBuilder.build_reverse(5, []) # => [1, 2, 3, 4, 5]

# Improper list (rarely used)
[1 | 2] # => [1 | 2] (tail is not a list!)
[1, 2 | 3] # => [1, 2 | 3]

# Pattern matching in functions
defmodule Sum do
  def sum([]), do: 0 # => Base case
  def sum([head | tail]) do
    head + sum(tail) # => Recursive case
  end
end

Sum.sum([1, 2, 3, 4, 5]) # => 15

# Nested lists
[[1, 2], [3, 4]] # => [[1, 2], [3, 4]]
[head | tail] = [[1, 2], [3, 4]] # => [[1, 2], [3, 4]]
head # => [1, 2]
tail # => [[3, 4]]

# Basic if expression
x = 10 # => 10
result = if x > 5 do
  "Greater than 5" # => "Greater than 5"
else
  "Less than or equal to 5"
end
result # => "Greater than 5"

# If without else (returns nil if false)
if true, do: "Yes" # => "Yes"
if false, do: "No" # => nil

# One-line syntax
if 2 + 2 == 4, do: "Math works", else: "Math broken" # => "Math works"

# Unless (opposite of if)
unless false, do: "This runs" # => "This runs"
unless true, do: "This doesn't run" # => nil

# Unless with else
unless 5 > 10 do
  "5 is not greater than 10" # => "5 is not greater than 10"
else
  "5 is greater than 10"
end

# Nested if
age = 25 # => 25
category = if age < 18 do
  "Minor"
else
  if age < 65 do
    "Adult" # => "Adult"
  else
    "Senior"
  end
end
category # => "Adult"

# If with pattern matching
user = {:ok, "Alice"} # => {:ok, "Alice"}
if match?({:ok, _name}, user) do
  {:ok, name} = user
  "Welcome, #{name}!" # => "Welcome, Alice!"
else
  "Error"
end

# Truthy values (everything except false and nil)
if 0, do: "Zero is truthy" # => "Zero is truthy"
if "", do: "Empty string is truthy" # => "Empty string is truthy"
if [], do: "Empty list is truthy" # => "Empty list is truthy"
if nil, do: "Nil is truthy", else: "Nil is falsy" # => "Nil is falsy"
if false, do: "False is truthy", else: "False is falsy" # => "False is falsy"

# If as last expression in function
defmodule Validator do
  def check_age(age) do
    if age >= 18 do
      {:ok, "Adult"} # => Returns this tuple if true
    else
      {:error, "Minor"}
    end
  end
end

Validator.check_age(25) # => {:ok, "Adult"}
Validator.check_age(15) # => {:error, "Minor"}

# Assign result of if
status = :active # => :active
message = if status == :active, do: "Running", else: "Stopped"
message # => "Running"

# Guard-like conditions
x = 5 # => 5
if is_integer(x) and x > 0, do: "Positive integer" # => "Positive integer"

# Unless for negative conditions (more readable)
if not (x == 0), do: "Not zero" # => Less readable
unless x == 0, do: "Not zero" # => More readable

# Multiple clauses with different patterns
defmodule Math do
  def abs(n) when n < 0, do: -n # => First clause: negative numbers
  def abs(n) when n >= 0, do: n # => Second clause: positive and zero
end

Math.abs(-5) # => 5
Math.abs(10) # => 10
Math.abs(0) # => 0

# Pattern matching on data types
defmodule TypeHandler do
  def handle(x) when is_integer(x), do: "Integer: #{x}"
  def handle(x) when is_binary(x), do: "String: #{x}"
  def handle(x) when is_atom(x), do: "Atom: #{inspect(x)}"
  def handle(_), do: "Unknown type"
end

TypeHandler.handle(42) # => "Integer: 42"
TypeHandler.handle("hello") # => "String: hello"
TypeHandler.handle(:ok) # => "Atom: :ok"
TypeHandler.handle([1, 2]) # => "Unknown type"

# Pattern matching on tuples
defmodule Response do
  def format({:ok, data}), do: "Success: #{data}"
  def format({:error, reason}), do: "Error: #{reason}"
  def format(_), do: "Unknown response"
end

Response.format({:ok, "Data loaded"}) # => "Success: Data loaded"
Response.format({:error, "Not found"}) # => "Error: Not found"
Response.format(:unknown) # => "Unknown response"

# Pattern matching on lists
defmodule ListOps do
  def first([]), do: nil # => Empty list
  def first([head | _tail]), do: head # => Non-empty list
end

ListOps.first([1, 2, 3]) # => 1
ListOps.first([]) # => nil

# Combining patterns and guards
defmodule Grade do
  def letter_grade(score) when score >= 90, do: "A"
  def letter_grade(score) when score >= 80, do: "B"
  def letter_grade(score) when score >= 70, do: "C"
  def letter_grade(score) when score >= 60, do: "D"
  def letter_grade(_score), do: "F"
end

Grade.letter_grade(95) # => "A"
Grade.letter_grade(75) # => "C"
Grade.letter_grade(55) # => "F"

# Different arities (different number of arguments)
defmodule Greeter do
  def greet(name), do: "Hello, #{name}!"
  def greet(name, greeting), do: "#{greeting}, #{name}!"
end

Greeter.greet("Alice") # => "Hello, Alice!"
Greeter.greet("Bob", "Hi") # => "Hi, Bob!"

# Map pattern matching
defmodule UserHandler do
  def role(%{role: :admin}), do: "Administrator"
  def role(%{role: :user}), do: "Regular User"
  def role(_), do: "Guest"
end

UserHandler.role(%{role: :admin, name: "Alice"}) # => "Administrator"
UserHandler.role(%{role: :user, name: "Bob"}) # => "Regular User"
UserHandler.role(%{name: "Charlie"}) # => "Guest"

# Recursive clauses with pattern matching
defmodule Factorial do
  def calc(0), do: 1 # => Base case
  def calc(n) when n > 0, do: n * calc(n - 1) # => Recursive case
end

Factorial.calc(5) # => 120

# Order matters! Specific before general
defmodule OrderMatters do
  # CORRECT order: specific first
  def classify(0), do: "Zero"
  def classify(n) when n < 0, do: "Negative"
  def classify(n) when n > 0, do: "Positive"

  # WRONG order would be:
  # def classify(n), do: "Number"  # This would match everything!
  # def classify(0), do: "Zero"    # Never reached
end

OrderMatters.classify(0) # => "Zero"
OrderMatters.classify(-5) # => "Negative"
OrderMatters.classify(10) # => "Positive"

# Basic default argument
defmodule Greeter do
  def greet(name, greeting \\ "Hello") do
    "#{greeting}, #{name}!"
  end
end

Greeter.greet("Alice") # => "Hello, Alice!" (uses default)
Greeter.greet("Bob", "Hi") # => "Hi, Bob!" (overrides default)

# Multiple default arguments
defmodule Server do
  def start(name, port \\ 8080, timeout \\ 5000) do
    {name, port, timeout}
  end
end

Server.start("MyServer") # => {"MyServer", 8080, 5000}
Server.start("MyServer", 3000) # => {"MyServer", 3000, 5000}
Server.start("MyServer", 3000, 10000) # => {"MyServer", 3000, 10000}

# Default with expressions (evaluated at call time)
defmodule Logger do
  def log(message, timestamp \\ DateTime.utc_now()) do
    "#{timestamp}: #{message}"
  end
end

Logger.log("Event happened") # => "2024-12-23 10:30:45Z: Event happened"
:timer.sleep(1000)
Logger.log("Another event") # => "2024-12-23 10:30:46Z: Another event" (different time!)

# Default arguments with pattern matching
defmodule User do
  def create(name, age \\ 0, role \\ :user) do
    %{name: name, age: age, role: role}
  end
end

User.create("Alice") # => %{age: 0, name: "Alice", role: :user}
User.create("Bob", 25) # => %{age: 25, name: "Bob", role: :user}
User.create("Charlie", 30, :admin) # => %{age: 30, name: "Charlie", role: :admin}

# Defaults with guards
defmodule Calculator do
  def divide(a, b \\ 1) when b != 0 do
    a / b
  end
end

Calculator.divide(10) # => 10.0 (10 / 1)
Calculator.divide(10, 2) # => 5.0

# Default arguments in multiple clauses (tricky!)
defmodule MultiClause do
  # When using defaults with multiple clauses, define a function head
  def process(data, opts \\ [])
  def process(data, opts) when is_list(opts) do
    {data, Keyword.get(opts, :mode, :default)}
  end
end

MultiClause.process("data") # => {"data", :default}
MultiClause.process("data", mode: :custom) # => {"data", :custom}

# Default with map/struct
defmodule Config do
  def build(name, opts \\ %{}) do
    Map.merge(%{timeout: 5000, retries: 3}, opts)
    |> Map.put(:name, name)
  end
end

Config.build("app") # => %{name: "app", retries: 3, timeout: 5000}
Config.build("app", %{timeout: 10000}) # => %{name: "app", retries: 3, timeout: 10000}

# Default empty list for accumulator
defmodule ListOps do
  def reverse(list, acc \\ [])
  def reverse([], acc), do: acc
  def reverse([head | tail], acc) do
    reverse(tail, [head | acc])
  end
end

ListOps.reverse([1, 2, 3]) # => [3, 2, 1]

# Keyword list defaults
defmodule Builder do
  def build(name, opts \\ [timeout: 5000, async: false]) do
    timeout = Keyword.get(opts, :timeout)
    async = Keyword.get(opts, :async)
    {name, timeout, async}
  end
end

Builder.build("task") # => {"task", 5000, false}
Builder.build("task", timeout: 10000) # => {"task", 10000, false}