Error Handling

import IO exposing print

let userName = "Alice"

let userAge = 30

print usrName

-- Error: Variable 'usrName' not found. Did you mean 'userName' or 'userAge'?

import IO exposing print

let userName = "Alice"

let userAge = 30

let userEmail = "alice@example.com"

print usrNme

-- Error: Variable 'usrNme' not found. Did you mean 'userName', 'userAge', or 'userEmail'?

import List
List.fold [1, 2, 3] 0
-- Error: Function 'fold' is not declared in module 'List'. Did you mean 'foldl' or 'foldr'?

fn example : Int -> Int
fn example x =
let y = 1    -- Error: Function body must be indented by at least 4 spaces
    x + y

if True then
    0
  else         -- Error: 'else' must align with 'if'
    1

let x =
x + 1          -- Error: Block must be indented more than parent
               -- Hint: Indent the block to 4 spaces

enum Direction = North | south    -- Error: Enum variant must start with uppercase

enum Person = { name: String, age: Int }
-- Error: Expected enum variant, found record syntax
-- Hint: Use an inline record type annotation instead.

enum Result a e = Ok a | Err e
-- Result OkType ErrType: first parameter is success, second is error
-- Error: Enum variant 'Ok' appears to have data without parentheses
-- Hint: Use `Ok(a)` instead of `Ok a`. Variant data requires parentheses.

let x = (1 + 2
-- Error: Unclosed '(' — expected ')'

let x = [1, 2)
-- Error: Mismatched delimiter — '(' expected ')' but found ')'

let x = 1 + 2]
-- Error: Unexpected ']' — no matching '['

let addPair = |(x, y): (Int, Int)| x + y
-- Error: Type annotations on tuple patterns must be on individual elements
-- Hint: Use `|(x: Int, y: Int)|` instead of `|(x, y): (Int, Int)|`.

fn greet : String -> String
fn greet name =
"Hello, " ++ name   -- Error: body must be indented by at least 4 spaces

fn double x =        -- Error: missing type signature
    x * 2

let x = 10
let result =
    if x > 5 then "big"
        else "small"   -- Error: else must align with if

let x = unknownVar    -- Error: Variable 'unknownVar' is not declared

fn add : Int -> Int -> Int
fn add x y =
    x + y

add "hello" 5  -- Error: Expected Int but got String

import Json

let data = Json.parse "{\"x\": 1}"

-- Error: Generic function result requires a type annotation for variable 'data'

-- Hint: Add a type annotation to specify the expected type

import Json

let data : Result { x : Int } String = Json.parse "{\"x\": 1}"

data

fn example : Int -> Int
fn example x =
    let inner = x + 1
    inner

inner  -- Error: Variable 'inner' is not in scope

{ name: "Alice", age: 30 }
-- Error: JavaScript-style record syntax is not allowed
-- Hint: Use `=` instead of `:` for record field assignment
-- Example: `{ name = "Alice" }`

{ name = "Alice", age = 30 }

let x = true     -- Error: 'true' is not a Keel keyword
                 -- Hint: Use `True` for boolean true

let x = True

let y = False

x && y

let x = null     -- Error: 'null' is not a Keel keyword
                 -- Hint: Use `Nothing` for absent values

let present = Just 42

let absent = Nothing

case present of
    Just n -> "Got a value"
    Nothing -> "Nothing"

return 5         -- Hint: Keel is expression-based; the last expression is the return value
match x of       -- Hint: Use `case ... of` for pattern matching
function add     -- Hint: Use `fn` to define functions
var x = 5        -- Hint: Use `let` for variable bindings

fn double : Int -> Int
fn double x =
    x * 2

-- Pattern matching uses case...of

let value = Just 5

case value of
    Just n -> n * 2
    Nothing -> 0

case 42 of
    "hello" -> 1  -- Error: Pattern type mismatch: expected Int, but pattern is String
    _ -> 0

case Just 5 of
    Ok n -> n  -- Error: Pattern type mismatch: expected Maybe, but pattern is Result (Ok)
    _ -> 0

let x = 2

case x of
    n if n + 1 -> "bad"  -- Error: Guard expression must be Bool, found Int
    _ -> "ok"

let x = 5

case x of
    n if n > 0 -> "positive"
    n if n < 0 -> "negative"
    _ -> "zero"

let x = 2

case x of
    1 -> 42  -- Int
    2 -> "hello"  -- Error: Case branches have incompatible types: Int and String
    _ -> 0

let x = 2

case x of
    1 -> "one"
    2 -> "two"
    _ -> "other"

import List

List.map 42 [1, 2, 3]

-- Error: Type mismatch: expected (a -> b), found Int

-- Hint: Function signature: (a -> b) -> [a] -> [b]

-- Expected argument type: (a -> b), but got: Int

import String

String.length 42

-- Error: Type mismatch: expected String, found Int

-- Hint: Function signature: String -> Int

-- Expected argument type: String, but got: Int

let items = [1, 2, 3]

items[10]  -- Error: Index 10 out of bounds for list of size 3

let items = [1, 2, 3]

items[0]  -- 1

-- Unwrap Ok with ?, short-circuit on Err
let addOne = |x: Int| Ok (x + 1)
let result = 5 |> addOne
result?

-- When ? is applied to Err, the result is Err (short-circuit)
let mayFail = |x: Int| Err "something failed"
let result = 5 |> mayFail
result?

import Result

-- Transform success values
let mapped : Result Int String = Ok 5 |> Result.map (|x| x * 2)

-- Chain operations that might fail
let chained : Result Int String =
    Ok 5 |> Result.andThen (|x| if x > 0 then
        Ok x
    else
        Err "negative")

-- Provide default values
let defaulted = Err "failed" |> Result.withDefault 0

-- Transform error values
Err "bad" |> Result.mapError (|e| "Error: " ++ e)

import Maybe

-- Transform present values
let mapped = Just 5 |> Maybe.map (|x| x * 2)

-- Chain operations that might return Nothing
let chained =
    Just 5 |> Maybe.andThen (|x| if x > 0 then
        Just x
    else
        Nothing)

-- Provide default values

Nothing |> Maybe.withDefault 0

import Result

-- Maybe to Result (with error message)
let a = Just 5 |> Result.fromMaybe "was nothing"

-- Result to Maybe (discards error)
let c : Maybe Int = Ok 5 |> Result.toMaybe

let d : Result Int String = Err "x"

d |> Result.toMaybe