fix: Handle multiline definitions

Author: dbrattli

chapters/compatibility.fs

@@ -8,8 +8,9 @@ from .NET when targeting Python with Fable.
 
 ## Common Types and Objects
 
-Some F#/.NET types have counterparts in Python. Fable takes advantage of this
-to compile to native types that are more performant and reduce code size.
+Some F#/.NET types have counterparts in Python. Fable takes advantage of
+this to compile to native types that are more performant and reduce code
+size. Native types also simplify interop with Python code and libraries.
 The most important common types are:
 
 |       F#/.NET Type       |  Python Type  |              Notes              |
@@ -20,7 +21,7 @@ The most important common types are:
 | `Tuple`                  | `tuple`       | Native Python tuple             |
 | `ResizeArray<T>`         | `list`        | Native Python list              |
 | `Dictionary<K,V>`        | `dict`        | Native Python dict              |
-| `seq<T>` / `IEnumerable` | iterator      | Uses `__iter__` protocol        |
+| `seq<T>` / `IEnumerable` | `Iterable`    | Uses `__iter__` protocol        |
 | `Array`                  | `FSharpArray` | Custom wrapper for F# semantics |
 
 ## .NET Base Class Library
@@ -46,7 +47,7 @@ Most FSharp.Core operators are supported, including formatting with `sprintf`,
 |      F# Type      |           Python           |
 | ----------------- | -------------------------- |
 | `Tuple`           | `tuple`                    |
-| `Option<T>`       | erased (see caveats)       |
+| `Option<T>`       | erased to `T \| None`      |
 | `string`          | `str`                      |
 | `List<T>`         | `List.fs` (immutable list) |
 | `Map<K,V>`        | `Map.fs` (immutable map)   |
@@ -235,6 +236,11 @@ let processed =
         squared)
 
 // Becomes a separate function in Python
+(**
+We can see that the mapping becomes a separate function in the generated Python code.
+*)
+
+(*** include-python: mapping, processed ***)
 
 (**
 ### Numeric Types
@@ -271,6 +277,12 @@ let wrapped: int = maxInt + 1 // Wraps around like .NET
 // bigint uses Python's native arbitrary-precision int
 let huge: bigint = 999999999999999999999999999999I
 
+(**
+This generates:
+*)
+
+(*** include-python: small, big, wrapped, huge ***)
+
 (**
 ### Computation Expressions
 
@@ -289,7 +301,8 @@ If your project has `[<EntryPoint>]`, you need:
 </PropertyGroup>
 ```
 
-This ensures absolute imports in generated Python.
+This ensures the use of absolute imports in generated Python. Applications
+in Python must use absolute imports to run correctly.
 
 ### Libraries
 
@@ -307,7 +320,7 @@ Libraries use relative imports by default, which is correct for packages.
 Fable.Python provides excellent F# support. The main things to watch for are:
 
 - Option erasure in edge cases
-- Multi-line lambda lifting
+- Multi-line lambda lifting, will not be anonymous
 - Some .NET APIs may be missing
 
 For most F# code, you can write idiomatic functional code and it will

chapters/getting-started.fs

@@ -26,24 +26,24 @@ dotnet new console -lang F#
 
 # Set up local tools and install Fable 5 (alpha)
 dotnet new tool-manifest
-dotnet tool install fable --version 5.0.0-alpha.17
+dotnet tool install fable --version 5.0.0-alpha.20
 
 # Add Fable.Core package
-dotnet add package Fable.Core --version 5.0.0-beta.2
+dotnet add package Fable.Core --version 5.0.0-beta.4
 ```
 
 ## Install Python Dependencies
 
 Fable-generated Python code requires the `fable-library` runtime:
 
 ```bash
-pip install "fable-library==5.0.0a17"
+pip install "fable-library==5.0.0a20"
 ```
 
 ---
 
 **Note:** Version pinning matters. The fable-library version must match
-your Fable compiler version. PyPI uses `5.0.0a17` format instead of `5.0.0-alpha.17`.
+your Fable compiler version. PyPI uses `5.0.0a20` format instead of `5.0.0-alpha.20`.
 
 ---
 

chapters/python.fs

@@ -205,7 +205,7 @@ unwrap the option first.
 | Dictionary       | `{"a": 1}`          | `Map.ofList [("a", 1)]`   |
 | None check       | `if x is None:`     | `match x with None ->`    |
 | String format    | `f"Hello {name}"`   | `$"Hello {name}"`         |
-| Type annotation  | `x: int`            | `x: int` (same!)          |
+| Type annotation  | `x: int`            | `x: int32`.               |
 | Comments         | `# comment`         | `// comment`              |
 | Multiline string | `"""text"""`        | `"""text"""` (same!)      |
 

docs/compatibility.md

@@ -5,8 +5,9 @@ from .NET when targeting Python with Fable.
 
 ## Common Types and Objects
 
-Some F#/.NET types have counterparts in Python. Fable takes advantage of this
-to compile to native types that are more performant and reduce code size.
+Some F#/.NET types have counterparts in Python. Fable takes advantage of
+this to compile to native types that are more performant and reduce code
+size. Native types also simplify interop with Python code and libraries.
 The most important common types are:
 
 |       F#/.NET Type       |  Python Type  |              Notes              |
@@ -17,7 +18,7 @@ The most important common types are:
 | `Tuple`                  | `tuple`       | Native Python tuple             |
 | `ResizeArray<T>`         | `list`        | Native Python list              |
 | `Dictionary<K,V>`        | `dict`        | Native Python dict              |
-| `seq<T>` / `IEnumerable` | iterator      | Uses `__iter__` protocol        |
+| `seq<T>` / `IEnumerable` | `Iterable`    | Uses `__iter__` protocol        |
 | `Array`                  | `FSharpArray` | Custom wrapper for F# semantics |
 
 ## .NET Base Class Library
@@ -43,7 +44,7 @@ Most FSharp.Core operators are supported, including formatting with `sprintf`,
 |      F# Type      |           Python           |
 | ----------------- | -------------------------- |
 | `Tuple`           | `tuple`                    |
-| `Option<T>`       | erased (see caveats)       |
+| `Option<T>`       | erased to `T \| None`      |
 | `string`          | `str`                      |
 | `List<T>`         | `List.fs` (immutable list) |
 | `Map<K,V>`        | `Map.fs` (immutable map)   |
@@ -96,6 +97,8 @@ is_enabled: bool = True
 coordinates: tuple[float64, float64] = (float64(10.5), float64(20.3))
 
 numbers: FSharpList[int32] = of_array(
+    Array[int32]([int32.ONE, int32.TWO, int32.THREE, int32.FOUR, int32.FIVE])
+)
 
 mutable_list: list[int32] = []
 ```
@@ -250,6 +253,15 @@ let processed =
 // Becomes a separate function in Python
 ```
 
+```python
+def mapping(x_1: int32) -> int32:
+    return x_1 * x_1
+
+processed: FSharpList[int32] = map(
+    mapping, of_array(Array[int32]([int32.ONE, int32.TWO, int32.THREE]))
+)
+```
+
 ### Numeric Types
 
 Numeric types in Fable.Python are implemented using custom PyO3 wrapper types

docs/fabletext.md

@@ -167,11 +167,14 @@ let flushCodeBuffer (ctx: ParseContext) : ParseContext =
 let mutable pythonFileContent: string option = None
 
 /// Checks if a line starts a new top-level definition (not indented).
+/// Excludes closing brackets which are continuation of previous definitions.
 let isTopLevelDefinition (line: string) : bool =
+    let trimmed = line.Trim()
     not (String.IsNullOrWhiteSpace line)
     && not (line.StartsWith " ")
     && not (line.StartsWith "\t")
     && not (line.StartsWith "#")
+    && not (trimmed = ")" || trimmed = "]" || trimmed = "}")
 
 /// Checks if a line is a decorator.
 let isDecorator (line: string) : bool =
@@ -221,7 +224,13 @@ let extractSymbol (symbol: string) (lines: string array) : string option =
             |> Option.defaultValue 0
 
         let defLine = lines[defIndex].TrimStart()
-        let isMultiline = defLine.StartsWith "class " || defLine.StartsWith "def "
+        // Multi-line if: class/def, or assignment ending with open paren/bracket
+        let isMultiline =
+            defLine.StartsWith "class "
+            || defLine.StartsWith "def "
+            || defLine.EndsWith "("
+            || defLine.EndsWith "["
+            || defLine.EndsWith "{"
 
         if not isMultiline then
             lines[defIndex]
@@ -373,8 +382,20 @@ def extract_symbol(symbol: str, lines: Array[str]) -> str | None:
         def_line: str = lines[def_index].lstrip()
         if not (
             True
-            if starts_with_exact(def_line, "class ")
-            else starts_with_exact(def_line, "def ")
+            if (
+                True
+                if (
+                    True
+                    if (
+                        True
+                        if starts_with_exact(def_line, "class ")
+                        else starts_with_exact(def_line, "def ")
+                    )
+                    else ends_with_exact(def_line, "(")
+                )
+                else ends_with_exact(def_line, "[")
+            )
+            else ends_with_exact(def_line, "{")
         ):
             return lines[def_index]
 

docs/python.md

@@ -196,7 +196,7 @@ unwrap the option first.
 | Dictionary       | `{"a": 1}`          | `Map.ofList [("a", 1)]`   |
 | None check       | `if x is None:`     | `match x with None ->`    |
 | String format    | `f"Hello {name}"`   | `$"Hello {name}"`         |
-| Type annotation  | `x: int`            | `x: int` (same!)          |
+| Type annotation  | `x: int`            | `x: int32`.               |
 | Comments         | `# comment`         | `// comment`              |
 | Multiline string | `"""text"""`        | `"""text"""` (same!)      |
 

tools/fabletext.fs

@@ -175,11 +175,14 @@ let flushCodeBuffer (ctx: ParseContext) : ParseContext =
 let mutable pythonFileContent: string option = None
 
 /// Checks if a line starts a new top-level definition (not indented).
+/// Excludes closing brackets which are continuation of previous definitions.
 let isTopLevelDefinition (line: string) : bool =
+    let trimmed = line.Trim()
     not (String.IsNullOrWhiteSpace line)
     && not (line.StartsWith " ")
     && not (line.StartsWith "\t")
     && not (line.StartsWith "#")
+    && not (trimmed = ")" || trimmed = "]" || trimmed = "}")
 
 /// Checks if a line is a decorator.
 let isDecorator (line: string) : bool =
@@ -229,7 +232,13 @@ let extractSymbol (symbol: string) (lines: string array) : string option =
             |> Option.defaultValue 0
 
         let defLine = lines[defIndex].TrimStart()
-        let isMultiline = defLine.StartsWith "class " || defLine.StartsWith "def "
+        // Multi-line if: class/def, or assignment ending with open paren/bracket
+        let isMultiline =
+            defLine.StartsWith "class "
+            || defLine.StartsWith "def "
+            || defLine.EndsWith "("
+            || defLine.EndsWith "["
+            || defLine.EndsWith "{"
 
         if not isMultiline then
             lines[defIndex]