hyperpolymath · hyperpolymath · Jun 12, 2026 · Jun 11, 2026 · Jun 11, 2026 · Jun 11, 2026
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;
+]