What is functional programming in F#?

F# is a multi-paradigm language, but its foundation is functional programming. This means that programs in F# are primarily built around functions, which are "pure" — they have no side effects and always return the same result for the same inputs. Key concepts include:

• Immutability: By default, data in F# is immutable. Variables are bindings, and their values cannot be changed after creation. This simplifies reasoning about the program and increases safety in multithreaded environments.
• Functions as first-class objects: Functions can be assigned to variables, passed as arguments to other functions, and returned from functions.
• Currying: Functions in F# take only one argument. Functions that take multiple arguments are automatically transformed into a sequence of functions, each accepting a single argument.
• Pattern Matching: A powerful construct for decomposing data and performing actions based on their structure.
• Type Inference: The F# compiler can automatically determine the types of most expressions, reducing the need for explicit type annotations.
• Expressions: Most constructs in F# are expressions that return a value. This allows for more concise code.

F# actively uses algebraic data types (ADTs):

• Records: Immutable data types with named fields.
• Discriminated Unions: Data types representing one of several possible values, each of which can have associated data. Used for modeling a finite number of states or options.

// Example of an immutable record
type Person = { Name: string; Age: int }

// Example of a discriminated union
type Shape =
    | Circle of radius: float
    | Rectangle of width: float * height: float

// Example of a function with pattern matching
let calculateArea shape =
    match shape with
    | Circle r -> System.Math.PI * r * r
    | Rectangle (w, h) -> w * h

The functional approach in F# promotes the creation of modular, easily testable, and parallelizable programs.