Intro f# functional_programming

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

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

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

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

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

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

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

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

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

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

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

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

F#
F# -> Imperative Programming
F# -> Declarative Programming

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

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

Imperative programming
How to make a scrambled egg

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

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

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

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

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

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

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

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

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.

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;
}

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()

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

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

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

Object Oriented Programming (oop)

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

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

•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

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)

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

•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

•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

•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

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

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

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

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

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

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

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

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

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

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

Recursion
A recursive function is a
function that calls itself.

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

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

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

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

.NET types
Immutability
integers strings date time

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

• 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

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

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) ;

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

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

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();

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

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

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

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

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

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

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]

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

Intro f# functional_programming

More Related Content

What's hot

Similar to Intro f# functional_programming

Recently uploaded

Intro f# functional_programming