F# uses an open development and engineering process.  The language evolution process is managed by Don Syme from Microsoft Research as the BDFL for the language design in conjunction 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, and the language was originally designed and implemented by Don Syme,[2] according to whom the name F# refers to either functional programming or System F.[18] Andrew Kennedy contributed to the design of units of measure.[2] The Visual F# Tools for Visual Studio are developed by Microsoft.[2] 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.[8]

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.[22] 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.[22] For example:

letx=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 and option types.[22] 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 (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 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 {rwithName="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). 

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.[22] All functions in F# are first class values and are immutable.[22] 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. 

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.[24] It is used, for example, when multiple ways of matching on a type exist.[22]

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.[23]

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. 

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'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 (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.[25]Inversion of control in F# follows this pattern.[25]

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[7] code. 

F# includes a feature for run-time meta-programming called quotations.[28] A quotation expression evaluates to an abstract syntax representation of F# expressions.  A definition labelled with the [<ReflectedDefinition>] attribute can also be accessed in its quotation form.  F# quotations are used for various purposes including to compile F# code to JavaScript[6] and GPU[7] code. 

F# 3.0 introduced a form of compile-time meta-programming through statically extensible type generation called F# type providers.[29] 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.[30]

In F# 3.0 the F# quotation and computation expression features are combined to implement LINQ queries.[31] For example:

// Use the OData type provider to create types that can be used to access the Northwind database.openMicrosoft. FSharp. Data. TypeProviderstypeNorthwind=ODataService<"http://services.odata.org/Northwind/Northwind.svc">letdb=Northwind. GetDataContext()// A query expression.letquery1=query{forcustomerindb. Customersdoselectcustomer}

The combination of type providers, queries and strongly typed functional programming is known as information rich programming.[32]

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. 

F# can be developed with any text editor.  Specific support exists in editors such as Emacs. 

WebSharper[33] 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. 

Among others, F# is used for quantitative finance programming,[34] energy trading and portfolio optimization,[35] machine learning,[36] business intelligence[37] and social gaming on Facebook.[38]

In recent years F# has been positioned as an optimized alternative to C#.  F#'s scripting ability and IL compatibility with all Microsoft products have made it popular among developers.  Many developers are creating solutions based on F# and use C# WCF Services.[clarification needed][citation needed][who?] 

// This is a comment for a sample hello world program.printfn"Hello World!" 

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

/// This is a documentation comment for a type definition.typePerson(name:string,age:int)=memberx. Name=namememberx. Age=age

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

/// This is a documentation comment for a function.letrecfactorialn=matchnwith|0->1|_->n*factorial(n-1)

Iteration examples:

/// Iteration using a 'for' loopletprintListlst=forxinlstdoprintfn"%d"x/// Iteration using a higher-order functionletprintList2lst=List.iter(printfn"%d")lst/// Iteration using a recursive function and pattern matchingletrecprintList3lst=matchlstwith|[]->()|h::t->printfn"%d"hprintList3t

Fibonacci examples:

/// Fibonacci Number formulaletrecfibn=matchnwith|0|1->n|_->fib(n-2)+fib(n-1)/// Another approach - a lazy infinite sequence of Fibonacci numbersletfibSeq=Seq.unfold(fun(a,b)->Some(a+b,(b,a+b)))(0,1)// Print even fibs[1..10]|>List.mapfib|>List.filter(funn->(n%2)=0)|>printList// Same thing, using a list expression[foriin1..10doletr=fibiifr%2=0thenyieldr]|>printList

A sample Windows Forms program:

// Open the Windows Forms libraryopenSystem. Windows. Forms// Create a window and set a few propertiesletform=newForm(Visible=true,TopMost=true,Text="Welcome to F#")// Create a label to show some text in the formletlabel=letx=3+(4*5)newLabel(Text=sprintf"x = %d"x)// Add the label to the formform. Controls. Add(label)// Finally, run the form[<System. STAThread>]Application. Run(form)

/// A simple prime number detectorletisPrime(n:int)=letbound=int(sqrt(floatn))seq{2..bound}|>Seq.forall(funx->n%x<>0)// We are using async workflowsletprimeAsyncn=async{return(n,isPrimen)}/// Return primes between m and n using multiple threadsletprimesmn=seq{m..n}|>Seq.mapprimeAsync|>Async. Parallel|>Async. RunSynchronously|>Array.filtersnd|>Array.mapfst// Run a testprimes10000001002000|>Array.iter(printfn"%d")