feat: static binary builds and automated release script

Switch reqwest from native-tls (openssl) to rustls-tls for a pure-Rust TLS stack, enabling fully static musl builds. Add `nix build .#static` for portable Linux binaries and `scripts/release.sh` for automated Gitea releases with changelog generation. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-18 19:06:33 -05:00
19 changed files with 107 additions and 642 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -42,45 +42,17 @@ When making changes:
 7. **Fix language limitations**: If you encounter parser/type system limitations, fix them (without regressions on guarantees or speed)
 8. **Git commits**: Always use `--no-gpg-sign` flag

-### Post-work checklist (run after each committable change)
-
-**MANDATORY: Run the full validation script after every committable change:**
-```bash
-./scripts/validate.sh
-```
-
-This script runs ALL of the following checks and will fail if any regress:
-1. `cargo check` — no Rust compilation errors
-2. `cargo test` — all Rust tests pass (currently 387)
-3. `cargo build --release` — release binary builds
-4. `lux test` on every package (path, frontmatter, xml, rss, markdown) — all 286 package tests pass
-5. `lux check` on every package — type checking + lint passes
-
-If `validate.sh` is not available or you need to run manually:
+### Post-work checklist (run after each major piece of work)
 ```bash
 nix develop --command cargo check       # No Rust errors
-nix develop --command cargo test        # All Rust tests pass
-nix develop --command cargo build --release  # Build release binary
-cd ../packages/path && ../../lang/target/release/lux test        # Package tests
-cd ../packages/frontmatter && ../../lang/target/release/lux test
-cd ../packages/xml && ../../lang/target/release/lux test
-cd ../packages/rss && ../../lang/target/release/lux test
-cd ../packages/markdown && ../../lang/target/release/lux test
+nix develop --command cargo test        # All tests pass (currently 381)
+./target/release/lux check              # Type check + lint all .lux files
+./target/release/lux fmt                # Format all .lux files
+./target/release/lux lint               # Standalone lint pass
 ```

-**Do NOT commit if any check fails.** Fix the issue first.
-
 ### Commit after every piece of work
-**After completing each logical unit of work, commit immediately.** This is NOT optional — every fix, feature, or change MUST be committed right away. Do not let changes accumulate uncommitted across multiple features. Each commit should be a single logical change (one feature, one bugfix, etc.). Use `--no-gpg-sign` flag for all commits.
-
-**Commit workflow:**
-1. Make the change
-2. Run `./scripts/validate.sh` (all 13 checks must pass)
-3. `git add` the relevant files
-4. `git commit --no-gpg-sign -m "type: description"` (use conventional commits: fix/feat/chore/docs)
-5. Move on to the next task
-
-**Never skip committing.** If you fixed a bug, commit it. If you added a feature, commit it. If you updated docs, commit it. Do not batch unrelated changes into one commit.
+**After completing each logical unit of work, commit immediately.** Do not let changes accumulate uncommitted across multiple features. Each commit should be a single logical change (one feature, one bugfix, etc.). Use `--no-gpg-sign` flag for all commits.

 **IMPORTANT: Always verify Lux code you write:**
 - Run with interpreter: `./target/release/lux file.lux`
@@ -137,7 +109,7 @@ When working on any major task that involves writing Lux code, **document every
 ## Code Quality

 - Fix all compiler warnings before committing
- Ensure all tests pass (currently 387 tests)
+- Ensure all tests pass (currently 381 tests)
 - Add new tests when adding features
 - Keep examples and documentation in sync

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -770,7 +770,7 @@ dependencies = [

 [[package]]
 name = "lux"
-version = "0.1.2"
+version = "0.1.0"
 dependencies = [
 "lsp-server",
 "lsp-types",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lux"
-version = "0.1.3"
+version = "0.1.0"
 edition = "2021"
 description = "A functional programming language with first-class effects, schema evolution, and behavioral types"
 license = "MIT"
--- a/flake.nix
+++ b/flake.nix
@@ -44,7 +44,7 @@
            printf "\n"
            printf "  \033[1;35m╦  ╦ ╦╦ ╦\033[0m\n"
            printf "  \033[1;35m║  ║ ║╔╣\033[0m\n"
-            printf "  \033[1;35m╩═╝╚═╝╩ ╩\033[0m  v0.1.3\n"
+            printf "  \033[1;35m╩═╝╚═╝╩ ╩\033[0m  v0.1.0\n"
            printf "\n"
            printf "  Functional language with first-class effects\n"
            printf "\n"
@@ -62,7 +62,7 @@

        packages.default = pkgs.rustPlatform.buildRustPackage {
          pname = "lux";
-          version = "0.1.3";
+          version = "0.1.0";
          src = ./.;
          cargoLock.lockFile = ./Cargo.lock;

@@ -79,7 +79,7 @@
          };
        in muslPkgs.rustPlatform.buildRustPackage {
          pname = "lux";
-          version = "0.1.3";
+          version = "0.1.0";
          src = ./.;
          cargoLock.lockFile = ./Cargo.lock;

--- a/scripts/release.sh
+++ b/scripts/release.sh
@@ -5,20 +5,12 @@ set -euo pipefail
 # Builds a static binary, generates changelog, and creates a Gitea release.
 #
 # Usage:
-#   ./scripts/release.sh              # auto-bump patch (0.2.0 → 0.2.1)
-#   ./scripts/release.sh patch        # same as above
-#   ./scripts/release.sh minor        # bump minor (0.2.0 → 0.3.0)
-#   ./scripts/release.sh major        # bump major (0.2.0 → 1.0.0)
-#   ./scripts/release.sh v1.2.3       # explicit version
+#   ./scripts/release.sh [version]
 #
 # Environment:
 #   GITEA_TOKEN - API token for git.qrty.ink (prompted if not set)
 #   GITEA_URL   - Gitea instance URL (default: https://git.qrty.ink)

-# cd to repo root (directory containing this script's parent)
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-cd "$SCRIPT_DIR/.."
-
 GITEA_URL="${GITEA_URL:-https://git.qrty.ink}"
 REPO_OWNER="blu"
 REPO_NAME="lux"
@@ -38,33 +30,14 @@ warn()  { printf "${YELLOW}!!${NC} %s\n" "$1"; }
 err()   { printf "${RED}error:${NC} %s\n" "$1" >&2; exit 1; }

 # --- Determine version ---
-CURRENT=$(grep '^version' Cargo.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')
-BUMP="${1:-patch}"
-
-bump_version() {
-    local ver="$1" part="$2"
-    IFS='.' read -r major minor patch <<< "$ver"
-    case "$part" in
-        major) echo "$((major + 1)).0.0" ;;
-        minor) echo "$major.$((minor + 1)).0" ;;
-        patch) echo "$major.$minor.$((patch + 1))" ;;
-        *)     echo "$part" ;;  # treat as explicit version
-    esac
-}
-
-case "$BUMP" in
-    major|minor|patch)
-        VERSION=$(bump_version "$CURRENT" "$BUMP")
-        info "Bumping $BUMP: $CURRENT → $VERSION"
-        ;;
-    *)
-        # Explicit version — strip v prefix if present
-        VERSION="${BUMP#v}"
-        info "Explicit version: $VERSION"
-        ;;
-esac
-
-TAG="v$VERSION"
+VERSION="${1:-}"
+if [ -z "$VERSION" ]; then
+    VERSION=$(grep '^version' Cargo.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')
+    info "Version from Cargo.toml: v$VERSION"
+fi
+# Ensure v prefix
+[[ "$VERSION" == v* ]] || VERSION="v$VERSION"
+TAG="$VERSION"

 # --- Check for clean working tree ---
 if [ -n "$(git status --porcelain)" ]; then
@@ -77,18 +50,7 @@ fi

 # --- Check if tag already exists ---
 if git rev-parse "$TAG" >/dev/null 2>&1; then
-    err "Tag $TAG already exists. Choose a different version."
-fi
-
-# --- Update version in source files ---
-if [ "$VERSION" != "$CURRENT" ]; then
-    info "Updating version in Cargo.toml and flake.nix..."
-    sed -i "0,/^version = \"$CURRENT\"/s//version = \"$VERSION\"/" Cargo.toml
-    sed -i "s/version = \"$CURRENT\";/version = \"$VERSION\";/g" flake.nix
-    sed -i "s/v$CURRENT/v$VERSION/g" flake.nix
-    git add Cargo.toml flake.nix
-    git commit --no-gpg-sign -m "chore: bump version to $VERSION"
-    ok "Version updated and committed"
+    err "Tag $TAG already exists. Bump version in Cargo.toml or choose a different version."
 fi

 # --- Generate changelog ---
@@ -102,7 +64,7 @@ else
    info "First release — summarizing recent commits:"
 fi

-CHANGELOG=$(git log "$RANGE" --pretty=format:"- %s" --no-merges 2>/dev/null | head -50 || true)
+CHANGELOG=$(git log "$RANGE" --pretty=format:"- %s" --no-merges 2>/dev/null | head -50)
 if [ -z "$CHANGELOG" ]; then
    CHANGELOG="- Initial release"
 fi
--- a/scripts/validate.sh
+++ b/scripts/validate.sh
@@ -1,73 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Lux Full Validation Script
-# Runs all checks: Rust tests, package tests, type checking, formatting, linting.
-# Run after every committable change to ensure no regressions.
-
-# cd to repo root (directory containing this script's parent)
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-cd "$SCRIPT_DIR/.."
-
-LUX="$(pwd)/target/release/lux"
-PACKAGES_DIR="$(pwd)/../packages"
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-CYAN='\033[0;36m'
-BOLD='\033[1m'
-NC='\033[0m'
-
-FAILED=0
-TOTAL=0
-
-step() {
-    TOTAL=$((TOTAL + 1))
-    printf "${CYAN}[%d]${NC} %s... " "$TOTAL" "$1"
-}
-
-ok() { printf "${GREEN}ok${NC} %s\n" "${1:-}"; }
-fail() { printf "${RED}FAIL${NC} %s\n" "${1:-}"; FAILED=$((FAILED + 1)); }
-
-# --- Rust checks ---
-step "cargo check"
-if nix develop --command cargo check 2>&1 | grep -q "Finished"; then ok; else fail; fi
-
-step "cargo test"
-OUTPUT=$(nix develop --command cargo test 2>&1 || true)
-RESULT=$(echo "$OUTPUT" | grep "test result:" || echo "no result")
-if echo "$RESULT" | grep -q "0 failed"; then ok "$RESULT"; else fail "$RESULT"; fi
-
-# --- Build release binary ---
-step "cargo build --release"
-if nix develop --command cargo build --release 2>&1 | grep -q "Finished"; then ok; else fail; fi
-
-# --- Package tests ---
-for pkg in path frontmatter xml rss markdown; do
-    PKG_DIR="$PACKAGES_DIR/$pkg"
-    if [ -d "$PKG_DIR" ]; then
-        step "lux test ($pkg)"
-        OUTPUT=$(cd "$PKG_DIR" && "$LUX" test 2>&1 || true)
-        RESULT=$(echo "$OUTPUT" | grep "passed" | tail -1 || echo "no result")
-        if echo "$RESULT" | grep -q "passed"; then ok "$RESULT"; else fail "$RESULT"; fi
-    fi
-done
-
-# --- Lux check on packages ---
-for pkg in path frontmatter xml rss markdown; do
-    PKG_DIR="$PACKAGES_DIR/$pkg"
-    if [ -d "$PKG_DIR" ]; then
-        step "lux check ($pkg)"
-        OUTPUT=$(cd "$PKG_DIR" && "$LUX" check 2>&1 || true)
-        RESULT=$(echo "$OUTPUT" | grep "passed" | tail -1 || echo "no result")
-        if echo "$RESULT" | grep -q "passed"; then ok; else fail "$RESULT"; fi
-    fi
-done
-
-# --- Summary ---
-printf "\n${BOLD}═══ Validation Summary ═══${NC}\n"
-if [ $FAILED -eq 0 ]; then
-    printf "${GREEN}All %d checks passed.${NC}\n" "$TOTAL"
-else
-    printf "${RED}%d/%d checks failed.${NC}\n" "$FAILED" "$TOTAL"
-    exit 1
-fi
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -541,9 +541,7 @@ pub enum Expr {
        span: Span,
    },
    /// Record literal: { name: "Alice", age: 30 }
-    /// With optional spread: { ...base, name: "Bob" }
    Record {
-        spread: Option<Box<Expr>>,
        fields: Vec<(Ident, Expr)>,
        span: Span,
    },
@@ -623,8 +621,7 @@ pub enum BinaryOp {
    And,
    Or,
    // Other
-    Pipe,   // |>
-    Concat, // ++
+    Pipe, // |>
 }

 impl fmt::Display for BinaryOp {
@@ -644,7 +641,6 @@ impl fmt::Display for BinaryOp {
            BinaryOp::And => write!(f, "&&"),
            BinaryOp::Or => write!(f, "||"),
            BinaryOp::Pipe => write!(f, "|>"),
-            BinaryOp::Concat => write!(f, "++"),
        }
    }
 }
--- a/src/codegen/c_backend.rs
+++ b/src/codegen/c_backend.rs
@@ -730,10 +730,10 @@ impl CBackend {
                }

                // Check for string concatenation - use lux_string_concat instead of +
-                if matches!(op, BinaryOp::Add | BinaryOp::Concat) {
+                if matches!(op, BinaryOp::Add) {
                    let left_is_string = self.infer_expr_type(left).as_deref() == Some("LuxString");
                    let right_is_string = self.infer_expr_type(right).as_deref() == Some("LuxString");
-                    if left_is_string || right_is_string || matches!(op, BinaryOp::Concat) {
+                    if left_is_string || right_is_string {
                        return Ok(format!("lux_string_concat({}, {})", l, r));
                    }
                }
@@ -858,7 +858,6 @@ impl CBackend {
        self.writeln("#include <stdio.h>");
        self.writeln("#include <stdlib.h>");
        self.writeln("#include <string.h>");
-        self.writeln("#include <math.h>");
        self.writeln("");
        self.writeln("// === Lux Runtime Types ===");
        self.writeln("");
@@ -2840,18 +2839,8 @@ impl CBackend {
                    }
                }

-                // String concatenation for ++ and +
-                if matches!(op, BinaryOp::Add | BinaryOp::Concat) {
-                    let left_is_string = self.infer_expr_type(left).as_deref() == Some("LuxString");
-                    let right_is_string = self.infer_expr_type(right).as_deref() == Some("LuxString");
-                    if left_is_string || right_is_string || matches!(op, BinaryOp::Concat) {
-                        return Ok(format!("lux_string_concat({}, {})", l, r));
-                    }
-                }
-
                let op_str = match op {
                    BinaryOp::Add => "+",
-                    BinaryOp::Concat => unreachable!("handled above"),
                    BinaryOp::Sub => "-",
                    BinaryOp::Mul => "*",
                    BinaryOp::Div => "/",
@@ -3030,10 +3019,6 @@ impl CBackend {
                            self.register_rc_var(&temp, "LuxString");
                            return Ok(temp);
                        }
-                        // Math module
-                        if module_name.name == "Math" {
-                            return self.emit_math_operation(&field.name, args);
-                        }
                        // Check for user-defined module function
                        let key = (module_name.name.clone(), field.name.clone());
                        if let Some(c_name) = self.module_functions.get(&key).cloned() {
@@ -3397,11 +3382,6 @@ impl CBackend {
                    }
                }

-                // Math module (treated as effect by parser but handled as direct C calls)
-                if effect.name == "Math" {
-                    return self.emit_math_operation(&operation.name, args);
-                }
-
                // Built-in Console effect
                if effect.name == "Console" {
                    if operation.name == "print" {
@@ -3864,34 +3844,12 @@ impl CBackend {
                }
            }

-            Expr::Record {
-                spread, fields, ..
-            } => {
-                if let Some(spread_expr) = spread {
-                    // Evaluate spread source, then override fields
-                    let base = self.emit_expr(spread_expr)?;
-                    if fields.is_empty() {
-                        Ok(base)
-                    } else {
-                        // Copy spread into a temp, then override fields
-                        let temp = format!("_spread_{}", self.fresh_name());
-                        self.writeln(&format!("__auto_type {} = {};", temp, base));
-                        for (name, val) in fields {
-                            let v = self.emit_expr(val)?;
-                            self.writeln(&format!("{}.{} = {};", temp, name.name, v));
-                        }
-                        Ok(temp)
-                    }
-                } else {
-                    let field_strs: Result<Vec<_>, _> = fields
-                        .iter()
-                        .map(|(name, val)| {
-                            let v = self.emit_expr(val)?;
-                            Ok(format!(".{} = {}", name.name, v))
-                        })
-                        .collect();
-                    Ok(format!("{{ {} }}", field_strs?.join(", ")))
-                }
+            Expr::Record { fields, .. } => {
+                let field_strs: Result<Vec<_>, _> = fields.iter().map(|(name, val)| {
+                    let v = self.emit_expr(val)?;
+                    Ok(format!(".{} = {}", name.name, v))
+                }).collect();
+                Ok(format!("{{ {} }}", field_strs?.join(", ")))
            }

            Expr::Field { object, field, .. } => {
@@ -3961,64 +3919,6 @@ impl CBackend {
        }
    }

-    /// Emit code for Math module operations (Math.sin, Math.cos, etc.)
-    fn emit_math_operation(&mut self, op: &str, args: &[Expr]) -> Result<String, CGenError> {
-        match op {
-            "abs" => {
-                let x = self.emit_expr(&args[0])?;
-                Ok(format!("fabs({})", x))
-            }
-            "min" => {
-                let a = self.emit_expr(&args[0])?;
-                let b = self.emit_expr(&args[1])?;
-                Ok(format!("fmin({}, {})", a, b))
-            }
-            "max" => {
-                let a = self.emit_expr(&args[0])?;
-                let b = self.emit_expr(&args[1])?;
-                Ok(format!("fmax({}, {})", a, b))
-            }
-            "sqrt" => {
-                let x = self.emit_expr(&args[0])?;
-                Ok(format!("sqrt({})", x))
-            }
-            "pow" => {
-                let base = self.emit_expr(&args[0])?;
-                let exp = self.emit_expr(&args[1])?;
-                Ok(format!("pow({}, {})", base, exp))
-            }
-            "floor" => {
-                let x = self.emit_expr(&args[0])?;
-                Ok(format!("(int64_t)floor({})", x))
-            }
-            "ceil" => {
-                let x = self.emit_expr(&args[0])?;
-                Ok(format!("(int64_t)ceil({})", x))
-            }
-            "round" => {
-                let x = self.emit_expr(&args[0])?;
-                Ok(format!("(int64_t)round({})", x))
-            }
-            "sin" => {
-                let x = self.emit_expr(&args[0])?;
-                Ok(format!("sin({})", x))
-            }
-            "cos" => {
-                let x = self.emit_expr(&args[0])?;
-                Ok(format!("cos({})", x))
-            }
-            "atan2" => {
-                let y = self.emit_expr(&args[0])?;
-                let x = self.emit_expr(&args[1])?;
-                Ok(format!("atan2({}, {})", y, x))
-            }
-            _ => Err(CGenError {
-                message: format!("Math.{} not supported in C backend", op),
-                span: None,
-            }),
-        }
-    }
-
    /// Emit code for List module operations (List.map, List.filter, etc.)
    fn emit_list_operation(&mut self, op: &str, args: &[Expr]) -> Result<String, CGenError> {
        match op {
@@ -5921,10 +5821,7 @@ impl CBackend {
                }
                self.collect_free_vars(body, &inner_bound, free);
            }
-            Expr::Record { spread, fields, .. } => {
-                if let Some(spread_expr) = spread {
-                    self.collect_free_vars(spread_expr, bound, free);
-                }
+            Expr::Record { fields, .. } => {
                for (_, val) in fields {
                    self.collect_free_vars(val, bound, free);
                }
--- a/src/codegen/js_backend.rs
+++ b/src/codegen/js_backend.rs
@@ -909,16 +909,13 @@ impl JsBackend {
        let val = self.emit_expr(&let_decl.value)?;
        let var_name = &let_decl.name.name;

-        if var_name == "_" {
-            // Wildcard binding: just execute for side effects
-            self.writeln(&format!("{};", val));
-        } else {
-            self.writeln(&format!("const {} = {};", var_name, val));
+        // Check if this is a run expression (often results in undefined)
+        // We still want to execute it for its side effects
+        self.writeln(&format!("const {} = {};", var_name, val));

-            // Register the variable for future use
-            self.var_substitutions
-                .insert(var_name.clone(), var_name.clone());
-        }
+        // Register the variable for future use
+        self.var_substitutions
+            .insert(var_name.clone(), var_name.clone());

        Ok(())
    }
@@ -957,17 +954,12 @@ impl JsBackend {
                let r = self.emit_expr(right)?;

                // Check for string concatenation
-                if matches!(op, BinaryOp::Add | BinaryOp::Concat) {
+                if matches!(op, BinaryOp::Add) {
                    if self.is_string_expr(left) || self.is_string_expr(right) {
                        return Ok(format!("({} + {})", l, r));
                    }
                }

-                // ++ on lists: use .concat()
-                if matches!(op, BinaryOp::Concat) {
-                    return Ok(format!("{}.concat({})", l, r));
-                }
-
                let op_str = match op {
                    BinaryOp::Add => "+",
                    BinaryOp::Sub => "-",
@@ -982,7 +974,6 @@ impl JsBackend {
                    BinaryOp::Ge => ">=",
                    BinaryOp::And => "&&",
                    BinaryOp::Or => "||",
-                    BinaryOp::Concat => unreachable!("handled above"),
                    BinaryOp::Pipe => {
                        // Pipe operator: x |> f becomes f(x)
                        return Ok(format!("{}({})", r, l));
@@ -1043,26 +1034,18 @@ impl JsBackend {
                name, value, body, ..
            } => {
                let val = self.emit_expr(value)?;
+                let var_name = format!("{}_{}", name.name, self.fresh_name());

-                if name.name == "_" {
-                    // Wildcard binding: just execute for side effects
-                    self.writeln(&format!("{};", val));
-                } else {
-                    let var_name = format!("{}_{}", name.name, self.fresh_name());
+                self.writeln(&format!("const {} = {};", var_name, val));

-                    self.writeln(&format!("const {} = {};", var_name, val));
-
-                    // Add substitution
-                    self.var_substitutions
-                        .insert(name.name.clone(), var_name.clone());
-                }
+                // Add substitution
+                self.var_substitutions
+                    .insert(name.name.clone(), var_name.clone());

                let body_result = self.emit_expr(body)?;

                // Remove substitution
-                if name.name != "_" {
-                    self.var_substitutions.remove(&name.name);
-                }
+                self.var_substitutions.remove(&name.name);

                Ok(body_result)
            }
@@ -1083,10 +1066,6 @@ impl JsBackend {
                        let arg = self.emit_expr(&args[0])?;
                        return Ok(format!("String({})", arg));
                    }
-                    if ident.name == "print" {
-                        let arg = self.emit_expr(&args[0])?;
-                        return Ok(format!("console.log({})", arg));
-                    }
                }

                let arg_strs: Result<Vec<_>, _> = args.iter().map(|a| self.emit_expr(a)).collect();
@@ -1249,15 +1228,10 @@ impl JsBackend {
                        }
                        Statement::Let { name, value, .. } => {
                            let val = self.emit_expr(value)?;
-                            if name.name == "_" {
-                                self.writeln(&format!("{};", val));
-                            } else {
-                                let var_name =
-                                    format!("{}_{}", name.name, self.fresh_name());
-                                self.writeln(&format!("const {} = {};", var_name, val));
-                                self.var_substitutions
-                                    .insert(name.name.clone(), var_name.clone());
-                            }
+                            let var_name = format!("{}_{}", name.name, self.fresh_name());
+                            self.writeln(&format!("const {} = {};", var_name, val));
+                            self.var_substitutions
+                                .insert(name.name.clone(), var_name.clone());
                        }
                    }
                }
@@ -1266,19 +1240,15 @@ impl JsBackend {
                self.emit_expr(result)
            }

-            Expr::Record {
-                spread, fields, ..
-            } => {
-                let mut parts = Vec::new();
-                if let Some(spread_expr) = spread {
-                    let spread_code = self.emit_expr(spread_expr)?;
-                    parts.push(format!("...{}", spread_code));
-                }
-                for (name, expr) in fields {
-                    let val = self.emit_expr(expr)?;
-                    parts.push(format!("{}: {}", name.name, val));
-                }
-                Ok(format!("{{ {} }}", parts.join(", ")))
+            Expr::Record { fields, .. } => {
+                let field_strs: Result<Vec<_>, _> = fields
+                    .iter()
+                    .map(|(name, expr)| {
+                        let val = self.emit_expr(expr)?;
+                        Ok(format!("{}: {}", name.name, val))
+                    })
+                    .collect();
+                Ok(format!("{{ {} }}", field_strs?.join(", ")))
            }

            Expr::Tuple { elements, .. } => {
@@ -2368,7 +2338,7 @@ impl JsBackend {
                }
            }
            Expr::BinaryOp { op, left, right, .. } => {
-                matches!(op, BinaryOp::Add | BinaryOp::Concat)
+                matches!(op, BinaryOp::Add)
                    && (self.is_string_expr(left) || self.is_string_expr(right))
            }
            _ => false,
--- a/src/formatter.rs
+++ b/src/formatter.rs
@@ -688,17 +688,15 @@ impl Formatter {
                        .join(", ")
                )
            }
-            Expr::Record {
-                spread, fields, ..
-            } => {
-                let mut parts = Vec::new();
-                if let Some(spread_expr) = spread {
-                    parts.push(format!("...{}", self.format_expr(spread_expr)));
-                }
-                for (name, val) in fields {
-                    parts.push(format!("{}: {}", name.name, self.format_expr(val)));
-                }
-                format!("{{ {} }}", parts.join(", "))
+            Expr::Record { fields, .. } => {
+                format!(
+                    "{{ {} }}",
+                    fields
+                        .iter()
+                        .map(|(name, val)| format!("{}: {}", name.name, self.format_expr(val)))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
            }
            Expr::EffectOp { effect, operation, args, .. } => {
                format!(
@@ -755,7 +753,6 @@ impl Formatter {
            BinaryOp::Ge => ">=",
            BinaryOp::And => "&&",
            BinaryOp::Or => "||",
-            BinaryOp::Concat => "++",
            BinaryOp::Pipe => "|>",
        }
    }
--- a/src/interpreter.rs
+++ b/src/interpreter.rs
@@ -74,9 +74,6 @@ pub enum BuiltinFn {
    MathFloor,
    MathCeil,
    MathRound,
-    MathSin,
-    MathCos,
-    MathAtan2,

    // Additional List operations
    ListIsEmpty,
@@ -1075,9 +1072,6 @@ impl Interpreter {
            ("floor".to_string(), Value::Builtin(BuiltinFn::MathFloor)),
            ("ceil".to_string(), Value::Builtin(BuiltinFn::MathCeil)),
            ("round".to_string(), Value::Builtin(BuiltinFn::MathRound)),
-            ("sin".to_string(), Value::Builtin(BuiltinFn::MathSin)),
-            ("cos".to_string(), Value::Builtin(BuiltinFn::MathCos)),
-            ("atan2".to_string(), Value::Builtin(BuiltinFn::MathAtan2)),
        ]));
        env.define("Math", math_module);

@@ -1121,50 +1115,11 @@ impl Interpreter {
    /// Execute a program
    pub fn run(&mut self, program: &Program) -> Result<Value, RuntimeError> {
        let mut last_value = Value::Unit;
-        let mut has_main_let = false;

        for decl in &program.declarations {
-            // Track if there's a top-level `let main = ...`
-            if let Declaration::Let(let_decl) = decl {
-                if let_decl.name.name == "main" {
-                    has_main_let = true;
-                }
-            }
            last_value = self.eval_declaration(decl)?;
        }

-        // Auto-invoke main if it was defined as a let binding with a function value
-        if has_main_let {
-            if let Some(main_val) = self.global_env.get("main") {
-                if let Value::Function(ref closure) = main_val {
-                    if closure.params.is_empty() {
-                        let span = Span { start: 0, end: 0 };
-                        let mut result = self.eval_call(main_val.clone(), vec![], span)?;
-                        // Trampoline loop
-                        loop {
-                            match result {
-                                EvalResult::Value(v) => {
-                                    last_value = v;
-                                    break;
-                                }
-                                EvalResult::Effect(req) => {
-                                    last_value = self.handle_effect(req)?;
-                                    break;
-                                }
-                                EvalResult::TailCall { func, args, span } => {
-                                    result = self.eval_call(func, args, span)?;
-                                }
-                                EvalResult::Resume(v) => {
-                                    last_value = v;
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
        Ok(last_value)
    }

@@ -1570,28 +1525,8 @@ impl Interpreter {
                self.eval_expr_tail(result, &block_env, tail)
            }

-            Expr::Record {
-                spread, fields, ..
-            } => {
+            Expr::Record { fields, .. } => {
                let mut record = HashMap::new();
-
-                // If there's a spread, evaluate it and start with its fields
-                if let Some(spread_expr) = spread {
-                    let spread_val = self.eval_expr(spread_expr, env)?;
-                    if let Value::Record(spread_fields) = spread_val {
-                        record = spread_fields;
-                    } else {
-                        return Err(RuntimeError {
-                            message: format!(
-                                "Spread expression must evaluate to a record, got {}",
-                                spread_val.type_name()
-                            ),
-                            span: Some(expr.span()),
-                        });
-                    }
-                }
-
-                // Override with explicit fields
                for (name, expr) in fields {
                    let val = self.eval_expr(expr, env)?;
                    record.insert(name.name.clone(), val);
@@ -1664,18 +1599,6 @@ impl Interpreter {
                    span: Some(span),
                }),
            },
-            BinaryOp::Concat => match (left, right) {
-                (Value::String(a), Value::String(b)) => Ok(Value::String(a + &b)),
-                (Value::List(a), Value::List(b)) => {
-                    let mut result = a;
-                    result.extend(b);
-                    Ok(Value::List(result))
-                }
-                (l, r) => Err(RuntimeError {
-                    message: format!("Cannot concatenate {} and {}", l.type_name(), r.type_name()),
-                    span: Some(span),
-                }),
-            },
            BinaryOp::Sub => match (left, right) {
                (Value::Int(a), Value::Int(b)) => Ok(Value::Int(a - b)),
                (Value::Float(a), Value::Float(b)) => Ok(Value::Float(a - b)),
@@ -2540,45 +2463,6 @@ impl Interpreter {
                }
            }

-            BuiltinFn::MathSin => {
-                if args.len() != 1 {
-                    return Err(err("Math.sin requires 1 argument"));
-                }
-                match &args[0] {
-                    Value::Float(n) => Ok(EvalResult::Value(Value::Float(n.sin()))),
-                    Value::Int(n) => Ok(EvalResult::Value(Value::Float((*n as f64).sin()))),
-                    v => Err(err(&format!("Math.sin expects number, got {}", v.type_name()))),
-                }
-            }
-
-            BuiltinFn::MathCos => {
-                if args.len() != 1 {
-                    return Err(err("Math.cos requires 1 argument"));
-                }
-                match &args[0] {
-                    Value::Float(n) => Ok(EvalResult::Value(Value::Float(n.cos()))),
-                    Value::Int(n) => Ok(EvalResult::Value(Value::Float((*n as f64).cos()))),
-                    v => Err(err(&format!("Math.cos expects number, got {}", v.type_name()))),
-                }
-            }
-
-            BuiltinFn::MathAtan2 => {
-                if args.len() != 2 {
-                    return Err(err("Math.atan2 requires 2 arguments: y, x"));
-                }
-                let y = match &args[0] {
-                    Value::Float(n) => *n,
-                    Value::Int(n) => *n as f64,
-                    v => return Err(err(&format!("Math.atan2 expects number, got {}", v.type_name()))),
-                };
-                let x = match &args[1] {
-                    Value::Float(n) => *n,
-                    Value::Int(n) => *n as f64,
-                    v => return Err(err(&format!("Math.atan2 expects number, got {}", v.type_name()))),
-                };
-                Ok(EvalResult::Value(Value::Float(y.atan2(x))))
-            }
-
            // Additional List operations
            BuiltinFn::ListIsEmpty => {
                let list = Self::expect_arg_1::<Vec<Value>>(&args, "List.isEmpty", span)?;
@@ -5160,7 +5044,6 @@ mod tests {
        // Create a simple migration that adds a field
        // Migration: old.name -> { name: old.name, email: "unknown" }
        let migration_body = Expr::Record {
-            spread: None,
            fields: vec![
                (
                    Ident::new("name", Span::default()),
--- a/src/lexer.rs
+++ b/src/lexer.rs
@@ -70,7 +70,6 @@ pub enum TokenKind {

    // Operators
    Plus,       // +
-    PlusPlus,   // ++
    Minus,      // -
    Star,       // *
    Slash,      // /
@@ -90,7 +89,6 @@ pub enum TokenKind {
    Arrow,      // =>
    ThinArrow,  // ->
    Dot,        // .
-    DotDotDot,  // ...
    Colon,      // :
    ColonColon, // ::
    Comma,      // ,
@@ -162,7 +160,6 @@ impl fmt::Display for TokenKind {
            TokenKind::True => write!(f, "true"),
            TokenKind::False => write!(f, "false"),
            TokenKind::Plus => write!(f, "+"),
-            TokenKind::PlusPlus => write!(f, "++"),
            TokenKind::Minus => write!(f, "-"),
            TokenKind::Star => write!(f, "*"),
            TokenKind::Slash => write!(f, "/"),
@@ -182,7 +179,6 @@ impl fmt::Display for TokenKind {
            TokenKind::Arrow => write!(f, "=>"),
            TokenKind::ThinArrow => write!(f, "->"),
            TokenKind::Dot => write!(f, "."),
-            TokenKind::DotDotDot => write!(f, "..."),
            TokenKind::Colon => write!(f, ":"),
            TokenKind::ColonColon => write!(f, "::"),
            TokenKind::Comma => write!(f, ","),
@@ -272,14 +268,7 @@ impl<'a> Lexer<'a> {

        let kind = match c {
            // Single-character tokens
-            '+' => {
-                if self.peek() == Some('+') {
-                    self.advance();
-                    TokenKind::PlusPlus
-                } else {
-                    TokenKind::Plus
-                }
-            }
+            '+' => TokenKind::Plus,
            '*' => TokenKind::Star,
            '%' => TokenKind::Percent,
            '(' => TokenKind::LParen,
@@ -375,22 +364,7 @@ impl<'a> Lexer<'a> {
                    TokenKind::Pipe
                }
            }
-            '.' => {
-                if self.peek() == Some('.') {
-                    // Check for ... (need to peek past second dot)
-                    // We look at source directly since we can only peek one ahead
-                    let next_next = self.source[self.pos..].chars().nth(1);
-                    if next_next == Some('.') {
-                        self.advance(); // consume second '.'
-                        self.advance(); // consume third '.'
-                        TokenKind::DotDotDot
-                    } else {
-                        TokenKind::Dot
-                    }
-                } else {
-                    TokenKind::Dot
-                }
-            }
+            '.' => TokenKind::Dot,
            ':' => {
                if self.peek() == Some(':') {
                    self.advance();
--- a/src/linter.rs
+++ b/src/linter.rs
@@ -513,10 +513,7 @@ impl Linter {
            Expr::Field { object, .. } | Expr::TupleIndex { object, .. } => {
                self.collect_refs_expr(object);
            }
-            Expr::Record { spread, fields, .. } => {
-                if let Some(spread_expr) = spread {
-                    self.collect_refs_expr(spread_expr);
-                }
+            Expr::Record { fields, .. } => {
                for (_, val) in fields {
                    self.collect_refs_expr(val);
                }
--- a/src/lsp.rs
+++ b/src/lsp.rs
@@ -1571,10 +1571,7 @@ fn collect_call_site_hints(
                collect_call_site_hints(source, e, param_names, hints);
            }
        }
-        Expr::Record { spread, fields, .. } => {
-            if let Some(spread_expr) = spread {
-                collect_call_site_hints(source, spread_expr, param_names, hints);
-            }
+        Expr::Record { fields, .. } => {
            for (_, e) in fields {
                collect_call_site_hints(source, e, param_names, hints);
            }
--- a/src/main.rs
+++ b/src/main.rs
@@ -37,7 +37,7 @@ use std::borrow::Cow;
 use std::collections::HashSet;
 use typechecker::TypeChecker;

-const VERSION: &str = env!("CARGO_PKG_VERSION");
+const VERSION: &str = "0.1.0";

 const HELP: &str = r#"
 Lux - A functional language with first-class effects
@@ -902,7 +902,6 @@ fn compile_to_c(path: &str, output_path: Option<&str>, run_after: bool, emit_c:
        .args(["-O2", "-o"])
        .arg(&output_bin)
        .arg(&temp_c)
-        .arg("-lm")
        .output();

    match compile_result {
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -1558,7 +1558,6 @@ impl Parser {
        loop {
            let op = match self.peek_kind() {
                TokenKind::Plus => BinaryOp::Add,
-                TokenKind::PlusPlus => BinaryOp::Concat,
                TokenKind::Minus => BinaryOp::Sub,
                _ => break,
            };
@@ -2208,11 +2207,6 @@ impl Parser {
            }));
        }

-        // Check for record spread: { ...expr, field: val }
-        if matches!(self.peek_kind(), TokenKind::DotDotDot) {
-            return self.parse_record_expr_rest(start);
-        }
-
        // Check if it's a record (ident: expr) or block
        if matches!(self.peek_kind(), TokenKind::Ident(_)) {
            let lookahead = self.tokens.get(self.pos + 1).map(|t| &t.kind);
@@ -2227,20 +2221,6 @@ impl Parser {

    fn parse_record_expr_rest(&mut self, start: Span) -> Result<Expr, ParseError> {
        let mut fields = Vec::new();
-        let mut spread = None;
-
-        // Check for spread: { ...expr, ... }
-        if self.check(TokenKind::DotDotDot) {
-            self.advance(); // consume ...
-            let spread_expr = self.parse_expr()?;
-            spread = Some(Box::new(spread_expr));
-
-            self.skip_newlines();
-            if self.check(TokenKind::Comma) {
-                self.advance();
-            }
-            self.skip_newlines();
-        }

        while !self.check(TokenKind::RBrace) {
            let name = self.parse_ident()?;
@@ -2257,11 +2237,7 @@ impl Parser {

        self.expect(TokenKind::RBrace)?;
        let span = start.merge(self.previous_span());
-        Ok(Expr::Record {
-            spread,
-            fields,
-            span,
-        })
+        Ok(Expr::Record { fields, span })
    }

    fn parse_block_rest(&mut self, start: Span) -> Result<Expr, ParseError> {
--- a/src/symbol_table.rs
+++ b/src/symbol_table.rs
@@ -527,10 +527,7 @@ impl SymbolTable {
                    self.visit_expr(e, scope_idx);
                }
            }
-            Expr::Record { spread, fields, .. } => {
-                if let Some(spread_expr) = spread {
-                    self.visit_expr(spread_expr, scope_idx);
-                }
+            Expr::Record { fields, .. } => {
                for (_, e) in fields {
                    self.visit_expr(e, scope_idx);
                }
--- a/src/typechecker.rs
+++ b/src/typechecker.rs
@@ -339,10 +339,7 @@ fn references_params(expr: &Expr, params: &[&str]) -> bool {
        Expr::Lambda { body, .. } => references_params(body, params),
        Expr::Tuple { elements, .. } => elements.iter().any(|e| references_params(e, params)),
        Expr::List { elements, .. } => elements.iter().any(|e| references_params(e, params)),
-        Expr::Record { spread, fields, .. } => {
-            spread.as_ref().is_some_and(|s| references_params(s, params))
-                || fields.iter().any(|(_, e)| references_params(e, params))
-        }
+        Expr::Record { fields, .. } => fields.iter().any(|(_, e)| references_params(e, params)),
        Expr::Match { scrutinee, arms, .. } => {
            references_params(scrutinee, params)
                || arms.iter().any(|a| references_params(&a.body, params))
@@ -519,9 +516,8 @@ fn has_recursive_calls(func_name: &str, body: &Expr) -> bool {
        Expr::Tuple { elements, .. } | Expr::List { elements, .. } => {
            elements.iter().any(|e| has_recursive_calls(func_name, e))
        }
-        Expr::Record { spread, fields, .. } => {
-            spread.as_ref().is_some_and(|s| has_recursive_calls(func_name, s))
-                || fields.iter().any(|(_, e)| has_recursive_calls(func_name, e))
+        Expr::Record { fields, .. } => {
+            fields.iter().any(|(_, e)| has_recursive_calls(func_name, e))
        }
        Expr::Field { object, .. } | Expr::TupleIndex { object, .. } => has_recursive_calls(func_name, object),
        Expr::Let { value, body, .. } => {
@@ -676,7 +672,6 @@ fn generate_auto_migration_expr(

    // Build the record expression
    Some(Expr::Record {
-        spread: None,
        fields: field_exprs,
        span,
    })
@@ -1541,7 +1536,7 @@ impl TypeChecker {
        // Use the declared type if present, otherwise use inferred
        let final_type = if let Some(ref type_expr) = let_decl.typ {
            let declared = self.resolve_type(type_expr);
-            if let Err(e) = unify_with_env(&inferred, &declared, &self.env) {
+            if let Err(e) = unify(&inferred, &declared) {
                self.errors.push(TypeError {
                    message: format!(
                        "Variable '{}' has type {}, but declared type is {}: {}",
@@ -1749,11 +1744,7 @@ impl TypeChecker {
                span,
            } => self.infer_block(statements, result, *span),

-            Expr::Record {
-                spread,
-                fields,
-                span,
-            } => self.infer_record(spread.as_deref(), fields, *span),
+            Expr::Record { fields, span } => self.infer_record(fields, *span),

            Expr::Tuple { elements, span } => self.infer_tuple(elements, *span),

@@ -1792,7 +1783,7 @@ impl TypeChecker {
        match op {
            BinaryOp::Add => {
                // Add supports both numeric types and string concatenation
-                if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
+                if let Err(e) = unify(&left_type, &right_type) {
                    self.errors.push(TypeError {
                        message: format!("Operands of '{}' must have same type: {}", op, e),
                        span,
@@ -1813,32 +1804,9 @@ impl TypeChecker {
                }
            }

-            BinaryOp::Concat => {
-                // Concat (++) supports strings and lists
-                if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
-                    self.errors.push(TypeError {
-                        message: format!("Operands of '++' must have same type: {}", e),
-                        span,
-                    });
-                }
-                match &left_type {
-                    Type::String | Type::List(_) | Type::Var(_) => left_type,
-                    _ => {
-                        self.errors.push(TypeError {
-                            message: format!(
-                                "Operator '++' requires String or List operands, got {}",
-                                left_type
-                            ),
-                            span,
-                        });
-                        Type::Error
-                    }
-                }
-            }
-
            BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div | BinaryOp::Mod => {
                // Arithmetic: both operands must be same numeric type
-                if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
+                if let Err(e) = unify(&left_type, &right_type) {
                    self.errors.push(TypeError {
                        message: format!("Operands of '{}' must have same type: {}", op, e),
                        span,
@@ -1862,7 +1830,7 @@ impl TypeChecker {

            BinaryOp::Eq | BinaryOp::Ne => {
                // Equality: operands must have same type
-                if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
+                if let Err(e) = unify(&left_type, &right_type) {
                    self.errors.push(TypeError {
                        message: format!("Operands of '{}' must have same type: {}", op, e),
                        span,
@@ -1873,7 +1841,7 @@ impl TypeChecker {

            BinaryOp::Lt | BinaryOp::Le | BinaryOp::Gt | BinaryOp::Ge => {
                // Comparison: operands must be same orderable type
-                if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
+                if let Err(e) = unify(&left_type, &right_type) {
                    self.errors.push(TypeError {
                        message: format!("Operands of '{}' must have same type: {}", op, e),
                        span,
@@ -1884,13 +1852,13 @@ impl TypeChecker {

            BinaryOp::And | BinaryOp::Or => {
                // Logical: both must be Bool
-                if let Err(e) = unify_with_env(&left_type, &Type::Bool, &self.env) {
+                if let Err(e) = unify(&left_type, &Type::Bool) {
                    self.errors.push(TypeError {
                        message: format!("Left operand of '{}' must be Bool: {}", op, e),
                        span: left.span(),
                    });
                }
-                if let Err(e) = unify_with_env(&right_type, &Type::Bool, &self.env) {
+                if let Err(e) = unify(&right_type, &Type::Bool) {
                    self.errors.push(TypeError {
                        message: format!("Right operand of '{}' must be Bool: {}", op, e),
                        span: right.span(),
@@ -1904,7 +1872,7 @@ impl TypeChecker {
                // right must be a function that accepts left's type
                let result_type = Type::var();
                let expected_fn = Type::function(vec![left_type.clone()], result_type.clone());
-                if let Err(e) = unify_with_env(&right_type, &expected_fn, &self.env) {
+                if let Err(e) = unify(&right_type, &expected_fn) {
                    self.errors.push(TypeError {
                        message: format!(
                            "Pipe target must be a function accepting {}: {}",
@@ -1936,7 +1904,7 @@ impl TypeChecker {
                }
            },
            UnaryOp::Not => {
-                if let Err(e) = unify_with_env(&operand_type, &Type::Bool, &self.env) {
+                if let Err(e) = unify(&operand_type, &Type::Bool) {
                    self.errors.push(TypeError {
                        message: format!("Operator '!' requires Bool operand: {}", e),
                        span,
@@ -1987,7 +1955,7 @@ impl TypeChecker {
            self.current_effects.clone(),
        );

-        match unify_with_env(&func_type, &expected_fn, &self.env) {
+        match unify(&func_type, &expected_fn) {
            Ok(subst) => result_type.apply(&subst),
            Err(e) => {
                // Provide more detailed error message based on the type of mismatch
@@ -2064,7 +2032,7 @@ impl TypeChecker {
                    let result_type = Type::var();
                    let expected_fn = Type::function(arg_types, result_type.clone());

-                    if let Err(e) = unify_with_env(field_type, &expected_fn, &self.env) {
+                    if let Err(e) = unify(field_type, &expected_fn) {
                        self.errors.push(TypeError {
                            message: format!(
                                "Type mismatch in {}.{} call: {}",
@@ -2136,7 +2104,7 @@ impl TypeChecker {
                for (i, (arg_type, (_, param_type))) in
                    arg_types.iter().zip(op.params.iter()).enumerate()
                {
-                    if let Err(e) = unify_with_env(arg_type, param_type, &self.env) {
+                    if let Err(e) = unify(arg_type, param_type) {
                        self.errors.push(TypeError {
                            message: format!(
                                "Argument {} of '{}.{}' has type {}, expected {}: {}",
@@ -2169,7 +2137,6 @@ impl TypeChecker {

    fn infer_field(&mut self, object: &Expr, field: &Ident, span: Span) -> Type {
        let object_type = self.infer_expr(object);
-        let object_type = self.env.expand_type_alias(&object_type);

        match &object_type {
            Type::Record(fields) => match fields.iter().find(|(n, _)| n == &field.name) {
@@ -2250,7 +2217,7 @@ impl TypeChecker {
        // Check return type if specified
        let ret_type = if let Some(rt) = return_type {
            let declared = self.resolve_type(rt);
-            if let Err(e) = unify_with_env(&body_type, &declared, &self.env) {
+            if let Err(e) = unify(&body_type, &declared) {
                self.errors.push(TypeError {
                    message: format!(
                        "Lambda body type {} doesn't match declared {}: {}",
@@ -2316,7 +2283,7 @@ impl TypeChecker {
        span: Span,
    ) -> Type {
        let cond_type = self.infer_expr(condition);
-        if let Err(e) = unify_with_env(&cond_type, &Type::Bool, &self.env) {
+        if let Err(e) = unify(&cond_type, &Type::Bool) {
            self.errors.push(TypeError {
                message: format!("If condition must be Bool, got {}: {}", cond_type, e),
                span: condition.span(),
@@ -2326,7 +2293,7 @@ impl TypeChecker {
        let then_type = self.infer_expr(then_branch);
        let else_type = self.infer_expr(else_branch);

-        match unify_with_env(&then_type, &else_type, &self.env) {
+        match unify(&then_type, &else_type) {
            Ok(subst) => then_type.apply(&subst),
            Err(e) => {
                self.errors.push(TypeError {
@@ -2367,7 +2334,7 @@ impl TypeChecker {
            // Check guard if present
            if let Some(ref guard) = arm.guard {
                let guard_type = self.infer_expr(guard);
-                if let Err(e) = unify_with_env(&guard_type, &Type::Bool, &self.env) {
+                if let Err(e) = unify(&guard_type, &Type::Bool) {
                    self.errors.push(TypeError {
                        message: format!("Match guard must be Bool: {}", e),
                        span: guard.span(),
@@ -2383,7 +2350,7 @@ impl TypeChecker {
            match &result_type {
                None => result_type = Some(body_type),
                Some(prev) => {
-                    if let Err(e) = unify_with_env(prev, &body_type, &self.env) {
+                    if let Err(e) = unify(prev, &body_type) {
                        self.errors.push(TypeError {
                            message: format!(
                                "Match arm has incompatible type: expected {}, got {}: {}",
@@ -2433,7 +2400,7 @@ impl TypeChecker {

            Pattern::Literal(lit) => {
                let lit_type = self.infer_literal(lit);
-                if let Err(e) = unify_with_env(&lit_type, expected, &self.env) {
+                if let Err(e) = unify(&lit_type, expected) {
                    self.errors.push(TypeError {
                        message: format!("Pattern literal type mismatch: {}", e),
                        span: lit.span,
@@ -2447,7 +2414,7 @@ impl TypeChecker {
                // For now, handle Option specially
                match name.name.as_str() {
                    "None" => {
-                        if let Err(e) = unify_with_env(expected, &Type::Option(Box::new(Type::var())), &self.env) {
+                        if let Err(e) = unify(expected, &Type::Option(Box::new(Type::var()))) {
                            self.errors.push(TypeError {
                                message: format!(
                                    "None pattern doesn't match type {}: {}",
@@ -2460,7 +2427,7 @@ impl TypeChecker {
                    }
                    "Some" => {
                        let inner_type = Type::var();
-                        if let Err(e) = unify_with_env(expected, &Type::Option(Box::new(inner_type.clone())), &self.env)
+                        if let Err(e) = unify(expected, &Type::Option(Box::new(inner_type.clone())))
                        {
                            self.errors.push(TypeError {
                                message: format!(
@@ -2489,7 +2456,7 @@ impl TypeChecker {

            Pattern::Tuple { elements, span } => {
                let element_types: Vec<Type> = elements.iter().map(|_| Type::var()).collect();
-                if let Err(e) = unify_with_env(expected, &Type::Tuple(element_types.clone()), &self.env) {
+                if let Err(e) = unify(expected, &Type::Tuple(element_types.clone())) {
                    self.errors.push(TypeError {
                        message: format!("Tuple pattern doesn't match type {}: {}", expected, e),
                        span: *span,
@@ -2539,7 +2506,7 @@ impl TypeChecker {

                    if let Some(type_expr) = typ {
                        let declared = self.resolve_type(type_expr);
-                        if let Err(e) = unify_with_env(&value_type, &declared, &self.env) {
+                        if let Err(e) = unify(&value_type, &declared) {
                            self.errors.push(TypeError {
                                message: format!(
                                    "Variable '{}' has type {}, but declared type is {}: {}",
@@ -2560,46 +2527,12 @@ impl TypeChecker {
        self.infer_expr(result)
    }

-    fn infer_record(
-        &mut self,
-        spread: Option<&Expr>,
-        fields: &[(Ident, Expr)],
-        span: Span,
-    ) -> Type {
-        // Start with spread fields if present
-        let mut field_types: Vec<(String, Type)> = if let Some(spread_expr) = spread {
-            let spread_type = self.infer_expr(spread_expr);
-            match spread_type {
-                Type::Record(spread_fields) => spread_fields,
-                _ => {
-                    self.errors.push(TypeError {
-                        message: format!(
-                            "Spread expression must be a record type, got {}",
-                            spread_type
-                        ),
-                        span,
-                    });
-                    Vec::new()
-                }
-            }
-        } else {
-            Vec::new()
-        };
-
-        // Apply explicit field overrides
-        let explicit_types: Vec<(String, Type)> = fields
+    fn infer_record(&mut self, fields: &[(Ident, Expr)], _span: Span) -> Type {
+        let field_types: Vec<(String, Type)> = fields
            .iter()
            .map(|(name, expr)| (name.name.clone(), self.infer_expr(expr)))
            .collect();

-        for (name, typ) in explicit_types {
-            if let Some(existing) = field_types.iter_mut().find(|(n, _)| n == &name) {
-                existing.1 = typ;
-            } else {
-                field_types.push((name, typ));
-            }
-        }
-
        Type::Record(field_types)
    }

@@ -2616,7 +2549,7 @@ impl TypeChecker {
        let first_type = self.infer_expr(&elements[0]);
        for elem in &elements[1..] {
            let elem_type = self.infer_expr(elem);
-            if let Err(e) = unify_with_env(&first_type, &elem_type, &self.env) {
+            if let Err(e) = unify(&first_type, &elem_type) {
                self.errors.push(TypeError {
                    message: format!("List elements must have same type: {}", e),
                    span,
@@ -2922,7 +2855,7 @@ impl TypeChecker {
            // Check return type matches if specified
            if let Some(ref return_type_expr) = impl_method.return_type {
                let return_type = self.resolve_type(return_type_expr);
-                if let Err(e) = unify_with_env(&body_type, &return_type, &self.env) {
+                if let Err(e) = unify(&body_type, &return_type) {
                    self.errors.push(TypeError {
                        message: format!(
                            "Method '{}' body has type {}, but declared return type is {}: {}",
--- a/src/types.rs
+++ b/src/types.rs
@@ -1887,18 +1887,6 @@ impl TypeEnv {
                "round".to_string(),
                Type::function(vec![Type::var()], Type::Int),
            ),
-            (
-                "sin".to_string(),
-                Type::function(vec![Type::Float], Type::Float),
-            ),
-            (
-                "cos".to_string(),
-                Type::function(vec![Type::Float], Type::Float),
-            ),
-            (
-                "atan2".to_string(),
-                Type::function(vec![Type::Float, Type::Float], Type::Float),
-            ),
        ]);
        env.bind("Math", TypeScheme::mono(math_module_type));