Content deleted Content added
m fix reason in hatnote |
Rescuing 2 sources and tagging 0 as dead.) #IABot (v2.0.9.5 |
||
| (48 intermediate revisions by 19 users not shown) | |||
Line 5:
| name = F#
| logo = F Sharp logo.svg
|
| logo caption =
|
| 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_date = {{start date and age|df=yes|{{wikidata|qualifier| Q648619 |P348|P577}}}}
| latest preview
| 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]], [[
| 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]]: [[
| 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
F# is developed by the [[F Sharp Software Foundation|F# Software Foundation]],<ref name="fsharporg">{{cite web |url=
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"
[[Python (programming language)|Python]], [[
==History==
===Versions===
{| class="wikitable"
|-
! F#<br/>version
! Language specification
! Date
Line 48 ⟶ 49:
! [[Runtime system|Runtime]]
|-
|
|
| 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>
Line 54 ⟶ 55:
|[[.NET Framework|.NET]] 1.0 - 3.5
|-
|
| [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>
Line 60 ⟶ 61:
|[[.NET Framework|.NET]] 2.0 - 4.0, [[Mono (software)|Mono]]
|-
|
| [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
|[[.NET Framework|.NET]] 2.0 - 4.5, [[Mono (software)|Mono]]
|-
|
| [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
|[[.NET Framework|.NET]] 2.0 - 4.5, [[Mono (software)|Mono]]
|-
|
| [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
|<!-- [[.NET Framework|.NET]] 2.0 - 4.5, [[Mono (software)|Mono]] -->
|-
|
| [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"
|[[.NET Framework|.NET]] 3.5 - 4.6.2, [[.NET
|-
|
|
|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"
| [[.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
|-
|
|
|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"
| [[.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
|-
|
|
|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"
| [[.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
|-
|
|
|November 2020<ref name="blogs.msdn.microsoft.com2">{{Cite web|url=https://devblogs.microsoft.com/dotnet/announcing-f-5/|title
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"
| [[
|-
|
|
|November 2021<ref>{{Cite web|url=https://devblogs.microsoft.com/dotnet/fsharp-6-is-officially-here/|title
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"
| [[
|-
|
|
|November 2022<ref>{{Cite web|url=https://devblogs.microsoft.com/dotnet/announcing-fsharp-7/|title
|[[Linux]], [[macOS]], [[Microsoft Windows|Windows]],
[[JavaScript]],<ref name="js"
| [[
|-
| 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>
|}
Line 135 ⟶ 148:
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 [[
F# originates from Microsoft Research, Cambridge, UK. The language was originally designed and implemented by [[Don Syme]],<ref name="historyMSR">{{cite web |url=
Andrew Kennedy contributed to the design of
{| class="wikitable"
|+ Summary of versions
|-
! F#<br/>version
! Features added
|-
!
|valign="top"|
* Functional programming
Line 160 ⟶ 174:
* Modules (no functors)
* Nested modules
* .NET
|-
!
|
* Active patterns
Line 177 ⟶ 191:
* Computation expressions
|-
!
|
* Type providers
Line 186 ⟶ 200:
* Provided units-of-measure
|-
!
|
* Named union type fields
Line 192 ⟶ 206:
* Type inference enhancements
|-
!
|
* Printf on unitized values
Line 206 ⟶ 220:
* Params dictionaries
|-
!
|
* Struct tuples which inter-operate with C# tuples
Line 220 ⟶ 234:
* Support for 'fixed'
|-
!
|
* Versioning alignment of binary, package, and language
Line 235 ⟶ 249:
* Enumeration cases emitted as public
|-
!
|
* Anonymous record types
|-
!
|
* Implicit yields
Line 247 ⟶ 261:
* Open static classes
|-
!
|
* FSharp.Core now targets netstandard2.0 only
Line 264 ⟶ 278:
* Improved compiler analysis for library authors
|-
!
|
* Tasks
Line 272 ⟶ 286:
* “as” patterns
* Indentation syntax revisions
*
*
* Implicit integer conversions
* First-class support for .NET-style implicit conversions
Line 281 ⟶ 295:
* InlineIfLambda optimizer directive
* Resumable code
*
* Map has Keys and Values
*
*
* Informational warnings for rarely used symbolic operators
|-
!
|
* Static abstract members support in interfaces
Line 302 ⟶ 316:
* 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
|}
Line 308 ⟶ 359:
===Functional programming===
Examples of functional features are:
Line 326 ⟶ 377:
* [[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
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"
<syntaxhighlight lang="fsharp">
let x = 3 + 4
Line 335 ⟶ 386:
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 ''record'' is a type where the data members are named. Here is an example of record definition:
Line 343 ⟶ 394:
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,
Line 355 ⟶ 406:
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"
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,
Line 365 ⟶ 416:
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 ''
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=
===Imperative programming===
Line 385 ⟶ 436:
===Object-oriented programming===
Like other [[Common Language Infrastructure]] (CLI) languages, F# can use CLI types through object-oriented programming.<ref name="overview"
* 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" } }}
Line 397 ⟶ 448:
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=
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.
Line 408 ⟶ 459:
===Asynchronous programming===
F# supports [[asynchronous programming]] through ''asynchronous workflows''.<ref name="aw"
<syntaxhighlight lang="fsharp">
let asynctask =
Line 417 ⟶ 468:
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
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=
[[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"
===Units of measure===
The F# type system supports [[Units of measurement|units of measure]] checking for numbers.<ref name="units-msdn">{{cite web |url=
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=
===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=
In F# 3.0 the F# quotation and computation expression features are combined to implement [[LINQ]] queries.<ref name="queries">{{cite web |url=
<syntaxhighlight lang="fsharp">
// Use the OData type provider to create types that can be used to access the Northwind database.
Line 451 ⟶ 551:
</syntaxhighlight>
The combination of type providers, queries and strongly typed functional programming is known as ''information rich programming''.<ref name="irp">{{cite web |url=
===Agent programming===
F# supports a variation of the [[Actor model|
<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! 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 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==
Line 479 ⟶ 615:
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>
===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://
=== Analytical programming ===
Among others, F# is used for quantitative finance programming,<ref>{{cite web |url=
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=
===Scripting===
F# can be used as a scripting language, mainly for desktop [[read–eval–print loop]] (REPL) scripting.<ref>{{cite web |url=
==Open-source community==
The F# [[Open-source model|open-source]] community includes the F# Software Foundation<ref name="fsharporg"
* [https://fable.io/ Fable], an F# to Javascript transpiler based on [https://babeljs.io Babel].
Line 511 ⟶ 647:
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.
Line 546 ⟶ 695:
let printList lst =
for x in lst do
printfn $"
/// Iteration using a higher-order function
Line 563 ⟶ 712:
<syntaxhighlight lang="fsharp">
/// Fibonacci Number formula
[<TailCall>]
let fib n =
let rec g n f0 f1 =
Line 638 ⟶ 788:
==Notes==
{{Reflist
==References==
Line 647 ⟶ 797:
* {{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=
* {{citation |first1=Mikael|last1=Lundin |title=
==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] {{Webarchive|url=https://web.archive.org/web/20130517105109/http://fsharp.github.io/ |date=2013-05-17 }}
* [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}}
Line 674 ⟶ 822:
[[Category:.NET programming languages]]
[[Category:Cross-platform free software]]
[[Category:High-level programming languages]]
[[Category:Functional languages]]
[[Category:Microsoft free software]]
Line 686 ⟶ 835:
[[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#. -->
| |||