feat: Added new chapters

Author: dbrattli

.vscode/settings.json

@@ -1,5 +1,7 @@
 {
     "cSpell.words": [
+        "elif",
+        "fastapi",
         "Hashnode"
     ]
 }

README.md

@@ -12,6 +12,7 @@ This is a comprehensive guide to [Fable.Python](https://github.com/fable-compile
 4. **Compatibility** - Supported F# features and limitations
 5. **Fable v5** - What's new in Fable v5 for Python
 6. **Pydantic** - Pydantic interop with Decorate and ClassAttributes
+7. **Units of Measure** - Compile-time dimensional analysis
 
 ## The Meta Twist
 
@@ -55,7 +56,8 @@ chapters/
 ├── 03-bindings.fs          # Python interop
 ├── 04-compatibility.fs     # F# feature support
 ├── 05-fable-v5.fs          # What's new in Fable v5
-└── 06-pydantic.fs          # Pydantic interop
+├── 06-pydantic.fs          # Pydantic interop
+└── 07-units-of-measure.fs  # Dimensional analysis
 tools/
 ├── fabletext.fs            # Fabletext converter (F#)
 └── fabletext.fsproj

chapters/01-introduction.fs

@@ -22,11 +22,27 @@ F# is a functional-first language with powerful features like:
 - **Algebraic data types** - Model your domain precisely
 
 With Fable.Python, you get all these benefits while targeting the Python ecosystem.
-This means you can:
 
-1. Use F#'s type system and functional patterns
-2. Interop with Python libraries (NumPy, Pandas, etc.)
-3. Deploy anywhere Python runs - no .NET runtime needed
+## When to Use Fable.Python
+
+Fable.Python is a great choice when:
+
+- **Python ecosystem access** - You need AI/ML libraries (PyTorch, TensorFlow, LangChain),
+  data science tools (Pandas, NumPy), or frameworks like Pydantic and FastAPI
+- **F# type safety** - You want pattern matching and exhaustive checking while using
+  Python libraries
+- **Shared domain logic** - Write once in F#, run on .NET, JavaScript, Rust, and Python
+- **Publish to PyPI** - Your F# library can be available to the entire Python ecosystem
+- **Units of measure** - F#'s compile-time dimensional analysis prevents unit errors
+  that Python can't catch
+
+## When NOT to Use Fable.Python
+
+- When your F# code depends on .NET libraries without Fable support
+- Performance-critical code (Python is still slow)
+- Team won't learn F#
+
+**Best fit:** You love F#, but need Python's ecosystem.
 
 ## A Simple Example
 

chapters/07-units-of-measure.fs

@@ -0,0 +1,134 @@
+(**
+# Units of Measure
+
+One of F#'s most powerful features for scientific and engineering code is
+**units of measure** - compile-time dimensional analysis that prevents
+unit-related bugs.
+
+## The Problem
+
+Unit errors are a classic source of bugs. The famous Mars Climate Orbiter
+was lost because one team used metric units while another used imperial.
+Python can't catch these errors:
+
+```python
+# Python - no protection
+distance = 100  # meters? feet? who knows!
+time = 9.58     # seconds? minutes?
+speed = distance / time  # ???
+```
+
+## F# Units of Measure
+
+F# lets you annotate numeric types with units that are checked at compile time:
+*)
+
+(*** hide ***)
+module UnitsOfMeasure
+
+(**
+*)
+
+[<Measure>] type m      // meters
+[<Measure>] type s      // seconds
+[<Measure>] type kg     // kilograms
+
+(**
+Now we can define values with units:
+*)
+
+let distance = 100.0<m>
+let time = 9.58<s>
+let speed = distance / time  // Automatically inferred as float<m/s>
+
+(**
+The compiler tracks units through all operations. Division of meters by
+seconds gives meters-per-second. This is all checked at compile time!
+
+## Preventing Errors
+
+Try to add incompatible units and the compiler stops you:
+
+```fsharp
+let distance = 100.0<m>
+let mass = 50.0<kg>
+
+// This won't compile!
+// let nonsense = distance + mass
+// Error: The unit of measure 'm' does not match 'kg'
+```
+
+## Derived Units
+
+You can define derived units based on existing ones:
+*)
+
+[<Measure>] type N = kg * m / s^2   // Newton
+[<Measure>] type J = N * m          // Joule
+
+let force = 10.0<N>
+let displacement = 5.0<m>
+let work = force * displacement     // Inferred as float<J>
+
+(**
+## Real-World Example: Physics Simulation
+
+Here's a practical example computing kinetic energy:
+*)
+
+let kineticEnergy (mass: float<kg>) (velocity: float<m/s>) : float<J> =
+    0.5 * mass * velocity * velocity
+
+let carMass = 1500.0<kg>
+let carSpeed = 30.0<m/s>
+let energy = kineticEnergy carMass carSpeed
+
+(**
+The function signature clearly documents what units are expected and returned.
+The compiler ensures you can't accidentally pass velocity where mass is expected.
+
+## Unit Conversions
+
+Define conversion functions with explicit unit transformations:
+*)
+
+[<Measure>] type km
+[<Measure>] type h
+
+let metersToKm (d: float<m>) : float<km> = d / 1000.0<m/km>
+let secondsToHours (t: float<s>) : float<h> = t / 3600.0<s/h>
+
+let marathonDistance = 42195.0<m>
+let marathonKm = metersToKm marathonDistance  // 42.195<km>
+
+(**
+## Generated Python
+
+When compiled to Python, units are erased (they're purely a compile-time
+feature), but your code is guaranteed to be unit-safe:
+
+```python
+def kinetic_energy(mass: float, velocity: float) -> float:
+    return 0.5 * mass * velocity * velocity
+
+car_mass: float = 1500.0
+car_speed: float = 30.0
+energy: float = kinetic_energy(car_mass, car_speed)
+```
+
+The Python code is clean and efficient. All the unit checking happened
+at compile time in F#, so there's no runtime overhead.
+
+## Why This Matters for Python
+
+Python is widely used in scientific computing, but lacks compile-time
+unit checking. With Fable.Python, you can:
+
+1. **Write unit-safe code** in F# with full dimensional analysis
+2. **Catch unit errors at compile time** before they become runtime bugs
+3. **Generate clean Python** that integrates with NumPy, SciPy, etc.
+4. **Document intent** - function signatures show expected units
+
+This is especially valuable for physics simulations, financial calculations,
+engineering applications, and any domain where mixing up units could be costly.
+*)