chore: small fixes

Author: dbrattli

.vscode/settings.json

@@ -22,7 +22,9 @@
         "pyfile",
         "pyname",
         "Pyxpecto",
+        "Sergey",
         "stroustrup",
+        "Tihon",
         "xunit"
     ]
 }

chapters/AsyncProgramming.fs

@@ -76,11 +76,7 @@ F# async shines when composing multiple operations:
 
 let fetchMultipleAsync () =
     async {
-        let! results =
-            [ fetchDataAsync ()
-              fetchDataAsync ()
-              fetchDataAsync () ]
-            |> Async.Parallel
+        let! results = [ fetchDataAsync (); fetchDataAsync (); fetchDataAsync () ] |> Async.Parallel
 
         return results |> Array.toList
     }
@@ -182,8 +178,10 @@ let taskExample () =
 let taskWithLoop () =
     task {
         let mutable sum = 0
+
         for i in 1..10 do
             sum <- sum + i
+
         return sum
     }
 
@@ -279,16 +277,13 @@ Here's a pattern for async HTTP operations (assuming you have bindings for `aioh
 // Simulated async HTTP - in real code you'd use aiohttp bindings
 let fetchUrlAsync (url: string) =
     async {
-        do! Async.Sleep 100  // Simulates network delay
+        do! Async.Sleep 100 // Simulates network delay
         return $"Response from {url}"
     }
 
 let fetchMultipleUrls (urls: string list) =
     async {
-        let! responses =
-            urls
-            |> List.map fetchUrlAsync
-            |> Async.Parallel
+        let! responses = urls |> List.map fetchUrlAsync |> Async.Parallel
 
         return responses |> Array.toList
     }
@@ -302,18 +297,17 @@ Choose based on whether operations are independent:
 let sequentialProcessing items =
     async {
         let results = ResizeArray()
+
         for item in items do
             let! result = fetchUrlAsync item
             results.Add(result)
+
         return results |> Seq.toList
     }
 
 let parallelProcessing items =
     async {
-        let! results =
-            items
-            |> List.map fetchUrlAsync
-            |> Async.Parallel
+        let! results = items |> List.map fetchUrlAsync |> Async.Parallel
         return results |> Array.toList
     }
 
@@ -331,17 +325,18 @@ let cancellableWork (token: CancellationToken) =
             token.ThrowIfCancellationRequested()
             do! Async.Sleep 50
             printfn $"Step {i}"
+
         return "Completed"
     }
 
 let runWithTimeout () =
     async {
-        use cts = new CancellationTokenSource(2000)  // 2 second timeout
+        use cts = new CancellationTokenSource(2000) // 2 second timeout
+
         try
             let! result = cancellableWork cts.Token
             return Some result
-        with
-        | :? OperationCanceledException ->
+        with :? OperationCanceledException ->
             return None
     }
 
@@ -373,7 +368,11 @@ When working with Python frameworks that expect native async functions:
 let getItemTask (itemId: int) =
     task {
         do! Task.Delay 10
-        return {| id = itemId; name = "Widget" |}
+
+        return {|
+            id = itemId
+            name = "Widget"
+        |}
     }
 
 (**
@@ -399,11 +398,7 @@ When you need rich composition primitives:
 let complexWorkflow () =
     async {
         // Run three operations in parallel
-        let! results =
-            [ fetchDataAsync ()
-              fetchDataAsync ()
-              fetchDataAsync () ]
-            |> Async.Parallel
+        let! results = [ fetchDataAsync (); fetchDataAsync (); fetchDataAsync () ] |> Async.Parallel
 
         // Then do something sequential
         do! Async.Sleep 100

chapters/GettingStarted.fs

@@ -3,8 +3,7 @@ module GettingStarted
 (**
 # Getting Started with Fable.Python
 
-Let's set up a Fable.Python project from scratch and get our first F# code
-running as Python.
+Let's set up a Fable.Python project from scratch and get our first F# code running as Python.
 
 ## Prerequisites
 
@@ -27,7 +26,7 @@ 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.20
+dotnet tool install fable --version 5.0.0-alpha.21
 
 # Add Fable.Core package
 dotnet add package Fable.Core --version 5.0.0-beta.4
@@ -44,7 +43,7 @@ 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.0a20` format instead of `5.0.0-alpha.20`.
+your Fable compiler version. PyPI uses `5.0.0a21` format instead of `5.0.0-alpha.21`.
 
 ---
 
@@ -76,10 +75,10 @@ Transpile to Python:
 dotnet fable --lang python
 ```
 
-This creates `Program.py` in your project directory. Run it:
+This creates `program.py` in your project directory. Run it:
 
 ```bash
-python3 Program.py
+python3 program.py
 ```
 
 You should see:
@@ -106,7 +105,7 @@ After setup, your project looks like this:
 ```text
 my-fable-python/
 ├── Program.fs          # Your F# source code
-├── Program.py          # Generated Python (don't edit!)
+├── program.py          # Generated Python (don't edit!)
 ├── my-fable-python.fsproj
 ├── fable_modules/      # Fable runtime modules
 └── .config/

chapters/Interop.fs

@@ -214,6 +214,30 @@ let factorial (count: int) : int =
 """
 
 (**
+### Py.python for Literal Python Code
+
+`Py.python` provides a cleaner way to embed literal Python code without
+parameter placeholders. The code is printed as statements, so use Python's
+`return` keyword if you need to return a value:
+*)
+
+open Fable.Python
+
+let greet (name: string) : string =
+    Py.python
+        $"""
+    greeting = f"Hello, {{name}}!"
+    return greeting
+"""
+
+(** This generates: *)
+(*** include-python: greet ***)
+
+(**
+This is useful when you want to write a block of Python code directly,
+especially when it doesn't need parameter substitution (you can use F#
+string interpolation instead).
+
 ## StringEnum: Type-Safe String Constants
 
 `StringEnum` creates discriminated unions that compile to Python strings:

chapters/Introduction.fs

@@ -3,16 +3,17 @@ module Introduction
 (**
 # Introduction to Fable.Python
 
-> This post is part of the [F# Advent Calendar 2025](https://sergeytihon.com/2025/11/03/f-advent-calendar-in-english-2025/).
-Thank you, Sergey Tihon, for organizing this wonderful tradition that brings the F# community together every year!
+> This post is part of the [F# Advent Calendar
+2025](https://sergeytihon.com/2025/11/03/f-advent-calendar-in-english-2025/). Thank you, Sergey Tihon, for organizing
+this wonderful tradition that brings the F# community together every year!
 
 Welcome to this guide on [Fable.Python](https://github.com/fable-compiler/Fable.Python/) -
 a compiler that transforms F# code into Python.
 
 ## What is Fable?
 
-[Fable](https://fable.io/) is a compiler that brings F# to different platforms. While
-Fable is best known for compiling F# to JavaScript, it also supports other targets
+[Fable](https://fable.io/) is a compiler that brings F# to different platforms and ecosystems. While
+Fable is best known for compiling F# to TypeScript and JavaScript, it also supports other targets
 including Python, Rust, and Dart.
 
 ## Why Fable.Python?
@@ -26,9 +27,9 @@ F# is a functional-first language with powerful features like:
 
 With Fable.Python, you get all these benefits while targeting the Python ecosystem.
 
-Python is the [most popular programming language](https://www.tiobe.com/tiobe-index/)
-in the world. And no matter what you think of Python, it will always be the second
-best language for everything. That ubiquity is exactly why Fable.Python exists.
+Python is currently [the most popular programming language in the world](https://www.tiobe.com/tiobe-index/). And no
+matter what you think of Python, it will always be the second best language for everything. That ubiquity is exactly why
+Fable.Python exists.
 
 ## When to Use Fable.Python
 
@@ -68,12 +69,10 @@ When compiled with Fable, this generates the following Python:
 (*** include-python: greet, message ***)
 
 (**
-The `name: Any | None = None` signature may look odd at first. This happens because
-F# infers the type from usage - since we only call `greet` with a string, the compiler
-doesn't know if it might also be called with unit `()` (no argument). If it were,
-Python would call it as `greet()` instead of `greet("Fable.Python")`. Adding an
-explicit type annotation `let greet (name: string) = ...` would generate a cleaner
-`name: str` parameter.
+The `name: Any | None = None` signature may look odd at first. This happens because F# infers the type from usage -
+since we only call `greet` with a string, the compiler doesn't know if it might also be called with unit `()` (no
+argument). If it were, Python would call it as `greet()` instead of `greet("Fable.Python")`. Adding an explicit type
+annotation `let greet (name: string) = ...` would generate a cleaner `name: str` parameter.
 
 ## The Power of Types
 
@@ -94,16 +93,14 @@ let shapes = [ Circle 5.0; Rectangle(3.0, 4.0) ]
 let totalArea = shapes |> List.sumBy area
 
 (**
-This compiles to Python while preserving the semantic meaning. The `Shape` type
-becomes a tagged class structure, and the `match` expression becomes clean
-conditional logic. The compiler ensures you handle all cases - if you add a
-new shape variant, the compiler will warn you about unhandled cases in
-the `area` function.
+This compiles to Python while preserving the semantic meaning. The `Shape` type becomes a tagged class structure, and
+the `match` expression becomes clean conditional logic. The compiler ensures you handle all cases, i.e if you add a new
+shape variant, the compiler will warn you about unhandled cases in the `area` function.
 
 ## What's Next?
 
-In the following chapters, we'll explore setting up your environment,
-working with Python libraries, and understanding F# compatibility with Fable.
+In the following chapters, we'll explore setting up your environment, working with Python libraries, and understanding
+F# compatibility with Fable.
 
 Let's begin.
 *)

chapters/Pydantic.fs

@@ -98,16 +98,13 @@ type Product() =
     member val Name: string = "" with get, set
 
     // Field with description
-    member val Description: Field<string> =
-        Field.Description "Product description" with get, set
+    member val Description: Field<string> = Field.Description "Product description" with get, set
 
     // Field with numeric constraints
-    member val Price: Field<float> =
-        Field.Ge 0.0 with get, set  // price >= 0
+    member val Price: Field<float> = Field.Ge 0.0 with get, set // price >= 0
 
     // Field with string constraints
-    member val Sku: Field<string> =
-        Field.Pattern "^[A-Z]{2}-[0-9]{4}$" with get, set  // e.g., "AB-1234"
+    member val Sku: Field<string> = Field.Pattern "^[A-Z]{2}-[0-9]{4}$" with get, set // e.g., "AB-1234"
 
 (**
 Available field constraints:
@@ -165,6 +162,7 @@ let customer = Customer.create 1 "Alice" (Some "alice@example.com")
 
 let showCustomer (c: Customer) =
     printfn "Customer %d: %s" c.id c.name
+
     match c.email with
     | Some email -> printfn "  Email: %s" email
     | None -> printfn "  No email on file"
@@ -210,10 +208,10 @@ let serializationExample () =
     user.Email <- Some "alice@example.com"
 
     // Convert to dictionary
-    let dict = user.model_dump()
+    let dict = user.model_dump ()
 
     // Convert to JSON string
-    let json = user.model_dump_json()
+    let json = user.model_dump_json ()
 
     // Pretty-printed JSON
     let prettyJson = user.model_dump_json_indented 2
@@ -254,12 +252,15 @@ This distinction is important for well-architected applications:
 /// Domain model - uses precise F# types
 type UserId = UserId of System.Guid
 
-type Money = { Amount: decimal; Currency: string }
+type Money = {
+    Amount: decimal
+    Currency: string
+}
 
 type DomainUser = {
     Id: UserId
     Name: string
-    Age: int32           // Bounded, wrapping arithmetic
+    Age: int32 // Bounded, wrapping arithmetic
     Balance: Money
 }
 
@@ -282,7 +283,11 @@ Explicit transformation between domain and DTO:
 module UserMapping =
     let toDTO (user: DomainUser) : UserDTO =
         let dto = UserDTO()
-        dto.Id <- match user.Id with UserId guid -> string guid
+
+        dto.Id <-
+            match user.Id with
+            | UserId guid -> string guid
+
         dto.Name <- user.Name
         dto.Age <- int user.Age
         dto.BalanceAmount <- float user.Balance.Amount
@@ -292,7 +297,7 @@ module UserMapping =
     let fromDTO (dto: UserDTO) : Result<DomainUser, string> =
         try
             Ok {
-                Id = UserId (System.Guid.Parse dto.Id)
+                Id = UserId(System.Guid.Parse dto.Id)
                 Name = dto.Name
                 Age = int32 dto.Age
                 Balance = {

chapters/Python.fs

@@ -3,18 +3,16 @@ module ForPythonDevelopers
 (**
 # Are You a Python Developer?
 
-If you're coming from Python, welcome. This chapter will help you understand
-the F# code you'll see throughout this guide. F# is more approachable than
-it might appear, and many concepts are familiar.
+If you're coming from Python, welcome. This chapter will help you understand the F# code you'll see throughout this
+guide. F# is more approachable than it might appear, and many concepts are familiar.
 
 ## What is F#?
 
-F# is a functional-first language that runs on .NET. But here's the key insight
-for you: **with Fable.Python, .NET is just a build tool**. You write F#, it
-compiles to Python, and you run Python. Your deployment is pure Python.
+F# is a functional-first language that runs on .NET. But here's the key insight for you: **with Fable.Python, .NET is
+just a build tool**. You write F#, it compiles to Python, and you run Python. Your deployment is pure Python.
 
-Think of it like TypeScript for JavaScript - you get better tooling and type
-safety during development, but the output is the language you know.
+Think of it like TypeScript for JavaScript - you get better tooling and type safety during development, but the output
+is the language you know.
 
 ## Key Concepts You'll See