Elixir模块属性 #

defmodule Example do
  @name "MyModule"
  @version "1.0.0"

  def info do
    "Module: #{@name}, Version: #{@version}"
  end
end

iex(1)> defmodule Example do
...>   @value 42
...>   def get_value, do: @value
...> end

iex(2)> Example.get_value()
42

defmodule User do
  @moduledoc """
  User management module.

  This module provides functions for managing users.
  """

  @doc """
  Creates a new user.

  ## Parameters

    - `name` - User name
    - `email` - User email

  ## Examples

      iex> User.new("Alice", "alice@example.com")
      %User{name: "Alice", email: "alice@example.com"}

  """
  def new(name, email) do
    %{name: name, email: email}
  end
end

defmodule User do
  @type t :: %__MODULE__{
    id: integer(),
    name: String.t(),
    email: String.t()
  }

  @type name :: String.t()
  @type email :: String.t()

  defstruct [:id, :name, :email]
end

defmodule Math do
  @spec add(number(), number()) :: number()
  def add(a, b), do: a + b

  @spec divide(number(), number()) :: {:ok, number()} | {:error, :division_by_zero}
  def divide(_, 0), do: {:error, :division_by_zero}
  def divide(a, b), do: {:ok, a / b}
end

defmodule MyGenServer do
  @behaviour GenServer

  def init(args), do: {:ok, args}
  def handle_call(_msg, _from, state), do: {:reply, :ok, state}
  def handle_cast(_msg, state), do: {:noreply, state}
end

defmodule Router do
  @routes []

  def route(path, handler) do
    @routes [{path, handler} | @routes]
  end

  def routes, do: @routes
end

defmodule Plugin do
  @callbacks []

  def register_callback(name, func) do
    @callbacks [{name, func} | @callbacks]
  end

  def callbacks, do: @routes
end

defmodule MyPlugin do
  Plugin.register_callback(:before_save, fn data -> data end)
  Plugin.register_callback(:after_save, fn data -> IO.puts("Saved") end)
end

defmodule MyModule do
  @before_compile MyModule

  defmacro __before_compile__(_env) do
    quote do
      def generated_function, do: "I was generated!"
    end
  end
end

defmodule MyModule do
  @after_compile __MODULE__

  def __after_compile__(_env, _bytecode) do
    IO.puts("Module compiled!")
  end
end

defmodule Tracer do
  @on_definition {Tracer, :trace}

  def trace(_env, :def, name, args, _guards, _body) do
    IO.puts("Defined function #{name}/#{length(args)}")
  end

  def trace(_env, :defp, name, args, _guards, _body) do
    IO.puts("Defined private function #{name}/#{length(args)}")
  end

  def trace(_, _, _, _, _, _), do: :ok

  def public_func(a, b), do: a + b
  defp private_func(a), do: a * 2
end

defmodule Config do
  @external_resource Path.join([__DIR__, "config.json"])

  @config File.read!(Path.join([__DIR__, "config.json"]))
          |> Jason.decode!()

  def get(key), do: Map.get(@config, key)
end

defmodule Optimized do
  @compile {:inline, my_func: 1}

  def my_func(x), do: x * 2
end

@compile :nowarn_unused_vars
@compile {:nowarn_unused_vars, true}
@compile {:inline, func: 1}
@compile {:autoload, false}

iex(1)> defmodule Example do
...>   @author "Developer"
...>   def info, do: __MODULE__.__info__(:attributes)
...> end

iex(2)> Example.info()
[author: "Developer"]

__MODULE__.__info__(:functions)
__MODULE__.__info__(:macros)
__MODULE__.__info__(:module)
__MODULE__.__info__(:attributes)
__MODULE__.__info__(:compile)

defmodule Constants do
  @pi 3.14159265359
  @e 2.71828182846
  @golden_ratio 1.61803398875

  def pi, do: @pi
  def e, do: @e
  def golden_ratio, do: @golden_ratio
end

defmodule AppConfig do
  @app_name Application.compile_env(:my_app, :name, "MyApp")
  @version Application.compile_env(:my_app, :version, "0.1.0")
  @env Application.compile_env(:my_app, :env, :dev)

  def app_name, do: @app_name
  def version, do: @version
  def env, do: @env
end

defmodule Task do
  @tasks %{}

  def register(name, func) do
    @tasks Map.put(@tasks, name, func)
  end

  def get(name), do: Map.get(@tasks, name)

  def all, do: @tasks
end