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

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

type Person = { name: String, age: Int }
-- Error: Expected enum variant, found record syntax
-- Hint: Use 'type alias' to define a record type alias.

type 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)|`.

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

import Result

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

-- Chain operations that might fail
let chained = 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