Let the |> fun beginAn introduction to F#

Bogdan Brinzarea-IamandiBanca Romaneasca

22 February 2010

Agenda

Topic Covered Today

History

From imperative to functional

Fundamentals

Data structures

Pattern matching

Immutability vs. Mutability

Object Oriented Programming

Async and Parallel Programming

25 February 2010

Unit testing 25 February 2010

History

F is for fun“The most original new face in computer languages since Bjarne Stroustrup developed C++ in the early 1980‘s”

http://www.simple-talk.com/opinion/geek-of-the-week/don-syme-geek-of-the-week/

What is F#?

Functional Programming Language Will ship with Visual Studio 2010 Deep roots in OCaml (http://caml.inria.fr) Developed by Microsoft Research

http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/

Why should F# matter to me?

Succinctness Type safety Type inference Expressivity Scripting Performance Seamless integration with .NET

Why should F# matter to me?

Functional programming Imperative programming Object oriented programming Scripted programming

Why should F# matter to me?

Well suited for: Technical programming Algorithmic programming Parallel programming Asynchronous programming Explorative programming Financial computing

From imperative to functional programming

Fibonacci C#

static IEnumerable<int> Fibonacci{

get{ int i = 1; int j = 2; while (true) { int n = i; yield return n; i = j; j = j + n; }}

}

Fibonacci F#

let fibs = Seq.unfold (fun (i,j) -> Some(i,(j,i+j))) (1,2)

Functional programming

Much more like our mind thinks Easy to grasp for scientists Pure functional programming has no

side effects - immutability Highly parallelizable Powerful function support with

currying and composition

Functional features in other languages

C# 3.0 already has lambda expressions, anonymous functions, first class functions, anonymous types

Matthew Podwysocki - Functional C# http://code.msdn.microsoft.com/FunctionalCSharp/

Bart de Smethttp://bartdesmet.net/blogs/bart/

Luca Bolognesehttp://blogs.msdn.com/lucabol/

Imperative programming

Variable and assignment as main operations

In C# value types are immutable F# is not pure functional as it has

Flow control (for, while, if) Mutable keyword Reference cells Arrays

Imperative vs Functional

Characteristic Imperative Functional

Programmer focus How to perform tasks (algorithms) and how to track changes in state.

What information is desired and what transformations are required.

State changes Important. Non-existent.

Order of execution Important. Low importance.

Primary flow control Loops, conditionals, and function (method) calls.

Function calls, including recursion.

Primary manipulation unit

Instances of structures or classes.

Functions as first-class objects and data collections.

MSDN Library http://msdn.microsoft.com/en-us/library/bb669144.aspx

Fundamentals

#light

Lightweight syntax Makes whitespaces significant Lets you leave out tokens such as begin end ; ;; in

Makes code more readable and concise

Hello world!

printfn "Hello world!"

Let keyword

// define a valuelet message ="Hello world!“

// define a function valuelet sqr x = x*x

Binds forever a value or function value to an identifier

DOES NOT assign a value to an identifier The identifiers are immutable The compiler infers the types

Type inference

F# is statically typed The compiler infers the type for all

variables and functions We need to specify only when it

cannot be deduced Every value and expression has a

definite type at compile time

Type inference

Automatic generalization - if the type is not specified it is inferred as generic

// 'a -> 'b -> 'a * 'blet pair x y = (x , y)

Type inference

The return type of a function is determined by the type of the last expression in the function.// int->int->intlet add1 x y = x + y + 1

// float->float->floatlet add10 x y = x + y + 1.0

Type inference

We can give the compiler a little help

// help inferring the type let (message:string) = "Hello world!"

let add (x:float) (y:float) = x+y let sum = add 2.0 1.0

Fun or lambda expressions

Can be used as parameters to other functions

let squares = Array.map (fun x->x*x) [|0..10|]

Recursive functions

Functions are not recursive by default

Make sure the recursively function ends

Use the rec keyword together with let

let rec Fibonacci n = if n<2 then n else Fibonacci n-1 + Fibonacci n-2

Currying or partial functions

Named after Haskell Curry A function that calls another function

and returns a function or A partial function

let add x y = x + y let add5 = add 5 let result = add5 6

Local identifiers

Indentation matters

let SquareAndSum x y = let sqr x = x * x sqr x + sqr y

Basic operators

Arithmetic operators Description

x + y Addition

x – y Subtraction

x * y Multiplication

x / y Division

x % y Modulus

x ** y Power of

Boolean operator Description

not Boolean NOT

|| Boolean OR

&& Boolean AND

Basic types

F# type C# type Examplebool Boolean truebyte Byte 45ysbyte SByte 45uyint16 Int16 45suint16 UInt16 45usint Int32 45uint UInt32 45uint64 Int64 45Luint64 UInt64 45ULchar Char ‘c’decimal Decimal 45Mstring String “A string”unit not applicable ()

Pipelines and functions composition

Scientists love it Composition f(g(x)) g >> f

Pipelines take an input of a function and pass it to the next oneinput |> function 1 |> function 2

Data types

Tuples

A group of unnamed but ordered values

Can contain different types In .NET System.Tuple

Arrays

All elements of the array must have the same type

Elements are mutable A lot of helper functions to choose from

(map, filter, iter etc.) let array1 = [| 0; 1; 2 |]

let array2 = [| 0..10 |]

let array3 = [| for i in 0..10 -> i |]

Lists

A series of elements all of same (base) type

Lists are immutable :: (cons operator) adds an element

to the head of the list @ concatenates lists Head, Tail properties A lot of helper functions to choose

from (head, tail, nth, map, iter, filter) let list1 = [ 1;2;3]

Sequences

A series of elements all of same type Equivalent to System.Collections.Generic.IEnumerable

Sequence expressions evaluate to sequences

A lot of helper functions to choose from (map, filter, iter) same as for lists

let seq1 = seq {1..10}

Discriminated unions

A way of grouping different values and types

Used to represent tree structures Data is not fixed Each possible option has a case

identifier

type Tree = | Nil | Node of int * Tree * Tree

Options

An option wraps a value indicating whether it exists or not

They are a simple example of discriminated union// a: int option let a = Some (42)// b: 'a optionlet b = None

Records

Simple way of grouping named values

We can use record expressions to set values

Easy cloning with copy and update record expressions

Pattern matching

Pattern matching at a glance

Offers branching of the control based on comparison of an expression with a set of patterns

One of the most powerful features of F#

Not a simple switch statement Haskell, ML and OCaml also have it

match expressions

When guards to add extra condition to the pattern

// Match expressionmatch test-expression with | pattern1 [ when condition ] -> result-expression1

| pattern2 [ when condition ] -> result-expression2

| ...

Patterns

Name ExampleConstant pattern 1.0,"test",30,Color.Red

Identifier pattern Some(x)Failure(msg)

Variable pattern A

as pattern (a, b) as tuple1

OR pattern ([h] | [h; _])

AND pattern (a, b) & (_, "test")

Cons pattern h :: t

List pattern [ a; b; c ]

Array pattern [| a; b; c |]

Patterns

Name ExampleParenthesized pattern ( a )

Tuple pattern ( a, b )

Record pattern { Name = name; }

Wildcard pattern _

Pattern together with type annotation

a : int

Type test pattern :? System.DateTime as dt

Null pattern null

Pattern matching

let rec f = function | x when x < 0 -> failwith "Negative values are not allowed."

| 0 | 1 as x -> x | x -> f (x-1) + f (x-2)

Active patterns

Pattern matching of Algebraic Data Types (ADTs)

Allow to define named partitions for input data

Partial active patterns when we need to partition only part of the input

Parameterized active patterns when we have more than one argument

Mutability vs immutability

Mutability

Use mutable to make a variable mutablelet mutable a = 1a <- 2

Arrays are mutablelet array = [|1..10|]array.[2] <- 5

Reference cells

ref operator allows to box mutable values inside reference cellstype Ref<'a> =

{ mutable contents: 'a } byref keyword to ask for a reference

cell or the address of a typical variable

Object Oriented Programming

Classes

type [access-modifier] type-name [type-params]( parameter-list ) [ as identifier ] =

[ class ] [inherit base-type-name(base-constructor-args) ]

[ let-bindings ] [ do-bindings ] member-list Let bindings define fields or function values

local to the class Do bindings define code to be executed upon

creation Identifier gives a name to the instance variable

Classes

new(argument-list) = constructor-body

new allows to define other constructors

Interfaces

// Interface declarationtype interface-name = [ interface ] abstract member1 : [ argument-types1 -> ] return-type1 abstract member2 : [ argument-types2 -> ] return-type2 ... // Implementing, inside a class type definition: interface interface-name with

member self-identifier.member1 argument-list = method-body1 member self-identifier.member2 argument-list = method-body2

// Implementing, by using an object expression let class-name (argument-list) = {

new interface-name with member self-identifier.member1 argument-list = method-body1 member self-identifier.member2 argument-list = method-body2 [ base-interface-definitions ]

} member-list

Abstract classes

// Abstract class syntax.type [ accessibility-modifier ] abstract-class-name

= [ inherit base-class-or-interface-name ] [ abstract-member-declarations-and-member-

definitions ]

// Abstract member syntax. abstract member member-name : type-signature

Inheritance

Virtual methods abstract member method-name : typedefault self-identifier.method-name argument-

list = method-bodyoverride self-identifier.method-name argument-

list = method-body

Use object expressions as an alternative

Generics

Values, methods, properties, classes, records, discriminated unions

Implicit generic constraint via type inference

Explicit generic constraint

Resources

Expert F# by Don Syme Programming F# by Chris Smith CTO Corner - http://ctocorner.com/fsharp/book/ HubFS

http://cs.hubfs.net/ Matthew Podwysocki

http://weblogs.asp.net/podwysocki/ Don Syme

http://blogs.msdn.com/dsyme Chris Smith

http://blogs.msdn.com/chrsmith/