F# Language Documentation

Welcome to the official Microsoft Developer Network (MSDN) documentation for the F# programming language. F# is a mature, open-source, cross-platform programming language that enables robust solutions. It is a strongly-typed, functional-first programming language that also supports imperative and object-oriented programming.

Introduction to F#

F# is designed to be simple, expressive, and efficient. Its functional-first approach emphasizes immutability, composability, and the use of type inference to reduce boilerplate code. This makes F# ideal for tasks involving complex data manipulation, concurrent programming, and building reliable, maintainable software.

Getting Started with F#

To start developing with F#, you can use Visual Studio or Visual Studio Code with the F# development tools. The .NET SDK includes support for F#.

Installation:

Your First F# Program:


// HelloFSharp.fs
printfn "Hello, F#!"

Save this as HelloFSharp.fs and run it from your terminal using dotnet run in a project context, or compile and run it directly.

Key F# Language Features

Types and Values

F# has a powerful type system with strong type inference. You can declare immutable values using let and mutable values using mutable.


let greeting = "Hello" // Type inference: string
let mutable count = 0  // Mutable integer

count <- count + 1
printfn "%s, count is %d" greeting count

Functions

Functions are first-class citizens in F#. They can be passed as arguments, returned from other functions, and assigned to variables.


let add x y = x + y
let multiply x y = x * y

let calculate f a b = f a b

let sum = calculate add 5 3 // sum is 8
let product = calculate multiply 5 3 // product is 15

// Higher-order functions and partial application
let add5 = add 5
let result = add5 10 // result is 15

Pattern Matching

Pattern matching is a powerful control flow construct that allows you to deconstruct data structures and execute code based on their shape.


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

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

let circleArea = getArea (Circle 5.0)
let rectArea = getArea (Rectangle (4.0, 6.0))

Asynchronous Programming

F# provides excellent support for asynchronous programming with the async computation expression.


open System.Net.Http

let fetchUrlAsync url =
    async {
        use client = new HttpClient()
        let! response = client.GetStringAsync(url) |> Async.AwaitTask
        return response.Length
    }

let downloadSize = fetchUrlAsync "https://www.microsoft.com"
let resultSize = Async.RunSynchronously downloadSize
printfn "Downloaded size: %d bytes" resultSize

Object-Oriented Programming

While F# is functional-first, it fully supports object-oriented programming. You can define types, classes, interfaces, and use inheritance and polymorphism.


type Person(name: string, age: int) =
    member val Name = name with get
    member val Age = age with get

    member this.Greet() =
        printfn "Hello, my name is %s and I am %d years old." this.Name this.Age

let person = Person("Alice", 30)
person.Greet()

Official F# Tutorials

Explore the official tutorials to deepen your understanding of F# concepts:

F# Code Samples

Browse the official F# code samples to see practical applications of the language:

F# Community

Join the vibrant F# community to learn, share, and get help:

"F# brings the power of functional programming to the .NET ecosystem, enabling developers to write concise, robust, and performant code."