View source for F Sharp (programming language)

{{Short description|Microsoft programming language}}
{{Distinguish|F (programming language)|F* (programming language)}}
{{Correct title|title=F#|reason=#}}
{{Infobox programming language
| name = F#
| logo = F Sharp logo.svg
| logo size = 128px
| logo caption = 
| paradigms = [[Programming paradigm#Multi-paradigm|Multi-paradigm]]: [[functional programming|functional]], [[imperative programming|imperative]], [[object-oriented programming|object-oriented]], [[agent-oriented programming|agent-oriented]], [[metaprogramming]], [[Reflective programming|reflective]], [[concurrent programming|concurrent]]
| family = [[ML (programming language)|ML]]: [[Caml]]: [[OCaml]]
| designer = [[Don Syme]], [[Microsoft Research]]
| developer = [[Microsoft]], [[F Sharp Software Foundation|The F# Software Foundation]]
| released = {{Start date and age|2005}}, version 1.0
| latest_release_version = {{wikidata|property|reference|edit| Q648619 |P348}}
| latest_release_date = {{start date and age|df=yes|{{wikidata|qualifier| Q648619 |P348|P577}}}}
| latest preview version = 
| latest preview date = 
| typing = [[Static typing|Static]], [[Strong and weak typing|strong]], [[Type inference|inferred]]
| implementations = 
| dialects = 
| influenced by = [[C Sharp (programming language)|C#]], [[Erlang (programming language)|Erlang]], [[Haskell]],<ref name="haskellInfluence">{{harvcoltxt|Syme|Granicz|Cisternino|2007|p=2|quote=F# also draws from Haskell particularly with regard to two advanced language features called ''sequence expressions'' and ''workflows''.}}</ref> [[ML (programming language)|ML]], [[OCaml]],<ref name="historyMSR"/><ref name="ocamlOrigins">{{cite web |title=Leveraging .NET Meta-programming Components from F# |first1=Don |last1=Syme |authorlink1=Don Syme |url=http://research.microsoft.com/apps/pubs/default.aspx?id=147193|year=2006|quote=[F#] is rooted in the Core ML design, and in particular has a core language largely compatible with that of OCaml}}</ref> [[Python (programming language)|Python]], [[Scala (programming language)|Scala]]
| influenced = [[C Sharp (programming language)|C#]],<ref>for async</ref> [[Elm (programming language)|Elm]], [[F* (programming language)|F*]], [[LiveScript (programming language)|LiveScript]]
| programming language = 
| operating system = [[Cross-platform software|Cross-platform]]: [[.NET]] framework, [[Mono (software)|Mono]]
| license = [[MIT License|MIT]]<ref>{{cite web |url=https://github.com/fsharp/fsharp/blob/master/License.txt |title=F# Software Foundation's License |website=[[GitHub]] |date=14 October 2021}}</ref><ref>{{cite web |url=https://github.com/Microsoft/visualfsharp/blob/master/License.txt |title=Microsoft's F# License |website=[[GitHub]] |date=16 October 2021}}</ref>
| website = {{URL|https://fsharp.org/}}


{{URL|https://learn.microsoft.com/en-us/dotnet/fsharp}}
| wikibooks = F Sharp Programming
| file ext = .fs, .fsi, .fsx, .fsscript
}}
'''F#''' (pronounced '''F sharp''') is a [[General-purpose programming language|general-purpose]], [[High-level programming language|high-level]], [[Strong and weak typing|strongly typed]], [[Programming paradigm#Multi-paradigm|multi-paradigm]] [[programming language]] that encompasses [[functional programming|functional]], [[imperative programming|imperative]], and [[object-oriented programming]] methods. It is most often used as a [[Cross-platform software|cross-platform]] [[Common Language Infrastructure]] (CLI) language on [[.NET]], but can also generate [[JavaScript]]<ref name="js">{{cite web |url=http://fsharp.org/use/web-apps/ |title=Using F# for Web Applications |author=The F# Software Foundation |access-date=2020-07-30}}</ref> and [[graphics processing unit]] (GPU) code.<ref name="gpgpu">{{cite web |url=http://fsharp.org/use/gpu/ |archive-url=https://web.archive.org/web/20191225110926/http://fsharp.org/use/gpu/ |url-status=dead |archive-date=2019-12-25 |title=Using F# for GPU Programming |author=The F# Software Foundation |access-date=2019-12-25}}</ref>

F# is developed by the [[F Sharp Software Foundation|F# Software Foundation]],<ref name="fsharporg">{{cite web |url=http://fsharp.org |title=The F# Software Foundation |author=The F# Software Foundation |access-date=2012-11-24}}</ref> [[Microsoft]] and open contributors. An [[Open-source software|open source]], cross-platform compiler for F# is available from the F# Software Foundation.<ref name="fsharposg">{{cite web |url=https://fsharp.github.io |title=F# Compiler (open source edition) @ github |author=The F# Software Foundation |access-date=2012-11-24}}</ref> F# is a fully supported language in [[Microsoft Visual Studio|Visual Studio]]<ref>{{cite web |url=https://docs.microsoft.com/en-us/visualstudio/ide/fsharp-visual-studio |title=Develop with Visual F# in Visual Studio |access-date=2020-07-30}}</ref> and [[JetBrains#IDEs|JetBrains Rider]].<ref>{{cite web |url=https://www.jetbrains.com/help/rider/F_Sharp.html |title=F# |access-date=2020-07-30}}</ref> [[Plug-in (computing)|Plug-ins]] supporting F# exist for many widely used editors including [[Visual Studio Code]], [[Vim (text editor)|Vim]], and [[Emacs]].

F# is a member of the [[ML (programming language)|ML]] language family and originated as a [[.NET Framework]] implementation of a core of the programming language [[OCaml]].<ref name="historyMSR"/><ref name="ocamlOrigins"/> It has also been influenced by [[C Sharp (programming language)|C#]], 
[[Python (programming language)|Python]], [[Haskell]],<ref name="haskellInfluence"/> [[Scala (programming language)|Scala]] and [[Erlang (programming language)|Erlang]].

==History==

===Versions===
{| class="wikitable"
|-
! F#<br/>version
! Language specification
! Date
! [[Computing platform|Platforms]]
! [[Runtime system|Runtime]]
|-
| 1.x
| 
| May 2005<ref>{{cite web|last=Syme|first=Don|title=F# 1.0.8 released|url=http://blogs.msdn.com/b/dsyme/archive/2005/05/21/420795.aspx|publisher=Microsoft|access-date=September 7, 2014}}</ref>
|[[Microsoft Windows|Windows]]
|[[.NET Framework|.NET]] 1.0 - 3.5
|-
| 2.0
| [http://fsharp.org/specs/language-spec/index.html#f-20 August 2010]
| April 2010<ref>{{cite web|last=Syme|first=Don|title=F# 2.0 released as part of Visual Studio 2010|url=http://blogs.msdn.com/b/dsyme/archive/2010/04/12/f-2-0-released-as-part-of-visual-studio-2010.aspx|publisher=Microsoft|access-date=September 7, 2014}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]] 
|[[.NET Framework|.NET]] 2.0 - 4.0, [[Mono (software)|Mono]]
|-
| 3.0
| [http://fsharp.org/specs/language-spec/index.html#f-30 November 2012]
| August 2012<ref>{{cite web|last=Zander|first=Jason|title=Visual Studio 2012 and .NET Framework 4.5 released to the web|url=http://blogs.msdn.com/b/jasonz/archive/2012/08/15/visual-studio-2012-and-net-framework-4-5-released-to-the-web.aspx|publisher=Microsoft|access-date=September 7, 2014}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]];<br/>[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
|[[.NET Framework|.NET]] 2.0 - 4.5, [[Mono (software)|Mono]]
|-
| 3.1
| [http://fsharp.org/specs/language-spec/index.html#f-31 November 2013]
| October 2013<ref>{{cite web|title=Visual Studio 2013 released to web|date=17 October 2013 |url=http://blogs.msdn.com/b/visualstudio/archive/2013/10/17/visual-studio-2013-released-to-web.aspx|publisher=Microsoft|access-date=September 7, 2014}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]];<br/>[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
|[[.NET Framework|.NET]] 2.0 - 4.5, [[Mono (software)|Mono]]
|-
| 4.0
| [http://fsharp.org/specs/language-spec/index.html#f-40 January 2016]
| July 2015<ref>{{cite web|title=Announcing the RTM of Visual F# 4.0|url=http://blogs.msdn.com/b/dotnet/archive/2015/07/20/announcing-the-rtm-of-visual-f-4-0.aspx|publisher=Microsoft|access-date=September 15, 2015}}</ref>
|<!-- [[Linux]], [[macOS]], [[Microsoft Windows|Windows]];<br/>[[JavaScript]], [[Graphics processing unit|GPU]] -->
|<!-- [[.NET Framework|.NET]] 2.0 - 4.5, [[Mono (software)|Mono]] -->
|-
| 4.1
| [http://fsharp.org/specs/language-spec/index.html#f-41 May 2018]
|March 2017<ref>{{Cite news|url=https://blogs.msdn.microsoft.com/dotnet/2017/03/07/announcing-f-4-1-and-the-visual-f-tools-for-visual-studio-2017-2/|title=Announcing F# 4.1 and the Visual F# Tools for Visual Studio 2017|access-date=2017-03-08|language=en-US}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
|[[.NET Framework|.NET]] 3.5 - 4.6.2, [[.NET]], [[Mono (software)|Mono]]
|-
| 4.5
|
|August 2018<ref>{{cite web|title=Announcing F# 4.5|date=14 August 2018|url=https://blogs.msdn.microsoft.com/dotnet/2018/08/14/announcing-f-4-5/|publisher=Microsoft|access-date=August 14, 2018}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
| [[.NET Framework|.NET]] 4.5 - 4.7.2,<ref>{{Cite web|url=https://www.nuget.org/packages/FSharp.Core/4.5.0|title=FSharp.Core 4.5.0}}</ref> [[.NET]] Core SDK 2.1.400<ref>{{cite web|title=Download .NET Core 2.1 (Linux, macOS, and Windows)|url=https://dotnet.microsoft.com/download/dotnet/2.1|publisher=Microsoft|access-date=May 13, 2021}}</ref>
|-
| 4.6
|
|March 2019<ref>{{cite web|title=Announcing F# 4.6|date=29 March 2019|url=https://devblogs.microsoft.com/dotnet/announcing-f-4-6/|publisher=Microsoft|access-date=March 29, 2019}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
| [[.NET Framework|.NET]] 4.5 - 4.7.2,<ref>{{Cite web|url=https://www.nuget.org/packages/FSharp.Core/4.6.0|title=FSharp.Core 4.6.0}}</ref> [[.NET]] Core SDK 2.2.300<ref>{{cite web|title=Download .NET Core 2.2 (Linux, macOS, and Windows)|url=https://dotnet.microsoft.com/download/dotnet/2.2|publisher=Microsoft|access-date=May 13, 2021}}</ref>
|-
| 4.7
|
|September 2019<ref>{{cite web|title=Announcing F# 4.7|date=23 September 2019|url=https://devblogs.microsoft.com/dotnet/announcing-f-4-7/|publisher=Microsoft|access-date=September 23, 2019}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
| [[.NET Framework|.NET]] 4.5 - 4.8,<ref>{{Cite web|url=https://www.nuget.org/packages/FSharp.Core/4.7.0|title=FSharp.Core 4.7.0}}</ref> [[.NET]] Core SDK 3.0.100<ref>{{cite web|title=Download .NET Core 3.0 (Linux, macOS, and Windows)|url=https://dotnet.microsoft.com/download/dotnet/3.0|publisher=Microsoft|access-date=May 13, 2021}}</ref>
|-
| 5.0
|
|November 2020<ref name="blogs.msdn.microsoft.com2">{{Cite web|url=https://devblogs.microsoft.com/dotnet/announcing-f-5/|title=Announcing F# 5|date=November 10, 2020}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
| [[.NET]] SDK 5.0.100<ref>{{cite web|title=Download .NET 5.0 (Linux, macOS, and Windows)|url=https://dotnet.microsoft.com/download/dotnet/5.0|publisher=Microsoft|access-date=May 13, 2021}}</ref>
|-
| 6.0
|
|November 2021<ref>{{Cite web|url=https://devblogs.microsoft.com/dotnet/fsharp-6-is-officially-here/|title=F# 6 is officially here!|date=November 9, 2021}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
| [[.NET]] SDK 6.0.100<ref>{{cite web|title=Download .NET 6.0 (Linux, macOS, and Windows)|url=https://dotnet.microsoft.com/download/dotnet/6.0|publisher=Microsoft|access-date=November 14, 2021}}</ref>
|-
| 7.0
|
|November 2022<ref>{{Cite web|url=https://devblogs.microsoft.com/dotnet/announcing-fsharp-7/|title=Announcing F# 7|date=November 8, 2022}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
| [[.NET]] SDK 7.0.100<ref>{{cite web|title=Download .NET 7.0 (Linux, macOS, and Windows)|url=https://dotnet.microsoft.com/en-us/download/dotnet/7.0|publisher=Microsoft|access-date=November 8, 2022}}</ref>
|-
| 8.0
|
|November 2023<ref>{{Cite web|url=https://devblogs.microsoft.com/dotnet/announcing-fsharp-8/|title=Announcing F# 8|date=November 14, 2023}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
| [[.NET]] SDK 8.0.100<ref>{{cite web|title=Download .NET 8.0 (Linux, macOS, and Windows)|url=https://dotnet.microsoft.com/en-us/download/dotnet/8.0|publisher=Microsoft|access-date=November 14, 2023}}</ref>
|-
| 9.0
|
|November 2024<ref>{{Cite web|url=https://learn.microsoft.com/en-us/dotnet/fsharp/whats-new/fsharp-9|title=What's new in F# 9|date=November 12, 2024}}</ref>
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"/> [[Graphics processing unit|GPU]]<ref name="gpgpu"/>
| [[.NET]] SDK 9.0.0<ref>{{cite web|title=Download .NET 9.0 (Linux, macOS, and Windows)|url=https://dotnet.microsoft.com/en-us/download/dotnet/9.0|publisher=Microsoft|access-date=January 13, 2025}}</ref>
|}

===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 [[Visual Studio#2010|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]],<ref name="historyMSR">{{cite web |url=https://www.microsoft.com/en-us/research/project/f-at-microsoft-research/ |title=F# Historical Acknowledgements |website=[[Microsoft]]}}</ref> according to whom in the fsharp team, they say the F is for "Fun".<ref>{{cite web |url=http://www.networkworld.com/article/2271225/software/the-a-z-of-programming-languages--f-.html |title=The A-Z of programming languages: F# |last1=Edwards |first1=Kathryn |date=23 December 2008 |website=[[Network World]] |publisher=IDG |access-date=8 August 2016 |archive-date=13 November 2018 |archive-url=https://web.archive.org/web/20181113210720/https://www.networkworld.com/article/2271225/software/the-a-z-of-programming-languages--f-.html |url-status=dead}}</ref> 
Andrew Kennedy contributed to the design of units of measure.<ref name="historyMSR"/> The Visual F# Tools for Visual Studio are developed by Microsoft.<ref name="historyMSR"/> 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.<ref name="fsharporg"/>

{| class="wikitable"
|+ Summary of versions
|-
! F#<br/>version
! Features added
|-
! 1.0
|valign="top"|
* Functional programming
* Discriminated unions
* Records
* Tuples
* Pattern matching
* Type abbreviations
* Object-oriented programming
* Structs
* Signature files
* Scripting files
* Imperative programming
* Modules (no functors)
* Nested modules
* .NET interoperability
|-
! 2.0
|
* Active patterns
* Units of measure
* Sequence expressions
* Asynchronous programming
* Agent programming
* Extension members
* Named arguments
* Optional arguments
* Array slicing
* Quotations
* Native interoperability
* Computation expressions
|-
! 3.0<ref>{{cite web|last=McNamara|first=Brian|title=More About F# 3.0 Language Features|url=http://blogs.msdn.com/b/fsharpteam/archive/2012/07/19/more-about-fsharp-3.0-language-features.aspx|access-date=September 7, 2014|publisher=Microsoft}}</ref>
|
* Type providers
* LINQ query expressions
* CLIMutable attribute
* Triple-quoted strings
* Auto-properties
* Provided units-of-measure
|-
! 3.1<ref>{{cite web|last=McNamara|first=Brian|title=Announcing a pre-release of F# 3.1|url=http://blogs.msdn.com/b/fsharpteam/archive/2013/06/27/announcing-a-pre-release-of-f-3-1-and-the-visual-f-tools-in-visual-studio-2013.aspx|access-date=September 7, 2014|publisher=Microsoft}}</ref>
|
* Named union type fields
* Extensions to array slicing
* Type inference enhancements
|-
! 4.0<ref>{{Cite news|title=Announcing the RTM of Visual F# 4.0|language=en-US|url=https://blogs.msdn.microsoft.com/dotnet/2015/07/20/announcing-the-rtm-of-visual-f-4-0/|access-date=2017-03-08}}</ref>
|
* Printf on unitized values
* Extension property initializers
* Non-null provided types
* Primary constructors as functions
* Static parameters for provided methods
* Printf interpolation
* Extended #if grammar
* Tailcall attribute
* Multiple interface instantiations
* Optional type args
* Params dictionaries
|-
! 4.1<ref>{{Cite news|title=Announcing F# 4.1 and the Visual F# Tools for Visual Studio 2017|language=en-US|url=https://blogs.msdn.microsoft.com/dotnet/2017/03/07/announcing-f-4-1-and-the-visual-f-tools-for-visual-studio-2017-2/|access-date=2017-03-08}}</ref>
|
* Struct tuples which inter-operate with C# tuples
* Struct annotations for Records
* Struct annotations for Single-case Discriminated Unions
* Underscores in numeric literals
* Caller info argument attributes
* Result type and some basic Result functions
* Mutually referential types and modules within the same file
* Implicit "Module" syntax on modules with shared name as type
* Byref returns, supporting consuming C# ref-returning methods
* Error message improvements
* Support for 'fixed'
|-
! 4.5<ref name="blogs.msdn.microsoft.com2"/>
|
* Versioning alignment of binary, package, and language
* Support for 'Span<T>' and related types
* Ability to produce 'byref' returns
* The 'voidptr' type
* The 'inref<'T>' and 'outref<'T>' types to represent readonly and write-only 'byref's
* 'IsByRefLike' structs
* 'IsReadOnly' structs
* Extension method support for 'byref<'T>'/'inref<'T>'/'outref<'T>'
* 'match!' keyword in computation expressions
* Relaxed upcast with 'yield' in F# seq/list/array expressions
* Relaxed indentation with list and array expressions
* Enumeration cases emitted as public
|-
! 4.6
|
* Anonymous record types
|-
! 4.7<ref name="blogs.msdn.microsoft.com.4.7">{{Cite web|url=https://devblogs.microsoft.com/dotnet/announcing-f-4-7/|title=Announcing F# 4.7|date=23 September 2019}}</ref>
|
* Implicit yields
* No more required double underscore
* Indentation relaxations for parameters passed to constructors and static methods
* 'nameof' function
* Open static classes
|-
! 5.0<ref name="blogs.msdn.microsoft.com.5.0">{{Cite web|url=https://devblogs.microsoft.com/dotnet/announcing-f-5/|title=Announcing F# 5|date=10 November 2020}}</ref>
|
* FSharp.Core now targets netstandard2.0 only
* Package references in F# scripts
* Support for Jupyter, nteract, and VSCode Notebooks
* String Interpolation
* Support for nameof
* Open Type declarations
* Enhanced Slicing
* F# quotations improvements
* Applicative Computation Expressions
* Improved stack traces in F# async and other computation expressions
* Improved .NET interop
* Improved Map and Set performance in FSharp.Core
* Improved compiler performance
* Improved compiler analysis for library authors
|-
! 6.0<ref>{{Cite web|url=https://docs.microsoft.com/en-us/dotnet/fsharp/whats-new/fsharp-6|title=What's new in F# 6 - F# Guide|date=10 March 2023}}</ref>
|
* Tasks
* Simpler indexing
* Augments to "active patterns"
* Overloaded custom operations in computation expressions
* “as” patterns
* Indentation syntax revisions
* More implicit conversions
* More implicit upcast conversions
* Implicit integer conversions
* First-class support for .NET-style implicit conversions
* Optional warnings for implicit conversions
* Formatting for binary numbers
* Discards on use bindings
* InlineIfLambda optimizer directive
* Resumable code
* More collection functions
* Map has Keys and Values
* More intrinsics for NativePtr
* More numeric types with unit annotations
* Informational warnings for rarely used symbolic operators
|-
! 7.0<ref>{{Cite web |url=https://devblogs.microsoft.com/dotnet/announcing-fsharp-7/ |title=Announcing F# 7 |date=8 November 2022}}</ref>
|
* Static abstract members support in interfaces
* Making working with SRTPs (statically resolved type parameters) easier
* Required properties checking
* Init scope and init-only properties
* Reference assemblies support
* F# self-contained deployments & Native AOT
* Added support for N-d arrays up to rank 32.
* Result module functions parity with Option.
* Fixes in resumable state machines codegen for the tasks builds.
* Better codegen for compiler-generated side-effect-free property getters
* ARM64 platform-specific compiler and ARM64 target support in F# compiler. Dependency manager #r caching support
* Parallel type-checking and project-checking support (experimental, can be enabled via VS setting, or by tooling authors)
* Miscellaneous bugfixes and improvements.
|-
! 8.0<ref>{{Cite web|url=https://devblogs.microsoft.com/dotnet/announcing-fsharp-8/|title=Announcing F# 8| date=14 November 2023}}</ref>
|
* _.Property shorthand for (fun x -> x.Property)
* Nested record field copy and update
* while! (while bang) feature <ref>{{Cite web |url=https://devblogs.microsoft.com/dotnet/simplifying-fsharp-computations-with-the-new-while-keyword/ |title=Simplifying F# computations with the new 'while!' keyword' |date=20 September 2023}}</ref>
* Extended string interpolation syntax
* Use and compose string literals for printf and related functions
* Arithmetic operators in literals
* Type constraint intersection syntax
* Extended fixed binding
* Easier [<Extension>] method definition
* Static members in interfaces
* Static let in discriminated unions, records, structs, and types without primary constructors
* try-with within seq{}, [], and [||] collection expressions
* Recursive calls and yield! within exception handler
* Tail call attribute
* [<Struct>] unions can now have > 49 cases
* Strict indentation rules
* New diagnostics from the compiler
* Switches for compiler parallelization
|-
! 9.0<ref>{{Cite web|url=https://learn.microsoft.com/en-us/dotnet/fsharp/whats-new/fsharp-9|title=What's new in F# 9| date=12 November 2024}}</ref>
|
* Nullable reference types
* Discriminated union .Is* properties
* Partial active patterns can return bool instead of unit option
* Prefer extension methods to intrinsic properties when arguments are provided
* Empty-bodied computation expressions
* Hash directives are allowed to take non-string arguments
* Extended #help directive in fsi to show documentation in the REPL
* Allow #nowarn to support the FS prefix on error codes to disable warnings
* Warning about TailCall attribute on non-recursive functions or let-bound values
* Enforce attribute targets
* Updates to the standard library (FSharp.Core)
* Developer productivity improvements
* Performance improvements
* Improvements in tooling
|}

==Language overview==

===Functional programming===
F# is a [[Strong and weak typing|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 system|Hindley–Milner type inference]])
* [[First-class function|Functions as first-class citizens]]
* [[Anonymous function]]s with capturing semantics (i.e., [[Closure (computer science)|closures]])
* Immutable variables and objects
* [[Lazy evaluation]] support
* [[Higher-order function]]s
* Nested functions
* [[Currying]]
* [[Pattern matching]]
* [[Algebraic data types]] 
* [[Tuple (computer science)|Tuples]]
* [[List comprehension]]
* [[Monad (functional programming)|Monad]] pattern support (called ''computation expressions''<ref>{{Cite web|title=F Sharp Programming/Computation Expressions - Wikibooks, open books for an open world|url=https://en.wikibooks.org/wiki/F_Sharp_Programming/Computation_Expressions|access-date=2022-01-21|website=en.wikibooks.org|language=en}}</ref>)
* [[Tail call|Tail call optimisation]]<ref>{{Cite web |last=kexugit |title=Tail calls in F# |url=https://docs.microsoft.com/en-us/archive/blogs/fsharpteam/tail-calls-in-f |access-date=2022-04-22 |website=docs.microsoft.com |date=8 July 2011 |language=en-us}}</ref>

F# is an expression-based language using [[eager evaluation]] and also in some instances [[lazy evaluation]]. Every statement in F#, 
including <code>if</code> expressions, <code>try</code> expressions and loops, is a composable expression with a static type.<ref name="overview"/> Functions and expressions that do not return any value have a return type of <code>unit</code>. F# uses the <code>let</code> keyword for binding values to a name.<ref name="overview">{{cite web |url=http://tomasp.net/articles/fsharp-i-introduction/article.pdf |title=F# Language Overview |access-date=2007-12-14}}</ref> For example:
<syntaxhighlight lang="fsharp">
let x = 3 + 4
</syntaxhighlight>
binds the value <code>7</code> to the name <code>x</code>.

New types are defined using the <code>type</code> keyword. For functional programming, F# provides ''tuple'', ''record'', ''discriminated union'', ''list'', ''option'', and ''result'' types.<ref name="overview"/> A ''[[n-tuple|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 <code>(A, B, C)</code>, 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: 
<syntaxhighlight lang="fsharp">
 type R = 
        { Name : string 
         Age : int }
</syntaxhighlight>
Records can be created as {{code|lang=fsharp|code=let r = { Name="AB"; Age=42 } }}. The <code>with</code> keyword is used to create a copy of a record, as in {{code|lang=fsharp|code={ r with Name="CD" } }}, which creates a new record by copying <code>r</code> and changing the value of the <code>Name</code> field (assuming the record created in the last example was named <code>r</code>).

A [[tagged union|discriminated union]] type is a [[type-safe]] version of [[union (computer science)|C unions]]. For example,
<syntaxhighlight lang="fsharp">
 type A = 
    | UnionCaseX of string
    | UnionCaseY of int
</syntaxhighlight>
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 {{code|lang=fsharp|code=head::tail}} notation (<code>::</code> is the [[cons]] operator) or a shorthand as {{code|lang=fsharp|code=[item1; item2; item3]}}. An empty list is written <code>[]</code>. The ''option'' type is a discriminated union type with choices <code>Some(x)</code> or <code>None</code>. F# types may be [[generic programming|generic]], implemented as generic .NET types.

F# supports [[lambda calculus|lambda functions]] and [[closure (computing)|closure]]s.<ref name="overview"/> All functions in F# are first class values and are immutable.<ref name="overview"/> Functions can be [[curry function|curried]]. Being first-class values, functions can be passed as arguments to other functions. Like other functional programming languages, F# allows [[function composition (computer science)|function composition]] using the <code>>></code> and <code><<</code> operators.

F# provides ''{{visible anchor|sequence expressions}}''<ref name="seq"/> that define a sequence <code>seq { ... }</code>, list <code>[ ... ]</code> or array <code>[| ... |]</code> through code that generates values. For example,
<syntaxhighlight lang="fsharp">
 seq { for b in 0 .. 25 do
           if b < 15 then
               yield b*b }
</syntaxhighlight>
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 [[Generator (computer programming)|generators]] – values are generated on-demand (i.e., are [[lazy evaluation|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.<ref name="activePatterns"/> It is used, for example, when multiple ways of matching on a type exist.<ref name="overview"/>

F# supports a general syntax for defining compositional computations called ''{{visible anchor|computation expressions}}''. Sequence expressions, asynchronous computations and queries are particular kinds of computation expressions. Computation expressions are an implementation of the [[monad (functional programming)|monad]] pattern.<ref name="seq">{{cite web |url=http://blogs.msdn.com/dsyme/archive/2007/09/22/some-details-on-f-computation-expressions-aka-monadic-or-workflow-syntax.aspx |title=Some Details on F# Computation Expressions |access-date=2007-12-14}}</ref>

===Imperative programming===
F# support for imperative programming includes
* <code>for</code> [[Control flow#Loops|loops]]
* <code>while</code> [[Control flow#Loops|loops]]
* [[array data structure|arrays]], created with the <code>[| ... |]</code> syntax
* [[Associative array|hash table]], created with the <code>dict [ ... ]</code> syntax or <code>System.Collections.Generic.Dictionary<_,_></code> type.
Values and record fields can also be labelled as <code>mutable</code>. For example:
<syntaxhighlight lang="fsharp">
// Define 'x' with initial value '1'
let mutable x = 1
// Change the value of 'x' to '3'
x <- 3
</syntaxhighlight>
Also, F# supports access to all CLI types and objects such as those defined in the <code>System.Collections.Generic</code> namespace defining imperative data structures.

===Object-oriented programming===
Like other [[Common Language Infrastructure]] (CLI) languages, F# can use CLI types through object-oriented programming.<ref name="overview"/> F# support for object-oriented programming in expressions includes:
* Dot-notation, e.g., {{code|lang=fsharp|code=x.Name}}
* Object expressions, e.g., {{ code|lang=fsharp| code={ new obj() with member x.ToString() = "hello" } }}
* Object construction, e.g., {{code|lang=fsharp|code=new Form()}}
* Type tests, e.g., {{code|lang=fsharp|code=x :? string}}
* Type coercions, e.g., {{code|lang=fsharp|code=x :?> string}}
* Named arguments, e.g., {{code|lang=fsharp|code=x.Method(someArgument=1)}}
* Named setters, e.g., {{code|lang=fsharp|code=new Form(Text="Hello")}}
* Optional arguments, e.g., {{code|lang=fsharp|code=x.Method(OptionalArgument=1)}}

Support for object-oriented programming in patterns includes
* Type tests, e.g., {{code|lang=fsharp|code=:? string as s}}
* Active patterns, which can be defined over object types<ref name="activePatterns">{{cite web |url=http://www.developerfusion.com/article/133772/pattern-matching-in-f-part-2-active-patterns/ |title=Pattern Matching in F# Part 2 : Active Patterns |access-date=2012-11-24 |archive-date=2012-12-09 |archive-url=https://web.archive.org/web/20121209125518/http://www.developerfusion.com/article/133772/pattern-matching-in-f-part-2-active-patterns |url-status=dead}}</ref>

F# object type definitions can be class, struct, interface, enum, or delegate type definitions, corresponding to the definition forms found in [[C Sharp (programming language)|C#]]. For example, here is a class with a constructor taking a name and age, and declaring two properties.
<syntaxhighlight lang="fsharp">
/// A simple object type definition
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age
</syntaxhighlight>

===Asynchronous programming===
F# supports [[asynchronous programming]] through ''asynchronous workflows''.<ref name="aw"/> An asynchronous workflow is defined as a sequence of commands inside an <code>async{ ... }</code>, as in
<syntaxhighlight lang="fsharp">
let asynctask = 
    async { let req = WebRequest.Create(url)
            let! response = req.GetResponseAsync()
            use stream = response.GetResponseStream()
            use streamreader = new System.IO.StreamReader(stream)
            return streamreader.ReadToEnd() }
</syntaxhighlight>
The <code>let!</code> 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 until the result needed for this one becomes available.

The async block may be invoked using the <code>Async.RunSynchronously</code> function. Multiple async blocks can be executed in parallel using the <code>Async.Parallel</code> function that takes a list of <code>async</code> objects (in the example, <code>asynctask</code> is an async object) and creates another async object to run the tasks in the lists in parallel. The resultant object is invoked using <code>Async.RunSynchronously</code>.<ref name="aw">{{cite web |url=http://blogs.msdn.com/dsyme/archive/2007/10/11/introducing-f-asynchronous-workflows.aspx |title=Introducing F# Asynchronous Workflows |access-date=2007-12-14}}</ref>

[[Inversion of control]] in F# follows this pattern.<ref name="aw"/>

Since version 6.0, F# supports creating, consuming and returning .NET tasks directly. <ref>{{cite web |url=https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/task-expressions | title=Task Expressions| date=19 April 2022|access-date=2023-01-15}}</ref>

<syntaxhighlight lang="fsharp">
    open System.Net.Http
    let fetchUrlAsync (url:string) = // string -> Task<string>
        task {
            use client = new HttpClient()
            let! response = client.GetAsync(url) 
            let! content = response.Content.ReadAsStringAsync()
            do! Task.Delay 500
            return content
        }

    // Usage
    let fetchPrint() =
        let task = task {
            let! data = fetchUrlAsync "https://example.com"
            printfn $"{data}"
        } 
        task.Wait()

</syntaxhighlight>

===Parallel programming===
Parallel programming is supported partly through the <code>Async.Parallel</code>, <code>Async.Start</code> and other operations that run asynchronous blocks in parallel.

Parallel programming is also supported through the <code>Array.Parallel</code> functional programming operators in the F# standard library, direct use of the <code>System.Threading.Tasks</code> 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 [[Graphics processing unit|GPU]]<ref name="gpgpu"/> code.

===Units of measure===
The F# type system supports [[Units of measurement|units of measure]] checking for numbers.<ref name="units-msdn">{{cite web |url=http://msdn.microsoft.com/en-us/library/dd233243.aspx |title=Units of Measure (F#) |access-date=2012-11-24}}</ref> 

In F#, you can assign units of measure, such as meters or kilograms, to floating point, unsigned integer<ref name="units extended">{{cite web|url=https://github.com/fsharp/fslang-design/blob/main/FSharp-6.0/FS-1091-Extend-Units-of-Measure.md| title=Extend Units of Measure to Include More Numeric Types | website=[[GitHub]] }}</ref> 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 aren't mistakenly added to times.

The units of measure feature integrates with F# type inference to require minimal type annotations in user code.<ref name="units">{{cite web |url=http://blogs.msdn.com/b/andrewkennedy/archive/2008/08/29/units-of-measure-in-f-part-one-introducing-units.aspx |title=Units of Measure in F#: Part One, Introducing Units |access-date=2012-11-24}}</ref>


<syntaxhighlight lang="fsharp">
[<Measure>] type m                  // meter
[<Measure>] type s                  // second

let distance = 100.0<m>     // float<m>
let time = 5.0<s>           // float<s>
let speed = distance/time   // float<m/s>


[<Measure>] type kg                 // kilogram
[<Measure>] type N = (kg * m)/(s^2) // Newtons
[<Measure>] type Pa = N/(m^2)       // Pascals 

[<Measure>] type days 
let better_age = 3u<days>          // uint<days>

</syntaxhighlight>

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 language]]s within the F# language, particularly through computation expressions.<ref name="overview"/>

F# includes a feature for run-time meta-programming called quotations.<ref name="quotations">{{cite web |url=http://msdn.microsoft.com/en-us/library/dd233212.aspx |title=Code Quotations (F#) |access-date=2012-11-24}}</ref> A quotation expression evaluates to an abstract syntax tree representation of the F# expressions. Similarly, definitions labelled with the <code>[&lt;ReflectedDefinition&gt;]</code> attribute can also be accessed in their quotation form. F# quotations are used for various purposes including to compile F# code into [[JavaScript]]<ref name="js"/> and [[Graphics processing unit|GPU]]<ref name="gpgpu"/> 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.<ref name="typeproviders">{{cite web |url=http://msdn.microsoft.com/en-us/library/hh156509.aspx |title=Type Providers |access-date=2012-11-24}}</ref> 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 (database)|Freebase]] knowledge graph.<ref>{{cite web |url=http://blogs.msdn.com/b/dsyme/archive/2012/09/21/new-tech-report-from-microsoft-research-strongly-typed-language-support-for-internet-scale-information-sources.aspx |title=New Tech Report from Microsoft Research: Strongly-Typed Language Support for Internet-Scale Information Sources |access-date=2012-11-24}}</ref>

In F# 3.0 the F# quotation and computation expression features are combined to implement [[LINQ]] queries.<ref name="queries">{{cite web |url=http://msdn.microsoft.com/en-us/library/vstudio/hh225374.aspx |title=Query Expressions (F#) |access-date=2012-11-24}}</ref> For example:
<syntaxhighlight lang="fsharp">
// Use the OData type provider to create types that can be used to access the Northwind database.
open Microsoft.FSharp.Data.TypeProviders

type Northwind = ODataService<"http://services.odata.org/Northwind/Northwind.svc">
let db = Northwind.GetDataContext()

// A query expression.
let query1 = query { for customer in db.Customers do
                     select customer }
</syntaxhighlight>

The combination of type providers, queries and strongly typed functional programming is known as ''information rich programming''.<ref name="irp">{{cite web |url=http://www.infoq.com/news/2011/09/Fsharp-3.0 |title=F# 3.0 – LINQ + Type Providers= Information Rich Programming |access-date=2012-11-24}}</ref>

===Agent programming===
F# supports a variation of the [[Actor model|actor]] programming model through the in-memory implementation of lightweight asynchronous agents. For example, the following code defines an agent and posts 2 messages:

<syntaxhighlight lang="fsharp">
    type Message =
        | Enqueue of string
        | Dequeue of AsyncReplyChannel<Option<string>>

    // Provides concurrent access to a list of strings
    let listManager = MailboxProcessor.Start(fun inbox ->
        let rec messageLoop list = async {
            let! msg = inbox.Receive()
            match msg with
                | Enqueue item ->
                    return! messageLoop (item :: list)

                | Dequeue replyChannel ->
                    match list with
                    | [] -> 
                        replyChannel.Reply None
                        return! messageLoop list
                    | head :: tail ->
                        replyChannel.Reply (Some head)
                        return! messageLoop tail
        }

        // Start the loop with an empty list
        messageLoop []
    )

    // Usage 
    async {
        // Enqueue some strings
        listManager.Post(Enqueue "Hello")
        listManager.Post(Enqueue "World")

        // Dequeue and process the strings
        let! str = listManager.PostAndAsyncReply(Dequeue)
        str |> Option.iter (printfn "Dequeued: %s")

    }
    |> Async.Start


</syntaxhighlight>

==Development tools==
* [[Microsoft Visual Studio|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 [http://ionide.io/ 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.<ref>{{cite web|title=Rider 2019.1 Kicks off its Early Access Program!|author=Alexander Kurakin |date=15 March 2019 |url=https://blog.jetbrains.com/dotnet/2019/03/15/rider-2019-1-kicks-off-early-access-program/}}</ref>
* [[LINQPad]] has supported F# since version 2.x.{{whose|date=May 2022}}
===Comparison of integrated development environments===
{{excerpt|Comparison of integrated development environments|F#}}

==Application areas==
F# is a [[general-purpose programming language]].

===Web programming===

The [https://safe-stack.github.io/ SAFE Stack] is an end-to-end F# stack to develop web applications. It uses [[ASP.NET Core]] on the server side and [https://fable.io Fable] on the client side.<ref>{{Cite web|url=http://fable.io/|title=Fable: JavaScript you can be proud of!|website=fable.io|access-date=2017-12-09}}</ref>

Alternative end-to-end F# options include the [[WebSharper]] framework and the Oxpecker framework.<ref name="websharper">{{cite web |url=http://websharper.com |title=WebSharper home |author=Intellifactory |access-date=2012-11-24}}</ref>

===Cross-platform app development===

F# can be used together with the [https://visualstudio.microsoft.com/xamarin/ Visual Studio Tools for Xamarin] to develop apps for [[iOS]] and [[Android (operating system)|Android]]. The [https://github.com/fsprojects/Fabulous Fabulous] library provides a more comfortable functional interface.

=== Analytical programming ===
Among others, F# is used for quantitative finance programming,<ref>{{cite web |url=http://www.microsoft.com/casestudies/Case_Study_Detail.aspx?casestudyid=4000006794 |title=Microsoft Case Studies:Microsoft Visual Studio 2012 - Financial Services Firm |website=[[Microsoft]] |access-date=2012-11-25}}</ref> energy trading and portfolio optimization,<ref>{{cite web |url=http://blogs.msdn.com/b/dsyme/archive/2011/01/12/f-for-energy-trading-and-energy-portfolio-optimization.aspx |title=F# for Energy Trading and Portfolio Optimization |access-date=2012-11-25}}</ref> machine learning,<ref>{{cite web |url=http://www.microsoft.com/casestudies/Case_Study_Detail.aspx?CaseStudyID=4000005226 |title=Microsoft Case Study: Grange Insurance |website=[[Microsoft]] |access-date=2012-11-25}}</ref> business intelligence<ref>{{cite book |chapter-url=http://dl.acm.org/citation.cfm?id=1362702.1362709&coll=ACM&dl=ACM&type=series&idx=SERIES824%25E2%2588%2582=series&WantType=Proceedings&title=ICFP |chapter=Learning with F# |doi=10.1145/1362702.1362709 |access-date=2012-11-25|title=Proceedings of the 4th ACM SIGPLAN workshop on Commercial users of functional programming - CUFP '07 |year=2007 |last1=Trelford |first1=Phil |pages=1–2 |isbn=9781450378444 |s2cid=24018363}}</ref> and social gaming on [[Facebook]].<ref>{{cite web |url=http://blogs.msdn.com/b/dsyme/archive/2012/10/23/f-job-in-social-gaming-inn-london.aspx |title=F# Job in Facebook Social Gaming |access-date=2012-11-25}}</ref>

In the 2010s, F# has been positioned as an optimized alternative to [[C Sharp (programming language)|C#]]. F#'s scripting ability and inter-language compatibility with all Microsoft products have made it popular among developers.<ref>{{cite web |url=https://fsharp.org/testimonials/ |title=F# Developer Testimonials |access-date=May 25, 2021}}</ref>

===Scripting===
F# can be used as a scripting language, mainly for desktop [[read–eval–print loop]] (REPL) scripting.<ref>{{cite web |url=https://docs.microsoft.com/en-gb/archive/blogs/chrsmith/scripting-in-f |title=Scripting in F# |date=12 September 2008 |access-date=2020-01-17}}</ref>

==Open-source community==
The F# [[Open-source model|open-source]] community includes the F# Software Foundation<ref name="fsharporg"/> and the F# Open Source Group at [[GitHub]].<ref name="fsharposg"/> Popular open-source F# projects include:

* [https://fable.io/ Fable], an F# to Javascript transpiler based on [https://babeljs.io Babel].
* [https://fsprojects.github.io/Paket/ Paket], an alternative package manager for .NET that can still use [[NuGet]] repositories, but has centralised version-management.
* [https://fake.build/ FAKE], an F# friendly build-system.
* [https://github.com/giraffe-fsharp/Giraffe Giraffe], a functionally oriented middleware for [[ASP.NET Core]].
* [https://suave.io/ 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:
<syntaxhighlight lang="fsharp">
// This is a comment for a sample hello world program.
printfn "Hello World!"
</syntaxhighlight>
A record type definition. Records are immutable by default and are compared by structural equality.

<syntaxhighlight lang="fsharp">
type Person = {
    FirstName: string
    LastName: string
    Age: int
}

// Creating an instance of the record
let person = { FirstName = "John"; LastName = "Doe"; Age = 30 }
</syntaxhighlight>


A Person class with a constructor taking a name and age and two immutable properties.
<syntaxhighlight lang="fsharp">
/// This is a documentation comment for a type definition.
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age
    
/// class instantiation
let mrSmith = Person("Smith", 42)

</syntaxhighlight>

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#:
<syntaxhighlight lang="fsharp">
/// Using pattern matching expression
let rec factorial n =
    match n with
    | 0 -> 1
    | _ -> n * factorial (n - 1)

/// For a single-argument functions there is syntactic sugar (pattern matching function):
let rec factorial = function 
    | 0 -> 1 
    | n -> n * factorial (n - 1)
    
/// Using fold and range operator
let factorial n = [1..n] |> Seq.fold (*) 1
</syntaxhighlight>

Iteration examples:
<syntaxhighlight lang="fsharp">
/// Iteration using a 'for' loop
let printList lst = 
    for x in lst do
        printfn $"{x}" 

/// Iteration using a higher-order function
let printList2 lst = 
    List.iter (printfn "%d") lst

/// Iteration using a recursive function and pattern matching
let rec printList3 lst =
    match lst with
    | [] -> ()
    | h :: t ->
        printfn "%d" h
        printList3 t
</syntaxhighlight>
Fibonacci examples:
<syntaxhighlight lang="fsharp">
/// Fibonacci Number formula
[<TailCall>]
let fib n =
    let rec g n f0 f1 =
        match n with
        | 0 -> f0
        | 1 -> f1
        | _ -> g (n - 1) f1 (f0 + f1)
    g n 0 1

/// Another approach - a lazy infinite sequence of Fibonacci numbers
let fibSeq = Seq.unfold (fun (a,b) -> Some(a+b, (b, a+b))) (0,1)

// Print even fibs
[1 .. 10]
|> List.map     fib
|> List.filter  (fun n -> (n % 2) = 0)
|> printList

// Same thing, using a list expression
[ for i in 1..10 do
    let r = fib i
    if r % 2 = 0 then yield r ]
|> printList
</syntaxhighlight>
A sample Windows Forms program:
<syntaxhighlight lang="fsharp">
// Open the Windows Forms library
open System.Windows.Forms

// Create a window and set a few properties
let form = new Form(Visible=true, TopMost=true, Text="Welcome to F#")

// Create a label to show some text in the form
let label =
    let x = 3 + (4 * 5)
    new Label(Text = $"{x}")

// Add the label to the form
form.Controls.Add(label)

// Finally, run the form
[<System.STAThread>]
Application.Run(form)
</syntaxhighlight>
Asynchronous parallel programming sample (parallel CPU and I/O tasks):
<syntaxhighlight lang="fsharp">
/// A simple prime number detector
let isPrime (n:int) =
   let bound = int (sqrt (float n))
   seq {2 .. bound} |> Seq.forall (fun x -> n % x <> 0)

// We are using async workflows
let primeAsync n =
    async { return (n, isPrime n) }

/// Return primes between m and n using multiple threads
let primes m n =
    seq {m .. n}
        |> Seq.map primeAsync
        |> Async.Parallel
        |> Async.RunSynchronously
        |> Array.filter snd
        |> Array.map fst

// Run a test
primes 1000000 1002000
    |> Array.iter (printfn "%d")
</syntaxhighlight>

==See also==
{{Portal|Free and open-source software}}
* [[OCaml]]
* [[C Sharp (programming language)|C#]]
* [[.NET Framework]]

==Notes==
{{Reflist}}

==References==
* {{citation |first1=Don |last1=Syme |author1-link=Don Syme |first2=Adam |last2=Granicz |first3=Antonio |last3=Cisternino |title=Expert F# |year=2007 |publisher=[[Apress]]}}
* {{citation |first1=Jon |last1=Harrop |title=Visual F# 2010 for Technical Computing |year=2010 |publisher=Flying Frog Consultancy}}
* {{citation |first1=Robert |last1=Pickering |title=Foundations of F# |year=2007 |publisher=[[Apress]]}}
* {{citation |first=Chris |last=Smith |title=Programming F# |year=2009 |publisher=[[O'Reilly Media|O'Reilly]]}}
* {{citation |first=Tomas |last=Petricek |title=Real World Functional Programming With Examples in F# and C# |year=2009 |publisher=[[Manning Publications]]}}
* {{citation |first1=Michael |last1=Hansen|first2=Hans |last2=Rischel |title=Functional Programming Using F# |year=2013 |publisher=[[Cambridge University Press]]}}
* {{citation |first1=Johan|last1=Astborg |title=F# for Quantitative Finance |url=https://www.packtpub.com/big-data-and-business-intelligence/f-quantitative-finance |year=2013 |publisher=[[Packt Publishing]]}}
* {{citation |first1=Mikael|last1=Lundin |title=Testing with F# |url=https://www.packtpub.com/application-development/testing-f |year=2015 |publisher=[[Packt Publishing]]}}

==External links==
{{Wikibooks|F Sharp Programming}}
* {{Official website|https://fsharp.org/}} The F# Software Foundation
* [https://fsharp.github.io The F# Open Source Group at GitHub]
* [https://fsharp.net/ The Visual F# Developer Center] {{Webarchive|url=https://web.archive.org/web/20081119161341/http://www.fsharp.net/ |date=2008-11-19}}
* [https://web.archive.org/web/20121130163443/http://www.tryfsharp.org/ Try F#, for learning F# in a web browser]
* [http://fssnip.net F# Snippets Site]
* [https://learn.microsoft.com/en-us/archive/blogs/fsharpteam/ The Visual F# team blog]
* [https://www.microsoft.com/en-us/research/project/f-at-microsoft-research/ The original Microsoft Research website for F#]
* [https://web.archive.org/web/20110715231625/http://www.ctocorner.com/fsharp/book/default.aspx The F# Survival Guide, Dec 2009 (Web-based book)]
* [http://fsharp.org/specs/language-spec/ The F# Language Specification]
* [http://www.developerfusion.com/article/122079/intro-to-f/ An introduction to F# programming] {{Webarchive|url=https://web.archive.org/web/20110713133206/http://www.developerfusion.com/article/122079/intro-to-f/ |date=2011-07-13}}
* [http://opcoast.com/demos/fsharp/index.html A tutorial showing the ''process'' of reaching a functional design; includes test and parallel coding]

{{ML programming}}
{{.NET Framework}}
{{Common Language Infrastructure}}
{{Microsoft FOSS}}
{{Microsoft Research}}

[[Category:.NET programming languages]]
[[Category:Cross-platform free software]]
[[Category:High-level programming languages]]
[[Category:Functional languages]]
[[Category:Microsoft free software]]
[[Category:Microsoft programming languages]]
[[Category:Microsoft Research]]
[[Category:ML programming language family]]
[[Category:OCaml programming language family]]
[[Category:Pattern matching programming languages]]
[[Category:Programming languages created in 2005]]
[[Category:Programming languages supporting units of measure]]
[[Category:Software using the Apache license]]
[[Category:Software using the MIT license]]
[[Category:Statically typed programming languages]]
<!-- Hidden categories below -->
[[Category:Articles with example OCaml code]]<!-- Code example category family member nearest F#. -->