F#: Functional Programming on the .NET Platform

F# is a functional-first language on the .NET platform, developed by Microsoft Research and now maintained by the .NET Foundation. It combines the expressiveness of functional programming with the full power and ecosystem of .NET, making it suitable for everything from data analysis and scientific computing to web services and business applications. F# is concise, type-safe, and productive — studies have shown that F# codebases are typically 50-70% smaller than equivalent C# implementations, a finding documented in the academic paper “Evidence-Based Software Engineering” by the F# team at Microsoft Research.

This guide provides a comprehensive introduction to F#, covering its functional features, unique capabilities, and practical applications in production environments.

Functional-First Design

F# defaults to immutability and functional patterns. Values are immutable by default, functions are first-class citizens, and the language encourages a declarative, expression-based style. Unlike Haskell, F# is not purely functional — it supports object-oriented and imperative styles when needed — but the functional approach is idiomatic and rewarded by the language design.

let name = "Alice"

let add x y = x + y
let result = add 3 4

let applyTwice f x = f (f x)
let double x = x * 2
applyTwice double 5

Expression-Oriented Programming

In F#, nearly everything is an expression that returns a value. if expressions, match expressions, and even try blocks all produce values:

let description = 
    if age >= 18 then "Adult"
    else "Minor"

let category = 
    match score with
    | x when x >= 90 -> "Excellent"
    | x when x >= 70 -> "Good"
    | _ -> "Needs improvement"

This expression-oriented design eliminates entire categories of bugs related to missing branches or early returns. Every code path must return a value, and the compiler enforces this consistently. This is a stark contrast to languages where if is a statement that produces no value, requiring mutable variables to capture results.

Type Inference

F# has powerful type inference based on Hindley-Milner type inference, the same system used by Haskell and ML. The compiler deduces types from usage, keeping code concise while maintaining full type safety:

let message = "Hello, F#!"
let pi = 3.14159
let numbers = [1; 2; 3; 4; 5]
let add x y = x + y

let addExplicit (x: int) (y: int) : int = x + y

Type inference works across modules and projects, so you rarely need to write explicit type annotations except at public API boundaries or when the compiler cannot resolve the type. This combination of type safety and conciseness is one of F#’s most appreciated features — you get the safety of static typing with the brevity of a dynamic language.

Discriminated Unions

Discriminated unions (DUs) are one of F#’s most powerful features. They model data that can take different forms, each with potentially different associated data:

type Shape =
    | Circle of radius: float
    | Rectangle of width: float * height: float
    | Triangle of base: float * height: float

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

let myShape = Circle 5.0
printfn "Area: %f" (area myShape)

The compiler enforces exhaustive matching — if you add a new case to Shape, every match expression that handles Shape values will produce a compiler warning until you handle the new case. This eliminates the runtime errors that occur when code paths are accidentally unhandled. This is the principle Scott Wlaschin calls “making illegal states unrepresentable” in his book “Domain Modeling Made Functional.”

Single-Case Discriminated Unions

A particularly useful pattern is the single-case discriminated union, which creates a distinct type from a primitive:

type Email = Email of string
type UserId = UserId of int

This prevents mixing up values of the same underlying type — a UserId cannot accidentally be passed where an Email is expected, even though both are wrappers around primitives. This adds a layer of type safety with zero runtime overhead.

Pattern Matching

Pattern matching in F# goes far beyond simple value matching. It supports destructuring, guards, nested patterns, and active patterns for custom matching logic:

let describePerson person =
    match person with
    | { Name = "Alice"; Age = age } when age < 18 ->
        "Young Alice"
    | { Name = "Alice" } -> "Adult Alice"
    | { Name = name; Age = age } when age < 18 ->
        sprintf "Young %s" name
    | { Name = name } -> sprintf "Adult %s" name

Pattern matching can also destructure tuples, lists, arrays, and discriminated unions in a single unified syntax:

let rec sumList nums =
    match nums with
    | [] -> 0
    | head :: tail -> head + sumList tail

Active Patterns

Active patterns let you define custom pattern matching logic. They are functions that return a choice of shape values, making pattern matching extensible:

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

let describeNumber n =
    match n with
    | Even -> "Even"
    | Odd -> "Odd"

Active patterns can have multiple cases and can carry extracted values, making them a powerful tool for domain-specific pattern matching.

Type Providers

Type providers are a unique F# feature that generates strongly typed access to external data at compile time. They work with databases, web services, JSON, CSV, XML, and more:

type dbSchema = SqlDataConnection<"Data Source=.;Initial Catalog=MyDb;Integrated Security=SSPI">

let db = dbSchema.GetDataContext()
let users = query {
    for user in db.Users do
    where (user.Age >= 18)
    select user
---

Type providers catch schema mismatches at compile time. If a database column is renamed or a JSON field changes type, your code breaks during compilation — not at runtime. This shifts error detection dramatically earlier in the development cycle. Don Syme, the creator of F#, has described type providers as one of the language’s most innovative features, fundamentally changing how developers interact with external data sources.

Pipelines and Composition

The pipe operator |> passes the result of one expression to the next function, creating readable data pipelines:

let processUsers users =
    users
    |> List.filter (fun u -> u.Active)
    |> List.map (fun u -> u.Name)
    |> String.concat ", "

let squareAndDouble = square >> double

The forward composition operator >> creates new functions by chaining existing ones, enabling point-free style where data flows through composed transformations.

Asynchronous Programming

F# has built-in support for asynchronous programming with computation expressions — the async workflow:

let fetchUrlAsync (url: string) = async {
    let client = new System.Net.Http.HttpClient()
    let! response = client.GetStringAsync(url) |> Async.AwaitTask
    return response.Length
---

let urls = ["https://example.com"; "https://dotnet.microsoft.com"]

let totalLength = 
    urls
    |> List.map fetchUrlAsync
    |> Async.Parallel
    |> Async.RunSynchronously
    |> Array.sum

The async workflow provides cancellation support, structured concurrency, and seamless interop with .NET’s Task-based asynchronous model. The let! keyword asynchronously awaits a value, while Async.Parallel runs multiple async computations concurrently.

.NET Ecosystem and Interop

F# runs on .NET, giving you access to the entire NuGet ecosystem. You can use any .NET library from F#, interoperate with C# and VB.NET projects in the same solution, and build web applications with ASP.NET Core, machine learning models with ML.NET, and data pipelines with the full .NET data stack.

Computation Expressions for Custom Workflows

Computation expressions are F#’s mechanism for defining custom control flows. The async computation expression is built into the language, but you can define your own for workflows like logging, validation, or probabilistic programming:

type LoggingBuilder() =
    member this.Bind(x, f) =
        printfn "Value: %A" x
        f x
    member this.Return(x) =
        printfn "Return: %A" x
        x

let logger = LoggingBuilder()

let loggedWorkflow = logger {
    let! x = 42
    let! y = x + 10
    return y * 2
---

Units of Measure

F# has built-in support for units of measure, catching dimensional analysis errors at compile time:

[<Measure>] type m
[<Measure>] type s
[<Measure>] type kg

let distance = 100.0<m>
let time = 9.58<s>
let speed = distance / time

Units of measure are particularly valuable in scientific computing, engineering, and financial applications where dimensional errors have real-world consequences. NASA’s Mars Climate Orbiter disaster, caused by a unit mismatch, is a cautionary tale that F#’s type system could have prevented.

FAQ

Is F# suitable for web development?

Yes. ASP.NET Core has excellent F# support, and the SAFE stack (Saturn, Azure, F#, Elmish) provides a full-stack functional web development experience. Giraffe is a functional-first ASP.NET Core web framework for F# that offers composable HTTP handlers.

How does F# compare to C# for .NET development?

F# produces more concise code (typically 50-70% less), has better type inference, and provides powerful functional features like discriminated unions and pattern matching. C# has broader industry adoption, more third-party libraries, and is better suited for large OOP-focused teams. Many projects use both — F# for core logic and C# for infrastructure.

Does F# support object-oriented programming?

Yes. F# supports classes, interfaces, inheritance, and polymorphism — all the standard OOP features. However, the functional approach is idiomatic, and mixing paradigms should be done deliberately.

What are type providers used for?

Type providers generate strongly typed access to external data sources at compile time. Common uses include database access (SQL Provider), JSON/XML parsing, CSV file reading, and web service consumption. They eliminate the need for code generation tools or runtime mapping layers.

Conclusion

F# combines the expressiveness of functional programming with the reach of .NET. Discriminated unions, pattern matching, type providers, pipeline operators, and async workflows make F# concise, safe, and productive. Whether you are building web services, data pipelines, or business applications, F# offers a type-safe environment on a mature, cross-platform runtime.

For foundational functional concepts, see Functional Programming Basics and Immutability Guide.