Intro to F# by F# Italia

1. F#

2. F#
F# is a multiparadigm
programming language
built on .NET

3. F#
F# is a scalable, simple, succinct,
type-safe, type-inferred, practical,
efficiently executing functional-
first/imperative/object –oriented,
explorative
Open Source programming language
built on .NET

4. F# and Open Source
F# 4.0 compiler + library
Open Source
Apache 2.0 license

6. F# is case-sensitive
let number = 1
let Number = 2
let NUMBER = 3

7. Whitespace/Indentation/Scope
The F# compiler allows you to use whitespace to delimit code blocks.
let sum (x,y) =
x + y

8. Declarations
let pi = 3.14159
floating-point constant
let sum x y = x + y
a function in two arguments

9. Let
let [value,
function,
module,
namespace,
class] = expression

10. Types of Defined Entities
F# manages to find types automatically:
This is called type inference
For instance
let pi = 3.14159
Here, pi will automatically obtain the type
float since 3.14159 can only have type float

11. Explicit Type Declarations
let sum x y = x + y
F# will assume that “+” is plus on the
type int.
let sum x y = (x + y) : float
It forces the function to have type
float

12. .NET Interop
open System
let timeOfDay = DateTime.Now.ToString("hh:mm:ss")

13. The F# failwith Function
F# has an failwith function, which when executed prints a string and stops the
execution.
let rec sqr n:float =
if n<0. then
failwith("Cannot compute the square root of a negative number in R")
else
Math.Sqrt n

14. Interop from F#
Use #r to reference a DLL .
Open the namespace
#r "System.Core.dll"
open System.Collections.Generic
let a = HashSet<int>()

15. F#
F# -> Imperative Programming
F# -> Declarative Programming

16. C#
A C# program usually
consists of statements to
change the program’s
state.

17. Imperative language
An imperative language
describes how to finish a
task with exact steps.

18. Imperative programming
How to make a scrambled egg

19. Control Flow
Branching with if/else
Looping with while/do
Looping with for
Handling exceptions

20. Computation as sequence
X = 3
Y = 7
X = 2X+Y
X = 13
Y = 7
State Before Control Flow State After

21. Focus on how to
do something
Change of state
Procedural
programming is a
common sub-type
You can have
function calls or
sub-routines
Frequently
combined with
object-oriented
programming
Imperative language

22. Functional Language
A functional-first language,
like F#, is more declarative,
describing what the program
should accomplish.

23. Computation as calculation
2*3+7 6+7
13

24. Declarative
Calculate the sum of the first ten
integers.
let result = [ 1 .. 10 ]
|> List.sum

25. Declarative
Calculate the sum of the first ten
integers.
let result = [ 1 .. 10 ]
|> List.reduce
(fun x this -> x + this)

26. Sum of first ten integers (C#)
int sum = 0;
for (int i = 1; i <= 10; i++)
{
sum += i;
}

27. Sum
Variable

28. C#
C# doesn’t allow the definition of
a function outside a class. So the
best practice is to create a static
function (method) into a class.

29. Sum of n integers with C#
int sum = 0;
int[] numbers = { 2,5,6,3,7,38,555,66 };
foreach (var item in numbers)
{
sum += item;
}

30. Imperative programming
open System.IO
open System.Net
let url = @"http://mahamudra.it/"
// Download the webpage
let req = WebRequest.Create(url)
let resp = req.GetResponse()
let stream = resp.GetResponseStream()
let reader = new StreamReader(stream)
let html = reader.ReadToEnd()

31. Syntactic sugar with C#
var url = @"http://mahamudra.it/";
var html = string.Empty;
// Download the webpage
var req = WebRequest.Create(url);
var resp = req.GetResponse();
using (var stream = resp.GetResponseStream())
{
using (var reader = new StreamReader (stream))
{
html = reader.ReadToEnd();
}
}

32. DRY
Do Not Repeat YourSelf

33. Procedural Programming
open System.IO
open System.Net
let getHtml url
// Download the webpage
let req = WebRequest.Create(url)
let resp = req.GetResponse()
let stream = resp.GetResponseStream()
let reader = new StreamReader(stream)
let html = reader.ReadToEnd()
html

34. But…

35. Functional Ideas
First-class Functions /
Higher-order Functions
• Functions can be passes as
arguments to other
functions
Purity
• Function calls don’t change
state
Immutable Data
• Data structures cannot be
modified
Reference
transparency
• Function results depend
only on its arguments

36. FP vs OOP

37. Object Oriented Programming (oop)

38. Object Oriented Programming (oop)

39. Functional Programming
F(x) g(x) gof(x)

40. body
p0 p1 p…
Return
f(p1,p2,..)
What’s a function?
pn
Parameters/
values
Name f

41. •A function f from a set X (the domain) to a set Y
(the range) maps each element x in X to a unique
element y in Y.
•For example, f(x) = x2 maps the set of real
numbers into the set of positive real numbers.
•i.e., the domain X is the set of all real
numbers, the range is the set of positive reals.
Background: Functions

42. Functions model determinism
X
F(X)
F(X)X’
F(X’)
Per ogni x esiste uno
ed un solo y tale che
f(x) sia uguale a y
outputs depend predictably on inputs
X’’ F(X’’)
F: x->F(x)

43. Functional Programming
f(x) g(x)
gof(x)
g(f(x))x f(x)
x g(f(x))

44. •If f is a function from X to Y and g is a function from Y
to Z, then (g ◦ f ) (x) is a function from X to Z defined
as
(g ◦ f ) (x) = g(f (x)), for all x in X
Simply put, it means to replace the x in g(x) with f (x).
•Example:
•f (x) = x2 + x; g(x) = 2x + 1
•g ◦ f = 2*f(x) + 1 = 2(x2 + x ) + 1
Background: Functional Composition

45. •Example using mathematical functions:
•f (x) = x2 + x
•g(x) = 2x + 1
•g ◦ f = 2(x2 + x ) + 1
•Example using programming language function
•int f (x) {x2 + x};
•int g(x) {2x + 1};
•Now, g(f(x))is {2 * f(x) + 1};
Background: Functional Composition

46. •Pure functional programming is state-free: no
assignment statements.
•In other words, no variables, no way to permanently
change memory.
•Programs in pure functional languages consist of
composite functions; output of each function becomes
input to another.
•Today, most functional languages have some imperative
statements.
Almost functional language

47. First Class Function
First-class
functions
Pure
functions
Recursion
Immutable
variables
Nonstrict
evaluation
Statements
Pattern
matching

48. First Class Function
First-class functions can
either accept another
function as an argument or
return a
function.

49. Higher order functions
Higher order functions
are those that take other
functions as parameters or
return other functions as
their results.

50. First Class Function
let execute fn a =
fn(a)
val execute : f:('a -> 'b) -> a:'a -> 'b
let result = execute (fun x -> x*x) 5
val result : int = 25

51. Function types

52. Pure Functions
First-class
functions
Pure
functions
Recursion
Immutable
variables
Nonstrict
evaluation
Statements
Pattern
matching

53. Pure functions
Pure functions are functions
that have no side effects. Also
called referentially transparent
functions.

54. Side Effects
[<EntryPoint>]
let main argv =
let result = execute (fun x->x*x) 5
printfn "%d" result
0 // return an integer exit code

55. Void vs Unit
Unit Types
// define a function returns unit
let f x = () // f : 'a -> unit
// use ignore to throw away the keyboard
input and f2 returns unit
let f2 () = System.Console.ReadKey() |>
ignore

56. Side effects
f(5) + f(5) <> 2*f(5)
Side effects requires a more
complex model, and thus makes
it harder to understand the
software

57. Recursion
First-class
functions
Pure
functions
Recursion
Immutable
variables
Nonstrict
evaluation
Statements
Pattern
matching

58. Recursion
A recursive function is a
function that calls itself.

59. Example
The factorial function “!” on
natural numbers
0! = 1
n! = n · (n − 1)!, n > 0
Recursion corresponds to loops in ordinary programming

60. Factorial
let rec fac n =
if n = 0 then 1 else n*fac (n-1)

61. Immutable variables
First-class
functions
Pure
functions
Recursion
Immutable
variables
Nonstrict
evaluation
Statements
Pattern
matching

62. Immutability
The value assigned to a
variable or a structure can’t
be change once initialized.

63. Value not Variable

64. .NET types
Immutability
integers strings date time

65. F#
Immutability
Seq Set List

66. In imperative programming, variables are used to
denote memory locations:
x = x + 1
means “Update the program state by adding 1 to
the value stored in the memory cell named x and
storing the sum back in the memory cell.”
x is used two ways: as an r-value and an l-
value
Semantics of Variables

67. • Functional languages adopt the mathematical notion of
a variable as something that represents an expression.
•There is no association with a memory location or
modification of a variable’s value.
• So in functional languages a variable represents an
immutable value.
•Since variables don’t get updated, there’s no concept
of assignment and consequently no notion of program
state.
Semantics of Variables

68. Practical motivation
public class Utility
{
static int n = 1;
public static int fun (int x)
{
n += 1;
return n+x;
}
}

69. Fun isn’t fun
This means that fun returns different values for
different calls, even when called with the same
argument.
Much harder to reason mathematically about such
functions: for instance, these values are different:
var result = Utility.fun(10) + Utility.fun(10);
var result = 2* Utility.fun(10) ;

70. Nonstrict evaluation
First-class
functions
Pure
functions
Recursion
Immutable
variables
Nonstrict
evaluation
Statements
Pattern
matching

71. Nonstrict evaluation
Nonstrict means that we can
have a variable that does not
get assigned (computed) until
the first time it is referenced.

72. Lazy loading (C#)
int[] list = {1,34,5,666,76};
var even_terms = from p in list where (p % 2==0) select p;
var it_does_not_matter = 1;
var count_even_terms = even_terms.Count();
it_does_not_matter.Dump();
count_even_terms.Dump();

73. Statements
First-class
functions
Pure
functions
Recursion
Immutable
variables
Nonstrict
evaluation
Statements
Pattern
matching

74. Statements
Statements are evaluable
pieces of code that have a
return value.

75. Statements
First-class
functions
Pure
functions
Recursion
Immutable
variables
Nonstrict
evaluation
Statements
Pattern
matching

76. Match vs Case

77. Match
F# has a case construct
match expr with
| pattern1 -> expr1
| pattern2 -> expr2
....

78. Pattern Matching
Select case
let isOdd number =
match number % 2 with
| 0 -> false
| _ -> true
* “_” is a “wildcard”, matches anything

79. Factorial
let rec fac n =
match n with
| 0 -> 1
| _ -> n*fac (n-1)

80. Sum of first ten integers
let rec sum lst =
match lst with
| [] -> 0
| head::tail->head+ sum tail
let result = sum [1..10]

81. Sum of n integers
let rec sum lst =
match lst with
| [] -> 0
| head::tail->head+ sum tail
let result = sum [2;5;6;3;7;38;555;66]

82. Take
let rec take n lista =
match (n,lista) with
| (0,_) -> []
| (_,[]) -> failwith "taking too many"
| (_,x::ls) -> x :: take (n-1) ls