Export (0) Print
Expand All

Keyword Reference (F#)

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

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 (F#)

Abstract Classes (F#)

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 (F#)

Members (F#)

Constraints (F#)

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

as

Classes (F#)

Pattern Matching (F#)

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 (F#)

Used to verify code during debugging.

base

Classes (F#)

Inheritance (F#)

Used as the name of the base class object.

begin

Verbose Syntax (F#)

In verbose syntax, indicates the start of a code block.

class

Classes (F#)

In verbose syntax, indicates the start of a class definition.

default

Members (F#)

Indicates an implementation of an abstract method; used together with an abstract method declaration to create a virtual method.

delegate

Delegates (F#)

Used to declare a delegate.

do

do Bindings (F#)

Loops: for...to Expression (F#)

Loops: for...in Expression (F#)

Loops: while...do Expression (F#)

Used in looping constructs or to execute imperative code.

done

Verbose Syntax (F#)

In verbose syntax, indicates the end of a block of code in a looping expression.

downcast

Casting and Conversions (F#)

Used to convert to a type that is lower in the inheritance chain.

downto

Loops: for...to Expression (F#)

In a for expression, used when counting in reverse.

elif

Conditional Expressions: if... then...else (F#)

Used in conditional branching. A short form of else if.

else

Conditional Expressions: if... then...else (F#)

Used in conditional branching.

end

Structures (F#)

Discriminated Unions (F#)

Records (F#)

Type Extensions (F#)

Verbose Syntax (F#)

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 (F#)

Exception Types (F#)

Used to declare an exception type.

extern

External Functions (F#)

Indicates that a declared program element is defined in another binary or assembly.

false

Primitive Types (F#)

Used as a Boolean literal.

finally

Exceptions: The try...finally Expression (F#)

Used together with try to introduce a block of code that executes regardless of whether an exception occurs.

for

Loops: for...to Expression (F#)

Loops: for...in Expression (F#)

Used in looping constructs.

fun

Lambda Expressions: The fun Keyword (F#)

Used in lambda expressions, also known as anonymous functions.

function

Match Expressions (F#)

Lambda Expressions: The fun Keyword (F#)

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 (F#)

Used to reference the top-level .NET namespace.

if

Conditional Expressions: if... then...else (F#)

Used in conditional branching constructs.

in

Loops: for...in Expression (F#)

Verbose Syntax (F#)

Used for sequence expressions and, in verbose syntax, to separate expressions from bindings.

inherit

Inheritance (F#)

Used to specify a base class or base interface.

inline

Functions (F#)

Inline Functions (F#)

Used to indicate a function that should be integrated directly into the caller's code.

interface

Interfaces (F#)

Used to declare and implement interfaces.

internal

Access Control (F#)

Used to specify that a member is visible inside an assembly but not outside it.

lazy

Lazy Computations (F#)

Used to specify a computation that is to be performed only when a result is needed.

let

let Bindings (F#)

Used to associate, or bind, a name to a value or function.

match

Match Expressions (F#)

Used to branch by comparing a value to a pattern.

member

Members (F#)

Used to declare a property or method in an object type.

module

Modules (F#)

Used to associate a name with a group of related types, values, and functions, to logically separate it from other code.

mutable

let Bindings (F#)

Used to declare a variable, that is, a value that can be changed.

namespace

Namespaces (F#)

Used to associate a name with a group of related types and modules, to logically separate it from other code.

new

Constructors (F#)

Constraints (F#)

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 (F#)

Constraints (F#)

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

null

Null Values (F#)

Constraints (F#)

Indicates the absence of an object.

Also used in generic parameter constraints.

of

Discriminated Unions (F#)

Delegates (F#)

Exception Types (F#)

Used in discriminated unions to indicate the type of categories of values, and in delegate and exception declarations.

open

Import Declarations: The open Keyword (F#)

Used to make the contents of a namespace or module available without qualification.

or

Symbol and Operator Reference (F#)

Constraints (F#)

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

Also used in member constraints.

override

Members (F#)

Used to implement a version of an abstract or virtual method that differs from the base version.

private

Access Control (F#)

Restricts access to a member to code in the same type or module.

public

Access Control (F#)

Allows access to a member from outside the type.

rec

Functions (F#)

Used to indicate that a function is recursive.

return

Asynchronous Workflows (F#)

Computation Expressions (F#)

Used to indicate a value to provide as the result of a computation expression.

static

Members (F#)

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

Structures (F#)

Constraints (F#)

Used to declare a structure type.

Also used in generic parameter constraints.

Used for OCaml compatibility in module definitions.

then

Conditional Expressions: if... then...else (F#)

Constructors (F#)

Used in conditional expressions.

Also used to perform side effects after object construction.

to

Loops: for...to Expression (F#)

Used in for loops to indicate a range.

true

Primitive Types (F#)

Used as a Boolean literal.

try

Exceptions: The try...with Expression (F#)

Exceptions: The try...finally Expression (F#)

Used to introduce a block of code that might generate an exception. Used together with with or finally.

type

F# Types

Classes (F#)

Records (F#)

Structures (F#)

Enumerations (F#)

Discriminated Unions (F#)

Type Abbreviations (F#)

Units of Measure (F#)

Used to declare a class, record, structure, discriminated union, enumeration type, unit of measure, or type abbreviation.

upcast

Casting and Conversions (F#)

Used to convert to a type that is higher in the inheritance chain.

use

Resource Management: The use Keyword (F#)

Used instead of let for values that require Dispose to be called to free resources.

val

Explicit Fields: The val Keyword (F#)

Signatures (F#)

Members (F#)

Used in a signature to indicate a value, or in a type to declare a member, in limited situations.

void

Primitive Types (F#)

Indicates the .NET void type. Used when interoperating with other .NET languages.

when

Constraints (F#)

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 (F#)

Introduces a looping construct.

with

Match Expressions (F#)

Object Expressions (F#)

Type Extensions (F#)

Exceptions: The try...with Expression (F#)

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

Sequences (F#)

Used in a sequence expression to produce a value for a sequence.

In addition, 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, these keywords are available for use as identifiers.

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

atomic

break

checked

component

const

constraint

constructor

continue

eager

event

external

fixed

functor

include

method

mixin

object

parallel

process

protected

pure

sealed

tailcall

trait

virtual

volatile

Community Additions

ADD
Show:
© 2014 Microsoft