Add native map literal syntax #{...}

Author: pchalamet

docs/language-choices.md

@@ -19,8 +19,9 @@ let x =
   - `'a list`
   - `'a option`
   - `'a map`
-- Map values can be built from tuple lists with `Map.ofList`:
-  - `Map.ofList [("a", 1); ("b", 2)]`
+- Map values use native literals:
+  - `#{ "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`
   - `int -> int -> int`

docs/supported-types.md

@@ -18,6 +18,14 @@ This document specifies the value and type system used by the interpreter.
 - Record: structural record types
 - Discriminated union: named union types with cases
 
+## Map literals
+- Native map literal syntax:
+  - empty: `#{}`
+  - populated: `#{ "a" = 1; "b" = 2 }`
+  - multiline entries are supported in an indented block.
+- Keys are `string`.
+- Values are inferred and unified to a single value type.
+
 ## Function types
 - Functions use curried arrow types:
   - `t1 -> t2`

docs/syntax-and-indentation.md

@@ -38,6 +38,14 @@ This document describes the concrete syntax accepted by the interpreter and the
   - literal `{ Name = "a"; Age = 1 }`
   - field access `p.Name`
   - copy-update `{ p with Age = 2 }`
+- Maps:
+  - empty `#{}`
+  - literal `#{ "a" = 1; "b" = 2 }`
+  - multiline:
+    - `#{`
+    - `    "a" = 1`
+    - `    "b" = 2`
+    - `}`
 - Lists:
   - `[a; b; c]`
   - range `[a..b]`

samples/types-showcase.fss

@@ -20,9 +20,7 @@ type Subscription =
 
 
 let scores =
-    Map.empty
-    |> Map.add "math" 20
-    |> Map.add "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") }
@@ -42,8 +40,10 @@ let format_address (address: { City: string; Zip: int }) = $"{address.City} ({ad
 
 // Name exposure for host capability maps.
 let capabilities =
-    Map.ofList
-        [(nameof format_address, "address formatting"); (nameof make_office_address, "office address constructor")]
+    #{
+        (nameof format_address) = "address formatting"
+        (nameof make_office_address) = "office address constructor"
+    }
 
 
 let city =

src/FScript.Language/Ast.fs

@@ -53,6 +53,7 @@ and Expr =
     | ERange of Expr * Expr * Span
     | ETuple of Expr list * Span
     | ERecord of (string * Expr) list * Span
+    | EMap of (Expr * Expr) list * Span
     | ERecordUpdate of Expr * (string * Expr) list * Span
     | EFieldGet of Expr * string * Span
     | ECons of Expr * Expr * Span
@@ -107,6 +108,7 @@ module Ast =
         | ERange (_, _, s) -> s
         | ETuple (_, s) -> s
         | ERecord (_, s) -> s
+        | EMap (_, s) -> s
         | ERecordUpdate (_, _, s) -> s
         | EFieldGet (_, _, s) -> s
         | ECons (_, _, s) -> s

src/FScript.Language/Eval.fs

@@ -239,6 +239,17 @@ module Eval =
             |> List.map (fun (name, valueExpr) -> name, evalExpr typeDefs env valueExpr)
             |> Map.ofList
             |> VRecord
+        | EMap (entries, _) ->
+            entries
+            |> List.fold (fun (acc: Map<string, Value>) (keyExpr, valueExpr) ->
+                match evalExpr typeDefs env keyExpr with
+                | VString key ->
+                    let value = evalExpr typeDefs env valueExpr
+                    acc.Add(key, value)
+                | _ ->
+                    // Type checker guarantees string keys for map literals.
+                    raise (EvalException { Message = "Map literal keys must be strings"; Span = Ast.spanOfExpr keyExpr })) (Map.empty<string, Value>)
+            |> VStringMap
         | ERecordUpdate (target, updates, span) ->
             match evalExpr typeDefs env target with
             | VRecord fields ->

src/FScript.Language/Lexer.fs

@@ -335,6 +335,7 @@ module Lexer =
                     i <- i + 2
                     col <- col + 2
                 | '.' -> addToken Dot (mkSpan line col 1) tokens; i <- i + 1; col <- col + 1
+                | '#' -> addToken Hash (mkSpan line col 1) tokens; i <- i + 1; col <- col + 1
                 | '{' -> addToken LBrace (mkSpan line col 1) tokens; i <- i + 1; col <- col + 1
                 | '}' -> addToken RBrace (mkSpan line col 1) tokens; i <- i + 1; col <- col + 1
                 | _ ->

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 | Let | Fun | If | Raise | For | Match | Typeof | Nameof -> true
+        | Ident _ | IntLit _ | FloatLit _ | StringLit _ | InterpString _ | BoolLit _ | LParen | LBracket | LBrace | Hash | Let | Fun | If | Raise | For | Match | Typeof | Nameof -> true
         | _ -> false
 
     let private isUpperIdent (name: string) =
@@ -529,6 +529,60 @@ module Parser =
                             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)
             | Let ->
                 parseLetExpr()
             | Fun ->

src/FScript.Language/Token.fs

@@ -39,6 +39,7 @@ type TokenKind =
     | Colon
     | Dot
     | RangeDots
+    | Hash
     | LBrace
     | RBrace
     | Type

src/FScript.Language/TypeInfer.fs

@@ -484,6 +484,24 @@ module TypeInfer =
                 inferred <- inferred.Add(name, applyType sAcc t1)
             let tRes = TRecord inferred
             sAcc, tRes, asTyped expr tRes
+        | EMap (entries, span) ->
+            let valueType = Types.freshVar()
+            let mutable sAcc = emptySubst
+            for (keyExpr, valueExpr) in entries do
+                let envForKey = applyEnv sAcc env
+                let sKey, tKey, _ = inferExpr typeDefs constructors envForKey keyExpr
+                let sKeyString = unify typeDefs (applyType sKey tKey) TString span
+                let sAfterKey = compose sKeyString (compose sKey sAcc)
+
+                let envForValue = applyEnv sAfterKey env
+                let sValue, tValue, _ = inferExpr typeDefs constructors envForValue valueExpr
+                let expectedValueType = applyType sValue (applyType sAfterKey valueType)
+                let sValueType = unify typeDefs expectedValueType tValue span
+
+                sAcc <- compose sValueType (compose sValue sAfterKey)
+
+            let tRes = TStringMap (applyType sAcc valueType)
+            sAcc, tRes, asTyped expr tRes
         | ERecordUpdate (baseExpr, updates, span) ->
             let sBase, tBase, _ = inferExpr typeDefs constructors env baseExpr
             let baseFields =