Elixir Intermediate

mix new example

{app, requirement}
{app, opts}
{app, requirement, opts}

{:plug, ">= 0.4.0"}, # 从 hex.pm 安装版本大于等于 0.4.0 的依赖
{:gettext, git: "https://github.com/elixir-lang/gettext.git", tag: "0.1"}, # 从指定git仓库下载依赖
{:local_dep, path: "/path/to/local/deps"}, # 本地依赖项
{:telemetry, "~> 0.4"}, # 从 hex.pm 安装版本 0.4 的依赖项
{:phoenix_view, github: "phoenixframework/phoenix_view", branch: "master"}, # 从 github 下载依赖 master 分支
{:cowboy, "~> 1.0", only: [:dev, :test]}, # 安装依赖，并只在 dev 与 tst 环境启用

mix deps.get

MIX_ENV=prod mix compile

# test/example_test.exs
defmodule ExampleTest do
  use ExUnit.Case
  doctest Example
  test "greets the world" do
    assert Example.hello() == :world
  end
end

1) test greets the world (ExampleTest)
   test/example_test.exs:4
   Assertion with != failed, both sides are exactly equal
   code: assert Example.hello() != :world
   left: :world
   stacktrace:
     test/example_test.exs:5: (test)

# 使用 Erlang 的模块计算函数运行时间
defmodule Example do
  def time(fun, args) do
    {time, result} = :timer.tc(fun, args)
    IO.puts("Time: #{time} μs\nResult: #{result}")
  end
end
Example.time(&(&1 * &1 * &1), [100])
# Time: 9 μs
# Result: 1000000

is_list('Example') # true
is_list("Example") # false
is_binary("Example") # true
<<"Example">> === "Example" # true

is_list('Example'). %% false
is_list("Example"). %% true
is_binary("Example"). %% false
is_binary(<<"Example">>). %% true

try do
  if elixir, do: raise "Oh NO!!!" # (RuntimeError) Oh NO!!!
  # (ArgumentError) the argument value is invalid
  raise ArgumentError, message: "the argument value is invalid"
rescue
  e in RuntimeError -> "A Runtime Error occurred: #{e.message}"
  e in ArgumentError -> "An Argument Error occurred: #{e.message}"
end

try do
  if elixir, do: raise "Oh NO!!!"
rescue
  e in RuntimeError -> "A Runtime Error occurred: #{e.message}"
after
  IO.puts("The End!!!")
end
# when elixir==true:
#     The End!!!
#     "A Runtime Error occurred: Oh NO!!!"

try do
  for x <- 1..10 do
    if rem(x, 3) == 0, do: throw x
  end
catch
  x -> "Caught: #{x}"
end
# "Caught: 3"

fn -> exit "Oops" end.() # (exit) "Oops"
try do
  exit "Oops"
catch
  :exit, _ -> "EXIT!!!"
end

defmodule ExampleError do
  defexception message: "an example error"
end
try do
  raise ExampleError
rescue
  e in ExampleError -> e.message
end
# "an example error"

defmodule Example do
  def add(a, b), do: a + b
end
Example.add(2, 3) # 5
spawn(Example, :add, [2, 3]) # #PID<0.124.0>

defmodule Example do
  def explode, do: exit :iris
end
spawn(Example, :explode, []) # #PID<0.150.0>
spawn_link(Example, :explode, []) # (EXIT from #PID<0.107.0>) shell process exited with reason: :iris

defmodule Example do
  def explode, do: exit :iris
  def run do
    Process.flag(:trap_exit, true)
    spawn_link(Example, :explode, [])
    receive do
      {:EXIT, _from_pid, reason} -> IO.puts("Exit reason: #{reason}")
    end
  end
end
Example.run() # Exit reason: iris

defmodule Example do
  def explode, do: exit :iris
  def run do
    spawn_monitor(Example, :explode, [])
    receive do
      {:DOWN, _ref, :process, _from_pid, reason} -> IO.puts("Exit reason: #{reason}")
    end
  end
end
Example.run() # Exit reason: iris

{:ok, agent} = Agent.start_link(fn -> [1, 2, 3] end) # {:ok, #PID<0.109.0>}
Agent.update(agent, fn (state) -> state ++ [4, 5] end)
Agent.get(agent, &(&1)) # [1, 2, 3, 4, 5]
{:ok, agent} = Agent.start_link(fn -> [1, 2, 3] end, name: Numbers)
Agent.get(Numbers, &(&1)) # [1, 2, 3]

defmodule Example do
  def add(a, b) do
    :timer.sleep(3000) # sleep 3 s
    a + b
  end
end
task = Task.async(Example, :add, [5, 6]) # 异步执行 Example.add
:timer.sleep(2000)
Task.await(task) # 获取 Example.add 的运行结果

@doc """
GenServer.handle_call/3 callback
"""
def handle_call(:dequeue, _from, [value | state]), do: {:reply, value, state}
def handle_call(:dequeue, _from, []), do: {:reply, nil, []}
def handle_call(:queue, _from, state), do: {:reply, state, state}

def queue(), do: GenServer.call(__MODULE__, :queue)
def dequeue(), do: GenServer.call(__MODULE__, :dequeue)

SimpleQueue.start_link([1, 2, 3]) # {:ok, #PID<0.136.0>}
SimpleQueue.dequeue() # 1
SimpleQueue.queue() # [2, 3]
SimpleQueue.dequeue() # 2
SimpleQueue.dequeue() # 3
SimpleQueue.queue() # []

@doc """
GenServer.handle_cast/2 callback
"""
def handle_cast({:enqueue, value}, state), do: {:noreply, state ++ [value]}

def enqueue(value), do: GenServer.cast(__MODULE__, {:enqueue, value})

defmodule SimpleQueue.Application do
  use Application
  def start(_type, _args) do
    children = [SimpleQueue]
    # 如果有配置项，可以使用元组来配置 children
    # children = [{SimpleQueue, [1, 2, 3]}]
    opts = [strategy: :one_for_one, name: SimpleQueue.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

def child_spec(opts) do
  %{
    id: SimpleQueue,
    start: {__MODULE__, :start_link, [opts]},
    shutdown: 5_000,
    restart: :permanent,
    type: :worker,
  }
end

options = [strategy: :one_for_one, name: SimpleQueue.Supervisor]
DynamicSupervisor.start_link(options)

{:ok, pid} = DynamicSupervisor.start_child(SimpleQueue.Supervisor, SimpleQueue)

children = [
  {Task.Supervisor, name: ExampleApp.TaskSupervisor, restart: :transient}
]
{:ok, pid} = Supervisor.start_link(children, [strategy: :one_for_one])

{:ok, pid} = Task.Supervisor.start_child(ExampleApp.TaskSupervisor, fn -> background_work() end)