F# is a functional programming language that runs on .NET and was created by Microsoft. It is part of the OCaml family of languages and is included in Visual Studio 2010. F# uses immutable values by default whereas other languages like C# use mutable values. F# code is more succinct due to its support for type inference and ability to write standalone functions without needing to be part of a class. F# also supports object-oriented programming and imperative programming. It allows for strong typing while keeping syntax clean.

1. Eriawan Kusumawardhono

2.  F# is starting from a research project of
Microsoft, created by Don Syme
 F# is a functional programming language
that runs on top of .NET
 F# is now part of VS 2010 built in
programming language
 Also part of OCAML programming language
family

3.  There are many definitions about this, and
there’s no simple standard definition
 According to Erik Meijer and Brian Beckman
of Microsoft, Functional Programming is
programming with mathematical function,
where function is a first class citizen of a
program

4.  A simple operation that returns a value, that
can have a parameter or more than one
parameters

5. f(x) = x+1
y=x+1

6. x=x+1
x++

7. F# OOP (C#, VB, C++…)
 Immutable by default  Mutable by default
 Function is the same as  Function is treated as a
data in a program, and can method that must reside in
be written as a standalone a body of a class
function  ‘Noisy’ syntax
 Succinct syntax  Type inference is only
 Type inference is available available since C# 3.0 and
from the start VB 9.0, not in C++ and
others

8. Comparison of F# to others such as C#, VB, C++

9.  Immutable by default  Mutable by default
let y = x + 1 x = x +1
 Mutable is explicit  Immutable is explicit.
For example, in C#:
let mutable x = x + 1 readonly x = 0
 In VB:
ReadOnly x As Integer

10.  In F#, it can be  In C# and VB, it must
standalone and simple be enclosed in a
class/module
let f x = x +2 class SimpleFunc
{
public static Int32
f(Int32 x)
 This is why it is called {
return x + 2;
“succinct” }
}
 This is “noisy”

11.  Already have at the first release
 It is also a strong type language
 Including built in support of Generic
 The type inference is not just local type
inference, but it then can be inferred based
on the use of the parameters!

12. Int32
let avalue =10 String
let aName = ‘Hello’
let savingInterest = 0.2 Double

13.  Type inference on functions when it’s used
let f x = sqr x + 1
Infers integer
.. return type from a whole
becomes int number…
let sqr x = x * x
Infers double
from a double
literal..
let f x = sqr x + 1.0

14. Less noise syntax but it’s still strongly typed

15.  Always begin with keyword “let”
let avalue = 10
let aName = ‘Hello’
let savingInterest = 0.2

16.  When there’s a need for explicit type system:
let x:int = 0
let piConstant:float = 3.141
let Name:String = ‘Eriawan’

17.  Always begin with let keyword
let f x = x + 1
let sqr y = y * y
let force x = x * gravity

18.  Parameters are written in a nice separation
“juxtaposition” syntax: a space
let sqr x = x * x
Function parameter
let add a b = a + b

19. The code in F#

20.  Multiple lines of code is using indentation:
let rec fib x =
if x < 2 then 1
else fib (x–1) + fib (x-2)

21.  Comment is the same with VB and C#
// some code
let x = x + 2
// XML doc comment:
/// <summary>A square function<summary>
/// <param name=‚x‛>the value</param>
let f x = x * x

22. The object oriented and imperative are here in F#

23. let f x = x *x
let g(x) = x* x
fun x -> x * x

24.  Mutable is easy, by adding keyword
“mutable”
 Next operation of assignment must use “<-”
to differentiate mutability.
let mutable y = 10
y <- y + 1

25.  Creating enum is also easy:
type Suit =
| Heart
| Diamond
| Spade
| Club

26. type Vector2D(dx:float, dy:float) =
// The pre-computed length of the vector
let length = sqrt(dx*dx + dy*dy)
/// The displacement along the X-axis
member v.DX = dx
/// The displacement along the Y-axis
member v.DY = dy
/// The length of the vector
member v.Length = length
// Re-scale the vector by a constant
member v.Scale(k) = Vector2D(k*dx, k*dy)

27.  It’s easy! Just create type but with abstract
keyword as modifier for all functions and
other members:
type IPeekPoke =
abstract Peek: unit -> int
abstract Poke: int -> unit

28. Unit of measure in F# only!

29. [<Measure>]
type kg
[<Measure>]
type m
[<Measure>]
type s
let gravityOnEarth = 9.81<m/s^2>
let heightOfMyOfficeWindow = 3.5<m>
let speedOfImpact =
sqrt (2.0 * gravityOnEarth + heightOfMyOfficeWindow)

30. Created by Eriawan Kusumawardhono, courtesy of RX Communica