Unify map literals with braces and support key expressions

Author: pchalamet

docs/language-choices.md

@@ -20,7 +20,7 @@ let x =
   - `'a option`
   - `'a map`
 - Map values use native literals:
-  - `#{ "a" = 1; "b" = 2 }`
+  - `{ ["a"] = 1; ["b"] = 2 }`
 - Runtime helpers are also available for map construction/updates (for example `Map.ofList`, `Map.add`).
 - Function types use arrow syntax:
   - `int -> string`
@@ -53,6 +53,7 @@ let x =
 - Host capabilities are exposed through explicit extern functions.
 - Typed decoding workflows use `typeof Name` tokens with host externs.
 - Capability maps can use `nameof identifier` for stable script-side function keys.
+- Capability maps use string keys in map literals (`[expr]` where `expr : string`).
 
 ## Formatting and layout choices
 - `match` case columns align.

docs/supported-types.md

@@ -20,10 +20,10 @@ This document specifies the value and type system used by the interpreter.
 
 ## Map literals
 - Native map literal syntax:
-  - empty: `#{}`
-  - populated: `#{ "a" = 1; "b" = 2 }`
+  - empty: `{}`
+  - populated: `{ ["a"] = 1; ["b"] = 2 }`
   - multiline entries are supported in an indented block.
-- Keys are `string`.
+- Keys are bracketed expressions and must have type `string`.
 - Values are inferred and unified to a single value type.
 
 ## Function types

docs/syntax-and-indentation.md

@@ -39,12 +39,13 @@ This document describes the concrete syntax accepted by the interpreter and the
   - field access `p.Name`
   - copy-update `{ p with Age = 2 }`
 - Maps:
-  - empty `#{}`
-  - literal `#{ "a" = 1; "b" = 2 }`
+  - empty `{}`
+  - literal `{ ["a"] = 1; ["b"] = 2 }`
+  - keys are bracketed expressions (`[expr]`) and must infer to `string`
   - multiline:
-    - `#{`
-    - `    "a" = 1`
-    - `    "b" = 2`
+    - `{`
+    - `    ["a"] = 1`
+    - `    ["b"] = 2`
     - `}`
 - Lists:
   - `[a; b; c]`

samples/types-showcase.fss

@@ -20,7 +20,7 @@ type Subscription =
 
 
 let scores =
-    #{ "math" = 20; "science" = 18 }
+    { ["math"] = 20; ["science"] = 18 }
 
 
 let user = { Id = 1; Name = "Ada"; Tags = ["engineer"; "writer"]; Address = Some { City = "London"; Zip = 12345 }; Scores = scores; Pair = (7, "seven") }
@@ -40,9 +40,9 @@ let format_address (address: { City: string; Zip: int }) = $"{address.City} ({ad
 
 // Name exposure for host capability maps.
 let capabilities =
-    #{
-        (nameof format_address) = "address formatting"
-        (nameof make_office_address) = "office address constructor"
+    {
+        ["format_address"] = "address formatting"
+        ["make_office_address"] = "office address constructor"
     }
 
 
@@ -59,6 +59,7 @@ let mathScore =
 
 
 let hasScience = updated.Scores |> Map.containsKey "science"
+let formatAddressKey = "format_address"
 
 let monthlyPrice =
     match subscription with
@@ -78,7 +79,7 @@ print $"Subscription price: {monthlyPrice}"
 // - value created through another named record type (OfficeAddress)
 print $"Structural address from literal: {format_address parisAddress}"
 print $"Structural address from OfficeAddress: {format_address officeAddress}"
-print $"Capability for format_address: {Map.tryGet (nameof format_address) capabilities |> Option.defaultValue missing}"
+print $"Capability for format_address: {Map.tryGet formatAddressKey capabilities |> Option.defaultValue missing}"
 
 
 updated.Tags |> List.iter print

src/FScript.Language/Parser.fs

@@ -39,7 +39,7 @@ module Parser =
 
     let private isStartAtom (k: TokenKind) =
         match k with
-        | Ident _ | IntLit _ | FloatLit _ | StringLit _ | InterpString _ | BoolLit _ | LParen | LBracket | LBrace | Hash | Let | Fun | If | Raise | For | Match | Typeof | Nameof -> true
+        | Ident _ | IntLit _ | FloatLit _ | StringLit _ | InterpString _ | BoolLit _ | LParen | LBracket | LBrace | Let | Fun | If | Raise | For | Match | Typeof | Nameof -> true
         | _ -> false
 
     let private isUpperIdent (name: string) =
@@ -494,105 +494,107 @@ module Parser =
             | LBrace ->
                 let lb = stream.Next()
                 if stream.Match(RBrace) then
-                    ERecord([], mkSpanFrom lb.Span lb.Span)
+                    EMap([], mkSpanFrom lb.Span lb.Span)
                 else
-                    let mark = stream.Mark()
-                    let tryRecordUpdate () =
-                        let baseExpr = parseExpr()
+                    let mapMark = stream.Mark()
+                    stream.SkipNewlines()
+                    let hasMapIndent = stream.Match(Indent)
+                    stream.SkipNewlines()
+                    if stream.Peek().Kind = LBracket then
+                        let parseMapEntry () =
+                            stream.Expect(LBracket, "Expected '[' in map entry key") |> ignore
+                            let keyExpr = parseExpr()
+                            stream.Expect(RBracket, "Expected ']' after map entry key") |> ignore
+                            stream.SkipNewlines()
+                            stream.Expect(Equals, "Expected '=' in map entry") |> ignore
+                            let value = parseExpr()
+                            keyExpr, value, (Ast.spanOfExpr value).End.Line
+
                         stream.SkipNewlines()
-                        if not (stream.Match(With)) then
-                            stream.Restore(mark)
-                            None
+                        if hasMapIndent && stream.Peek().Kind = Dedent then
+                            stream.Next() |> ignore
+
+                        if stream.Peek().Kind = RBrace then
+                            let rb = stream.Expect(RBrace, "Expected '}' in map literal")
+                            EMap([], mkSpanFrom lb.Span rb.Span)
                         else
-                            let updates = ResizeArray<string * Expr>()
-                            let parseUpdateField () =
-                                let nameTok = stream.ExpectIdent("Expected field name in record update")
+                            let entries = ResizeArray<Expr * Expr>()
+                            let firstKey, firstValue, firstLine = parseMapEntry()
+                            entries.Add(firstKey, firstValue)
+
+                            let rec parseTail (lastEntryEndLine: int) =
+                                stream.SkipNewlines()
+                                if hasMapIndent && stream.Peek().Kind = Dedent then
+                                    stream.Next() |> ignore
+                                if stream.Peek().Kind = RBrace then
+                                    ()
+                                elif stream.Match(Semicolon) then
+                                    stream.SkipNewlines()
+                                    if hasMapIndent && stream.Peek().Kind = Dedent then
+                                        stream.Next() |> ignore
+                                    if stream.Peek().Kind = RBrace then
+                                        ()
+                                    else
+                                        let key, value, valueLine = parseMapEntry()
+                                        entries.Add(key, value)
+                                        parseTail valueLine
+                                else
+                                    let next = stream.Peek()
+                                    if next.Span.Start.Line > lastEntryEndLine then
+                                        let key, value, valueLine = parseMapEntry()
+                                        entries.Add(key, value)
+                                        parseTail valueLine
+                                    else
+                                        raise (ParseException { Message = "Expected ';', newline, or '}' in map literal"; Span = next.Span })
+
+                            parseTail firstLine
+                            let rb = stream.Expect(RBrace, "Expected '}' in map literal")
+                            EMap(entries |> Seq.toList, mkSpanFrom lb.Span rb.Span)
+                    else
+                        stream.Restore(mapMark)
+                        let mark = stream.Mark()
+                        let tryRecordUpdate () =
+                            let baseExpr = parseExpr()
+                            stream.SkipNewlines()
+                            if not (stream.Match(With)) then
+                                stream.Restore(mark)
+                                None
+                            else
+                                let updates = ResizeArray<string * Expr>()
+                                let parseUpdateField () =
+                                    let nameTok = stream.ExpectIdent("Expected field name in record update")
+                                    let name =
+                                        match nameTok.Kind with
+                                        | Ident n -> n
+                                        | _ -> ""
+                                    stream.SkipNewlines()
+                                    stream.Expect(Equals, "Expected '=' in record update field") |> ignore
+                                    let value = parseExpr()
+                                    updates.Add(name, value)
+                                parseUpdateField()
+                                while stream.Match(Semicolon) do
+                                    parseUpdateField()
+                                let rb = stream.Expect(RBrace, "Expected '}' in record update")
+                                Some (ERecordUpdate(baseExpr, updates |> Seq.toList, mkSpanFrom lb.Span rb.Span))
+                        match tryRecordUpdate() with
+                        | Some updateExpr -> updateExpr
+                        | None ->
+                            let fields = ResizeArray<string * Expr>()
+                            let parseField () =
+                                let nameTok = stream.ExpectIdent("Expected field name in record literal")
                                 let name =
                                     match nameTok.Kind with
                                     | Ident n -> n
                                     | _ -> ""
                                 stream.SkipNewlines()
-                                stream.Expect(Equals, "Expected '=' in record update field") |> ignore
+                                stream.Expect(Equals, "Expected '=' in record field") |> ignore
                                 let value = parseExpr()
-                                updates.Add(name, value)
-                            parseUpdateField()
-                            while stream.Match(Semicolon) do
-                                parseUpdateField()
-                            let rb = stream.Expect(RBrace, "Expected '}' in record update")
-                            Some (ERecordUpdate(baseExpr, updates |> Seq.toList, mkSpanFrom lb.Span rb.Span))
-                    match tryRecordUpdate() with
-                    | Some updateExpr -> updateExpr
-                    | None ->
-                        let fields = ResizeArray<string * Expr>()
-                        let parseField () =
-                            let nameTok = stream.ExpectIdent("Expected field name in record literal")
-                            let name =
-                                match nameTok.Kind with
-                                | Ident n -> n
-                                | _ -> ""
-                            stream.SkipNewlines()
-                            stream.Expect(Equals, "Expected '=' in record field") |> ignore
-                            let value = parseExpr()
-                            fields.Add(name, value)
-                        parseField()
-                        while stream.Match(Semicolon) do
+                                fields.Add(name, value)
                             parseField()
-                        let rb = stream.Expect(RBrace, "Expected '}' in record literal")
-                        ERecord(fields |> Seq.toList, mkSpanFrom lb.Span rb.Span)
-            | Hash ->
-                let hashTok = stream.Next()
-                let lb = stream.Expect(LBrace, "Expected '{' after '#' for map literal")
-                let mapStart = mkSpanFrom hashTok.Span lb.Span
-                stream.SkipNewlines()
-                let hasIndent = stream.Match(Indent)
-
-                let parseMapEntry () =
-                    let key = parsePostfix()
-                    stream.SkipNewlines()
-                    stream.Expect(Equals, "Expected '=' in map entry") |> ignore
-                    let value = parseExpr()
-                    key, value, (Ast.spanOfExpr value).End.Line
-
-                stream.SkipNewlines()
-                if hasIndent && stream.Peek().Kind = Dedent then
-                    stream.Next() |> ignore
-
-                if stream.Peek().Kind = RBrace then
-                    let rb = stream.Expect(RBrace, "Expected '}' in map literal")
-                    EMap([], mkSpanFrom mapStart rb.Span)
-                else
-                    let entries = ResizeArray<Expr * Expr>()
-                    let firstKey, firstValue, firstLine = parseMapEntry()
-                    entries.Add(firstKey, firstValue)
-
-                    let rec parseTail (lastEntryEndLine: int) =
-                        stream.SkipNewlines()
-                        if hasIndent && stream.Peek().Kind = Dedent then
-                            stream.Next() |> ignore
-                        if stream.Peek().Kind = RBrace then
-                            ()
-                        elif stream.Match(Semicolon) then
-                            stream.SkipNewlines()
-                            if hasIndent && stream.Peek().Kind = Dedent then
-                                stream.Next() |> ignore
-                            if stream.Peek().Kind = RBrace then
-                                ()
-                            else
-                                let key, value, valueLine = parseMapEntry()
-                                entries.Add(key, value)
-                                parseTail valueLine
-                        else
-                            let next = stream.Peek()
-                            if next.Span.Start.Line > lastEntryEndLine then
-                                let key, value, valueLine = parseMapEntry()
-                                entries.Add(key, value)
-                                parseTail valueLine
-                            else
-                                raise (ParseException { Message = "Expected ';', newline, or '}' in map literal"; Span = next.Span })
-
-                    parseTail firstLine
-                    let rb = stream.Expect(RBrace, "Expected '}' in map literal")
-                    EMap(entries |> Seq.toList, mkSpanFrom mapStart rb.Span)
+                            while stream.Match(Semicolon) do
+                                parseField()
+                            let rb = stream.Expect(RBrace, "Expected '}' in record literal")
+                            ERecord(fields |> Seq.toList, mkSpanFrom lb.Span rb.Span)
             | Let ->
                 parseLetExpr()
             | Fun ->

tests/FScript.Language.Tests/EvalTests.fs

@@ -65,7 +65,7 @@ type EvalTests () =
 
     [<Test>]
     member _.``Evaluates map literals`` () =
-        match Helpers.eval "#{ \"a\" = 1; \"b\" = 2 }" with
+        match Helpers.eval "{ [\"a\"] = 1; [\"b\"] = 2 }" with
         | VStringMap m ->
             m.Count |> should equal 2
             match m.["a"] with
@@ -78,14 +78,20 @@ type EvalTests () =
 
     [<Test>]
     member _.``Evaluates map literals with duplicate keys as last-wins`` () =
-        match Helpers.eval "#{ \"a\" = 1; \"a\" = 2 }" with
+        match Helpers.eval "{ [\"a\"] = 1; [\"a\"] = 2 }" with
         | VStringMap m ->
             m.Count |> should equal 1
             match m.["a"] with
             | VInt 2L -> ()
             | _ -> Assert.Fail("Expected key a to map to 2")
         | _ -> Assert.Fail("Expected map value")
 
+    [<Test>]
+    member _.``Evaluates empty map literal`` () =
+        match Helpers.eval "{}" with
+        | VStringMap m -> m.Count |> should equal 0
+        | _ -> Assert.Fail("Expected empty map value")
+
     [<Test>]
     member _.``Evaluates record copy-update immutably`` () =
         Helpers.eval "let p = { Name = \"a\"; Age = 1 }\nlet p2 = { p with Age = 2 }\np.Age" |> assertInt 1L

tests/FScript.Language.Tests/HostExternTests.fs

@@ -51,11 +51,11 @@ type HostExternTests () =
 
     [<Test>]
     member _.``Native map literal composes with Map externs`` () =
-        match Helpers.evalWithExterns externs "#{ \"a\" = 1; \"b\" = 2 } |> Map.count" with
+        match Helpers.evalWithExterns externs "{ [\"a\"] = 1; [\"b\"] = 2 } |> Map.count" with
         | VInt 2L -> ()
         | _ -> Assert.Fail("Expected map count 2")
 
-        match Helpers.evalWithExterns externs "#{ \"a\" = 1; \"b\" = 2 } |> Map.tryGet \"b\"" with
+        match Helpers.evalWithExterns externs "{ [\"a\"] = 1; [\"b\"] = 2 } |> Map.tryGet \"b\"" with
         | VOption (Some (VInt 2L)) -> ()
         | _ -> Assert.Fail("Expected Some 2")
 

tests/FScript.Language.Tests/LexerTests.fs

@@ -94,6 +94,8 @@ type LexerTests () =
         fieldTokens |> List.exists (fun t -> t.Kind = Dot) |> should equal true
 
     [<Test>]
-    member _.``Tokenizes map literal prefix`` () =
-        let tokens = Lexer.tokenize "#{ \"a\" = 1 }"
-        tokens |> List.exists (fun t -> t.Kind = Hash) |> should equal true
+    member _.``Tokenizes brace map literal with bracket key`` () =
+        let tokens = Lexer.tokenize "{ [\"a\"] = 1 }"
+        tokens |> List.exists (fun t -> t.Kind = LBrace) |> should equal true
+        tokens |> List.exists (fun t -> t.Kind = LBracket) |> should equal true
+        tokens |> List.exists (fun t -> t.Kind = RBracket) |> should equal true

tests/FScript.Language.Tests/ParserTests.fs

@@ -112,21 +112,35 @@ type ParserTests () =
 
     [<Test>]
     member _.``Parses map literal`` () =
-        let p = Helpers.parse "#{ \"a\" = 1; \"b\" = 2 }"
+        let p = Helpers.parse "{ [\"a\"] = 1; [\"b\"] = 2 }"
         match p.[0] with
         | SExpr (EMap (entries, _)) ->
             entries.Length |> should equal 2
         | _ -> Assert.Fail("Expected map literal")
 
     [<Test>]
     member _.``Parses multiline map literal`` () =
-        let src = "#{\n    \"a\" = 1\n    \"b\" = 2\n}"
+        let src = "{\n    [\"a\"] = 1\n    [\"b\"] = 2\n}"
         let p = Helpers.parse src
         match p.[0] with
         | SExpr (EMap (entries, _)) ->
             entries.Length |> should equal 2
         | _ -> Assert.Fail("Expected multiline map literal")
 
+    [<Test>]
+    member _.``Parses empty map literal`` () =
+        let p = Helpers.parse "{}"
+        match p.[0] with
+        | SExpr (EMap (entries, _)) -> entries.Length |> should equal 0
+        | _ -> Assert.Fail("Expected empty map literal")
+
+    [<Test>]
+    member _.``Parses map literal with key expression`` () =
+        let p = Helpers.parse "let a = \"x\"\n{ [a] = 1 }"
+        match p.[1] with
+        | SExpr (EMap (entries, _)) -> entries.Length |> should equal 1
+        | _ -> Assert.Fail("Expected map literal with expression key")
+
     [<Test>]
     member _.``Parses let expression without in`` () =
         let p = Helpers.parse "let x = (let y = 1\n    y + 1\n)"
@@ -331,7 +345,7 @@ type ParserTests () =
 
     [<Test>]
     member _.``Parses multiline lambda argument closed by parenthesis on same line`` () =
-        let src = "Map.fold (fun acc key value ->\n    match value with\n    | \"workspace:*\" -> key :: acc\n    | _ -> acc) [] #{ \"a\" = \"workspace:*\" }"
+        let src = "Map.fold (fun acc key value ->\n    match value with\n    | \"workspace:*\" -> key :: acc\n    | _ -> acc) [] { [\"a\"] = \"workspace:*\" }"
         let p = Helpers.parse src
         match p.[0] with
         | SExpr (EApply (EApply (EApply (EFieldGet (EVar ("Map", _), "fold", _), _, _), _, _), _, _)) -> ()