F# on Brian Braatz Blog

F# in a Nutshell

Wed, 14 Sep 2016 00:00:00 +0000

What is F#?

F# is a functional-first programming language that runs on .NET.

It’s like that one friend who insists on doing everything in a more “mathematically pure” way while the rest of your group happily hacks away in imperative C#.

Why Should You Care About F#?

Concise and Expressive – F# lets you do more with less code. No more endless curly braces and semicolons. Just pure, readable beauty.
Immutability by Default – In F#, variables are immutable unless you explicitly make them mutable. This means fewer bugs due to unintended side effects.
Pattern Matching – This is where F# really shines. Instead of writing a dozen if-else statements, you can elegantly destructure data with pattern matching.
Interoperability – It runs on .NET, so you can use all your favorite C# libraries if you must.
It Makes You Look Smart – Let’s be honest, telling people you code in a functional language makes you sound 10x more intelligent.

A Taste of F#

Let’s take a look at some basic F# code and how it compares to C#.

Hello, Functional World!

1

printfn "Hello, F#!"

Compare that to the C# version:

1
2
3
4
5
6


using System;
class Program {
 static void Main() {
 Console.WriteLine("Hello, F#!");
 }
}

F# wins on brevity.

Functions in F#

1
2


let square x = x * x
printfn "%d" (square 5) // Prints 25

That’s it. No return types, no explicit public static nonsense. Just clean, pure function definition.

Pattern Matching Magic

1
2
3
4
5
6
7


let describeNumber x =
 match x with
 | 0 -> "Zero"
 | 1 -> "One"
 | _ -> "Something else"

printfn "%s" (describeNumber 42) // Prints "Something else"

Tell me that doesn’t look cleaner than a bunch of if-statements!

When to Use F#

F# isn’t for everything, but it shines in:

Data Science and Analytics – It has great libraries for numerical computing.
Finance – Banks love F# for its precision and reliability.
Domain-Driven Design – Functional programming fits well with event-driven architectures.
Writing Less Code – If you’re tired of boilerplate and just want to get stuff done.

When Not to Use F#

If You Hate Indentation-Based Syntax – F# relies on whitespace, so if you’re a {} fanatic, you might struggle.
If You Live in the C# World – If your team is all-in on C#, switching to F# might be more pain than it’s worth.
If You Need to Work With GUI Apps – F# is better suited for backend work.

The Future of F#

F# isn’t going anywhere. It’s actively developed and maintained, with strong support from Microsoft and the open-source community. Plus, with .NET evolving rapidly, F# is only getting better.

If you haven’t tried F# yet, give it a shot. Worst case? You learn something new. Best case? You discover your new favorite language.

Key Ideas

Concept	Summary
Functional Programming	F# is a functional-first language on .NET.
Concise Syntax	Less boilerplate compared to C#.
Immutability	Variables are immutable by default.
Pattern Matching	A powerful alternative to if-else chains.
Interoperability	F# works seamlessly with .NET libraries.
Use Cases	Great for data science, finance, and DDD.

References

F# Code Snippets

Wed, 14 Sep 2016 00:00:00 +0000

Common F# Code Snippets

1. Printing to the Console

1

printfn "Hello, world!"

No need for Console.WriteLine, just a simple printfn and you’re done!

2. Defining a Function

1
2


let square x = x * x
printfn "%d" (square 5) // Outputs: 25

Functions are first-class citizens in F#, and defining one is a breeze.

3. Piping Data (`|>` Operator)

1
2
3


let square x = x * x
let result = 5 |> square |> string
printfn "%s" result // Outputs: "25"

Piping makes function composition elegant and clean.

4. Pattern Matching

1
2
3
4
5
6
7


let describeNumber x =
 match x with
 | 0 -> "Zero"
 | 1 -> "One"
 | _ -> "Something else"

printfn "%s" (describeNumber 42) // Outputs: "Something else"

Forget those clunky if-else chains. Pattern matching is the way to go!

5. List Comprehensions

1
2
3


let numbers = [1..5]
let squaredNumbers = [for n in numbers -> n * n]
printfn "%A" squaredNumbers // Outputs: [1; 4; 9; 16; 25]

Simple, readable, and efficient.

6. Recursive Functions

1
2
3
4
5


let rec factorial n =
 if n <= 1 then 1
 else n * factorial (n - 1)

printfn "%d" (factorial 5) // Outputs: 120

Because recursion is the functional way!

7. Tuples and Destructuring

1
2
3


let person = ("Alice", 30)
let (name, age) = person
printfn "%s is %d years old." name age

Tuple unpacking makes handling grouped data a breeze.

8. Records (Lightweight Data Structures)

1
2
3


type Person = { Name: string; Age: int }
let bob = { Name = "Bob"; Age = 25 }
printfn "%A" bob // Outputs: { Name = "Bob"; Age = 25 }

Simple, structured data without the C# verbosity.

9. Option Type (No More Nulls!)

1
2
3
4
5
6
7


let divide a b =
 if b = 0 then None
 else Some (a / b)

match divide 10 2 with
| Some result -> printfn "Result: %d" result
| None -> printfn "Cannot divide by zero!"

F# says “nope” to nulls, and we love it.

10. Asynchronous Code

1
2
3
4
5
6
7
8


open System.Threading.Tasks

let asyncExample = async {
 do! Async.Sleep 1000
 printfn "Task Complete!"
}

Async.Start asyncExample

11. Sequences (Lazy Evaluation)

1
2


let infiniteNumbers = Seq.initInfinite (fun x -> x * x)
printfn "%A" (infiniteNumbers |> Seq.take 5 |> Seq.toList) // Outputs: [0; 1; 4; 9; 16]

Need an infinite list but don’t want to destroy your RAM? Sequences to the rescue!

12. Higher-Order Functions

1
2
3


let applyTwice f x = f (f x)
let double x = x * 2
printfn "%d" (applyTwice double 3) // Outputs: 12

Functions that take functions and return functions? Welcome to functional programming!

13. Discriminated Unions

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


type Shape =
 | Circle of float
 | Rectangle of float * float

let area shape =
 match shape with
 | Circle r -> System.Math.PI * r * r
 | Rectangle (w, h) -> w * h

printfn "Circle area: %f" (area (Circle 5.0)) // Outputs: Circle area: 78.54

A clean and powerful way to model data variations.

14. Using the `map` Function

1
2
3


let numbers = [1..5]
let squared = numbers |> List.map (fun x -> x * x)
printfn "%A" squared // Outputs: [1; 4; 9; 16; 25]

Apply a function to every element of a list with zero fuss.

15. Folding (Reduce in Other Languages)

1
2


let sum = List.fold (fun acc x -> acc + x) 0 [1..5]
printfn "%d" sum // Outputs: 15

Folding is just a fancy way of saying “reduce everything to a single value.”

16. Working with Dictionaries

1
2


let dict = dict ["one", 1; "two", 2; "three", 3]
printfn "%d" (dict.["two"]) // Outputs: 2

Need key-value pairs? Dictionaries got you covered.

17. Using `try...with` for Exception Handling

1
2
3
4
5
6
7
8
9


let safeDivide a b =
 try
 Some (a / b)
 with
 | :? System.DivideByZeroException -> None

match safeDivide 10 0 with
| Some result -> printfn "Result: %d" result
| None -> printfn "Oops! Division by zero."

Because sometimes, life (and division) throws you an error.

18. Using `async` Workflows

1
2
3
4
5
6


let asyncJob = async {
 do! Async.Sleep 1000
 printfn "Done sleeping!"
}

Async.Start asyncJob

Non-blocking, super clean asynchronous programming.

19. Partial Application

1
2
3


let multiply x y = x * y
let double = multiply 2
printfn "%d" (double 10) // Outputs: 20

Fix arguments ahead of time for ultimate function reusability!

20. Using `Seq.filter` for Filtering Data

1
2
3


let numbers = [1..10]
let evens = numbers |> List.filter (fun x -> x % 2 = 0)
printfn "%A" evens // Outputs: [2; 4; 6; 8; 10]

Elegant, readable, and functional filtering.

21. Function Composition (`>>` Operator)

1
2
3
4
5


let add2 x = x + 2
let multiply3 x = x * 3
let addThenMultiply = add2 >> multiply3

printfn "%d" (addThenMultiply 4) // Outputs: 18

Think of >> as piping without explicit arguments. Super clean!

22. Defining Custom Operators

1
2


let (++) x y = x + y * 2
printfn "%d" (5 ++ 3) // Outputs: 11

Why use boring old operators when you can make your own?

23. Using the `yield` Keyword in Sequences

1
2
3
4
5
6


let numbers = seq {
 yield 1
 yield 2
 yield! [3; 4; 5]
}
printfn "%A" (numbers |> Seq.toList) // Outputs: [1; 2; 3; 4; 5]

yield! lets you expand another sequence inside your own.

24. Type Providers for Easy Data Access

1
2
3
4
5
6
7
8


#r "nuget: FSharp.Data"
open FSharp.Data

let csv = CsvProvider<"Name,Age\nAlice,30\nBob,25">
let data = csv.GetSample()

for row in data.Rows do
 printfn "%s is %d years old" row.Name row.Age

Type providers give you strongly-typed access to external data. No manual parsing required!

25. Asynchronous Parallel Computation

1
2
3
4
5
6
7


open System.Threading.Tasks

let task1 = async { return 5 }
let task2 = async { return 10 }
let combined = Async.Parallel [task1; task2]

Async.RunSynchronously combined |> printfn "%A" // Outputs: [|5; 10|]

Run multiple async tasks in parallel like a pro.

26. Memoization (Caching Function Results)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


let memoize f =
 let cache = System.Collections.Generic.Dictionary<_, _>()
 fun x ->
 if cache.ContainsKey(x) then cache.[x]
 else
 let result = f x
 cache.[x] <- result
 result

let expensiveComputation = memoize (fun x -> x * x * x)
printfn "%d" (expensiveComputation 10) // Outputs: 1000

Memoization = automatic caching for expensive functions.

27. Active Patterns for Smart Matching

1
2
3
4
5
6
7
8


let (|Even|Odd|) x = if x % 2 = 0 then Even else Odd

let describeNumber x =
 match x with
 | Even -> "Even number"
 | Odd -> "Odd number"

printfn "%s" (describeNumber 5) // Outputs: Odd number

Active patterns let you create custom match cases for cleaner logic.

28. Infinite Lazy Sequences

1
2
3
4
5


let rec fibs a b = seq {
 yield a
 yield! fibs b (a + b)
}
printfn "%A" (fibs 0 1 |> Seq.take 10 |> Seq.toList)

Lazy evaluation lets you generate infinite sequences without crashing your machine.

29. Using `MailboxProcessor` for Actor-Based Concurrency

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


let agent = MailboxProcessor.Start(fun inbox ->
 let rec loop () = async {
 let! msg = inbox.Receive()
 printfn "Received: %s" msg
 return! loop()
 }
 loop()
)

agent.Post "Hello, F#"

MailboxProcessor is a great way to handle message-based concurrency.

30. Dependency Injection with Partial Application

1
2
3
4
5
6
7


let log message = printfn "Log: %s" message
let add x y = x + y
let addWithLogging = fun x y ->
 log (sprintf "Adding %d and %d" x y)
 add x y

printfn "%d" (addWithLogging 3 7) // Outputs: Log: Adding 3 and 7, then 10

Inject dependencies (like logging) into your functions using partial application.

F# on Brian Braatz Blog

F# in a Nutshell

What is F#?

Why Should You Care About F#?

A Taste of F#

Hello, Functional World!

Functions in F#

Pattern Matching Magic

When to Use F#

When Not to Use F#

The Future of F#

Key Ideas

References

F# Code Snippets

Common F# Code Snippets

1. Printing to the Console

2. Defining a Function

3. Piping Data (|> Operator)

4. Pattern Matching

5. List Comprehensions

6. Recursive Functions

7. Tuples and Destructuring

8. Records (Lightweight Data Structures)

9. Option Type (No More Nulls!)

10. Asynchronous Code

11. Sequences (Lazy Evaluation)

12. Higher-Order Functions

13. Discriminated Unions

14. Using the map Function

15. Folding (Reduce in Other Languages)

16. Working with Dictionaries

17. Using try...with for Exception Handling

18. Using async Workflows

19. Partial Application

20. Using Seq.filter for Filtering Data

21. Function Composition (>> Operator)

22. Defining Custom Operators

23. Using the yield Keyword in Sequences

24. Type Providers for Easy Data Access

25. Asynchronous Parallel Computation

26. Memoization (Caching Function Results)

27. Active Patterns for Smart Matching

28. Infinite Lazy Sequences

29. Using MailboxProcessor for Actor-Based Concurrency

30. Dependency Injection with Partial Application

References

3. Piping Data (`|>` Operator)

14. Using the `map` Function

17. Using `try...with` for Exception Handling

18. Using `async` Workflows

20. Using `Seq.filter` for Filtering Data

21. Function Composition (`>>` Operator)

23. Using the `yield` Keyword in Sequences

29. Using `MailboxProcessor` for Actor-Based Concurrency