F# is a strongly typed, multi-paradigm programming language that encompasses functional, imperative,
and object-oriented programming techniques.
F# is most often used as a cross-platform CLI language, but can also be used to generate
JavaScript and GPU code.
F# is developed by the F# Software Foundation: Microsoft and open contributors.
An open source, cross-platform compiler for F# is available from the F# Software Foundation.
F# is also a fully supported language in Visual Studio.
Other tools supporting F# development include Mono, MonoDevelop, SharpDevelop and WebSharper.
F# originated from ML and has been influenced by OCaml, C#, Python, Haskell, Scala and Erlang.
Overview Functional programming
F# is a strongly typed functional-first language that uses type inference.
The programmer does not need to declare types—the compiler deduces types during compilation.
F# also allows explicit type annotations, and requires them in some situations.
F# is an expression-based language using eager evaluation.
Every statement in F#, including if expressions, try expressions and loops, is a composable
expression with a static type.
Functions and expressions that do not return any value have a return type of unit.
F# uses the let keyword for binding values to a name.
For example:
binds the value 7 to the name x.
New types are defined using the type keyword.
For functional programming, F# provides tuple, record, discriminated union, list and option
types.
A tuple represents a collection of n values, where n ≥ 0.
The value n is called the arity of the tuple.
A 3-tuple would be represented as, where A, B and C are values of possibly different types.
A tuple can be used to store values only when the number of values is known at design-time
and stays constant throughout execution.
A record is a type where the data members are named, as in { Name:string; Age:int }. Records
can be created as { Name="AB"; Age=42 }. The with keyword is used to create a copy of a
record, as in { r with Name="CD" }, which creates a new record by copying r and changing
the value of the Name field.
A discriminated union type is a type-safe version of C unions.
For example,
Values of the union type can correspond to either union case.
The types of the values carried by each union case is included in the definition of each
case.
The list type is an immutable linked list represented either using a head::tail notation
or a shorthand as [item1; item2; item3].
An empty list is written []. The option type is a discriminated union type with choices
Some(x) or None.
F# types may be generic, implemented as generic .NET types.
F# supports lambda functions and closures.
All functions in F# are first class values and are immutable.
Functions can be curried.
Being first-class values, functions can be passed as arguments to other functions.
Like other functional programming languages, F# allows function composition using the >> and
<< operators.
F# provides sequence expressions that define a sequence seq { ... }, list [ ... ] or array
[| ... |] through code that generates values.
For example,
forms a sequence of squares of numbers from 0 to 14 by filtering out numbers from the
range of numbers from 0 to 25.
Sequences are generated on-demand, while lists and arrays are evaluated eagerly.
F# uses pattern matching to bind values to names.
Pattern matching is also used when accessing discriminated unions - the union is value
matched against pattern rules and a rule is selected when a match succeeds.
F# also supports Active Patterns as a form of extensible pattern matching.
It is used, for example, when multiple ways of matching on a type exist.
F# supports a general syntax for defining compositional computations called computation
expressions.
Sequence expressions, asynchronous computations and queries are particular kinds of computation
expressions.
Computation expressions are an implementation of the monad pattern.
Imperative programming F# support for imperative programming includes
for loops while loops
arrays, created with the [| ... |] syntax hash table, created with the dict [ ... ] syntax
or System.Collections.Generic.Dictionary<_,_> type).
Values and record fields can also be labelled as mutable.
For example:
In addition, F# supports access to all CLI types and objects such as those defined in
the System.Collections.Generic namespace defining imperative data structures.
Object programming F#, like other CLI languages, can use CLI
types and objects through object programming.
F# support for object programming in expressions includes:
Dot-notation Object expressions with member x.ToString()
= "hello" }) Object construction)
Type tests Type coercions
named arguments) Named setters)
Optional arguments Support for object programming in patterns
includes Type tests
Active patterns, which can be defined over object types
F# object type definitions can be class, struct, interface, enum or delegate type definitions,
corresponding to the definition forms found in the C#.
For example, here is a class with a constructor taking a name and age, and declaring two properties.
Asynchronous programming F# supports asynchronous programming through
asynchronous workflows.
An asynchronous workflow is defined as a sequence of commands inside an async{ ... }, as in
The let!
defines the rest of the async block as the delegate, and passes it as the callback function
of an asynchronous operation.
This solves the inversion of control problem.
The async block is invoked using the Async.RunSynchronously function.
Multiple async blocks are executed in parallel using the Async.Parallel function that takes
a list of async objects and creates another async object to run the tasks in the lists
in parallel.
The resultant object is invoked using Async.RunSynchronously.
Parallel programming Parallel programming is supported partly through
the Async.Parallel, Async.Start and other operations that run asynchronous blocks in
parallel.
Parallel programming is also supported through the Array.Parallel functional programming
operators in the F# standard library, direct use of the System.Threading.Tasks task programming
model, the direct use of .NET thread pool and .NET threads and through dynamic translation
of F# code to alternative parallel execution engines such as GPU code.
Units of measure The F# type system supports units of measure
checking for numbers.
The units of measure feature integrates with F# type inference to require minimal type
annotations in user code.
Metaprogramming F# allows some forms of syntax customization
to support embedding custom domain-specific languages within the F# language itself, particularly
through computation expressions.
F# includes a feature for run-time meta-programming called quotations.
A quotation expression evaluates to an abstract syntax representation of F# expressions.
A definition labelled with the [] attribute can also be accessed in its quotation
form.
F# quotations are used for various purposes including to compile F# code to JavaScript
and GPU code.
Information rich programming F# 3.0 introduced a form of compile-time meta-programming
through statically extensible type generation called F# type providers.
F# type providers allow the F# compiler and tools to be extended with components that
provide type information to the compiler on-demand at compile time.
F# type providers have been used to give strongly typed access to connected information sources
in a scalable way, including to the Freebase knowledge graph.
In F# 3.0 the F# quotation and computation expression features are combined to implement
LINQ queries.
For example:
The combination of type providers, queries and strongly typed functional programming
is known as information rich programming.
Agent programming F# supports a variation of the Actor programming
model through the in-memory implementation of lightweight asynchronous agents.
For example, the following code defines an agent and posts 2 messages:
Development tools F# can be developed with any text editor.
Specific support exists in editors such as Emacs.
The Visual F# tools from Microsoft include full IDE integration in Visual Studio.
With the language service installed, Visual Studio can be used to create F# projects and
the Visual Studio debugger used to debug F# code.
In addition, the Visual F# tools comes with a Visual Studio-hosted REPL interactive console
that can be used to execute F# code as it is being written.
WebSharper is a framework for cross-tier JavaScript and HTML5 development with F#.
MonoDevelop is an integrated development environment supporting F# programming on Linux, Mac and
Windows including support for the interactive console as used by Visual Studio.
SharpDevelop has supported F# since version 3.0.
LINQPad has supported F# since version 2.x.
Application areas F# is a general purpose programming language.
Web programming F# is a central part of the WebSharper framework
where F# code is executed as a .NET code on the server and as JavaScript code on the client-side.
Analytical programming Among others, F# is used for quantitative
finance programming, energy trading and portfolio optimization, machine learning, business intelligence
and social gaming on Facebook.
In recent years F# has been positioned as an optimised alternative to C# and F#'s scripting
ability and IL compatibility with all Microsoft products have made it popular amongst developers.
Many developers are creating solutions based on F# and use C# WCF Services.
Scripting F# is often used as a scripting language,
mainly for desktop REPL scripting.
Open source community The F# open source community includes the
F# Software Foundation and the F# Open Source Group at GitHub.
History F# originates from Microsoft Research, Cambridge
and the language was originally designed and implemented by Don Syme.
Andrew Kennedy contributed to the design of units of measure.
The F# language and the Visual F# tools for Windows are developed by Microsoft.
The F# Software Foundation develop the F# open source compiler and tools based partly
on open source releases by the Microsoft Visual F# team.
F# features a legacy "ML compatibility mode" that can directly compile programs written
in a large subset of OCaml.
Examples A few small samples follow:
A Person class with a constructor taking a name and age and two properties.
A simple example that is often used to demonstrate the syntax of functional languages is the
factorial function for non-negative 32-bit integers, here shown in F#:
Iteration examples:
Fibonacci examples:
A sample Windows Forms program:
Asynchronous parallel programming sample:
See also OCaml
C# .NET Framework
Scala Clojure
Haskell Nemerle
Notes
References Syme, Don; Granicz, Adam; Cisternino, Antonio.
Expert F#.
Apress.
Harrop, Jon.
Visual F# 2010 for Technical Computing.
Flying Frog Consultancy.
Pickering, Robert.
Foundations of F#.
Apress. Smith, Chris.
Programming F#.
O'Reilly.
Petricek, Tomas.
Real World Functional Programming With Examples in F# and C#.
Manning Publications.
Hansen, Michael; Rischel, Hans.
Functional Programming Using F#.
Cambridge University Press.
External links The F# Software Foundation
The F# Open Source Group at GitHub The Visual F# Developer Center
Tsunami, an embeddable desktop F# IDE Cloud Tsunami, an embeddable Silverlight F#
IDE Try F#, for learning F# in your browser
F# Snippets Site The Visual F# team blog
The original Microsoft Research website for F#
Planet F# The F# Survival Guide, Dec 2009
The F# Language Specification An introduction to F# programming
F# Tutorials for Beginning through Advanced Learners