Include a snippet on the power of .NET

_snippets/async_expressions.md

@@ -20,12 +20,12 @@
             return $"Validation error: {msg}"
     }
 
-    processPersonAsync { Name = "Snowdrop"; Age = 13}
+    processPersonAsync { Name = "Snowdrop"; Age = 13 }
     |> Async.RunSynchronously
 ---
 ## Async Programming made Easy
 
 F# async expressions provide a powerful way to handle asynchronous programming, making it more readable and maintainable. They allow you to write non-blocking code that looks like synchronous code, which is particularly useful for I/O-bound operations.
 <!--more-->
 - **Async expressions** provide a clean syntax for defining asynchronous workflows
 - **Integration with existing libraries** makes it easy to use async expressions with other F# features

_snippets/dotnet_ecosystem.md

@@ -0,0 +1,27 @@
+---
+order: 1
+title: DotNet.fs
+excerpt_separator: <!--more-->
+code: |
+    // Example: Extracting information from text with regular expressions
+    open System.Text.RegularExpressions
+    let input = "Emails: [email protected], [email protected], invalid-email"
+    let pattern = @"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b"
+    for matched in Regex.Matches(input, pattern) do
+        printfn $"Found email: {matched.Value}" // [email protected] and [email protected]
+
+    // Example: Image processing
+    open SixLabors.ImageSharp // NuGet package: SixLabors.ImageSharp
+    open SixLabors.ImageSharp.Processing
+    use image = Image.Load "input.png"
+    image.Mutate(_.Resize(300, 200).Flip(FlipMode.Horizontal ||| FlipMode.Vertical) >> ignore)
+    image.Save "output.jpg"
+    ---
+
+## Full access to .NET ecosystem
+
+F# has seamless .NET integration which lets you work with existing .NET libraries and frameworks. Anything written in C# can be used from F# and vice versa.
+<!--more-->
+- **[Web](https://dotnet.microsoft.com/en-us/apps/aspnet), [Mobile](https://dotnet.microsoft.com/en-us/apps/maui), [Desktop](https://dotnet.microsoft.com/en-us/apps/desktop), [Cloud](https://dotnet.microsoft.com/en-us/apps/cloud), [Microservices](https://dotnet.microsoft.com/en-us/apps/aspnet/microservices), [Artificial Intelligence](https://dotnet.microsoft.com/en-us/apps/ai), [Game Development](https://dotnet.microsoft.com/en-us/apps/games), and [Internet of Things](https://dotnet.microsoft.com/en-us/apps/iot)** frameworks are ready to be used.
+- [**NuGet packages**](https://www.nuget.org), all hundreds of thousands of them, reduce your code complexity.
+- **Mixing C# and F#** in the same solution is possible for incremental adoption.

_snippets/fable.md

@@ -32,11 +32,11 @@
 ---
 ## F# for JavaScript and the Full Stack
 
-F# is for both client and server. With [F# web technologies]({{ '/use/web-apps/' | relative_url }}), you can target JavaScript environments directly. This means you can use F# to build web applications, mobile apps, and even serverless functions that run in the cloud.
+F# is for both client and server. With [F# web technologies]({{ '/use/web-apps/' | relative_url }}), you can target JavaScript environments directly without including the rest of .NET. This means you can use F# across both frontend and backend to build web applications, mobile apps, and even serverless functions that run in the cloud.
 <!--more-->
 - **Type-safe DOM manipulation** catches errors at compile time, not runtime
 - **Seamless React integration** with hooks and modern patterns
 - **Full npm ecosystem access** with clean TypeScript-like interop
 - **Simplified async programming** with F#'s computation expressions for promises
 
 F# brings its powerful type system and immutability to frontend development, eliminating common JavaScript bugs while maintaining full access to the JavaScript ecosystem.

_snippets/oop.md

@@ -40,9 +40,8 @@
 ---
 ## Objects Made Simple
 
 F# is **functional first** and **immutable by default**, but it also provides pragmatic support for object programming.
 <!--more-->
-- **Seamless .NET integration** lets you work with existing .NET libraries and frameworks
 - **Rich interface system** allows you to define clear contracts for your components
 - **Object expressions** provide lightweight implementation of interfaces without defining full classes
 - **Concise member syntax** keeps methods and properties clean and readable

_snippets/sequence_expressions.md

@@ -3,11 +3,13 @@ order: 15
 title: SequenceExpressions.fs
 excerpt_separator: <!--more-->
 code: |
+    // This is an active pattern. It allows customized pattern matching.
+    let (|Divides|_|) divisor x = x % divisor = 0
     let rec fizzBuzzSeq n = seq {
         match n with
-        | x when x % 15 = 0 -> "fizzbuzz"
-        | x when x % 3 = 0 -> "fizz"
-        | x when x % 5 = 0 -> "buzz"
+        | Divides 15 -> "fizzbuzz"
+        | Divides 3 -> "fizz"
+        | Divides 5 -> "buzz"
         | _ -> n.ToString()
 
         // Tail recursion makes this as efficient as a "while" loop

_snippets/typeproviders.md

@@ -3,7 +3,7 @@ order: 14
 title: TypeProviders.fs
 excerpt_separator: <!--more-->
 code: |
-    open FSharp.Data
+    open FSharp.Data // NuGet package: FSharp.Data
 
     type PeopleDB = CsvProvider<"people.csv">