Convert Roc to Haskell

Convert Roc code to idiomatic Haskell. This skill extends meta-convert-dev with Roc-to-Haskell specific type mappings, idiom translations, and tooling for migrating platform-based Roc code to pure functional Haskell.

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: Roc types → Haskell types
• Idiom translations: Roc patterns → idiomatic Haskell
• Error handling: Roc Result → Haskell Either/Maybe
• Platform model: Roc applications/platforms → Haskell IO/mtl
• Abilities: Roc abilities → Haskell type classes
• Tag unions: Roc structural tags → Haskell algebraic data types

This Skill Does NOT Cover

• General conversion methodology - see meta-convert-dev
• Roc language fundamentals - see lang-roc-dev
• Haskell language fundamentals - see lang-haskell-dev
• Reverse conversion (Haskell → Roc) - see convert-haskell-roc
• Platform development - Both use different models; design from scratch

---

Quick Reference

Roc	Haskell	Notes
Str	String or Text	Use Text for production
U8, U16, U32, U64	Word8, Word16, Word32, Word64	Unsigned integers
I8, I16, I32, I64	Int8, Int16, Int32, Int64	Signed integers
F32, F64	Float, Double	Floating point
Bool	Bool	Direct mapping
List a	[a]	Lists
Dict k v	Map k v	Use Data.Map
Set a	Set a	Use Data.Set
Result a e	Either e a	Note reversed type params
[Tag1, Tag2]	data X = Tag1 | Tag2	Sum types
{ field : Type }	data X = X { field :: Type }	Records
Task a err	IO a or ExceptT err IO a	Effects
where a implements Ability	(TypeClass a) =>	Constraints

When Converting Code

1. Analyze platform boundaries - Understand where Roc platform ends and application begins
2. Map types first - Roc's structural types need explicit Haskell ADTs
3. Preserve semantics over syntax similarity
4. Embrace laziness - Haskell is lazy by default; Roc is strict
5. Handle effects properly - Roc Tasks become IO or monad transformers
6. Test equivalence - Same inputs → same outputs for pure logic

---

Type System Mapping

Primitive Types

Roc	Haskell	Notes
Str	String	List of Char (less efficient)
Str	Text	Preferred from Data.Text
U8	Word8	From Data.Word
U16	Word16	From Data.Word
U32	Word32	From Data.Word
U64	Word64	From Data.Word
U128	Integer	No direct u128, use arbitrary precision
I8	Int8	From Data.Int
I16	Int16	From Data.Int
I32	Int32	From Data.Int
I64	Int64	From Data.Int
I128	Integer	Arbitrary precision
F32	Float	32-bit float
F64	Double	64-bit float
Bool	Bool	Direct mapping
Num a	Polymorphic number	Use type classes

Collection Types

Roc	Haskell	Notes
List a	[a]	Linked list
List a	Vector a	For indexed access (Data.Vector)
Dict k v	Map k v	From Data.Map
Set a	Set a	From Data.Set

Composite Types

Roc	Haskell	Notes
{ name : Str, age : U32 }	data User = User { name :: Text, age :: Word32 }	Record syntax
[Ok a, Err e]	Either e a	Note: type params reversed!
[Some a, None]	Maybe a	Optional values
[Tag1, Tag2, Tag3]	data X = Tag1 | Tag2 | Tag3	Sum types
[Tag(T)]	data X = Tag T	Tag with payload

Function Types

Roc	Haskell	Notes
a -> b	a -> b	Simple function
a, b -> c	a -> b -> c	Curried by default
a -> b where a implements Eq	(Eq a) => a -> b	Type class constraint

---

Idiom Translation

Pattern 1: Records and Record Updates

Roc:

user = { name: "Alice", age: 30, email: "alice@example.com" }

# Update syntax
olderUser = { user & age: 31 }

# Field access
userName = user.name

Haskell:

data User = User
    { name :: Text
    , age :: Word32
    , email :: Text
    } deriving (Show, Eq)

user = User "Alice" 30 "alice@example.com"

-- Update syntax
olderUser = user { age = 31 }

-- Field access (auto-generated accessor functions)
userName = name user

Why this translation:

• Roc's anonymous records need named data declarations in Haskell
• Both support record update syntax, but Haskell generates accessor functions
• Haskell requires explicit type declarations; Roc infers structural types

Pattern 2: Tag Unions and Pattern Matching

Roc:

# Tag union
Color : [Red, Yellow, Green, Custom(U8, U8, U8)]

# Pattern matching
colorName = when color is
    Red -> "red"
    Yellow -> "yellow"
    Green -> "green"
    Custom(r, g, b) -> "rgb(\(Num.toStr(r)), \(Num.toStr(g)), \(Num.toStr(b)))"

Haskell:

-- Algebraic data type
data Color
    = Red
    | Yellow
    | Green
    | Custom Word8 Word8 Word8
    deriving (Show, Eq)

-- Pattern matching with case
colorName :: Color -> String
colorName color = case color of
    Red -> "red"
    Yellow -> "yellow"
    Green -> "green"
    Custom r g b -> "rgb(" ++ show r ++ ", " ++ show g ++ ", " ++ show b ++ ")"

-- Or with function patterns
colorName' :: Color -> String
colorName' Red = "red"
colorName' Yellow = "yellow"
colorName' Green = "green"
colorName' (Custom r g b) = "rgb(" ++ show r ++ ", " ++ show g ++ ", " ++ show b ++ ")"

Why this translation:

• Roc's structural tag unions become nominal ADTs in Haskell
• Both enforce exhaustive pattern matching
• Haskell allows pattern matching in function definitions, not just case expressions

Pattern 3: Result Type and Error Handling

Roc:

divide : I64, I64 -> Result I64 [DivByZero]
divide = \a, b ->
    if b == 0 then
        Err(DivByZero)
    else
        Ok(a // b)

# Using try (!) for propagation
calculate : I64, I64, I64 -> Result I64 [DivByZero]
calculate = \a, b, c ->
    x = divide!(a, b)
    y = divide!(x, c)
    Ok(y)

Haskell:

-- Either for errors (note reversed params from Roc)
data DivError = DivByZero deriving (Show, Eq)

divide :: Int64 -> Int64 -> Either DivError Int64
divide a 0 = Left DivByZero
divide a b = Right (a `div` b)

-- Using do-notation for propagation
calculate :: Int64 -> Int64 -> Int64 -> Either DivError Int64
calculate a b c = do
    x <- divide a b
    y <- divide x c
    return y

-- Or with applicative style
calculate' :: Int64 -> Int64 -> Int64 -> Either DivError Int64
calculate' a b c =
    divide a b >>= \x ->
    divide x c

Why this translation:

• Roc's Result a e maps to Haskell's Either e a (type params reversed!)
• Roc's ! suffix maps to Haskell's <- in do-notation
• Both provide monadic error propagation
• Haskell's Either is more general (any error type), Roc uses tag unions

Pattern 4: Abilities to Type Classes

Roc:

# Using ability constraint
toString : a -> Str where a implements Inspect
toString = \value ->
    Inspect.toStr(value)

# Custom type automatically implements abilities
User : {
    name : Str,
    age : U32,
}

user = { name: "Alice", age: 30 }
expect Inspect.toStr(user) == "{ name: \"Alice\", age: 30 }"

Haskell:

-- Type class constraint
toString :: (Show a) => a -> String
toString value = show value

-- Custom type with deriving
data User = User
    { name :: Text
    , age :: Word32
    } deriving (Show, Eq)

user = User "Alice" 30
-- show user == "User {name = \"Alice\", age = 30}"

Why this translation:

• Roc abilities are similar to Haskell type classes
• Roc auto-derives abilities; Haskell requires explicit deriving clauses
• Haskell has more established type classes (Functor, Monad, etc.)

Pattern 5: List Pipeline Operations

Roc:

numbers = [1, 2, 3, 4, 5]

result = numbers
    |> List.map(\n -> n * 2)
    |> List.keepIf(\n -> n > 5)
    |> List.walk(0, \acc, n -> acc + n)

Haskell:

import Data.Function ((&))

numbers = [1, 2, 3, 4, 5]

-- Using function composition (right to left)
result = foldr (+) 0 . filter (>5) . map (*2) $ numbers

-- Or using & operator (left to right, like Roc)
result' = numbers
    & map (*2)
    & filter (>5)
    & foldr (+) 0

Why this translation:

• Roc's |> maps to Haskell's & operator
• Function composition . is more idiomatic but reads backward
• Haskell's foldr/foldl map to Roc's List.walk

---

Error Handling

Result → Either Translation

Type Mapping:

Roc:     Result a e
         [Ok a, Err e]

Haskell: Either e a
         Left e | Right a

Key Difference: Type parameters are reversed!

Roc:

parseAge : Str -> Result U32 [ParseError Str]
parseAge = \str ->
    when Str.toU32(str) is
        Ok(n) -> Ok(n)
        Err(_) -> Err(ParseError("Not a valid number"))

# Chain operations
validateUser : Str, Str -> Result User [ParseError Str, InvalidEmail]
validateUser = \ageStr, emailStr ->
    age = parseAge!(ageStr)
    email = validateEmail!(emailStr)
    Ok({ name: "User", age, email })

Haskell:

import Text.Read (readMaybe)
import Data.Text (Text)

data ValidationError
    = ParseError String
    | InvalidEmail
    deriving (Show, Eq)

parseAge :: Text -> Either ValidationError Word32
parseAge str =
    case readMaybe (unpack str) of
        Just n -> Right n
        Nothing -> Left (ParseError "Not a valid number")

-- Chain with do-notation
validateUser :: Text -> Text -> Either ValidationError User
validateUser ageStr emailStr = do
    age <- parseAge ageStr
    email <- validateEmail emailStr
    return $ User "User" age email

Multiple Error Types

Roc:

# Tag union for multiple errors
Error : [ParseError Str, DivByZero, NetworkError Str]

process : Str, Str -> Result I64 Error
process = \aStr, bStr ->
    a = Str.toI64!(aStr) |> Result.mapErr(\_ -> ParseError("Invalid a"))
    b = Str.toI64!(bStr) |> Result.mapErr(\_ -> ParseError("Invalid b"))
    divide!(a, b) |> Result.mapErr(\_ -> DivByZero)

Haskell:

data Error
    = ParseError String
    | DivByZero
    | NetworkError String
    deriving (Show, Eq)

process :: Text -> Text -> Either Error Int64
process aStr bStr = do
    a <- parseI64 aStr `mapLeft` const (ParseError "Invalid a")
    b <- parseI64 bStr `mapLeft` const (ParseError "Invalid b")
    divide a b `mapLeft` const DivByZero
  where
    mapLeft f (Left e) = Left (f e)
    mapLeft _ (Right x) = Right x

---

Platform Model Translation

Roc Platform/Application → Haskell IO

Roc Application:

app [main] {
    pf: platform "https://github.com/roc-lang/basic-cli/releases/..."
}

import pf.Stdout
import pf.Task exposing [Task]
import pf.File

main : Task {} []
main =
    content = File.readUtf8!("input.txt")
    processed = Str.toUpper(content)
    File.writeUtf8!("output.txt", processed)
    Stdout.line!("Done!")

Haskell:

import qualified Data.Text.IO as TIO
import qualified Data.Text as T
import System.IO

main :: IO ()
main = do
    content <- TIO.readFile "input.txt"
    let processed = T.toUpper content
    TIO.writeFile "output.txt" processed
    putStrLn "Done!"

Key Differences:

• Roc separates platform (I/O) from application (pure code)
• Haskell uses IO monad throughout
• Roc's ! suffix maps to Haskell's <- in do-notation
• Both use monadic composition for effects

Task Error Handling

Roc:

readConfig : Str -> Task Config [FileNotFound, ParseError Str]
readConfig = \path ->
    content = File.readUtf8!(path)  # May fail with FileNotFound
    when parseJson(content) is
        Ok(config) -> Task.ok(config)
        Err(e) -> Task.err(ParseError(e))

Haskell:

import Control.Monad.Except
import qualified Data.Text.IO as TIO

data ConfigError
    = FileNotFound
    | ParseError String
    deriving (Show, Eq)

readConfig :: FilePath -> ExceptT ConfigError IO Config
readConfig path = do
    contentE <- liftIO $ try $ TIO.readFile path
    content <- case contentE of
        Left (_ :: IOException) -> throwError FileNotFound
        Right c -> return c
    case parseJson content of
        Left e -> throwError (ParseError e)
        Right config -> return config

Why this translation:

• Roc Tasks with error types map to ExceptT err IO a
• Both provide error propagation and recovery
• Haskell separates IO errors (exceptions) from domain errors (Either/ExceptT)

---

Concurrency Patterns

Roc Task Concurrency → Haskell Async

Roc:

# Platform-provided concurrency
import pf.Task exposing [Task]
import pf.Http

fetchBoth : Task (Str, Str) [HttpErr]
fetchBoth =
    # Platform may execute concurrently
    Task.parallel2(
        Http.get("http://api.example.com/1"),
        Http.get("http://api.example.com/2")
    )

Haskell:

import Control.Concurrent.Async
import Network.HTTP.Simple

fetchBoth :: IO (ByteString, ByteString)
fetchBoth = concurrently
    (getResponseBody <$> httpBS "http://api.example.com/1")
    (getResponseBody <$> httpBS "http://api.example.com/2")

-- Or with race (first wins)
fetchFirst :: IO ByteString
fetchFirst = race
    (getResponseBody <$> httpBS "http://api.example.com/1")
    (getResponseBody <$> httpBS "http://api.example.com/2")
    >>= either return return

Why this translation:

• Roc delegates all concurrency to the platform
• Haskell provides explicit concurrency primitives (async library)
• Both provide structured concurrency with proper cleanup

No Direct Threading

Roc:

# Roc applications don't directly manage threads
# All concurrency is platform capability
# Task composition is the only abstraction

Haskell:

import Control.Concurrent

-- Haskell provides lightweight threads
main = do
    forkIO $ do
        threadDelay 1000000
        putStrLn "Hello from thread"
    putStrLn "Main thread continues"
    threadDelay 2000000

-- Use async for structured concurrency (recommended)
import Control.Concurrent.Async

main' = do
    a <- async $ do
        threadDelay 1000000
        return "result"
    result <- wait a
    print result

---

Laziness Translation

Roc (Strict) → Haskell (Lazy)

Roc:

# Roc is strict by default
numbers = [1, 2, 3, 4, 5]

# This evaluates immediately
doubled = List.map(numbers, \n -> n * 2)

# Infinite lists require Stream or explicit laziness
naturals = Stream.iterate(0, \n -> n + 1)

Haskell:

-- Haskell is lazy by default
numbers = [1, 2, 3, 4, 5]

-- This creates a thunk, evaluated on demand
doubled = map (*2) numbers

-- Infinite lists work naturally
naturals = iterate (+1) 0
take 10 naturals  -- [0,1,2,3,4,5,6,7,8,9]

-- Force strict evaluation when needed
import Control.DeepSeq

strictDoubled = force $ map (*2) numbers

Key Differences:

• Roc evaluates eagerly; add explicit limits before processing
• Haskell evaluates lazily; infinite structures work out of the box
• When converting, be careful with space leaks in Haskell (use seq, $!, or strict data structures)

---

Common Pitfalls

1. Result Type Parameter Order

❌ Assuming Roc Result and Haskell Either have same param order
✓ Remember: Result a e → Either e a (reversed!)

Roc:

divide : I64, I64 -> Result I64 [DivByZero]
#                    Result ^ok  ^err

Haskell:

divide :: Int64 -> Int64 -> Either DivError Int64
--                          Either ^err     ^ok

2. Structural vs Nominal Types

❌ Using Haskell tuples for Roc records
✓ Define proper ADTs with record syntax

Roc:

user = { name: "Alice", age: 30 }  # Structural type

Haskell:

-- Wrong: (Text, Word32)  -- Positional, no field names
-- Right:
data User = User { name :: Text, age :: Word32 }

3. Platform Boundary Confusion

❌ Trying to replicate Roc's platform model in Haskell
✓ Use IO monad or mtl transformers for effects

4. Strict vs Lazy Semantics

❌ Assuming Roc's eager evaluation in Haskell
✓ Add explicit limits (take, drop) before consuming infinite lists
✓ Use strict variants when performance matters (foldl', force)

5. Ability Auto-Derivation

❌ Expecting Haskell to auto-derive like Roc
✓ Add explicit deriving clauses (Show, Eq, etc.)

---

Tooling

Tool	Purpose	Notes
GHC	Haskell compiler	Primary compiler
GHCi	REPL	Interactive development
Stack	Build tool	Dependency management, reproducible builds
Cabal	Build tool	Alternative to Stack
HLint	Linter	Code suggestions
Ormolu / Brittany	Formatter	Code formatting
hspec / QuickCheck	Testing	Unit and property-based tests

No direct Roc→Haskell transpiler exists; conversion is manual.

---

Examples

Example 1: Simple - Tag Union Pattern Matching

Before (Roc):

Status : [Pending, Approved, Rejected]

handleStatus : Status -> Str
handleStatus = \status ->
    when status is
        Pending -> "Waiting..."
        Approved -> "Done!"
        Rejected -> "Failed"

After (Haskell):

data Status = Pending | Approved | Rejected
    deriving (Show, Eq)

handleStatus :: Status -> String
handleStatus Pending = "Waiting..."
handleStatus Approved = "Done!"
handleStatus Rejected = "Failed"

Example 2: Medium - Result with Error Propagation

Before (Roc):

divide : I64, I64 -> Result I64 [DivByZero]
divide = \a, b ->
    if b == 0 then
        Err(DivByZero)
    else
        Ok(a // b)

calculate : I64, I64, I64 -> Result I64 [DivByZero]
calculate = \a, b, c ->
    x = divide!(a, b)
    y = divide!(x, c)
    Ok(y)

# Usage
when calculate(20, 4, 2) is
    Ok(result) -> Num.toStr(result)
    Err(DivByZero) -> "Error: division by zero"

After (Haskell):

data DivError = DivByZero
    deriving (Show, Eq)

divide :: Int64 -> Int64 -> Either DivError Int64
divide _ 0 = Left DivByZero
divide a b = Right (a `div` b)

calculate :: Int64 -> Int64 -> Int64 -> Either DivError Int64
calculate a b c = do
    x <- divide a b
    y <- divide x c
    return y

-- Usage
result = case calculate 20 4 2 of
    Right r -> show r
    Left DivByZero -> "Error: division by zero"

Example 3: Complex - Platform Application to IO

Before (Roc):

app [main] {
    pf: platform "https://github.com/roc-lang/basic-cli/releases/..."
}

import pf.Stdout
import pf.File
import pf.Task exposing [Task]

Config : { port : U16, host : Str }

parseConfig : Str -> Result Config [ParseError Str]
parseConfig = \content ->
    # Parse JSON content
    when Json.decode(content) is
        Ok(config) -> Ok(config)
        Err(e) -> Err(ParseError(e))

main : Task {} []
main =
    # Read config file
    content = File.readUtf8!("config.json")

    # Parse config
    config = when parseConfig(content) is
        Ok(c) -> Task.ok!(c)
        Err(ParseError(msg)) ->
            Stdout.line!("Config error: \(msg)")
            Task.err!(ConfigError)

    # Use config
    Stdout.line!("Starting server on \(config.host):\(Num.toStr(config.port))")

After (Haskell):

{-# LANGUAGE DeriveGeneric #-}

import qualified Data.Text.IO as TIO
import qualified Data.Text as T
import Data.Aeson (FromJSON, eitherDecode)
import GHC.Generics
import Control.Monad.Except
import qualified Data.ByteString.Lazy as BL

data Config = Config
    { port :: Word16
    , host :: Text
    } deriving (Generic, Show)

instance FromJSON Config

data AppError
    = ParseError String
    | ConfigError
    deriving (Show, Eq)

parseConfig :: BL.ByteString -> Either AppError Config
parseConfig content =
    case eitherDecode content of
        Right config -> Right config
        Left err -> Left (ParseError err)

main :: IO ()
main = do
    result <- runExceptT $ do
        -- Read config file
        content <- liftIO $ BL.readFile "config.json"

        -- Parse config
        config <- case parseConfig content of
            Right c -> return c
            Left (ParseError msg) -> do
                liftIO $ putStrLn $ "Config error: " ++ msg
                throwError ConfigError

        -- Use config
        liftIO $ putStrLn $
            "Starting server on " ++ T.unpack (host config)
            ++ ":" ++ show (port config)

    case result of
        Left err -> putStrLn $ "Error: " ++ show err
        Right _ -> return ()

---

See Also

For more examples and patterns, see:

• meta-convert-dev - Foundational patterns with cross-language examples
• convert-elm-haskell - Similar pure functional language conversion
• lang-roc-dev - Roc development patterns
• lang-haskell-dev - Haskell development patterns

Cross-cutting pattern skills:

• patterns-concurrency-dev - Compare Roc Task model with Haskell async/STM
• patterns-serialization-dev - JSON handling across languages
• patterns-metaprogramming-dev - Template Haskell vs no metaprogramming in Roc