chore: bump version to 0.1.8

Add missing List operations requested by ergon game engine project:
- findIndex(list, predicate) -> Option<Int>
- zip(list1, list2) -> List<(A, B)>
- flatten(listOfLists) -> List<A>
- contains(list, element) -> Bool

Resolves ergon porting blocker #4.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Cargo.lock

@@ -225,7 +225,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -392,6 +392,12 @@ dependencies = [
  "wasip3",
 ]
 
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
 [[package]]
 name = "h2"
 version = "0.3.27"
@@ -770,8 +776,9 @@ dependencies = [
 
 [[package]]
 name = "lux"
-version = "0.1.4"
+version = "0.1.7"
 dependencies = [
+ "glob",
  "lsp-server",
  "lsp-types",
  "postgres",
@@ -1182,7 +1189,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1475,7 +1482,7 @@ dependencies = [
  "getrandom 0.4.1",
  "once_cell",
  "rustix",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lux"
-version = "0.1.5"
+version = "0.1.8"
 edition = "2021"
 description = "A functional programming language with first-class effects, schema evolution, and behavioral types"
 license = "MIT"
@@ -17,6 +17,7 @@ reqwest = { version = "0.11", default-features = false, features = ["blocking",
 tiny_http = "0.12"
 rusqlite = { version = "0.31", features = ["bundled"] }
 postgres = "0.19"
+glob = "0.3"
 
 
 [dev-dependencies]

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.5\n"
+            printf "  \033[1;35m╩═╝╚═╝╩ ╩\033[0m  v0.1.8\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.5";
+          version = "0.1.8";
           src = ./.;
           cargoLock.lockFile = ./Cargo.lock;
 
@@ -79,7 +79,7 @@
           };
         in muslPkgs.rustPlatform.buildRustPackage {
           pname = "lux";
-          version = "0.1.5";
+          version = "0.1.8";
           src = ./.;
           cargoLock.lockFile = ./Cargo.lock;
 

src/ast.rs

@@ -697,8 +697,9 @@ pub enum Pattern {
     Var(Ident),
     /// Literal: 42, "hello", true
     Literal(Literal),
-    /// Constructor: Some(x), None, Ok(v)
+    /// Constructor: Some(x), None, Ok(v), module.Constructor(x)
     Constructor {
+        module: Option<Ident>,
         name: Ident,
         fields: Vec<Pattern>,
         span: Span,

src/codegen/c_backend.rs

@@ -146,6 +146,8 @@ pub struct CBackend {
     imported_modules: HashSet<String>,
     /// Variable name renames: Lux name → C variable name (for let binding name mangling)
     var_renames: HashMap<String, String>,
+    /// Inner type for Option-typed variables (variable name -> inner C type, e.g. "LuxInt")
+    var_option_inner_types: HashMap<String, String>,
 }
 
 impl CBackend {
@@ -177,6 +179,7 @@ impl CBackend {
             module_functions: HashMap::new(),
             imported_modules: HashSet::new(),
             var_renames: HashMap::new(),
+            var_option_inner_types: HashMap::new(),
         }
     }
 
@@ -279,7 +282,7 @@ impl CBackend {
                 Declaration::Let(let_decl) => {
                     // Skip run expressions - they're handled in the main wrapper
                     if !matches!(&let_decl.value, Expr::Run { .. }) {
-                        self.emit_global_let(&let_decl.name)?;
+                        self.emit_global_let(let_decl)?;
                     }
                 }
                 _ => {}
@@ -599,6 +602,18 @@ impl CBackend {
         self.writeln(&format!("{} {}({}) {{", ret_type, mangled_name, full_params));
         self.indent += 1;
 
+        // Register parameter types so match/option inference can use them
+        for p in &func.params {
+            if let Ok(c_type) = self.type_expr_to_c(&p.typ) {
+                let escaped = self.escape_c_keyword(&p.name.name);
+                self.var_types.insert(escaped.clone(), c_type);
+                // Track Option inner types for match pattern extraction
+                if let Some(inner) = self.option_inner_type_from_type_expr(&p.typ) {
+                    self.var_option_inner_types.insert(escaped, inner);
+                }
+            }
+        }
+
         let old_has_evidence = self.has_evidence;
         if is_effectful {
             self.has_evidence = true;
@@ -1149,7 +1164,12 @@ impl CBackend {
         self.writeln("    void (*delete_file)(void* env, LuxString path);");
         self.writeln("    LuxBool (*isDir)(void* env, LuxString path);");
         self.writeln("    void (*mkdir)(void* env, LuxString path);");
+        self.writeln("    void (*copy)(void* env, LuxString src, LuxString dst);");
         self.writeln("    LuxList* (*readDir)(void* env, LuxString path);");
+        self.writeln("    LuxList* (*glob)(void* env, LuxString pattern);");
+        self.writeln("    Result (*tryRead)(void* env, LuxString path);");
+        self.writeln("    Result (*tryWrite)(void* env, LuxString path, LuxString content);");
+        self.writeln("    Result (*tryDelete)(void* env, LuxString path);");
         self.writeln("    void* env;");
         self.writeln("} LuxFileHandler;");
         self.writeln("");
@@ -1336,6 +1356,20 @@ impl CBackend {
         self.writeln("    mkdir(path, 0755);");
         self.writeln("}");
         self.writeln("");
+        self.writeln("static void lux_file_copy(LuxString src, LuxString dst) {");
+        self.writeln("    FILE* fin = fopen(src, \"rb\");");
+        self.writeln("    if (!fin) return;");
+        self.writeln("    FILE* fout = fopen(dst, \"wb\");");
+        self.writeln("    if (!fout) { fclose(fin); return; }");
+        self.writeln("    char buf[4096];");
+        self.writeln("    size_t n;");
+        self.writeln("    while ((n = fread(buf, 1, sizeof(buf), fin)) > 0) {");
+        self.writeln("        fwrite(buf, 1, n, fout);");
+        self.writeln("    }");
+        self.writeln("    fclose(fin);");
+        self.writeln("    fclose(fout);");
+        self.writeln("}");
+        self.writeln("");
         self.writeln("#include <dirent.h>");
         self.writeln("// Forward declarations needed by lux_file_readDir");
         self.writeln("static LuxList* lux_list_new(int64_t capacity);");
@@ -1356,6 +1390,85 @@ impl CBackend {
         self.writeln("    return result;");
         self.writeln("}");
         self.writeln("");
+        self.writeln("#include <glob.h>");
+        self.writeln("static LuxList* lux_file_glob(LuxString pattern) {");
+        self.writeln("    LuxList* result = lux_list_new(16);");
+        self.writeln("    glob_t globbuf;");
+        self.writeln("    int ret = glob(pattern, 0, NULL, &globbuf);");
+        self.writeln("    if (ret == 0) {");
+        self.writeln("        for (size_t i = 0; i < globbuf.gl_pathc; i++) {");
+        self.writeln("            size_t len = strlen(globbuf.gl_pathv[i]);");
+        self.writeln("            LuxString name = (LuxString)lux_rc_alloc(len + 1, LUX_TAG_STRING);");
+        self.writeln("            memcpy(name, globbuf.gl_pathv[i], len + 1);");
+        self.writeln("            lux_list_push(result, (void*)name);");
+        self.writeln("        }");
+        self.writeln("        globfree(&globbuf);");
+        self.writeln("    }");
+        self.writeln("    return result;");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static Result lux_file_tryRead(LuxString path) {");
+        self.writeln("    Result r;");
+        self.writeln("    FILE* f = fopen(path, \"r\");");
+        self.writeln("    if (!f) {");
+        self.writeln("        char buf[512];");
+        self.writeln("        snprintf(buf, sizeof(buf), \"Failed to read file '%s': %s\", path, strerror(errno));");
+        self.writeln("        size_t len = strlen(buf);");
+        self.writeln("        LuxString msg = (LuxString)lux_rc_alloc(len + 1, LUX_TAG_STRING);");
+        self.writeln("        memcpy(msg, buf, len + 1);");
+        self.writeln("        r.tag = Result_TAG_ERR;");
+        self.writeln("        r.data.err.field0 = (void*)msg;");
+        self.writeln("        return r;");
+        self.writeln("    }");
+        self.writeln("    fseek(f, 0, SEEK_END);");
+        self.writeln("    long size = ftell(f);");
+        self.writeln("    fseek(f, 0, SEEK_SET);");
+        self.writeln("    LuxString content = (LuxString)lux_rc_alloc(size + 1, LUX_TAG_STRING);");
+        self.writeln("    size_t read_size = fread(content, 1, size, f);");
+        self.writeln("    content[read_size] = '\\0';");
+        self.writeln("    fclose(f);");
+        self.writeln("    r.tag = Result_TAG_OK;");
+        self.writeln("    r.data.ok.field0 = (void*)content;");
+        self.writeln("    return r;");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static Result lux_file_tryWrite(LuxString path, LuxString content) {");
+        self.writeln("    Result r;");
+        self.writeln("    FILE* f = fopen(path, \"w\");");
+        self.writeln("    if (!f) {");
+        self.writeln("        char buf[512];");
+        self.writeln("        snprintf(buf, sizeof(buf), \"Failed to write file '%s': %s\", path, strerror(errno));");
+        self.writeln("        size_t len = strlen(buf);");
+        self.writeln("        LuxString msg = (LuxString)lux_rc_alloc(len + 1, LUX_TAG_STRING);");
+        self.writeln("        memcpy(msg, buf, len + 1);");
+        self.writeln("        r.tag = Result_TAG_ERR;");
+        self.writeln("        r.data.err.field0 = (void*)msg;");
+        self.writeln("        return r;");
+        self.writeln("    }");
+        self.writeln("    fputs(content, f);");
+        self.writeln("    fclose(f);");
+        self.writeln("    r.tag = Result_TAG_OK;");
+        self.writeln("    r.data.ok.field0 = NULL;");
+        self.writeln("    return r;");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static Result lux_file_tryDelete(LuxString path) {");
+        self.writeln("    Result r;");
+        self.writeln("    if (remove(path) != 0) {");
+        self.writeln("        char buf[512];");
+        self.writeln("        snprintf(buf, sizeof(buf), \"Failed to delete file '%s': %s\", path, strerror(errno));");
+        self.writeln("        size_t len = strlen(buf);");
+        self.writeln("        LuxString msg = (LuxString)lux_rc_alloc(len + 1, LUX_TAG_STRING);");
+        self.writeln("        memcpy(msg, buf, len + 1);");
+        self.writeln("        r.tag = Result_TAG_ERR;");
+        self.writeln("        r.data.err.field0 = (void*)msg;");
+        self.writeln("        return r;");
+        self.writeln("    }");
+        self.writeln("    r.tag = Result_TAG_OK;");
+        self.writeln("    r.data.ok.field0 = NULL;");
+        self.writeln("    return r;");
+        self.writeln("}");
+        self.writeln("");
         self.writeln("static LuxString default_file_read(void* env, LuxString path) {");
         self.writeln("    (void)env;");
         self.writeln("    return lux_file_read(path);");
@@ -1391,11 +1504,36 @@ impl CBackend {
         self.writeln("    lux_file_mkdir(path);");
         self.writeln("}");
         self.writeln("");
+        self.writeln("static void default_file_copy(void* env, LuxString src, LuxString dst) {");
+        self.writeln("    (void)env;");
+        self.writeln("    lux_file_copy(src, dst);");
+        self.writeln("}");
+        self.writeln("");
         self.writeln("static LuxList* default_file_readDir(void* env, LuxString path) {");
         self.writeln("    (void)env;");
         self.writeln("    return lux_file_readDir(path);");
         self.writeln("}");
         self.writeln("");
+        self.writeln("static LuxList* default_file_glob(void* env, LuxString pattern) {");
+        self.writeln("    (void)env;");
+        self.writeln("    return lux_file_glob(pattern);");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static Result default_file_tryRead(void* env, LuxString path) {");
+        self.writeln("    (void)env;");
+        self.writeln("    return lux_file_tryRead(path);");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static Result default_file_tryWrite(void* env, LuxString path, LuxString content) {");
+        self.writeln("    (void)env;");
+        self.writeln("    return lux_file_tryWrite(path, content);");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static Result default_file_tryDelete(void* env, LuxString path) {");
+        self.writeln("    (void)env;");
+        self.writeln("    return lux_file_tryDelete(path);");
+        self.writeln("}");
+        self.writeln("");
         self.writeln("static LuxFileHandler default_file_handler = {");
         self.writeln("    .read = default_file_read,");
         self.writeln("    .write = default_file_write,");
@@ -1404,7 +1542,12 @@ impl CBackend {
         self.writeln("    .delete_file = default_file_delete,");
         self.writeln("    .isDir = default_file_isDir,");
         self.writeln("    .mkdir = default_file_mkdir,");
+        self.writeln("    .copy = default_file_copy,");
         self.writeln("    .readDir = default_file_readDir,");
+        self.writeln("    .glob = default_file_glob,");
+        self.writeln("    .tryRead = default_file_tryRead,");
+        self.writeln("    .tryWrite = default_file_tryWrite,");
+        self.writeln("    .tryDelete = default_file_tryDelete,");
         self.writeln("    .env = NULL");
         self.writeln("};");
         self.writeln("");
@@ -2051,6 +2194,42 @@ impl CBackend {
         self.writeln("    return result;");
         self.writeln("}");
         self.writeln("");
+        // Sort helper: compare two void* as boxed ints
+        self.writeln("static int lux_compare_int(const void* a, const void* b) {");
+        self.writeln("    LuxInt va = *(LuxInt*)(*(void**)a);");
+        self.writeln("    LuxInt vb = *(LuxInt*)(*(void**)b);");
+        self.writeln("    return (va > vb) - (va < vb);");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static int lux_compare_string(const void* a, const void* b) {");
+        self.writeln("    LuxString sa = (LuxString)(*(void**)a);");
+        self.writeln("    LuxString sb = (LuxString)(*(void**)b);");
+        self.writeln("    return strcmp(sa, sb);");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("static LuxList* lux_list_sort(LuxList* list) {");
+        self.writeln("    if (list->length <= 1) {");
+        self.writeln("        lux_incref(list);");
+        self.writeln("        return list;");
+        self.writeln("    }");
+        self.writeln("    LuxList* result = lux_list_new(list->length);");
+        self.writeln("    for (int64_t i = 0; i < list->length; i++) {");
+        self.writeln("        lux_incref(list->elements[i]);");
+        self.writeln("        result->elements[i] = list->elements[i];");
+        self.writeln("    }");
+        self.writeln("    result->length = list->length;");
+        self.writeln("    // Determine element type from first element and sort");
+        self.writeln("    if (result->length > 0 && result->elements[0] != NULL) {");
+        self.writeln("        uint32_t tag = LUX_RC_HEADER(result->elements[0])->tag;");
+        self.writeln("        if (tag == LUX_TAG_BOXED_INT) {");
+        self.writeln("            qsort(result->elements, result->length, sizeof(void*), lux_compare_int);");
+        self.writeln("        } else if (tag == LUX_TAG_STRING) {");
+        self.writeln("            qsort(result->elements, result->length, sizeof(void*), lux_compare_string);");
+        self.writeln("        }");
+        self.writeln("    }");
+        self.writeln("    return result;");
+        self.writeln("}");
+        self.writeln("");
         // === Map Runtime Functions ===
         self.writeln("static LuxMap* lux_map_new(int64_t capacity) {");
         self.writeln("    LuxMap* map = (LuxMap*)malloc(sizeof(LuxMap));");
@@ -2124,20 +2303,6 @@ impl CBackend {
         self.writeln("static Option lux_option_none(void) { return (Option){Option_TAG_NONE}; }");
         self.writeln("static Option lux_option_some(void* value) { return (Option){Option_TAG_SOME, .data.some = {value}}; }");
         self.writeln("");
-        self.writeln("// String indexOf / lastIndexOf — return Option<Int>");
-        self.writeln("static Option lux_string_indexOf(LuxString s, LuxString needle) {");
-        self.writeln("    char* pos = strstr(s, needle);");
-        self.writeln("    if (pos) return lux_option_some((void*)(intptr_t)(pos - s));");
-        self.writeln("    return lux_option_none();");
-        self.writeln("}");
-        self.writeln("static Option lux_string_lastIndexOf(LuxString s, LuxString needle) {");
-        self.writeln("    char* last = NULL;");
-        self.writeln("    char* pos = strstr(s, needle);");
-        self.writeln("    while (pos) { last = pos; pos = strstr(pos + 1, needle); }");
-        self.writeln("    if (last) return lux_option_some((void*)(intptr_t)(last - s));");
-        self.writeln("    return lux_option_none();");
-        self.writeln("}");
-        self.writeln("");
         self.writeln("// === Boxing/Unboxing ===");
         self.writeln("// All boxed values are RC-managed.");
         self.writeln("");
@@ -2171,6 +2336,20 @@ impl CBackend {
         self.writeln("}");
         self.writeln("static LuxString lux_unbox_string(void* p) { return (LuxString)p; }");
         self.writeln("");
+        self.writeln("// String indexOf / lastIndexOf — return Option<Int>");
+        self.writeln("static Option lux_string_indexOf(LuxString s, LuxString needle) {");
+        self.writeln("    char* pos = strstr(s, needle);");
+        self.writeln("    if (pos) return lux_option_some(lux_box_int((LuxInt)(pos - s)));");
+        self.writeln("    return lux_option_none();");
+        self.writeln("}");
+        self.writeln("static Option lux_string_lastIndexOf(LuxString s, LuxString needle) {");
+        self.writeln("    char* last = NULL;");
+        self.writeln("    char* pos = strstr(s, needle);");
+        self.writeln("    while (pos) { last = pos; pos = strstr(pos + 1, needle); }");
+        self.writeln("    if (last) return lux_option_some(lux_box_int((LuxInt)(last - s)));");
+        self.writeln("    return lux_option_none();");
+        self.writeln("}");
+        self.writeln("");
         self.writeln("// === Polymorphic Drop Function ===");
         self.writeln("// Called when an object's refcount reaches zero.");
         self.writeln("// Recursively decrefs any owned references before freeing.");
@@ -2706,7 +2885,11 @@ impl CBackend {
         for param in &func.params {
             let escaped = self.escape_c_keyword(&param.name.name);
             if let Ok(c_type) = self.type_expr_to_c(&param.typ) {
-                self.var_types.insert(escaped, c_type);
+                self.var_types.insert(escaped.clone(), c_type);
+                // Track Option inner types for match pattern extraction
+                if let Some(inner) = self.option_inner_type_from_type_expr(&param.typ) {
+                    self.var_option_inner_types.insert(escaped, inner);
+                }
             }
         }
 
@@ -3067,6 +3250,13 @@ impl CBackend {
                 // Infer the type from the value expression
                 let var_type = self.infer_expr_type(value).unwrap_or_else(|| "LuxInt".to_string());
 
+                // Track Option inner type for match pattern extraction
+                if var_type == "Option" {
+                    if let Some(inner) = self.infer_option_inner_type(value) {
+                        self.var_option_inner_types.insert(var_name.clone(), inner);
+                    }
+                }
+
                 self.writeln(&format!("{} {} = {};", var_type, var_name, val));
 
                 // Register the variable rename so nested expressions can find it
@@ -3375,6 +3565,13 @@ impl CBackend {
                             // Record variable type for future inference
                             self.var_types.insert(escaped_name.clone(), typ.clone());
 
+                            // Track Option inner type for match pattern extraction
+                            if typ == "Option" {
+                                if let Some(inner) = self.infer_option_inner_type(value) {
+                                    self.var_option_inner_types.insert(escaped_name.clone(), inner);
+                                }
+                            }
+
                             // Handle ownership transfer or RC registration
                             if let Some(source_name) = source_var {
                                 // Ownership transfer: unregister source, register dest
@@ -3679,6 +3876,16 @@ impl CBackend {
                             }
                             return Ok("NULL".to_string());
                         }
+                        "copy" => {
+                            let src = self.emit_expr(&args[0])?;
+                            let dst = self.emit_expr(&args[1])?;
+                            if self.has_evidence {
+                                self.writeln(&format!("ev->file->copy(ev->file->env, {}, {});", src, dst));
+                            } else {
+                                self.writeln(&format!("lux_file_copy({}, {});", src, dst));
+                            }
+                            return Ok("NULL".to_string());
+                        }
                         "readDir" | "listDir" => {
                             let path = self.emit_expr(&args[0])?;
                             let temp = format!("_readdir_{}", self.fresh_name());
@@ -3690,6 +3897,50 @@ impl CBackend {
                             self.register_rc_var(&temp, "LuxList*");
                             return Ok(temp);
                         }
+                        "glob" => {
+                            let pattern = self.emit_expr(&args[0])?;
+                            let temp = format!("_glob_{}", self.fresh_name());
+                            if self.has_evidence {
+                                self.writeln(&format!("LuxList* {} = ev->file->glob(ev->file->env, {});", temp, pattern));
+                            } else {
+                                self.writeln(&format!("LuxList* {} = lux_file_glob({});", temp, pattern));
+                            }
+                            self.register_rc_var(&temp, "LuxList*");
+                            return Ok(temp);
+                        }
+                        "tryRead" => {
+                            let path = self.emit_expr(&args[0])?;
+                            let temp = format!("_file_tryread_{}", self.fresh_name());
+                            if self.has_evidence {
+                                self.writeln(&format!("Result {} = ev->file->tryRead(ev->file->env, {});", temp, path));
+                            } else {
+                                self.writeln(&format!("Result {} = lux_file_tryRead({});", temp, path));
+                            }
+                            return Ok(temp);
+                        }
+                        "tryWrite" => {
+                            let path = self.emit_expr(&args[0])?;
+                            let content = self.emit_expr(&args[1])?;
+                            if self.has_evidence {
+                                let temp = format!("_file_trywrite_{}", self.fresh_name());
+                                self.writeln(&format!("Result {} = ev->file->tryWrite(ev->file->env, {}, {});", temp, path, content));
+                                return Ok(temp);
+                            } else {
+                                let temp = format!("_file_trywrite_{}", self.fresh_name());
+                                self.writeln(&format!("Result {} = lux_file_tryWrite({}, {});", temp, path, content));
+                                return Ok(temp);
+                            }
+                        }
+                        "tryDelete" => {
+                            let path = self.emit_expr(&args[0])?;
+                            let temp = format!("_file_trydelete_{}", self.fresh_name());
+                            if self.has_evidence {
+                                self.writeln(&format!("Result {} = ev->file->tryDelete(ev->file->env, {});", temp, path));
+                            } else {
+                                self.writeln(&format!("Result {} = lux_file_tryDelete({});", temp, path));
+                            }
+                            return Ok(temp);
+                        }
                         _ => {}
                     }
                 }
@@ -4615,6 +4866,184 @@ impl CBackend {
                 Ok(result_var)
             }
 
+            "sort" => {
+                if args.len() != 1 {
+                    return Err(CGenError {
+                        message: "List.sort takes 1 argument".to_string(),
+                        span: None,
+                    });
+                }
+                let list = self.emit_expr(&args[0])?;
+                let result_var = format!("_sorted_{}", self.fresh_name());
+                self.writeln(&format!(
+                    "LuxList* {} = lux_list_sort({});",
+                    result_var, list
+                ));
+                self.register_rc_var(&result_var, "LuxList*");
+                Ok(result_var)
+            }
+            "sortBy" => {
+                if args.len() != 2 {
+                    return Err(CGenError {
+                        message: "List.sortBy takes 2 arguments".to_string(),
+                        span: None,
+                    });
+                }
+                let list = self.emit_expr(&args[0])?;
+                let closure = self.emit_expr(&args[1])?;
+                let result_var = format!("_sorted_{}", self.fresh_name());
+                // Copy the list then do insertion sort with custom comparator
+                self.writeln(&format!(
+                    "LuxList* {} = lux_list_new({}->length);",
+                    result_var, list
+                ));
+                self.writeln(&format!(
+                    "for (int64_t _i = 0; _i < {}->length; _i++) {{",
+                    list
+                ));
+                self.writeln(&format!(
+                    "    lux_incref({}->elements[_i]);",
+                    list
+                ));
+                self.writeln(&format!(
+                    "    {}->elements[_i] = {}->elements[_i];",
+                    result_var, list
+                ));
+                self.writeln("}");
+                self.writeln(&format!(
+                    "{}->length = {}->length;",
+                    result_var, list
+                ));
+                // Insertion sort using the comparator closure
+                self.writeln(&format!(
+                    "for (int64_t _i = 1; _i < {}->length; _i++) {{",
+                    result_var
+                ));
+                self.writeln(&format!(
+                    "    void* _key = {}->elements[_i];",
+                    result_var
+                ));
+                self.writeln("    int64_t _j = _i - 1;");
+                self.writeln(&format!(
+                    "    while (_j >= 0 && *(LuxInt*){}.fn({}.env, {}->elements[_j], _key) > 0) {{",
+                    closure, closure, result_var
+                ));
+                self.writeln(&format!(
+                    "        {}->elements[_j + 1] = {}->elements[_j];",
+                    result_var, result_var
+                ));
+                self.writeln("        _j--;");
+                self.writeln("    }");
+                self.writeln(&format!(
+                    "    {}->elements[_j + 1] = _key;",
+                    result_var
+                ));
+                self.writeln("}");
+                self.register_rc_var(&result_var, "LuxList*");
+                Ok(result_var)
+            }
+            "findIndex" => {
+                if args.len() != 2 {
+                    return Err(CGenError { message: "List.findIndex takes 2 arguments".to_string(), span: None });
+                }
+                let elem_type = self.infer_callback_param_type(&args[1], 0);
+                let elem_is_prim = Self::is_primitive_c_type(&elem_type);
+
+                let list = self.emit_expr(&args[0])?;
+                let closure = self.emit_expr(&args[1])?;
+                let id = self.fresh_name();
+                let result_var = format!("_findidx_{}", id);
+                let i_var = format!("_i_{}", id);
+                let elem_var = format!("_elem_{}", id);
+                let fn_var = format!("_fn_{}", id);
+                let matches_var = format!("_matches_{}", id);
+
+                let arg_pass = if elem_is_prim {
+                    format!("{}({})", Self::unbox_fn_for_type(&elem_type), elem_var)
+                } else {
+                    elem_var.clone()
+                };
+                let fn_cast = if elem_is_prim {
+                    format!("(LuxBool(*)(void*, {}))", elem_type)
+                } else {
+                    "(LuxBool(*)(void*, void*))".to_string()
+                };
+
+                self.writeln(&format!("Option {} = lux_option_none();", result_var));
+                self.writeln(&format!("for (int64_t {} = 0; {} < {}->length; {}++) {{", i_var, i_var, list, i_var));
+                self.indent += 1;
+                self.writeln(&format!("void* {} = {}->elements[{}];", elem_var, list, i_var));
+                self.writeln(&format!("LuxClosure* {} = (LuxClosure*){};", fn_var, closure));
+                self.writeln(&format!("LuxBool {} = ({}{}->fn_ptr)({}->env, {});", matches_var, fn_cast, fn_var, fn_var, arg_pass));
+                self.writeln(&format!("if ({}) {{", matches_var));
+                self.indent += 1;
+                self.writeln(&format!("{} = lux_option_some((void*)(intptr_t){});", result_var, i_var));
+                self.writeln("break;");
+                self.indent -= 1;
+                self.writeln("}");
+                self.indent -= 1;
+                self.writeln("}");
+                if closure.starts_with("_closure_") || closure.starts_with("_fn_ref_") {
+                    self.writeln(&format!("lux_decref_closure({});", closure));
+                }
+                Ok(result_var)
+            }
+
+            "zip" => {
+                if args.len() != 2 {
+                    return Err(CGenError { message: "List.zip takes 2 arguments".to_string(), span: None });
+                }
+                let list1 = self.emit_expr(&args[0])?;
+                let list2 = self.emit_expr(&args[1])?;
+                let id = self.fresh_name();
+                let result_var = format!("_zip_{}", id);
+                let len_var = format!("_ziplen_{}", id);
+                let i_var = format!("_i_{}", id);
+
+                self.writeln(&format!("int64_t {} = {}->length < {}->length ? {}->length : {}->length;", len_var, list1, list2, list1, list2));
+                self.writeln(&format!("LuxList* {} = lux_list_new({});", result_var, len_var));
+                self.writeln(&format!("for (int64_t {} = 0; {} < {}; {}++) {{", i_var, i_var, len_var, i_var));
+                self.indent += 1;
+                self.writeln(&format!("LuxTuple* _tup = (LuxTuple*)lux_rc_alloc(sizeof(LuxTuple) + 2 * sizeof(void*), LUX_TAG_TUPLE);"));
+                self.writeln("_tup->length = 2;");
+                self.writeln(&format!("_tup->elements[0] = {}->elements[{}];", list1, i_var));
+                self.writeln(&format!("_tup->elements[1] = {}->elements[{}];", list2, i_var));
+                self.writeln(&format!("lux_incref({}->elements[{}]);", list1, i_var));
+                self.writeln(&format!("lux_incref({}->elements[{}]);", list2, i_var));
+                self.writeln(&format!("lux_list_push({}, (void*)_tup);", result_var));
+                self.indent -= 1;
+                self.writeln("}");
+                self.register_rc_var(&result_var, "LuxList*");
+                Ok(result_var)
+            }
+
+            "flatten" => {
+                if args.len() != 1 {
+                    return Err(CGenError { message: "List.flatten takes 1 argument".to_string(), span: None });
+                }
+                let list = self.emit_expr(&args[0])?;
+                let id = self.fresh_name();
+                let result_var = format!("_flat_{}", id);
+                let i_var = format!("_i_{}", id);
+                let j_var = format!("_j_{}", id);
+                let inner_var = format!("_inner_{}", id);
+
+                self.writeln(&format!("LuxList* {} = lux_list_new(16);", result_var));
+                self.writeln(&format!("for (int64_t {} = 0; {} < {}->length; {}++) {{", i_var, i_var, list, i_var));
+                self.indent += 1;
+                self.writeln(&format!("LuxList* {} = (LuxList*){}->elements[{}];", inner_var, list, i_var));
+                self.writeln(&format!("for (int64_t {} = 0; {} < {}->length; {}++) {{", j_var, j_var, inner_var, j_var));
+                self.indent += 1;
+                self.writeln(&format!("lux_incref({}->elements[{}]);", inner_var, j_var));
+                self.writeln(&format!("lux_list_push({}, {}->elements[{}]);", result_var, inner_var, j_var));
+                self.indent -= 1;
+                self.writeln("}");
+                self.indent -= 1;
+                self.writeln("}");
+                self.register_rc_var(&result_var, "LuxList*");
+                Ok(result_var)
+            }
+
             _ => Err(CGenError {
                 message: format!("Unsupported List operation: {}", op),
                 span: None,
@@ -4841,8 +5270,8 @@ impl CBackend {
                 if c_type == "void*" {
                     // Cast from void* to actual type
                     if Self::is_primitive_c_type(&actual_type) {
-                        // For primitive types stored as void*, cast via intptr_t
-                        self.writeln(&format!("{} {} = ({})(intptr_t)({});", actual_type, var_name, actual_type, c_expr));
+                        // For primitive types stored as boxed void*, dereference
+                        self.writeln(&format!("{} {} = *({}*)({});", actual_type, var_name, actual_type, c_expr));
                     } else if !actual_type.ends_with('*') && actual_type != "void" {
                         // Struct types: cast to pointer and dereference
                         self.writeln(&format!("{} {} = *({}*)({});", actual_type, var_name, actual_type, c_expr));
@@ -5047,8 +5476,8 @@ impl CBackend {
                             },
                             "List" => match field.name.as_str() {
                                 "map" | "filter" | "concat" | "reverse" | "take" | "drop"
-                                | "range" | "sort" | "sortBy" | "flatten" | "intersperse" => return Some("LuxList*".to_string()),
-                                "head" | "tail" | "get" | "find" | "last" => return Some("Option".to_string()),
+                                | "range" | "sort" | "sortBy" | "flatten" | "intersperse" | "zip" => return Some("LuxList*".to_string()),
+                                "head" | "tail" | "get" | "find" | "findIndex" | "last" => return Some("Option".to_string()),
                                 "length" => return Some("LuxInt".to_string()),
                                 "fold" | "foldLeft" => {
                                     // Fold return type is the type of the init value (2nd arg)
@@ -5142,9 +5571,9 @@ impl CBackend {
                 if effect.name == "List" {
                     match operation.name.as_str() {
                         // Operations returning lists
-                        "map" | "filter" | "concat" | "reverse" | "take" | "drop" | "range" => Some("LuxList*".to_string()),
+                        "map" | "filter" | "concat" | "reverse" | "take" | "drop" | "range" | "sort" | "sortBy" | "zip" | "flatten" => Some("LuxList*".to_string()),
                         // Operations returning Option
-                        "head" | "tail" | "get" | "find" => Some("Option".to_string()),
+                        "head" | "tail" | "get" | "find" | "findIndex" => Some("Option".to_string()),
                         // Operations returning Int
                         "length" => Some("LuxInt".to_string()),
                         // Fold returns the type of the init value
@@ -5156,7 +5585,7 @@ impl CBackend {
                             }
                         }
                         // Operations returning Bool
-                        "isEmpty" | "any" | "all" => Some("LuxBool".to_string()),
+                        "isEmpty" | "any" | "all" | "contains" => Some("LuxBool".to_string()),
                         _ => None,
                     }
                 } else if effect.name == "Random" {
@@ -5175,9 +5604,10 @@ impl CBackend {
                 } else if effect.name == "File" {
                     match operation.name.as_str() {
                         "read" => Some("LuxString".to_string()),
-                        "write" | "append" | "delete" | "mkdir" => Some("void".to_string()),
+                        "write" | "append" | "delete" | "mkdir" | "copy" => Some("void".to_string()),
                         "exists" | "isDir" => Some("LuxBool".to_string()),
-                        "readDir" | "listDir" => Some("LuxList*".to_string()),
+                        "readDir" | "listDir" | "glob" => Some("LuxList*".to_string()),
+                        "tryRead" | "tryWrite" | "tryDelete" => Some("Result".to_string()),
                         _ => None,
                     }
                 } else if effect.name == "Http" {
@@ -5383,7 +5813,13 @@ impl CBackend {
                     None
                 }
             }
-            Expr::Var(_) => None,
+            Expr::Var(ident) => {
+                let escaped = self.escape_c_keyword(&ident.name);
+                // Check renamed variables first, then original name
+                let lookup_name = self.var_renames.get(&ident.name).unwrap_or(&escaped);
+                self.var_option_inner_types.get(lookup_name).cloned()
+                    .or_else(|| self.var_option_inner_types.get(&escaped).cloned())
+            }
             _ => None,
         }
     }
@@ -5561,9 +5997,25 @@ impl CBackend {
         }
     }
 
-    fn emit_global_let(&mut self, name: &Ident) -> Result<(), CGenError> {
-        // Declare global variable without initializer (initialized in main)
-        self.writeln(&format!("static LuxInt {} = 0;", name.name));
+    fn emit_global_let(&mut self, let_decl: &crate::ast::LetDecl) -> Result<(), CGenError> {
+        // Infer type from the value expression (or type annotation)
+        let typ = if let Some(ref type_expr) = let_decl.typ {
+            self.type_expr_to_c(type_expr).unwrap_or_else(|_| "LuxInt".to_string())
+        } else {
+            self.infer_expr_type(&let_decl.value).unwrap_or_else(|| "LuxInt".to_string())
+        };
+        let default = match typ.as_str() {
+            "LuxString" => "NULL",
+            "LuxBool" => "false",
+            "LuxFloat" => "0.0",
+            "LuxList*" | "LuxClosure*" => "NULL",
+            "Option" => "{0}",
+            "Result" => "{0}",
+            _ if typ.ends_with('*') => "NULL",
+            _ => "0",
+        };
+        self.writeln(&format!("static {} {} = {};", typ, let_decl.name.name, default));
+        self.var_types.insert(let_decl.name.name.clone(), typ);
         self.writeln("");
         Ok(())
     }
@@ -5666,6 +6118,20 @@ impl CBackend {
         self.type_expr_to_c(type_expr)
     }
 
+    /// Extract the inner C type from an Option<T> type expression
+    fn option_inner_type_from_type_expr(&self, type_expr: &TypeExpr) -> Option<String> {
+        if let TypeExpr::App(base, args) = type_expr {
+            if let TypeExpr::Named(name) = base.as_ref() {
+                if name.name == "Option" {
+                    if let Some(inner) = args.first() {
+                        return self.type_expr_to_c(inner).ok();
+                    }
+                }
+            }
+        }
+        None
+    }
+
     fn type_expr_to_c(&self, type_expr: &TypeExpr) -> Result<String, CGenError> {
         match type_expr {
             TypeExpr::Named(ident) => {
@@ -6018,7 +6484,8 @@ impl CBackend {
                             // These List operations return new lists
                             return matches!(field.name.as_str(),
                                 "map" | "filter" | "concat" | "reverse" |
-                                "take" | "drop" | "range"
+                                "take" | "drop" | "range" | "zip" | "flatten" |
+                                "sort" | "sortBy"
                             );
                         }
                         if module.name == "String" {
@@ -6044,7 +6511,8 @@ impl CBackend {
                 if effect.name == "List" {
                     matches!(operation.name.as_str(),
                         "map" | "filter" | "concat" | "reverse" |
-                        "take" | "drop" | "range"
+                        "take" | "drop" | "range" | "zip" | "flatten" |
+                        "sort" | "sortBy"
                     )
                 } else if effect.name == "Process" {
                     // Process.exec returns RC-managed string

src/codegen/js_backend.rs

@@ -1812,6 +1812,18 @@ impl JsBackend {
                     end, start, start
                 ))
             }
+            "sort" => {
+                let list = self.emit_expr(&args[0])?;
+                Ok(format!(
+                    "[...{}].sort((a, b) => a < b ? -1 : a > b ? 1 : 0)",
+                    list
+                ))
+            }
+            "sortBy" => {
+                let list = self.emit_expr(&args[0])?;
+                let func = self.emit_expr(&args[1])?;
+                Ok(format!("[...{}].sort({})", list, func))
+            }
             _ => Err(JsGenError {
                 message: format!("Unknown List operation: {}", operation),
                 span: None,

src/exhaustiveness.rs

@@ -333,11 +333,13 @@ mod tests {
     fn test_option_exhaustive() {
         let patterns = vec![
             Pattern::Constructor {
+                module: None,
                 name: make_ident("None"),
                 fields: vec![],
                 span: span(),
             },
             Pattern::Constructor {
+                module: None,
                 name: make_ident("Some"),
                 fields: vec![Pattern::Wildcard(span())],
                 span: span(),
@@ -352,6 +354,7 @@ mod tests {
     #[test]
     fn test_option_missing_none() {
         let patterns = vec![Pattern::Constructor {
+            module: None,
             name: make_ident("Some"),
             fields: vec![Pattern::Wildcard(span())],
             span: span(),
@@ -391,11 +394,13 @@ mod tests {
     fn test_result_exhaustive() {
         let patterns = vec![
             Pattern::Constructor {
+                module: None,
                 name: make_ident("Ok"),
                 fields: vec![Pattern::Wildcard(span())],
                 span: span(),
             },
             Pattern::Constructor {
+                module: None,
                 name: make_ident("Err"),
                 fields: vec![Pattern::Wildcard(span())],
                 span: span(),

src/formatter.rs

@@ -733,7 +733,30 @@ impl Formatter {
         match &lit.kind {
             LiteralKind::Int(n) => n.to_string(),
             LiteralKind::Float(f) => format!("{}", f),
-            LiteralKind::String(s) => format!("\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\"").replace('{', "\\{").replace('}', "\\}")),
+            LiteralKind::String(s) => {
+                if s.contains('\n') {
+                    // Use triple-quoted multiline string
+                    let tab = " ".repeat(self.config.indent_size);
+                    let base_indent = tab.repeat(self.indent_level);
+                    let content_indent = tab.repeat(self.indent_level + 1);
+                    let lines: Vec<&str> = s.split('\n').collect();
+                    let mut result = String::from("\"\"\"\n");
+                    for line in &lines {
+                        if line.is_empty() {
+                            result.push('\n');
+                        } else {
+                            result.push_str(&content_indent);
+                            result.push_str(&line.replace('{', "\\{").replace('}', "\\}"));
+                            result.push('\n');
+                        }
+                    }
+                    result.push_str(&base_indent);
+                    result.push_str("\"\"\"");
+                    result
+                } else {
+                    format!("\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\"").replace('{', "\\{").replace('}', "\\}"))
+                }
+            },
             LiteralKind::Char(c) => format!("'{}'", c),
             LiteralKind::Bool(b) => b.to_string(),
             LiteralKind::Unit => "()".to_string(),
@@ -772,12 +795,22 @@ impl Formatter {
             Pattern::Wildcard(_) => "_".to_string(),
             Pattern::Var(ident) => ident.name.clone(),
             Pattern::Literal(lit) => self.format_literal(lit),
-            Pattern::Constructor { name, fields, .. } => {
+            Pattern::Constructor {
+                module,
+                name,
+                fields,
+                ..
+            } => {
+                let prefix = match module {
+                    Some(m) => format!("{}.", m.name),
+                    None => String::new(),
+                };
                 if fields.is_empty() {
-                    name.name.clone()
+                    format!("{}{}", prefix, name.name)
                 } else {
                     format!(
-                        "{}({})",
+                        "{}{}({})",
+                        prefix,
                         name.name,
                         fields
                             .iter()

src/interpreter.rs

@@ -28,6 +28,8 @@ pub enum BuiltinFn {
     ListGet,
     ListRange,
     ListForEach,
+    ListSort,
+    ListSortBy,
 
     // String operations
     StringSplit,
@@ -81,10 +83,14 @@ pub enum BuiltinFn {
     // Additional List operations
     ListIsEmpty,
     ListFind,
+    ListFindIndex,
     ListAny,
     ListAll,
     ListTake,
     ListDrop,
+    ListZip,
+    ListFlatten,
+    ListContains,
 
     // Additional String operations
     StringStartsWith,
@@ -972,14 +978,23 @@ impl Interpreter {
                 Value::Builtin(BuiltinFn::ListIsEmpty),
             ),
             ("find".to_string(), Value::Builtin(BuiltinFn::ListFind)),
+            ("findIndex".to_string(), Value::Builtin(BuiltinFn::ListFindIndex)),
             ("any".to_string(), Value::Builtin(BuiltinFn::ListAny)),
             ("all".to_string(), Value::Builtin(BuiltinFn::ListAll)),
             ("take".to_string(), Value::Builtin(BuiltinFn::ListTake)),
             ("drop".to_string(), Value::Builtin(BuiltinFn::ListDrop)),
+            ("zip".to_string(), Value::Builtin(BuiltinFn::ListZip)),
+            ("flatten".to_string(), Value::Builtin(BuiltinFn::ListFlatten)),
+            ("contains".to_string(), Value::Builtin(BuiltinFn::ListContains)),
             (
                 "forEach".to_string(),
                 Value::Builtin(BuiltinFn::ListForEach),
             ),
+            ("sort".to_string(), Value::Builtin(BuiltinFn::ListSort)),
+            (
+                "sortBy".to_string(),
+                Value::Builtin(BuiltinFn::ListSortBy),
+            ),
         ]));
         env.define("List", list_module);
 
@@ -2716,6 +2731,55 @@ impl Interpreter {
                 Ok(EvalResult::Value(Value::Bool(true)))
             }
 
+            BuiltinFn::ListFindIndex => {
+                let (list, func) = Self::expect_args_2::<Vec<Value>, Value>(&args, "List.findIndex", span)?;
+                for (i, item) in list.iter().enumerate() {
+                    let v = self.eval_call_to_value(func.clone(), vec![item.clone()], span)?;
+                    match v {
+                        Value::Bool(true) => {
+                            return Ok(EvalResult::Value(Value::Constructor {
+                                name: "Some".to_string(),
+                                fields: vec![Value::Int(i as i64)],
+                            }));
+                        }
+                        Value::Bool(false) => {}
+                        _ => return Err(err("List.findIndex predicate must return Bool")),
+                    }
+                }
+                Ok(EvalResult::Value(Value::Constructor {
+                    name: "None".to_string(),
+                    fields: vec![],
+                }))
+            }
+
+            BuiltinFn::ListZip => {
+                let (list1, list2) = Self::expect_args_2::<Vec<Value>, Vec<Value>>(&args, "List.zip", span)?;
+                let result: Vec<Value> = list1
+                    .into_iter()
+                    .zip(list2.into_iter())
+                    .map(|(a, b)| Value::Tuple(vec![a, b]))
+                    .collect();
+                Ok(EvalResult::Value(Value::List(result)))
+            }
+
+            BuiltinFn::ListFlatten => {
+                let list = Self::expect_arg_1::<Vec<Value>>(&args, "List.flatten", span)?;
+                let mut result = Vec::new();
+                for item in list {
+                    match item {
+                        Value::List(inner) => result.extend(inner),
+                        other => result.push(other),
+                    }
+                }
+                Ok(EvalResult::Value(Value::List(result)))
+            }
+
+            BuiltinFn::ListContains => {
+                let (list, target) = Self::expect_args_2::<Vec<Value>, Value>(&args, "List.contains", span)?;
+                let found = list.iter().any(|item| Value::values_equal(item, &target));
+                Ok(EvalResult::Value(Value::Bool(found)))
+            }
+
             BuiltinFn::ListTake => {
                 let (list, n) = Self::expect_args_2::<Vec<Value>, i64>(&args, "List.take", span)?;
                 let n = n.max(0) as usize;
@@ -2742,6 +2806,67 @@ impl Interpreter {
                 Ok(EvalResult::Value(Value::Unit))
             }
 
+            BuiltinFn::ListSort => {
+                // List.sort(list) - sort using natural ordering (Int, Float, String, Bool)
+                let mut list =
+                    Self::expect_arg_1::<Vec<Value>>(&args, "List.sort", span)?;
+                list.sort_by(|a, b| Self::compare_values(a, b));
+                Ok(EvalResult::Value(Value::List(list)))
+            }
+
+            BuiltinFn::ListSortBy => {
+                // List.sortBy(list, fn(a, b) => Int) - sort with custom comparator
+                // Comparator returns negative (a < b), 0 (a == b), or positive (a > b)
+                let (list, func) =
+                    Self::expect_args_2::<Vec<Value>, Value>(&args, "List.sortBy", span)?;
+                let mut indexed: Vec<(usize, Value)> =
+                    list.into_iter().enumerate().collect();
+                let mut err: Option<RuntimeError> = None;
+                let func_ref = &func;
+                let self_ptr = self as *mut Self;
+                indexed.sort_by(|a, b| {
+                    if err.is_some() {
+                        return std::cmp::Ordering::Equal;
+                    }
+                    // Safety: we're in a single-threaded context and the closure
+                    // needs mutable access to call eval_call_to_value
+                    let interp = unsafe { &mut *self_ptr };
+                    match interp.eval_call_to_value(
+                        func_ref.clone(),
+                        vec![a.1.clone(), b.1.clone()],
+                        span,
+                    ) {
+                        Ok(Value::Int(n)) => {
+                            if n < 0 {
+                                std::cmp::Ordering::Less
+                            } else if n > 0 {
+                                std::cmp::Ordering::Greater
+                            } else {
+                                std::cmp::Ordering::Equal
+                            }
+                        }
+                        Ok(_) => {
+                            err = Some(RuntimeError {
+                                message: "List.sortBy comparator must return Int"
+                                    .to_string(),
+                                span: Some(span),
+                            });
+                            std::cmp::Ordering::Equal
+                        }
+                        Err(e) => {
+                            err = Some(e);
+                            std::cmp::Ordering::Equal
+                        }
+                    }
+                });
+                if let Some(e) = err {
+                    return Err(e);
+                }
+                let result: Vec<Value> =
+                    indexed.into_iter().map(|(_, v)| v).collect();
+                Ok(EvalResult::Value(Value::List(result)))
+            }
+
             // Additional String operations
             BuiltinFn::StringStartsWith => {
                 let (s, prefix) = Self::expect_args_2::<String, String>(&args, "String.startsWith", span)?;
@@ -3357,6 +3482,18 @@ impl Interpreter {
         })
     }
 
+    /// Compare two values for natural ordering (used by List.sort)
+    fn compare_values(a: &Value, b: &Value) -> std::cmp::Ordering {
+        match (a, b) {
+            (Value::Int(x), Value::Int(y)) => x.cmp(y),
+            (Value::Float(x), Value::Float(y)) => x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal),
+            (Value::String(x), Value::String(y)) => x.cmp(y),
+            (Value::Bool(x), Value::Bool(y)) => x.cmp(y),
+            (Value::Char(x), Value::Char(y)) => x.cmp(y),
+            _ => std::cmp::Ordering::Equal,
+        }
+    }
+
     fn match_pattern(&self, pattern: &Pattern, value: &Value) -> Option<Vec<(String, Value)>> {
         match pattern {
             Pattern::Wildcard(_) => Some(Vec::new()),
@@ -3864,6 +4001,119 @@ impl Interpreter {
                 }
             }
 
+            ("File", "copy") => {
+                let source = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.copy requires a string source path".to_string(),
+                        span: None,
+                    }),
+                };
+                let dest = match request.args.get(1) {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.copy requires a string destination path".to_string(),
+                        span: None,
+                    }),
+                };
+                match std::fs::copy(&source, &dest) {
+                    Ok(_) => Ok(Value::Unit),
+                    Err(e) => Err(RuntimeError {
+                        message: format!("Failed to copy '{}' to '{}': {}", source, dest, e),
+                        span: None,
+                    }),
+                }
+            }
+
+            ("File", "glob") => {
+                let pattern = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.glob requires a string pattern".to_string(),
+                        span: None,
+                    }),
+                };
+                match glob::glob(&pattern) {
+                    Ok(paths) => {
+                        let entries: Vec<Value> = paths
+                            .filter_map(|entry| entry.ok())
+                            .map(|path| Value::String(path.to_string_lossy().to_string()))
+                            .collect();
+                        Ok(Value::List(entries))
+                    }
+                    Err(e) => Err(RuntimeError {
+                        message: format!("Invalid glob pattern '{}': {}", pattern, e),
+                        span: None,
+                    }),
+                }
+            }
+
+            // ===== File Effect (safe Result-returning variants) =====
+            ("File", "tryRead") => {
+                let path = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.tryRead requires a string path".to_string(),
+                        span: None,
+                    }),
+                };
+                match std::fs::read_to_string(&path) {
+                    Ok(content) => Ok(Value::Constructor {
+                        name: "Ok".to_string(),
+                        fields: vec![Value::String(content)],
+                    }),
+                    Err(e) => Ok(Value::Constructor {
+                        name: "Err".to_string(),
+                        fields: vec![Value::String(format!("Failed to read file '{}': {}", path, e))],
+                    }),
+                }
+            }
+            ("File", "tryWrite") => {
+                let path = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.tryWrite requires a string path".to_string(),
+                        span: None,
+                    }),
+                };
+                let content = match request.args.get(1) {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.tryWrite requires string content".to_string(),
+                        span: None,
+                    }),
+                };
+                match std::fs::write(&path, &content) {
+                    Ok(()) => Ok(Value::Constructor {
+                        name: "Ok".to_string(),
+                        fields: vec![Value::Unit],
+                    }),
+                    Err(e) => Ok(Value::Constructor {
+                        name: "Err".to_string(),
+                        fields: vec![Value::String(format!("Failed to write file '{}': {}", path, e))],
+                    }),
+                }
+            }
+            ("File", "tryDelete") => {
+                let path = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.tryDelete requires a string path".to_string(),
+                        span: None,
+                    }),
+                };
+                match std::fs::remove_file(&path) {
+                    Ok(()) => Ok(Value::Constructor {
+                        name: "Ok".to_string(),
+                        fields: vec![Value::Unit],
+                    }),
+                    Err(e) => Ok(Value::Constructor {
+                        name: "Err".to_string(),
+                        fields: vec![Value::String(format!("Failed to delete file '{}': {}", path, e))],
+                    }),
+                }
+            }
+
             // ===== Process Effect =====
             ("Process", "exec") => {
                 use std::process::Command;

src/lexer.rs

@@ -411,7 +411,26 @@ impl<'a> Lexer<'a> {
             }
 
             // String literals
-            '"' => self.scan_string(start)?,
+            '"' => {
+                // Check for triple-quote multiline string """
+                if self.peek() == Some('"') {
+                    // Clone to peek at the second char
+                    let mut lookahead = self.chars.clone();
+                    lookahead.next(); // consume first peeked "
+                    if lookahead.peek() == Some(&'"') {
+                        // It's a triple-quote: consume both remaining quotes
+                        self.advance(); // second "
+                        self.advance(); // third "
+                        self.scan_multiline_string(start)?
+                    } else {
+                        // It's an empty string ""
+                        self.advance(); // consume closing "
+                        TokenKind::String(String::new())
+                    }
+                } else {
+                    self.scan_string(start)?
+                }
+            }
 
             // Char literals
             '\'' => self.scan_char(start)?,
@@ -669,6 +688,211 @@ impl<'a> Lexer<'a> {
         Ok(TokenKind::InterpolatedString(parts))
     }
 
+    fn scan_multiline_string(&mut self, _start: usize) -> Result<TokenKind, LexError> {
+        let mut parts: Vec<StringPart> = Vec::new();
+        let mut current_literal = String::new();
+
+        // Skip the first newline after opening """ if present
+        if self.peek() == Some('\n') {
+            self.advance();
+        } else if self.peek() == Some('\r') {
+            self.advance();
+            if self.peek() == Some('\n') {
+                self.advance();
+            }
+        }
+
+        loop {
+            match self.advance() {
+                Some('"') => {
+                    // Check for closing """
+                    if self.peek() == Some('"') {
+                        let mut lookahead = self.chars.clone();
+                        lookahead.next(); // consume first peeked "
+                        if lookahead.peek() == Some(&'"') {
+                            // Closing """ found
+                            self.advance(); // second "
+                            self.advance(); // third "
+                            break;
+                        }
+                    }
+                    // Not closing triple-quote, just a regular " in the string
+                    current_literal.push('"');
+                }
+                Some('\\') => {
+                    // Handle escape sequences (same as regular strings)
+                    match self.peek() {
+                        Some('{') => {
+                            self.advance();
+                            current_literal.push('{');
+                        }
+                        Some('}') => {
+                            self.advance();
+                            current_literal.push('}');
+                        }
+                        _ => {
+                            let escape_start = self.pos;
+                            let escaped = match self.advance() {
+                                Some('n') => '\n',
+                                Some('r') => '\r',
+                                Some('t') => '\t',
+                                Some('\\') => '\\',
+                                Some('"') => '"',
+                                Some('0') => '\0',
+                                Some('\'') => '\'',
+                                Some(c) => {
+                                    return Err(LexError {
+                                        message: format!("Invalid escape sequence: \\{}", c),
+                                        span: Span::new(escape_start - 1, self.pos),
+                                    });
+                                }
+                                None => {
+                                    return Err(LexError {
+                                        message: "Unterminated multiline string".into(),
+                                        span: Span::new(_start, self.pos),
+                                    });
+                                }
+                            };
+                            current_literal.push(escaped);
+                        }
+                    }
+                }
+                Some('{') => {
+                    // Interpolation (same as regular strings)
+                    if !current_literal.is_empty() {
+                        parts.push(StringPart::Literal(std::mem::take(&mut current_literal)));
+                    }
+
+                    let mut expr_text = String::new();
+                    let mut brace_depth = 1;
+
+                    loop {
+                        match self.advance() {
+                            Some('{') => {
+                                brace_depth += 1;
+                                expr_text.push('{');
+                            }
+                            Some('}') => {
+                                brace_depth -= 1;
+                                if brace_depth == 0 {
+                                    break;
+                                }
+                                expr_text.push('}');
+                            }
+                            Some(c) => expr_text.push(c),
+                            None => {
+                                return Err(LexError {
+                                    message: "Unterminated interpolation in multiline string"
+                                        .into(),
+                                    span: Span::new(_start, self.pos),
+                                });
+                            }
+                        }
+                    }
+
+                    parts.push(StringPart::Expr(expr_text));
+                }
+                Some(c) => current_literal.push(c),
+                None => {
+                    return Err(LexError {
+                        message: "Unterminated multiline string".into(),
+                        span: Span::new(_start, self.pos),
+                    });
+                }
+            }
+        }
+
+        // Strip common leading whitespace from all lines
+        let strip_indent = |s: &str| -> String {
+            if s.is_empty() {
+                return String::new();
+            }
+            let lines: Vec<&str> = s.split('\n').collect();
+            // Find minimum indentation of non-empty lines
+            let min_indent = lines
+                .iter()
+                .filter(|line| !line.trim().is_empty())
+                .map(|line| line.len() - line.trim_start().len())
+                .min()
+                .unwrap_or(0);
+            // Strip that indentation from each line
+            lines
+                .iter()
+                .map(|line| {
+                    if line.len() >= min_indent {
+                        &line[min_indent..]
+                    } else {
+                        line.trim_start()
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join("\n")
+        };
+
+        // Strip trailing whitespace-only line before closing """
+        let trim_trailing = |s: &mut String| {
+            // Remove trailing spaces/tabs (indent before closing """)
+            while s.ends_with(' ') || s.ends_with('\t') {
+                s.pop();
+            }
+            // Remove the trailing newline
+            if s.ends_with('\n') {
+                s.pop();
+                if s.ends_with('\r') {
+                    s.pop();
+                }
+            }
+        };
+
+        if parts.is_empty() {
+            trim_trailing(&mut current_literal);
+            let result = strip_indent(&current_literal);
+            return Ok(TokenKind::String(result));
+        }
+
+        // Add remaining literal
+        if !current_literal.is_empty() {
+            trim_trailing(&mut current_literal);
+            parts.push(StringPart::Literal(current_literal));
+        }
+
+        // For interpolated multiline strings, strip indent from literal parts
+        // First, collect all literal content to find min indent
+        let mut all_text = String::new();
+        for part in &parts {
+            if let StringPart::Literal(lit) = part {
+                all_text.push_str(lit);
+            }
+        }
+        let lines: Vec<&str> = all_text.split('\n').collect();
+        let min_indent = lines
+            .iter()
+            .filter(|line| !line.trim().is_empty())
+            .map(|line| line.len() - line.trim_start().len())
+            .min()
+            .unwrap_or(0);
+
+        if min_indent > 0 {
+            for part in &mut parts {
+                if let StringPart::Literal(lit) = part {
+                    let stripped_lines: Vec<&str> = lit
+                        .split('\n')
+                        .map(|line| {
+                            if line.len() >= min_indent {
+                                &line[min_indent..]
+                            } else {
+                                line.trim_start()
+                            }
+                        })
+                        .collect();
+                    *lit = stripped_lines.join("\n");
+                }
+            }
+        }
+
+        Ok(TokenKind::InterpolatedString(parts))
+    }
+
     fn scan_char(&mut self, start: usize) -> Result<TokenKind, LexError> {
         let c = match self.advance() {
             Some('\\') => match self.advance() {

src/main.rs

@@ -3925,6 +3925,49 @@ c")"#;
         assert_eq!(eval(source).unwrap(), r#""literal {braces}""#);
     }
 
+    #[test]
+    fn test_multiline_string() {
+        let source = r#"
+            let s = """
+                hello
+                world
+            """
+            let result = String.length(s)
+        "#;
+        // "hello\nworld" = 11 chars
+        assert_eq!(eval(source).unwrap(), "11");
+    }
+
+    #[test]
+    fn test_multiline_string_with_quotes() {
+        // Quotes are fine in the middle of triple-quoted strings
+        let source = "let s = \"\"\"\n    She said \"hello\" to him.\n\"\"\"";
+        assert_eq!(eval(source).unwrap(), r#""She said "hello" to him.""#);
+    }
+
+    #[test]
+    fn test_multiline_string_interpolation() {
+        let source = r#"
+            let name = "Lux"
+            let s = """
+                Hello, {name}!
+            """
+        "#;
+        assert_eq!(eval(source).unwrap(), r#""Hello, Lux!""#);
+    }
+
+    #[test]
+    fn test_multiline_string_empty() {
+        let source = r#"let s = """""""#;
+        assert_eq!(eval(source).unwrap(), r#""""#);
+    }
+
+    #[test]
+    fn test_multiline_string_inline() {
+        let source = r#"let s = """hello world""""#;
+        assert_eq!(eval(source).unwrap(), r#""hello world""#);
+    }
+
     // Option tests
     #[test]
     fn test_option_constructors() {
@@ -5629,4 +5672,55 @@ c")"#;
         "#;
         assert_eq!(eval(source).unwrap(), "Some(30)");
     }
+
+    #[test]
+    fn test_file_copy() {
+        use std::io::Write;
+        // Create a temp file, copy it, verify contents
+        let dir = std::env::temp_dir().join("lux_test_file_copy");
+        let _ = std::fs::create_dir_all(&dir);
+        let src = dir.join("src.txt");
+        let dst = dir.join("dst.txt");
+        std::fs::File::create(&src).unwrap().write_all(b"hello copy").unwrap();
+        let _ = std::fs::remove_file(&dst);
+
+        let source = format!(r#"
+            fn main(): Unit with {{File}} =
+                File.copy("{}", "{}")
+            let _ = run main() with {{}}
+            let result = "done"
+        "#, src.display(), dst.display());
+        let result = eval(&source);
+        assert!(result.is_ok(), "File.copy failed: {:?}", result);
+        let contents = std::fs::read_to_string(&dst).unwrap();
+        assert_eq!(contents, "hello copy");
+
+        // Cleanup
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn test_effectful_callback_propagation() {
+        // WISH-7: effectful callbacks in List.forEach should propagate effects
+        // This should type-check successfully because Console effect is inferred
+        let source = r#"
+            fn printAll(items: List<String>): Unit =
+                List.forEach(items, fn(x: String): Unit => Console.print(x))
+            let result = "ok"
+        "#;
+        let result = eval(source);
+        assert!(result.is_ok(), "Effectful callback should type-check: {:?}", result);
+    }
+
+    #[test]
+    fn test_effectful_callback_in_map() {
+        // Effectful callback in List.map should propagate effects
+        let source = r#"
+            fn readAll(paths: List<String>): List<String> =
+                List.map(paths, fn(p: String): String => File.read(p))
+            let result = "ok"
+        "#;
+        let result = eval(source);
+        assert!(result.is_ok(), "Effectful callback in map should type-check: {:?}", result);
+    }
 }

src/modules.rs

@@ -279,6 +279,12 @@ impl ModuleLoader {
                 }
                 Declaration::Type(t) if t.visibility == Visibility::Public => {
                     exports.insert(t.name.name.clone());
+                    // Also export constructors for ADT types
+                    if let crate::ast::TypeDef::Enum(variants) = &t.definition {
+                        for variant in variants {
+                            exports.insert(variant.name.name.clone());
+                        }
+                    }
                 }
                 Declaration::Effect(e) => {
                     // Effects are always exported

src/parser.rs

@@ -846,6 +846,7 @@ impl Parser {
     /// Parse function parameters
     fn parse_params(&mut self) -> Result<Vec<Parameter>, ParseError> {
         let mut params = Vec::new();
+        self.skip_newlines();
 
         while !self.check(TokenKind::RParen) {
             let start = self.current_span();
@@ -855,9 +856,11 @@ impl Parser {
             let span = start.merge(self.previous_span());
 
             params.push(Parameter { name, typ, span });
+            self.skip_newlines();
 
             if !self.check(TokenKind::RParen) {
                 self.expect(TokenKind::Comma)?;
+                self.skip_newlines();
             }
         }
 
@@ -1919,9 +1922,27 @@ impl Parser {
             TokenKind::Ident(name) => {
                 // Check if it starts with uppercase (constructor) or lowercase (variable)
                 if name.chars().next().map_or(false, |c| c.is_uppercase()) {
-                    self.parse_constructor_pattern()
+                    self.parse_constructor_pattern_with_module(None)
                 } else {
                     let ident = self.parse_ident()?;
+                    // Check for module-qualified constructor: module.Constructor
+                    if self.check(TokenKind::Dot) {
+                        // Peek ahead to see if next is an uppercase identifier
+                        let dot_pos = self.pos;
+                        self.advance(); // skip dot
+                        if let TokenKind::Ident(next_name) = self.peek_kind() {
+                            if next_name
+                                .chars()
+                                .next()
+                                .map_or(false, |c| c.is_uppercase())
+                            {
+                                return self
+                                    .parse_constructor_pattern_with_module(Some(ident));
+                            }
+                        }
+                        // Not a module-qualified constructor, backtrack
+                        self.pos = dot_pos;
+                    }
                     Ok(Pattern::Var(ident))
                 }
             }
@@ -1931,25 +1952,40 @@ impl Parser {
         }
     }
 
-    fn parse_constructor_pattern(&mut self) -> Result<Pattern, ParseError> {
-        let start = self.current_span();
+    fn parse_constructor_pattern_with_module(
+        &mut self,
+        module: Option<Ident>,
+    ) -> Result<Pattern, ParseError> {
+        let start = module
+            .as_ref()
+            .map(|m| m.span)
+            .unwrap_or_else(|| self.current_span());
         let name = self.parse_ident()?;
 
         if self.check(TokenKind::LParen) {
             self.advance();
+            self.skip_newlines();
             let mut fields = Vec::new();
             while !self.check(TokenKind::RParen) {
                 fields.push(self.parse_pattern()?);
+                self.skip_newlines();
                 if !self.check(TokenKind::RParen) {
                     self.expect(TokenKind::Comma)?;
+                    self.skip_newlines();
                 }
             }
             self.expect(TokenKind::RParen)?;
             let span = start.merge(self.previous_span());
-            Ok(Pattern::Constructor { name, fields, span })
-        } else {
-            let span = name.span;
             Ok(Pattern::Constructor {
+                module,
+                name,
+                fields,
+                span,
+            })
+        } else {
+            let span = start.merge(name.span);
+            Ok(Pattern::Constructor {
+                module,
                 name,
                 fields: Vec::new(),
                 span,
@@ -1960,12 +1996,15 @@ impl Parser {
     fn parse_tuple_pattern(&mut self) -> Result<Pattern, ParseError> {
         let start = self.current_span();
         self.expect(TokenKind::LParen)?;
+        self.skip_newlines();
 
         let mut elements = Vec::new();
         while !self.check(TokenKind::RParen) {
             elements.push(self.parse_pattern()?);
+            self.skip_newlines();
             if !self.check(TokenKind::RParen) {
                 self.expect(TokenKind::Comma)?;
+                self.skip_newlines();
             }
         }
 
@@ -2095,6 +2134,7 @@ impl Parser {
 
     fn parse_lambda_params(&mut self) -> Result<Vec<Parameter>, ParseError> {
         let mut params = Vec::new();
+        self.skip_newlines();
 
         while !self.check(TokenKind::RParen) {
             let start = self.current_span();
@@ -2110,9 +2150,11 @@ impl Parser {
 
             let span = start.merge(self.previous_span());
             params.push(Parameter { name, typ, span });
+            self.skip_newlines();
 
             if !self.check(TokenKind::RParen) {
                 self.expect(TokenKind::Comma)?;
+                self.skip_newlines();
             }
         }
 
@@ -2200,6 +2242,7 @@ impl Parser {
     fn parse_tuple_or_paren_expr(&mut self) -> Result<Expr, ParseError> {
         let start = self.current_span();
         self.expect(TokenKind::LParen)?;
+        self.skip_newlines();
 
         if self.check(TokenKind::RParen) {
             self.advance();
@@ -2210,16 +2253,19 @@ impl Parser {
         }
 
         let first = self.parse_expr()?;
+        self.skip_newlines();
 
         if self.check(TokenKind::Comma) {
             // Tuple
             let mut elements = vec![first];
             while self.check(TokenKind::Comma) {
                 self.advance();
+                self.skip_newlines();
                 if self.check(TokenKind::RParen) {
                     break;
                 }
                 elements.push(self.parse_expr()?);
+                self.skip_newlines();
             }
             self.expect(TokenKind::RParen)?;
             let span = start.merge(self.previous_span());

src/typechecker.rs

@@ -981,6 +981,13 @@ impl TypeChecker {
                     if !fields.is_empty() {
                         self.env.bind(&name, TypeScheme::mono(Type::Record(fields)));
                     }
+
+                    // Also copy type definitions so imported types are usable
+                    for (type_name, type_def) in &module_checker.env.types {
+                        if !self.env.types.contains_key(type_name) {
+                            self.env.types.insert(type_name.clone(), type_def.clone());
+                        }
+                    }
                 }
                 ImportKind::Direct => {
                     // Import a specific name directly
@@ -1951,6 +1958,17 @@ impl TypeChecker {
         let func_type = self.infer_expr(func);
         let arg_types: Vec<Type> = args.iter().map(|a| self.infer_expr(a)).collect();
 
+        // Propagate effects from callback arguments to enclosing scope
+        for arg_type in &arg_types {
+            if let Type::Function { effects, .. } = arg_type {
+                for effect in &effects.effects {
+                    if self.inferring_effects {
+                        self.inferred_effects.insert(effect.clone());
+                    }
+                }
+            }
+        }
+
         // Check property constraints from where clauses
         if let Expr::Var(func_id) = func {
             if let Some(constraints) = self.property_constraints.get(&func_id.name).cloned() {
@@ -2061,6 +2079,18 @@ impl TypeChecker {
                 if let Some((_, field_type)) = fields.iter().find(|(n, _)| n == &operation.name) {
                     // It's a function call on a module field
                     let arg_types: Vec<Type> = args.iter().map(|a| self.infer_expr(a)).collect();
+
+                    // Propagate effects from callback arguments to enclosing scope
+                    for arg_type in &arg_types {
+                        if let Type::Function { effects, .. } = arg_type {
+                            for effect in &effects.effects {
+                                if self.inferring_effects {
+                                    self.inferred_effects.insert(effect.clone());
+                                }
+                            }
+                        }
+                    }
+
                     let result_type = Type::var();
                     let expected_fn = Type::function(arg_types, result_type.clone());
 
@@ -2120,6 +2150,17 @@ impl TypeChecker {
                 // Check argument types
                 let arg_types: Vec<Type> = args.iter().map(|a| self.infer_expr(a)).collect();
 
+                // Propagate effects from callback arguments to enclosing scope
+                for arg_type in &arg_types {
+                    if let Type::Function { effects, .. } = arg_type {
+                        for effect in &effects.effects {
+                            if self.inferring_effects {
+                                self.inferred_effects.insert(effect.clone());
+                            }
+                        }
+                    }
+                }
+
                 if arg_types.len() != op.params.len() {
                     self.errors.push(TypeError {
                         message: format!(
@@ -2442,7 +2483,7 @@ impl TypeChecker {
                 Vec::new()
             }
 
-            Pattern::Constructor { name, fields, span } => {
+            Pattern::Constructor { name, fields, span, .. } => {
                 // Look up constructor
                 // For now, handle Option specially
                 match name.name.as_str() {

src/types.rs

@@ -956,6 +956,46 @@ impl TypeEnv {
                         params: vec![("path".to_string(), Type::String)],
                         return_type: Type::Unit,
                     },
+                    EffectOpDef {
+                        name: "copy".to_string(),
+                        params: vec![
+                            ("source".to_string(), Type::String),
+                            ("dest".to_string(), Type::String),
+                        ],
+                        return_type: Type::Unit,
+                    },
+                    EffectOpDef {
+                        name: "glob".to_string(),
+                        params: vec![("pattern".to_string(), Type::String)],
+                        return_type: Type::List(Box::new(Type::String)),
+                    },
+                    EffectOpDef {
+                        name: "tryRead".to_string(),
+                        params: vec![("path".to_string(), Type::String)],
+                        return_type: Type::App {
+                            constructor: Box::new(Type::Named("Result".to_string())),
+                            args: vec![Type::String, Type::String],
+                        },
+                    },
+                    EffectOpDef {
+                        name: "tryWrite".to_string(),
+                        params: vec![
+                            ("path".to_string(), Type::String),
+                            ("content".to_string(), Type::String),
+                        ],
+                        return_type: Type::App {
+                            constructor: Box::new(Type::Named("Result".to_string())),
+                            args: vec![Type::Unit, Type::String],
+                        },
+                    },
+                    EffectOpDef {
+                        name: "tryDelete".to_string(),
+                        params: vec![("path".to_string(), Type::String)],
+                        return_type: Type::App {
+                            constructor: Box::new(Type::Named("Result".to_string())),
+                            args: vec![Type::Unit, Type::String],
+                        },
+                    },
                 ],
             },
         );
@@ -1499,6 +1539,16 @@ impl TypeEnv {
                     Type::Option(Box::new(Type::var())),
                 ),
             ),
+            (
+                "findIndex".to_string(),
+                Type::function(
+                    vec![
+                        Type::List(Box::new(Type::var())),
+                        Type::function(vec![Type::var()], Type::Bool),
+                    ],
+                    Type::Option(Box::new(Type::Int)),
+                ),
+            ),
             (
                 "any".to_string(),
                 Type::function(
@@ -1543,6 +1593,50 @@ impl TypeEnv {
                     Type::Unit,
                 ),
             ),
+            (
+                "sort".to_string(),
+                Type::function(
+                    vec![Type::List(Box::new(Type::var()))],
+                    Type::List(Box::new(Type::var())),
+                ),
+            ),
+            (
+                "sortBy".to_string(),
+                {
+                    let elem = Type::var();
+                    Type::function(
+                        vec![
+                            Type::List(Box::new(elem.clone())),
+                            Type::function(vec![elem.clone(), elem], Type::Int),
+                        ],
+                        Type::List(Box::new(Type::var())),
+                    )
+                },
+            ),
+            (
+                "zip".to_string(),
+                Type::function(
+                    vec![
+                        Type::List(Box::new(Type::var())),
+                        Type::List(Box::new(Type::var())),
+                    ],
+                    Type::List(Box::new(Type::Tuple(vec![Type::var(), Type::var()]))),
+                ),
+            ),
+            (
+                "flatten".to_string(),
+                Type::function(
+                    vec![Type::List(Box::new(Type::List(Box::new(Type::var()))))],
+                    Type::List(Box::new(Type::var())),
+                ),
+            ),
+            (
+                "contains".to_string(),
+                Type::function(
+                    vec![Type::List(Box::new(Type::var())), Type::var()],
+                    Type::Bool,
+                ),
+            ),
         ]);
         env.bind("List", TypeScheme::mono(list_module_type));
 

stdlib/html.lux

@@ -14,6 +14,7 @@
 pub type Html<M> =
     | Element(String, List<Attr<M>>, List<Html<M>>)
     | Text(String)
+    | RawHtml(String)
     | Empty
 
 // Attributes that can be applied to elements
@@ -41,6 +42,7 @@ pub type Attr<M> =
     | OnKeyDown(fn(String): M)
     | OnKeyUp(fn(String): M)
     | DataAttr(String, String)
+    | Attribute(String, String)
 
 // ============================================================================
 // Element builders - Container elements
@@ -180,6 +182,28 @@ pub fn video<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
 pub fn audio<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
     Element("audio", attrs, children)
 
+// ============================================================================
+// Element builders - Document / Head elements
+// ============================================================================
+
+pub fn meta<M>(attrs: List<Attr<M>>): Html<M> =
+    Element("meta", attrs, [])
+
+pub fn link<M>(attrs: List<Attr<M>>): Html<M> =
+    Element("link", attrs, [])
+
+pub fn script<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
+    Element("script", attrs, children)
+
+pub fn iframe<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
+    Element("iframe", attrs, children)
+
+pub fn figure<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
+    Element("figure", attrs, children)
+
+pub fn figcaption<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
+    Element("figcaption", attrs, children)
+
 // ============================================================================
 // Element builders - Tables
 // ============================================================================
@@ -285,6 +309,12 @@ pub fn onKeyUp<M>(h: fn(String): M): Attr<M> =
 pub fn data<M>(name: String, value: String): Attr<M> =
     DataAttr(name, value)
 
+pub fn attr<M>(name: String, value: String): Attr<M> =
+    Attribute(name, value)
+
+pub fn rawHtml<M>(content: String): Html<M> =
+    RawHtml(content)
+
 // ============================================================================
 // Utility functions
 // ============================================================================
@@ -319,6 +349,7 @@ pub fn renderAttr<M>(attr: Attr<M>): String =
         Checked(false) => "",
         Name(n) => " name=\"" + n + "\"",
         DataAttr(name, value) => " data-" + name + "=\"" + value + "\"",
+        Attribute(name, value) => " " + name + "=\"" + value + "\"",
         // Event handlers are ignored in static rendering
         OnClick(_) => "",
         OnInput(_) => "",
@@ -355,6 +386,7 @@ pub fn render<M>(html: Html<M>): String =
             }
         },
         Text(content) => escapeHtml(content),
+        RawHtml(content) => content,
         Empty => ""
     }
 
@@ -368,15 +400,47 @@ pub fn escapeHtml(s: String): String = {
     s4
 }
 
-// Render a full HTML document
+// Render a full HTML document (basic)
 pub fn document(title: String, headExtra: List<Html<M>>, bodyContent: List<Html<M>>): String = {
     let headElements = List.concat([
-        [Element("meta", [DataAttr("charset", "UTF-8")], [])],
-        [Element("meta", [Name("viewport"), Value("width=device-width, initial-scale=1.0")], [])],
+        [Element("meta", [Attribute("charset", "UTF-8")], [])],
+        [Element("meta", [Name("viewport"), Attribute("content", "width=device-width, initial-scale=1.0")], [])],
         [Element("title", [], [Text(title)])],
         headExtra
     ])
-    let doc = Element("html", [DataAttr("lang", "en")], [
+    let doc = Element("html", [Attribute("lang", "en")], [
+        Element("head", [], headElements),
+        Element("body", [], bodyContent)
+    ])
+    "<!DOCTYPE html>\n" + render(doc)
+}
+
+// Render a full HTML document with SEO meta tags
+pub fn seoDocument(
+    title: String,
+    description: String,
+    url: String,
+    ogImage: String,
+    headExtra: List<Html<M>>,
+    bodyContent: List<Html<M>>
+): String = {
+    let headElements = List.concat([
+        [Element("meta", [Attribute("charset", "UTF-8")], [])],
+        [Element("meta", [Name("viewport"), Attribute("content", "width=device-width, initial-scale=1.0")], [])],
+        [Element("title", [], [Text(title)])],
+        [Element("meta", [Name("description"), Attribute("content", description)], [])],
+        [Element("meta", [Attribute("property", "og:title"), Attribute("content", title)], [])],
+        [Element("meta", [Attribute("property", "og:description"), Attribute("content", description)], [])],
+        [Element("meta", [Attribute("property", "og:type"), Attribute("content", "website")], [])],
+        [Element("meta", [Attribute("property", "og:url"), Attribute("content", url)], [])],
+        [Element("meta", [Attribute("property", "og:image"), Attribute("content", ogImage)], [])],
+        [Element("meta", [Name("twitter:card"), Attribute("content", "summary_large_image")], [])],
+        [Element("meta", [Name("twitter:title"), Attribute("content", title)], [])],
+        [Element("meta", [Name("twitter:description"), Attribute("content", description)], [])],
+        [Element("link", [Attribute("rel", "canonical"), Href(url)], [])],
+        headExtra
+    ])
+    let doc = Element("html", [Attribute("lang", "en")], [
         Element("head", [], headElements),
         Element("body", [], bodyContent)
     ])

stdlib/http.lux

@@ -625,6 +625,41 @@ pub fn router(routes: List<Route>, notFound: fn(Request): Response): Handler =
         }
     }
 
+// ============================================================
+// Static File Serving
+// ============================================================
+
+// Serve a static file from disk
+pub fn serveStaticFile(basePath: String, requestPath: String): Response with {File} = {
+    let filePath = basePath + requestPath
+    if File.exists(filePath) then {
+        let content = File.read(filePath)
+        let mime = getMimeType(filePath)
+        { status: 200, headers: [("Content-Type", mime)], body: content }
+    } else
+        { status: 404, headers: textHeaders(), body: "Not Found" }
+}
+
+// ============================================================
+// Form Body Parsing
+// ============================================================
+
+// Parse URL-encoded form body (same format as query strings)
+pub fn parseFormBody(body: String): List<(String, String)> =
+    parseQueryParams(body)
+
+// Get a form field value by name
+pub fn getFormField(fields: List<(String, String)>, name: String): Option<String> =
+    getParam(fields, name)
+
+// ============================================================
+// Response Helpers
+// ============================================================
+
+// Send a Response using HttpServer effect (convenience wrapper)
+pub fn sendResponse(resp: Response): Unit with {HttpServer} =
+    HttpServer.respondWithHeaders(resp.status, resp.body, resp.headers)
+
 // ============================================================
 // Example Usage
 // ============================================================