2010.11.19 iniziare con F#
Download as PPTX, PDF0 likes1,072 views
In Visual Studio 2010 竪 apparso un nuovo linguaggio: F#. Cos'竪, da dove nasce, come si scrive in F#. E perch竪 tanti lo stanno apprezzando pi湛 di C#...
![Trends [Source: PDC 2010 Anders Heijsberg]
Declarative
ConcurrentDynamic](https://image.slidesharecdn.com/2010-11-19iniziareconf-101119155730-phpapp02/85/2010-11-19-iniziare-con-F-6-320.jpg)
![C# and VB Evolution [Source: PDC 2010 Anders Heijsberg]
Managed Code
Generics
Language
Integrated Query
Dynamic + Language
Parity
C# + VB v.Next
Asynchronous
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](https://image.slidesharecdn.com/2010-11-19iniziareconf-101119155730-phpapp02/85/2010-11-19-iniziare-con-F-7-320.jpg)
![F# Evolution [Source: PDC 2010 Don Syme]
F# 1.0
Functional, Generics (Microsoft
Research)
Visual Studio 2008
Interactive, Objects
F# 2.0
Visual Studio 2010
Asynchronous, Parallel, Units of
Measure
Language foundations for strongly typed
access to external named data and
services
F# 3.0](https://image.slidesharecdn.com/2010-11-19iniziareconf-101119155730-phpapp02/85/2010-11-19-iniziare-con-F-15-320.jpg)
![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 = false
val c : float = 3.0
val 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|]](https://image.slidesharecdn.com/2010-11-19iniziareconf-101119155730-phpapp02/85/2010-11-19-iniziare-con-F-23-320.jpg)
![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 + 1
val incr : int -> int
> 10 |> incr
val 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](https://image.slidesharecdn.com/2010-11-19iniziareconf-101119155730-phpapp02/85/2010-11-19-iniziare-con-F-28-320.jpg)
![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 string
val Evaluate : Map<string,int> -> Expr -> int
val 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](https://image.slidesharecdn.com/2010-11-19iniziareconf-101119155730-phpapp02/85/2010-11-19-iniziare-con-F-36-320.jpg)
![NASA Mars Climate Orbiter, 1999 [Source: PDC 2010 Andrew Kennedy]](https://image.slidesharecdn.com/2010-11-19iniziareconf-101119155730-phpapp02/85/2010-11-19-iniziare-con-F-43-320.jpg)
![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](https://image.slidesharecdn.com/2010-11-19iniziareconf-101119155730-phpapp02/85/2010-11-19-iniziare-con-F-44-320.jpg)
More Related Content
Similar to 2010.11.19 iniziare con F# (20)
More from Marco Parenzan (20)
2010.11.19 iniziare con F#
- 1. In collaborazione con Iniziare con F# 損 Marco Parenzan
- 2. 19/11/2010 www.xedotnet.org 2 損 Non 竪 possibile insegnare a programmare in F# in unora 損 Si vuole rispondere a due domande: Perch竪 apprendere lapproccio funzionale? Vale la pena imparare F#? Obiettivi
- 3. 19/11/2010 www.xedotnet.org 3 損 Da Wikipedia http://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
- 4. 19/11/2010 www.xedotnet.org 4 損 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 Programmazione Imperativa
- 5. 19/11/2010 www.xedotnet.org 5 損 Da Wikipedia http://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
- 6. Trends [Source: PDC 2010 Anders Heijsberg] Declarative ConcurrentDynamic
- 7. C# and VB Evolution [Source: PDC 2010 Anders Heijsberg] Managed Code Generics Language Integrated Query Dynamic + Language Parity C# + VB v.Next Asynchronous 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
- 8. 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 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? Programmazione Funzionale e .NET
- 9. 19/11/2010 www.xedotnet.org 9 損 Da Wikipedia http://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 Programmazione Dichiarativa
- 10. 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
- 11. 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 dellexecution plan) Domain Specific Languages
- 12. 19/11/2010 www.xedotnet.org 12 損 Da Wikipedia http://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 Programmazione Funzionale
- 13. 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
- 14. 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#
- 15. F# Evolution [Source: PDC 2010 Don Syme] F# 1.0 Functional, Generics (Microsoft Research) Visual Studio 2008 Interactive, Objects F# 2.0 Visual Studio 2010 Asynchronous, Parallel, Units of Measure Language foundations for strongly typed access to external named data and services F# 3.0
- 16. 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 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/ Storia
- 17. 19/11/2010 www.xedotnet.org 17 損 ...fermo restando che F# 竪 un General Purpose Language Implementa anche lapproccio imperativo 損 Alcuni domini importanti Financial Modeling Data Mining Scientific Analisys Academic Applicazioni tipiche per F#
- 18. 損 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. 19/11/2010 www.xedotnet.org 19 損 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 Scripting Interattivo
- 20. 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 Lambiente interattivo
- 21. In collaborazione con Elementi di F# 19/11/2010 www.xedotnet.org 21
- 22. 19/11/2010 www.xedotnet.org 22 損 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
- 23. 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 = false val c : float = 3.0 val 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|]
- 24. 19/11/2010 www.xedotnet.org 24 損 Immutability Side-effects 損 Composition / Currying 損 Pattern Matching 損 Type inference 損 Recursion 損 Workflows Concetti Chiave
- 25. 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'
- 26. 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
- 27. 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 >
- 28. 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 + 1 val incr : int -> int > 10 |> incr val 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
- 29. 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/Cu rrying 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 -> int val incr : int -> int val it : int = 6
- 30. 19/11/2010 www.xedotnet.org 30 損 Reflector support gi F# (con un suo plug- in, non ancora completo) F# e Reflector
- 31. 19/11/2010 www.xedotnet.org 31 損 Cosa genera questo programma in F#? (che non significa niente...) let a = 4 let mutable b = a + 5 let f x = x + a let g = f b 損 Se si usa Reflector... F# e Immutability dal punto di vista di .NET
- 32. 19/11/2010 www.xedotnet.org 32 損 let restituisce sempre il pattern della definizione del valore Pattern
- 33. 19/11/2010 www.xedotnet.org 33 損 Anche chiamate 束option types損 損 Simile allereditariet 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
- 34. 19/11/2010 www.xedotnet.org 34 損 possibile adornare lalternativa 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"
- 35. 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_Sh arp_Programming/Pattern_Matchi ng_Basics Pattern Matching type Nome = string type Marca= string type 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"
- 36. 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 string val Evaluate : Map<string,int> -> Expr -> int val 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
- 37. 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 allinizio 損 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
- 38. 19/11/2010 www.xedotnet.org 38 損 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 > let rec factorial = function | 0 | 1 -> 1 | n -> n * factorial (n - 1) > factorial 10 val it : int = 3628800
- 39. 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 竪 lultima. 損 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
- 40. 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 b val max : 'a -> 'a -> 'a when 'a : comparison
- 41. 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 delloggetto 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損 lesecuzione del programma e agiscono in background Ad esempio per un logging... Computational Workflow
- 42. 19/11/2010 www.xedotnet.org 42 let bind value1 function1 = printfn "Bind %A." value1 function1 value1 let result value1 = printfn "Returning result: %A" value1 fun () -> value1 let 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) -> 'b val result : 'a -> (unit -> 'a) val delay : (unit -> 'a) -> unit -> 'a type 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) end val trace : TraceBuilder Starting traced execution. val trace1 : (unit -> unit -> int) Bind 7. Bind 5. Bind 12. Returning result: 12 val it : (unit -> int) = <fun:result@40>
- 43. NASA Mars Climate Orbiter, 1999 [Source: PDC 2010 Andrew Kennedy]
- 44. 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
- 45. Iniziare con F#
- 46. In collaborazione con Iniziare con F# Conclusioni 17/01/2008 www.xedotnet.org 46
- 47. Perch竪 apprendere lapproccio funzionale 損 Maggiore controllo del codice Minimizzare lo stato (mutable) Organizzare il codice Applicazione di Pattern Esalta limmutabilit dei dati
- 48. 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 lapproccio imperativo) Esalta limmutabilit 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
- 49. Libri & Blog 損 Beginning F# Robert Pickering - APress http://www.amazon.com/Beginning-F-Robert- Pickering/dp/1430223898/ref=sr_1_1?ie=UTF8&s=books&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 - OReilly 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_bxgy_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
- 50. 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