F# Guide — What is F#? Functional-First .NET Language

In this tutorial, you will learn about F# Guide. We cover key concepts, practical examples, and best practices to help you master this topic.

F# is a functional-first programming language on the .NET platform that combines the expressiveness of functional programming with the power and reach of the .NET ecosystem -- enabling concise, correct, and performant code.

What You'll Learn

• The history and design of F#
• Immutability by default and type inference
• Discriminated unions and pattern matching
• .NET interop and async workflows

Why It Matters

F# brings the rigor of functional programming to .NET -- used for financial modeling, data science, web services, and cross-platform applications. DodaZIP uses F# for compression algorithm configuration where immutable data prevents subtle threading bugs.

Real-World Use

Morgan Stanley and Credit Suisse use F# for trading systems. Jet.com uses F# for pricing algorithms. Microsoft uses F# in Azure services. F# type providers let you consume SQL, JSON, and CSV with compiler-checked schemas.

flowchart LR
    A["What is F#?"] --> B[".NET Setup"]
    B --> C["Let Bindings"]
    C --> D["Functions"]
    D --> E["Discriminated Unions"]
    A:::current --> B
    style A fill:#2563eb,stroke:#2563eb,color:#fff
    style B fill:#dbeafe,stroke:#2563eb,color:#1e40af
    style C fill:#dbeafe,stroke:#2563eb,color:#1e40af
    style D fill:#dbeafe,stroke:#2563eb,color:#1e40af
    style E fill:#f1f5f9,stroke:#94a3b8,color:#64748b

The History of F#

F# originated at Microsoft Research in 2005, developed by Don Syme. It's a member of the ML family (like OCaml) but with .NET integration.

Key milestones:

• 2005: F# 1.0 (Microsoft Research)
• 2010: F# 2.0 -- shipped with Visual Studio
• 2014: F# 3.1 -- type providers
• 2016: F# 4.0 -- open source
• 2021: F# 6.0 -- task expressions, better tooling
• 2023+: F# 7+ -- continued .NET integration

Immutability by Default

// Immutable binding
let x = 10
// x <- 20  // ERROR

// Mutable (explicit)
let mutable y = 10
y <- 20  // OK

Discriminated Unions

type PaymentMethod =
    | Cash
    | Card of string
    | Crypto of address: string * amount: float

let payment = Card "Visa-1234"

Pattern Matching

let describe payment =
    match payment with
    | Cash -> "Paying with cash"
    | Card issuer -> sprintf "Paying with %s" issuer
    | Crypto (addr, amt) -> sprintf "Crypto: %f" amt

A Quick Taste

printfn "Hello, F#!"
let numbers = [1; 2; 3; 4; 5]
let doubled = numbers |> List.map (fun n -> n * 2)
printfn "%A" doubled

Common Mistakes

1. Forgetting rec for recursion

F# requires let rec factorial n = ... for recursive functions.

2. Confusing = with <-

= creates binding, <- assigns to mutable. let x = 5 vs x <- 10.

3. Incomplete pattern matching

F# enforces exhaustive matching on discriminated unions.

4. Wrong indentation

F# uses significant whitespace. Use 4 spaces consistently.

Practice Questions

1. What makes F# immutable by default? All bindings are immutable unless explicitly mutable. Collections are immutable by default.

2. What are discriminated unions? Types that take one of several named cases with optional data -- like enums with payloads.

3. How does F# pattern matching differ from C# switch? F# matching is exhaustive, works with DUs, lists, tuples, and active patterns.

Challenge: Explain why immutability by default helps prevent bugs in multithreaded applications.

FAQ

{{< faq question="Is F# a good first functional language?" >}} Yes. F# has excellent tooling (VS Code + Ionide), runs on .NET (huge ecosystem), and has a gentler learning curve than Haskell. {{< /faq >}}

{{< faq question="Can F# replace C#?" >}} Yes in many scenarios. F# can do everything C# can with less code. Many shops use both -- F# for logic and processing, C# for UI and legacy code. {{< /faq >}}

{{< faq question="Does F# work on Linux?" >}} Yes. .NET 6+ is fully cross-platform. F# works on Windows, Linux, and macOS. {{< /faq >}}

{{< faq question="What are type providers?" >}} F# feature that generates types at compile time from external data sources. A SQL type provider creates types matching your database schema. {{< /faq >}}

{{< faq question="How does F# compare to Python?" >}} F# has stronger type safety, better performance, built-in async. Python has a larger ecosystem. F# type providers enable compiler-checked data access. {{< /faq >}}

What's Next

Now that you understand what F# is, proceed to set up .NET and write your first program.