| F# | |
|---|---|
 | |
| Paradigms | Multi-paradigm:functional,imperative,object-oriented,agent-oriented,metaprogramming,reflective,concurrent |
| Family | ML:Caml:OCaml |
| Designed by | Don Syme,Microsoft Research |
| Developer | Microsoft,The F# Software Foundation |
| First appeared | 2005; 20 years ago (2005), version 1.0 |
| Stable release | |
| Typing discipline | Static,strong,inferred |
| OS | Cross-platform:.NET framework,Mono |
| License | MIT[2][3] |
| Filename extensions | .fs, .fsi, .fsx, .fsscript |
| Website | fsharp |
| Influenced by | |
| C#,Erlang,Haskell,[4]ML,OCaml,[5][6]Python,Scala | |
| Influenced | |
| C#,[7]Elm,F*,LiveScript | |
| |
F# (pronouncedF sharp) is ageneral-purpose,high-level,strongly typed,multi-paradigmprogramming language that encompassesfunctional,imperative, andobject-oriented programming methods. It is most often used as across-platformCommon Language Infrastructure (CLI) language on.NET, but can also generateJavaScript[8] andgraphics processing unit (GPU) code.[9]
F# is developed by theF# Software Foundation,[10]Microsoft and open contributors. Anopen source, cross-platform compiler for F# is available from the F# Software Foundation.[11] F# is a fully supported language inVisual Studio[12] andJetBrains Rider.[13]Plug-ins supporting F# exist for many widely used editors includingVisual Studio Code,Vim, andEmacs.
F# is a member of theML language family and originated as a.NET Framework implementation of a core of the programming languageOCaml.[5][6] It has also been influenced byC#,Python,Haskell,[4]Scala andErlang.
| F# version | Language specification | Date | Platforms | Runtime |
|---|---|---|---|---|
| 1.x | May 2005[14] | Windows | .NET 1.0 - 3.5 | |
| 2.0 | August 2010 | April 2010[15] | Linux,macOS,Windows | .NET 2.0 - 4.0,Mono |
| 3.0 | November 2012 | August 2012[16] | Linux,macOS,Windows; JavaScript,[8]GPU[9] | .NET 2.0 - 4.5,Mono |
| 3.1 | November 2013 | October 2013[17] | Linux,macOS,Windows; JavaScript,[8]GPU[9] | .NET 2.0 - 4.5,Mono |
| 4.0 | January 2016 | July 2015[18] | ||
| 4.1 | May 2018 | March 2017[19] | Linux,macOS,Windows, | .NET 3.5 - 4.6.2,.NET,Mono |
| 4.5 | August 2018[20] | Linux,macOS,Windows, | .NET 4.5 - 4.7.2,[21].NET Core SDK 2.1.400[22] | |
| 4.6 | March 2019[23] | Linux,macOS,Windows, | .NET 4.5 - 4.7.2,[24].NET Core SDK 2.2.300[25] | |
| 4.7 | September 2019[26] | Linux,macOS,Windows, | .NET 4.5 - 4.8,[27].NET Core SDK 3.0.100[28] | |
| 5.0 | November 2020[29] | Linux,macOS,Windows, | .NET SDK 5.0.100[30] | |
| 6.0 | November 2021[31] | Linux,macOS,Windows, | .NET SDK 6.0.100[32] | |
| 7.0 | November 2022[33] | Linux,macOS,Windows, | .NET SDK 7.0.100[34] | |
| 8.0 | November 2023[35] | Linux,macOS,Windows, | .NET SDK 8.0.100[36] | |
| 9.0 | November 2024[37] | Linux,macOS,Windows, | .NET SDK 9.0.0[38] |
F# uses an open development and engineering process. The language evolution process is managed byDon Syme fromMicrosoft Research as thebenevolent dictator for life (BDFL) for the language design, together with the F# Software Foundation.Earlier versions of the F# language were designed byMicrosoft andMicrosoft Research using a closed development process.
F# was first included in Visual Studio in the2010 edition, at the same level asVisual 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 byDon Syme,[5] according to whom in the fsharp team, they say the F is for "Fun".[39] Andrew Kennedy contributed to the design of units of measure.[5] The Visual F# Tools for Visual Studio are developed by Microsoft.[5] 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.[10]
| F# version | Features added |
|---|---|
| 1.0 |
|
| 2.0 |
|
| 3.0[40] |
|
| 3.1[41] |
|
| 4.0[42] |
|
| 4.1[43] |
|
| 4.5[29] |
|
| 4.6 |
|
| 4.7[44] |
|
| 5.0[45] |
|
| 6.0[46] |
|
| 7.0[47] |
|
| 8.0[48] |
|
| 9.0[50] |
|
F# is astrongly typed functional-first language with a large number of capabilities that are normally found only infunctional 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:
F# is an expression-based language usingeager evaluation and also in some instanceslazy evaluation. Every statement in F#, includingif expressions,try expressions and loops, is a composable expression with a static type.[53] Functions and expressions that do not return any value have a return type ofunit. F# uses thelet keyword for binding values to a name.[53] For example:
letx=3+4
binds the value7 to the namex.
New types are defined using thetype keyword. For functional programming, F# providestuple,record,discriminated union,list,option, andresult types.[53] Atuple represents a set ofn values, wheren ≥ 0. The valuen is called thearity 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.
Arecord is a type where the data members are named. Here is an example of record definition:
typeR={Name:stringAge:int}
Records can be created asletr={Name="AB";Age=42}. Thewith keyword is used to create a copy of a record, as in{rwithName="CD"}, which creates a new record by copyingr and changing the value of theName field (assuming the record created in the last example was namedr).
Adiscriminated union type is atype-safe version ofC unions. For example,
typeA=|UnionCaseXofstring|UnionCaseYofint
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.
Thelist type is an immutablelinked list represented either using ahead::tail notation (:: is thecons operator) or a shorthand as[item1;item2;item3]. An empty list is written[]. Theoption type is a discriminated union type with choicesSome(x) orNone. F# types may begeneric, implemented as generic .NET types.
F# supportslambda functions andclosures.[53] All functions in F# are first class values and are immutable.[53] Functions can becurried. Being first-class values, functions can be passed as arguments to other functions. Like other functional programming languages, F# allowsfunction composition using the>> and<< operators.
F# providessequence expressions[54] that define a sequenceseq { ... }, list[ ... ] or array[| ... |] through code that generates values. For example,
seq{forbin0..25doifb<15thenyieldb*b}
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 aregenerators – values are generated on-demand (i.e., arelazily evaluated) – while lists and arrays are evaluated eagerly.
F# usespattern 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 supportsactive patterns as a form of extensible pattern matching.[55] It is used, for example, when multiple ways of matching on a type exist.[53]
F# supports a general syntax for defining compositional computations calledcomputation expressions. Sequence expressions, asynchronous computations and queries are particular kinds of computation expressions. Computation expressions are an implementation of themonad pattern.[54]
F# support for imperative programming includes
forloopswhileloops[| ... |] syntaxdict [ ... ] syntax orSystem.Collections.Generic.Dictionary<_,_> type.Values and record fields can also be labelled asmutable. For example:
// Define 'x' with initial value '1'letmutablex=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 theSystem.Collections.Generic namespace defining imperative data structures.
Like otherCommon Language Infrastructure (CLI) languages, F# can use CLI types through object-oriented programming.[53] F# support for object-oriented programming in expressions includes:
x.Name{newobj()withmemberx.ToString()="hello"}newForm()x:?stringx:?>stringx.Method(someArgument=1)newForm(Text="Hello")x.Method(OptionalArgument=1)Support for object-oriented programming in patterns includes
:?stringassF# object type definitions can be class, struct, interface, enum, or delegate type definitions, corresponding to the definition forms found inC#. For example, here is a class with a constructor taking a name and age, and declaring two properties.
/// A simple object type definitiontypePerson(name:string,age:int)=memberx.Name=namememberx.Age=age
F# supportsasynchronous programming throughasynchronous workflows.[56] An asynchronous workflow is defined as a sequence of commands inside anasync{ ... }, as in
letasynctask=async{letreq=WebRequest.Create(url)let!response=req.GetResponseAsync()usestream=response.GetResponseStream()usestreamreader=newSystem.IO.StreamReader(stream)returnstreamreader.ReadToEnd()}
Thelet! 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 theAsync.RunSynchronously function. Multiple async blocks can be executed in parallel using theAsync.Parallel function that takes a list ofasync 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 usingAsync.RunSynchronously.[56]
Inversion of control in F# follows this pattern.[56]
Since version 6.0, F# supports creating, consuming and returning .NET tasks directly.[57]
openSystem.Net.HttpletfetchUrlAsync(url:string)=// string -> Task<string>task{useclient=newHttpClient()let!response=client.GetAsync(url)let!content=response.Content.ReadAsStringAsync()do!Task.Delay500returncontent}// UsageletfetchPrint()=lettask=task{let!data=fetchUrlAsync"https://example.com"printfn$"{data}"}task.Wait()
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 theArray.Parallel functional programming operators in the F# standard library, direct use of theSystem.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 asGPU[9] code.
The F# type system supportsunits of measure checking for numbers:[58] units of measure, such as meters or kilograms, can be assigned to floating point, unsigned integer[59] 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.[60]
[<Measure>]typem// meter[<Measure>]types// secondletdistance=100.0<m>// float<m>lettime=5.0<s>// float<s>letspeed=distance/time// float<m/s>[<Measure>]typekg// kilogram[<Measure>]typeN=(kg*m)/(s^2)// Newtons[<Measure>]typePa=N/(m^2)// Pascals[<Measure>]typedaysletbetter_age=3u<days>// uint<days>
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.
F# allows some forms of syntax customizing viametaprogramming to support embedding customdomain-specific languages within the F# language, particularly through computation expressions.[53]
F# includes a feature for run-time meta-programming called quotations.[61] 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 intoJavaScript[8] andGPU[9] 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.
F# 3.0 introduced a form of compile-time meta-programming through statically extensible type generation called F# type providers.[62] 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 theFreebase knowledge graph.[63]
In F# 3.0 the F# quotation and computation expression features are combined to implementLINQ queries.[64] 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 asinformation rich programming.[65]
F# supports a variation of theactor programming model through the in-memory implementation of lightweight asynchronous agents. For example, the following code defines an agent and posts 2 messages:
typeMessage=|Enqueueofstring|DequeueofAsyncReplyChannel<Option<string>>// Provides concurrent access to a list of stringsletlistManager=MailboxProcessor.Start(funinbox->letrecmessageLooplist=async{let!msg=inbox.Receive()matchmsgwith|Enqueueitem->return!messageLoop(item::list)|DequeuereplyChannel->matchlistwith|[]->replyChannel.ReplyNonereturn!messageLooplist|head::tail->replyChannel.Reply(Somehead)return!messageLooptail}// Start the loop with an empty listmessageLoop[])// Usageasync{// Enqueue some stringslistManager.Post(Enqueue"Hello")listManager.Post(Enqueue"World")// Dequeue and process the stringslet!str=listManager.PostAndAsyncReply(Dequeue)str|>Option.iter(printfn"Dequeued: %s")}|>Async.Start
| IDE | License | Windows | Linux | macOS | Developer |
|---|---|---|---|---|---|
| Microsoft Visual Studio | Proprietary (standard) Freeware (community edition) | Yes | No | Yes | Microsoft |
| Visual Studio Code[67] | Proprietary (binary code) MIT License (source code) | Yes | Yes | Yes | Microsoft |
| Rider[68] | Proprietary | Yes | Yes | Yes | JetBrains |
F# is ageneral-purpose programming language.
TheSAFE Stack is an end-to-end F# stack to develop web applications. It usesASP.NET Core on the server side andFable on the client side.[69]
Alternative end-to-end F# options include theWebSharper framework and the Oxpecker framework.[70]
F# can be used together with theVisual Studio Tools for Xamarin to develop apps foriOS andAndroid. TheFabulous library provides a more comfortable functional interface.
Among others, F# is used for quantitative finance programming,[71] energy trading and portfolio optimization,[72] machine learning,[73] business intelligence[74] and social gaming onFacebook.[75]
In the 2010s, F# has been positioned as an optimized alternative toC#. F#'s scripting ability and inter-language compatibility with all Microsoft products have made it popular among developers.[76]
F# can be used as a scripting language, mainly for desktopread–eval–print loop (REPL) scripting.[77]
The F#open-source community includes the F# Software Foundation[10] and the F# Open Source Group atGitHub.[11] Popular open-source F# projects include:
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.
A few small samples follow:
// This is a comment for a sample hello world program.printfn"Hello World!"
A record type definition. Records are immutable by default and are compared by structural equality.
typePerson={FirstName:stringLastName:stringAge:int}// Creating an instance of the recordletperson={FirstName="John";LastName="Doe";Age=30}
A Person class with a constructor taking a name and age and two immutable properties.
/// This is a documentation comment for a type definition.typePerson(name:string,age:int)=memberx.Name=namememberx.Age=age/// class instantiationletmrSmith=Person("Smith",42)
A simple example that is often used to demonstrate the syntax of functional languages is thefactorial function for non-negative 32-bit integers, here shown in F#:
/// Using pattern matching expressionletrecfactorialn=matchnwith|0->1|_->n*factorial(n-1)/// For a single-argument functions there is syntactic sugar (pattern matching function):letrecfactorial=function|0->1|n->n*factorial(n-1)/// Using fold and range operatorletfactorialn=[1..n]|>Seq.fold(*)1
Iteration examples:
/// Iteration using a 'for' loopletprintListlst=forxinlstdoprintfn$"{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 formula[<TailCall>]letfibn=letrecgnf0f1=matchnwith|0->f0|1->f1|_->g(n-1)f1(f0+f1)gn01/// 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=$"{x}")// Add the label to the formform.Controls.Add(label)// Finally, run the form[<System.STAThread>]Application.Run(form)
Asynchronous parallel programming sample (parallel CPU and I/O tasks):
/// 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")
{{cite web}}:Missing or empty|title= (help)[F#] is rooted in the Core ML design, and in particular has a core language largely compatible with that of OCaml
ML programming | ||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Software |
|  | ||||||||||||
| Community |
| |||||||||||||
 Book Category:Family:MLCategory:Family:OCamlCategory:Software:OCaml | ||||||||||||||
| Overview | |||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Software |
| ||||||||||||
| Licenses | |||||||||||||
| Forges | |||||||||||||
| Related | |||||||||||||
| Main projects |
| ||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| MSR Labs applied research |
| ||||||||||||||
