F Sharp (programming language)
F# is a functional-first, general purpose, strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. F# is most often used as a cross-platform Common Language Infrastructure language on.NET Core, but it can also generate JavaScript and graphics processing unit 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 a fully supported language in Visual Studio and JetBrains Rider. Plug-ins supporting F# exist for many widely used editors, most notably the extension for Visual Studio Code, and integrations for other editors such as Vim, and Emacs.
F# is a member of the ML language family and originated as a.NET Framework implementation of a core of the programming language OCaml. It has also been influenced by C#,
Python, Haskell, Scala, and Erlang.
History
Versions
In the course of its development, the language has gone through several versions:| Version | Language specification | Date | Platforms | Runtime |
| F# 1.x | May 2005 | Windows | .NET 1.0 - 3.5 | |
| F# 2.0 | April 2010 | Linux, macOS, Windows | .NET 2.0 - 4.0, Mono | |
| F# 3.0 | August 2012 | Linux, macOS, Windows; JavaScript, GPU | .NET 2.0 - 4.5, Mono | |
| F# 3.1 | October 2013 | Linux, macOS, Windows; JavaScript, GPU | .NET 2.0 - 4.5, Mono | |
| F# 4.0 | July 2015 | |||
| F# 4.1 | March 2017 | Linux, macOS, Windows, JavaScript, GPU | .NET 3.5 - 4.6.2,.NET Core, Mono | |
| F# 4.5 | August 2018 | Linux, macOS, Windows, JavaScript, GPU | .NET 4.5 - 4.7.2,.NET Core SDK 2.1.400 | |
| F# 4.7 | September 2019 |
Language evolution
F# uses an open development and engineering process.The language evolution process is managed by Don Syme from Microsoft Research as the benevolent dictator for life for the language design, together with the F# Software Foundation.
Earlier versions of the F# language were designed by Microsoft and Microsoft Research using a closed development process.
F# originates from Microsoft Research, Cambridge, UK. The language was originally designed and implemented by Don Syme, according to whom in the fsharp team, they say the F is for "Fun".
Andrew Kennedy contributed to the design of units of measure. The Visual F# Tools for Visual Studio are developed by Microsoft. The F# Software Foundation developed the F# open-source compiler and tools, incorporating the open-source compiler implementation provided by the Microsoft Visual F# Tools team.
| F# 1.0 | F# 2.0 | F# 3.0 | F# 3.1 | F# 4.0 | F# 4.1 | F# 4.5 | F# 4.7 | |
| Features added |
|
Language 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:let x = 3 + 4
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, option, and result types. A tuple represents a set of n values, where n ≥ 0. The value n is called the arity of the tuple. A 3-tuple would be represented as A record is a type where the data members are named. Here is an example of record definition:
type R =
Records can be created as. The
with keyword is used to create a copy of a record, as in, 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,
type A =
| UnionCaseX of string
| UnionCaseY of int
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 notation or a shorthand as. An empty list is written
Some 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 ' that define a sequence
seq , list seq
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 generators – values 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 '. 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-
forloops -
whileloops - arrays, created with the
syntax - hash table, created with the
dictsyntax orSystem.Collections.Generic.Dictionary<_,_>type.
mutable. For example:// Define 'x' with initial value '1'
let mutable x = 1
// Change the value of 'x' to '3'
x <- 3
Also, F# supports access to all CLI types and objects such as those defined in the
System.Collections.Generic namespace defining imperative data structures.Object-oriented programming
Like other Common Language Infrastructure languages, F# can use CLI types through object-oriented programming. F# support for object-oriented programming in expressions includes:- Dot-notation, e.g.,
- Object expressions, e.g.,
- Object construction, e.g.,
- Type tests, e.g.,
- Type coercions, e.g.,
- Named arguments, e.g.,
- Named setters, e.g.,
- Optional arguments, e.g.,
- Type tests, e.g.,
- Active patterns, which can be defined over object types
/// A simple object type definition
type Person =
member x.Name = name
member x.Age = age
Asynchronous programming
F# supports asynchronous programming through asynchronous workflows. An asynchronous workflow is defined as a sequence of commands inside anasync, as inlet asynctask =
async
The
let! indicates that the expression on the right should be done asynchronously but the flow should only continue when the result is available. In other words, from the point of view of the code block, it's as if getting the response is a blocking call, whereas from the point of view of the system, the thread won't be blocked and may be used to process other flows while the result needed for this one doesn't become available.The async block may be invoked using the
Async.RunSynchronously function. Multiple async blocks can be 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.Inversion of control in F# follows this pattern.
Parallel programming
Parallel programming is supported partly through theAsync.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 customizing via metaprogramming to support embedding custom domain-specific languages within the F# language, particularly through computation expressions.F# includes a feature for run-time meta-programming called quotations. A quotation expression evaluates to an abstract syntax tree representation of the F# expressions. Similarly, definitions labelled with the
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:
// Use the OData type provider to create types that can be used to access the Northwind database.
open Microsoft.FSharp.Data.TypeProviders
type Northwind = ODataService<"http://services.odata.org/Northwind/Northwind.svc">
let db = Northwind.GetDataContext
// A query expression.
let query1 = query
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:let counter =
MailboxProcessor.Start
Development tools
- Visual Studio, with the Visual F# tools from Microsoft installed, can be used to create, run and debug F# projects. The Visual F# tools include a Visual Studio-hosted read–eval–print loop interactive console that can execute F# code as it is written. Visual Studio for Mac also fully supports F# projects.
- Visual Studio Code contains full support for F# via the .
- F# can be developed with any text editor. Specific support exists in editors such as Emacs.
- JetBrains Rider is optimized for the development of F# Code starting with release 2019.1.
- LINQPad has supported F# since version 2.x.
Application areas
Web programming
The is an end-to-end F# stack to develop web applications. It uses ASP.NET Core on the server side and on the client side.An alternative end-to-end F# option is the WebSharper framework.
Cross-platform app development
F# can be used together with the to develop apps for iOS and Android. The library provides a more comfortable functional interface.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 the 2010s, F# has been positioned as an optimized alternative to C#. F#'s scripting ability and inter-language compatibility with all Microsoft products have made it popular among developers. Many developers are creating systems based on F# and use C# WCF Services.
Scripting
F# can be used as a scripting language, mainly for desktop read–eval–print loop scripting.Open-source community
The F# open-source community includes the F# Software Foundation and the F# Open Source Group at GitHub.. Popular open-source F# projects include:- , an F# to Javascript transpiler based on .
- , an alternative package manager for.NET that can still use NuGet repositories, but has centralised version-management.
- , an F# friendly build-system.
- , a functionally oriented middleware for ASP.NET Core.
- , a lightweight web-server and web-development library.
Compatibility
Examples
A few small samples follow:// This is a comment for a sample hello world program.
open System
Console.WriteLine
A Person class with a constructor taking a name and age and two immutable properties.
/// This is a documentation comment for a type definition.
type Person =
member x.Name = name
member x.Age = age
/// class instantiation
let mrSmith = Person
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#:
/// Using pattern matching expression
let rec factorial n =
match n with
| 0 -> 1
| _ -> n * factorial
/// For a single-argument functions there is syntactic sugar :
let rec factorial = function
| 0 -> 1
| n -> n * factorial
/// Using fold and range operator
let factorial n = |> Seq.fold 1
Iteration examples:
/// Iteration using a 'for' loop
let printList lst =
for x in lst do
printfn "%d" x
/// Iteration using a higher-order function
let printList2 lst =
List.iter lst
/// Iteration using a recursive function and pattern matching
let rec printList3 lst =
match lst with
| ->
| h :: t ->
printfn "%d" h
printList3 t
Fibonacci examples:
/// Fibonacci Number formula
let fib n =
let rec g n f0 f1 =
match n with
| 0 -> f0
| 1 -> f1
| _ -> g f1
g n 0 1
/// Another approach - a lazy infinite sequence of Fibonacci numbers
let fibSeq = Seq.unfold
// Print even fibs
// Same thing, using a list expression
A sample Windows Forms program:
// Open the Windows Forms library
open System.Windows.Forms
// Create a window and set a few properties
let form = new Form
// Create a label to show some text in the form
let label =
let x = 3 +
new Label
// Add the label to the form
form.Controls.Add
// Finally, run the form
Application.Run
Asynchronous parallel programming sample :
/// A simple prime number detector
let isPrime =
let bound = int
seq |> Seq.forall
// We are using async workflows
let primeAsync n =
async
/// Return primes between m and n using multiple threads
let primes m n =
seq
|> Seq.map primeAsync
|> Async.Parallel
|> Async.RunSynchronously
|> Array.filter snd
|> Array.map fst
// Run a test
primes 1000000 1002000
|> Array.iter