Convert Erlang to Elixir

Convert Erlang code to idiomatic Elixir. This skill extends meta-convert-dev with Erlang-to-Elixir specific type mappings, idiom translations, and tooling for translating between these two languages that share the BEAM VM runtime.

This Skill Extends

• meta-convert-dev - Foundational conversion patterns (APTV workflow, testing strategies)

For general concepts like the Analyze → Plan → Transform → Validate workflow, testing strategies, and common pitfalls, see the meta-skill first.

This Skill Adds

• Type mappings: Erlang types → Elixir types with modern syntax
• Idiom translations: Erlang patterns → idiomatic Elixir
• OTP behaviors: gen_server → GenServer, supervisor → Supervisor
• Syntax modernization: Records → Structs, -spec → @spec
• Module system: Erlang modules → Elixir modules with metaprogramming
• Build tools: rebar3 → Mix project structure

This Skill Does NOT Cover

• General conversion methodology - see meta-convert-dev
• Erlang language fundamentals - see lang-erlang-dev
• Elixir language fundamentals - see lang-elixir-dev
• Reverse conversion (Elixir → Erlang) - see convert-elixir-erlang
• Phoenix framework specifics - see lang-elixir-phoenix-dev

---

Quick Reference

Erlang	Elixir	Notes
atom	:atom	Atoms prefixed with :
{ok, Value}	{:ok, value}	Atoms and snake_case
<<"binary">>	"binary"	Strings are binaries
[H|T]	[h | t]	Same list syntax
#{} (map)	%{}	Map syntax similar
#record{}	%Struct{}	Records → Structs
-module(name).	defmodule Name do	Module definition
-export([f/1]).	def f(arg)	Public functions
fun(X) -> X end	fn x -> x end	Anonymous functions
receive ... end	receive do ... end	Message receiving
gen_server	GenServer	OTP behavior
supervisor	Supervisor	OTP supervisor
?MODULE	__MODULE__	Module reference

---

Type System Mapping

Primitive Types

Erlang	Elixir	Notes
atom	:atom	Atoms require : prefix in Elixir
integer	integer	Arbitrary precision in both
float	float	64-bit double precision
binary / <<"string">>	"string"	Elixir strings are UTF-8 binaries
list / 'charlist'	'charlist'	Lists of integers
true / false	true / false	Boolean atoms
undefined	nil	Elixir uses nil atom
pid	pid	Process identifiers identical
reference	reference	Same on BEAM

Collection Types

Erlang	Elixir	Notes
[H|T]	[h | t]	Linked lists, same structure
[]	[]	Empty list
{a, b, c}	{:a, :b, :c}	Tuples identical, atoms need :
#{}	%{}	Maps (Erlang 17+)
#{key => value}	%{key: value}	Atom keys shorthand in Elixir
orddict	Map or Keyword	Use Elixir's Map module
sets	MapSet	Elixir's set implementation

Composite Types

Erlang	Elixir	Notes
-record(user, {name, age}).	defstruct [:name, :age]	Records → Structs
#user{name=N, age=A}	%User{name: n, age: a}	Record instance → Struct
-type name() :: type().	@type name :: type	Type specifications
-spec func(type) -> type.	@spec func(type) :: type	Function specs
-callback func(type) -> type.	@callback func(type) :: type	Behavior callbacks

---

Idiom Translation

Pattern: Module Definition

Erlang:

-module(my_module).
-export([public_function/1]).

-type my_type() :: atom() | binary().

public_function(Arg) ->
    private_function(Arg).

private_function(Arg) ->
    {ok, Arg}.

Elixir:

defmodule MyModule do
  @moduledoc """
  Module documentation goes here.
  """

  @type my_type :: atom() | binary()

  @spec public_function(term()) :: {:ok, term()}
  def public_function(arg) do
    private_function(arg)
  end

  defp private_function(arg) do
    {:ok, arg}
  end
end

Why this translation:

• Elixir uses defmodule with do/end blocks
• Functions are public by default unless defp (private)
• @moduledoc and @doc for documentation
• CamelCase for module names, snake_case for functions

---

Pattern: Function Clauses and Pattern Matching

Erlang:

factorial(0) -> 1;
factorial(N) when N > 0 -> N * factorial(N - 1).

process_result({ok, Data}) ->
    {success, Data};
process_result({error, Reason}) ->
    {failure, Reason}.

Elixir:

def factorial(0), do: 1
def factorial(n) when n > 0, do: n * factorial(n - 1)

def process_result({:ok, data}), do: {:success, data}
def process_result({:error, reason}), do: {:failure, reason}

Why this translation:

• Multiple function clauses work the same way
• Elixir uses : prefix for atoms
• do: for single-line functions, do/end for multi-line
• Guards work identically with when

---

Pattern: Records to Structs

Erlang:

-record(user, {
    id :: integer(),
    name :: binary(),
    email :: binary()
}).

create_user(Id, Name, Email) ->
    #user{id=Id, name=Name, email=Email}.

get_user_name(#user{name=Name}) ->
    Name.

Elixir:

defmodule User do
  @enforce_keys [:id, :name, :email]
  defstruct [:id, :name, :email]

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

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

  def get_name(%User{name: name}), do: name
end

---

Pattern: gen_server to GenServer

Erlang:

-module(counter_server).
-behaviour(gen_server).

-export([start_link/0, increment/0, get_count/0]).
-export([init/1, handle_call/3, handle_cast/2]).

start_link() ->
    gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).

increment() ->
    gen_server:cast(?MODULE, increment).

get_count() ->
    gen_server:call(?MODULE, get_count).

init([]) ->
    {ok, #{count => 0}}.

handle_call(get_count, _From, State = #{count := Count}) ->
    {reply, Count, State}.

handle_cast(increment, State = #{count := Count}) ->
    {noreply, State#{count := Count+1}}.

Elixir:

defmodule CounterServer do
  use GenServer

  # Client API

  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, :ok, opts ++ [name: __MODULE__])
  end

  def increment do
    GenServer.cast(__MODULE__, :increment)
  end

  def get_count do
    GenServer.call(__MODULE__, :get_count)
  end

  # Server Callbacks

  @impl true
  def init(:ok) do
    {:ok, %{count: 0}}
  end

  @impl true
  def handle_call(:get_count, _from, state) do
    {:reply, state.count, state}
  end

  @impl true
  def handle_cast(:increment, state) do
    {:noreply, %{state | count: state.count + 1}}
  end
end

Why this translation:

• use GenServer imports behavior
• @impl true marks callback implementations
• __MODULE__ replaces ?MODULE
• Maps update with %{map | key: value} syntax

---

Pattern: Supervisor Trees

Erlang:

-module(my_supervisor).
-behaviour(supervisor).

init([]) ->
    Children = [
        {counter_server,
         {counter_server, start_link, []},
         permanent, 5000, worker, [counter_server]}
    ],
    {ok, {{one_for_one, 5, 10}, Children}}.

Elixir:

defmodule MySupervisor do
  use Supervisor

  def start_link(init_arg) do
    Supervisor.start_link(__MODULE__, init_arg, name: __MODULE__)
  end

  @impl true
  def init(_init_arg) do
    children = [
      {CounterServer, []}
    ]

    Supervisor.init(children, strategy: :one_for_one)
  end
end

---

Pattern: Message Passing

Erlang:

Pid = spawn(fun() -> loop(0) end),
Pid ! {self(), increment},
receive
    {reply, Msg} -> io:format("Got: ~p~n", [Msg])
after 5000 ->
    io:format("Timeout~n")
end.

Elixir:

pid = spawn(fn -> loop(0) end)
send(pid, {self(), :increment})

receive do
  {:reply, msg} -> IO.puts("Got: #{inspect(msg)}")
after
  5000 -> IO.puts("Timeout")
end

---

Pattern: Error Handling

Erlang:

safe_divide(_, 0) -> {error, division_by_zero};
safe_divide(A, B) -> {ok, A / B}.

handle_file(File) ->
    try
        {ok, Content} = file:read_file(File),
        process(Content)
    catch
        error:Reason -> {error, Reason}
    end.

Elixir:

def safe_divide(_a, 0), do: {:error, :division_by_zero}
def safe_divide(a, b), do: {:ok, a / b}

def handle_file(file) do
  try do
    {:ok, content} = File.read!(file)
    process(content)
  rescue
    e in File.Error -> {:error, e.reason}
  end
end

# With construct for error handling
def handle_file_with(file) do
  with {:ok, content} <- File.read(file),
       {:ok, processed} <- process(content) do
    {:ok, processed}
  end
end

---

OTP Behavior Translation

Erlang callback	Elixir callback	Notes
init/1	init/1	Same signature
handle_call/3	handle_call/3	Synchronous requests
handle_cast/2	handle_cast/2	Asynchronous messages
handle_info/2	handle_info/2	Non-OTP messages
terminate/2	terminate/2	Cleanup

---

Syntax Modernization

Pipe Operator

Erlang:

Result = process(transform(filter(validate(Input)))).

Elixir:

result =
  input
  |> validate()
  |> filter()
  |> transform()
  |> process()

List Comprehensions

Erlang:

[X*2 || X <- lists:seq(1, 10), X rem 2 =:= 0].

Elixir:

for x <- 1..10, rem(x, 2) == 0, do: x * 2

---

Common Pitfalls

1. Atom Syntax Confusion

# WRONG
case result do
  ok -> :success
end

# CORRECT
case result do
  :ok -> :success
end

2. Variable Rebinding

# Elixir allows rebinding
x = 1
x = 2  # OK

# Use pin operator to match
^x = 2  # Match error if x != 2

3. String vs Charlist

string = "hello"   # Binary (UTF-8)
charlist = 'hello' # Charlist

# Convert between them
String.to_charlist("hello")
List.to_string('hello')

---

Tooling

Erlang	Elixir	Purpose
rebar3	Mix	Build tool
EUnit	ExUnit	Testing
Dialyzer	Dialyzer	Type checker
erlc	elixirc	Compiler
erl	IEx	REPL

Migration Workflow

1. Setup Elixir project: mix new my_app
2. Add Erlang dependencies in mix.exs
3. Call Erlang from Elixir: :erlang_module.function(args)
4. Gradual migration: Keep Erlang in src/ (auto-compiled by Mix)

---

See Also

• meta-convert-dev - Foundational patterns
• convert-elixir-erlang - Reverse conversion
• lang-erlang-dev - Erlang patterns
• lang-elixir-dev - Elixir patterns