Typespecs and Types

defmodule Order do
  @enforce_keys [:id]
  defstruct [:id, status: :pending, items: []]

  # A union of literal atoms, written with `|`.
  @type status :: :pending | :paid | :shipped

  # A map type: `required(...)` keys must be present,
  # `optional(...)` keys may be. `String.t()` is a
  # UTF-8 string; `pos_integer()` is 1, 2, 3...
  @type item :: %{
          required(:sku) => String.t(),
          required(:qty) => pos_integer(),
          optional(:gift) => boolean()
        }

  # `%__MODULE__{...}` is this struct, with a type for
  # each field. `[item()]` is shorthand for
  # `list(item())`.
  @type t :: %__MODULE__{
          id: pos_integer(),
          status: status(),
          items: [item()]
        }

  # `@typep` is private: usable only inside this
  # module, and hidden from the docs.
  @typep count :: non_neg_integer()

  # `keyword()` is a keyword list, like the options
  # here.
  @spec new(pos_integer(), [item()], keyword()) :: t()
  def new(id, items, opts \\ []) do
    struct!(__MODULE__, [id: id, items: items] ++ opts)
  end

  @spec quantity(t()) :: count()
  def quantity(order), do: order.items |> Enum.map(& &1.qty) |> Enum.sum()

  @spec half(integer()) :: integer()
  def half(n), do: n / 2
end

order = Order.new(1, [%{sku: "TEA", qty: 2}, %{sku: "MUG", qty: 1, gift: true}])
IO.inspect(order)
IO.inspect(Order.quantity(order), label: "quantity")

IO.inspect(Order.half(3), label: "half(3)")

defmodule Checker do
  def check(title, source) do
    {_modules, diagnostics} = Code.with_diagnostics(fn -> Code.compile_string(source) end)
    IO.puts("== #{title}")

    if diagnostics == [] do
      IO.puts("    (no warnings)")
    end

    for %{message: message} <- diagnostics do
      [kept | _] = String.split(message, "\nwhere ")
      kept |> String.trim() |> String.replace(~r/^(?=.)/m, "    ") |> IO.puts()
    end
  end
end

Checker.check("forgot to unwrap {:ok, _}", ~S"""
defmodule Shipping do
  def ship(%{status: :paid} = order), do: {:shipped, order}

  def run, do: ship({:ok, %{status: :paid}})
end
""")

Checker.check("typo in a struct field", ~S"""
defmodule Report do
  def line(%Order{} = order), do: "order #{order.id}: #{order.stauts}"
end
""")

Checker.check("a string where a number goes", ~S"""
defmodule Pricing do
  def total(line), do: line.price * line.qty

  def run, do: total(%{price: "9.99", qty: 2})
end
""")

Checker.check("a case clause that can never match", ~S"""
defmodule Form do
  defp parse_qty("one"), do: {:ok, 1}
  defp parse_qty(_), do: :error

  def qty(input) do
    case parse_qty(input) do
      {:ok, n} -> n
      :error -> 0
      nil -> 1
    end
  end
end
""")

Checker.check("a redundant clause", ~S"""
defmodule Labels do
  def label(s) when is_binary(s), do: s
  def label(a) when is_atom(a), do: Atom.to_string(a)
  def label(s) when is_binary(s), do: String.upcase(s)
end
""")

Checker.check("the guard wins over the spec", ~S"""
defmodule Shout do
  @spec shout(integer()) :: String.t()
  def shout(s) when is_binary(s), do: String.upcase(s)

  def run, do: shout(42)
end
""")

Checker.check("unknown input is not checked", ~S"""
defmodule Inbox do
  def ship(%{status: :paid} = order), do: {:shipped, order}

  def handle(input), do: ship(input)
end
""")

try do
  Inbox.handle(:oops)
rescue
  e in FunctionClauseError -> IO.puts("FunctionClauseError: " <> Exception.message(e))
end