Convert Haskell to Erlang

Convert Haskell code to idiomatic Erlang/OTP. This skill extends meta-convert-dev with Haskell-to-Erlang specific type mappings, idiom translations, and tooling for converting pure functional code to fault-tolerant distributed systems.

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: Haskell types → Erlang terms
• Idiom translations: Pure functions → Process-based patterns
• Error handling: Maybe/Either → ok/error tuples
• Async patterns: Monadic IO → Process message passing
• Concurrency: STM/Async → OTP behaviors and supervision
• Evaluation: Lazy → Eager evaluation strategies

This Skill Does NOT Cover

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

---

Quick Reference

| Haskell | Erlang | Notes | |---------|--------|-------| | Int, Integer | integer() | Arbitrary precision in both | | Float, Double | float() | IEEE 754 floating point | | String | string() / binary() | String is [char()], prefer binaries | | [a] | [term()] | Lists work similarly | | (a, b) | {A, B} | Tuples preserve structure | | Maybe a | undefined \| A or {ok, A} \| error | No Maybe, use atoms/tuples | | Either e a | {ok, A} \| {error, E} | Standard Erlang convention | | data X = ... | -record(x, {...}) or map() | Records or maps | | class TypeClass | -behaviour(...) | OTP behaviors | | IO a | fun() -> A or process | Side effects via processes | | do notation | Pattern matching + case | Sequential operations | | fmap, <$> | lists:map/2 | List transformations | | >>= (bind) | Nested function calls | No monadic bind | | pure / return | Direct value | No lifting needed |

When Converting Code

1. Analyze purity boundaries - Identify pure vs effectful code
2. Map types to Erlang terms - Create type equivalence table
3. Convert laziness to eagerness - Evaluate strictly
4. Replace monads with processes - IO/State → gen_server
5. Adopt Erlang idioms - Don't write "Haskell code in Erlang syntax"
6. Embrace failure - Use supervision trees, not defensive code
7. Test equivalence - Same inputs → same outputs

---

Type System Mapping

Primitive Types

| Haskell | Erlang | Notes | |---------|--------|-------| | Int | integer() | Erlang integers are arbitrary precision | | Integer | integer() | No distinction in Erlang | | Float | float() | IEEE 754 double precision | | Double | float() | No separate double type | | Char | char() | Integer 0-1114111 (Unicode) | | Bool | boolean() | true / false atoms | | () (unit) | ok or {} | Often use ok atom |

Collection Types

| Haskell | Erlang | Notes | |---------|--------|-------| | [a] | [A] | Lists are similar, but eager | | String | string() | List of chars: [char()] | | Text | binary() | Prefer UTF-8 binaries | | ByteString | binary() | Direct mapping | | (a, b) | {A, B} | Tuples | | (a, b, c) | {A, B, C} | N-tuples supported | | Map k v | #{K => V} | Erlang maps (17+) | | Set a | sets:set(A) or ordsets:ordset(A) | Standard library modules |

Composite Types

| Haskell | Erlang | Notes | |---------|--------|-------| | data X = X { field :: Type } | -record(x, {field :: type()}) | Record syntax | | data X = X { field :: Type } | #{field => Type} | Or use maps | | newtype UserId = UserId Int | integer() or -type user_id() :: integer() | Type aliases only | | type Alias = Type | -type alias() :: type() | Type aliases | | data X = A \| B | Atoms or tagged tuples | Sum types | | data X = A Int \| B String | {a, integer()} \| {b, string()} | Tagged unions |

Function Types

| Haskell | Erlang | Notes | |---------|--------|-------| | a -> b | fun((A) -> B) | Single argument | | a -> b -> c | fun((A, B) -> C) | Multiple arguments (uncurried) | | IO a | fun(() -> A) | Thunk for lazy eval | | m a (monad) | Process or explicit state | Use processes for effects |

Monadic Types

| Haskell | Erlang | Notes | |---------|--------|-------| | Maybe a | undefined \| A | Or {ok, A} \| error | | Either e a | {ok, A} \| {error, E} | Standard error convention | | IO a | Side effects directly | No IO monad needed | | State s a | gen_server state | Use OTP behavior | | Reader r a | Pass as parameter | Or use process dictionary | | Writer w a | Accumulate in state | Or send messages |

---

Idiom Translation

Pattern: Maybe to ok/error

Haskell:

findUser :: UserId -> Maybe User
findUser uid = lookup uid users

getUserEmail :: UserId -> String
getUserEmail uid =
    case findUser uid of
        Just user -> email user
        Nothing -> "no-email@example.com"

Erlang:

-spec find_user(user_id()) -> {ok, user()} | error.
find_user(UserId) ->
    case lists:keyfind(UserId, #user.id, users()) of
        false -> error;
        User -> {ok, User}
    end.

-spec get_user_email(user_id()) -> string().
get_user_email(UserId) ->
    case find_user(UserId) of
        {ok, User} -> User#user.email;
        error -> "no-email@example.com"
    end.

Why this translation:

• Erlang has no Maybe type, uses atoms and tuples instead
• {ok, Value} | error is the standard Erlang convention
• Pattern matching works similarly in both languages

Pattern: Either to {ok, Value} | {error, Reason}

Haskell:

validateAge :: Int -> Either String Int
validateAge age
    | age < 0 = Left "Age cannot be negative"
    | age > 150 = Left "Age too high"
    | otherwise = Right age

validateEmail :: String -> Either String String
validateEmail email
    | '@' `elem` email = Right email
    | otherwise = Left "Invalid email"

createUser :: Int -> String -> Either String User
createUser age email = do
    validAge <- validateAge age
    validEmail <- validateEmail email
    return $ User validEmail validAge

Erlang:

-spec validate_age(integer()) -> {ok, integer()} | {error, string()}.
validate_age(Age) when Age < 0 ->
    {error, "Age cannot be negative"};
validate_age(Age) when Age > 150 ->
    {error, "Age too high"};
validate_age(Age) ->
    {ok, Age}.

-spec validate_email(string()) -> {ok, string()} | {error, string()}.
validate_email(Email) ->
    case lists:member($@, Email) of
        true -> {ok, Email};
        false -> {error, "Invalid email"}
    end.

-spec create_user(integer(), string()) -> {ok, user()} | {error, string()}.
create_user(Age, Email) ->
    case validate_age(Age) of
        {ok, ValidAge} ->
            case validate_email(Email) of
                {ok, ValidEmail} ->
                    {ok, #user{email = ValidEmail, age = ValidAge}};
                {error, Reason} ->
                    {error, Reason}
            end;
        {error, Reason} ->
            {error, Reason}
    end.

Why this translation:

• Either maps naturally to {ok, Value} | {error, Reason}
• Monadic do-notation becomes nested case statements
• Early returns via pattern matching replace bind operator

Pattern: List Comprehensions

Haskell:

-- Filter and map
evenSquares :: [Int] -> [Int]
evenSquares xs = [x^2 | x <- xs, even x]

-- Cartesian product
pairs :: [a] -> [b] -> [(a, b)]
pairs xs ys = [(x, y) | x <- xs, y <- ys]

-- Nested with guards
pythagoras :: Int -> [(Int, Int, Int)]
pythagoras n = [(a, b, c) | a <- [1..n],
                             b <- [a..n],
                             c <- [b..n],
                             a^2 + b^2 == c^2]

Erlang:

%% Filter and map
-spec even_squares([integer()]) -> [integer()].
even_squares(Xs) ->
    [X * X || X <- Xs, X rem 2 =:= 0].

%% Cartesian product
-spec pairs([A], [B]) -> [{A, B}].
pairs(Xs, Ys) ->
    [{X, Y} || X <- Xs, Y <- Ys].

%% Nested with guards
-spec pythagoras(integer()) -> [{integer(), integer(), integer()}].
pythagoras(N) ->
    [{A, B, C} || A <- lists:seq(1, N),
                   B <- lists:seq(A, N),
                   C <- lists:seq(B, N),
                   A * A + B * B =:= C * C].

Why this translation:

• List comprehensions translate almost directly
• Guards work similarly in both languages
• Syntax is nearly identical

Pattern: Recursive Functions

Haskell:

factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n - 1)

sum' :: [Int] -> Int
sum' [] = 0
sum' (x:xs) = x + sum' xs

map' :: (a -> b) -> [a] -> [b]
map' _ [] = []
map' f (x:xs) = f x : map' f xs

Erlang:

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

-spec sum([integer()]) -> integer().
sum([]) -> 0;
sum([X|Xs]) -> X + sum(Xs).

-spec map(fun((A) -> B), [A]) -> [B].
map(_, []) -> [];
map(F, [X|Xs]) -> [F(X) | map(F, Xs)].

Why this translation:

• Pattern matching translates directly
• Recursion works identically
• Guards provide additional safety in Erlang

Pattern: Higher-Order Functions

Haskell:

processItems :: [Item] -> [Result]
processItems items =
    items
    & filter isValid
    & map transform
    & map enrich
    & filter isComplete

-- Function composition
addThenDouble :: Int -> Int
addThenDouble = (*2) . (+1)

-- Partial application
add5 :: Int -> Int
add5 = (+5)

Erlang:

-spec process_items([item()]) -> [result()].
process_items(Items) ->
    lists:filter(fun is_complete/1,
        lists:map(fun enrich/1,
            lists:map(fun transform/1,
                lists:filter(fun is_valid/1, Items)))).

%% Or with pipes (shell syntax, not in modules)
%% Items
%%   |> lists:filter(fun is_valid/1)
%%   |> lists:map(fun transform/1)
%%   |> lists:map(fun enrich/1)
%%   |> lists:filter(fun is_complete/1).

%% Function composition - manual
-spec add_then_double(integer()) -> integer().
add_then_double(X) -> (X + 1) * 2.

%% Partial application - use fun wrapper
-spec add5(integer()) -> integer().
add5(X) -> X + 5.

%% Or return a fun
make_adder(N) -> fun(X) -> X + N end.

Why this translation:

• Erlang doesn't have built-in composition operators
• Functions are not curried by default
• Use nested calls or explicit intermediate variables
• Partial application requires wrapping in fun

---

Error Handling

Haskell Error Model → Erlang Error Model

| Haskell Pattern | Erlang Pattern | Use Case | |----------------|----------------|----------| | Maybe a | {ok, A} \| error | Simple success/failure | | Maybe a | undefined \| A | Nullable values | | Either String a | {ok, A} \| {error, Reason} | Errors with context | | Pure exception (error) | erlang:error(Reason) | Unrecoverable errors | | MonadError | Process exit/crash | Let it crash philosophy |

Exception Handling

Haskell:

-- Throwing errors
safeDivide :: Float -> Float -> Either String Float
safeDivide _ 0 = Left "division by zero"
safeDivide x y = Right (x / y)

-- Catching exceptions
parseConfig :: FilePath -> IO (Either String Config)
parseConfig path = do
    contents <- readFile path
    return $ case decode contents of
        Just config -> Right config
        Nothing -> Left "Failed to parse config"

Erlang:

%% Returning errors
-spec safe_divide(float(), float()) -> {ok, float()} | {error, string()}.
safe_divide(_, 0.0) ->
    {error, "division by zero"};
safe_divide(X, Y) ->
    {ok, X / Y}.

%% Try-catch for external calls
-spec parse_config(file:filename()) -> {ok, config()} | {error, term()}.
parse_config(Path) ->
    try
        {ok, Contents} = file:read_file(Path),
        case jsone:decode(Contents) of
            Config -> {ok, Config}
        end
    catch
        error:Reason -> {error, Reason}
    end.

Let It Crash vs Defensive Programming

Haskell (defensive):

processUser :: UserId -> IO (Either String Result)
processUser uid = do
    userResult <- fetchUser uid
    case userResult of
        Left err -> return $ Left err
        Right user -> do
            validationResult <- validateUser user
            case validationResult of
                Left err -> return $ Left err
                Right validUser -> do
                    saveResult <- saveUser validUser
                    case saveResult of
                        Left err -> return $ Left err
                        Right result -> return $ Right result

Erlang (let it crash):

%% Under supervisor, just crash on error
-spec process_user(user_id()) -> result().
process_user(UserId) ->
    User = fetch_user(UserId),        % Crash if not found
    ValidUser = validate_user(User),  % Crash if invalid
    save_user(ValidUser).             % Crash if save fails

%% Supervisor handles restart
-spec init([]) -> {ok, {supervisor:sup_flags(), [supervisor:child_spec()]}}.
init([]) ->
    SupFlags = #{
        strategy => one_for_one,
        intensity => 5,
        period => 60
    },
    ChildSpecs = [#{
        id => user_processor,
        start => {user_processor, start_link, []},
        restart => permanent,
        shutdown => 5000,
        type => worker
    }],
    {ok, {SupFlags, ChildSpecs}}.

Why this translation:

• Erlang embraces failure with supervision trees
• Don't handle every error - let supervisors restart failed processes
• Reserve error tuples for expected failures

---

Concurrency Patterns

IO Monad → Processes

Haskell:

-- Sequential IO operations
main :: IO ()
main = do
    putStrLn "Enter your name:"
    name <- getLine
    putStrLn $ "Hello, " ++ name

-- Concurrent operations with Async
import Control.Concurrent.Async

fetchData :: IO ()
fetchData = do
    (users, orders) <- concurrently fetchUsers fetchOrders
    processData users orders

Erlang:

%% Sequential operations (no special monad needed)
main() ->
    io:format("Enter your name:~n"),
    {ok, [Name]} = io:fread("", "~s"),
    io:format("Hello, ~s~n", [Name]).

%% Concurrent operations with processes
fetch_data() ->
    Parent = self(),
    spawn(fun() -> Parent ! {users, fetch_users()} end),
    spawn(fun() -> Parent ! {orders, fetch_orders()} end),

    Users = receive {users, U} -> U end,
    Orders = receive {orders, O} -> O end,

    process_data(Users, Orders).

State Monad → gen_server

Haskell:

import Control.Monad.State

type Counter a = State Int a

increment :: Counter ()
increment = modify (+1)

getCount :: Counter Int
getCount = get

program :: Counter Int
program = do
    increment
    increment
    increment
    getCount

main :: IO ()
main = print $ evalState program 0  -- Prints 3

Erlang:

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

%% API
-export([start_link/0, increment/0, get_count/0]).

%% gen_server callbacks
-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).

%% Callbacks
init([]) ->
    {ok, 0}.

handle_call(get_count, _From, Count) ->
    {reply, Count, Count}.

handle_cast(increment, Count) ->
    {noreply, Count + 1}.

%% Usage
main() ->
    {ok, _Pid} = counter:start_link(),
    counter:increment(),
    counter:increment(),
    counter:increment(),
    Count = counter:get_count(),
    io:format("~p~n", [Count]).  % Prints 3

STM → ETS or gen_server

Haskell:

import Control.Concurrent.STM

type Account = TVar Int

transfer :: Account -> Account -> Int -> STM ()
transfer from to amount = do
    fromBalance <- readTVar from
    when (fromBalance < amount) retry
    modifyTVar from (subtract amount)
    modifyTVar to (+ amount)

main :: IO ()
main = do
    account1 <- newTVarIO 1000
    account2 <- newTVarIO 0
    atomically $ transfer account1 account2 500

Erlang (using ETS):

-module(bank).
-export([init/0, transfer/3]).

init() ->
    ets:new(accounts, [named_table, public, set]),
    ets:insert(accounts, {account1, 1000}),
    ets:insert(accounts, {account2, 0}).

transfer(From, To, Amount) ->
    % Note: ETS operations are not atomic across multiple keys
    % For true atomicity, use gen_server or mnesia transactions
    [{From, FromBalance}] = ets:lookup(accounts, From),

    if FromBalance >= Amount ->
        ets:update_counter(accounts, From, {2, -Amount}),
        ets:update_counter(accounts, To, {2, Amount}),
        ok;
    true ->
        {error, insufficient_funds}
    end.

Erlang (using gen_server for atomicity):

-module(bank_server).
-behaviour(gen_server).

-export([start_link/0, transfer/3]).
-export([init/1, handle_call/3]).

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

transfer(From, To, Amount) ->
    gen_server:call(?MODULE, {transfer, From, To, Amount}).

init([]) ->
    State = #{account1 => 1000, account2 => 0},
    {ok, State}.

handle_call({transfer, From, To, Amount}, _From, State) ->
    FromBalance = maps:get(From, State),
    if FromBalance >= Amount ->
        NewState = State#{
            From => FromBalance - Amount,
            To => maps:get(To, State) + Amount
        },
        {reply, ok, NewState};
    true ->
        {reply, {error, insufficient_funds}, State}
    end.

Why this translation:

• Erlang has no STM; use ETS for shared state or gen_server for atomicity
• gen_server provides serialized access (single-threaded state)
• For distributed transactions, use Mnesia

---

Memory & Evaluation

Lazy → Eager Evaluation

Haskell (lazy):

-- Infinite lists
naturals :: [Integer]
naturals = [1..]

take10 :: [Integer]
take10 = take 10 naturals  -- Only evaluates first 10

-- Lazy evaluation benefits
expensiveComputation :: Int -> Int
expensiveComputation x = trace ("Computing " ++ show x) (x * 2)

result = if condition
         then take 5 $ map expensiveComputation [1..1000]
         else []
-- Only computes first 5 if condition is True

Erlang (eager):

%% No infinite lists - must be explicit
naturals(N) -> lists:seq(1, N).

take10() -> lists:sublist(naturals(10), 10).

%% Must be careful with large computations
expensive_computation(X) ->
    io:format("Computing ~p~n", [X]),
    X * 2.

result(Condition) ->
    case Condition of
        true ->
            %% All 1000 items are computed, then we take 5
            lists:sublist(lists:map(fun expensive_computation/1,
                                     lists:seq(1, 1000)), 5);
        false ->
            []
    end.

%% Better: Use lazy construction
result_lazy(Condition) ->
    case Condition of
        true ->
            %% Compute only what's needed
            [expensive_computation(X) || X <- lists:seq(1, 5)];
        false ->
            []
    end.

Thunks for Delayed Evaluation

Haskell:

-- Lazy by default
expensiveValue :: Int
expensiveValue = sum [1..1000000]

useValue :: Bool -> Int
useValue False = 0
useValue True = expensiveValue  -- Only computed if needed

Erlang:

%% Use fun() for thunks
expensive_value() -> lists:sum(lists:seq(1, 1000000)).

use_value(false) -> 0;
use_value(true) -> expensive_value().  % Computed every time called

%% Or pass as thunk
use_value_lazy(false, _Thunk) -> 0;
use_value_lazy(true, Thunk) -> Thunk().

%% Usage
Result = use_value_lazy(true, fun expensive_value/0).

Why this translation:

• Erlang is eager by default
• Use fun() to create thunks for delayed evaluation
• Be explicit about when computation happens

---

Common Pitfalls

1. Assuming laziness: Erlang evaluates eagerly. Infinite lists don't work; be careful with large computations.

2. Missing currying: Haskell functions are curried by default; Erlang functions take all arguments at once. Use fun wrappers for partial application.

3. Type safety assumptions: Haskell's type system catches errors at compile time; Erlang catches them at runtime. Add comprehensive tests.

4. Monadic composition: Haskell's >>= and do-notation have no direct equivalent. Use nested case statements or helper functions.

5. Defensive error handling: Don't translate Haskell's comprehensive error handling to defensive Erlang code. Embrace "let it crash" with supervision.

6. Immutability patterns: Both languages are immutable, but Erlang uses processes for state instead of monads. Don't try to replicate State monad patterns.

7. String handling: Haskell String is [Char]; Erlang string() is [char()]. Prefer binary() in Erlang for efficiency.

8. Pattern matching limitations: Erlang guards are more limited than Haskell's. Can't call arbitrary functions in guards.

9. Type class translation: Haskell type classes don't map directly to Erlang behaviors. Behaviors are for OTP patterns, not ad-hoc polymorphism.

10. Performance expectations: Pure functional Haskell can be optimized heavily by GHC. Erlang prioritizes fault tolerance and concurrency over raw speed.

---

Tooling

| Tool | Purpose | Notes | |------|---------|-------| | Manual translation | Convert code by hand | No mature transpiler exists | | Dialyzer | Static analysis for Erlang | Type specs help catch errors | | EUnit | Unit testing | Port Haskell HSpec tests | | PropEr | Property-based testing | Similar to QuickCheck | | Common Test | Integration testing | For OTP application testing | | Rebar3 | Build tool | Like Cabal/Stack | | Observer | Runtime inspection | Monitor processes, memory |

---

Examples

Example 1: Simple - Pure Function Translation

Before (Haskell):

-- Calculate factorial
factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n - 1)

-- Filter even numbers
evens :: [Int] -> [Int]
evens xs = [x | x <- xs, even x]

After (Erlang):

%% Calculate factorial
-spec factorial(integer()) -> integer().
factorial(0) -> 1;
factorial(N) when N > 0 -> N * factorial(N - 1).

%% Filter even numbers
-spec evens([integer()]) -> [integer()].
evens(Xs) -> [X || X <- Xs, X rem 2 =:= 0].

Example 2: Medium - Maybe and List Processing

Before (Haskell):

data User = User { userId :: Int, userName :: String, userEmail :: String }

findUser :: Int -> [User] -> Maybe User
findUser uid users = find (\u -> userId u == uid) users

getUserEmails :: [Int] -> [User] -> [String]
getUserEmails ids users =
    mapMaybe (\uid -> fmap userEmail $ findUser uid users) ids

processUserData :: [Int] -> [User] -> [String]
processUserData ids users =
    getUserEmails ids users
    & filter (not . null)
    & map (\email -> "Email: " ++ email)

After (Erlang):

-record(user, {
    user_id :: integer(),
    user_name :: string(),
    user_email :: string()
}).

-spec find_user(integer(), [#user{}]) -> {ok, #user{}} | error.
find_user(UserId, Users) ->
    case lists:filter(fun(U) -> U#user.user_id =:= UserId end, Users) of
        [User|_] -> {ok, User};
        [] -> error
    end.

-spec get_user_emails([integer()], [#user{}]) -> [string()].
get_user_emails(Ids, Users) ->
    lists:filtermap(
        fun(UserId) ->
            case find_user(UserId, Users) of
                {ok, User} -> {true, User#user.user_email};
                error -> false
            end
        end,
        Ids
    ).

-spec process_user_data([integer()], [#user{}]) -> [string()].
process_user_data(Ids, Users) ->
    Emails = get_user_emails(Ids, Users),
    Filtered = lists:filter(fun(E) -> E =/= "" end, Emails),
    lists:map(fun(Email) -> "Email: " ++ Email end, Filtered).

Example 3: Complex - Stateful Server with Error Handling

Before (Haskell):

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

import Control.Monad.State
import Control.Monad.Except
import qualified Data.Map as Map

type UserId = Int
type SessionId = String

data User = User
    { userId :: UserId
    , userName :: String
    } deriving (Show, Eq)

data AppError
    = UserNotFound UserId
    | InvalidSession SessionId
    | DatabaseError String
    deriving (Show)

type Sessions = Map.Map SessionId UserId
type Users = Map.Map UserId User

data AppState = AppState
    { appSessions :: Sessions
    , appUsers :: Users
    } deriving (Show)

newtype App a = App
    { runApp :: ExceptT AppError (State AppState) a
    } deriving (Functor, Applicative, Monad, MonadState AppState, MonadError AppError)

createSession :: UserId -> App SessionId
createSession uid = do
    users <- gets appUsers
    case Map.lookup uid users of
        Nothing -> throwError $ UserNotFound uid
        Just _ -> do
            let sessionId = "session-" ++ show uid
            modify $ \s -> s { appSessions = Map.insert sessionId uid (appSessions s) }
            return sessionId

getUser :: SessionId -> App User
getUser sessionId = do
    sessions <- gets appSessions
    case Map.lookup sessionId sessions of
        Nothing -> throwError $ InvalidSession sessionId
        Just uid -> do
            users <- gets appUsers
            case Map.lookup uid users of
                Nothing -> throwError $ UserNotFound uid
                Just user -> return user

logout :: SessionId -> App ()
logout sessionId = do
    sessions <- gets appSessions
    unless (Map.member sessionId sessions) $
        throwError $ InvalidSession sessionId
    modify $ \s -> s { appSessions = Map.delete sessionId (appSessions s) }

-- Usage
runProgram :: AppState -> Either AppError (SessionId, AppState)
runProgram initialState =
    let action = do
            sid <- createSession 1
            user <- getUser sid
            logout sid
            return sid
    in runState (runExceptT $ runApp action) initialState

After (Erlang):

-module(session_server).
-behaviour(gen_server).

%% API
-export([start_link/0, create_session/1, get_user/1, logout/1]).

%% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, terminate/2]).

-record(user, {
    user_id :: integer(),
    user_name :: string()
}).

-record(state, {
    sessions :: #{session_id() => user_id()},
    users :: #{user_id() => #user{}}
}).

-type user_id() :: integer().
-type session_id() :: string().
-type error_reason() :: {user_not_found, user_id()}
                      | {invalid_session, session_id()}
                      | {database_error, string()}.

%%% API Functions

-spec start_link() -> {ok, pid()} | {error, term()}.
start_link() ->
    gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).

-spec create_session(user_id()) -> {ok, session_id()} | {error, error_reason()}.
create_session(UserId) ->
    gen_server:call(?MODULE, {create_session, UserId}).

-spec get_user(session_id()) -> {ok, #user{}} | {error, error_reason()}.
get_user(SessionId) ->
    gen_server:call(?MODULE, {get_user, SessionId}).

-spec logout(session_id()) -> ok | {error, error_reason()}.
logout(SessionId) ->
    gen_server:call(?MODULE, {logout, SessionId}).

%%% gen_server Callbacks

init([]) ->
    %% Initialize with sample user
    Users = #{1 => #user{user_id = 1, user_name = "Alice"}},
    {ok, #state{sessions = #{}, users = Users}}.

handle_call({create_session, UserId}, _From, State) ->
    #state{sessions = Sessions, users = Users} = State,
    case maps:is_key(UserId, Users) of
        false ->
            {reply, {error, {user_not_found, UserId}}, State};
        true ->
            SessionId = "session-" ++ integer_to_list(UserId),
            NewSessions = maps:put(SessionId, UserId, Sessions),
            NewState = State#state{sessions = NewSessions},
            {reply, {ok, SessionId}, NewState}
    end;

handle_call({get_user, SessionId}, _From, State) ->
    #state{sessions = Sessions, users = Users} = State,
    case maps:get(SessionId, Sessions, undefined) of
        undefined ->
            {reply, {error, {invalid_session, SessionId}}, State};
        UserId ->
            case maps:get(UserId, Users, undefined) of
                undefined ->
                    {reply, {error, {user_not_found, UserId}}, State};
                User ->
                    {reply, {ok, User}, State}
            end
    end;

handle_call({logout, SessionId}, _From, State) ->
    #state{sessions = Sessions} = State,
    case maps:is_key(SessionId, Sessions) of
        false ->
            {reply, {error, {invalid_session, SessionId}}, State};
        true ->
            NewSessions = maps:remove(SessionId, Sessions),
            NewState = State#state{sessions = NewSessions},
            {reply, ok, NewState}
    end.

handle_cast(_Msg, State) ->
    {noreply, State}.

terminate(_Reason, _State) ->
    ok.

%%% Usage Example

run_program() ->
    {ok, _Pid} = start_link(),
    {ok, SessionId} = create_session(1),
    {ok, _User} = get_user(SessionId),
    ok = logout(SessionId),
    {ok, SessionId}.

Key differences in this example:

• Haskell's monad transformers become gen_server state
• ExceptT error handling becomes {ok, Value} | {error, Reason} tuples
• State monad becomes gen_server process state
• Pattern matching and guards handle all error cases
• OTP behavior provides structure and supervision

---

See Also

For more examples and patterns, see:

• meta-convert-dev - Foundational patterns with cross-language examples
• convert-erlang-haskell - Reverse conversion (Erlang → Haskell)
• lang-haskell-dev - Haskell development patterns
• lang-erlang-dev - Erlang development patterns

Cross-cutting pattern skills:

• patterns-concurrency-dev - Processes, supervision, fault tolerance
• patterns-serialization-dev - Data encoding, validation
• patterns-metaprogramming-dev - Compile-time code generation