F# Cheatsheet


The VS11 beta includes a really slick cheatsheet style F# language reference. A gem for groking F# syntax.

The samples are grouped into modules. A module is just a collection of value, function and type definitions.

To execute the code in F# Interactive, highlight a line of code and then either type Alt-Enter, or right-click and choose “Send to Interactive”. To start F# Interactive, see the “View” menu.

For more about F#, see: http://fsharp.net

For templates to use with F#, see the ‘Online Templates’ in Visual Studio, ‘New Project’ > ‘Online Templates’

For specific F# topics, see:

Contents

Primitives Lists Basic Functions Tuples Booleans Strings Lists Dictionaries Object Oriented Parameter Lists Arrays Sequences Generics Recursion Record Types Unions Option Values Pattern Matching Active Patterns Interfaces .NET Libraries .NET Regular Expressions Recursive Trees Inlined Generic Arithmetic Units Of Measure Events Lightweight Async Agent Parallel Array Computations I Parallel Array Computations II Database Access OData Access Boilerplate WinForm

Primitives

module Integers = 
    /// A very simple constant integer.
    let sampleInteger = 176

    /// This is the result of doing some arithmetic starting with the first integer
    let sampleInteger2 = (sampleInteger/4 + 5 - 7) * 4

Lists

module ListsOfIntegers = 

    /// A list of the numbers from 0 to 99
    let sampleNumbers = [ 0 .. 99 ]

    /// A list of all tuples containing all the numbers from 0 to 99 and their squares
    let sampleTableOfSquares = [ for i in 0 .. 99 -> (i, i*i) ]

    // The next line prints a result using %A for generic printing
    printfn "The numbers from 0 to 99 are:\n%A" sampleNumbers

    // The next line prints a list that includes tuples, using %A for generic printing
    printfn "The table of squares from 0 to 99 is:\n%A" sampleTableOfSquares

Basic Functions

/// This first module some basic function definitions in F#.
module SomeBasicFunctionsAndTypeInference = 


    /// This shows how to use 'let' to define a function that accepts an integer
    /// as an argument and returns an integer. The type of the argument is inferred to 
    /// be an integer.
    let sampleFunction1 x = x*x + 3             

    // The next line applies the function and gives the result a name using 'let'. The result type 
    // is inferred from the type of the function.
    let sampleResult1 = sampleFunction1 4573

    // The next line prints the result of applying the function
    printfn "The result of squaring the integer 4573 and adding 3 is %d" sampleResult1

    /// Where needed, you can annotate the type of a parameter name using "(argument:type)", 
    /// as shown in the sample below.
    let sampleFunction2 (x:int) = 2*x*x - x/5 + 3

    // Again the next line applies the function and gives the result a name using 'let'. 
    let sampleResult2 = sampleFunction2 (7 + 4)

    printfn "The result of applying the 1st sample function to (7 + 4) is %d" sampleResult2

    /// This shows a similar function that accepts and returns floating-point numbers.
    /// In this example, the argument and return types of the function are inferred to
    /// have type 'float' (also called 'double') based on the implementation code.
    let sampleFunction3 x = 
        if x < 100.0 then 
            2.0*x*x - x/5.0 + 3.0
        else 
            2.0*x*x + x/5.0 - 37.0

    /// The result of applying 'sampleFunction3' over double-precision floating point numbers 
    let sampleResult3 = sampleFunction3 (6.5 + 4.5)

    printfn "The result of applying the 2nd sample function to (6.5 + 4.5) is %f" sampleResult3

Tuples

/// This sample defines and prints some basic tuple values in F#.
module SomeBasicTuples = 

    /// A simple tuple of integers
    let sampleTuple1 = (1, 2, 3)

    /// A function that swaps the order of two values in a tuple. If you hover
    /// the mouse over the function you will see its inferred type is generic.
    let swapElementsOfTuple (a, b) = (b, a)

    printfn "The result of swapping (1, 2) is %A" (swapElementsOfTuple (1,2))

    /// A simple tuple of an integer, a string and a double-precision floating point number
    let sampleTuple2 = (1, "fred", 3.1415)

    printfn "The first sample tuple is %A" sampleTuple1

    printfn "The second sample tuple is %A" sampleTuple2

Boolean Values

/// This sample defines and prints some basic boolean values in F#.
module SomeBooleanValues = 

    /// A simple boolean value
    let boolean1 = true

    /// A second simple boolean value
    let boolean2 = false

    /// Compute a new boolean using ands, ors, and nots
    let boolean3 = not boolean1 && (boolean2 || false)

    printfn "The expression 'not boolean1 && (boolean2 || false)' is %A" boolean3

String Values

/// This sample defines and prints some basic string values in F#.
module SomeStringValues = 

    /// A simple string
    let sampleString1  = "Hello"

    /// A second simple string
    let sampleString2  = "world"

    /// A third string, using a verbatim string literal
    let sampleString3  = @"c:\Program Files\"

    /// A fourth string, using a triple-quote string literal
    let sampleString4 = """He said "hello world" after you did"""

    /// "Hello world" computed using string concatenation
    let resultString1  = sampleString1 + " " + sampleString2

    printfn "The first result string is '%s'" resultString1

    /// "Hello world" computed using a .NET library function
    let resultString2 = System.String.Join(" ",[| sampleString1; sampleString2 |])
      // Try re-typing the above line to see intellisense in action
      // Note, ctrl-J on (partial) identifiers re-activates it

    printfn "The second result string is '%s'" resultString2

    /// A string formed by taking the first 7 characters of one of the result strings
    let resultString3  = resultString1.[0..6]

    printfn "The third result string is '%s'" resultString1

Basic Lists

/// This sample shows some more basic list values in F# and how to 
/// processes lists using functions such as 'map' and pipelining
module WorkingWithLists = 

    /// The empty list
    let sampleList1 = [ ]           

    /// A list with 3 integers
    let sampleList2 = [ 1; 2; 3 ]     

    /// A sample list, containing numbers from 1 to 1000
    let sampleList3 = [ 1 .. 1000 ]

    /// Create another list, containing the days which are Monday in the current year
    let sampleList4 = 
        [ for month in 1 .. 12 do
              for day in 1 .. System.DateTime.DaysInMonth(2011, month) do 
                  yield System.DateTime(2011, month, day) ]

    /// Create a list containing the tuples which are the coordinates of the black squares on
    /// a chess board.
    let sampleList5 = 
        [ for i in 0 .. 7 do
              for j in 0 .. 7 do 
                 if (i+j) % 2 = 1 then 
                     yield (i, j) ]


    /// Sum of a list
    let sumOfSampleList3 = List.sum sampleList3

    /// A new list with the squares of the numbers from 10 to 20. The function
    /// is defined using the pipeline operator.
    let resultList2 = 
        sampleList3 |> List.map (fun x -> x*x) 

    /// A function that computes the sum of the squares of the numbers divisible by 3.
    let sumOfSquaresUpTo n = 
        sampleList3
          |> List.filter (fun x -> x % 3 = 0)
          |> List.sumBy (fun x -> x * x)

    // Many more functions are in the 'List' module. You can also use functions in 
    // the 'Seq' module to process lists.

Dictionaries

/// This sample defines and use some dictionary and lookup table values in F#.
module SomeDictionaryValues = 
    
    /// The 'open' declaration is used to open a namespace.
    /// They are usually placed at the start of a file or module.
    open System.Collections.Generic

    /// This creates an immutable dictionary with integer keys and string values.
    /// Lookup is based on hashing the keys, which are the first elements of the tuples.
    let sampleLookupTable1 = dict [ (1, "ElementOne"); (2, "ElementTwo") ]

    /// This creates a much large immutable dictionary with integer keys and string values.
    let sampleLookupTable2 = dict [ for i in 0 .. 10000 -> (i, "Element" + string i) ]

    /// This looks up one entry in the dictionary. Its result is "ElementOne".
    let sampleLookupResult1 = sampleLookupTable1.[1]

    /// This looks up one entry in the dictionary. Its result is "Element100".
    let sampleLookupResult2 = sampleLookupTable2.[100]

    /// This function creates a mutable dictionary with integer keys and string values
    let createAndPopulateDictionary() = 
        let sampleDictionary = Dictionary<int,string>()
        for key,value in [ (1, "One"); (2, "Two") ] do 
            sampleDictionary.Add (key,value)
        sampleDictionary

    /// A mutable dictionary created using createAndPopulateDictionary.
    let sampleLookupTable3 = createAndPopulateDictionary()

    /// This looks up one entry in the dictionary
    let sampleLookupResult3 = sampleLookupTable2.[2]

    /// This creates an immutable map, based on a balanced binary tree, with integer keys and string values.
    /// Keys are compared using an ordering.
    let sampleLookupTable4 = Map.ofList [ for i in 0 .. 1000 -> (i, string (i*i)) ]

    /// This looks up one entry in the dictionary
    let sampleLookupResult4 = sampleLookupTable4.[465]

OOP / Classes

/// This sample shows how to define a simple class type.
module DefiningClasses = 

    /// A sample class defining a 2-dimensional vector type. The constructor
    /// for the type takes two arguments: dx and dy, both of type 'float'. This
    /// is the type of double-precision floating-point numbers and is a synonym 
    /// for 'double'.
    type SampleObject(dx:float, dy:float) = 
        /// The length of the vector, computed when the object is constructed
        let length = sqrt (dx*dx + dy*dy)

        /// The first parameter of the object
        member v.DX = dx

        /// The second parameter of the object
        member v.DY = dy

        /// The length of the object
        member v.Length = length

        // Return a new the vector where both parameters are scaled by a constant 
        member v.Scale(k) = SampleObject(k*dx, k*dy)
    
    /// An instance of the SampleObject class
    let sampleObject1 = SampleObject(3.0, 4.0)

    // Call a method on the sample object which returns a new object modifies its state.
    let sampleObject2 = sampleObject1.Scale(10.0)

    printfn "The length of sampleObject2 is %f" sampleObject2.Length

    printfn "The length of sampleObject2 is %f" sampleObject2.Length

Parameter Lists

/// This sample shows some parameter lists in F#.
module ParameterLists = 
    // Parameters supplied to functions and methods are, in general, patterns separated by spaces. 
    // 
    // Methods usually use the tupled form of passing arguments. This achieves a clearer result from 
    // other .NET languages.
    //
    // The curried form is most often used with functions created by using let bindings. 
    //
    // Tupled form:
    //    member this.SomeMethod(param1, param2) = ...
    //
    // Curried form:
    //   let function1 param1 param2 = ...

    /// This is an example of a function taking three arguments in curried form
    let addUpTheNumbers x y z = x + y + z

    printfn "The result of adding up the numbers is '%d'" (addUpTheNumbers 9 32 12)

    /// This is an example of a function taking three arguments in tupled form. 
    let addUpTheNumbersInTheTuple (x, y, z) = x + y + z

    printfn "The result of adding up the numbers is '%d'" (addUpTheNumbersInTheTuple (9, 32, 12))

    type Slice = Slice of int * int * string

    /// You can use other patterns within arguments. This sample shows how to match a single case
    /// union type using the name of the tag for the union case.
    let getSlice (Slice(p0, p1, text)) = 
        printfn "Data begins at %d and ends at %d in string %s" p0 p1 text
        text.[p0..p1]

    let substring = getSlice (Slice(0, 4, "Et tu, Brute?"))
    printfn "Substring: %s" substring


    /// Arguments for methods can be specified by position in a comma-separated argument list, or they can be passed 
    /// to a method explicitly by providing the name, followed by an equal sign and the value to be passed in. 
    /// If specified by providing the name, they can appear in a different order from that used in the declaration.
    /// 
    /// Named arguments are allowed only for methods, not for let-bound functions, function values, or lambda expressions.

    type SpeedingTicket(speed: int, limit: int) =
        member this.GetSpeedOver() = speed - limit

    let calculateFine (ticket : SpeedingTicket) =
        let delta = ticket.GetSpeedOver()
        if delta < 20 then 50.0 else 100.0

    let ticket1 = SpeedingTicket(limit = 55, speed = 70)
    printfn "The speeding fine is %f" (calculateFine ticket1)
 
    /// You can specify an optional parameter for a method by using a question mark in front of the parameter name. 
    /// Optional parameters are interpreted as the F# option type, so you can query them in the regular way that 
    /// option types are queried, by using a match expression with Some and None. Optional parameters are 
    /// permitted only on members, not on functions created by using let bindings.
    type DuplexType =
        | Full
        | Half

    type Connection(?rate0 : int, ?duplex0 : DuplexType, ?parity0 : bool) =
        let duplex = defaultArg duplex0 Full
        let parity = defaultArg parity0 false
        let rate = defaultArg rate0 (match duplex with Full -> 9600 | Half -> 4800)
        do printfn "Baud Rate: %d Duplex: %A Parity: %b" rate duplex parity

    let conn1 = Connection(duplex0 = Full)
    let conn2 = Connection(duplex0 = Half)
    let conn3 = Connection(300, Half, true)

Arrays

/// This sample defines and uses some array values in F#.
module WorkingWithArrays = 

    /// The empty array
    let sampleArray1 = [| |]

    /// Create a sample array, containing the five strings
    let sampleArray2 = [| "hello"; "world"; "and"; "hello"; "world"; "again" |]

    /// Create another array, containing the numbers from 1 to 1000
    let sampleArray3 = [| 1 .. 1000 |]

    /// Create another array, containing only the words "hello" and "world"
    let sampleArray4 = [| for word in sampleArray2 do
                             if word.Contains("l") then 
                                 yield word |]

    // Create an array initialized by index, containing the even numbers from 0 to 2000.
    let evenNumbersUpTo1000 = Array.init 1001 (fun n -> n * 2) 

    // Extract a sub-array using slicing notation
    let evenNumbersUpTo500 = evenNumbersUpTo1000.[0..500]


    /// This function prints one of the sample arrays using a loop.
    let printSampleArray4() = 
        for word in sampleArray4 do 
            System.Console.WriteLine("word: {0}",word)

    /// Execute the function 
    printSampleArray4()
    
    // Set two elements of the first sample array
    sampleArray2.[1] <- "world"
    sampleArray2.[3] <- "world"

    /// Get the length of the array 
    let arrLength = sampleArray4.Length        

    /// A function that computes the sum of the lengths of the words the start with 'h'
    let sumOfLengthsOfWords = 
        sampleArray2 
          |> Array.filter (fun x -> x.StartsWith "h")
          |> Array.sumBy (fun x -> x.Length)

    // Many more functions are in the 'Array' module. You can also use functions in 
    // the 'Seq' module to process arrays.

Sequences

/// This sample defines and uses some sequence (IEnumerable) objects in F#. Sequences
/// are evaluated on-demand, and re-evaluated each time they are iterated. Lists, arrays
/// and other collections can also be used as sequences.
module WorkingWithSequences = 

    /// The empty sequence
    let sampleSequence1 = Seq.empty

    /// Create a sample sequence, yield five strings
    let sampleSequence2 = seq {  yield "hello"; yield "world"; yield "and"; yield "hello"; yield "world"; yield "again" }

    /// Create another array, containing the numbers from 1 to 1000
    let sampleSequence3 = seq { 1 .. 1000 }

    /// Create another array, containing only the words "hello" and "world"
    let sampleSequence4 = 
        seq { for word in sampleSequence2 do
                if word.Contains("l") then 
                    yield word }

    // Create a sequence using one of the library functions in the Seq module.
    let evenNumbersUpTo1000 = Seq.init 1001 (fun n -> n * 2) 


    /// This function prints one of the sample arrays using a loop.
    let printSampleSequence3() = 
        for word in sampleSequence4 do 
            System.Console.WriteLine("word: {0}",word)

    /// Execute the function 
    printSampleSequence3()
    
    /// Create an infinite sequence which is a random walk.
    let rnd = System.Random()
    let rec randomWalk x =
        seq { yield x
              yield! randomWalk (x + rnd.NextDouble() - 0.5) }
    
    let first100ValuesOfRandomWalk = 
        randomWalk 5.0 
           |> Seq.truncate 100
           |> Seq.toList

    // Many more functions are in the 'Seq' module. You can convert sequences to lists,
    // arrays and dictionaries using Seq.toList, Seq.toArray and dict.

Generics

/// This sample shows how to define a generic class type.
module DefiningGenericClass = 

    /// A class which contains one item of mutable state and which implements the given interface.
    type HistoricalStateTracker<'T>(initialElement: 'T) = 
        /// The internal state of the class, recording the historical states in reverse order
        let mutable historicalStates = [ initialElement ]

        /// Add a new element to the list of states
        member x.UpdateState newState = 
            historicalStates <- newState :: historicalStates

        /// Get the entire list of historical states
        member x.History = historicalStates

        /// Get the latest state
        member x.CurrentState = historicalStates.Head

    /// A sample instance of the HistoricalStateTracker class, stogin integers
    let sampleStateTracker = HistoricalStateTracker 10

    // Add a state
    sampleStateTracker.UpdateState 17

    // Get the history
    sampleStateTracker.History

Recursion

/// This sample shows how to define recursive functions.
module DefiningRecursiveFunctions  = 
              
    /// Compute the factorial of an integer. The function is recursive and is thus defined using
    /// 'let rec'.
    let rec factorial n = if n = 0 then 1 else n * factorial (n-1)

    /// Compute the highest-common-factor of two integers. The function is recursive and is thus defined using
    /// 'let rec'. The recursive calls are tailcalls and the function is turned into a loop.
    /// Also, note that in F#, a function may take two arguments separated by spaces. This is called 
    /// 'currying'.
    let rec highestCommonFactor a b =                       
        if a=0 then b
        elif a<b then highestCommonFactor a (b-a)           
        else highestCommonFactor (a-b) b

    /// Compute the sum of a list of integers using a recursive function. The function is recursive and is thus defined using
    /// 'let rec'.
    let rec sumList xs =
        match xs with
        | []    -> 0
        | y::ys -> y + sumList ys

    /// Sometimes functions need to be made 'tail recursive'. This can mean using a helper
    /// function which carries an accumulator which builds up the result. This function 
    /// shows an example of such a helper function.
    let rec private sumListTailRecursiveHelper accumulator xs =
        match xs with
        | []    -> accumulator
        | y::ys -> sumListTailRecursiveHelper (accumulator+y) ys

    /// This function calls the helper function to process the elements of the list in a 
    /// tail-recursive way.
    let sumListTailRecursive xs = sumListTailRecursiveHelper 0 xs

Record Types

/// This sample defines a record type representing some simple user data.
module DefiningRecordTypes = 

    /// This defines a record type, which is a .NET reference type with the given properties.
    type ContactCard = 
        { Name  : string;
          Phone : string;
          Ok    : bool }
              
    /// An example ContectCard object
    let sampleRecordObject1 = { Name = "Alf" ; Phone = "(206) 555-0157" ; Ok = false }

    /// A second example ContectCard object
    let sampleRecordObject2 = { sampleRecordObject1 with Phone = "(206) 555-0112"; Ok = true }

    /// A function to convert a 'ContactCard' object to a string
    let showCard c = 
        c.Name + " Phone: " + c.Phone + (if not c.Ok then " (unchecked)" else "")

Unions

/// This sample defines a and use some dictionary and lookup table values in F#.
module DefiningUnionTypes = 

    /// Represents the suit of a playing card
    type Suit = 
        | Hearts 
        | Clubs 
        | Diamonds 
        | Spades

    /// Represents the rank of a playing card
    type Rank = 
        /// Represents the rank of cards 2 .. 10
        | Value of int
        | Ace
        | King
        | Queen
        | Jack
        static member GetAllRanks() = 
            [ yield Ace
              for i in 2 .. 10 do yield Value i
              yield Jack
              yield Queen
              yield King ]
                                   
    type Card =  { Suit: Suit; Rank: Rank }
              
    /// Return a list representing all the cards in the deck
    let fullDeck = 
        [ for suit in [ Hearts; Diamonds; Clubs; Spades] do
             for rank in Rank.GetAllRanks() do 
                 yield { Suit=suit; Rank=rank } ]

    /// A function to convert a 'Card' object to a string
    let showCard c = 
        let rankString = 
            match c.Rank with 
            | Ace -> "Ace"
            | King -> "King"
            | Queen -> "Queen"
            | Jack -> "Jack"
            | Value n -> string n
        let suitString = 
            match c.Suit with 
            | Clubs -> "clubs"
            | Diamonds -> "diamonds"
            | Spades -> "spades"
            | Hearts -> "hearts"
        rankString  + " of " + suitString

    let printAllCards() = 
        for card in fullDeck do 
            printfn "%s" (showCard card)

Option Values

/// Option values are any kind of value tagged with either 'Some' or 'None'.
/// They are used extensively in F# code to represent the cases where many other
/// languages would use null references.
module Options = 
    open System

    let data = Some(1,3)
    printfn "data = %A" data;
    printfn "data.IsSome = %b" data.IsSome
    printfn "data.IsNone = %b" data.IsNone
    printfn "data.Value = %A" data.Value

    let data2 = None
    printfn "data2.IsSome = %b" data2.IsSome
    printfn "data2.IsNone = %b" data2.IsNone


    let openingHours day = 
        match day with 
        | DayOfWeek.Monday 
        | DayOfWeek.Tuesday 
        | DayOfWeek.Thursday 
        | DayOfWeek.Friday    -> Some(9,17)
        | DayOfWeek.Wednesday -> Some(9,19) // extended hours on Wednesday
        | _ -> None 

    let today = DateTime.Now.DayOfWeek 

    match openingHours today with 
    | None -> printfn "The shop's not open today"
    | Some(s,f) -> printfn "The shop's open today from %02d:00-%d:00" s f

Pattern Matching

/// Pattern matching is used throughout F# code. This sample shows some simple
/// examples of pattern matching. Many of the other samples in this file also
/// use pattern matching.
module PatternMatching = 


    /// The following example shows how to match on an option value.
    let printOption data =
        match data with
        | Some var1  -> printfn "The value %d was given" var1
        | None -> ()

    // Call the function
    printOption (Some 17)
    
    /// In the following example, the PersonName discriminated union contains a mixture of strings 
    /// and characters that represent possible forms of names. The cases of the discriminated 
    /// union are FirstOnly, LastOnly, and FirstLast.
    type PersonName =
        | FirstOnly of string
        | LastOnly of string
        | FirstLast of string * string

    let constructQuery personName = 
        match personName with
        | FirstOnly firstName -> printf "May I call you %s?" firstName
        | LastOnly lastName -> printf "Are you Mr. or Ms. %s?" lastName
        | FirstLast(firstName, lastName) -> printf "Are you %s %s?" firstName lastName

    

    /// This samples shows how to use a 'when' clause to add an extra check to a pattern matching rule.
    let function1 x =
        match x with
        | (var1, var2) when var1 > var2 -> printfn "%d is greater than %d" var1 var2 
        | (var1, var2) when var1 < var2 -> printfn "%d is less than %d" var1 var2
        | (var1, var2) -> printfn "%d equals %d" var1 var2

    // Call the function with some input values
    function1 (1, 2)
    function1 (2, 1)
    function1 (0, 0)

    /// The following sample shows how to use 'or' patterns when input data can match 
    /// multiple patterns, and you want to execute the same code as a result. The types 
    /// of both sides of the OR pattern must be compatible.
    let detectZeroOR point =
        match point with
        | (0, _) | (_, 0) -> printfn "Zero found."
        | _ -> printfn "Both nonzero."

    // Call the function with some input values
    detectZeroOR (0, 0)
    detectZeroOR (1, 0)
    detectZeroOR (0, 10)
    detectZeroOR (10, 15)


    /// The list pattern enables lists to be decomposed into a number of elements. The list 
    /// pattern itself can match only lists of a specific number of elements. 
    let listLength list =
        match list with
        | [] -> 0
        | [ _ ] -> 1
        | [ _; _ ] -> 2
        | [ _; _; _ ] -> 3
        | _ -> List.length list

    // Call the function with some input values
    printfn "%d" (listLength [ 1 ])
    printfn "%d" (listLength [ 1; 1 ])
    printfn "%d" (listLength [ 1; 1; 1; ])
    printfn "%d" (listLength [ ] )


    open System.Windows.Forms

    /// The type test pattern is used to match the input against a type. If the input type 
    /// is a match to or a derived type of the type specified in the pattern, the match succeeds.
    ///
    /// The following example demonstrates the type test pattern.
    let textOfControl (control:Control) =
        match control with
        | :? Button as button -> "Button " + button.Text 
        | :? CheckBox -> "CheckBox"
        | _ -> control.Text

    /// The null pattern matches the null value that can appear when you are working with types that 
    /// allow a null value. Null patterns are frequently used when interoperating with .NET Framework 
    /// code. For example, the return value of a .NET API might be the input to a match expression. You 
    /// can control program flow based on whether the return value is null, and also on other characteristics 
    /// of the returned value. You can use the null pattern to prevent null values from propagating to 
    /// the rest of your program.
    let readFromFile (reader : System.IO.StreamReader) =
        match reader.ReadLine() with
        | null -> None 
        | line -> Some line

Active Patterns

/// F# supports extensible pattern matching through 'active patterns'.
/// This sample shows how to define a set of partial active patterns and use 
/// them in pattern matching. 
module ActivePatterns = 

    /// This is a partial active pattern which will match strings that can be converted to integers
    let (|Integer|_|) (str: string) =
       let mutable intvalue = 0
       if System.Int32.TryParse(str, &intvalue) then Some(intvalue)
       else None

    /// This is a partial active pattern which will match strings that can be converted to floating point numbers
    let (|Float|_|) (str: string) =
       let mutable floatvalue = 0.0
       if System.Double.TryParse(str, &floatvalue) then Some(floatvalue)
       else None

    /// This is a function which uses the two active patterns
    let parseNumeric str =
         match str with 
         | Integer i -> printfn "%d : Integer" i
         | Float f -> printfn "%f : Floating point" f
         | _ -> printfn "%s : Not matched." str

    // Now call the function with a variety of inputs
    let result1 = parseNumeric "1.1"
    let result2 = parseNumeric "0"
    let result3 = parseNumeric "0.0"
    let result4 = parseNumeric "10"
    let result5 = parseNumeric "Something else"

Interfaces

/// This sample shows how to define an interface type and a class that implements it.
module DefiningClassesAndInterfaces = 

    /// A sample interface type with two methods.  
    type IPeekPoke = 
        /// A method on the interface type. It takes no arguments. The type 'unit' is the F# name for both
        /// 'no arguments' and 'no results', called 'void' in languages such as C#.
        abstract Peek: unit -> int

        /// A second method on the interface type. It takes one argument and returns no result.
        abstract Poke: int -> unit

              
    /// A class which contains one item of mutable state and which implements the given interface.
    type ClassImplementingPeekPoke(initialState:int) = 
        /// The internal state of the ClassImplementingPeekPoke
        let mutable state = initialState

        // Implement the IPeekPoke interface
        interface IPeekPoke with 
            member x.Poke n = state <- state + n
            member x.Peek() = state 
        
        /// Has the ClassImplementingPeekPoke been poked?
        member x.HasBeenPoked = (state <> 0)


    /// A sample instance of the ClassImplementingPeekPoke class, viewed through the IPeekPoke interface.
    let sampleObject = ClassImplementingPeekPoke(12) :> IPeekPoke

    // Call a method on the sample widget which modifies its state.
    sampleObject.Poke(4)

    // Get the result of calling a method on the sample widget.
    let peekResult = sampleObject.Peek()

    // A list of two objects, each implementing the interface, but sharing state. 
    // The implementations each use an F# object expression, which is a convenient
    // way of implementing objects without needing to write a new class.
    let alternativeImplementations() = 

        // Use a F# reference cell as the shared state
        let sharedState = ref 0

        [ { new IPeekPoke with 
               member x.Peek() = !sharedState / 2
               member x.Poke n = sharedState := n }

          { new IPeekPoke with 
               member x.Peek() = !sharedState * 2
               member x.Poke n = sharedState := n } ]

.NET Libraries

/// This sample shows working with the .NET times for decimals and dates.
module WorkingWithDotNetLibraryTypes = 

    open System

    /// The current time
    let sampleTime = DateTime.Now 

    /// A list with 2 dates - the start and end of the year 2011
    let sampleListOfDates = [ DateTime(2011,1,1); DateTime(2011,12,31) ]     

    /// Create another list, containing the days which are Saturday or Sunday in the current year
    let sampleListOfDates4 = 
        [ for month in 1 .. 12 do

              let thisYear = DateTime.Now.Year

              for day in 1 .. DateTime.DaysInMonth(thisYear, month) do 

                  let date = DateTime(year=thisYear, month=month, day=day)

                  match date.DayOfWeek with
                  | DayOfWeek.Saturday 
                  | DayOfWeek.Sunday -> yield date 
                  | _  -> () ]

    /// Decimal literals use the 'M' suffix
    let sampleDecimalConstant = 103.62M

    /// A function to increment a decimal
    let incrementMoney (x:System.Decimal) = x + 1.0M

    /// Some data representing account values
    let accounts = [ 23.6M; 101.62M; 13.62M ]

    /// The result of adding up some decimal constants
    let addingUpDecimalNumbers = accounts |> List.map incrementMoney |> List.sum


    // Many more types, properties and methods are in the 'Sys

.NET Regular Expressions

/// This sample shows how to use the .NET regular expression libraries from F#
module WorkingWithRegularExpressions = 

    open System.Text.RegularExpressions

    let names = ["Mr. Henry Hunt"; "Ms. Sara Samuels"; "Abraham Adams"; "Ms. Nicole Norris"]

    /// This example shows how to check if a string matches a regular expression.
    /// The regular expression pattern  matches any occurrence of "Mr ", "Mr. ", "Mrs ", 
    /// "Mrs. ", "Miss ", "Ms " or "Ms. "
    let namesWithTitle = 
        names |> List.filter (fun name -> Regex.IsMatch(name, @"(Mr\.? |Mrs\.? |Miss |Ms\.? )"))

    /// This example shows how to remove all titles by replacing with the empty string.
    let namesWithTitlesRemoved = 
        names |> List.map (fun name -> Regex.Replace(name, @"(Mr\.? |Mrs\.? |Miss |Ms\.? )", ""))

    /// A function to identify duplicate words in some input text.
    ///  \b    - Start at a word boundary.
    ///  (\w+) - Match one or more word characters. Together, they form a group that can be referred to as \1.
    ///  \s    - Match a white-space character.
    ///  \1    - Match the substring that is equal to the group named \1.
    ///  \b    - Match a word boundary.
    let identifyDuplicateWords input = 
        for m in Regex.Matches(input, @"\b(\w+?)\s\1\b", RegexOptions.IgnoreCase) do
            printfn "\"%s\" duplicates '%s' at position %d" m.Value m.Groups.[1].Value m.Index

    /// Run the sample
    identifyDuplicateWords "This this is a nice day. What about this? This tastes good. I saw a a dog."

    // More information on using regular expressions with F# is available on MSDN.

Recursive Trees

/// This sample shows how to use union types to define a type of recursive trees 
/// for an embedded language of expressions.
module RecursiveTrees  = 
              
    open System.Collections.Generic

    /// This type is an example of a discriminated union representing an expression tree
    /// in an embedded domain specific language.
    type Expr = 
        /// Represents a constant node in the expression tree
        | Number of int
        /// Represents an addition node in the expression tree
        | Add of Expr * Expr
        /// Represents a multiplication node in the expression tree
        | Multiply of Expr * Expr
        /// Represents a variable node in the expression tree
        | Var of string
  
    /// This function traverses an expression and evaluates it.  
    /// 
    /// If a variable node is encountered we look up the value of the variable in 
    /// the given environment. Here the environment is an F# map, which is an immutable
    /// dictionary collection, stored as a binary tree.
    let rec evaluateExpression (env:IDictionary<string,int>) expr = 
        match expr with
        | Number n -> n
        | Add (x,y) -> evaluateExpression env x + evaluateExpression env y
        | Multiply (x,y) -> evaluateExpression env x * evaluateExpression env y
        | Var id    -> env.[id]
  
    /// This is a sample initial environment which gives values to the variables a, b and c.
    let sampleEnvironment = dict [ ("a", 1) ; ("b", 2) ; ("c", 3) ]
             
    /// This is a sample initial expression in the embedded domain specific language
    let sampleExpression = Add(Var "a", Multiply(Number 2, Var "b"))

    /// This evaluates the expression.
    let evaluationResult = evaluateExpression sampleEnvironment sampleExpression

Inlined Generic Arithmetic

/// This sample shows how to use inlined functions to create functions that are
/// generic over arithmetic type.
module InlinedGenericArithmetic = 
              
    open System.Collections.Generic

    /// Return a square around a point, using any numeric type that supports addition and subtraction.
    /// The use of 'inline' means that the function becomes generic over arithmetic type.
    /// The square is represented as a tuple of points, where the points are also represented
    /// as tuples.
    let inline squareAroundPoint dx (x, y) = ( (x-dx, y-dx), (x+dx, y-dx), (x+dx, y+dx), (x-dx, y+dx))

    // A square, using 32-bit integer coordinates
    let square1 = squareAroundPoint 3 (10, 20)

    // A square, using floating point coordinates
    let square2 = squareAroundPoint 3.0 (10.0, 20.0)

    // A square, using big-integer coordinates
    let square3 = squareAroundPoint 3I (10I, 20I)

Units Of Measure

/// This sample shows how you can annotate your code with units of measure when using
/// F# arithmetic over numeric types.
module UnitsOfMeasure = 
              
    open Microsoft.FSharp.Data.UnitSystems.SI.UnitNames
    open Microsoft.FSharp.Data.UnitSystems.SI.UnitSymbols

    /// Return two points 10 meters either side of the value.
    let leftAndRightByTenMeters (x: float<meter>) = (x - 10.0<m>,  x + 10.0<m>) 

    /// Check if a range contains a point
    let contains ((x1: float<m>, x2:float<meter>)) p = (x1 <= p && p <= x2)

    /// Check if two ranges overlap
    let overlap (x1, x2) p2 =  contains p2 x1 || contains p2 x2

    let area1 = leftAndRightByTenMeters 116.0<m>
    let area2 = leftAndRightByTenMeters 107.3<m>

    printfn "Do the areas overlap? - %s" (if overlap area1 area2 then "yes" else "no")

    /// Define a new unit-of-measure
    [<Measure>]
    type centimeter

    /// Define a conversion function for the new unit-of-measure based on a conversion constant
    let convertToMeters (x: float<centimeter>) = x / 100.0<centimeter/meter>

    convertToMeters 250.0<centimeter>

Events

/// This sample shows how you can react to events in F# code.
module Events = 
              
    open System.Drawing
    open System.Windows.Forms
    
    /// Create a form
    let form = new Form(Text = "Sample Form For Events", TopMost=true, Size=Size(300,300), Visible=true)
    let button1 = new Button(Text = "Press Button 1", Location=Point(100,100), AutoSize=true)
    let button2 = new Button(Text = "Launch", Location=Point(100,160), AutoSize=true)
    let text = new Label (Text = "This form is a part of the 'Events' sample for showing how F# programs can react to events such as mouse clicks", 
                          Location=Point(20,50), Size=Size(260,40))
    form.Controls.Add button1
    form.Controls.Add button2
    form.Controls.Add text

    // This shows how to react to an event using a standard synchronous handler. You can also use
    // AddHandler and RemoveHandler to detach specific handler objects.
    button1.MouseClick.Add (fun args -> 
         text.Text <- sprintf "Button #1 was clicked. The mouse position (%d, %d)" args.X args.Y
    )
    

    // This shows how to react to an event using a pipeline of handlers. 
    form.MouseMove
       |> Event.filter (fun args -> args.X < 10 && args.Y < 10)
       |> Event.add (fun args -> 
           text.Text <- sprintf "The mouse moved over the secret area at position (%d, %d)" args.X args.Y
    )

    // This shows how to react to an event using an asynchronous handler that starts a co-routine. See the 
    // later samples for more information on asynchronous programming.
    button2.MouseClick.Add (fun args -> 
     async {
         for i in 5.0 .. -0.1 .. 0.0 do 
            text.Text <- sprintf "Countdown: %0.2f" i
            do! Async.Sleep 100
         text.Text <- "Blast off!" 
     } |> Async.StartImmediate)

Lightweight Asynchronous Agent

/// This sample shows how you to create a lightweight asynchronous agent in F# code.
module Agents = 
              
    /// This is a common type alias used for the F# mailbox processor type
    type Agent<'T> = MailboxProcessor<'T>
    
    /// A simple agent that reacts to messsages, which are strings
    let agent1 = 
        Agent.Start (fun inbox -> async { 
            while true do 
                let! message = inbox.Receive()
                printfn "[Agents] Agent #1 received message <<<%s>>>"  message
         })

    // Send 10 messages to the agent
    for i in 1 .. 10 do 
        agent1.Post (sprintf "message %d to agent" i)

    
 
    /// A message type used by the second agent 
    type Message = 
        | Message1 of int
        | Message2 of AsyncReplyChannel<int>

    /// The second agent. The body is a series of asynchronous recursive functions.
    let agent2 = 
        Agent.Start (fun inbox -> 
            let rec state1 total = 
                async { printfn "[Agents] now in state #1, total = %d" total
                        let! message = inbox.Receive()
                        match message with 
                        | Message1 n -> 
                            // Increment and go to state #2 
                            return! state2 (total + n)
                        | Message2 reply -> 
                            // Reply to the message and stay in state #1
                            reply.Reply total; 
                            return! state1 total }

            and state2 total = 
                async { printfn "[Agents] now in state #2, total = %d" total
                        let! message = inbox.Receive()
                        match message with 
                        | Message1 n -> 
                            // Increment and go to state #1 
                            return! state1 (total + n)
                        | Message2 reply -> 
                            // Reply to the message and stay in state #2
                            reply.Reply total; 
                            return! state2 total }
            
            // Start in state one
            state1 0
         )

    for i in 1 .. 10 do 
        agent2.Post (Message1 i)

    let total = agent2.PostAndReply Message2

Parallel Array Computations I

/// This sample shows how to do some simple parallel array programming with F#
module ParallelArrayComputations = 
              
    // This is a smaller input array
    let oneSmallArray = [| 0 .. 100 |]

    // This is a bigger input array
    let oneBigArray = [| 0 .. 100000 |]
    
    // This does some CPU intensive computation 
    let rec computeSomeFunction x = 
        if x <= 2 then 1 
        else computeSomeFunction (x-1) + computeSomeFunction (x-2)
       
    // This shows how to do a parallel map over a small input array
    let computeResults1() = oneSmallArray |> Array.Parallel.map (fun x -> computeSomeFunction (x % 38))

    // We can use the same formula to do a parallel map over a large input array
    let computeResults2() = oneBigArray |> Array.Parallel.map (fun x -> computeSomeFunction (x % 20))

    // This shows how to do a slightly different parallel operation over a large input array.
    // The operation chooses results where the answer is even.
    let computeResults3() = 
        oneBigArray |> Array.Parallel.choose (fun x -> 
            let v = computeSomeFunction (x % 20) 
            if v % 2 = 0 then Some (x,v) else None)

    let results1 = computeResults1()
    let results2 = computeResults2()
    let results3 = computeResults3()

    printfn "[ParallelArrayComputations] results1 = %A" results1
    printfn "[ParallelArrayComputations] results2 = %A" results2
    printfn "[ParallelArrayComputations] results3 = %A" results3 

Parallel Async Computations II

/// This sample shows how to do some simple parallel async programming with F#.
/// Parallel async programming usually involves a mixture of CPU and I/O intensive 
/// computations.
module ParallelAsyncComputations = 
              
    /// A set of web pages to fetch in parallel
    let webPages = [ "http://www.microsoft.com"; 
                     "http://www.msdn.com"; 
                     "http://research.microsoft.com" ]
    
    /// Do an asynchronous fetch of a web page
    let asyncGetWebPage (url:string) = 
        async { use req = new System.Net.WebClient()
                let! html = req.AsyncDownloadString(System.Uri(url))
                return (url, html) }

    /// Get the results of a parallel fork-join composition and start as a background process
    let pages = 
        async { printfn "[ParallelAsyncComputations] The sample is starting..."
                let! pages = Async.Parallel [ for page in webPages -> asyncGetWebPage page ]  
                printfn "[ParallelAsyncComputations] The results are now ready"
                /// Print the results
                for (url, html) in pages do 
                    printfn "[ParallelAsyncComputations] The HTML for %s has %d characters"  url html.Length
        } |> Async.Start

Database Access

/// This sample indicates how to access a database from F#.
module DatabaseAccess = 
              
    // The easiest way to access a SQL database from F# is to use F# type providers. To do this in 
    // a project, add a reference to System.Data, System.Data.Linq, FSharp.Data.TypeProviders.dll.
    // You can use Server Explorer to build your ConnectionString. 

    (*
    #if INTERACTIVE
    #r "System.Data"
    #r "System.Data.Linq"
    #r "FSharp.Data.TypeProviders"
    #endif

    open Microsoft.FSharp.Data.TypeProviders
    
    type SqlConnection = SqlDataConnection<ConnectionString = @"Data Source=.\sqlexpress;Initial Catalog=tempdb;Integrated Security=True">
    let db = SqlConnection.GetDataContext()

    let table = 
        query { for r in db.Table do
                select r }
    *)


    // You can also use SqlEntityConnection instead of SqlDataConnection, which accesses the database using Entity Framework.
    //
    // Alternatively, use the ADO.NET library to access database connections in a dynamically typed way.

    let placeHolder = 1

OData Access

module ODataAccess = 
              
    // The easiest way to access an OData service from F# is to use F# type providers. To do this in 
    // a project, add a reference to System.Data, System.Data.Linq, FSharp.Data.TypeProviders.dll.
    //
    // For more about OData see www.odata.org. You can use a search engine to find suitable service URLs.
    // One good source of OData sources is the Azure Data Market.

    (*
    #if INTERACTIVE
    #r "System.Data.Services.Client"
    #r "FSharp.Data.TypeProviders"
    #endif

    // open System.Data.Services.Client
    // open Microsoft.FSharp.Data.TypeProviders

    // Consume demographics population and income OData service from Azure Marketplace. For more information, Please go to https://datamarket.azure.com/dataset/c7154924-7cab-47ac-97fb-7671376ff656
    type Demographics = ODataService<ServiceUri = "https://api.datamarket.azure.com/Esri/KeyUSDemographicsTrial/">
    let ctx = Demographics.GetDataContext()
    
    //To sign up for a Azure Marketplace account at https://datamarket.azure.com/account/info
    ctx.Credentials <- System.Net.NetworkCredential ("<your liveID>", "<your Azure Marketplace Key>")
     
    let cities = 
        query { for c in ctx.demog1 do
                where (c.StateName = "Washington")
                select c } 
    
    for c in cities do
        printfn "%A - %A" c.GeographyId c.PerCapitaIncome2010.Value

    *)

    let placeHolder = 1

Boilerplate WinForm

#if COMPILED
module BoilerPlateForForm = 
    [<System.STAThread>]
    do ()
    do System.Windows.Forms.Application.Run()

#endif