Add List.empty plus Map.map/Map.iter externs

Author: pchalamet

README.md

@@ -28,6 +28,7 @@ FScript currently includes:
 - optional type annotations on parameters,
 - type declarations: records and unions (including recursive forms),
 - interpolation, pipeline operator, `typeof` type tokens, and `nameof` identifier tokens for host workflows.
+- unified brace literals for records/maps (`{ Field = value }`, `{ [key] = value }`, `{}` for empty map).
 
 ## Quick Start
 

docs/external-functions.md

@@ -58,10 +58,15 @@ Higher-order externs (for example `List.map`, `Map.fold`, `Option.map`) are impl
 - `Map.filter`
 - `Map.fold`
 - `Map.choose`
+- `Map.map`
+- `Map.iter`
 - `Map.containsKey`
 - `Map.remove`
 
+`Map.empty` is an arity-0 value (`'a map`), not an invokable function.
+
 ### List
+- `List.empty`
 - `List.map`
 - `List.choose`
 - `List.collect`

docs/supported-types.md

@@ -23,7 +23,11 @@ This document specifies the value and type system used by the interpreter.
   - empty: `{}`
   - populated: `{ ["a"] = 1; ["b"] = 2 }`
   - multiline entries are supported in an indented block.
-- Keys are bracketed expressions and must have type `string`.
+- Keys are bracketed expressions and must have type `string` (for example `{ [keyExpr] = value }`).
+- Record literals and map literals share `{ ... }` braces:
+  - map entries use `[expr] = value`
+  - record entries use `Field = value`
+  - `{}` denotes an empty map.
 - Values are inferred and unified to a single value type.
 
 ## Function types

docs/syntax-and-indentation.md

@@ -41,6 +41,9 @@ This document describes the concrete syntax accepted by the interpreter and the
 - Maps:
   - empty `{}`
   - literal `{ ["a"] = 1; ["b"] = 2 }`
+  - map entries always use bracketed keys (`[expr] = value`)
+  - record entries use field assignments (`Field = value`)
+  - when braces are empty (`{}`), the literal is a map
   - keys are bracketed expressions (`[expr]`) and must infer to `string`
   - multiline:
     - `{`

src/FScript.Runtime/ListExterns.fs

@@ -3,6 +3,14 @@ namespace FScript.Runtime
 open FScript.Language
 
 module ListExterns =
+    let empty : ExternalFunction =
+        { Name = "List.empty"
+          Scheme = Forall([ 0 ], TList (TVar 0))
+          Arity = 0
+          Impl = fun _ -> function
+              | [] -> VList []
+              | _ -> raise (HostCommon.evalError "List.empty expects no arguments") }
+
     let rec private valueEquals a b =
         match a, b with
         | VUnit, VUnit -> true

src/FScript.Runtime/MapExterns.fs

@@ -112,6 +112,33 @@ module MapExterns =
                   VStringMap chosen
               | _ -> raise (HostCommon.evalError "Map.choose expects (function, map)") }
 
+    let map : ExternalFunction =
+        { Name = "Map.map"
+          Scheme = Forall([ 0; 1 ], TFun(TFun(TVar 0, TVar 1), TFun(TStringMap (TVar 0), TStringMap (TVar 1))))
+          Arity = 2
+          Impl = fun ctx -> function
+              | [ mapper; mapValue ] ->
+                  let m = asStringMap mapValue
+                  let mapped =
+                      m
+                      |> Map.map (fun _ value -> ctx.Apply mapper value)
+                  VStringMap mapped
+              | _ -> raise (HostCommon.evalError "Map.map expects (function, map)") }
+
+    let iter : ExternalFunction =
+        { Name = "Map.iter"
+          Scheme = Forall([ 0 ], TFun(TFun(TString, TFun(TVar 0, TUnit)), TFun(TStringMap (TVar 0), TUnit)))
+          Arity = 2
+          Impl = fun ctx -> function
+              | [ iterator; mapValue ] ->
+                  let m = asStringMap mapValue
+                  m
+                  |> Map.iter (fun key value ->
+                      let iteratorWithKey = ctx.Apply iterator (VString key)
+                      ctx.Apply iteratorWithKey value |> ignore)
+                  VUnit
+              | _ -> raise (HostCommon.evalError "Map.iter expects (function, map)") }
+
     let containsKey : ExternalFunction =
         { Name = "Map.containsKey"
           Scheme = Forall([ 0 ], TFun(TString, TFun(TStringMap (TVar 0), TBool)))

src/FScript.Runtime/Registry.fs

@@ -28,8 +28,11 @@ module Registry =
           MapExterns.filter
           MapExterns.fold
           MapExterns.choose
+          MapExterns.map
+          MapExterns.iter
           MapExterns.containsKey
           MapExterns.remove
+          ListExterns.empty
           ListExterns.map
           ListExterns.choose
           ListExterns.collect

tests/FScript.Language.Tests/HostExternTests.fs

@@ -77,6 +77,26 @@ type HostExternTests () =
         | VOption (Some (VInt 20L)) -> ()
         | _ -> Assert.Fail("Expected chosen map value 20 for key b")
 
+    [<Test>]
+    member _.``Map.map maps values and Map.iter applies key-value iterator`` () =
+        match Helpers.evalWithExterns externs "Map.ofList [(\"a\", 1); (\"b\", 2)] |> Map.map (fun v -> v + 10) |> Map.tryGet \"b\"" with
+        | VOption (Some (VInt 12L)) -> ()
+        | _ -> Assert.Fail("Expected mapped map value 12 for key b")
+
+        let original = Console.Out
+        use writer = new StringWriter()
+        Console.SetOut(writer)
+        try
+            let result =
+                Helpers.evalWithExterns externs
+                    "Map.ofList [(\"a\", 1); (\"b\", 2)] |> Map.iter (fun key -> fun value -> print $\"{key}:{value}\")"
+            match result with
+            | VUnit -> ()
+            | _ -> Assert.Fail("Expected unit")
+            writer.ToString().Replace("\r\n", "\n").TrimEnd() |> should equal "a:1\nb:2"
+        finally
+            Console.SetOut(original)
+
     [<Test>]
     member _.``Fs write-side externs operate under root confinement`` () =
         let root = Path.Combine(Path.GetTempPath(), "fscript-host-extern-tests", Guid.NewGuid().ToString("N"))
@@ -105,6 +125,15 @@ type HostExternTests () =
         | VList [ VInt 1L; VInt 2L; VInt 3L; VInt 4L ] -> ()
         | _ -> Assert.Fail("Expected mapped int list")
 
+    [<Test>]
+    member _.``List.empty behaves as a value and cannot be invoked`` () =
+        match Helpers.evalWithExterns externs "List.empty |> List.length" with
+        | VInt 0L -> ()
+        | _ -> Assert.Fail("Expected empty list length 0")
+
+        let act () = Helpers.evalWithExterns externs "List.empty ()" |> ignore
+        act |> should throw typeof<TypeException>
+
     [<Test>]
     member _.``List.iter external applies function and returns unit`` () =
         let original = Console.Out

tests/FScript.Runtime.Tests/RegistryTests.fs

@@ -35,7 +35,10 @@ type RegistryTests () =
         names.Contains "Map.filter" |> should equal true
         names.Contains "Map.fold" |> should equal true
         names.Contains "Map.choose" |> should equal true
+        names.Contains "Map.map" |> should equal true
+        names.Contains "Map.iter" |> should equal true
         names.Contains "Map.remove" |> should equal true
+        names.Contains "List.empty" |> should equal true
         names.Contains "List.map" |> should equal true
         names.Contains "List.choose" |> should equal true
         names.Contains "List.collect" |> should equal true