Generic Types in F#

A generic type or function in F# is parameterized over one or more type placeholders, written with a leading apostrophe like 'a, 'b, so the same definition works across many concrete types without duplication. A function like let identity x = x is automatically inferred to have type 'a -> 'a, meaning it accepts a value of any type and returns a value of that same type, and a type like type Box<'a> = { Contents: 'a } can hold an int, a string, or any other type inside Contents while the compiler still tracks exactly which one at each use site.

You rarely need to write type parameters explicitly -- F#'s type inference generalizes a function automatically based on how it's used, so let first (a, b) = a is inferred as 'a * 'b -> 'a without annotation. For types, you declare parameters after the name, as in type Pair<'a, 'b> = { First: 'a; Second: 'b }, and construct them like any other record: { First = 1; Second = "one" } gives a Pair<int, string>. Generic functions over collections are everywhere in the standard library -- List.map : ('a -> 'b) -> 'a list -> 'b list works on a list of any element type because it never inspects the elements itself, only threads them through the caller-supplied function.

F#'s type inference doesn't just infer concrete types -- it infers the most general type possible for a let-bound function, a process called automatic generalization. Writing let listOfOne x = [x] gives the inferred signature 'a -> 'a list without any annotation, and that same function works unmodified whether you call listOfOne 5 or listOfOne "hi" in different parts of the same file. This generalization happens at the point of definition for functions, but for simple (non-function) values bound with let, F#'s value restriction can prevent generalization in certain cases, requiring either an explicit type annotation or eta-expansion into a function to resolve.

Sometimes a generic function needs to do more than just move values around -- comparing them, for instance -- which requires a constraint. F# adds these automatically in many cases: let maxOf a b = if a > b then a else b infers as 'a -> 'a -> 'a when 'a : comparison, restricting 'a to types that support the > operator, so calling maxOf 3 5 works but maxOf (fun x -> x) (fun y -> y) fails to compile because function types don't support comparison. Explicit constraint syntax like let inline addOne (x: ^a) : ^a = x + LanguagePrimitives.GenericOne uses statically resolved type parameters (denoted with ^a instead of 'a) to require that 'a supports the + operator, resolved separately for each concrete type at each call site during compilation.