F Sharp (programming language)

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 including Visual Studio Code, 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

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 (BDFL) 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# was first included in Visual Studio in the 2010 edition, at the same level as Visual Basic (.NET) and C# (albeit as an option), and remains in all later editions, thus making the language widely available and well-supported.

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.

6 more chapters are free with a Lably account.

Language overview

Functional programming

F# is a strongly typed functional-first language with a large number of capabilities that are normally found only in functional programming languages, while supporting object-oriented features available in C#. Together, these features allow F# programs to be written in a completely functional style and also allow functional and object-oriented styles to be mixed.

Examples of functional features are:

Everything is an expression
Type inference (using Hindley–Milner type inference)
Functions as first-class citizens
Anonymous functions with capturing semantics (i.e., closures)
Immutable variables and objects
Lazy evaluation support
Higher-order functions
Nested functions
Currying
Pattern matching
Algebraic data types
Tuples
List comprehension
Monad pattern support (called computation expressions)
Tail call optimisation

F# is an expression-based language using eager evaluation and also in some instances lazy 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:

<span id="mwA4Q"></span><span class="k" id="mwA4U">let</span><span class="w" id="mwA4Y"> </span><span class="nv" id="mwA4c">x</span><span class="w" id="mwA4g"> </span><span class="o" id="mwA4k">=</span><span class="w" id="mwA4o"> </span><span class="mi" id="mwA4s">3</span><span class="w" id="mwA4w"> </span><span class="o" id="mwA40">+</span><span class="w" id="mwA44"> </span><span class="mi" id="mwA48">4</span>

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, B, C), 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 during execution.

A record is a type where the data members are named. Here is an example of record definition:

<span id="mwA6o"></span><span class="w" id="mwA6s"> </span><span class="k" id="mwA6w">type</span><span class="w" id="mwA60"> </span><span class="nc" id="mwA64">R</span><span class="w" id="mwA68"> </span><span class="o" id="mwA7A">=</span><span class="w" id="mwA7E"> </span> <span class="w" id="mwA7I"> </span><span class="o" id="mwA7M">{</span><span class="w" id="mwA7Q"> </span><span class="n" id="mwA7U">Name</span><span class="w" id="mwA7Y"> </span><span class="o" id="mwA7c">:</span><span class="w" id="mwA7g"> </span><span class="kt" id="mwA7k">string</span><span class="w" id="mwA7o"> </span> <span class="w" id="mwA7s"> </span><span class="n" id="mwA7w">Age</span><span class="w" id="mwA70"> </span><span class="o" id="mwA74">:</span><span class="w" id="mwA78"> </span><span class="n" id="mwA8A">int</span><span class="w" id="mwA8E"> </span><span class="o" id="mwA8I">}</span>

Records can be created as let r = { 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 (assuming the record created in the last example was named r).

A discriminated union type is a type-safe version of C unions. For example,

<span id="mwA-0"></span><span class="w" id="mwA-4"> </span><span class="k" id="mwA-8">type</span><span class="w" id="mwA_A"> </span><span class="nc" id="mwA_E">A</span><span class="w" id="mwA_I"> </span><span class="o" id="mwA_M">=</span><span class="w" id="mwA_Q"> </span> <span class="w" id="mwA_U"> </span><span class="o" id="mwA_Y">|</span><span class="w" id="mwA_c"> </span><span class="n" id="mwA_g">UnionCaseX</span><span class="w" id="mwA_k"> </span><span class="k" id="mwA_o">of</span><span class="w" id="mwA_s"> </span><span class="kt" id="mwA_w">string</span> <span class="w" id="mwA_0"> </span><span class="o" id="mwA_4">|</span><span class="w" id="mwA_8"> </span><span class="n" id="mwBAA">UnionCaseY</span><span class="w" id="mwBAE"> </span><span class="k" id="mwBAI">of</span><span class="w" id="mwBAM"> </span><span class="n" id="mwBAQ">int</span>

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 (:: is the cons operator) 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,

<span id="mwBDo"></span><span class="w" id="mwBDs"> </span><span class="n" id="mwBDw">seq</span><span class="w" id="mwBD0"> </span><span class="o" id="mwBD4">{</span><span class="w" id="mwBD8"> </span><span class="k" id="mwBEA">for</span><span class="w" id="mwBEE"> </span><span class="n" id="mwBEI">b</span><span class="w" id="mwBEM"> </span><span class="k" id="mwBEQ">in</span><span class="w" id="mwBEU"> </span><span class="mi" id="mwBEY">0</span><span class="w" id="mwBEc"> </span><span class="o" id="mwBEg">..</span><span class="w" id="mwBEk"> </span><span class="mi" id="mwBEo">25</span><span class="w" id="mwBEs"> </span><span class="k" id="mwBEw">do</span> <span class="w" id="mwBE0"> </span><span class="k" id="mwBE4">if</span><span class="w" id="mwBE8"> </span><span class="n" id="mwBFA">b</span><span class="w" id="mwBFE"> </span><span class="o" id="mwBFI"><</span><span class="w" id="mwBFM"> </span><span class="mi" id="mwBFQ">15</span><span class="w" id="mwBFU"> </span><span class="k" id="mwBFY">then</span> <span class="w" id="mwBFc"> </span><span class="k" id="mwBFg">yield</span><span class="w" id="mwBFk"> </span><span class="n" id="mwBFo">b</span><span class="o" id="mwBFs">*</span><span class="n" id="mwBFw">b</span><span class="w" id="mwBF0"> </span><span class="o" id="mwBF4">}</span>

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 (i.e., are lazily evaluated) – 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:

<span id="mwBIo"></span><span class="c1" id="mwBIs">// Define 'x' with initial value '1'</span> <span class="k" id="mwBIw">let</span><span class="w" id="mwBI0"> </span><span class="nv" id="mwBI4">mutable</span><span class="w" id="mwBI8"> </span><span class="n" id="mwBJA">x</span><span class="w" id="mwBJE"> </span><span class="o" id="mwBJI">=</span><span class="w" id="mwBJM"> </span><span class="mi" id="mwBJQ">1</span> <span class="c1" id="mwBJU">// Change the value of 'x' to '3'</span> <span class="n" id="mwBJY">x</span><span class="w" id="mwBJc"> </span><span class="o" id="mwBJg"><-</span><span class="w" id="mwBJk"> </span><span class="mi" id="mwBJo">3</span>

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 (CLI) languages, F# can use CLI types through object-oriented programming. F# support for object-oriented programming in expressions includes:

Dot-notation, e.g., x.Name
Object expressions, e.g., { new obj() with member x.ToString() = "hello" }
Object construction, e.g., new Form()
Type tests, e.g., x :? string
Type coercions, e.g., x :?> string
Named arguments, e.g., x.Method(someArgument=1)
Named setters, e.g., new Form(Text="Hello")
Optional arguments, e.g., x.Method(OptionalArgument=1)

Support for object-oriented programming in patterns includes

Type tests, e.g., :? string as s
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 C#. For example, here is a class with a constructor taking a name and age, and declaring two properties.

<span id="mwBQc"></span><span class="sd" id="mwBQg">/// A simple object type definition</span> <span class="k" id="mwBQk">type</span><span class="w" id="mwBQo"> </span><span class="nc" id="mwBQs">Person</span><span class="o" id="mwBQw">(</span><span class="n" id="mwBQ0">name</span><span class="w" id="mwBQ4"> </span><span class="o" id="mwBQ8">:</span><span class="w" id="mwBRA"> </span><span class="kt" id="mwBRE">string</span><span class="o" id="mwBRI">,</span><span class="w" id="mwBRM"> </span><span class="n" id="mwBRQ">age</span><span class="w" id="mwBRU"> </span><span class="o" id="mwBRY">:</span><span class="w" id="mwBRc"> </span><span class="n" id="mwBRg">int</span><span class="o" id="mwBRk">)</span><span class="w" id="mwBRo"> </span><span class="o" id="mwBRs">=</span> <span class="w" id="mwBRw"> </span><span class="k" id="mwBR0">member</span><span class="w" id="mwBR4"> </span><span class="n" id="mwBR8">x</span><span class="p" id="mwBSA">.</span><span class="nf" id="mwBSE">Name</span><span class="w" id="mwBSI"> </span><span class="o" id="mwBSM">=</span><span class="w" id="mwBSQ"> </span><span class="n" id="mwBSU">name</span> <span class="w" id="mwBSY"> </span><span class="k" id="mwBSc">member</span><span class="w" id="mwBSg"> </span><span class="n" id="mwBSk">x</span><span class="p" id="mwBSo">.</span><span class="nf" id="mwBSs">Age</span><span class="w" id="mwBSw"> </span><span class="o" id="mwBS0">=</span><span class="w" id="mwBS4"> </span><span class="n" id="mwBS8">age</span>

Asynchronous programming

F# supports asynchronous programming through asynchronous workflows. An asynchronous workflow is defined as a sequence of commands inside an async{ ... }, as in

<span id="mwBTs"></span><span class="k" id="mwBTw">let</span><span class="w" id="mwBT0"> </span><span class="nv" id="mwBT4">asynctask</span><span class="w" id="mwBT8"> </span><span class="o" id="mwBUA">=</span><span class="w" id="mwBUE"> </span> <span class="w" id="mwBUI"> </span><span class="n" id="mwBUM">async</span><span class="w" id="mwBUQ"> </span><span class="o" id="mwBUU">{</span><span class="w" id="mwBUY"> </span><span class="k" id="mwBUc">let</span><span class="w" id="mwBUg"> </span><span class="nv" id="mwBUk">req</span><span class="w" id="mwBUo"> </span><span class="o" id="mwBUs">=</span><span class="w" id="mwBUw"> </span><span class="nn" id="mwBU0">WebRequest</span><span class="p" id="mwBU4">.</span><span class="n" id="mwBU8">Create</span><span class="o" id="mwBVA">(</span><span class="n" id="mwBVE">url</span><span class="o" id="mwBVI">)</span> <span class="w" id="mwBVM"> </span><span class="k" id="mwBVQ">let!</span><span class="w" id="mwBVU"> </span><span class="nv" id="mwBVY">response</span><span class="w" id="mwBVc"> </span><span class="o" id="mwBVg">=</span><span class="w" id="mwBVk"> </span><span class="n" id="mwBVo">req</span><span class="o" id="mwBVs">.</span><span class="n" id="mwBVw">GetResponseAsync</span><span class="bp" id="mwBV0">()</span> <span class="w" id="mwBV4"> </span><span class="k" id="mwBV8">use</span><span class="w" id="mwBWA"> </span><span class="n" id="mwBWE">stream</span><span class="w" id="mwBWI"> </span><span class="o" id="mwBWM">=</span><span class="w" id="mwBWQ"> </span><span class="n" id="mwBWU">response</span><span class="o" id="mwBWY">.</span><span class="n" id="mwBWc">GetResponseStream</span><span class="bp" id="mwBWg">()</span> <span class="w" id="mwBWk"> </span><span class="k" id="mwBWo">use</span><span class="w" id="mwBWs"> </span><span class="n" id="mwBWw">streamreader</span><span class="w" id="mwBW0"> </span><span class="o" id="mwBW4">=</span><span class="w" id="mwBW8"> </span><span class="k" id="mwBXA">new</span><span class="w" id="mwBXE"> </span><span class="nn" id="mwBXI">System</span><span class="p" id="mwBXM">.</span><span class="nn" id="mwBXQ">IO</span><span class="p" id="mwBXU">.</span><span class="n" id="mwBXY">StreamReader</span><span class="o" id="mwBXc">(</span><span class="n" id="mwBXg">stream</span><span class="o" id="mwBXk">)</span> <span class="w" id="mwBXo"> </span><span class="k" id="mwBXs">return</span><span class="w" id="mwBXw"> </span><span class="n" id="mwBX0">streamreader</span><span class="o" id="mwBX4">.</span><span class="n" id="mwBX8">ReadToEnd</span><span class="bp" id="mwBYA">()</span><span class="w" id="mwBYE"> </span><span class="o" id="mwBYI">}</span>

The let! indicates that the expression on the right (getting the response) 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 is as if getting the response is a blocking call, whereas from the point of view of the system, the thread will not be blocked and may be used to process other flows until the result needed for this one becomes 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 (in the example, asynctask is an async object) 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.

Since version 6.0, F# supports creating, consuming and returning .NET tasks directly.

<span id="mwBZw"></span><span class="w" id="mwBZ0"> </span><span class="k" id="mwBZ4">open</span><span class="w" id="mwBZ8"> </span><span class="nn" id="mwBaA">System.Net.Http</span> <span class="w" id="mwBaE"> </span><span class="k" id="mwBaI">let</span><span class="w" id="mwBaM"> </span><span class="nv" id="mwBaQ">fetchUrlAsync</span><span class="w" id="mwBaU"> </span><span class="o" id="mwBaY">(</span><span class="n" id="mwBac">url</span><span class="o" id="mwBag">:</span><span class="kt" id="mwBak">string</span><span class="o" id="mwBao">)</span><span class="w" id="mwBas"> </span><span class="o" id="mwBaw">=</span><span class="w" id="mwBa0"> </span><span class="c1" id="mwBa4">// string -> Task<string></span> <span class="w" id="mwBa8"> </span><span class="n" id="mwBbA">task</span><span class="w" id="mwBbE"> </span><span class="o" id="mwBbI">{</span> <span class="w" id="mwBbM"> </span><span class="k" id="mwBbQ">use</span><span class="w" id="mwBbU"> </span><span class="n" id="mwBbY">client</span><span class="w" id="mwBbc"> </span><span class="o" id="mwBbg">=</span><span class="w" id="mwBbk"> </span><span class="k" id="mwBbo">new</span><span class="w" id="mwBbs"> </span><span class="n" id="mwBbw">HttpClient</span><span class="bp" id="mwBb0">()</span> <span class="w" id="mwBb4"> </span><span class="k" id="mwBb8">let!</span><span class="w" id="mwBcA"> </span><span class="nv" id="mwBcE">response</span><span class="w" id="mwBcI"> </span><span class="o" id="mwBcM">=</span><span class="w" id="mwBcQ"> </span><span class="n" id="mwBcU">client</span><span class="o" id="mwBcY">.</span><span class="n" id="mwBcc">GetAsync</span><span class="o" id="mwBcg">(</span><span class="n" id="mwBck">url</span><span class="o" id="mwBco">)</span><span class="w" id="mwBcs"> </span> <span class="w" id="mwBcw"> </span><span class="k" id="mwBc0">let!</span><span class="w" id="mwBc4"> </span><span class="nv" id="mwBc8">content</span><span class="w" id="mwBdA"> </span><span class="o" id="mwBdE">=</span><span class="w" id="mwBdI"> </span><span class="n" id="mwBdM">response</span><span class="o" id="mwBdQ">.</span><span class="n" id="mwBdU">Content</span><span class="o" id="mwBdY">.</span><span class="n" id="mwBdc">ReadAsStringAsync</span><span class="bp" id="mwBdg">()</span> <span class="w" id="mwBdk"> </span><span class="k" id="mwBdo">do</span><span class="o" id="mwBds">!</span><span class="w" id="mwBdw"> </span><span class="nn" id="mwBd0">Task</span><span class="p" id="mwBd4">.</span><span class="n" id="mwBd8">Delay</span><span class="w" id="mwBeA"> </span><span class="mi" id="mwBeE">500</span> <span class="w" id="mwBeI"> </span><span class="k" id="mwBeM">return</span><span class="w" id="mwBeQ"> </span><span class="n" id="mwBeU">content</span> <span class="w" id="mwBeY"> </span><span class="o" id="mwBec">}</span> <span class="w" id="mwBeg"> </span><span class="c1" id="mwBek">// Usage</span> <span class="w" id="mwBeo"> </span><span class="k" id="mwBes">let</span><span class="w" id="mwBew"> </span><span class="nv" id="mwBe0">fetchPrint</span><span class="bp" id="mwBe4">()</span><span class="w" id="mwBe8"> </span><span class="o" id="mwBfA">=</span> <span class="w" id="mwBfE"> </span><span class="k" id="mwBfI">let</span><span class="w" id="mwBfM"> </span><span class="nv" id="mwBfQ">task</span><span class="w" id="mwBfU"> </span><span class="o" id="mwBfY">=</span><span class="w" id="mwBfc"> </span><span class="n" id="mwBfg">task</span><span class="w" id="mwBfk"> </span><span class="o" id="mwBfo">{</span> <span class="w" id="mwBfs"> </span><span class="k" id="mwBfw">let!</span><span class="w" id="mwBf0"> </span><span class="nv" id="mwBf4">data</span><span class="w" id="mwBf8"> </span><span class="o" id="mwBgA">=</span><span class="w" id="mwBgE"> </span><span class="n" id="mwBgI">fetchUrlAsync</span><span class="w" id="mwBgM"> </span><span class="s" id="mwBgQ">"https://example.com"</span> <span class="w" id="mwBgU"> </span><span class="n" id="mwBgY">printfn</span><span class="w" id="mwBgc"> </span><span class="o" id="mwBgg">$</span><span class="s" id="mwBgk">"{data}"</span> <span class="w" id="mwBgo"> </span><span class="o" id="mwBgs">}</span><span class="w" id="mwBgw"> </span> <span class="w" id="mwBg0"> </span><span class="n" id="mwBg4">task</span><span class="o" id="mwBg8">.</span><span class="n" id="mwBhA">Wait</span><span class="bp" id="mwBhE">()</span>

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: units of measure, such as meters or kilograms, can be assigned to floating point, unsigned integer and signed integer values. This allows the compiler to check that arithmetic involving these values is dimensionally consistent, helping to prevent common programming mistakes by ensuring that, for instance, lengths are not mistakenly added to times.

The units of measure feature integrates with F# type inference to require minimal type annotations in user code.

<span id="mwBjI"></span><span class="o" id="mwBjM">[<</span><span class="n" id="mwBjQ">Measure</span><span class="o" id="mwBjU">>]</span><span class="w" id="mwBjY"> </span><span class="k" id="mwBjc">type</span><span class="w" id="mwBjg"> </span><span class="nc" id="mwBjk">m</span><span class="w" id="mwBjo"> </span><span class="c1" id="mwBjs">// meter</span> <span class="o" id="mwBjw">[<</span><span class="n" id="mwBj0">Measure</span><span class="o" id="mwBj4">>]</span><span class="w" id="mwBj8"> </span><span class="k" id="mwBkA">type</span><span class="w" id="mwBkE"> </span><span class="nc" id="mwBkI">s</span><span class="w" id="mwBkM"> </span><span class="c1" id="mwBkQ">// second</span> <span class="k" id="mwBkU">let</span><span class="w" id="mwBkY"> </span><span class="nv" id="mwBkc">distance</span><span class="w" id="mwBkg"> </span><span class="o" id="mwBkk">=</span><span class="w" id="mwBko"> </span><span class="mi" id="mwBks">100</span><span class="o" id="mwBkw">.</span><span class="mi" id="mwBk0">0</span><span class="o" id="mwBk4"><</span><span class="n" id="mwBk8">m</span><span class="o" id="mwBlA">></span><span class="w" id="mwBlE"> </span><span class="c1" id="mwBlI">// float<m></span> <span class="k" id="mwBlM">let</span><span class="w" id="mwBlQ"> </span><span class="nv" id="mwBlU">time</span><span class="w" id="mwBlY"> </span><span class="o" id="mwBlc">=</span><span class="w" id="mwBlg"> </span><span class="mi" id="mwBlk">5</span><span class="o" id="mwBlo">.</span><span class="mi" id="mwBls">0</span><span class="o" id="mwBlw"><</span><span class="n" id="mwBl0">s</span><span class="o" id="mwBl4">></span><span class="w" id="mwBl8"> </span><span class="c1" id="mwBmA">// float<s></span> <span class="k" id="mwBmE">let</span><span class="w" id="mwBmI"> </span><span class="nv" id="mwBmM">speed</span><span class="w" id="mwBmQ"> </span><span class="o" id="mwBmU">=</span><span class="w" id="mwBmY"> </span><span class="n" id="mwBmc">distance</span><span class="o" id="mwBmg">/</span><span class="n" id="mwBmk">time</span><span class="w" id="mwBmo"> </span><span class="c1" id="mwBms">// float<m/s></span> <span class="o" id="mwBmw">[<</span><span class="n" id="mwBm0">Measure</span><span class="o" id="mwBm4">>]</span><span class="w" id="mwBm8"> </span><span class="k" id="mwBnA">type</span><span class="w" id="mwBnE"> </span><span class="nc" id="mwBnI">kg</span><span class="w" id="mwBnM"> </span><span class="c1" id="mwBnQ">// kilogram</span> <span class="o" id="mwBnU">[<</span><span class="n" id="mwBnY">Measure</span><span class="o" id="mwBnc">>]</span><span class="w" id="mwBng"> </span><span class="k" id="mwBnk">type</span><span class="w" id="mwBno"> </span><span class="nc" id="mwBns">N</span><span class="w" id="mwBnw"> </span><span class="o" id="mwBn0">=</span><span class="w" id="mwBn4"> </span><span class="o" id="mwBn8">(</span><span class="n" id="mwBoA">kg</span><span class="w" id="mwBoE"> </span><span class="o" id="mwBoI">*</span><span class="w" id="mwBoM"> </span><span class="n" id="mwBoQ">m</span><span class="o" id="mwBoU">)/(</span><span class="n" id="mwBoY">s</span><span class="o" id="mwBoc">^</span><span class="mi" id="mwBog">2</span><span class="o" id="mwBok">)</span><span class="w" id="mwBoo"> </span><span class="c1" id="mwBos">// Newtons</span> <span class="o" id="mwBow">[<</span><span class="n" id="mwBo0">Measure</span><span class="o" id="mwBo4">>]</span><span class="w" id="mwBo8"> </span><span class="k" id="mwBpA">type</span><span class="w" id="mwBpE"> </span><span class="nc" id="mwBpI">Pa</span><span class="w" id="mwBpM"> </span><span class="o" id="mwBpQ">=</span><span class="w" id="mwBpU"> </span><span class="n" id="mwBpY">N</span><span class="o" id="mwBpc">/(</span><span class="n" id="mwBpg">m</span><span class="o" id="mwBpk">^</span><span class="mi" id="mwBpo">2</span><span class="o" id="mwBps">)</span><span class="w" id="mwBpw"> </span><span class="c1" id="mwBp0">// Pascals </span> <span class="o" id="mwBp4">[<</span><span class="n" id="mwBp8">Measure</span><span class="o" id="mwBqA">>]</span><span class="w" id="mwBqE"> </span><span class="k" id="mwBqI">type</span><span class="w" id="mwBqM"> </span><span class="nc" id="mwBqQ">days</span><span class="w" id="mwBqU"> </span> <span class="k" id="mwBqY">let</span><span class="w" id="mwBqc"> </span><span class="nv" id="mwBqg">better_age</span><span class="w" id="mwBqk"> </span><span class="o" id="mwBqo">=</span><span class="w" id="mwBqs"> </span><span class="mi" id="mwBqw">3u</span><span class="o" id="mwBq0"><</span><span class="n" id="mwBq4">days</span><span class="o" id="mwBq8">></span><span class="w" id="mwBrA"> </span><span class="c1" id="mwBrE">// uint<days></span>

The F# static type checker provides this functionality at compile time, but units are erased from the compiled code. Consequently, it is not possible to determine a value's unit at runtime.

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 [<ReflectedDefinition>] attribute can also be accessed in their quotation form. F# quotations are used for various purposes including to compile F# code into JavaScript and GPU code. Quotations represent their F# code expressions as data for use by other parts of the program while requiring it to be syntactically correct F# 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:

<span id="mwBuA"></span><span class="c1" id="mwBuE">// Use the OData type provider to create types that can be used to access the Northwind database.</span> <span class="k" id="mwBuI">open</span><span class="w" id="mwBuM"> </span><span class="nn" id="mwBuQ">Microsoft.FSharp.Data.TypeProviders</span> <span class="k" id="mwBuU">type</span><span class="w" id="mwBuY"> </span><span class="nc" id="mwBuc">Northwind</span><span class="w" id="mwBug"> </span><span class="o" id="mwBuk">=</span><span class="w" id="mwBuo"> </span><span class="n" id="mwBus">ODataService</span><span class="o" id="mwBuw"><</span><span class="s" id="mwBu0">"http://services.odata.org/Northwind/Northwind.svc"</span><span class="o" id="mwBu4">></span> <span class="k" id="mwBu8">let</span><span class="w" id="mwBvA"> </span><span class="nv" id="mwBvE">db</span><span class="w" id="mwBvI"> </span><span class="o" id="mwBvM">=</span><span class="w" id="mwBvQ"> </span><span class="nn" id="mwBvU">Northwind</span><span class="p" id="mwBvY">.</span><span class="n" id="mwBvc">GetDataContext</span><span class="bp" id="mwBvg">()</span> <span class="c1" id="mwBvk">// A query expression.</span> <span class="k" id="mwBvo">let</span><span class="w" id="mwBvs"> </span><span class="nv" id="mwBvw">query1</span><span class="w" id="mwBv0"> </span><span class="o" id="mwBv4">=</span><span class="w" id="mwBv8"> </span><span class="n" id="mwBwA">query</span><span class="w" id="mwBwE"> </span><span class="o" id="mwBwI">{</span><span class="w" id="mwBwM"> </span><span class="k" id="mwBwQ">for</span><span class="w" id="mwBwU"> </span><span class="n" id="mwBwY">customer</span><span class="w" id="mwBwc"> </span><span class="k" id="mwBwg">in</span><span class="w" id="mwBwk"> </span><span class="n" id="mwBwo">db</span><span class="o" id="mwBws">.</span><span class="n" id="mwBww">Customers</span><span class="w" id="mwBw0"> </span><span class="k" id="mwBw4">do</span> <span class="w" id="mwBw8"> </span><span class="k" id="mwBxA">select</span><span class="w" id="mwBxE"> </span><span class="n" id="mwBxI">customer</span><span class="w" id="mwBxM"> </span><span class="o" id="mwBxQ">}</span>

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:

<span id="mwByA"></span><span class="w" id="mwByE"> </span><span class="k" id="mwByI">type</span><span class="w" id="mwByM"> </span><span class="nc" id="mwByQ">Message</span><span class="w" id="mwByU"> </span><span class="o" id="mwByY">=</span> <span class="w" id="mwByc"> </span><span class="o" id="mwByg">|</span><span class="w" id="mwByk"> </span><span class="n" id="mwByo">Enqueue</span><span class="w" id="mwBys"> </span><span class="k" id="mwByw">of</span><span class="w" id="mwBy0"> </span><span class="kt" id="mwBy4">string</span> <span class="w" id="mwBy8"> </span><span class="o" id="mwBzA">|</span><span class="w" id="mwBzE"> </span><span class="n" id="mwBzI">Dequeue</span><span class="w" id="mwBzM"> </span><span class="k" id="mwBzQ">of</span><span class="w" id="mwBzU"> </span><span class="n" id="mwBzY">AsyncReplyChannel</span><span class="o" id="mwBzc"><</span><span class="n" id="mwBzg">Option</span><span class="o" id="mwBzk"><</span><span class="kt" id="mwBzo">string</span><span class="o" id="mwBzs">>></span> <span class="w" id="mwBzw"> </span><span class="c1" id="mwBz0">// Provides concurrent access to a list of strings</span> <span class="w" id="mwBz4"> </span><span class="k" id="mwBz8">let</span><span class="w" id="mwB0A"> </span><span class="nv" id="mwB0E">listManager</span><span class="w" id="mwB0I"> </span><span class="o" id="mwB0M">=</span><span class="w" id="mwB0Q"> </span><span class="nn" id="mwB0U">MailboxProcessor</span><span class="p" id="mwB0Y">.</span><span class="n" id="mwB0c">Start</span><span class="o" id="mwB0g">(</span><span class="k" id="mwB0k">fun</span><span class="w" id="mwB0o"> </span><span class="n" id="mwB0s">inbox</span><span class="w" id="mwB0w"> </span><span class="o" id="mwB00">-></span> <span class="w" id="mwB04"> </span><span class="k" id="mwB08">let</span><span class="w" id="mwB1A"> </span><span class="nv" id="mwB1E">rec</span><span class="w" id="mwB1I"> </span><span class="n" id="mwB1M">messageLoop</span><span class="w" id="mwB1Q"> </span><span class="kt" id="mwB1U">list</span><span class="w" id="mwB1Y"> </span><span class="o" id="mwB1c">=</span><span class="w" id="mwB1g"> </span><span class="n" id="mwB1k">async</span><span class="w" id="mwB1o"> </span><span class="o" id="mwB1s">{</span> <span class="w" id="mwB1w"> </span><span class="k" id="mwB10">let!</span><span class="w" id="mwB14"> </span><span class="nv" id="mwB18">msg</span><span class="w" id="mwB2A"> </span><span class="o" id="mwB2E">=</span><span class="w" id="mwB2I"> </span><span class="n" id="mwB2M">inbox</span><span class="o" id="mwB2Q">.</span><span class="n" id="mwB2U">Receive</span><span class="bp" id="mwB2Y">()</span> <span class="w" id="mwB2c"> </span><span class="k" id="mwB2g">match</span><span class="w" id="mwB2k"> </span><span class="n" id="mwB2o">msg</span><span class="w" id="mwB2s"> </span><span class="k" id="mwB2w">with</span> <span class="w" id="mwB20"> </span><span class="o" id="mwB24">|</span><span class="w" id="mwB28"> </span><span class="n" id="mwB3A">Enqueue</span><span class="w" id="mwB3E"> </span><span class="n" id="mwB3I">item</span><span class="w" id="mwB3M"> </span><span class="o" id="mwB3Q">-></span> <span class="w" id="mwB3U"> </span><span class="k" id="mwB3Y">return</span><span class="o" id="mwB3c">!</span><span class="w" id="mwB3g"> </span><span class="n" id="mwB3k">messageLoop</span><span class="w" id="mwB3o"> </span><span class="o" id="mwB3s">(</span><span class="n" id="mwB3w">item</span><span class="w" id="mwB30"> </span><span class="o" id="mwB34">::</span><span class="w" id="mwB38"> </span><span class="kt" id="mwB4A">list</span><span class="o" id="mwB4E">)</span> <span class="w" id="mwB4I"> </span><span class="o" id="mwB4M">|</span><span class="w" id="mwB4Q"> </span><span class="n" id="mwB4U">Dequeue</span><span class="w" id="mwB4Y"> </span><span class="n" id="mwB4c">replyChannel</span><span class="w" id="mwB4g"> </span><span class="o" id="mwB4k">-></span> <span class="w" id="mwB4o"> </span><span class="k" id="mwB4s">match</span><span class="w" id="mwB4w"> </span><span class="kt" id="mwB40">list</span><span class="w" id="mwB44"> </span><span class="k" id="mwB48">with</span> <span class="w" id="mwB5A"> </span><span class="o" id="mwB5E">|</span><span class="w" id="mwB5I"> </span><span class="bp" id="mwB5M">[]</span><span class="w" id="mwB5Q"> </span><span class="o" id="mwB5U">-></span><span class="w" id="mwB5Y"> </span> <span class="w" id="mwB5c"> </span><span class="n" id="mwB5g">replyChannel</span><span class="o" id="mwB5k">.</span><span class="n" id="mwB5o">Reply</span><span class="w" id="mwB5s"> </span><span class="n" id="mwB5w">None</span> <span class="w" id="mwB50"> </span><span class="k" id="mwB54">return</span><span class="o" id="mwB58">!</span><span class="w" id="mwB6A"> </span><span class="n" id="mwB6E">messageLoop</span><span class="w" id="mwB6I"> </span><span class="kt" id="mwB6M">list</span> <span class="w" id="mwB6Q"> </span><span class="o" id="mwB6U">|</span><span class="w" id="mwB6Y"> </span><span class="n" id="mwB6c">head</span><span class="w" id="mwB6g"> </span><span class="o" id="mwB6k">::</span><span class="w" id="mwB6o"> </span><span class="n" id="mwB6s">tail</span><span class="w" id="mwB6w"> </span><span class="o" id="mwB60">-></span> <span class="w" id="mwB64"> </span><span class="n" id="mwB68">replyChannel</span><span class="o" id="mwB7A">.</span><span class="n" id="mwB7E">Reply</span><span class="w" id="mwB7I"> </span><span class="o" id="mwB7M">(</span><span class="n" id="mwB7Q">Some</span><span class="w" id="mwB7U"> </span><span class="n" id="mwB7Y">head</span><span class="o" id="mwB7c">)</span> <span class="w" id="mwB7g"> </span><span class="k" id="mwB7k">return</span><span class="o" id="mwB7o">!</span><span class="w" id="mwB7s"> </span><span class="n" id="mwB7w">messageLoop</span><span class="w" id="mwB70"> </span><span class="n" id="mwB74">tail</span> <span class="w" id="mwB78"> </span><span class="o" id="mwB8A">}</span> <span class="w" id="mwB8E"> </span><span class="c1" id="mwB8I">// Start the loop with an empty list</span> <span class="w" id="mwB8M"> </span><span class="n" id="mwB8Q">messageLoop</span><span class="w" id="mwB8U"> </span><span class="bp" id="mwB8Y">[]</span> <span class="w" id="mwB8c"> </span><span class="o" id="mwB8g">)</span> <span class="w" id="mwB8k"> </span><span class="c1" id="mwB8o">// Usage </span> <span class="w" id="mwB8s"> </span><span class="n" id="mwB8w">async</span><span class="w" id="mwB80"> </span><span class="o" id="mwB84">{</span> <span class="w" id="mwB88"> </span><span class="c1" id="mwB9A">// Enqueue some strings</span> <span class="w" id="mwB9E"> </span><span class="n" id="mwB9I">listManager</span><span class="o" id="mwB9M">.</span><span class="n" id="mwB9Q">Post</span><span class="o" id="mwB9U">(</span><span class="n" id="mwB9Y">Enqueue</span><span class="w" id="mwB9c"> </span><span class="s" id="mwB9g">"Hello"</span><span class="o" id="mwB9k">)</span> <span class="w" id="mwB9o"> </span><span class="n" id="mwB9s">listManager</span><span class="o" id="mwB9w">.</span><span class="n" id="mwB90">Post</span><span class="o" id="mwB94">(</span><span class="n" id="mwB98">Enqueue</span><span class="w" id="mwB-A"> </span><span class="s" id="mwB-E">"World"</span><span class="o" id="mwB-I">)</span> <span class="w" id="mwB-M"> </span><span class="c1" id="mwB-Q">// Dequeue and process the strings</span> <span class="w" id="mwB-U"> </span><span class="k" id="mwB-Y">let!</span><span class="w" id="mwB-c"> </span><span class="nv" id="mwB-g">str</span><span class="w" id="mwB-k"> </span><span class="o" id="mwB-o">=</span><span class="w" id="mwB-s"> </span><span class="n" id="mwB-w">listManager</span><span class="o" id="mwB-0">.</span><span class="n" id="mwB-4">PostAndAsyncReply</span><span class="o" id="mwB-8">(</span><span class="n" id="mwB_A">Dequeue</span><span class="o" id="mwB_E">)</span> <span class="w" id="mwB_I"> </span><span class="n" id="mwB_M">str</span><span class="w" id="mwB_Q"> </span><span class="o" id="mwB_U">|></span><span class="w" id="mwB_Y"> </span><span class="nn" id="mwB_c">Option</span><span class="p" id="mwB_g">.</span><span class="n" id="mwB_k">iter</span><span class="w" id="mwB_o"> </span><span class="o" id="mwB_s">(</span><span class="n" id="mwB_w">printfn</span><span class="w" id="mwB_0"> </span><span class="s" id="mwB_4">"Dequeued: %s"</span><span class="o" id="mwB_8">)</span> <span class="w" id="mwCAA"> </span><span class="o" id="mwCAE">}</span> <span class="w" id="mwCAI"> </span><span class="o" id="mwCAM">|></span><span class="w" id="mwCAQ"> </span><span class="nn" id="mwCAU">Async</span><span class="p" id="mwCAY">.</span><span class="n" id="mwCAc">Start</span>

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 (REPL) 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 Ionide extension.
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.

Comparison of integrated development environments

Application areas

F# is a general-purpose programming language.

Web programming

The SAFE Stack is an end-to-end F# stack to develop web applications. It uses ASP.NET Core on the server side and Fable on the client side.

Alternative end-to-end F# options include the WebSharper framework and the Oxpecker framework.

Cross-platform app development

F# can be used together with the Visual Studio Tools for Xamarin to develop apps for iOS and Android. The Fabulous 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.

Scripting

F# can be used as a scripting language, mainly for desktop read–eval–print loop (REPL) 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:

Fable, an F# to Javascript transpiler based on Babel.
Paket, an alternative package manager for .NET that can still use NuGet repositories, but has centralised version-management.
FAKE, an F# friendly build-system.
Giraffe, a functionally oriented middleware for ASP.NET Core.
Suave, a lightweight web-server and web-development library.

Compatibility

F# features a legacy "ML compatibility mode" that can directly compile programs written in a large subset of OCaml roughly, with no functors, objects, polymorphic variants, or other additions.

Examples

A few small samples follow:

<span id="mwCIU"></span><span class="c1" id="mwCIY">// This is a comment for a sample hello world program.</span> <span class="n" id="mwCIc">printfn</span><span class="w" id="mwCIg"> </span><span class="s" id="mwCIk">"Hello World!"</span>

A record type definition. Records are immutable by default and are compared by structural equality.

<span id="mwCI0"></span><span class="k" id="mwCI4">type</span><span class="w" id="mwCI8"> </span><span class="nc" id="mwCJA">Person</span><span class="w" id="mwCJE"> </span><span class="o" id="mwCJI">=</span><span class="w" id="mwCJM"> </span><span class="o" id="mwCJQ">{</span> <span class="w" id="mwCJU"> </span><span class="n" id="mwCJY">FirstName</span><span class="o" id="mwCJc">:</span><span class="w" id="mwCJg"> </span><span class="kt" id="mwCJk">string</span> <span class="w" id="mwCJo"> </span><span class="n" id="mwCJs">LastName</span><span class="o" id="mwCJw">:</span><span class="w" id="mwCJ0"> </span><span class="kt" id="mwCJ4">string</span> <span class="w" id="mwCJ8"> </span><span class="n" id="mwCKA">Age</span><span class="o" id="mwCKE">:</span><span class="w" id="mwCKI"> </span><span class="n" id="mwCKM">int</span> <span class="o" id="mwCKQ">}</span> <span class="c1" id="mwCKU">// Creating an instance of the record</span> <span class="k" id="mwCKY">let</span><span class="w" id="mwCKc"> </span><span class="nv" id="mwCKg">person</span><span class="w" id="mwCKk"> </span><span class="o" id="mwCKo">=</span><span class="w" id="mwCKs"> </span><span class="o" id="mwCKw">{</span><span class="w" id="mwCK0"> </span><span class="n" id="mwCK4">FirstName</span><span class="w" id="mwCK8"> </span><span class="o" id="mwCLA">=</span><span class="w" id="mwCLE"> </span><span class="s" id="mwCLI">"John"</span><span class="o" id="mwCLM">;</span><span class="w" id="mwCLQ"> </span><span class="n" id="mwCLU">LastName</span><span class="w" id="mwCLY"> </span><span class="o" id="mwCLc">=</span><span class="w" id="mwCLg"> </span><span class="s" id="mwCLk">"Doe"</span><span class="o" id="mwCLo">;</span><span class="w" id="mwCLs"> </span><span class="n" id="mwCLw">Age</span><span class="w" id="mwCL0"> </span><span class="o" id="mwCL4">=</span><span class="w" id="mwCL8"> </span><span class="mi" id="mwCMA">30</span><span class="w" id="mwCME"> </span><span class="o" id="mwCMI">}</span>

A Person class with a constructor taking a name and age and two immutable properties.

<span id="mwCMc"></span><span class="sd" id="mwCMg">/// This is a documentation comment for a type definition.</span> <span class="k" id="mwCMk">type</span><span class="w" id="mwCMo"> </span><span class="nc" id="mwCMs">Person</span><span class="o" id="mwCMw">(</span><span class="n" id="mwCM0">name</span><span class="w" id="mwCM4"> </span><span class="o" id="mwCM8">:</span><span class="w" id="mwCNA"> </span><span class="kt" id="mwCNE">string</span><span class="o" id="mwCNI">,</span><span class="w" id="mwCNM"> </span><span class="n" id="mwCNQ">age</span><span class="w" id="mwCNU"> </span><span class="o" id="mwCNY">:</span><span class="w" id="mwCNc"> </span><span class="n" id="mwCNg">int</span><span class="o" id="mwCNk">)</span><span class="w" id="mwCNo"> </span><span class="o" id="mwCNs">=</span> <span class="w" id="mwCNw"> </span><span class="k" id="mwCN0">member</span><span class="w" id="mwCN4"> </span><span class="n" id="mwCN8">x</span><span class="p" id="mwCOA">.</span><span class="nf" id="mwCOE">Name</span><span class="w" id="mwCOI"> </span><span class="o" id="mwCOM">=</span><span class="w" id="mwCOQ"> </span><span class="n" id="mwCOU">name</span> <span class="w" id="mwCOY"> </span><span class="k" id="mwCOc">member</span><span class="w" id="mwCOg"> </span><span class="n" id="mwCOk">x</span><span class="p" id="mwCOo">.</span><span class="nf" id="mwCOs">Age</span><span class="w" id="mwCOw"> </span><span class="o" id="mwCO0">=</span><span class="w" id="mwCO4"> </span><span class="n" id="mwCO8">age</span> <span class="w" id="mwCPA"> </span> <span class="sd" id="mwCPE">/// class instantiation</span> <span class="k" id="mwCPI">let</span><span class="w" id="mwCPM"> </span><span class="nv" id="mwCPQ">mrSmith</span><span class="w" id="mwCPU"> </span><span class="o" id="mwCPY">=</span><span class="w" id="mwCPc"> </span><span class="n" id="mwCPg">Person</span><span class="o" id="mwCPk">(</span><span class="s" id="mwCPo">"Smith"</span><span class="o" id="mwCPs">,</span><span class="w" id="mwCPw"> </span><span class="mi" id="mwCP0">42</span><span class="o" id="mwCP4">)</span>

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#:

<span id="mwCQM"></span><span class="sd" id="mwCQQ">/// Using pattern matching expression</span> <span class="k" id="mwCQU">let</span><span class="w" id="mwCQY"> </span><span class="nv" id="mwCQc">rec</span><span class="w" id="mwCQg"> </span><span class="n" id="mwCQk">factorial</span><span class="w" id="mwCQo"> </span><span class="n" id="mwCQs">n</span><span class="w" id="mwCQw"> </span><span class="o" id="mwCQ0">=</span> <span class="w" id="mwCQ4"> </span><span class="k" id="mwCQ8">match</span><span class="w" id="mwCRA"> </span><span class="n" id="mwCRE">n</span><span class="w" id="mwCRI"> </span><span class="k" id="mwCRM">with</span> <span class="w" id="mwCRQ"> </span><span class="o" id="mwCRU">|</span><span class="w" id="mwCRY"> </span><span class="mi" id="mwCRc">0</span><span class="w" id="mwCRg"> </span><span class="o" id="mwCRk">-></span><span class="w" id="mwCRo"> </span><span class="mi" id="mwCRs">1</span> <span class="w" id="mwCRw"> </span><span class="o" id="mwCR0">|</span><span class="w" id="mwCR4"> </span><span class="o" id="mwCR8">_</span><span class="w" id="mwCSA"> </span><span class="o" id="mwCSE">-></span><span class="w" id="mwCSI"> </span><span class="n" id="mwCSM">n</span><span class="w" id="mwCSQ"> </span><span class="o" id="mwCSU">*</span><span class="w" id="mwCSY"> </span><span class="n" id="mwCSc">factorial</span><span class="w" id="mwCSg"> </span><span class="o" id="mwCSk">(</span><span class="n" id="mwCSo">n</span><span class="w" id="mwCSs"> </span><span class="o" id="mwCSw">-</span><span class="w" id="mwCS0"> </span><span class="mi" id="mwCS4">1</span><span class="o" id="mwCS8">)</span> <span class="sd" id="mwCTA">/// For a single-argument functions there is syntactic sugar (pattern matching function):</span> <span class="k" id="mwCTE">let</span><span class="w" id="mwCTI"> </span><span class="nv" id="mwCTM">rec</span><span class="w" id="mwCTQ"> </span><span class="n" id="mwCTU">factorial</span><span class="w" id="mwCTY"> </span><span class="o" id="mwCTc">=</span><span class="w" id="mwCTg"> </span><span class="k" id="mwCTk">function</span><span class="w" id="mwCTo"> </span> <span class="w" id="mwCTs"> </span><span class="o" id="mwCTw">|</span><span class="w" id="mwCT0"> </span><span class="mi" id="mwCT4">0</span><span class="w" id="mwCT8"> </span><span class="o" id="mwCUA">-></span><span class="w" id="mwCUE"> </span><span class="mi" id="mwCUI">1</span><span class="w" id="mwCUM"> </span> <span class="w" id="mwCUQ"> </span><span class="o" id="mwCUU">|</span><span class="w" id="mwCUY"> </span><span class="n" id="mwCUc">n</span><span class="w" id="mwCUg"> </span><span class="o" id="mwCUk">-></span><span class="w" id="mwCUo"> </span><span class="n" id="mwCUs">n</span><span class="w" id="mwCUw"> </span><span class="o" id="mwCU0">*</span><span class="w" id="mwCU4"> </span><span class="n" id="mwCU8">factorial</span><span class="w" id="mwCVA"> </span><span class="o" id="mwCVE">(</span><span class="n" id="mwCVI">n</span><span class="w" id="mwCVM"> </span><span class="o" id="mwCVQ">-</span><span class="w" id="mwCVU"> </span><span class="mi" id="mwCVY">1</span><span class="o" id="mwCVc">)</span> <span class="w" id="mwCVg"> </span> <span class="sd" id="mwCVk">/// Using fold and range operator</span> <span class="k" id="mwCVo">let</span><span class="w" id="mwCVs"> </span><span class="nv" id="mwCVw">factorial</span><span class="w" id="mwCV0"> </span><span class="n" id="mwCV4">n</span><span class="w" id="mwCV8"> </span><span class="o" id="mwCWA">=</span><span class="w" id="mwCWE"> </span><span class="o" id="mwCWI">[</span><span class="mi" id="mwCWM">1</span><span class="o" id="mwCWQ">..</span><span class="n" id="mwCWU">n</span><span class="o" id="mwCWY">]</span><span class="w" id="mwCWc"> </span><span class="o" id="mwCWg">|></span><span class="w" id="mwCWk"> </span><span class="nn" id="mwCWo">Seq</span><span class="p" id="mwCWs">.</span><span class="n" id="mwCWw">fold</span><span class="w" id="mwCW0"> </span><span class="o" id="mwCW4">(*)</span><span class="w" id="mwCW8"> </span><span class="mi" id="mwCXA">1</span>

Iteration examples:

<span id="mwCXQ"></span><span class="sd" id="mwCXU">/// Iteration using a 'for' loop</span> <span class="k" id="mwCXY">let</span><span class="w" id="mwCXc"> </span><span class="nv" id="mwCXg">printList</span><span class="w" id="mwCXk"> </span><span class="n" id="mwCXo">lst</span><span class="w" id="mwCXs"> </span><span class="o" id="mwCXw">=</span><span class="w" id="mwCX0"> </span> <span class="w" id="mwCX4"> </span><span class="k" id="mwCX8">for</span><span class="w" id="mwCYA"> </span><span class="n" id="mwCYE">x</span><span class="w" id="mwCYI"> </span><span class="k" id="mwCYM">in</span><span class="w" id="mwCYQ"> </span><span class="n" id="mwCYU">lst</span><span class="w" id="mwCYY"> </span><span class="k" id="mwCYc">do</span> <span class="w" id="mwCYg"> </span><span class="n" id="mwCYk">printfn</span><span class="w" id="mwCYo"> </span><span class="o" id="mwCYs">$</span><span class="s" id="mwCYw">"{x}"</span><span class="w" id="mwCY0"> </span> <span class="sd" id="mwCY4">/// Iteration using a higher-order function</span> <span class="k" id="mwCY8">let</span><span class="w" id="mwCZA"> </span><span class="nv" id="mwCZE">printList2</span><span class="w" id="mwCZI"> </span><span class="n" id="mwCZM">lst</span><span class="w" id="mwCZQ"> </span><span class="o" id="mwCZU">=</span><span class="w" id="mwCZY"> </span> <span class="w" id="mwCZc"> </span><span class="nn" id="mwCZg">List</span><span class="p" id="mwCZk">.</span><span class="n" id="mwCZo">iter</span><span class="w" id="mwCZs"> </span><span class="o" id="mwCZw">(</span><span class="n" id="mwCZ0">printfn</span><span class="w" id="mwCZ4"> </span><span class="s" id="mwCZ8">"%d"</span><span class="o" id="mwCaA">)</span><span class="w" id="mwCaE"> </span><span class="n" id="mwCaI">lst</span> <span class="sd" id="mwCaM">/// Iteration using a recursive function and pattern matching</span> <span class="k" id="mwCaQ">let</span><span class="w" id="mwCaU"> </span><span class="nv" id="mwCaY">rec</span><span class="w" id="mwCac"> </span><span class="n" id="mwCag">printList3</span><span class="w" id="mwCak"> </span><span class="n" id="mwCao">lst</span><span class="w" id="mwCas"> </span><span class="o" id="mwCaw">=</span> <span class="w" id="mwCa0"> </span><span class="k" id="mwCa4">match</span><span class="w" id="mwCa8"> </span><span class="n" id="mwCbA">lst</span><span class="w" id="mwCbE"> </span><span class="k" id="mwCbI">with</span> <span class="w" id="mwCbM"> </span><span class="o" id="mwCbQ">|</span><span class="w" id="mwCbU"> </span><span class="bp" id="mwCbY">[]</span><span class="w" id="mwCbc"> </span><span class="o" id="mwCbg">-></span><span class="w" id="mwCbk"> </span><span class="bp" id="mwCbo">()</span> <span class="w" id="mwCbs"> </span><span class="o" id="mwCbw">|</span><span class="w" id="mwCb0"> </span><span class="n" id="mwCb4">h</span><span class="w" id="mwCb8"> </span><span class="o" id="mwCcA">::</span><span class="w" id="mwCcE"> </span><span class="n" id="mwCcI">t</span><span class="w" id="mwCcM"> </span><span class="o" id="mwCcQ">-></span> <span class="w" id="mwCcU"> </span><span class="n" id="mwCcY">printfn</span><span class="w" id="mwCcc"> </span><span class="s" id="mwCcg">"%d"</span><span class="w" id="mwCck"> </span><span class="n" id="mwCco">h</span> <span class="w" id="mwCcs"> </span><span class="n" id="mwCcw">printList3</span><span class="w" id="mwCc0"> </span><span class="n" id="mwCc4">t</span>

Fibonacci examples:

<span id="mwCdI"></span><span class="sd" id="mwCdM">/// Fibonacci Number formula</span> <span class="o" id="mwCdQ">[<</span><span class="n" id="mwCdU">TailCall</span><span class="o" id="mwCdY">>]</span> <span class="k" id="mwCdc">let</span><span class="w" id="mwCdg"> </span><span class="nv" id="mwCdk">fib</span><span class="w" id="mwCdo"> </span><span class="n" id="mwCds">n</span><span class="w" id="mwCdw"> </span><span class="o" id="mwCd0">=</span> <span class="w" id="mwCd4"> </span><span class="k" id="mwCd8">let</span><span class="w" id="mwCeA"> </span><span class="nv" id="mwCeE">rec</span><span class="w" id="mwCeI"> </span><span class="n" id="mwCeM">g</span><span class="w" id="mwCeQ"> </span><span class="n" id="mwCeU">n</span><span class="w" id="mwCeY"> </span><span class="n" id="mwCec">f0</span><span class="w" id="mwCeg"> </span><span class="n" id="mwCek">f1</span><span class="w" id="mwCeo"> </span><span class="o" id="mwCes">=</span> <span class="w" id="mwCew"> </span><span class="k" id="mwCe0">match</span><span class="w" id="mwCe4"> </span><span class="n" id="mwCe8">n</span><span class="w" id="mwCfA"> </span><span class="k" id="mwCfE">with</span> <span class="w" id="mwCfI"> </span><span class="o" id="mwCfM">|</span><span class="w" id="mwCfQ"> </span><span class="mi" id="mwCfU">0</span><span class="w" id="mwCfY"> </span><span class="o" id="mwCfc">-></span><span class="w" id="mwCfg"> </span><span class="n" id="mwCfk">f0</span> <span class="w" id="mwCfo"> </span><span class="o" id="mwCfs">|</span><span class="w" id="mwCfw"> </span><span class="mi" id="mwCf0">1</span><span class="w" id="mwCf4"> </span><span class="o" id="mwCf8">-></span><span class="w" id="mwCgA"> </span><span class="n" id="mwCgE">f1</span> <span class="w" id="mwCgI"> </span><span class="o" id="mwCgM">|</span><span class="w" id="mwCgQ"> </span><span class="o" id="mwCgU">_</span><span class="w" id="mwCgY"> </span><span class="o" id="mwCgc">-></span><span class="w" id="mwCgg"> </span><span class="n" id="mwCgk">g</span><span class="w" id="mwCgo"> </span><span class="o" id="mwCgs">(</span><span class="n" id="mwCgw">n</span><span class="w" id="mwCg0"> </span><span class="o" id="mwCg4">-</span><span class="w" id="mwCg8"> </span><span class="mi" id="mwChA">1</span><span class="o" id="mwChE">)</span><span class="w" id="mwChI"> </span><span class="n" id="mwChM">f1</span><span class="w" id="mwChQ"> </span><span class="o" id="mwChU">(</span><span class="n" id="mwChY">f0</span><span class="w" id="mwChc"> </span><span class="o" id="mwChg">+</span><span class="w" id="mwChk"> </span><span class="n" id="mwCho">f1</span><span class="o" id="mwChs">)</span> <span class="w" id="mwChw"> </span><span class="n" id="mwCh0">g</span><span class="w" id="mwCh4"> </span><span class="n" id="mwCh8">n</span><span class="w" id="mwCiA"> </span><span class="mi" id="mwCiE">0</span><span class="w" id="mwCiI"> </span><span class="mi" id="mwCiM">1</span> <span class="sd" id="mwCiQ">/// Another approach - a lazy infinite sequence of Fibonacci numbers</span> <span class="k" id="mwCiU">let</span><span class="w" id="mwCiY"> </span><span class="nv" id="mwCic">fibSeq</span><span class="w" id="mwCig"> </span><span class="o" id="mwCik">=</span><span class="w" id="mwCio"> </span><span class="nn" id="mwCis">Seq</span><span class="p" id="mwCiw">.</span><span class="n" id="mwCi0">unfold</span><span class="w" id="mwCi4"> </span><span class="o" id="mwCi8">(</span><span class="k" id="mwCjA">fun</span><span class="w" id="mwCjE"> </span><span class="o" id="mwCjI">(</span><span class="n" id="mwCjM">a</span><span class="o" id="mwCjQ">,</span><span class="n" id="mwCjU">b</span><span class="o" id="mwCjY">)</span><span class="w" id="mwCjc"> </span><span class="o" id="mwCjg">-></span><span class="w" id="mwCjk"> </span><span class="n" id="mwCjo">Some</span><span class="o" id="mwCjs">(</span><span class="n" id="mwCjw">a</span><span class="o" id="mwCj0">+</span><span class="n" id="mwCj4">b</span><span class="o" id="mwCj8">,</span><span class="w" id="mwCkA"> </span><span class="o" id="mwCkE">(</span><span class="n" id="mwCkI">b</span><span class="o" id="mwCkM">,</span><span class="w" id="mwCkQ"> </span><span class="n" id="mwCkU">a</span><span class="o" id="mwCkY">+</span><span class="n" id="mwCkc">b</span><span class="o" id="mwCkg">)))</span><span class="w" id="mwCkk"> </span><span class="o" id="mwCko">(</span><span class="mi" id="mwCks">0</span><span class="o" id="mwCkw">,</span><span class="mi" id="mwCk0">1</span><span class="o" id="mwCk4">)</span> <span class="c1" id="mwCk8">// Print even fibs</span> <span class="o" id="mwClA">[</span><span class="mi" id="mwClE">1</span><span class="w" id="mwClI"> </span><span class="o" id="mwClM">..</span><span class="w" id="mwClQ"> </span><span class="mi" id="mwClU">10</span><span class="o" id="mwClY">]</span> <span class="o" id="mwClc">|></span><span class="w" id="mwClg"> </span><span class="nn" id="mwClk">List</span><span class="p" id="mwClo">.</span><span class="n" id="mwCls">map</span><span class="w" id="mwClw"> </span><span class="n" id="mwCl0">fib</span> <span class="o" id="mwCl4">|></span><span class="w" id="mwCl8"> </span><span class="nn" id="mwCmA">List</span><span class="p" id="mwCmE">.</span><span class="n" id="mwCmI">filter</span><span class="w" id="mwCmM"> </span><span class="o" id="mwCmQ">(</span><span class="k" id="mwCmU">fun</span><span class="w" id="mwCmY"> </span><span class="n" id="mwCmc">n</span><span class="w" id="mwCmg"> </span><span class="o" id="mwCmk">-></span><span class="w" id="mwCmo"> </span><span class="o" id="mwCms">(</span><span class="n" id="mwCmw">n</span><span class="w" id="mwCm0"> </span><span class="o" id="mwCm4">%</span><span class="w" id="mwCm8"> </span><span class="mi" id="mwCnA">2</span><span class="o" id="mwCnE">)</span><span class="w" id="mwCnI"> </span><span class="o" id="mwCnM">=</span><span class="w" id="mwCnQ"> </span><span class="mi" id="mwCnU">0</span><span class="o" id="mwCnY">)</span> <span class="o" id="mwCnc">|></span><span class="w" id="mwCng"> </span><span class="n" id="mwCnk">printList</span> <span class="c1" id="mwCno">// Same thing, using a list expression</span> <span class="o" id="mwCns">[</span><span class="w" id="mwCnw"> </span><span class="k" id="mwCn0">for</span><span class="w" id="mwCn4"> </span><span class="n" id="mwCn8">i</span><span class="w" id="mwCoA"> </span><span class="k" id="mwCoE">in</span><span class="w" id="mwCoI"> </span><span class="mi" id="mwCoM">1</span><span class="o" id="mwCoQ">..</span><span class="mi" id="mwCoU">10</span><span class="w" id="mwCoY"> </span><span class="k" id="mwCoc">do</span> <span class="w" id="mwCog"> </span><span class="k" id="mwCok">let</span><span class="w" id="mwCoo"> </span><span class="nv" id="mwCos">r</span><span class="w" id="mwCow"> </span><span class="o" id="mwCo0">=</span><span class="w" id="mwCo4"> </span><span class="n" id="mwCo8">fib</span><span class="w" id="mwCpA"> </span><span class="n" id="mwCpE">i</span> <span class="w" id="mwCpI"> </span><span class="k" id="mwCpM">if</span><span class="w" id="mwCpQ"> </span><span class="n" id="mwCpU">r</span><span class="w" id="mwCpY"> </span><span class="o" id="mwCpc">%</span><span class="w" id="mwCpg"> </span><span class="mi" id="mwCpk">2</span><span class="w" id="mwCpo"> </span><span class="o" id="mwCps">=</span><span class="w" id="mwCpw"> </span><span class="mi" id="mwCp0">0</span><span class="w" id="mwCp4"> </span><span class="k" id="mwCp8">then</span><span class="w" id="mwCqA"> </span><span class="k" id="mwCqE">yield</span><span class="w" id="mwCqI"> </span><span class="n" id="mwCqM">r</span><span class="w" id="mwCqQ"> </span><span class="o" id="mwCqU">]</span> <span class="o" id="mwCqY">|></span><span class="w" id="mwCqc"> </span><span class="n" id="mwCqg">printList</span>

A sample Windows Forms program:

<span id="mwCqw"></span><span class="c1" id="mwCq0">// Open the Windows Forms library</span> <span class="k" id="mwCq4">open</span><span class="w" id="mwCq8"> </span><span class="nn" id="mwCrA">System.Windows.Forms</span> <span class="c1" id="mwCrE">// Create a window and set a few properties</span> <span class="k" id="mwCrI">let</span><span class="w" id="mwCrM"> </span><span class="nv" id="mwCrQ">form</span><span class="w" id="mwCrU"> </span><span class="o" id="mwCrY">=</span><span class="w" id="mwCrc"> </span><span class="k" id="mwCrg">new</span><span class="w" id="mwCrk"> </span><span class="n" id="mwCro">Form</span><span class="o" id="mwCrs">(</span><span class="n" id="mwCrw">Visible</span><span class="o" id="mwCr0">=</span><span class="k" id="mwCr4">true</span><span class="o" id="mwCr8">,</span><span class="w" id="mwCsA"> </span><span class="n" id="mwCsE">TopMost</span><span class="o" id="mwCsI">=</span><span class="k" id="mwCsM">true</span><span class="o" id="mwCsQ">,</span><span class="w" id="mwCsU"> </span><span class="n" id="mwCsY">Text</span><span class="o" id="mwCsc">=</span><span class="s" id="mwCsg">"Welcome to F#"</span><span class="o" id="mwCsk">)</span> <span class="c1" id="mwCso">// Create a label to show some text in the form</span> <span class="k" id="mwCss">let</span><span class="w" id="mwCsw"> </span><span class="nv" id="mwCs0">label</span><span class="w" id="mwCs4"> </span><span class="o" id="mwCs8">=</span> <span class="w" id="mwCtA"> </span><span class="k" id="mwCtE">let</span><span class="w" id="mwCtI"> </span><span class="nv" id="mwCtM">x</span><span class="w" id="mwCtQ"> </span><span class="o" id="mwCtU">=</span><span class="w" id="mwCtY"> </span><span class="mi" id="mwCtc">3</span><span class="w" id="mwCtg"> </span><span class="o" id="mwCtk">+</span><span class="w" id="mwCto"> </span><span class="o" id="mwCts">(</span><span class="mi" id="mwCtw">4</span><span class="w" id="mwCt0"> </span><span class="o" id="mwCt4">*</span><span class="w" id="mwCt8"> </span><span class="mi" id="mwCuA">5</span><span class="o" id="mwCuE">)</span> <span class="w" id="mwCuI"> </span><span class="k" id="mwCuM">new</span><span class="w" id="mwCuQ"> </span><span class="n" id="mwCuU">Label</span><span class="o" id="mwCuY">(</span><span class="n" id="mwCuc">Text</span><span class="w" id="mwCug"> </span><span class="o" id="mwCuk">=</span><span class="w" id="mwCuo"> </span><span class="o" id="mwCus">$</span><span class="s" id="mwCuw">"{x}"</span><span class="o" id="mwCu0">)</span> <span class="c1" id="mwCu4">// Add the label to the form</span> <span class="n" id="mwCu8">form</span><span class="o" id="mwCvA">.</span><span class="n" id="mwCvE">Controls</span><span class="o" id="mwCvI">.</span><span class="n" id="mwCvM">Add</span><span class="o" id="mwCvQ">(</span><span class="n" id="mwCvU">label</span><span class="o" id="mwCvY">)</span> <span class="c1" id="mwCvc">// Finally, run the form</span> <span class="o" id="mwCvg">[<</span><span class="nn" id="mwCvk">System</span><span class="p" id="mwCvo">.</span><span class="n" id="mwCvs">STAThread</span><span class="o" id="mwCvw">>]</span> <span class="nn" id="mwCv0">Application</span><span class="p" id="mwCv4">.</span><span class="n" id="mwCv8">Run</span><span class="o" id="mwCwA">(</span><span class="n" id="mwCwE">form</span><span class="o" id="mwCwI">)</span>

Asynchronous parallel programming sample (parallel CPU and I/O tasks):

<span id="mwCwY"></span><span class="sd" id="mwCwc">/// A simple prime number detector</span> <span class="k" id="mwCwg">let</span><span class="w" id="mwCwk"> </span><span class="nv" id="mwCwo">isPrime</span><span class="w" id="mwCws"> </span><span class="o" id="mwCww">(</span><span class="n" id="mwCw0">n</span><span class="o" id="mwCw4">:</span><span class="n" id="mwCw8">int</span><span class="o" id="mwCxA">)</span><span class="w" id="mwCxE"> </span><span class="o" id="mwCxI">=</span> <span class="w" id="mwCxM"> </span><span class="k" id="mwCxQ">let</span><span class="w" id="mwCxU"> </span><span class="nv" id="mwCxY">bound</span><span class="w" id="mwCxc"> </span><span class="o" id="mwCxg">=</span><span class="w" id="mwCxk"> </span><span class="n" id="mwCxo">int</span><span class="w" id="mwCxs"> </span><span class="o" id="mwCxw">(</span><span class="n" id="mwCx0">sqrt</span><span class="w" id="mwCx4"> </span><span class="o" id="mwCx8">(</span><span class="kt" id="mwCyA">float</span><span class="w" id="mwCyE"> </span><span class="n" id="mwCyI">n</span><span class="o" id="mwCyM">))</span> <span class="w" id="mwCyQ"> </span><span class="n" id="mwCyU">seq</span><span class="w" id="mwCyY"> </span><span class="o" id="mwCyc">{</span><span class="mi" id="mwCyg">2</span><span class="w" id="mwCyk"> </span><span class="o" id="mwCyo">..</span><span class="w" id="mwCys"> </span><span class="n" id="mwCyw">bound</span><span class="o" id="mwCy0">}</span><span class="w" id="mwCy4"> </span><span class="o" id="mwCy8">|></span><span class="w" id="mwCzA"> </span><span class="nn" id="mwCzE">Seq</span><span class="p" id="mwCzI">.</span><span class="n" id="mwCzM">forall</span><span class="w" id="mwCzQ"> </span><span class="o" id="mwCzU">(</span><span class="k" id="mwCzY">fun</span><span class="w" id="mwCzc"> </span><span class="n" id="mwCzg">x</span><span class="w" id="mwCzk"> </span><span class="o" id="mwCzo">-></span><span class="w" id="mwCzs"> </span><span class="n" id="mwCzw">n</span><span class="w" id="mwCz0"> </span><span class="o" id="mwCz4">%</span><span class="w" id="mwCz8"> </span><span class="n" id="mwC0A">x</span><span class="w" id="mwC0E"> </span><span class="o" id="mwC0I"><></span><span class="w" id="mwC0M"> </span><span class="mi" id="mwC0Q">0</span><span class="o" id="mwC0U">)</span> <span class="c1" id="mwC0Y">// We are using async workflows</span> <span class="k" id="mwC0c">let</span><span class="w" id="mwC0g"> </span><span class="nv" id="mwC0k">primeAsync</span><span class="w" id="mwC0o"> </span><span class="n" id="mwC0s">n</span><span class="w" id="mwC0w"> </span><span class="o" id="mwC00">=</span> <span class="w" id="mwC04"> </span><span class="n" id="mwC08">async</span><span class="w" id="mwC1A"> </span><span class="o" id="mwC1E">{</span><span class="w" id="mwC1I"> </span><span class="k" id="mwC1M">return</span><span class="w" id="mwC1Q"> </span><span class="o" id="mwC1U">(</span><span class="n" id="mwC1Y">n</span><span class="o" id="mwC1c">,</span><span class="w" id="mwC1g"> </span><span class="n" id="mwC1k">isPrime</span><span class="w" id="mwC1o"> </span><span class="n" id="mwC1s">n</span><span class="o" id="mwC1w">)</span><span class="w" id="mwC10"> </span><span class="o" id="mwC14">}</span> <span class="sd" id="mwC18">/// Return primes between m and n using multiple threads</span> <span class="k" id="mwC2A">let</span><span class="w" id="mwC2E"> </span><span class="nv" id="mwC2I">primes</span><span class="w" id="mwC2M"> </span><span class="n" id="mwC2Q">m</span><span class="w" id="mwC2U"> </span><span class="n" id="mwC2Y">n</span><span class="w" id="mwC2c"> </span><span class="o" id="mwC2g">=</span> <span class="w" id="mwC2k"> </span><span class="n" id="mwC2o">seq</span><span class="w" id="mwC2s"> </span><span class="o" id="mwC2w">{</span><span class="n" id="mwC20">m</span><span class="w" id="mwC24"> </span><span class="o" id="mwC28">..</span><span class="w" id="mwC3A"> </span><span class="n" id="mwC3E">n</span><span class="o" id="mwC3I">}</span> <span class="w" id="mwC3M"> </span><span class="o" id="mwC3Q">|></span><span class="w" id="mwC3U"> </span><span class="nn" id="mwC3Y">Seq</span><span class="p" id="mwC3c">.</span><span class="n" id="mwC3g">map</span><span class="w" id="mwC3k"> </span><span class="n" id="mwC3o">primeAsync</span> <span class="w" id="mwC3s"> </span><span class="o" id="mwC3w">|></span><span class="w" id="mwC30"> </span><span class="nn" id="mwC34">Async</span><span class="p" id="mwC38">.</span><span class="n" id="mwC4A">Parallel</span> <span class="w" id="mwC4E"> </span><span class="o" id="mwC4I">|></span><span class="w" id="mwC4M"> </span><span class="nn" id="mwC4Q">Async</span><span class="p" id="mwC4U">.</span><span class="n" id="mwC4Y">RunSynchronously</span> <span class="w" id="mwC4c"> </span><span class="o" id="mwC4g">|></span><span class="w" id="mwC4k"> </span><span class="nn" id="mwC4o">Array</span><span class="p" id="mwC4s">.</span><span class="n" id="mwC4w">filter</span><span class="w" id="mwC40"> </span><span class="n" id="mwC44">snd</span> <span class="w" id="mwC48"> </span><span class="o" id="mwC5A">|></span><span class="w" id="mwC5E"> </span><span class="nn" id="mwC5I">Array</span><span class="p" id="mwC5M">.</span><span class="n" id="mwC5Q">map</span><span class="w" id="mwC5U"> </span><span class="n" id="mwC5Y">fst</span> <span class="c1" id="mwC5c">// Run a test</span> <span class="n" id="mwC5g">primes</span><span class="w" id="mwC5k"> </span><span class="mi" id="mwC5o">1000000</span><span class="w" id="mwC5s"> </span><span class="mi" id="mwC5w">1002000</span> <span class="w" id="mwC50"> </span><span class="o" id="mwC54">|></span><span class="w" id="mwC58"> </span><span class="nn" id="mwC6A">Array</span><span class="p" id="mwC6E">.</span><span class="n" id="mwC6I">iter</span><span class="w" id="mwC6M"> </span><span class="o" id="mwC6Q">(</span><span class="n" id="mwC6U">printfn</span><span class="w" id="mwC6Y"> </span><span class="s" id="mwC6c">"%d"</span><span class="o" id="mwC6g">)</span>