1. Iniziare con F#
Marco Parenzan
Code Kata + New in .NET

2. Obiettivi
Non possibile imparare a programmare in F# in unora
Si vuole rispondere a una domanda:
Vale la pena imparare F#?
3. Programmazione Imperativa
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
4. Programmazione Imperativa
Nella programmazione imperativa, i concetti principali sono:
Lo stato (le variabili)
Lassegnazione (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 lesecuzione 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
5. Programmazione Orientata agli Oggetti
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
6. Trends [Source: PDC 2010 Anders Heijsberg]
7. C# and VB Evolution [Source: PDC 2010 Anders Heijsberg]
C# + VB v.Next
Asynchronous Programming
C# 4.0 + VB 10.0
Dynamic + Language Parity
C# 3.0 + VB 9.0
Language Integrated Query
C# 2.0 + VB 8.0
Generics
C# 1.0 + VB 7.0
Managed Code
8. Programmazione Funzionale e .NET
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 dallespressione, non dalla annotazione della variabile (che, in caso di ambiguit, si pu ancora usare)
Anonymous Types
Tipi definiti dalluso
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 dallinizio?
9. Programmazione Dichiarativa
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
lesatto complemento della programmazione dichiarativa
10. Programmazione Dichiarativa
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
11. Domain Specific Languages
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 dellexecution plan)
12. Programmazione Funzionale
Da Wikipediahttp://en.wikipedia.org/wiki/Functional_programming
...la computazione viene espressa in termini di funzioni ed evita luso 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 luso di stato per evitare insidiosi side-effects
Specie in concurrent programming
Enfatizza la forma dei dati, non limplementazione
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 lenfasi sullapproccio imperativo
Preferisce la ricorsione alliterazione
Innalza il livello di astrazione
13. Programmazione Funzionale
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
14. Cos F#
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)
15. F# Evolution [Source: PDC 2010 Don Syme]
Language foundations for strongly typed access to external named data and services
F# 3.0
F# 2.0
Visual Studio 2010
Asynchronous, Parallel, Units of Measure

Visual Studio 2008
Interactive, Objects
F# 1.0
Functional, Generics (Microsoft Research)
16. Storia
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 limplementazione 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 linclusione 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/
17. Applicazioni tipiche per F#
...fermo restando che F# un General Purpose Language
Implementa anche lapproccio imperativo
Alcuni domini importanti
Financial Modeling
Data Mining
Scientific Analisys
Academic
18. Caratteristiche di 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
19. Scripting Interattivo
Utilizzato in ambito amministrativo, matematico o Dynamic Languages
Cmd, PowerShell, Mathematica, (Iron)Python, (Iron)Ruby
Lutente 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
20. Lambiente interattivo
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
21. Shell interattiva
In una shell interattiva, i comandi vengono terminati con il doppio carattere ;;
it lultimo valore calcolato
It non it

F# Case Sensitive

Shell Interattiva
> 3+4
> 3+4;;
val it : int = 7
>it
val it : int = 7
>It
Script.fsx(3,1): error FS0039: The value or constructor 'It' is not defined
22. Elementi di F#
Iniziare con F#
23. Elementi di F#
Immutability
Functions as first class citizen
Composition / Currying
Pattern Matching
Type inference
Recursion
Workflows
24. Valori, non variabili
let permette di definire valori
= non assegnazione, ma uguaglianza, al fine della definizione
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
> leta=4;;val a : int = 4
> leta=5;;
Script.fsx(5,5): error FS0037: Duplicate definition of value 'a'
25. Valori mutabili, allora variabili
let mutable permette di definire valori mutabili
a una variabile
Motto:
se proprio serve...
> letmutable a=4;;val a : int = 4
> aletlista=[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 = false
val c : float = 3.0
val b : string = "due"
val a : int = 1
>typePerson={Name:string;Surname:string;};;type Person =
{Name: string;
Surname: string;}
>letp={Name="Mario";Surname="Rossi"};;val p : Person = {Name = "Mario";
Surname = "Rossi";}
>letvalues=[|10;20;30|]val values : int [] = [|10; 20; 30|]
28. Funzioni come valori
let permette di definire anche funzioni
Le funzioni associano ad valori in ingresso dei valori in uscita
Le funzioni sono valori
Le funzioni sono elementi first class del linguaggio:
Possono essere passate come parametri
Possono essere restituite come risultati
Possono essere memorizzate in variabili e srutture dati
> letfx=x+1;;val f : int -> int
> f5;;val it : int = 6
29. f x si pu anche scrivere come x |> f
In caso di due parametri, il parametro in pipelining quello pi a destra

y|>fx

30. ottimo quando si usano applicazioni in sequenzaPipelining operator
> letincrx=x+1val incr : int -> int
> 10|>incrval it : int = 11
>let f x y = x*2+y*3
val f : int -> int -> int
> 10 |> f 20
val 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 (+) 0
val values : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
val sumOfValues : int = 60
31. possibile valorizzare parzialmente i parametri di una funzionecomponendo un nuovo valore (partial function application)
Infatti notiamo che dopo una let viene sempre mostrato il formato del valore
Il meccanismo si chiama curryinghttp://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
>letfxy=x+y
>letincrx=fx1
>incr5
val f : int -> int -> intval incr : int -> intval it : int = 6
32. Reflector support gi F# (con un suo plug-in, non ancora completo)
F# e Reflector
33. Cosa genera questo programma in F#? (che non significa niente...)
leta=4letmutableb=a+5letfx=x+aletg=fb
Se si usa Reflector...
F# e Immutability dal punto di vista di .NET
34. let restituisce sempre il pattern della definizione del valore
Pattern
35. Anche chiamate option types
Simile allereditariet in OOP
functional inheritance
Anche il tipo diventa un valore
Simile a una Enum???
Discriminated Unions
>typeVeicolo=|Auto|Moto|Camion
;;
>letveicolo=Auto;;
val veicolo : Veicolo = Auto
36. possibile adornare lalternativa del tipo con degli attributi
Discriminated Union
>typeNome=string>typeMarca=string>typeColore=string>typeVeicolo=|AutoofColore|MotoofMarca|CamionofNome>letveicolo=Auto("rossa")val veicolo : Veicolo = Auto "rossa"
37. 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
typeNome=stringtypeMarca=stringtypeColore=stringtypeVeicolo=|AutoofColore|MotoofMarca|CamionofNomeletveicolo=Auto("rossa")matchveicolowith|Auto(colore)->printfn"Un'auto%s"colore|Moto(marca)->printfn"Unamoto%s"marca|_->printfn"unveicoloqualsiasi"
38. type Expr =
| Num of int
| Add of Expr * Expr
| Mul of Expr * Expr
| Var of string
letrec Evaluate (env:Map) exp =
match exp with
| Num n -> n
| Add (x,y) ->Evaluateenv x + Evaluateenv y
| Mul (x,y) ->Evaluateenv x * Evaluateenv 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 notevole di pattern matching
type Expr =
| Num of int
| Add of Expr * Expr
| Mul of Expr * Expr
| Var of string
val Evaluate : Map -> Expr -> int
val envA : Map = map [("a", 1); ("b", 2); ("c", 3)]
val expT1 : Expr = Add (Var "a",Mul (Num 2,Var "b"))
val resT1 : int = 5
39. Osservare cosa F# ha generato a fronte del codice scritto prima, descrive molto bene il concetto di declarative programming detto allinizio
Classi gi implementate (e spesso lo si faceva a mano)
Uso estensivo di:

IEquatable

40. IStructuralEquatable 41. IComparableSono 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
42. Una funziona viene dichiarata ricorsiva con la parola chiave rec
lequivalente funzionale delliterazione
Si ha spesso paura di usare le funzioni ricorsive per le prestazioni e il consumo dello stack
Ricorsione
> letrecfactorial=function|0|1->1|n->n*factorial(n-1)> factorial 10
val it : int = 3628800
43. Tail Recursion
Tail Call Optimization unacaratteristica del compilatoreF# (e in alcunicasianche del JITer .NET) chetrasformaunafunzionericorsiva in un ciclo while se la chiamataricorsiva lultima.
Questa ottimizzazionerisolveilproblemadello stack overflow
Bisognasempretentare di pensare ad unafunzioneaffinchsia tail optimizable

Perchilcompilatore (o ilJITer) non fannotutto da solo

Il TCO disponibilenel CLR 4.0

Quindianche in C#!