F Sharp (programming Language) Learning | F Sharp (programming Language) Facts and Resources | DefaultLogic For Business

F Sharp (programming Language)
Fsharp, Logomark, October 2014.svg
F# logomark
ParadigmMulti-paradigm: functional, imperative, object-oriented, metaprogramming, reflective, concurrent
Designed byDon Syme, Microsoft Research
DeveloperMicrosoft, The F# Software Foundation
First appeared2005; 13 years ago (2005), version 1.0
Stable release
4.5[1] / August 14, 2018; 3 months ago (2018-08-14)
Preview release
4.5 preview / July 26, 2018; 4 months ago (2018-07-26)[2]
Typing disciplineStatic, strong, inferred
OSCross-platform: .NET Framework, Mono, JavaScript
LicenseMIT license[3][4]
Filename extensions.fs, .fsi, .fsx, .fsscript
Influenced by
C#, Erlang, Haskell,[5]ML, OCaml,[6][7]Python, Scala
C#,[8]Elm, F*, LiveScript

F# (pronounced F sharp) is a strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. F# is most often used as a cross-platform Common Language Infrastructure (CLI) language, but it can also generate JavaScript[9] and graphics processing unit (GPU) code.[10]

F# is developed by the F# Software Foundation,[11]Microsoft and open contributors. An open source, cross-platform compiler for F# is available from the F# Software Foundation.[12] F# is also a fully supported language in Visual Studio[13] and Xamarin Studio.[14] Other tools supporting F# development include Mono, MonoDevelop, SharpDevelop, MBrace and WebSharper.[15]Plug-ins supporting F# exist for many widely used editors, most notably the Ionide extension for Atom and Visual Studio Code, and integrations for other editors such as Vim, Emacs, and Sublime Text.

F# is a member of the ML language family and originated as a .NET Framework implementation of a core of the programming language OCaml,[6][7] it has also been influenced by C#, Python, Haskell,[5]Scala, and Erlang.



In the course of its development, the language has gone through several versions:

Note that F# Interactive (which is the term F# use to refer to REPL (Read-Evaluate-Print Loop)) runs only on .NET Framework, and that is why it only runs on Windows.[23]

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# originates from Microsoft Research, Cambridge. The language was originally designed and implemented by Don Syme,[6] according to whom in the fsharp team, they say the F is for "Fun".[24] Andrew Kennedy contributed to the design of units of measure.[6] The Visual F# Tools for Visual Studio are developed by Microsoft.[6] 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.[11]

Summary of versions
F# 1.0 F# 2.0 F# 3.0[25] F# 3.1[26] F# 4.0[27] F# 4.1[28] F# 4.5[1]
  • Functional programming
  • Discriminated unions
  • Records
  • Tuples
  • Pattern matching
  • Type abbreviations
  • Object programming
  • Structs
  • Signature files
  • Scripting files
  • Imperative programming
  • Modules (no functors)
  • Nested modules
  • .NET Interoperability
  • Active patterns
  • Units of measure
  • Sequence expressions
  • Asynchronous programming
  • Agent programming
  • Extension members
  • Named arguments
  • Optional arguments
  • Array slicing
  • Quotations
  • Native interoperability
  • Computation expressions
  • Type providers
  • LINQ query expressions
  • CLIMutable attribute
  • Triple-quoted strings
  • Auto-properties
  • Provided units-of-measure
  • Named union type fields
  • Extensions to array slicing
  • Type inference enhancements
  • 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
  • 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'
  • 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

Language overview

Functional programming

F# is a strongly typed functional-first language that uses type inference. The programmer does not need to declare types--the compiler deduces types during compilation (type inference). F# also allows explicit type annotations, and requires them in some situations.

F# is an expression-based language using eager evaluation. Every statement in F#, including if expressions, try expressions and loops, is a composable expression with a static type.[29] Functions and expressions that do not return any value have a return type of unit. F# uses the let keyword for binding values to a name.[29] For example:

let x = 3 + 4

binds the value 7 to the name x.

New types are defined using the type keyword. For functional programming, F# provides tuple, record, discriminated union, list, option, and result types.[29] A tuple represents a set of n values, where n >= 0. The value n is called the arity of the tuple. A 3-tuple would be represented as (A, B, C), where A, B, and C are values of possibly different types. A tuple can be used to store values only when the number of values is known at design-time and stays constant during execution.

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

 type R = 
        { Name : string 
         Age : int }

Records can be created as let r = { Name="AB"; Age=42 }. The with keyword is used to create a copy of a record, as in { r with Name="CD" }, which creates a new record by copying r and changing the value of the Name field (assuming the record created in the last example was named r).

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

 type A = 
    | UnionCaseX of string
    | UnionCaseY of int

Values of the union type can correspond to either union case. The types of the values carried by each union case is included in the definition of each case.

The list type is an immutable linked list represented either using a head::tail notation (:: is the cons operator) or a shorthand as [item1; item2; item3]. An empty list is written []. The option type is a discriminated union type with choices Some(x) or None. F# types may be generic, implemented as generic .NET types.

F# supports lambda functions and closures.[29] All functions in F# are first class values and are immutable.[29] Functions can be curried. Being first-class values, functions can be passed as arguments to other functions. Like other functional programming languages, F# allows function composition using the >> and << operators.

F# provides sequence expressions[30] that define a sequence seq { ... }, list [ ... ] or array [| ... |] through code that generates values. For example,

 seq { for b in 0 .. 25 do
           if b < 15 then
               yield b*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 are generators - values are generated on-demand (i.e., are lazily evaluated) - while lists and arrays are evaluated eagerly.

F# uses pattern matching to bind values to names. Pattern matching is also used when accessing discriminated unions - the union is value matched against pattern rules and a rule is selected when a match succeeds. F# also supports Active Patterns as a form of extensible pattern matching.[31] It is used, for example, when multiple ways of matching on a type exist.[29]

F# supports a general syntax for defining compositional computations called computation expressions. Sequence expressions, asynchronous computations and queries are particular kinds of computation expressions. Computation expressions are an implementation of the monad pattern.[30]

Imperative programming

F# support for imperative programming includes

  • for loops
  • while loops
  • arrays, created with the [| ... |] syntax
  • hash table, created with the dict [ ... ] syntax or System.Collections.Generic.Dictionary<_,_> type.

Values and record fields can also be labelled as mutable. For example:

// Define 'x' with initial value '1'
let mutable x = 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 the System.Collections.Generic namespace defining imperative data structures.

Object programming

Like other Common Language Infrastructure (CLI) languages, F# can use CLI types and objects through object programming.[29] F# support for object programming in expressions includes:

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

Support for object programming in patterns includes

  • Type tests, e.g., :? string as s
  • Active patterns, which can be defined over object types[31]

F# object type definitions can be class, struct, interface, enum, or delegate type definitions, corresponding to the definition forms found in C#. For example, here is a class with a constructor taking a name and age, and declaring two properties.

/// A simple object type definition
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age

Asynchronous programming

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

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 }

The let! indicates that the expression on the right (getting the response) should be done asynchronously but the flow should only continue when the result is available. In other words, from the point of view of the code block, it's as if getting the response is a blocking call, whereas from the point of view of the system, the thread won't be blocked and may be used to process other flows while the result needed for this one doesn't become available.

The async block may be invoked using the Async.RunSynchronously function. Multiple async blocks can be executed in parallel using the Async.Parallel function that takes a list of async objects (in the example, asynctask is an async object) and creates another async object to run the tasks in the lists in parallel. The resultant object is invoked using Async.RunSynchronously.[32]Inversion of control in F# follows this pattern.[32]

Parallel programming

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

Parallel programming is also supported through the Array.Parallel functional programming operators in the F# standard library, direct use of the System.Threading.Tasks task programming model, the direct use of .NET thread pool and .NET threads and through dynamic translation of F# code to alternative parallel execution engines such as GPU[10] code.

Units of measure

The F# type system supports units of measure checking for numbers.[33] The units of measure feature integrates with F# type inference to require minimal type annotations in user code.[34]


F# allows some forms of syntax customizing via metaprogramming to support embedding custom domain-specific languages within the F# language, particularly through computation expressions.[29]

F# includes a feature for run-time meta-programming called quotations.[35] A quotation expression evaluates to an abstract syntax tree representation of the F# expressions. Similarly, definitions labelled with the [<ReflectedDefinition>] attribute can also be accessed in their quotation form. F# quotations are used for various purposes including to compile F# code into JavaScript[9] and GPU[10] 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.[36] F# type providers allow the F# compiler and tools to be extended with components that provide type information to the compiler on-demand at compile time. F# type providers have been used to give strongly typed access to connected information sources in a scalable way, including to the Freebase knowledge graph.[37]

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

// 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 }

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

Agent programming

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

let counter =
    MailboxProcessor.Start(fun inbox ->
        let rec loop n =
            async { do printfn "n = %d, waiting..." n
                    let! msg = inbox.Receive
                    return! loop(n+msg) }
        loop 0)

Development tools

  • The Visual F# tools from Microsoft include full integrated development environment (IDE) integration in Visual Studio. With the language service installed, Visual Studio can be used to create F# projects and its debugger used on F# code. The Visual F# tools include a Visual Studio-hosted read-eval-print loop (REPL) interactive console that can execute F# code as it is written. Visual Studio for Mac also fully supports F# projects.
  • Visual Studio Code contains full support for F# via the Ionide extension.
  • F# can be developed with any text editor. Specific support exists in editors such as Emacs.
  • The Fable project (styled as F# |> Babel) -- provides support for targeting JavaScript as a compilation backend for F# code.[40]
  • WebSharper[41] is a framework for cross-tier JavaScript and HTML5 development with F#.
  • MonoDevelop is an integrated development environment supporting F# programming on Linux, macOS, and Windows including support for the interactive console as used by Visual Studio.
  • SharpDevelop has supported F# since version 3.0.
  • MBrace is a framework and runtime for the development of applications with F# for the cloud.
  • LINQPad has supported F# since version 2.x.
  • Xamarin Studio supports F# since version 3.0.

Application areas

F# is a general-purpose programming language.

Web programming

F# is a central part of the WebSharper framework where F# code is executed as .NET code on a server and as JavaScript code on a client.[41]

Analytical programming

Among others, F# is used for quantitative finance programming,[42] energy trading and portfolio optimization,[43] machine learning,[44] business intelligence[45] and social gaming on Facebook.[46]

In the 2010s, F# has been positioned as an optimized alternative to C#. F#'s scripting ability and inter-language compatibility with all Microsoft products have made it popular among developers. Many developers are creating systems based on F# and use C# WCF Services.[clarification needed][][who?]


F# can be used as a scripting language, mainly for desktop read-eval-print loop (REPL) scripting.[47]

Open-source community

The F# open-source community includes the F# Software Foundation[11] and the F# Open Source Group at GitHub.[12]


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.
open System
Console.WriteLine("Hello World!")

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

/// 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)

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

/// 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

Iteration examples:

/// Iteration using a 'for' loop
let printList lst = 
    for x in lst do
        printfn "%d" 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

Fibonacci examples:

/// Fibonacci Number formula
let rec fib n =
    match n with
    | 0 | 1 -> n
    | _ -> fib (n - 2) + fib (n - 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

A sample Windows Forms program:

// 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 = sprintf "x = %d" x)

// Add the label to the form

// Finally, run the form

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

/// 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")

See also


  1. ^ a b c https://blogs.msdn.microsoft.com/dotnet/2018/08/14/announcing-f-4-5/
  2. ^ https://blogs.msdn.microsoft.com/dotnet/2018/07/26/announcing-f-4-5-preview/
  3. ^ https://github.com/fsharp/fsharp/blob/master/License.txt. Missing or empty |title= (help)
  4. ^ https://github.com/Microsoft/visualfsharp/blob/master/License.txt. Missing or empty |title= (help)
  5. ^ a b Syme, Granicz & Cisternino (2007:2)
  6. ^ a b c d e "F# Historical Acknowledgements". Retrieved .
  7. ^ a b Syme, Don (2006). "Leveraging .NET Meta-programming Components from F#". [F#] is rooted in the Core ML design, and in particular has a core language largely compatible with that of OCaml
  8. ^ for async
  9. ^ a b c d e f The F# Software Foundation. "Using F# with HTML5 Web Applications". Retrieved .
  10. ^ a b c d e f g The F# Software Foundation. "Using F# for GPU Programming". Retrieved .
  11. ^ a b c The F# Software Foundation. "The F# Software Foundation". Retrieved .
  12. ^ a b The F# Software Foundation. "F# Compiler (open source edition) @ github". Retrieved .
  13. ^ S. Somasegar. "F# - A functional Programming Language". Retrieved .
  14. ^ Friedman, Nat (May 28, 2014). "Announcing Xamarin 3". Retrieved 2014.
  15. ^ Pickering, Robert (2009). Beginning F#, Apress. p. 11.
  16. ^ Syme, Don. "F# 1.0.8 released". Microsoft. Retrieved 2014.
  17. ^ Syme, Don. "F# 2.0 released as part of Visual Studio 2010". Microsoft. Retrieved 2014.
  18. ^ Zander, Jason. "Visual Studio 2012 and .NET Framework 4.5 released to the web". Microsoft. Retrieved 2014.
  19. ^ "Visual Studio 2013 released to web". Microsoft. Retrieved 2014.
  20. ^ "Announcing the RTM of Visual F# 4.0". Microsoft. Retrieved 2015.
  21. ^ "Announcing F# 4.1 and the Visual F# Tools for Visual Studio 2017". Retrieved .
  22. ^ https://www.nuget.org/packages/FSharp.Core#
  23. ^ https://www.reddit.com/r/programming/comments/97cnsp/announcing_f_45/
  24. ^ Edwards, Kathryn (23 December 2008). "The A-Z of programming languages: F#". networkworld.com. IDG. Retrieved 2016.
  25. ^ McNamara, Brian. "More About F# 3.0 Language Features". Microsoft. Retrieved 2014.
  26. ^ McNamara, Brian. "Announcing a pre-release of F# 3.1". Microsoft. Retrieved 2014.
  27. ^ "Announcing the RTM of Visual F# 4.0". Retrieved .
  28. ^ "Announcing F# 4.1 and the Visual F# Tools for Visual Studio 2017". Retrieved .
  29. ^ a b c d e f g h "F# Language Overview" (PDF). Retrieved .
  30. ^ a b "Some Details on F# Computation Expressions". Retrieved .
  31. ^ a b "Pattern Matching in F# Part 2 : Active Patterns". Retrieved .
  32. ^ a b c "Introducing F# Asynchronous Workflows". Retrieved .
  33. ^ "Units of Measure (F#)". Retrieved .
  34. ^ "Units of Measure in F#: Part One, Introducing Units". Retrieved .
  35. ^ "Code Quotations (F#)". Retrieved .
  36. ^ "Type Providers". Retrieved .
  37. ^ "New Tech Report from Microsoft Research: Strongly-Typed Language Support for Internet-Scale Information Sources". Retrieved .
  38. ^ "Query Expressions (F#)". Retrieved .
  39. ^ "F# 3.0 - LINQ + Type Providers= Information Rich Programming". Retrieved .
  40. ^ "Fable: JavaScript you can be proud of!". fable.io. Retrieved .
  41. ^ a b Intellifactory. "WebSharper home". Retrieved .
  42. ^ "Microsoft Case Studies:Microsoft Visual Studio 2012 - Financial Services Firm". Retrieved .
  43. ^ "F# for Energy Trading and Portfolio Optimization". Retrieved .
  44. ^ "Microsoft Case Study: Grange Insurance". Retrieved .
  45. ^ "Learning with F#". Retrieved .
  46. ^ "F# Job in Facebook Social Gaming". Retrieved .
  47. ^ "Scripting in F#". Retrieved .


  • Syme, Don; Granicz, Adam; Cisternino, Antonio (2007). "Expert F#". Apress.
  • Harrop, Jon (2010). "Visual F# 2010 for Technical Computing". Flying Frog Consultancy.
  • Pickering, Robert (2007). "Foundations of F#". Apress.
  • Smith, Chris (2009). "Programming F#". O'Reilly.
  • Petricek, Tomas (2009). "Real World Functional Programming With Examples in F# and C#". Manning Publications.
  • Hansen, Michael; Rischel, Hans (2013). "Functional Programming Using F#". Cambridge University Press.
  • Astborg, Johan (2013). "F# for Quantitative Finance". Packt Publishing.
  • Lundin, Mikael (2015). "Testing with F#". Packt Publishing.

External links

  This article uses material from the Wikipedia page available here. It is released under the Creative Commons Attribution-Share-Alike License 3.0.



Connect with defaultLogic
What We've Done
Led Digital Marketing Efforts of Top 500 e-Retailers.
Worked with Top Brands at Leading Agencies.
Successfully Managed Over $50 million in Digital Ad Spend.
Developed Strategies and Processes that Enabled Brands to Grow During an Economic Downturn.
Taught Advanced Internet Marketing Strategies at the graduate level.

Manage research, learning and skills at defaultlogic.com. Create an account using LinkedIn to manage and organize your omni-channel knowledge. defaultlogic.com is like a shopping cart for information -- helping you to save, discuss and share.

  Contact Us