Bind working somewhat

Author: finnhodgkin

src/codegen/js.rs

@@ -1482,8 +1482,46 @@ fn gen_op_with_dicts(ctx: &CodegenCtx, op: &crate::cst::QualifiedIdent) -> JsExp
     }
 }
 
-/// Apply a binary operator: `op(left)(right)`
-fn apply_binop_js(op_expr: JsExpr, left: JsExpr, right: JsExpr) -> JsExpr {
+/// Check if an operator is `$` (apply) or `#` (applyFlipped) which should be inlined
+/// as direct function application rather than generating `apply(f)(x)`.
+fn is_inline_apply_op(ctx: &CodegenCtx, op_name: Symbol) -> Option<bool> {
+    // Returns Some(false) for `$` (normal order: left(right))
+    // Returns Some(true) for `#` (flipped order: right(left))
+    // Returns None for other operators
+    if let Some((_, target_fn)) = ctx.operator_targets.get(&op_name) {
+        let name = interner::resolve(*target_fn).unwrap_or_default();
+        // Only inline operators that target regular functions, not class methods.
+        // operator_class_targets contains operators whose targets are class methods
+        // (e.g., <*> → Control.Apply.apply). Operators NOT in this map target regular
+        // functions (e.g., $ → Data.Function.apply) and are safe to inline.
+        let is_class_op = ctx.exports.operator_class_targets.contains_key(&op_name)
+            || ctx.module.imports.iter().any(|imp| {
+                ctx.registry.lookup(&imp.module.parts)
+                    .map_or(false, |e| e.operator_class_targets.contains_key(&op_name))
+            });
+        if is_class_op {
+            return None;
+        }
+        match name.as_str() {
+            "apply" => return Some(false),        // $ : f $ x → f(x)
+            "applyFlipped" => return Some(true),  // # : x # f → f(x)
+            _ => {}
+        }
+    }
+    None
+}
+
+/// Apply a binary operator: `op(left)(right)`, with inlining for `$` and `#`.
+fn apply_binop_js(ctx: &CodegenCtx, op_name: Symbol, op_expr: JsExpr, left: JsExpr, right: JsExpr) -> JsExpr {
+    if let Some(flipped) = is_inline_apply_op(ctx, op_name) {
+        if flipped {
+            // `#` (applyFlipped): `x # f` → `f(x)`
+            return JsExpr::App(Box::new(right), vec![left]);
+        } else {
+            // `$` (apply): `f $ x` → `f(x)`
+            return JsExpr::App(Box::new(left), vec![right]);
+        }
+    }
     JsExpr::App(
         Box::new(JsExpr::App(Box::new(op_expr), vec![left])),
         vec![right],
@@ -1515,7 +1553,7 @@ fn gen_op_chain(
         let op_js = gen_op_with_dicts(ctx, &operators[0].value);
         let l = gen_expr(ctx, operands[0]);
         let r = gen_expr(ctx, operands[1]);
-        return apply_binop_js(op_js, l, r);
+        return apply_binop_js(ctx, operators[0].value.name, op_js, l, r);
     }
 
     // Generate JS for all operands and operators
@@ -1539,7 +1577,7 @@ fn gen_op_chain(
                 op_stack.pop();
                 let right_val = output.pop().unwrap();
                 let left_val = output.pop().unwrap();
-                let result = apply_binop_js(op_js[top_idx].clone(), left_val, right_val);
+                let result = apply_binop_js(ctx, operators[top_idx].value.name, op_js[top_idx].clone(), left_val, right_val);
                 output.push(result);
             } else {
                 break;
@@ -1554,7 +1592,7 @@ fn gen_op_chain(
     while let Some(top_idx) = op_stack.pop() {
         let right_val = output.pop().unwrap();
         let left_val = output.pop().unwrap();
-        let result = apply_binop_js(op_js[top_idx].clone(), left_val, right_val);
+        let result = apply_binop_js(ctx, operators[top_idx].value.name, op_js[top_idx].clone(), left_val, right_val);
         output.push(result);
     }
 
@@ -1852,6 +1890,7 @@ fn resolve_operator(ctx: &CodegenCtx, op_qident: &QualifiedIdent) -> JsExpr {
         if ctx.local_names.contains(target_fn) {
             return JsExpr::Var(js_name);
         }
+
         if let Some(source_parts) = ctx.name_source.get(target_fn) {
             if let Some(js_mod) = ctx.import_map.get(source_parts) {
                 return JsExpr::ModuleAccessor(js_mod.clone(), js_name);
@@ -2615,14 +2654,16 @@ fn gen_curried_lambda(params: &[String], body: JsExpr) -> JsExpr {
     result
 }
 
-fn make_qualified_ref(_ctx: &CodegenCtx, qual_mod: Option<&Ident>, name: &str) -> JsExpr {
+fn make_qualified_ref(ctx: &CodegenCtx, qual_mod: Option<&Ident>, name: &str) -> JsExpr {
     if let Some(mod_sym) = qual_mod {
         let mod_str = interner::resolve(*mod_sym).unwrap_or_default();
         let js_mod = any_name_to_js(&mod_str.replace('.', "_"));
         JsExpr::ModuleAccessor(js_mod, any_name_to_js(name))
     } else {
-        // Unqualified: look for it in scope
-        JsExpr::Var(any_name_to_js(name))
+        // Resolve through name_source for proper module qualification
+        let sym = interner::intern(name);
+        let base = resolve_name_to_js(ctx, sym);
+        maybe_insert_dict_args(ctx, sym, base)
     }
 }
 

src/typechecker/check.rs

@@ -961,6 +961,15 @@ fn is_prim_module(module_name: &crate::cst::ModuleName) -> bool {
         && crate::interner::resolve(module_name.parts[0]).unwrap_or_default() == "Prim"
 }
 
+/// Check if a deferred class constraint should be silently skipped in Pass 3.
+/// - `IsSymbol`: compiler-solved for any type-level string literal.
+/// - `Bind`: synthesized by do-notation desugaring; always resolvable when the
+///   Bind class is imported (standalone tests without Control.Bind skip this).
+fn is_skip_deferred_class(class_name: Symbol) -> bool {
+    let name = crate::interner::resolve(class_name).unwrap_or_default();
+    matches!(name.as_str(), "IsSymbol" | "Bind")
+}
+
 /// Check if a CST ModuleName is a Prim submodule (e.g. Prim.Coerce, Prim.Row).
 fn is_prim_submodule(module_name: &crate::cst::ModuleName) -> bool {
     module_name.parts.len() >= 2
@@ -1026,13 +1035,14 @@ fn prim_submodule_exports(module_name: &crate::cst::ModuleName) -> ModuleExports
             exports.class_param_counts.insert(intern("RowToList"), 2);
         }
         "Symbol" => {
-            // classes: Append, Compare, Cons
-            for class in &["Append", "Compare", "Cons"] {
+            // classes: Append, Compare, Cons, IsSymbol
+            for class in &["Append", "Compare", "Cons", "IsSymbol"] {
                 exports.instances.insert(intern(class), Vec::new());
             }
             exports.class_param_counts.insert(intern("Append"), 3);
             exports.class_param_counts.insert(intern("Compare"), 3);
             exports.class_param_counts.insert(intern("Cons"), 3);
+            exports.class_param_counts.insert(intern("IsSymbol"), 1);
         }
         "TypeError" => {
             // classes: Fail, Warn; type constructors: Text, Beside, Above, Quote, QuoteLabel
@@ -1462,6 +1472,7 @@ pub fn check_module(module: &Module, registry: &ModuleRegistry) -> CheckResult {
         }
     }
 
+
     // Process imports: bring imported names into scope
     let explicitly_imported_types = process_imports(
         module,
@@ -5233,9 +5244,14 @@ pub fn check_module(module: &Module, registry: &ModuleRegistry) -> CheckResult {
 
         // If the class itself is not known (not in any instance map and no
         // methods registered), produce UnknownClass instead of NoInstanceFound.
+        // Exception: compiler-solved/synthesized classes (IsSymbol, Bind from
+        // do-notation) are silently skipped when not imported.
         let class_is_known = instances.contains_key(class_name)
             || ctx.class_methods.values().any(|(cn, _)| cn == class_name);
         if !class_is_known {
+            if is_skip_deferred_class(*class_name) {
+                continue;
+            }
             errors.push(TypeError::UnknownClass {
                 span: *span,
                 name: *class_name,
@@ -6123,6 +6139,14 @@ fn process_imports(
                         }
                     }
                 }
+                // Also import instance_registry and instance_modules so codegen
+                // can resolve concrete dict expressions (e.g., bindEffect, applicativeEffect).
+                for (key, inst_name) in &module_exports.instance_registry {
+                    ctx.instance_registry.insert(*key, *inst_name);
+                }
+                for (inst_name, mod_parts) in &module_exports.instance_modules {
+                    ctx.instance_modules.entry(*inst_name).or_insert_with(|| mod_parts.clone());
+                }
             }
             Some(ImportList::Hiding(items)) => {
                 let hidden: HashSet<Symbol> = items.iter().map(|i| import_name(i)).collect();

src/typechecker/infer.rs

@@ -2425,6 +2425,12 @@ impl InferCtx {
             if env.lookup(bind_sym).is_none() {
                 return Err(TypeError::UndefinedVariable { span, name: bind_sym });
             }
+            // Defer a Bind constraint so codegen can resolve the concrete dictionary
+            // (e.g., bindEffect for Effect monad). Do-notation desugars to `bind` calls
+            // but doesn't go through normal variable inference, so we must explicitly
+            // create the constraint here.
+            let bind_class = crate::interner::intern("Bind");
+            self.deferred_constraints.push((span, bind_class, vec![monad_ty.clone()], self.current_binding_name));
         }
 
         // Check that `discard` is in scope when do-notation has non-last discards

tests/node_integration.rs

@@ -0,0 +1,136 @@
+//! Node.js integration tests for the full compiler pipeline.
+//!
+//! These tests compile PureScript modules using the test-compiler-fun project
+//! (with real Prelude, Effect, etc.) and run the output with Node.js to verify
+//! correctness of the generated JavaScript.
+
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+/// Get the project root directory (where Cargo.toml lives).
+fn project_root() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+}
+
+/// Get the test-compiler-fun project directory.
+fn test_project_dir() -> PathBuf {
+    project_root().join("..").join("test-compiler-fun")
+}
+
+/// Mutex to serialize integration tests that share the filesystem.
+use std::sync::Mutex;
+static TEST_MUTEX: Mutex<()> = Mutex::new(());
+
+/// Write a Main.purs to the test project, compile all modules, and return
+/// the output directory path. Panics on compilation failure.
+fn compile_with_main(main_source: &str) -> PathBuf {
+    let test_dir = test_project_dir();
+    let main_path = test_dir.join("src").join("Main.purs");
+    let output_dir = project_root().join("output");
+
+    // Write the Main.purs source
+    std::fs::write(&main_path, main_source).expect("Failed to write Main.purs");
+
+    // Clean output
+    let _ = std::fs::remove_dir_all(&output_dir);
+
+    // Compile using cargo run
+    let status = Command::new("cargo")
+        .args([
+            "run",
+            "--",
+            "compile",
+            "../test-compiler-fun/src/**/*.purs",
+            "../test-compiler-fun/.spago/*/src/**/*.purs",
+        ])
+        .current_dir(&project_root())
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .status()
+        .expect("Failed to run cargo");
+
+    assert!(status.success(), "Compilation failed");
+    output_dir
+}
+
+/// Run a Node.js expression that imports and executes Main, returning stdout.
+fn run_main(output_dir: &Path) -> String {
+    let main_js = output_dir.join("Main").join("index.js");
+    assert!(
+        main_js.exists(),
+        "Main/index.js not found at {}",
+        main_js.display()
+    );
+
+    let script = format!(
+        "import('{}').then(m => {{ if (typeof m.main === 'function') m.main(); }})",
+        main_js.display()
+    );
+
+    let output = Command::new("node")
+        .args(["--input-type=module", "-e", &script])
+        .output()
+        .expect("Failed to run node");
+
+    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+
+    if !output.status.success() {
+        panic!(
+            "Node.js execution failed:\n--- stdout ---\n{}\n--- stderr ---\n{}",
+            stdout, stderr
+        );
+    }
+
+    stdout
+}
+
+/// Compile and run a Main.purs, returning stdout.
+fn compile_and_run(main_source: &str) -> String {
+    let output_dir = compile_with_main(main_source);
+    run_main(&output_dir)
+}
+
+// ===== Integration tests =====
+
+#[test]
+fn node_simple_map_show_log() {
+    let _lock = TEST_MUTEX.lock().unwrap();
+    let output = compile_and_run(
+        r#"module Main where
+
+import Prelude
+
+import Effect (Effect)
+import Effect.Console (log)
+
+main :: Effect Unit
+main =
+  [ 1, 2, 3 ] <#> (\x -> x + 1)
+    # show >>> log
+"#,
+    );
+    assert_eq!(output.trim(), "[2,3,4]");
+}
+
+#[test]
+fn node_do_notation_bind_pure() {
+    let _lock = TEST_MUTEX.lock().unwrap();
+    let output = compile_and_run(
+        r#"module Main where
+
+import Prelude
+
+import Effect (Effect)
+import Effect.Console (log)
+
+main :: Effect Unit
+main = do
+  twoThreeFour <- pure $ [ 1, 2, 3 ] <#> (\x -> x + 1)
+  log $ show twoThreeFour
+  log $ "HI!"
+  pure unit
+"#,
+    );
+    assert_eq!(output.trim(), "[2,3,4]\nHI!");
+}