Edit

Share via

Keyword Reference

  • Article

This topic contains links to information about all F# language keywords.

F# Keyword Table

The following table shows all F# keywords in alphabetical order, together with brief descriptions and links to relevant topics that contain more information.

Keyword Link Description
abstract Members

Abstract Classes		 Indicates a method that either has no implementation in the type in which it is declared or that is virtual and has a default implementation.
and let Bindings

Records

Members

Constraints		 Used in mutually recursive bindings and records, in property declarations, and with multiple constraints on generic parameters.
as Classes

Pattern Matching		 Used to give the current class object an object name. Also used to give a name to a whole pattern within a pattern match.
assert Assertions Used to verify code during debugging.
base Classes

Inheritance		 Used as the name of the base class object.
begin Verbose Syntax In verbose syntax, indicates the start of a code block.
class Classes In verbose syntax, indicates the start of a class definition.
default Members Indicates an implementation of an abstract method; used together with an abstract method declaration to create a virtual method.
delegate Delegates Used to declare a delegate.
do do Bindings

Loops: for...to Expression

Loops: for...in Expression

Loops: while...do Expression		 Used in looping constructs or to execute imperative code.
done Verbose Syntax In verbose syntax, indicates the end of a block of code in a looping expression.
downcast Casting and Conversions Used to convert to a type that is lower in the inheritance chain.
downto Loops: for...to Expression In a for expression, used when counting in reverse.
elif Conditional Expressions: if...then...else Used in conditional branching. A short form of else if.
else Conditional Expressions: if...then...else Used in conditional branching.
end Structs

Discriminated Unions

Records

Type Extensions

Verbose Syntax		 In type definitions and type extensions, indicates the end of a section of member definitions.

In verbose syntax, used to specify the end of a code block that starts with the begin keyword.
exception Exception Handling

Exception Types		 Used to declare an exception type.
extern External Functions Indicates that a declared program element is defined in another binary or assembly.
false Primitive Types Used as a Boolean literal.
finally Exceptions: The try...finally Expression Used together with try to introduce a block of code that executes regardless of whether an exception occurs.
fixed Fixed Used to "pin" a pointer on the stack to prevent it from being garbage collected.
for Loops: for...to Expression

Loops: for...in Expression		 Used in looping constructs.
fun Lambda Expressions: The fun Keyword Used in lambda expressions, also known as anonymous functions.
function Match Expressions

Lambda Expressions: The fun Keyword		 Used as a shorter alternative to the fun keyword and a match expression in a lambda expression that has pattern matching on a single argument.
global Namespaces Used to reference the top-level .NET namespace.
if Conditional Expressions: if...then...else Used in conditional branching constructs.
in Loops: for...in Expression

Verbose Syntax		 Used for sequence expressions and, in verbose syntax, to separate expressions from bindings.
inherit Inheritance Used to specify a base class or base interface.
inline Functions

Inline Functions		 Used to indicate a function that should be integrated directly into the caller's code.
interface Interfaces Used to declare and implement interfaces.
internal Access Control Used to specify that a member is visible inside an assembly but not outside it.
lazy Lazy Expressions Used to specify an expression that is to be performed only when a result is needed.
let let Bindings Used to associate, or bind, a name to a value or function.
let! Async expressions

Task expressions

Computation Expressions		 Used in async expressions to bind a name to the result of an asynchronous computation, or, in other computation expressions, used to bind a name to a result, which is of the computation type.
match Match Expressions Used to branch by comparing a value to a pattern.
match! Computation Expressions Used to inline a call to a computation expression and pattern match on its result.
member Members Used to declare a property or method in an object type.
module Modules Used to associate a name with a group of related types, values, and functions, to logically separate it from other code.
mutable let Bindings Used to declare a variable, that is, a value that can be changed.
namespace Namespaces Used to associate a name with a group of related types and modules, to logically separate it from other code.
new Constructors

Constraints		 Used to declare, define, or invoke a constructor that creates or that can create an object.

Also used in generic parameter constraints to indicate that a type must have a certain constructor.
not Symbol and Operator Reference

Constraints		 Not actually a keyword. However, not struct in combination is used as a generic parameter constraint.
null Null Values

Constraints		 Indicates the absence of an object.

Also used in generic parameter constraints.
of Discriminated Unions

Delegates

Exception Types		 Used in discriminated unions to indicate the type of categories of values, and in delegate and exception declarations.
open Import Declarations: The open Keyword Used to make the contents of a namespace or module available without qualification.
or Symbol and Operator Reference

Constraints		 Used with Boolean conditions as a Boolean or operator. Equivalent to ||.

Also used in member constraints.
override Members Used to implement a version of an abstract or virtual method that differs from the base version.
private Access Control Restricts access to a member to code in the same type or module.
public Access Control Allows access to a member from outside the type.
rec Functions Used to indicate that a function is recursive.
return Computation Expressions

Async expressions

Task expressions		 Used to indicate a value to provide as the result of a computation expression.
return! Computation Expressions

Async expressions

Task expressions		 Used to indicate a computation expression that, when evaluated, provides the result of the containing computation expression.
select Query Expressions Used in query expressions to specify what fields or columns to extract. Note that this is a contextual keyword, which means that it is not actually a reserved word and it only acts like a keyword in appropriate context.
static Members Used to indicate a method or property that can be called without an instance of a type, or a value member that is shared among all instances of a type.
struct Structs

Tuples

Constraints		 Used to declare a structure type.

Used to specify a struct tuple.

Also used in generic parameter constraints.

Used for OCaml compatibility in module definitions.
then Conditional Expressions: if...then...else

Constructors		 Used in conditional expressions.

Also used to perform side effects after object construction.
to Loops: for...to Expression Used in for loops to indicate a range.
true Primitive Types Used as a Boolean literal.
try Exceptions: The try...with Expression

Exceptions: The try...finally Expression		 Used to introduce a block of code that might generate an exception. Used together with with or finally.
type F# Types

Classes

Records

Structs

Enumerations

Discriminated Unions

Type Abbreviations

Units of Measure		 Used to declare a class, record, structure, discriminated union, enumeration type, unit of measure, or type abbreviation.
upcast Casting and Conversions Used to convert to a type that is higher in the inheritance chain.
use Resource Management: The use Keyword Used instead of let for values that require Dispose to be called to free resources.
use! Computation Expressions

Async expressions

Task expressions		 Used instead of let! in async expressions and other computation expressions for values that require Dispose to be called to free resources.
val Explicit Fields: The val Keyword

Signatures

Members		 Used in a signature to indicate a value, or in a type to declare a member, in limited situations.
void Primitive Types Indicates the .NET void type. Used when interoperating with other .NET languages.
when Constraints Used for Boolean conditions (when guards) on pattern matches and to introduce a constraint clause for a generic type parameter.
while Loops: while...do Expression Introduces a looping construct.
with Match Expressions

Object Expressions

Copy and Update Record Expressions

Type Extensions

Exceptions: The try...with Expression		 Used together with the match keyword in pattern matching expressions. Also used in object expressions, record copying expressions, and type extensions to introduce member definitions, and to introduce exception handlers.
yield Lists, Arrays, Sequences Used in a list, array, or sequence expression to produce a value for a sequence. Typically can be omitted, as it is implicit in most situations.
yield! Computation Expressions

Async expressions

Task expressions		 Used in a computation expression to append the result of a given computation expression to a collection of results for the containing computation expression.
const Type Providers Type Providers allow the use of const as a keyword to specify a constant literal as a type parameter argument.

The following tokens are reserved in F# because they are keywords in the OCaml language:

  • asr
  • land
  • lor
  • lsl
  • lsr
  • lxor
  • mod
  • sig

If you use the --mlcompatibility compiler option, the above keywords are available for use as identifiers.

The following tokens are reserved as keywords for future expansion of F#:

  • break
  • checked
  • component
  • const
  • constraint
  • continue
  • event
  • external
  • include
  • mixin
  • parallel
  • process
  • protected
  • pure
  • sealed
  • tailcall
  • trait
  • virtual

The following tokens were once reserved as keywords but were released in F# 4.1, so now you can use them as identifiers:

Keyword Reason
method Use member to introduce methods.
constructor Use new to introduce constructors.
atomic Related to the fad for transactional memory circa 2006. This would now be a library-defined computation expression.
eager No longer needed; it was initially designed to be let eager to match a potential let lazy.
object No need to reserve this.
recursive Use rec.
functor If F# added parameterized modules, you'd use module M(args) = ....
measure The [<Measure>] attribute suffices.
volatile The [<Volatile>] attribute suffices.

See also