defmodule MyProject.Main do
  def hello do
    IO.puts "Hello, World!"
  end
end
 
# Run function
MyProject.Main.hello()

# This is a single-line comment in Elixir.
 
# There is no native multi-line comment block;
# each line in a multi-line comment block must start with '#'
 
@doc "Documentation for functions, used by ExDoc"
def documented_function do
end

# Variables are bound to values. They can be rebound, but the data is immutable.
name = "VR Rathod"
age = 25
 
# Atoms (Constants whose name is their value, similar to Symbols in Ruby)
:ok
:error
:not_found
 
# Booleans are just atoms underneath:
# true is equivalent to :true
# false is equivalent to :false

# In Elixir, '=' is the match operator, not assignment
x = 1 // Matches x with 1. Since x is unbound, it binds to 1.
 
# Match check
1 = x // Matches 1 with value of x (1). Success!
# 2 = x // Raises MatchError

# Destructure Tuple
{status, result} = {:ok, "success"} // status = :ok, result = "success"
 
# Destructure List
[head | tail] = [1, 2, 3] // head = 1, tail = [2, 3]

# Use pin operator to match against a variable's existing value rather than rebinding it.
x = 10
# {^x, y} = {20, 30} // Raises MatchError (expects first element to be 10)
{^x, y} = {10, 30} // y = 30

# 1. If
if age >= 18 do
  "Adult"
else
  "Minor"
end
 
# 2. Unless (negated if)
unless is_authorized do
  "Access Denied"
end
 
# 3. Cond (evaluates first expression that evaluates to truthy)
cond do
  score >= 90 -> "Grade A"
  score >= 80 -> "Grade B"
  true        -> "Grade F" # default fallback
end

# Match on structural shape and values
case File.read("data.txt") do
  {:ok, contents} -> IO.puts("Contents: #{contents}")
  {:error, :enoent} -> IO.puts("File not found.")
  {:error, reason}  -> IO.puts("Failed: #{reason}")
end

# with sequences matching steps. If any step fails to match,
# it breaks early and returns the unmatched term.
with {:ok, user} <- get_user(1),
     {:ok, profile} <- get_profile(user.id),
     {:ok, address} <- parse_address(profile.address) do
  {:ok, {user, address}}
else
  {:error, reason} -> {:error, "Chaining failed due to: #{reason}"}
end

# Loop through recursion
defmodule Math do
  def sum_list([], acc), do: acc
  def sum_list([head | tail], acc), do: sum_list(tail, acc + head)
end
 
Math.sum_list([1, 2, 3], 0) # 6

# Lists: Linked list (fast prepends O(1), slow reads O(n))
list = [2, 3]
full_list = [1 | list] # [1, 2, 3] (Cons prepending)
 
# Tuples: Contiguous array (fast reads O(1), slow insertions/updates O(n))
tuple = {:ok, "data"}
elem(tuple, 1) # "data"

# map literals
map = %{:name => "Alice", "age" => 30}
 
# Syntactic sugar if keys are atoms
atom_map = %{name: "Alice", age: 30}
atom_map.name # "Alice"
 
# Updating maps (returns new map)
updated_map = %{atom_map | age: 31}

# Structs are extension maps with compile-time checks and default values
defmodule User do
  defstruct name: "Guest", age: 18
end
 
guest = %User{} # %User{name: "Guest", age: 18}
user = %User{name: "VR", age: 25}

# Enum evaluates collections eagerly
list = [1, 2, 3, 4]
doubled = Enum.map(list, fn x -> x * 2 end) # [2, 4, 6, 8]
 
# Stream evaluates collections lazily (infinite processing)
stream = Stream.map(list, fn x -> x * 2 end)
# Nothing evaluated yet
Enum.take(stream, 2) # [2, 4]

defmodule Account do
  # Public function
  def check_eligibility(age) when age >= 18 do
    :ok
  end
  
  # Overloaded body for pattern match
  def check_eligibility(_age) do
    {:error, :underage}
  end
  
  # Private function (defp)
  defp secret_key do
    "123"
  end
end

# Passes result of expression as first argument of next function
string = "  hello world  "
 
# Traditional
res = String.capitalize(String.trim(string))
 
# Piped (Highly readable flow)
res = 
  string
  |> String.trim()
  |> String.capitalize() # "Hello world"

# Spawn creates a new BEAM lightweight process executing given function
pid = spawn(fn -> 
  IO.puts("Running in background process")
end)

# Send message
send(self(), {:hello, "world"})
 
# Receive message
receive do
  {:hello, msg} -> 
    IO.puts("Received: #{msg}")
  {:error, _} -> 
    IO.puts("Failed")
after
  5000 -> 
    IO.puts("Timeout after 5 seconds")
end

# Simplifies running background process to store state
{:ok, agent} = Agent.start_link(fn -> [] end)
 
Agent.update(agent, fn state -> ["Item 1" | state] end)
items = Agent.get(agent, fn state -> state end) # ["Item 1"]

defmodule QueueServer do
  use GenServer
  
  # Client API
  def start_link(initial_state) do
    GenServer.start_link(__MODULE__, initial_state)
  end
  
  def enqueue(pid, element) do
    GenServer.cast(pid, {:enqueue, element}) # asynchronous
  end
  
  def dequeue(pid) do
    GenServer.call(pid, :dequeue) # synchronous
  end
  
  # Server Callbacks
  @impl true
  def init(state) do
    {:ok, state}
  end
  
  @impl true
  def handle_cast({:enqueue, element}, state) do
    {:noreply, state ++ [element]}
  end
  
  @impl true
  def handle_call(:dequeue, _from, [head | tail]) do
    {:reply, head, tail}
  end
end

# Supervisors monitor worker processes and restart them upon failure
children = [
  {QueueServer, [1, 2, 3]}
]
 
# Start supervisor with One-For-One strategy:
# if a child process dies, only that process is restarted.
Supervisor.start_link(children, strategy: :one_for_one)

try do
  raise "Some error occurred"
rescue
  e in RuntimeError -> IO.puts("Rescued: #{e.message}")
after
  IO.puts("Finished")
end

# Write to file
File.write("config.txt", "port=4000\nhost=localhost\n")
 
# Read from file
case File.read("config.txt") do
  {:ok, binary} -> IO.puts(binary)
  {:error, reason} -> IO.puts("Error: #{reason}")
end

# Macros inject code blocks into compile-time AST
defmodule Assertion do
  defmacro assert(expression) do
    quote do
      if !unquote(expression) do
        raise "Assertion failed!"
      end
    end
  end
end

# Create new project template
mix new my_app
 
# Compile project
mix compile
 
# Run interactive IEx console with project code loaded
iex -S mix
 
# Run tests
mix test