feat(parser): accept slash-effect-row in type-expression position (closes #547) (#550)

hyperpolymath · claude · web-flow · commit 3e53f1d3d6de · 2026-06-12T01:44:35.000+01:00
## Summary Closes #547. The slash-effect-row form `fn(...) -> T / { E1, E2 }` (and its single-effect short form `fn(...) -> T / E`) parses today only in fn-decl signatures (`return_type`, lines 271-282); it parse-errors in record-field and type-alias positions, forcing every effectful function-typed record field to fall back to the older `-{E}->` arrow form. This is a parser asymmetry, not a language-design question. Surfaced during the post-#228 idaptik port batch in [`hyperpolymath/idaptik#153`](https://github.com/hyperpolymath/idaptik/pull/153). ## Surface-grammar diff ``` type_expr_arrow: | T -> R (already) | T -{E}-> R (already) + | T -> R / { E1, E2, ... } (this PR) + | T -> R / E (this PR) type_expr_primary (FN form, fn-as-type): | fn(A, ...) -> R (already) | fn(A, ...) -{E}-> R (already) + | fn(A, ...) -> R / { E1, ... } (this PR) + | fn(A, ...) -> R / E (this PR) ``` Both spellings remain accepted. `-{E}->` semantics are unchanged. ## Verification - `dune build bin/main.exe` — clean - `dune runtest` — **376/376 PASS** (368 baseline + 8 new) - **Conflict count unchanged** (21 s/r, 1 r/r — same as pre-PR) - Headline probes (all `Type checking passed`): ``` pub type AsyncCall = fn(Int) -> Int / { Async }; pub type H = { call: fn(Int) -> Int / { Async } } pub type H = { call: fn(Int) -> Int / Async } // single short pub type Multi = fn(Int, String) -> Bool / { IO, Async }; pub type R = Int -> Int / { Mut }; // arrow-as-type pub type R = fn() -> () / { IO }; // zero-arg ``` ## Semantic note (which arrow the effect attaches to) - In `type_expr_arrow` (no `fn(...)` wrapper), the slash effect attaches to the **outermost** arrow — the position of the slash itself. This is the natural reading of `A -> B / { E }`. - In the FN-form (`fn(A, B) -> R / { E }`), the effect attaches to the **innermost** arrow (the call site), matching the established prefix-row `-{E}->` FN-form precedent (lines 555-582). This is what consumers expect when porting `fn(A, B) -{E}-> R`. For users who want inner-arrow effect attachment in arrow-as-type positions, the existing `-{E}->` form continues to express that. ## Refs - Closes #547 - Refs #228 (sibling parser-asymmetry gap, closed in #241 / #447 / #523) - Refs #229 (estate-wide ReScript-surface elimination) - Refs #548 (sibling gap from the same port batch — module-level mutable bindings, PR #549) - Refs hyperpolymath/idaptik#153 (the port batch that surfaced this) 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Signed-off-by: hyperpolymath <6759885+hyperpolymath@users.noreply.github.com> Signed-off-by: Jonathan D.A. Jewell <6759885+hyperpolymath@users.noreply.github.com> Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
diff --git a/.github/workflows/secret-scanner.yml b/.github/workflows/secret-scanner.yml
@@ -15,8 +15,9 @@ jobs:
     secrets: inherit
   trufflehog:
     runs-on: ubuntu-latest
+    timeout-minutes: 10
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
         with:
           fetch-depth: 0
       - name: TruffleHog Secret Scan
diff --git a/lib/parser.mly b/lib/parser.mly
@@ -505,6 +505,22 @@ type_expr_arrow:
     { TyArrow (arg, None, ret, None) }
   | arg = type_expr_primary MINUS LBRACE eff = effect_expr RBRACE ARROW ret = type_expr_arrow
     { TyArrow (arg, None, ret, Some eff) }
+  /* #547: slash-effect-row trailing form `T -> R / { E1, ... }` and
+     single-effect `T -> R / E`. Mirrors the return_type slash forms
+     in fn-decl signatures (lines 271-282) one level up to type-
+     expression position, closing the parser asymmetry surfaced in
+     #547: until this PR the `fn(...) -> R / { E }` syntax accepted
+     in fn-decl signatures parse-errored in record-field / type-alias
+     positions, forcing every effectful function-typed record field
+     to fall back to the older `-{E}->` arrow form. Both spellings
+     remain accepted; the slash form is the canonical effect-row
+     spelling from the Frontier Guide. Effect attaches to the
+     outermost arrow (the position of the slash); inner-arrow
+     attachment is still expressible via `-{E}->`. */
+  | arg = type_expr_primary ARROW ret = type_expr_arrow SLASH LBRACE effs = separated_nonempty_list(COMMA, effect_term) RBRACE
+    { TyArrow (arg, None, ret, Some (effect_union_of_list effs)) }
+  | arg = type_expr_primary ARROW ret = type_expr_arrow SLASH single = effect_term
+    { TyArrow (arg, None, ret, Some single) }
   /* `(A, B, ...) -> R` lowers to the curried arrow `A -> B -> ... -> R`
      so user source can write multi-arg fn types without manual currying.
      The existing tuple-as-type rule (LPAREN ty COMMA tys RPAREN) still
@@ -566,6 +582,39 @@ type_expr_primary:
     { match params with
       | [] -> TyArrow (TyTuple [], None, ret, None)
       | _  -> List.fold_right (fun p acc -> TyArrow (p, None, acc, None)) params ret }
+  /* #547: slash-effect-row form for fn-type, single + braced. Mirrors
+     the `MINUS LBRACE ... ARROW` variant immediately below it. The
+     effect attaches to the innermost arrow (the one whose result is
+     ret) to match the existing prefix-row semantics. */
+  | FN LPAREN params = separated_list(COMMA, type_expr) RPAREN ARROW
+    ret = type_expr_arrow SLASH LBRACE effs = separated_nonempty_list(COMMA, effect_term) RBRACE
+    { let eff = effect_union_of_list effs in
+      match params with
+      | [] -> TyArrow (TyTuple [], None, ret, Some eff)
+      | _ ->
+        let rev_params = List.rev params in
+        (match rev_params with
+         | [] -> assert false
+         | last :: earlier_rev ->
+           let innermost = TyArrow (last, None, ret, Some eff) in
+           List.fold_left
+             (fun acc p -> TyArrow (p, None, acc, None))
+             innermost
+             earlier_rev) }
+  | FN LPAREN params = separated_list(COMMA, type_expr) RPAREN ARROW
+    ret = type_expr_arrow SLASH single = effect_term
+    { match params with
+      | [] -> TyArrow (TyTuple [], None, ret, Some single)
+      | _ ->
+        let rev_params = List.rev params in
+        (match rev_params with
+         | [] -> assert false
+         | last :: earlier_rev ->
+           let innermost = TyArrow (last, None, ret, Some single) in
+           List.fold_left
+             (fun acc p -> TyArrow (p, None, acc, None))
+             innermost
+             earlier_rev) }
   /* Effect-row variant: `fn(A, B) -{E}-> C`. Mirrors the prefix-row arrow
      already accepted in `type_expr_arrow` and in `return_type`, and is
      required by hand-ports such as `fn(Http::Request) -{IO}-> Http::Response`
diff --git a/test/test_slash_effect_row.ml b/test/test_slash_effect_row.ml
@@ -0,0 +1,90 @@
+(* SPDX-License-Identifier: MPL-2.0 *)
+(* Copyright (c) 2026 Jonathan D.A. Jewell <jonathan.jewell@open.ac.uk> *)
+
+(** #547 — slash-effect-row `fn(...) -> T / { E }` in type-expression
+    position.
+
+    Until this PR the `fn(...) -> T / { E }` syntax accepted in fn-decl
+    return-type position parse-errored in record-field and type-alias
+    positions, forcing every effectful function-typed record field to
+    fall back to the older `-{E}->` arrow form. This test module pins
+    down the parser slice that closes the asymmetry. *)
+
+open Affinescript
+
+let parse_ok (src : string) : (unit, string) result =
+  try
+    let _prog = Parse_driver.parse_string ~file:"<test_slash_effect_row>" src in
+    Ok ()
+  with
+  | Parse_driver.Parse_error (m, sp) ->
+    Error (Printf.sprintf "Parse error at %s: %s" (Span.show sp) m)
+  | e -> Error (Printf.sprintf "Unexpected: %s" (Printexc.to_string e))
+
+(* Slash-row in a type alias — the headline case from the issue body. *)
+let alias_braced_single_effect () =
+  let src = "pub type AsyncCall = fn(Int) -> Int / { Async };\n" in
+  match parse_ok src with
+  | Ok () -> ()
+  | Error m -> Alcotest.fail ("expected ok, got: " ^ m)
+
+(* Slash-row in a record field — the load-bearing case (effectful
+   handler stored in a record). *)
+let record_field_braced_effect () =
+  let src = "pub type H = { call: fn(Int) -> Int / { Async } }\n" in
+  match parse_ok src with
+  | Ok () -> ()
+  | Error m -> Alcotest.fail ("expected ok, got: " ^ m)
+
+(* Single-effect short form (no braces). *)
+let record_field_single_effect_short () =
+  let src = "pub type H = { call: fn(Int) -> Int / Async }\n" in
+  match parse_ok src with
+  | Ok () -> ()
+  | Error m -> Alcotest.fail ("expected ok, got: " ^ m)
+
+(* Multi-effect braced row — Frontier Guide `/{IO, Async}` shape. *)
+let multi_effect_row () =
+  let src = "pub type Multi = fn(Int, String) -> Bool / { IO, Async };\n" in
+  match parse_ok src with
+  | Ok () -> ()
+  | Error m -> Alcotest.fail ("expected ok, got: " ^ m)
+
+(* Arrow-as-type form (no `fn(...)` wrapper) with slash row. *)
+let arrow_type_with_braced_row () =
+  let src = "pub type R = Int -> Int / { Mut };\n" in
+  match parse_ok src with
+  | Ok () -> ()
+  | Error m -> Alcotest.fail ("expected ok, got: " ^ m)
+
+(* Zero-arg fn with effect row. *)
+let zero_arg_fn_with_effect () =
+  let src = "pub type R = fn() -> () / { IO };\n" in
+  match parse_ok src with
+  | Ok () -> ()
+  | Error m -> Alcotest.fail ("expected ok, got: " ^ m)
+
+(* Regression: existing `-{E}->` arrow form still parses. *)
+let arrow_form_still_works () =
+  let src = "pub type H = { call: Int -{Async}-> Int }\n" in
+  match parse_ok src with
+  | Ok () -> ()
+  | Error m -> Alcotest.fail ("expected ok, got: " ^ m)
+
+(* Regression: plain (no effect) fn type still parses. *)
+let plain_fn_type_still_works () =
+  let src = "pub type H = { call: fn(Int) -> Int }\n" in
+  match parse_ok src with
+  | Ok () -> ()
+  | Error m -> Alcotest.fail ("expected ok, got: " ^ m)
+
+let tests = [
+  Alcotest.test_case "type alias with `/{Effect}` braced single"  `Quick alias_braced_single_effect;
+  Alcotest.test_case "record field with `/{Effect}` braced"      `Quick record_field_braced_effect;
+  Alcotest.test_case "record field with `/Effect` single short"  `Quick record_field_single_effect_short;
+  Alcotest.test_case "multi-effect `/{IO, Async}`"               `Quick multi_effect_row;
+  Alcotest.test_case "arrow-as-type with braced row"             `Quick arrow_type_with_braced_row;
+  Alcotest.test_case "zero-arg fn with effect"                   `Quick zero_arg_fn_with_effect;
+  Alcotest.test_case "regression: `-{E}->` arrow form"           `Quick arrow_form_still_works;
+  Alcotest.test_case "regression: plain fn type"                 `Quick plain_fn_type_still_works;
+]
