Structs, Protokolle, Behaviours und Fehler

defmodule Person do
  @enforce_keys [:name]
  defstruct [:name, alter: 0, hobbys: []]

  def neu(name, alter), do: %Person{name: name, alter: alter}

  def vorstellen(%Person{name: n, alter: a}) when a >= 18, do: "#{n} (#{a}, volljährig)"
  def vorstellen(%Person{name: n, alter: a}), do: "#{n} (#{a})"

  def geburtstag(%Person{} = p), do: %{p | alter: p.alter + 1}
end

defmodule Demo1 do
  def run do
    mia = Person.neu("Mia", 17)
    IO.inspect(mia)
    IO.puts(Person.vorstellen(mia))
    aelter = Person.geburtstag(mia)
    IO.puts(Person.vorstellen(aelter))
    IO.inspect(%Person{name: "Tom"})
    IO.inspect(mia.name)
    IO.inspect(is_map(mia))
    IO.inspect(mia.__struct__)
    IO.inspect(Map.from_struct(mia))
    IO.inspect(match?(%Person{alter: 17}, mia))

    try do
      struct!(Person, alter: 5)
    rescue
      e in ArgumentError -> IO.puts("Pflichtfeld fehlt: #{Exception.message(e)}")
    end
  end
end

Demo1.run()

defprotocol Beschreibbar do
  @doc "Gibt eine Beschreibung zurück"
  def beschreibe(wert)
end

defimpl Beschreibbar, for: Integer do
  def beschreibe(n), do: "Ganzzahl #{n}"
end

defimpl Beschreibbar, for: BitString do
  def beschreibe(s), do: "Text mit #{String.length(s)} Zeichen"
end

defimpl Beschreibbar, for: List do
  def beschreibe(l), do: "Liste mit #{length(l)} Elementen"
end

defmodule Hund, do: defstruct([:name])

defimpl Beschreibbar, for: Hund do
  def beschreibe(%Hund{name: n}), do: "Hund #{n}"
end

defmodule Demo2 do
  def run do
    for w <- [42, "Hallo", [1, 2], %Hund{name: "Rex"}] do
      IO.puts(Beschreibbar.beschreibe(w))
    end

  end
end

Demo2.run()

# Eingebaute Protokolle: String.Chars (to_string), Inspect, Enumerable
defmodule Punkt do
  defstruct [:x, :y]
end
defimpl String.Chars, for: Punkt do
  def to_string(%Punkt{x: x, y: y}), do: "(#{x}|#{y})"
end
defimpl Inspect, for: Punkt do
  def inspect(%Punkt{x: x, y: y}, _opts), do: "#Punkt<#{x},#{y}>"
end
defmodule Demo3 do
  def run do
    IO.puts("Punkt: #{%Punkt{x: 1, y: 2}}")
    IO.inspect(%Punkt{x: 3, y: 4})
  end
end

Demo3.run()

defmodule Formatter do
  @callback format(term) :: String.t()
  @callback name() :: String.t()
end

defmodule JsonLike do
  @behaviour Formatter
  @impl true
  def name, do: "json-ish"
  @impl true
  def format(%{} = map) do
    inhalt = map |> Enum.sort() |> Enum.map_join(", ", fn {k, v} -> "\"#{k}\": #{inspect(v)}" end)
    "{" <> inhalt <> "}"
  end
end

defmodule CsvLike do
  @behaviour Formatter
  @impl true
  def name, do: "csv"
  @impl true
  def format(%{} = map), do: map |> Enum.sort() |> Enum.map_join(",", fn {_, v} -> to_string(v) end)
end

daten = %{name: "Mia", alter: 17}
for mod <- [JsonLike, CsvLike] do
  IO.puts("#{mod.name()}: #{mod.format(daten)}")
end

defmodule Konto do
  def abheben(stand, betrag) when betrag > stand, do: {:error, :nicht_genug_guthaben}
  def abheben(stand, betrag) when betrag <= 0, do: {:error, :ungueltiger_betrag}
  def abheben(stand, betrag), do: {:ok, stand - betrag}
end

for betrag <- [30, 500, -1] do
  case Konto.abheben(100, betrag) do
    {:ok, neu} -> IO.puts("ok, neuer Stand #{neu}")
    {:error, grund} -> IO.puts("Fehler: #{grund}")
  end
end

# Exceptions
try do
  1 / 0
rescue
  e in ArithmeticError -> IO.puts("Arithmetik: #{Exception.message(e)}")
end

try do
  raise ArgumentError, message: "ungültig"
rescue
  e in ArgumentError -> IO.puts("Gefangen: #{e.message}")
after
  IO.puts("after läuft immer")
end

defmodule MeinFehler do
  defexception message: "eigener Fehler", code: 500
end

try do
  raise MeinFehler, code: 404
rescue
  e in MeinFehler -> IO.puts("#{e.message} (#{e.code})")
end

result = try do
  throw(:abbruch)
catch
  :abbruch -> "geworfen und gefangen"
end
IO.puts(result)

IO.inspect(Integer.parse("x"))
IO.inspect(Map.fetch(%{a: 1}, :b))
IO.inspect(Map.fetch!(%{a: 1}, :a))
IO.inspect(File.read("/gibt/es/nicht"))
IO.inspect(Enum.map(["1", "x", "3"], fn s ->
  case Integer.parse(s) do
    {n, ""} -> {:ok, n}
    _ -> {:error, s}
  end
end))