探索Elixir的秘密，函数式编程入门关键基础概念大汇总

# 定义模块（必须首字母大写）
defmodule Greeter do
  # 定义函数（使用def关键字）
  def say_hello(name) do
    "你好，#{name}！欢迎来到Elixir的世界！"
  end
end

# 调用函数（注意模块名和函数调用方式）
IO.puts(Greeter.say_hello("开发者"))

# 元组匹配
{:ok, result} = {:ok, "成功获取数据"}

# 列表解构
[head | tail] = [1, 2, 3, 4]  # head=1, tail=[2,3,4]

# Map模式匹配
%{name: "Alice", age: age} = %{name: "Alice", age: 30}  # age被绑定为30

# 函数参数匹配
def handle_response({:ok, data}), do: "处理数据: #{data}"
def handle_response({:error, reason}), do: "错误: #{reason}"

"hello world"
|> String.split(" ")        # ["hello", "world"]
|> Enum.map(&String.capitalize/1)  # ["Hello", "World"] 
|> Enum.join(" ")           # "Hello World"
|> IO.puts()               # 输出结果

defmodule Counter do
  def start(initial_value) do
    # 创建新进程
    spawn(fn -> loop(initial_value) end)
  end

  defp loop(count) do
    receive do  # 等待消息
      :increment -> loop(count + 1)
      {:get, pid} -> 
        send(pid, count)  # 发送消息回原进程
        loop(count)
    end
  end
end

# 使用示例
counter_pid = Counter.start(0)
send(counter_pid, :increment)
send(counter_pid, {:get, self()})

receive do
  value -> IO.puts("当前计数: #{value}")  # 输出"当前计数: 1"
end

defmodule ChatRouter do
  use GenServer  # 使用OTP的GenServer行为模式

  # 客户端API
  def start_link(_), do: GenServer.start_link(__MODULE__, :ok, name: __MODULE__)

  def register(user), do: GenServer.call(__MODULE__, {:register, user})
  
  def send_msg(from, to, msg), do: GenServer.cast(__MODULE__, {:send, from, to, msg})

  # 服务端回调
  def init(:ok), do: {:ok, %{users: %{}}}

  def handle_call({:register, user}, _from, state) do
    if Map.has_key?(state.users, user) do
      {:reply, {:error, :user_exists}, state}
    else
      new_state = put_in(state.users[user], [])
      {:reply, :ok, new_state}
    end
  end

  def handle_cast({:send, from, to, msg}, state) do
    case state.users do
      %{^to => inbox} ->
        updated_inbox = [{"From #{from}", msg} | inbox]
        new_state = put_in(state.users[to], updated_inbox)
        {:noreply, new_state}
      _ ->
        {:noreply, state}
    end
  end
end

# 启动路由系统
ChatRouter.start_link([])

# 注册用户
ChatRouter.register("Alice")
ChatRouter.register("Bob")

# 发送消息
ChatRouter.send_msg("Bob", "Alice", "你好Alice！")
ChatRouter.send_msg("Alice", "Bob", "收到，Bob！")

# 查询邮箱（需要扩展实现）

defmodule KeyValueStore do
  use GenServer

  # 客户端API
  def start, do: GenServer.start(__MODULE__, :ok)
  
  def put(pid, key, value), do: GenServer.cast(pid, {:put, key, value})
  
  def get(pid, key), do: GenServer.call(pid, {:get, key})

  # 服务端回调
  def init(:ok), do: {:ok, %{}}

  def handle_cast({:put, key, value}, state) do
    {:noreply, Map.put(state, key, value)}
  end

  def handle_call({:get, key}, _from, state) do
    {:reply, Map.get(state, key), state}
  end
end

# 使用示例
{:ok, pid} = KeyValueStore.start()
KeyValueStore.put(pid, :name, "Elixir")
IO.inspect(KeyValueStore.get(pid, :name))  # 输出"Elixir"

list = [1, 2, 3]
new_list = list ++ [4]  # 正确做法
# list本身不会被修改，需要接收返回值

# 错误示例：
list = [1, 2, 3]
List.append(list, 4)  # 返回新列表但不改变原变量
IO.inspect(list)     # 仍然输出[1,2,3]

# 正确处理异步消息
defmodule SafeReceiver do
  def start do
    spawn(fn -> 
      receive do
        msg -> handle_msg(msg)
      after
        1000 -> :timeout  # 设置超时机制
      end
    end)
  end
end