feat(language): add tuple let destructuring and LSP signatures for conversions

Author: pchalamet

CHANGELOG.md

@@ -4,6 +4,7 @@ All notable changes to FScript are documented in this file.
 
 ## [Unreleased]
 - Added `Int/Float/Bool` conversion helpers in stdlib-style builtins (`*.tryParse` and `*.toString`) for safe scalar parsing and string formatting.
+- Added tuple let destructuring (`let (a, b) = ...`) for top-level, block, and let-expression non-rec bindings.
 
 ## [0.40.0]
 

docs/specs/syntax-and-indentation.md

@@ -23,8 +23,11 @@ This document describes the concrete syntax accepted by the interpreter and the
   - `fun (x: int) -> expr`
 - Let expression (layout style):
   - `let x = expr`
+  - `let (a, b) = expr` (tuple destructuring)
   - `let rec f x = ... and g y = ...`
   - nested via blocks
+  - tuple destructuring is supported for non-`rec` `let` bindings only
+  - `[<export>] let` requires a single identifier binding (tuple patterns are rejected)
   - `[<export>]` is only valid on top-level `let` bindings
   - attribute names are case-sensitive (`[<export>]` is valid, `[<Export>]` is not)
 - Conditionals:

samples/add.fss

@@ -1,9 +1,11 @@
-let result =
+let (firstRaw, secondRaw) =
     match Env.Arguments with
-    | first :: second :: _ ->
-        match (Int.tryParse first, Int.tryParse second) with
-        | (Some firstValue, Some secondValue) -> firstValue + secondValue
-        | _ -> raise "Invalid arguments: 2 ints expected"
-    | _ -> raise "Required arguments: first second"
+    | first :: second :: _ -> (first, second)
+    | _ -> ("0", "0")
 
-result
+let (first, second) =
+    match (Int.tryParse firstRaw, Int.tryParse secondRaw) with
+    | (Some firstValue, Some secondValue) -> (firstValue, secondValue)
+    | _ -> raise "Invalid arguments: 2 ints expected"
+
+first + second

src/FScript.CSharpInterop/LanguageServer/LspSymbols.fs

@@ -120,13 +120,25 @@ module LspSymbols =
         let builtinSignatures =
             [ "ignore", "'a -> unit"
               "print", "string -> unit"
+              "Int.tryParse", "string -> int option"
+              "Float.tryParse", "string -> float option"
+              "Bool.tryParse", "string -> bool option"
+              "Int.toString", "int -> string"
+              "Float.toString", "float -> string"
+              "Bool.toString", "bool -> string"
               "nameof", "string -> string"
               "typeof", "string -> type" ]
             |> Map.ofList
 
         let builtinParamNames =
             [ "ignore", [ "value" ]
               "print", [ "message" ]
+              "Int.tryParse", [ "value" ]
+              "Float.tryParse", [ "value" ]
+              "Bool.tryParse", [ "value" ]
+              "Int.toString", [ "value" ]
+              "Float.toString", [ "value" ]
+              "Bool.toString", [ "value" ]
               "nameof", [ "name" ]
               "typeof", [ "name" ] ]
             |> Map.ofList
@@ -425,12 +437,40 @@ module LspSymbols =
                 match stmt with
                 | TypeInfer.TSLet (name, _, t, _, _, _) when name = targetName ->
                     Some t
+                | TypeInfer.TSLetPattern (_, _, bindings, _, _) ->
+                    bindings |> Map.tryFind targetName
                 | TypeInfer.TSLetRecGroup (bindings, _, _) ->
                     bindings
                     |> List.tryPick (fun (name, _, t, _) ->
                         if name = targetName then Some t else None)
                 | _ -> None)
 
+        let rec collectPatternNames (pat: Pattern) : string list =
+            match pat with
+            | PVar (name, _) -> [ name ]
+            | PCons (head, tail, _) -> collectPatternNames head @ collectPatternNames tail
+            | PTuple (items, _) -> items |> List.collect collectPatternNames
+            | PRecord (fields, _) -> fields |> List.collect (fun (_, p) -> collectPatternNames p)
+            | PMap (clauses, tailOpt, _) ->
+                let fromClauses =
+                    clauses
+                    |> List.collect (fun (k, v) -> collectPatternNames k @ collectPatternNames v)
+                let fromTail =
+                    match tailOpt with
+                    | Some tail -> collectPatternNames tail
+                    | None -> []
+                fromClauses @ fromTail
+            | PSome (inner, _) -> collectPatternNames inner
+            | PUnionCase (_, _, payload, _) ->
+                match payload with
+                | Some p -> collectPatternNames p
+                | None -> []
+            | PWildcard _
+            | PLiteral _
+            | PNil _
+            | PNone _
+            | PTypeRef _ -> []
+
         for stmt in program do
             match stmt with
             | SType _ ->
@@ -444,6 +484,16 @@ module LspSymbols =
                     | Some t -> result <- result |> Map.add name t
                     | None -> ()
                 | None -> ()
+            | SLetPattern (pattern, _, _, _) ->
+                let candidate = accepted @ [ stmt ]
+                match tryInferWithCurrent candidate with
+                | Some typed ->
+                    accepted <- candidate
+                    for name in collectPatternNames pattern do
+                        match extractTypeForName typed name with
+                        | Some t -> result <- result |> Map.add name t
+                        | None -> ()
+                | None -> ()
             | SLetRecGroup (bindings, _, _) ->
                 let candidate = accepted @ [ stmt ]
                 match tryInferWithCurrent candidate with
@@ -481,6 +531,7 @@ module LspSymbols =
             | SType _ ->
                 accepted <- accepted @ [ stmt ]
             | SLet _
+            | SLetPattern _
             | SLetRecGroup _ ->
                 let candidate = accepted @ [ stmt ]
                 match tryInferWithCurrent candidate with
@@ -529,6 +580,9 @@ module LspSymbols =
             | ELet (_, value, body, _, _) ->
                 let withValue = collectExpr acc value
                 collectExpr withValue body
+            | ELetPattern (_, value, body, _) ->
+                let withValue = collectExpr acc value
+                collectExpr withValue body
             | ELetRecGroup (bindings, body, _) ->
                 let withBindings =
                     bindings
@@ -586,13 +640,44 @@ module LspSymbols =
             | ETypeOf _
             | ENameOf _ -> acc
 
+        let rec collectPatternVarSpans (pat: Pattern) : (string * Span) list =
+            match pat with
+            | PVar (name, span) -> [ name, span ]
+            | PCons (head, tail, _) -> collectPatternVarSpans head @ collectPatternVarSpans tail
+            | PTuple (items, _) -> items |> List.collect collectPatternVarSpans
+            | PRecord (fields, _) -> fields |> List.collect (fun (_, p) -> collectPatternVarSpans p)
+            | PMap (clauses, tailOpt, _) ->
+                let fromClauses =
+                    clauses
+                    |> List.collect (fun (k, v) -> collectPatternVarSpans k @ collectPatternVarSpans v)
+                let fromTail =
+                    match tailOpt with
+                    | Some tail -> collectPatternVarSpans tail
+                    | None -> []
+                fromClauses @ fromTail
+            | PSome (inner, _) -> collectPatternVarSpans inner
+            | PUnionCase (_, _, payload, _) ->
+                match payload with
+                | Some p -> collectPatternVarSpans p
+                | None -> []
+            | PWildcard _
+            | PLiteral _
+            | PNil _
+            | PNone _
+            | PTypeRef _ -> []
+
         let withDeclsAndExprs =
             program
             |> List.fold (fun state stmt ->
                 match stmt with
                 | SLet (name, _, expr, _, _, span) ->
                     let withDecl = addOccurrence name span state
                     collectExpr withDecl expr
+                | SLetPattern (pattern, expr, _, _) ->
+                    let withDecls =
+                        collectPatternVarSpans pattern
+                        |> List.fold (fun inner (name, span) -> addOccurrence name span inner) state
+                    collectExpr withDecls expr
                 | SLetRecGroup (bindings, _, _) ->
                     bindings
                     |> List.fold (fun inner (name, _, expr, span) ->
@@ -861,6 +946,8 @@ module LspSymbols =
                     inScrutinee @ inCases
                 | ELet (_, value, body, _, _) ->
                     collectFieldVarUses fieldTypes value @ collectFieldVarUses fieldTypes body
+                | ELetPattern (_, value, body, _) ->
+                    collectFieldVarUses fieldTypes value @ collectFieldVarUses fieldTypes body
                 | ELetRecGroup (bindings, body, _) ->
                     let inBindings =
                         bindings
@@ -1007,6 +1094,10 @@ module LspSymbols =
             | ELet (name, value, body, _, span) ->
                 mkBinding name span (Ast.spanOfExpr body) None
                 :: (collectExprBindings value @ collectExprBindings body)
+            | ELetPattern (pattern, value, body, _) ->
+                let scope = Ast.spanOfExpr body
+                let fromPattern = collectPatternBindings scope pattern
+                fromPattern @ collectExprBindings value @ collectExprBindings body
             | ELetRecGroup (bindings, body, _) ->
                 let fromBindings =
                     bindings
@@ -1270,6 +1361,8 @@ module LspSymbols =
                 collectExpr (collectExpr acc source) body
             | ELet (_, value, body, _, _) ->
                 collectExpr (collectExpr acc value) body
+            | ELetPattern (_, value, body, _) ->
+                collectExpr (collectExpr acc value) body
             | ELetRecGroup (bindings, body, _) ->
                 let withBindings =
                     bindings |> List.fold (fun state (_, _, value, _) -> collectExpr state value) acc
@@ -1322,6 +1415,8 @@ module LspSymbols =
             match stmt with
             | SLet (_, _, expr, _, _, _) ->
                 collectExpr state expr
+            | SLetPattern (_, expr, _, _) ->
+                collectExpr state expr
             | SLetRecGroup (bindings, _, _) ->
                 bindings |> List.fold (fun inner (_, _, expr, _) -> collectExpr inner expr) state
             | SExpr expr ->
@@ -1388,6 +1483,8 @@ module LspSymbols =
                         collectExpr withGuard false body) withScrutinee
                 | ELet (_, value, body, _, _) ->
                     collectExpr (collectExpr acc false value) false body
+                | ELetPattern (_, value, body, _) ->
+                    collectExpr (collectExpr acc false value) false body
                 | ELetRecGroup (bindings, body, _) ->
                     let withBindings =
                         bindings |> List.fold (fun state (_, _, value, _) -> collectExpr state false value) acc

src/FScript.Language/Ast.fs

@@ -52,6 +52,7 @@ and Expr =
     | EFor of string * Expr * Expr * Span
     | EMatch of Expr * (Pattern * Expr option * Expr * Span) list * Span
     | ELet of string * Expr * Expr * bool * Span
+    | ELetPattern of Pattern * Expr * Expr * Span
     | ELetRecGroup of (string * Param list * Expr * Span) list * Expr * Span
     | EList of Expr list * Span
     | ERange of Expr * Expr * Span
@@ -84,6 +85,7 @@ and Stmt =
     | SType of TypeDef
     | SImport of string * string * Span
     | SLet of string * Param list * Expr * bool * bool * Span
+    | SLetPattern of Pattern * Expr * bool * Span
     | SLetRecGroup of (string * Param list * Expr * Span) list * bool * Span
     | SExpr of Expr
 
@@ -118,6 +120,7 @@ module Ast =
         | EFor (_, _, _, s) -> s
         | EMatch (_, _, s) -> s
         | ELet (_, _, _, _, s) -> s
+        | ELetPattern (_, _, _, s) -> s
         | ELetRecGroup (_, _, s) -> s
         | EList (_, s) -> s
         | ERange (_, _, s) -> s

src/FScript.Language/Eval.fs

@@ -481,6 +481,14 @@ module Eval =
                 let v = evalExpr typeDefs env value
                 let env' = env |> Map.add name v
                 evalExpr typeDefs env' body
+        | ELetPattern (pattern, value, body, span) ->
+            let v = evalExpr typeDefs env value
+            match patternMatch typeDefs pattern v with
+            | Some bindings ->
+                let env' = Map.fold (fun acc k value -> Map.add k value acc) env bindings
+                evalExpr typeDefs env' body
+            | None ->
+                raise (EvalException { Message = "Let pattern did not match value"; Span = span })
         | ELetRecGroup (bindings, body, span) ->
             if bindings.IsEmpty then
                 evalExpr typeDefs env body
@@ -736,6 +744,11 @@ module Eval =
         program
         |> List.tryPick (function
             | TypeInfer.TSLet(name, _, _, _, _, _) when Set.contains name reserved -> Some name
+            | TypeInfer.TSLetPattern(_, _, bindings, _, _) ->
+                bindings
+                |> Map.toList
+                |> List.tryFind (fun (name, _) -> Set.contains name reserved)
+                |> Option.map fst
             | TypeInfer.TSLetRecGroup(bindings, _, _) ->
                 bindings
                 |> List.tryFind (fun (name, _, _, _) -> Set.contains name reserved)
@@ -872,6 +885,13 @@ module Eval =
                 else
                     let v = evalExpr typeDefs env expr
                     env <- env |> Map.add name v
+            | TypeInfer.TSLetPattern(pattern, expr, _, _, span) ->
+                let v = evalExpr typeDefs env expr
+                match patternMatch typeDefs pattern v with
+                | Some bindings ->
+                    env <- Map.fold (fun acc k value -> Map.add k value acc) env bindings
+                | None ->
+                    raise (EvalException { Message = "Let pattern did not match value"; Span = span })
             | TypeInfer.TSLetRecGroup(bindings, _, span) ->
                 if bindings.IsEmpty then
                     ()

src/FScript.Language/IncludeResolver.fs

@@ -174,6 +174,7 @@ module IncludeResolver =
             statements
             |> List.collect (function
                 | SLet(name, _, _, _, _, _) -> [ name ]
+                | SLetPattern(pattern, _, _, _) -> collectPatternBindings pattern |> Set.toList
                 | SLetRecGroup(bindings, _, _) -> bindings |> List.map (fun (name, _, _, _) -> name)
                 | _ -> [])
             |> Set.ofList
@@ -229,6 +230,10 @@ module IncludeResolver =
                     ELet(name, rewriteExpr boundWithName valueExpr, rewriteExpr boundWithName bodyExpr, true, span)
                 else
                     ELet(name, rewriteExpr boundNames valueExpr, rewriteExpr (Set.add name boundNames) bodyExpr, false, span)
+            | ELetPattern (pattern, valueExpr, bodyExpr, span) ->
+                let rewrittenPattern = rewritePattern aliases selfPrefix topLevelTypeNames pattern
+                let boundWithPattern = Set.union boundNames (collectPatternBindings rewrittenPattern)
+                ELetPattern(rewrittenPattern, rewriteExpr boundNames valueExpr, rewriteExpr boundWithPattern bodyExpr, span)
             | ELetRecGroup (bindings, body, span) ->
                 let names = bindings |> List.map (fun (name, _, _, _) -> name) |> Set.ofList
                 let recursiveBound = Set.union boundNames names
@@ -316,6 +321,9 @@ module IncludeResolver =
                 let bound = rewrittenArgs |> List.fold (fun s p -> Set.add p.Name s) Set.empty
                 let bodyBound = if isRec then Set.add rewrittenName bound else bound
                 SLet(rewrittenName, rewrittenArgs, rewriteExpr bodyBound valueExpr, isRec, isExported, span)
+            | SLetPattern(pattern, valueExpr, isExported, span) ->
+                let rewrittenPattern = rewritePattern aliases selfPrefix topLevelTypeNames pattern
+                SLetPattern(rewrittenPattern, rewriteExpr Set.empty valueExpr, isExported, span)
             | SLetRecGroup(bindings, isExported, span) ->
                 let names = bindings |> List.map (fun (name, _, _, _) -> qualifySelfName name) |> Set.ofList
                 let rewrittenBindings =