Convert Erlang to Haskell

Convert Erlang code to idiomatic Haskell. This skill extends meta-convert-dev with Erlang-to-Haskell specific type mappings, idiom translations, and concurrency patterns for translating between these functional languages with fundamentally different type systems and runtime models.

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 dynamic types → Haskell static types
•Idiom translations: Erlang patterns → idiomatic Haskell
•Concurrency models: OTP behaviors → STM/async patterns
•Error handling: let-it-crash → Maybe/Either types
•Message passing: Process mailboxes → Channels/TQueue
•Supervision: Supervisor trees → immortal/distributed-process

This Skill Does NOT Cover

•General conversion methodology - see meta-convert-dev
•Erlang language fundamentals - see lang-erlang-dev
•Haskell language fundamentals - see lang-haskell-dev
•Reverse conversion (Haskell → Erlang) - see convert-haskell-erlang
•Elixir conversions - see convert-elixir-haskell

Quick Reference

Erlang	Haskell	Notes
`atom()`	`Data.Text` or custom sum type	Atoms → Text or algebraic types
`integer()`	`Integer` or `Int`	Unbounded vs. bounded
`float()`	`Double` or `Float`	Precision choice
`binary()`	`ByteString`	`Data.ByteString.Strict` or `.Lazy`
`list()`	`[a]`	Homogeneous lists
`tuple()`	`(a, b, ...)` or custom product type	Fixed-size tuples or records
`map()`	`Map k v`	`Data.Map.Strict`
`pid()`	`ThreadId` or `Async a`	Process identifiers
`reference()`	`IORef` or `TVar`	Mutable references
`fun()`	`a -> b`	First-class functions
`ok \| {error, Reason}`	`Either Error a` or `Maybe a`	Error handling

Type System Mapping

Primitives

Erlang	Haskell	Example Conversion
`42`	`42 :: Integer`	Integer literals
`3.14`	`3.14 :: Double`	Floating point
`true`	`True :: Bool`	Boolean
`undefined`	`Nothing :: Maybe a`	Absence of value
`<<"hello">>`	`"hello" :: ByteString`	Binary strings
`'atom'`	`"atom" :: Text` or `Atom` ADT	Symbolic constants

Collections

Erlang	Haskell	Notes
`[1, 2, 3]`	`[1, 2, 3] :: [Int]`	Linked lists
`{ok, Value}`	`Right Value :: Either Error a`	Success tuple
`#{key => value}`	`Map.fromList [(key, value)]`	Key-value maps
`[H\|T]`	`(h:t)`	List pattern matching

Composite Types

Erlang	Haskell	Example
`-record(user, {name, age}).`	`data User = User { userName :: Text, userAge :: Int }`	Records
`-type result() :: ok \| {error, term()}.`	`data Result = Ok \| Error String`	Sum types
`-spec add(integer(), integer()) -> integer().`	`add :: Int -> Int -> Int`	Function signatures
`-opaque handle().`	`newtype Handle = Handle Int`	Opaque types

Process Types

Erlang Concept	Haskell Equivalent	Library
`pid()`	`Async a`	`async` package
`gen_server`	Custom type class + `TVar`	`stm`, `async`
`supervisor`	`Supervisor`	`immortal`, `distributed-process`
Message passing	`Chan`, `TQueue`, `STM`	`stm`, `unagi-chan`

Idiom Translation

Pattern: Pattern Matching

Erlang:

erlang

handle_result(ok) -> success;
handle_result({error, Reason}) -> {failure, Reason};
handle_result(Other) -> {unknown, Other}.

Haskell:

haskell

data Result = Ok | Error String
data Response = Success | Failure String | Unknown String

handleResult :: Result -> Response
handleResult Ok = Success
handleResult (Error reason) = Failure reason

Why this translation: Haskell's pattern matching is structurally similar but requires explicit type constructors in algebraic data types.

Pattern: Message Passing (gen_server)

Erlang:

erlang

-module(counter).
-behaviour(gen_server).

handle_call(increment, _From, State) ->
    {reply, ok, State + 1};
handle_call(get, _From, State) ->
    {reply, State, State}.

Haskell:

haskell

module Counter where

import Control.Concurrent.STM

data CounterMsg = Increment | Get (TMVar Int)

counter :: TVar Int -> CounterMsg -> STM ()
counter state Increment = modifyTVar' state (+1)
counter state (Get reply) = readTVar state >>= putTMVar reply

Why this translation: Haskell uses Software Transactional Memory (STM) instead of actor message passing. TVar provides lock-free mutable state.

Pattern: Supervision Trees

Erlang:

erlang

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

Haskell:

haskell

import Control.Immortal

runSupervised :: IO ()
runSupervised = do
    thread <- createWithLabel "worker1" $ \_ -> worker
    onUnexpectedFinish thread $ \_ -> print "Worker crashed, restarting"

Why this translation: immortal library provides automatic restart semantics. For full OTP-style supervision, use distributed-process or cloud-haskell.

Pattern: Spawn and Message Send

Erlang:

erlang

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

Haskell:

haskell

import Control.Concurrent
import Control.Concurrent.Chan

spawnWorker :: IO ()
spawnWorker = do
    chan <- newChan
    replyChan <- newChan
    _ <- forkIO $ worker chan
    writeChan chan (Hello, replyChan)
    reply <- readChan replyChan
    putStrLn $ "Got: " ++ show reply

Why this translation: Haskell's Chan provides FIFO message queues. Use async for lightweight process management.

Pattern: List Comprehensions

Erlang:

erlang

Doubles = [X*2 || X <- [1,2,3,4], X rem 2 =:= 0].

Haskell:

haskell

doubles :: [Int]
doubles = [x*2 | x <- [1,2,3,4], even x]

Why this translation: Syntax is nearly identical. Haskell's comprehensions support multiple generators and guards.

Pattern: Error Handling

Erlang:

erlang

case file:read_file("data.txt") of
    {ok, Data} -> process(Data);
    {error, Reason} -> handle_error(Reason)
end.

Haskell:

haskell

import qualified Data.ByteString as BS
import Control.Exception

readAndProcess :: IO ()
readAndProcess = do
    result <- try (BS.readFile "data.txt") :: IO (Either IOError BS.ByteString)
    case result of
        Right dat -> process dat
        Left err -> handleError err

Why this translation: Haskell uses exception handling via try/catch or the Either monad. For pure code, prefer ExceptT transformer.

Pattern: Higher-Order Functions

Erlang:

erlang

lists:map(fun(X) -> X * 2 end, [1,2,3]).
lists:foldl(fun(X, Acc) -> X + Acc end, 0, [1,2,3]).

Haskell:

haskell

map (*2) [1,2,3]
foldl (+) 0 [1,2,3]

Why this translation: Haskell's curried functions eliminate need for explicit lambdas. Point-free style is idiomatic.

Pattern: Binary Pattern Matching

Erlang:

erlang

<<Version:8, Type:8, Payload/binary>> = Packet.

Haskell:

haskell

import qualified Data.Binary.Get as Get
import Data.ByteString.Lazy (ByteString)
import Data.Word (Word8)

parsePacket :: ByteString -> (Word8, Word8, ByteString)
parsePacket = Get.runGet $ do
    version <- Get.getWord8
    typ <- Get.getWord8
    payload <- Get.getRemainingLazyByteString
    return (version, typ, payload)

Why this translation: Haskell's binary package provides parsing combinators. cereal and attoparsec are alternatives.

Pattern: Guards

Erlang:

erlang

abs(X) when X < 0 -> -X;
abs(X) -> X.

Haskell:

haskell

abs' :: (Ord a, Num a) => a -> a
abs' x | x < 0     = -x
       | otherwise = x

Why this translation: Syntax nearly identical. Haskell guards use | instead of when.

Pattern: ETS Tables

Erlang:

erlang

Table = ets:new(cache, [set, public]),
ets:insert(Table, {key, value}),
[{key, Value}] = ets:lookup(Table, key).

Haskell:

haskell

import qualified Data.HashTable.IO as HT

type HashTable k v = HT.BasicHashTable k v

useCache :: IO ()
useCache = do
    table <- HT.new :: IO (HashTable String String)
    HT.insert table "key" "value"
    value <- HT.lookup table "key"
    print value

Why this translation: Mutable hash tables via hashtables package. For pure code, use Data.Map.

Error Handling

Philosophy Shift

Erlang: "Let it crash" - processes fail, supervisors restart them. Haskell: "Make illegal states unrepresentable" - type system prevents errors at compile time.

Practical Translation

Erlang:

erlang

-spec divide(number(), number()) -> {ok, number()} | {error, divide_by_zero}.
divide(_, 0) -> {error, divide_by_zero};
divide(X, Y) -> {ok, X / Y}.

Haskell:

haskell

data DivideError = DivideByZero

divide :: Double -> Double -> Either DivideError Double
divide _ 0 = Left DivideByZero
divide x y = Right (x / y)

-- Or using Maybe for simpler errors
divide' :: Double -> Double -> Maybe Double
divide' _ 0 = Nothing
divide' x y = Just (x / y)

Exception Handling

Erlang:

erlang

try
    risky_operation()
catch
    error:Reason -> {error, Reason}
end.

Haskell:

haskell

import Control.Exception

safeRisky :: IO (Either SomeException Result)
safeRisky = try riskyOperation

Concurrency Patterns

1. Lightweight Processes

Erlang:

erlang

spawn(fun worker/0)

Haskell:

haskell

import Control.Concurrent.Async

async worker  -- Returns Async a

Pattern: Use async for fire-and-forget, race for first-to-finish, concurrently for parallel composition.

2. Message Channels

Erlang:

erlang

Pid ! Message,
receive Pattern -> handle(Pattern) end.

Haskell:

haskell

import Control.Concurrent.Chan

writeChan chan message
msg <- readChan chan

Alternatives:

•TQueue (STM-based, composable)
•unagi-chan (high-performance bounded channels)

3. Select-Style Multiplexing

Erlang:

erlang

receive
    {msg1, Data} -> handle_msg1(Data);
    {msg2, Data} -> handle_msg2(Data)
after 1000 ->
    timeout
end.

Haskell:

haskell

import Control.Concurrent.STM

selectMessage :: TQueue Msg1 -> TQueue Msg2 -> IO Response
selectMessage q1 q2 = atomically $
    (handleMsg1 <$> readTQueue q1) `orElse`
    (handleMsg2 <$> readTQueue q2)

Pattern: orElse provides non-deterministic choice. For timeouts, use registerDelay.

4. GenServer Equivalent

Erlang:

erlang

-module(kv_store).
-behaviour(gen_server).

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

start_link() -> gen_server:start_link(?MODULE, [], []).
init([]) -> {ok, #{}}.

put(Pid, Key, Value) -> gen_server:cast(Pid, {put, Key, Value}).
get(Pid, Key) -> gen_server:call(Pid, {get, Key}).

handle_cast({put, Key, Value}, State) ->
    {noreply, State#{Key => Value}}.

handle_call({get, Key}, _From, State) ->
    {reply, maps:get(Key, State, undefined), State}.

Haskell:

haskell

module KVStore where

import Control.Concurrent.STM
import qualified Data.Map.Strict as Map

data KVStore k v = KVStore (TVar (Map.Map k v))

newKVStore :: STM (KVStore k v)
newKVStore = KVStore <$> newTVar Map.empty

put :: Ord k => KVStore k v -> k -> v -> STM ()
put (KVStore store) key value = modifyTVar' store (Map.insert key value)

get :: Ord k => KVStore k v -> k -> STM (Maybe v)
get (KVStore store) key = Map.lookup key <$> readTVar store

-- Usage:
-- store <- atomically newKVStore
-- atomically $ put store "key" "value"
-- value <- atomically $ get store "key"

5. Distributed Computing

Erlang:

erlang

{server, 'node@host'} ! Message.

Haskell (Cloud Haskell):

haskell

import Control.Distributed.Process

send serverId message

Libraries:

•distributed-process: Erlang-style distributed computing
•network-transport-tcp: Network backend
•cloud-haskell: Full framework

Memory & Ownership

Garbage Collection

Both Erlang and Haskell use GC, but differently:

Aspect	Erlang	Haskell
GC Strategy	Per-process generational	Generational for whole heap
Latency	Microsecond pauses per process	Millisecond pauses (tunable)
Memory Model	Process-local heaps	Shared heap with immutability
Tuning	`spawn_opt` flags	GHC RTS options (`-H`, `-A`)

Mutable State

Erlang:

erlang

% Processes hold mutable state via recursion
loop(State) ->
    receive
        {update, NewState} -> loop(NewState)
    end.

Haskell:

haskell

-- Explicit mutability via IORef or TVar
import Data.IORef

updateState :: IORef Int -> IO ()
updateState ref = modifyIORef' ref (+1)

Philosophy: Haskell makes mutation explicit in types (IO, STM). Pure functions remain referentially transparent.

Common Pitfalls

1. Forgetting Type Signatures

Problem: Haskell infers types, but polymorphism can cause ambiguity.

Solution: Always write top-level type signatures.

haskell

-- Bad: Type defaulting may surprise you
divide x y = x / y

-- Good: Explicit constraints
divide :: Double -> Double -> Double
divide x y = x / y

2. Overusing Exceptions in Pure Code

Problem: error, undefined break referential transparency.

Solution: Use Maybe, Either, or ExceptT.

haskell

-- Bad: Exception in pure code
head' [] = error "Empty list"

-- Good: Explicit failure
head' :: [a] -> Maybe a
head' [] = Nothing
head' (x:_) = Just x

3. Ignoring Laziness

Problem: Erlang is strict; Haskell is lazy. Space leaks possible.

Solution: Use strict data structures and functions when needed.

haskell

import qualified Data.Map.Strict as Map  -- Not Data.Map
import Data.List (foldl')                -- Not foldl

sum' :: [Int] -> Int
sum' = foldl' (+) 0  -- Strict accumulator

4. Blocking in STM

Problem: atomically blocks can cause deadlocks if misused.

Solution: Keep STM transactions short and pure.

haskell

-- Bad: IO inside STM (won't compile)
atomically $ do
    x <- readTVar var
    putStrLn "Debug"  -- ERROR!

-- Good: IO outside STM
x <- atomically $ readTVar var
putStrLn $ "Value: " ++ show x

5. Misunderstanding Monads

Problem: Treating IO like synchronous Erlang code.

Solution: Embrace do-notation and functors.

haskell

-- Haskell idiomatic
contents <- readFile "file.txt"
process contents

6. Not Using Newtype

Problem: Primitive obsession (using String, Int everywhere).

Solution: Wrap primitives for type safety.

haskell

-- Bad
type UserId = Int

-- Good
newtype UserId = UserId Int

7. Channel Deadlocks

Problem: Mixing Chan with synchronous expectations.

Solution: Use async for structured concurrency.

haskell

-- Prefer this over manual channel management
result <- async computation
wait result

8. Forgetting Stack/Cabal Configuration

Problem: Erlang's rebar3 manages deps; Haskell needs explicit config.

Solution: Use Stack or Cabal with curated package sets (Stackage).

yaml

# stack.yaml
resolver: lts-22.0
packages:
  - .
extra-deps: []

Tooling

Ecosystem Equivalents

Erlang Tool	Haskell Equivalent	Purpose
`rebar3`	`stack` or `cabal`	Build system
`dialyzer`	`ghc -Wall -Werror`	Static analysis
`eunit`	`hspec` or `tasty`	Unit testing
`common_test`	`hspec` + `QuickCheck`	Property testing
`observer`	`threadscope`, `eventlog2html`	Profiling
`recon`	`ekg`	Runtime monitoring
`relx`	`docker` + static binaries	Release management
`hex`	`hackage` / `stackage`	Package registry

Development Workflow

bash

# Erlang
rebar3 new app myapp
rebar3 compile
rebar3 shell

# Haskell
stack new myapp
stack build
stack ghci

Migration Strategy

Step 1: Identify OTP Boundaries

•Map gen_server, gen_statem, supervisor to Haskell equivalents
•Document message protocols

Step 2: Translate Core Logic

•Start with pure functions (easiest to translate)
•Convert -spec to type signatures
•Port pattern matching and guards

Step 3: Replace Concurrency Primitives

•spawn → async
•receive → Chan or STM
•Supervision → immortal or distributed-process

Step 4: Handle Binary Protocols

•Use binary, cereal, or attoparsec
•Preserve wire format compatibility if needed

Step 5: Testing

•Port EUnit tests to Hspec
•Use QuickCheck for property-based testing
•Add type-driven tests (e.g., should-not-typecheck)

Step 6: Performance Tuning

•Profile with +RTS -p
•Use strict data structures
•Consider deepseq for forcing evaluation

Step 7: Deployment

•Build static binaries with stack --docker
•Use multi-stage Docker builds
•Consider GHC runtime flags (-N, -H, -A)

Examples

Example 1: Simple HTTP Client

Erlang:

erlang

-module(http_client).
-export([fetch/1]).

fetch(Url) ->
    inets:start(),
    case httpc:request(get, {Url, []}, [], []) of
        {ok, {{_, 200, _}, _, Body}} -> {ok, Body};
        {ok, {{_, Code, _}, _, _}} -> {error, Code};
        {error, Reason} -> {error, Reason}
    end.

Haskell:

haskell

module HttpClient where

import Network.HTTP.Simple
import qualified Data.ByteString.Lazy.Char8 as L8

fetch :: String -> IO (Either String String)
fetch url = do
    response <- httpLBS (parseRequest_ url)
    let status = getResponseStatusCode response
    return $ if status == 200
        then Right (L8.unpack $ getResponseBody response)
        else Left ("HTTP " ++ show status)

Example 2: Concurrent File Processing

Erlang:

erlang

process_files(Files) ->
    Parent = self(),
    [spawn(fun() ->
        {ok, Data} = file:read_file(F),
        Parent ! {done, F, process(Data)}
     end) || F <- Files],
    collect(length(Files), []).

collect(0, Acc) -> Acc;
collect(N, Acc) ->
    receive {done, File, Result} -> collect(N-1, [{File, Result}|Acc]) end.

Haskell:

haskell

import Control.Concurrent.Async
import qualified Data.ByteString as BS

processFiles :: [FilePath] -> IO [(FilePath, Result)]
processFiles files =
    forConcurrently files $ \file -> do
        dat <- BS.readFile file
        let result = process dat
        return (file, result)

Example 3: GenServer-Style State Machine

Erlang:

erlang

-module(door).
-behaviour(gen_statem).

locked(cast, {button, Code}, #{code := Code} = Data) ->
    {next_state, unlocked, Data};
locked(cast, {button, _}, Data) ->
    {keep_state, Data}.

unlocked(cast, lock, Data) ->
    {next_state, locked, Data}.

Haskell:

haskell

{-# LANGUAGE LambdaCase #-}

module Door where

import Control.Concurrent.STM

data State = Locked | Unlocked
data Event = Button Int | Lock

doorFSM :: TVar State -> Int -> Event -> STM ()
doorFSM state correctCode = \case
    Button code | code == correctCode -> writeTVar state Unlocked
    Button _ -> return ()
    Lock -> writeTVar state Locked

Convert Erlang to Haskell

This Skill Extends

This Skill Adds

This Skill Does NOT Cover

Quick Reference

Type System Mapping

Primitives

Collections

Composite Types

Process Types

Idiom Translation

Pattern: Pattern Matching

Pattern: Message Passing (gen_server)

Pattern: Supervision Trees

Pattern: Spawn and Message Send

Pattern: List Comprehensions

Pattern: Error Handling

Pattern: Higher-Order Functions

Pattern: Binary Pattern Matching

Pattern: Guards

Pattern: ETS Tables

Error Handling

Philosophy Shift

Practical Translation

Exception Handling

Concurrency Patterns

1. Lightweight Processes

2. Message Channels

3. Select-Style Multiplexing

4. GenServer Equivalent

5. Distributed Computing

Memory & Ownership

Garbage Collection

Mutable State

Common Pitfalls

1. Forgetting Type Signatures

2. Overusing Exceptions in Pure Code

3. Ignoring Laziness

4. Blocking in STM

5. Misunderstanding Monads

6. Not Using Newtype

7. Channel Deadlocks

8. Forgetting Stack/Cabal Configuration

Tooling

Ecosystem Equivalents

Development Workflow

Migration Strategy

Step 1: Identify OTP Boundaries

Step 2: Translate Core Logic

Step 3: Replace Concurrency Primitives

Step 4: Handle Binary Protocols

Step 5: Testing

Step 6: Performance Tuning

Step 7: Deployment

Examples

Example 1: Simple HTTP Client

Example 2: Concurrent File Processing

Example 3: GenServer-Style State Machine

See Also