Parser: collapse double-parens at call sites with records

Call-site `(…)` now accepts the same content as a record primary.
Named items or a trailing `,` signal "one record arg"; pure-positional
lists keep today's curried fold so existing code is unchanged:

  f()              App(f, UnitValue)        unchanged
  f(x)             App(f, x)                unchanged
  f(x, y)          App(App(f, x), y)        unchanged (curried)
  f((age: 30))     App(f, record)           unchanged (inner primary is record)
  f(age: 30)       App(f, record)           NEW — collapses to single paren
  f(x,)            App(f, 1-record(x))      NEW — trailing-comma as record
  f(x, name: v)    App(f, record)           NEW — mixed items

Surface-syntax only; no semantic shift. Ronald's framing: "application
is a space, and (…) is either grouping or a record — both work the
same way whether or not the function is juxtaposed with them."

Playground examples with record args now use single parens:
  getName(name: "Ada", age: 42)
  useName(age: 30)
  ToString(x: 1, y: 2)

Two new parser tests verify the collapse and the equivalence with
the double-paren form.

Tests: 87 Parser + 75 Core + 25 Playground (all green).

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

Author: 2 people

src/TypeFighter.Parser01.Tests/TestCases/Records.fs

@@ -32,6 +32,20 @@ let ``parens without trailing comma are grouping`` () =
     """( 42 )"""
     |> shouldParseTo (X.Lit 42)
 
+[<Test>]
+let ``call-with-named-arg collapses to single parens`` () =
+    """f(name: "Ada")"""
+    |> shouldParseTo
+        (X.App (X.Var "f")
+            (X.MkRecord [ X.Property "name" (X.Lit "Ada") ]))
+
+[<Test>]
+let ``call-with-double-parens equals call-with-single`` () =
+    let a = parse """f(name: "Ada")"""
+    let b = parse """f((name: "Ada"))"""
+    if a <> b then
+        failwithf "Expected same AST.\n  a: %A\n  b: %A" a b
+
 
 // ---- Property access --------------------------------------------
 

src/TypeFighter.Parser01/Syntax.fs

@@ -391,17 +391,32 @@ let private arrow =
 
 type private CallTail = Expr<unit> -> Expr<unit>
 
+// Call-site `(…)` accepts the same shape as a record primary.
+// Named items or a trailing `,` ⇒ one record arg; pure-positional
+// lists keep today's curried fold so existing code is unaffected.
 let private callArgs : Parser<CallTail> =
+    let trailingComma =
+        (sym "," |> map (fun _ -> true))
+        <|> mkParser (fun inp -> POk.create inp.idx inp.idx false)
     parse {
         let! openP  = sym "("
-        let! args   = commaList expr
+        let! items  = commaList recordItem
+        let! comma  = trailingComma
         let! closeP = sym ")"
         let apply (src: Expr<unit>) =
-            match args.result with
-            | []   -> X.App src (X.Var "UnitValue")           // f() ≡ f UnitValue
-            | xs   -> xs |> List.fold (fun acc a -> X.App acc a) src
+            let hasNamed =
+                items.result |> List.exists (fun i -> i.TryAsPositional.IsNone)
+            match items.result, comma.result, hasNamed with
+            | [], _, _ ->
+                X.App src (X.Var "UnitValue")
+            | _, true, _
+            | _, _, true ->
+                X.App src (X.MkRecord items.result)
+            | xs, false, false ->
+                let exprs = xs |> List.choose (fun i -> i.TryAsPositional)
+                exprs |> List.fold (fun acc a -> X.App acc a) src
         return
-            { range = Range.merge [ openP.range; args.range; closeP.range ]
+            { range = Range.merge [ openP.range; items.range; closeP.range ]
               result = apply }
     }
 

web/src/examples.json

@@ -33,7 +33,7 @@
       },
       {
         "title": "structural accessor",
-        "source": "// `getName` is inferred from its body alone — no annotations.\n// Any record with a `name` field of type String works.\n\nlet getName = r => r.name;\nlog(getName((name: \"Ada\", age: 42)));\nlog(getName((name: \"Bob\", age: 31)));"
+        "source": "// `getName` is inferred from its body alone — no annotations.\n// Any record with a `name` field of type String works.\n\nlet getName = r => r.name;\nlog(getName(name: \"Ada\", age: 42));\nlog(getName(name: \"Bob\", age: 31));"
       },
       {
         "title": "record from function",
@@ -84,15 +84,15 @@
     "examples": [
       {
         "title": "ToString is polymorphic",
-        "source": "// ToString's type is `tv_0 -> String` — one instantiation per\n// call site. Three unrelated argument types, one function.\n\nlog(ToString(42));\nlog(ToString(true));\nlog(ToString((x: 1, y: 2)));"
+        "source": "// ToString's type is `tv_0 -> String` — one instantiation per\n// call site. Three unrelated argument types, one function.\n\nlog(ToString(42));\nlog(ToString(true));\nlog(ToString(x: 1, y: 2));"
       },
       {
         "title": "inferred function type",
         "source": "// No annotations anywhere. The type checker works out:\n//   greet : String -> String\n// from the shape of concat and \"Hello, \".\n\nlet greet = s => concat(\"Hello, \")(s);\nlog(greet(\"Ada\"));"
       },
       {
         "title": "inferred record shape",
-        "source": "// `getX`'s inferred type is `( x: tv_0 & y: Number ) -> tv_0` —\n// both the field set and each field's type come from the call\n// sites, with no annotation on `getX`.\n\nlet getX = p => p.x;\nlog(ToString(getX((x: 10, y: 20))));\nlog(ToString(getX((x: 99, y: 100))));"
+        "source": "// `getX`'s inferred type is `( x: tv_0 & y: Number ) -> tv_0` —\n// both the field set and each field's type come from the call\n// sites, with no annotation on `getX`.\n\nlet getX = p => p.x;\nlog(ToString(getX(x: 10, y: 20)));\nlog(ToString(getX(x: 99, y: 100)));"
       },
       {
         "title": "function as value",
@@ -122,7 +122,7 @@
       },
       {
         "title": "record shape mismatch",
-        "source": "// useName demands a record with a `name` field. The argument has\n// `age` but no `name` — \"required field missing\" fires.\n\nlet useName = r => r.name;\nuseName((age: 30));"
+        "source": "// useName demands a record with a `name` field. The argument has\n// `age` but no `name` — \"required field missing\" fires.\n\nlet useName = r => r.name;\nuseName(age: 30);"
       },
       {
         "title": "parse error",