F Sharp (programming language)

From Wikipedia, the free encyclopedia
  (Redirected from F Sharp programming language)
Jump to: navigation, search
F#
FSharp Logo.png
Paradigm(s) multi-paradigm: functional, imperative, object-oriented, metaprogramming, concurrent
Designed by Microsoft Research, Don Syme
Developer Microsoft, The F# Software Foundation
Appeared in 2005 (version 1.0) (2005 (version 1.0))
Stable release 3.1.1[1] / December 25, 2013 (2013-12-25)
Typing discipline static, strong, inferred
Influenced by ML, OCaml, C#, Python, Haskell,[2] Scala, Erlang
Influenced F*, LiveScript
OS Cross-platform (.NET Framework, Mono, JavaScript)
License Apache license
Website fsharp.org

F# (pronounced eff Sharp) is a strongly typed, multi-paradigm programming language encompassing functional, imperative and object-oriented programming techniques. F# is most often used as a cross-platform CLI language, but can also be used to generate JavaScript[3] and GPU[4] code.

F# is developed by the F# Software Foundation:[5] Microsoft and open contributors. An open source, cross-platform compiler for F# is available from the F# Software Foundation.[6] F# is also a fully supported language in Visual Studio.[7] Other tools supporting F# development[clarification needed] include Mono, MonoDevelop, SharpDevelop and WebSharper

F# originated from ML and has been influenced by OCaml, C#, Python, Haskell,[2] Scala and Erlang.

Overview[edit]

Functional programming[edit]

F# is a strongly typed functional-first language that uses type inference. Types do not need to be explicitly declared by the programmer; they will be deduced by the compiler during compilation. F# also allows explicit type annotations and requires them in some situations.

F# is an expression-based language using eager evaluation. Every statement in F#, including if expressions, try expressions and loops, is a composable expression with a static type.[8] 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.[8] 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 and option types.[8] A tuple represents a collection of n values, where n ≥ 0. The value n is called the arity of the tuple. A 3-tuple would be represented as (A, B, C), where A, B and C are values of possibly different types. A tuple can be used to store values only when the number of values is known at design-time and stays constant throughout execution.

A record is a type where the data members are named, as in { Name:string; Age:int }. Records can be created as { Name="AB"; Age=42 }. The with keyword is used to create a copy of a record, as in { 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.[8] All functions in F# are first class values and are immutable.[8] 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[9] 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 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.[10] It is used, for example, when multiple ways of matching on a type exist.[8]

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

Imperative programming[edit]

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 be '3'
x <- 3

In addition, 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[edit]

F#, like other CLI languages, can use CLI types and objects through object programming.[8] 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.[10]

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

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

Asynchronous programming[edit]

F# supports asynchronous programming through asynchronous workflows.[11] 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! allows the rest of the async block to be defined as the delegate and passed as the callback function of an asynchronous operation. This solves the inversion of control problem.[11] The async block is invoked using the Async.RunSynchronously function. Multiple async blocks are 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.[11]

Parallel programming[edit]

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

Units of measure[edit]

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

Metaprogramming[edit]

F# allows some forms of syntax customization to support embedding custom domain-specific languages within the F# language itself, particularly through computation expressions.[8]

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

Information rich programming[edit]

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

In F# 3.0 the F# quotation and computation expression features are combined to implement LINQ queries.[17] 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.[18]

Agent programming[edit]

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[edit]

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

The Visual F# tools from Microsoft include full IDE integration in Visual Studio. With the language service installed, Visual Studio can be used to create F# projects and the Visual Studio debugger used to debug F# code. In addition, the Visual F# tools comes with a Visual Studio-hosted REPL interactive console that can be used to execute F# code as it is being written.

WebSharper [19] is a framework for cross-tier JavaScript and HTML5 development with F#.

MonoDevelop is an integrated development environment supporting F# programming on Linux, Mac and Windows including support for the interactive console as used by Visual Studio.

SharpDevelop supports F# since version 3.0.

LINQPad supports F# since version 2.x.

Application areas[edit]

F# is a general purpose programming language.

Web programming[edit]

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

Analytical programming[edit]

Among others, F# is used for quantitative finance programming,[20] energy trading and portfolio optimization,[21] machine learning,[22] business intelligence[23] and social gaming on Facebook.[24]

Scripting[edit]

F# is often used as a scripting language, mainly for desktop REPL scripting.[25]

Open source community[edit]

The F# open source community includes the F# Software Foundation[5] and the F# Open Source Group at GitHub.[6]

History[edit]

F# originates from Microsoft Research, Cambridge and the language was originally designed and implemented by Don Syme.[26] Andrew Kennedy contributed to the design of units of measure.[26] The F# language and the Visual F# tools for Windows are developed by Microsoft.[26] The F# Software Foundation develop the F# open source compiler and tools based partly on open source releases by the Microsoft Visual F# team.[5]

F# features a legacy "ML compatibility mode" which allow programs written in a large subset of OCaml (roughly, with no functors, objects, polymorphic variants and other additions) to be immediately compiled as F#.

Examples[edit]

A few small samples follow:

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

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

/// This is a documentation comment for a type definition.
type Person(name : string, age : int) =
    member x.Name = name
    member x.Age = age

A simple example that is often used to demonstrate the syntax of functional languages is the factorial function for non-negative 32-bit integers, here shown in F#:

/// This is a documentation comment for a function.
let rec factorial n =
    match n with
    | 0 -> 1
    | _ -> n * factorial (n - 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 - 1) + fib (n - 2)
 
/// 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
form.Controls.Add(label)
 
// Finally, run the form
[<System.STAThread>]
Application.Run(form)

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

/// A very naive 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[edit]

Notes[edit]

  1. ^ http://visualstudiogallery.msdn.microsoft.com/4019ccb1-7adf-4ba0-b9b7-3d4149a4fa2a?SRC=VSIDE
  2. ^ a b Syme, Granicz & Cisternino (2007:2) "F# also draws from Haskell particularly with regard to two advanced language features called sequence expressions and workflows."
  3. ^ a b The F# Software Foundation. "Using F# with HTML5 ...)". Retrieved 2012-11-24. 
  4. ^ a b c The F# Software Foundation. "Using F# with GPUs". Retrieved 2012-11-24. 
  5. ^ a b c The F# Software Foundation. "The F# Software Foundation". Retrieved 2012-11-24. 
  6. ^ a b The F# Software Foundation. "F# Compiler (open source edition) @ github". Retrieved 2012-11-24. 
  7. ^ S. Somasegar. "F# - A functional Programming Language". Retrieved 2007-10-18. 
  8. ^ a b c d e f g h "F# Language Overview". Retrieved 2007-12-14. 
  9. ^ a b "Some Details on F# Computation Expressions". Retrieved 2007-12-14. 
  10. ^ a b "Pattern Matching in F# Part 2 : Active Patterns". Retrieved 2012-11-24. 
  11. ^ a b c "Introducing F# Asynchronous Workflows". Retrieved 2007-12-14. 
  12. ^ "Units of Measure (F#)". Retrieved 2012-11-24. 
  13. ^ "Units of Measure in F#: Part One, Introducing Units". Retrieved 2012-11-24. 
  14. ^ "Code Quotations (F#)". Retrieved 2012-11-24. 
  15. ^ "Type Providers". Retrieved 2012-11-24. 
  16. ^ "New Tech Report from Microsoft Research: Strongly-Typed Language Support for Internet-Scale Information Sources". Retrieved 2012-11-24. 
  17. ^ "Query Expressions (F#)". Retrieved 2012-11-24. 
  18. ^ "F# 3.0 – LINQ + Type Providers = Information Rich Programming". Retrieved 2012-11-24. 
  19. ^ a b Intellifactory. "WebSharper home". Retrieved 2012-11-24. 
  20. ^ "Microsoft Case Studies:Microsoft Visual Studio 2012 - Financial Services Firm". Retrieved 2012-11-25. 
  21. ^ "F# for Energy Trading and Portfolio Optimization". Retrieved 2012-11-25. 
  22. ^ "Microsoft Case Study: Grange Insurance". Retrieved 2012-11-25. 
  23. ^ "Learning with F#". Retrieved 2012-11-25. 
  24. ^ "F# Job in Facebook Social Gaming". Retrieved 2012-11-25. 
  25. ^ "Scripting in F#". Retrieved 2012-11-25. 
  26. ^ a b c "F# Historical Acknowledgements". Retrieved 2012-11-24. 

References[edit]

  • 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. 

External links[edit]