Convert Roc to F#

Convert Roc code to idiomatic F#. This skill extends

meta-convert-dev

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 → F# types
• Idiom translations: Roc patterns → idiomatic F#
• Error handling: Roc Result/tag unions → F# Result/Option
• Platform shift: Roc platform model → .NET runtime
• Paradigm alignment: Both functional-first, but different architectures

This Skill Does NOT Cover

• General conversion methodology - see

  meta-convert-dev

• Roc language fundamentals - see

  lang-roc-dev

• F# language fundamentals - see

  lang-fsharp-dev

• Reverse conversion (F# → Roc) - see

  convert-fsharp-roc

Quick Reference

Str

string

I64

int64

I32

int

F64

float

double

Bool

bool

List a

'a list

Dict k v

Map<'k,'v>

Set a

Set<'a>

[Some a, None]

Option<'a>

Result a e

Result<'a,'e>

{ ... }

[...]

type X = ...

Task a err

Async<'a>

Task<'a>

{}

unit

When Converting Code

1. Analyze source thoroughly before writing target
2. Map types first - create type equivalence table
3. Preserve semantics over syntax similarity
4. Adopt F# idioms - leverage .NET ecosystem
5. Handle edge cases - error paths, effects, resource management
6. Test equivalence - same inputs → same outputs

Paradigm Translation

Mental Model Shift: Platform Model → .NET Runtime

Both Roc and F# are functional-first languages, but they differ fundamentally in how they handle effects:

Task ok err

Async<'a>

Architecture Mental Model

Roc (Platform Model)              F# (.NET)
┌─────────────────────┐           ┌─────────────────────┐
│   Your Roc Code     │           │   Your F# Code      │
│   (pure only)       │           │  (can do I/O)       │
│   ↓                 │           │  ↓                  │
│   Platform API      │           │   .NET BCL          │
│   ↓                 │           │   ↓                 │
│   Platform Host     │           │   CLR Runtime       │
└─────────────────────┘           └─────────────────────┘
    Clear separation                   Everything in
    between pure & effects              same runtime

Key shift: In Roc, I/O goes through the platform's

Task

Console.WriteLine

Type System Mapping

Primitive Types

Str

string

I8

sbyte

I16

int16

I32

int

I64

int64

long

I128

System.Numerics.BigInteger

U8

byte

U16

uint16

U32

uint32

U64

uint64

ulong

U128

System.Numerics.BigInteger

F32

float32

single

F64

float

double

Bool

bool

{}

unit

Collection Types

List a

'a list

Dict k v

Map<'k,'v>

Set a

Set<'a>

(a, b)

'a * 'b

(a, b, c)

'a * 'b * 'c

Composite Types

{ ... }

{ ... }

type X = { ... }

[A, B, C]

type X = A | B | C

[A I64, B Str]

type X = A of int64 | B of string

[Some a, None]

Option<'a>

Result ok err

Result<'ok,'err>

Roc Specific Types → F#

Task a err

Async<'a>

Task<'a>

type Email = Email of string

'a when 'a :> IEquatable<'a>

Idiom Translation

Pattern 1: Tag Unions to Discriminated Unions

Roc:

Color : [Red, Green, Blue, Custom(U8, U8, U8)]

describe : Color -> Str
describe = \color ->
    when color is
        Red -> "red"
        Green -> "green"
        Blue -> "blue"
        Custom(r, g, b) -> "rgb(\(Num.toStr(r)), \(Num.toStr(g)), \(Num.toStr(b)))"

F#:

type Color =
    | Red
    | Green
    | Blue
    | Custom of r: byte * g: byte * b: byte

let describe color =
    match color with
    | Red -> "red"
    | Green -> "green"
    | Blue -> "blue"
    | Custom (r, g, b) -> $"rgb({r}, {g}, {b})"

Why this translation:

• Roc tag unions → F# discriminated unions (nearly identical)
• Roc

  when

  → F#

  match

  (same exhaustiveness checking)
• Roc interpolation

  \(x)

  → F# interpolation

  $"{x}"

  or

  {x}

• Both enforce exhaustive pattern matching

Pattern 2: Optional Values

Roc:

findUser : I64 -> [Some User, None]
findUser = \id ->
    List.findFirst(users, \u -> u.id == id)
    |> Result.toOption

userName =
    when findUser(1) is
        Some(u) -> u.name
        None -> "Unknown"

F#:

let findUser id =
    users |> List.tryFind (fun u -> u.Id = id)

let userName =
    match findUser 1 with
    | Some u -> u.Name
    | None -> "Unknown"

Why this translation:

• Roc

  [Some a, None]

  → F#

  Option<'a>

  (built-in type)
• Roc pattern matching → F# pattern matching (direct mapping)
• F# has

  Option.map

  ,

  Option.bind

  helpers not shown in Roc example
• Both achieve same null-safety

Pattern 3: Result Error Handling

Roc:

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

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

F#:

type DivisionError = DivByZero

let divide x y =
    if y = 0 then
        Error DivByZero
    else
        Ok (x / y)

let calculate a b c =
    result {
        let! x = divide a b
        let! y = divide x c
        return y
    }

Why this translation:

• Roc

  Result ok err

  → F#

  Result<'ok,'err>

  (built-in)
• Roc

  !

  try operator → F#

  let!

  in computation expression
• Roc tag errors

  [DivByZero]

  → F# DU

  type DivisionError = DivByZero

• F# computation expressions provide cleaner syntax than nested matches

Pattern 4: List Operations

Roc:

result =
    items
    |> List.keepIf(\x -> x.active)
    |> List.map(\x -> x.value)
    |> List.walk(0, Num.add)

F#:

let result =
    items
    |> List.filter (fun x -> x.Active)
    |> List.map (fun x -> x.Value)
    |> List.sum

Why this translation:

• Roc

  keepIf

  → F#

  filter

  (different naming)
• Roc

  walk(0, Num.add)

  → F#

  sum

  (built-in helper)
• Both use pipeline operator idiomatically
• F# has more list helpers (

  sum

  ,

  average

  , etc.)

Pattern 5: Record Updates

Roc:

Person : {
    firstName : Str,
    lastName : Str,
    age : U32,
}

person = { firstName: "Alice", lastName: "Smith", age: 30 }
olderPerson = { person & age: 31 }

F#:

type Person = {
    FirstName: string
    LastName: string
    Age: int
}

let person = { FirstName = "Alice"; LastName = "Smith"; Age = 30 }
let olderPerson = { person with Age = 31 }

Why this translation:

• Roc

  &

  operator → F#

  with

  keyword (copy-and-update)
• Roc uses camelCase → F# uses PascalCase (convention)
• Both create new records (immutable)
• F# uses semicolons

  ;

  for field separators, Roc uses commas

Pattern 6: Pipeline Operator

Roc:

result =
    userId
    |> fetchUser
    |> validateUser
    |> saveUser

F#:

// Same pipeline style
let result =
    userId
    |> fetchUser
    |> validateUser
    |> saveUser

// Or with composition
let processUser =
    fetchUser
    >> validateUser
    >> saveUser

let result = processUser userId

Why this translation:

• Both use

  |>

  for pipeline (identical)
• F# also has

  >>

  composition operator (Roc doesn't)
• Same left-to-right data flow
• F# provides more composition options

Error Handling

Roc Result Model → F# Result/Exception Model

Roc only has

Result

Result<'a,'e>

Roc:

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

when divide(10, 0) is
    Ok(result) -> Stdout.line!("Result: \(Num.toStr(result))")
    Err(DivByZero) -> Stdout.line!("Cannot divide by zero")

F# (Result style - preferred):

type DivisionError = DivByZero

let divide x y =
    if y = 0 then
        Error DivByZero
    else
        Ok (x / y)

match divide 10 0 with
| Ok result -> printfn $"Result: {result}"
| Error DivByZero -> printfn "Cannot divide by zero"

F# (Exception style - for interop):

let divide x y =
    if y = 0 then
        raise (System.DivideByZeroException())
    else
        x / y

try
    let result = divide 10 0
    printfn $"Result: {result}"
with
| :? System.DivideByZeroException -> printfn "Cannot divide by zero"

Migration strategy:

1. Prefer F#

   Result

   type for functional code (matches Roc semantics)
2. Use exceptions when integrating with .NET libraries
3. Convert Roc

   when ... is

   to F#

   match ... with

4. Tag unions become discriminated unions

Multiple Error Types

Roc:

ValidationError : [EmptyName, InvalidAge, InvalidEmail]

validatePerson : Str, I64, Str -> Result Person ValidationError
validatePerson = \name, age, email ->
    if Str.isEmpty(name) then
        Err(EmptyName)
    else if age < 0 || age > 120 then
        Err(InvalidAge)
    else if !(Str.contains(email, "@")) then
        Err(InvalidEmail)
    else
        Ok({ name, age, email })

F#:

type ValidationError =
    | EmptyName
    | InvalidAge
    | InvalidEmail

type Person = {
    Name: string
    Age: int
    Email: string
}

let validatePerson name age email =
    if System.String.IsNullOrWhiteSpace(name) then
        Error EmptyName
    elif age < 0 || age > 120 then
        Error InvalidAge
    elif not (email.Contains("@")) then
        Error InvalidEmail
    else
        Ok { Name = name; Age = age; Email = email }

Why this translation:

• Roc tag unions → F# discriminated unions (direct mapping)
• Roc

  if/else if

  → F#

  if/elif

  (same control flow)
• Both use

  Result

  with typed errors
• Both have exhaustive pattern matching

Async and Effects

Roc Task → F# Async

This is a significant paradigm shift. Roc

Task

Async

Roc:

import pf.Http
import pf.Task exposing [Task]

fetchData : Str -> Task Str [HttpErr]
fetchData = \url ->
    Http.get!(url)

processMultiple : List Str -> Task (List Str) [HttpErr]
processMultiple = \urls ->
    urls
    |> List.map(fetchData)
    |> Task.sequence

main : Task {} []
main =
    results = processMultiple!(urls)
    Stdout.line!("Done")

F#:

open System.Net.Http

type HttpError = HttpErr of string

let httpClient = new HttpClient()

let fetchData url = async {
    try
        let! response = httpClient.GetStringAsync(url) |> Async.AwaitTask
        return Ok response
    with
    | ex -> return Error (HttpErr ex.Message)
}

let processMultiple urls = async {
    let! results =
        urls
        |> List.map fetchData
        |> Async.Parallel
    return Array.toList results |> List.choose id  // Extract Ok values
}

[<EntryPoint>]
let main argv =
    let urls = ["url1"; "url2"; "url3"]
    processMultiple urls
    |> Async.RunSynchronously
    |> ignore
    printfn "Done"
    0

Why this translation:

• Roc

  Task a err

  → F#

  Async<Result<'a, 'err>>

  (effects + errors)
• Roc

  !

  operator → F#

  let!

  in

  async { }

  block
• Roc platform handles execution → F# needs

  Async.RunSynchronously

• Roc

  main

  is a Task → F#

  main

  returns int (exit code)

Pure vs Effectful Code

Roc:

# Pure computation
add : I64, I64 -> I64
add = \x, y -> x + y

# Effectful computation (must return Task)
greet : Str -> Task Str []
greet = \name ->
    Stdout.line!("Hello, \(name)!")
    Task.ok(name)

F#:

// Pure computation
let add x y = x + y

// Effectful computation (no special type required)
let greet name =
    printfn $"Hello, {name}!"
    name  // Can return pure value directly

// Or as Async if needed
let greetAsync name = async {
    printfn $"Hello, {name}!"
    return name
}

Migration strategy:

1. Roc

   Task

   functions → F#

   Async

   or direct I/O (depends on context)
2. Roc pure functions → F# pure functions (direct mapping)
3. Roc

   !

   try operator → F#

   let!

   or

   do!

4. Separate pure logic from effects for clarity

Platform Architecture

Roc Application + Platform → .NET Application

Roc (Platform-based):

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

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

main : Task {} []
main =
    input = Stdin.line!
    processed = processInput(input)
    Stdout.line!(processed)

processInput : Str -> Str
processInput = \input ->
    Str.toUpper(input)

F# (.NET Console App):

[<EntryPoint>]
let main argv =
    let input = System.Console.ReadLine()
    let processed = processInput input
    System.Console.WriteLine(processed)
    0  // Return exit code

let processInput input =
    input.ToUpper()

Key differences:

• Roc entry point is a

  Task

  that platform executes
• F# entry point is a function that returns int (exit code)
• Roc separates pure from effectful code; F# can mix them
• Roc uses platform imports; F# uses .NET BCL directly

Common Pitfalls

1. Forgetting F# allows mutability

   • Roc has no mutable variables
   • F# allows

     mutable

     keyword and

     ref

     cells
   • Benefit: Can use mutable state when performance-critical

2. Not leveraging F# exceptions

   • Roc only has

     Result

     type
   • F# has both

     Result

     and exceptions
   • Strategy: Use

     Result

     for domain errors, exceptions for unexpected failures

3. Missing .NET BCL libraries

   • Roc only has what the platform provides
   • F# has access to entire .NET ecosystem
   • Benefit: Rich library support (LINQ, JSON.NET, Entity Framework, etc.)

4. Not using F# computation expressions

   • Roc uses pattern matching and

     !

     operator
   • F# has

     async { }

     ,

     result { }

     ,

     seq { }

     , etc.
   • Strategy: Use computation expressions for cleaner code

5. Ignoring F# type providers

   • Roc has no metaprogramming
   • F# has type providers for compile-time code generation
   • Benefit: Can generate types from SQL, JSON, CSV at compile time

6. Assuming strict platform/application split

   • Roc strictly separates pure (app) from effects (platform)
   • F# mixes pure and impure code freely
   • Strategy: Maintain separation for clarity, but leverage flexibility

7. Not using F# units of measure

   • Roc has no built-in units
   • F# has

     [<Measure>]

     for type-safe calculations
   • Benefit: Compile-time dimension checking

8. Missing F# Interactive (REPL)

   • Roc has limited REPL support
   • F# has FSI for interactive development
   • Benefit: Rapid prototyping and exploration

Module System

Roc Interfaces → F# Modules/Namespaces

Roc:

# User.roc
interface User
    exposes [User, create, getName]
    imports []

User : {
    id : I64,
    name : Str,
    email : Str,
}

create : Str, Str -> User
create = \name, email -> {
    id: generateId(),
    name,
    email,
}

getName : User -> Str
getName = \user -> user.name

F#:

// User.fs
namespace MyApp

module User =
    type User = {
        Id: int64
        Name: string
        Email: string
    }

    let create name email = {
        Id = generateId()
        Name = name
        Email = email
    }

    let getName user = user.Name

Migration notes:

• Roc interfaces → F# modules or namespaces
• Roc

  exposes

  is explicit → F# exports everything by default
• Roc file-based modules → F# file order matters in .fsproj

Build System

Roc Application → .NET Project

Roc:

# main.roc - single file or multiple interfaces
app [main] {
    pf: platform "https://..."
}

import Types
import Logic

main : Task {} []
main =
    Logic.run

Build commands:

roc build main.roc
roc run main.roc

F# (.fsproj):

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <Compile Include="Types.fs" />
    <Compile Include="Logic.fs" />
    <Compile Include="Program.fs" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="FSharp.Data" Version="6.3.0" />
  </ItemGroup>
</Project>

Build commands:

dotnet build
dotnet run

Key differences:

• Roc infers dependencies from imports
• F# needs .fsproj and explicit file ordering
• Roc uses platform URLs; F# uses NuGet packages
• F# has richer build tooling (watch mode, publish, etc.)

Testing

Roc Expect → F# Testing Frameworks

Roc:

add : I64, I64 -> I64
add = \x, y -> x + y

expect add(2, 2) == 4

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

expect divide(10, 0) == Err(DivByZero)
expect divide(10, 2) == Ok(5)

Run tests:

roc test main.roc

F# (Expecto):

module Tests

open Expecto

let add x y = x + y

[<Tests>]
let tests =
    testList "Math tests" [
        testCase "addition" <| fun () ->
            Expect.equal (add 2 2) 4 "2 + 2 = 4"

        testCase "division by zero" <| fun () ->
            let result = divide 10L 0L
            Expect.equal result (Error DivByZero) "should error"

        testCase "division success" <| fun () ->
            let result = divide 10L 2L
            Expect.equal result (Ok 5L) "10 / 2 = 5"
    ]

[<EntryPoint>]
let main args =
    runTestsWithCLIArgs [] args tests

Run tests:

dotnet test

Migration strategy:

• Convert Roc

  expect

  statements to test framework assertions
• Group related expects into test lists
• F# has richer testing tools (Expecto, xUnit, FsUnit, FsCheck)

Examples

Example 1: Simple - Record and Pattern Matching

Before (Roc):

User : { id : I64, name : Str, email : Str }

users = [
    { id: 1, name: "Alice", email: "alice@example.com" },
    { id: 2, name: "Bob", email: "bob@example.com" },
]

findUserById : I64 -> [Some User, None]
findUserById = \id ->
    when List.findFirst(users, \u -> u.id == id) is
        Ok(user) -> Some(user)
        Err(_) -> None

getUserName : I64 -> Str
getUserName = \id ->
    when findUserById(id) is
        Some(u) -> u.name
        None -> "Unknown"

After (F#):

type User = {
    Id: int64
    Name: string
    Email: string
}

let users = [
    { Id = 1L; Name = "Alice"; Email = "alice@example.com" }
    { Id = 2L; Name = "Bob"; Email = "bob@example.com" }
]

let findUserById id =
    users |> List.tryFind (fun u -> u.Id = id)

let getUserName id =
    match findUserById id with
    | Some u -> u.Name
    | None -> "Unknown"

Example 2: Medium - Result with Multiple Errors

Before (Roc):

ValidationError : [InvalidName, InvalidAge]

Person : { name : Str, age : I64 }

validateName : Str -> Result Str [InvalidName]
validateName = \name ->
    if Str.isEmpty(name) then
        Err(InvalidName)
    else
        Ok(name)

validateAge : I64 -> Result I64 [InvalidAge]
validateAge = \age ->
    if age < 0 || age > 120 then
        Err(InvalidAge)
    else
        Ok(age)

createPerson : Str, I64 -> Result Person [InvalidName, InvalidAge]
createPerson = \name, age ->
    validName = validateName!(name)
    validAge = validateAge!(age)
    Ok({ name: validName, age: validAge })

After (F#):

type ValidationError =
    | InvalidName
    | InvalidAge

type Person = {
    Name: string
    Age: int
}

let validateName name =
    if System.String.IsNullOrWhiteSpace(name) then
        Error InvalidName
    else
        Ok name

let validateAge age =
    if age < 0 || age > 120 then
        Error InvalidAge
    else
        Ok age

let createPerson name age =
    result {
        let! validName = validateName name
        let! validAge = validateAge age
        return { Name = validName; Age = validAge }
    }

Example 3: Complex - Task-based File Processing

Before (Roc):

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

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

ProcessingError : [FileNotFound Str, InvalidFormat Str]

readFile : Str -> Task Str [FileReadErr Path.ReadErr]*
readFile = \path ->
    File.readUtf8(Path.fromStr(path))

processContent : Str -> Result Str [InvalidFormat Str]
processContent = \content ->
    if Str.contains(content, "error") then
        Err(InvalidFormat("Content contains error"))
    else
        Ok(Str.toUpper(content))

writeFile : Str, Str -> Task {} [FileWriteErr Path.WriteErr]*
writeFile = \path, content ->
    File.writeUtf8(Path.fromStr(path), content)

processFile : Str, Str -> Task {} [FileReadErr Path.ReadErr, InvalidFormat Str, FileWriteErr Path.WriteErr]*
processFile = \inputPath, outputPath ->
    content = readFile!(inputPath)
    processed = processContent!(content)
    writeFile!(outputPath, processed)

main : Task {} []
main =
    when processFile("input.txt", "output.txt") is
        Ok({}) -> Stdout.line!("File processed successfully")
        Err(FileReadErr(_)) -> Stdout.line!("Error reading file")
        Err(InvalidFormat(msg)) -> Stdout.line!("Invalid format: \(msg)")
        Err(FileWriteErr(_)) -> Stdout.line!("Error writing file")

After (F#):

open System.IO

type ProcessingError =
    | FileNotFound of string
    | InvalidFormat of string

let readFile path = async {
    try
        let! content = File.ReadAllTextAsync(path) |> Async.AwaitTask
        return Ok content
    with
    | :? FileNotFoundException ->
        return Error (FileNotFound path)
    | ex ->
        return Error (FileNotFound $"Error: {ex.Message}")
}

let processContent content =
    if content.Contains("error") then
        Error (InvalidFormat "Content contains error")
    else
        Ok (content.ToUpper())

let writeFile path content = async {
    try
        do! File.WriteAllTextAsync(path, content) |> Async.AwaitTask
        return Ok ()
    with
    | ex ->
        return Error (FileNotFound $"Write error: {ex.Message}")
}

let processFile inputPath outputPath = async {
    let! contentResult = readFile inputPath
    match contentResult with
    | Error e -> return Error e
    | Ok content ->
        match processContent content with
        | Error e -> return Error e
        | Ok processed ->
            return! writeFile outputPath processed
}

[<EntryPoint>]
let main argv =
    let result =
        processFile "input.txt" "output.txt"
        |> Async.RunSynchronously

    match result with
    | Ok () -> printfn "File processed successfully"
    | Error (FileNotFound msg) -> printfn $"File error: {msg}"
    | Error (InvalidFormat msg) -> printfn $"Invalid format: {msg}"

    0

Key conversions:

• Roc

  Task a err

  → F#

  Async<Result<'a, 'err>>

• Roc platform I/O → F# direct file I/O with .NET APIs
• Roc

  !

  operator → F#

  let!

  in async blocks
• Roc

  main

  returns Task → F#

  main

  returns int

See Also

For more examples and patterns, see:

• meta-convert-dev

  - Foundational patterns with cross-language examples

• convert-fsharp-roc

  - Reverse conversion (F# → Roc)

• lang-roc-dev

  - Roc development patterns

• lang-fsharp-dev

  - F# development patterns

Cross-cutting pattern skills:

• patterns-concurrency-dev

  - Task model vs Async workflows

• patterns-serialization-dev

  - JSON, validation across languages

• patterns-metaprogramming-dev

  - No metaprogramming vs type providers