In collaborazione con

Iniziare con F#

» Marco Parenzan

19/11/2010 www.xedotnet.org 2

» Non è possibile insegnare a programmare in F# in un’ora

» Si vuole rispondere a due domande:• Perchè apprendere l’approccio funzionale?• Vale la pena imparare F#?

Obiettivi

19/11/2010 www.xedotnet.org 3

» Da Wikipediahttp://en.wikipedia.org/wiki/Imperative_programming

• «...la computazione viene espressa in termini di istruzioni che cambiano lo stato di un programma...»

» Nella programmazione imperativa, noi...• ...NON diciamo COSA vogliamo....• ...ma DICIAMO COME fare per ottenere quello che

vogliamo

Programmazione Imperativa

19/11/2010 www.xedotnet.org 4

» Nella programmazione imperativa, i concetti principali sono:• Lo stato (le variabili)• L’assegnazione (delle variabili)• La sequenza delle operazioni (che cambiano lo stato delle variabili)

» Pros• Approccio «naturale»

• «The hardware implementation of almost all computers is imperative »• Ad un certo punto l’esecuzione va fatta

• Quando viene insegnato il concetto astratto di algoritmo, viene implicitamente richiesto di essere gli «esecutori»

» Cons• La gestione dello stato può essere complicata ed è spesso causa di errori

• Forse abusiamo delle variabili• Sempre di più ora che si parla di parallel e distributed programming

Programmazione Imperativa

19/11/2010 www.xedotnet.org 5

» Da Wikipediahttp://en.wikipedia.org/wiki/Object-oriented_programming

• «...i dati vengono espressi in termini di strutture contenenti campi e metodi...»

» La programmazione orientata agli oggetti è implicitamente imperativa, in quanto è «stato» assieme ai metodi che permetto di «cambiare questo stato»

» Nel nostro ragionamento, quindi, non ci interessa• I concetti di OOP non ci danno niente in più nel confronto

Imperativo vs. Funzionale• Comunque parleremo di F# e OOP

Programmazione Orientata agli Oggetti

Trends [Source: PDC 2010 – Anders Heijsberg]

Declarative

ConcurrentDynamic

C# and VB Evolution [Source: PDC 2010 – Anders Heijsberg]

Managed Code

Generics

Language Integrated Query

Dynamic + Language Parity

C# + VB v.NextAsynchronous Programming

C# 1.0 + VB 7.0

C# 2.0 + VB 8.0

C# 3.0 + VB 9.0

C# 4.0 + VB 10.0

19/11/2010 www.xedotnet.org 8

» C# 3.0 (rilasciato con .NET Framework 3.5) implementa alcuni aspetti della programmazione funzionale (http://tomasp.net/articles/csharp3-concepts.aspx)

• Lambda Expression• Quando le funzioni possono essere create a runtime, possono essere memorizzate in strutture

dati, essere passate come parametri o ritornate come risultati

• Type Inference (Inferenza di tipo)• Dedurre il tipo dall’espressione, non dalla annotazione della variabile (che, in caso di

ambiguità, si può ancora usare)

• Anonymous Types• Tipi definiti dall’uso

• Metaprogramming• È lo scrivere programmi che scrivono o manipolano altri programmi (se scrivono o manipolano

se stessi, si dice «reflection»)• Le Expressions e gli Expression Trees sono i fondamenti del metaprogramming in .NET

3.5/sp1/4.0 (oltre alla Reflection...)

• In realtà sono: syntactic sugar e librerie• Cosa succede se questi concetti entrano nella definizione del linguaggio sin

dall’inizio?

Programmazione Funzionale e .NET

19/11/2010 www.xedotnet.org 9

» Da Wikipediahttp://en.wikipedia.org/wiki/Declarative_programming

• «...esprime la logica della computazione SENZA descrivere il flusso di controllo...»

» Nella programmazione dichiarativa, noi...• ...DICIAMO COSA vogliamo....• ...ma NON diciamo come fare per ottenere quello

che vogliamo» È l’esatto complemento della programmazione

dichiarativa

Programmazione Dichiarativa

19/11/2010 www.xedotnet.org 10

» Nella programmazione dichiarativa, i concetti principali sono:• Le proprietà (esplicitare dei valori)• I vincoli (esplicitare le regole cui devono sottostare valori

non esplicitati) » Pros• Migliore astrazione• Non devo pensare alla gestione dello stato

» Cons• Approccio (forse) non «naturale» (?!?!?!)

• Lo usiamo, ma non sappiamo che lo stiamo facendo

Programmazione Dichiarativa

19/11/2010 www.xedotnet.org 11

» Tra i linguaggi «dichiarativi» (cioè quelli che implementano un paradigma di programmazione «dichiarativo») troviamo i Domain Specific Languages

» Ne usiamo ogni giorno• HTML

• Descriviamo cosa vogliamo vedere• Non descriviamo COME faremo a rappresentarlo (non disegnamo

linee, lettere, colori)

• SQL• Nella selezione (SELECT) descriviamo i vincoli sui dati che

vogliamo ottenere,• Non descriviamo COME estrarre i dati da un database

(generazione dell’execution plan)

Domain Specific Languages

19/11/2010 www.xedotnet.org 12

» Da Wikipediahttp://en.wikipedia.org/wiki/Functional_programming • «...la computazione viene espressa in termini di funzioni ed evita l’uso di stato e dati mutabili...»

» Nella programmazione funzionale...• Le funzioni sono First-Class Types (High Order Functions)• Inferenza dei tipi• Immutabilità

• La scelta di essere «mutabile» (ed essere a rischio di «side effectes», è esplicita)• Evita l’uso di stato per evitare insidiosi «side-effects»

• Specie in concurrent programming• Enfatizza la forma dei dati, non l’implementazione

• Uso di dati polimorfici e di pattern matching• Modellato sul lambda calcolo

• Expression Oriented• Promuove la «lazy evaluation»

• Valutazione «pigra», il più tardi possibile (non «eager», «impaziente», «anticipato»)• Riduce l’enfasi sull’approccio imperativo

• Preferisce la ricorsione all’iterazione• Innalza il livello di astrazione

Programmazione Funzionale

19/11/2010 www.xedotnet.org 13

» Nella programmazione funzionale, i concetti principali sono:• I valori e la loro immutabilità

• Non ci sono variabili

• Il lambda calcolo» Pros• Migliore astrazione

• «... l'aumento delle prestazioni dei calcolatori ha tuttavia spostato l'attenzione della comunità informatica sullo sviluppo rapido del software, sulla sua correttezza e manutenibilità...»

» Cons• Approccio (forse) non «naturale» (?!?!?!)

• Lo usiamo, ma non sappiamo che lo stiamo facendo

Programmazione Funzionale

19/11/2010 www.xedotnet.org 14

» È un linguaggio funzionale• Deriva la sua sintassi dal linguaggio Ocaml• È il suo obiettivo principale

» È un linguaggio imperativo• Se non si può fare altrimenti

» È un linguaggio OOP• Perchè deve essere interoperabile con .NET

» Links• http://msdn.microsoft.com/en-us/fsharp/default.aspx• http://research.microsoft.com/en-us/um/cambridge/projects/fsharp / • http://en.wikipedia.org/wiki/F_Sharp_(programming_language )

Cos’è F#

F# Evolution [Source: PDC 2010 – Don Syme]

F# 1.0Functional, Generics (Microsoft Research)

…Visual Studio 2008Interactive, Objects

F# 2.0Visual Studio 2010Asynchronous, Parallel, Units of Measure

Language foundations for strongly typed access to external named data and services

F# 3.0

19/11/2010 www.xedotnet.org 16

» Iniziato nel 2002 in Microsoft Research ad opera principalmente di Don Syme• http://blogs.msdn.com/b/dsyme/• http://en.wikipedia.org/wiki/Don_Syme

» A Don si deve anche l’implementazione dei generics nel CLR 2.0 (usati poi pesantemente in F#)

» A inizio 2005 viene rilasciata la prima release pubblica di F#• http://blogs.msdn.com/b/dsyme/archive/2005/01/05/346857.aspx

» Nel 2009 Somasegar annuncia l’inclusione di F# (2.0) in Visual Studio 2010• http://blogs.msdn.com/b/somasegar/archive/2009/10/09/f-in-vs2010.aspx

» Il 4 novembre 2010 il source code di F# viene rilasciato come Open Source• http://blogs.msdn.com/b/dsyme/archive/2010/11/04/announcing-the-f-compiler-

library-source-code-drop.aspx

» Si può anche installare sotto Linux e Mac OSX con MONO• http://fsxplat.codeplex.com/

Storia

19/11/2010 www.xedotnet.org 17

» ...fermo restando che F# è un General Purpose Language• Implementa anche l’approccio imperativo

» Alcuni domini importanti• Financial Modeling• Data Mining• Scientific Analisys• Academic

Applicazioni tipiche per F#

» Shell per lo scripting interattivo• Ottimo per la prototipazione

» Conciso» Type Inference• Strongly Typed• Automatic Generalization (sempre generico, se ha senso)• Poca Type Annotation (attributi)

» First Class Functions• Currying, Lazy Evaluations

» Pattern matching

Caratteristiche di F#

19/11/2010 www.xedotnet.org 19

» Utilizzato in ambito amministrativo, matematico o Dynamic Languages• Cmd, PowerShell, Mathematica, (Iron)Python, (Iron)Ruby

» L’utente inserisce i comandi uno alla volta, eseguendoli• Normalmente, i linguaggi di scripting sono interpretati• F# è compilato

» Uno scripting è di successo quanto più semplice è scrivere il codice• In F# è possibile avere la verifica (statica) dei tipi

Scripting Interattivo

19/11/2010 www.xedotnet.org 20

» Da riga di comando, digitare fsi.exe

» Da Visual Studio 2010, due opzioni• CTRL+ALT+F per una console F#

interactive• Creare un progetto F#, inserire un

file .fsx ed eseguire «selezioni» di codice con ALT+INVIO

L’ambiente interattivo

In collaborazione con

Elementi di F#

19/11/2010 www.xedotnet.org 21

19/11/2010 www.xedotnet.org 22

» Shell interattiva» In una shell interattiva,

i comandi vengono terminati con il doppio carattere ;;

» it è l’ultimo valore calcolato

» It non è it• F# è Case Sensitive

Shell Interattiva

> 3+4> 3+4;;val it : int = 7

>itval it : int = 7>ItScript.fsx(3,1): error FS0039: The value or constructor 'It' is not defined

19/11/2010 www.xedotnet.org 23

» Liste

» Tuple

» Record

» Array

Tipi di dati

>let lista = [1..10];;val lista : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

>let tupla = (1, "due", 3.0, false);;val tupla : int * string * float * bool = (1, "due", 3.0, false)>let a,b,c,d = tupla;;val d : bool = falseval c : float = 3.0val b : string = "due"val a : int = 1

>type Person = { Name: string; Surname: string; };;type Person = {Name: string; Surname: string;}>let p = { Name="Mario"; Surname="Rossi" };;val p : Person = {Name = "Mario"; Surname = "Rossi";}

>let values = [|10; 20; 30|val values : int [] = [|10; 20; 30|]

19/11/2010 www.xedotnet.org 24

» Immutability• Side-effects

» Composition / Currying» Pattern Matching» Type inference» Recursion» Workflows

Concetti Chiave

19/11/2010 www.xedotnet.org 25

» let permette di definire valori• F# applica sempre la

Type Inference (a : int)

• Simile a var in C#...• ...ma il feeling è quello

dello scripting...» a è un valore, non una

variabile• a è immutabile

Valori, non variabili

> let a = 4;;val a : int = 4

> let a = 5;;Script.fsx(5,5): error FS0037: Duplicate definition of value 'a'

19/11/2010 www.xedotnet.org 26

» let mutable permette di definire valori mutabili

» a diventa sostanzialmente una variabile

» Motto:• «se proprio serve...»

Valori «mutabili», allora variabili

> let mutable a = 4;;val a : int = 4

> let a = a + 1;;val a : int = 5

19/11/2010 www.xedotnet.org 27

» let permette di definire funzioni• Le funzioni sono valori• Le funzioni associano

ad valori in ingresso dei valori in uscita

» Le funzioni sono valori

Funzioni come valori

> let f x = x + 1;;val f : int -> int

> f 5;;val it : int = 6

>

19/11/2010 www.xedotnet.org 28

» f x si può anche scrivere come x |> f

» In caso di due parametri, il parametro in pipelining è quello più a destra• y |> f x

• È ottimo quando si usano applicazioni in sequenza

Pipelining operator

> let incr x = x + 1val incr : int -> int> 10 |> incrval it : int = 11

> let f x y = x*2+y*3val f : int -> int -> int> 10 |> f 20val it : int = 70

>let values = [1..10]let sumOfValues = values |> List.filter (fun x -> (x % 2 = 0)) |> List.map (fun x -> x*2) |> List.fold (+) 0val values : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]val sumOfValues : int = 60

19/11/2010 www.xedotnet.org 29

» È possibile valorizzare parzialmente i parametri di una funzione componendo un nuovo valore (partial function application)

» Infatti notiamo che dopo una let viene sempre mostrato il formato del valore

» Il meccanismo si chiama «currying»http://en.wikipedia.org/wiki/Currying • È una tecnica che permette di

trasformare una funzione di n parametri in una «catena di funzioni di un solo parametro»

Composition

>let f x y = x + y>let incr x = f x 1>incr 5

val f : int -> int -> intval incr : int -> intval it : int = 6

19/11/2010 www.xedotnet.org 30

» Reflector supportà già F# (con un suo plug-in, non ancora completo)

F# e Reflector

19/11/2010 www.xedotnet.org 31

» Cosa genera questo programma in F#? (che non significa niente...)let a = 4let mutable b = a + 5let f x = x + alet g = f b

» Se si usa Reflector...

F# e Immutability dal punto di vista di .NET

19/11/2010 www.xedotnet.org 32

» let restituisce sempre il pattern della definizione del valore

Pattern

19/11/2010 www.xedotnet.org 33

» Anche chiamate «option types»

» Simile all’ereditarietà in OOP• «functional

inheritance»» Anche il tipo diventa

un valore• Simile a una Enum???

Discriminated Unions

>type Veicolo = | Auto| Moto| Camion;;

>let veicolo = Auto;;val veicolo : Veicolo = Auto

19/11/2010 www.xedotnet.org 34

» È possibile adornare l’alternativa del tipo con degli attributi

Discriminated Union

>type Nome = string>type Marca= string>type Colore = string

>type Veicolo = | Auto of Colore| Moto of Marca| Camion of Nome

>let veicolo = Auto("rossa")val veicolo : Veicolo = Auto "rossa"

19/11/2010 www.xedotnet.org 35

» La «sequenza» di informazioni di tipo e di attributi può essere usata per «discriminare» il tipo

» La sequenza di tipo e di attributi è un «pattern»

» È uno dei meccanismi fondamentali di F#• http://

en.wikibooks.org/wiki/F_Sharp_Programming/Pattern_Matching_Basics

Pattern Matching

type Nome = stringtype Marca= stringtype Colore = string

type Veicolo = | Auto of Colore| Moto of Marca| Camion of Nome

let veicolo = Auto("rossa")

match veicolo with| Auto(colore) -> printfn "Un' auto %s" colore| Moto(marca) -> printfn "Una moto %s" marca| _ -> printfn "un veicolo qualsiasi"

19/11/2010 www.xedotnet.org 36

type Expr = | Num of int | Add of Expr * Expr | Mul of Expr * Expr | Var of string let rec Evaluate (env:Map<string,int>) exp = match exp with | Num n -> n | Add (x,y) -> Evaluate env x + Evaluate env y | Mul (x,y) -> Evaluate env x * Evaluate env y | Var id -> env.[id] let envA = Map.ofList [ "a",1 ; "b",2 ; "c",3 ] let expT1 = Add(Var "a",Mul(Num 2,Var "b"))let resT1 = Evaluate envA expT1

Un esempio evoluto di pattern matching

type Expr = | Num of int | Add of Expr * Expr | Mul of Expr * Expr | Var of stringval Evaluate : Map<string,int> -> Expr -> intval envA : Map<string,int> = map [("a", 1); ("b", 2); ("c", 3)]val expT1 : Expr = Add (Var "a",Mul (Num 2,Var "b"))val resT1 : int = 5

19/11/2010 www.xedotnet.org 37

» Osservare cosa F# ha generato a fronte del codice scritto prima, descrive molto bene il concetto di «declarative programming» detto all’inizio

» Classi già implementate (e spesso lo si faceva a mano)

» Uso estensivo di: • IEquatable• IStructuralEquatable• IComparable

» Sono i concetti trovati negli «anonymous types» in C# 3.0

» In C# lo si poteva fare, ma non siamo mai stati realmente abituati a farlo

Discriminated Union, Pattern Matching e Reflector

19/11/2010 www.xedotnet.org 38

» Una funziona viene dichiarata ricorsiva con la parola chiave rec

» È l’equivalente funzionale dell’iterazione

» Si ha spesso paura di usare le funzioni ricorsive per le prestazioni e il «consumo» dello stack

Ricorsione

> let rec factorial = function    | 0 | 1 -> 1    | n -> n * factorial (n - 1)> factorial 10val it : int = 3628800

19/11/2010 www.xedotnet.org 39

» Tail Call Optimization è una caratteristica del compilatore F# (e in alcuni casi anche del JITer .NET) che trasforma una funzione ricorsiva in un ciclo while se la chiamata ricorsiva è l’ultima.

» Questa ottimizzazione risolve il problema dello stack overflow

» Bisogna sempre tentare di pensare ad una funzione affinchè sia “tail optimizable”• Perchè il compilatore (o il JITer) non fanno tutto da solo

» Il TCO è disponibile nel CLR 4.0• Quindi anche in C#!

Tail Recursion

19/11/2010 www.xedotnet.org 40

» Il codice che è applicabile a più tipi, viene automaticament generalizzato

» È interessante notare come il codice generato dipenda fortemente da funzioni standard di libreria

Automatic Generalization

>let max a b = if a>b then a else bval max : 'a -> 'a -> 'a when 'a : comparison

19/11/2010 www.xedotnet.org 41

» Sono un concetto complicato» Permette di definire un DSL

• F# mette a disposizione delle parole chiave, integrate nel linguaggio (let, let!, use, use!, do, do!, for, while if, yield, yield!, return, return!)

• «Mappa» queste parole chiave sui metodi di una classe «builder» (Let, Bind, Using, For, While, if, Combine, Yield, YieldFrom, Return, ReturnFrom)

• Questi metodi possono essere implementati da un programma• Quindi un «workflow» scritto con quelle parole chiave viene eseguito come

sequenza di metodi dell’oggetto builder, di cui noi abbiamo pienamente il controllo

» È un approccio AOP (Aspect Oriented Programming)http://en.wikipedia.org/wiki/Aspect-oriented_programming • I metodi (Let, Bind, ....) «osservano» l’esecuzione del programma e agiscono

in background• Ad esempio per un logging...

Computational Workflow

19/11/2010 www.xedotnet.org 42

let bind value1 function1 = printfn "Bind %A." value1 function1 value1let result value1 = printfn "Returning result: %A" value1 fun () -> value1let delay function1 = fun () -> function1()type TraceBuilder() = member x.Bind(value1, function1) = bind value1 function1 member x.Return(value1) = result value1 member x.Delay(function1) = printfn "Starting traced execution." delay function1

let trace = new TraceBuilder()let trace1 = trace { let! x = 7 let! y = 5 let! sum = x + y return sum }

trace1()

Tracing Workflow

>val bind : 'a -> ('a -> 'b) -> 'bval result : 'a -> (unit -> 'a)val delay : (unit -> 'a) -> unit -> 'atype TraceBuilder = class new : unit -> TraceBuilder member Bind : value1:'c * function1:('c -> 'd) -> 'd member Delay : function1:(unit -> 'a) -> (unit -> 'a) member Return : value1:'b -> (unit -> 'b) endval trace : TraceBuilder

Starting traced execution.val trace1 : (unit -> unit -> int)

Bind 7.Bind 5.Bind 12.Returning result: 12val it : (unit -> int) = <fun:result@40>

NASA Mars Climate Orbiter, 1999 [Source: PDC 2010 – Andrew Kennedy]

19/11/2010 www.xedotnet.org 44

» È un estensione al Type system extension

» Non è invasivo• È un meccanismo di

annotazione basato sul processo di inferenza

» Non ha costo a runtime» Attenzione!• È una prima versione• Ci sono diverse cose da

fare• Ma è già un gran bel lavoro

Unità di Misura

>[<Measure>]type m;;[<Measure>]type m

>[<Measure>]type s;;[<Measure>]type s

>let space = 10.0<m>;;val space : float<m> = 10.0

>let time = 2.0<s>;;val time : float<s> = 2.0

>let speed = space/time;;val speed : float<m/s> = 5.0

>let acc = space/time/time;;val acc : float<m/s ^ 2> = 2.5

Iniziare con F#

ESEMPI, PROGRAMMAZIONE

IMPERATIVA E INTEROPERABILITÀ

CON .NET

In collaborazione con

Iniziare con F#Conclusioni

17/01/2008 www.xedotnet.org 46

Perchè apprendere l’approccio funzionale

» Maggiore controllo del codice• Minimizzare lo stato (mutable)• Organizzare il codice• Applicazione di Pattern• Esalta l’immutabilità dei dati

Vale la pena imparare F#?

» Tutto ciò che si può fare in C# lo si può fare in F# (almeno, al momento, mi pare…)• È multiparadigma (supporta l’approccio imperativo)• Esalta l’immutabilità dei dati e la valutazione di espressioni (sembra tutto LINQ!)• È interoperabile con .NET

» Alcune cose sono più semplici• Applicare i design patterns• Sintassi più succinta• Task asincroni (workflow)• Operazioni di trasformazione• Computazioni• Domain Specific Languages• Aspect Oriented Programming

» Alcune cose sono più complicate• GUI programming

» C’è già un sacco di codice F# in Internet da riusare

Libri & Blog

» Beginning F#• Robert Pickering - APress• http://www.amazon.com/Beginning-F-Robert-Pickering/dp/1430223898/ref=sr_1_1?ie=UTF8&s=bo

oks&qid=1290127128&sr=8-1-spell• Blog: http://strangelights.com/blog/

» Expert F# 2.0• Don Syme, Adam Granicz, Antonio Cisternino - APress• http://www.amazon.com/Expert-2-0-Experts-Voice-Syme/dp/1430224312/ref=pd_sim_b_3• Blog: http://blogs.msdn.com/b/dsyme/

» Programming F#• Chris Smith - O’Reilly• http://www.amazon.com/Programming-comprehensive-writing-complex-problems/dp/0596153643

/ref=pd_bxgy_b_img_b• Blog: http://blogs.msdn.com/b/chrsmith/

» Real World Functional Programming: With Examples in F# and C#• Tomas Petricek – Manning• http://www.amazon.com/Real-World-Functional-Programming-Examples/dp/1933988924/ref=pd_b

xgy_b_img_b

• Blog: http://tomasp.net/ » Professional F#

• Ted Neward, Aaron Erickson, Talbott Crowll, Rick Minerich – Wrox• http://

www.amazon.com/Professional-F-2-0-Ted-Neward/dp/047052801X/ref=sr_1_1?ie=UTF8&s=books&qid=1290127457&sr=1-1

• Blog: http://blogs.tedneward.com/ 19/11/2010 www.xedotnet.org 49

blog:

email:

web:

twitter:

slideshare:

Link

21 maggio 2010 www.xedotnet.org 50

»Marco Parenzan

http://blog.codeisvalue.com/

marco.parenzan@libero.it

http://www.codeisvalue.com/

marco_parenzan

http://www.slideshare.com/marco.parenzan