![Trends [Source: PDC 2010 – Anders Heijsberg]](https://image.slidesharecdn.com/2011-02-19-introducingfsharp-110221161131-phpapp02/85/2011-02-19-Introducing-F-6-320.jpg)
![C# and VB Evolution [Source: PDC 2010 – Anders Heijsberg]C# + VB v.NextAsynchronous ProgrammingC# 4.0 + VB 10.0Dynamic + Language ParityC# 3.0 + VB 9.0Language Integrated QueryC# 2.0 + VB 8.0GenericsC# 1.0 + VB 7.0Managed Code](https://image.slidesharecdn.com/2011-02-19-introducingfsharp-110221161131-phpapp02/85/2011-02-19-Introducing-F-7-320.jpg)
![F# Evolution [Source: PDC 2010 – Don Syme]Language foundations for strongly typed access to external named data and servicesF# 3.0F# 2.0Visual Studio 2010Asynchronous, Parallel, Units of Measure…Visual Studio 2008Interactive, ObjectsF# 1.0Functional, Generics (Microsoft Research)](https://image.slidesharecdn.com/2011-02-19-introducingfsharp-110221161131-phpapp02/85/2011-02-19-Introducing-F-15-320.jpg)
![Tipi di dati (immutabili)ListeTupleRecordArray>letlista=[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>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|]](https://image.slidesharecdn.com/2011-02-19-introducingfsharp-110221161131-phpapp02/85/2011-02-19-Introducing-F-27-320.jpg)
![È 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*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](https://image.slidesharecdn.com/2011-02-19-introducingfsharp-110221161131-phpapp02/85/2011-02-19-Introducing-F-30-320.jpg)
![type Expr = | Num of int | Add of Expr * Expr | Mul of Expr * Expr | Var of stringletrec Evaluate (env:Map<string,int>) 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 expT1Un esempio notevole di pattern matchingtype 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](https://image.slidesharecdn.com/2011-02-19-introducingfsharp-110221161131-phpapp02/85/2011-02-19-Introducing-F-38-320.jpg)
![NASA Mars Climate Orbiter, 1999[Source: PDC 2010 – Andrew Kennedy]](https://image.slidesharecdn.com/2011-02-19-introducingfsharp-110221161131-phpapp02/85/2011-02-19-Introducing-F-44-320.jpg)
![Ma è già un gran bel lavoroUnità di Misura>[<Measure>]typem;;[<Measure>]type m>[<Measure>]types;;[<Measure>]type s>letspace=10.0<m>;;val space : float<m> = 10.0>lettime=2.0<s>;;val time : float<s> = 2.0>letspeed=space/time;;val speed : float<m/s> = 5.0>letacc=space/time/time;;valacc : float<m/s ^ 2> = 2.5](https://image.slidesharecdn.com/2011-02-19-introducingfsharp-110221161131-phpapp02/85/2011-02-19-Introducing-F-47-320.jpg)
More Related Content
What's hot (20)
Similar to 2011.02.19 Introducing F# (20)
More from Marco Parenzan (20)
2011.02.19 Introducing F#
- 1. Iniziare con F#Marco ParenzanCode Kata + New in .NET
- 2. ObiettiviNon è possibile imparare a programmare in F# in un’oraSi vuole rispondere a una domanda:Vale la pena imparare F#?
- 3. Programmazione ImperativaDa 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 ImperativaNella programmazione imperativa, i concetti principali sono:Lo stato (le variabili)L’assegnazione (delle variabili)La sequenza delle operazioni (che cambiano lo stato delle variabili)ProsApproccio «naturale»«The hardware implementation of almost all computers is imperative »Ad un certo punto l’esecuzione va fattaQuando viene insegnato il concetto astratto di algoritmo, viene implicitamente richiesto di essere gli «esecutori»ConsLa gestione dello stato può essere complicata ed è spesso causa di erroriForse abusiamo delle variabiliSempre di più ora che si parla di parallel e distributed programming
- 5. Programmazione Orientata agli OggettiDa 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 interessaI concetti di OOP non ci danno niente in più nel confronto Imperativo vs. FunzionaleComunque 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.NextAsynchronous ProgrammingC# 4.0 + VB 10.0Dynamic + Language ParityC# 3.0 + VB 9.0Language Integrated QueryC# 2.0 + VB 8.0GenericsC# 1.0 + VB 7.0Managed Code
- 8. Programmazione Funzionale e .NETC# 3.0 (rilasciato con .NET Framework 3.5) implementa alcuni aspetti della programmazione funzionale (http://tomasp.net/articles/csharp3-concepts.aspx)Lambda ExpressionQuando le funzioni possono essere create a runtime, possono essere memorizzate in strutture dati, essere passate come parametri o ritornate come risultatiType Inference (Inferenza di tipo)Dedurre il tipo dall’espressione, non dalla annotazione della variabile (che, in caso di ambiguità, si può ancora usare)Anonymous TypesTipi definiti dall’usoMetaprogrammingÈ 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 librerieCosa succede se questi concetti entrano nella definizione del linguaggio sin dall’inizio?
- 9. Programmazione DichiarativaDa 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
- 10. Programmazione DichiarativaNella programmazione dichiarativa, i concetti principali sono:Le proprietà (esplicitare dei valori)I vincoli (esplicitare le regole cui devono sottostare valori non esplicitati) ProsMigliore astrazioneNon devo pensare alla gestione dello statoConsApproccio (forse) non «naturale» (?!?!?!)Lo usiamo, ma non sappiamo che lo stiamo facendo
- 11. Domain Specific LanguagesTra i linguaggi «dichiarativi» (cioè quelli che implementano un paradigma di programmazione «dichiarativo») troviamo i Domain Specific LanguagesNe usiamo ogni giornoHTMLDescriviamo cosa vogliamo vedereNon descriviamo COME faremo a rappresentarlo (non disegnamo linee, lettere, colori)SQLNella selezione (SELECT) descriviamo i vincoli sui dati che vogliamo ottenere,Non descriviamo COME estrarre i dati da un database (generazione dell’execution plan)
- 12. Programmazione FunzionaleDa 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 tipiImmutabilità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 programmingEnfatizza la forma dei dati, non l’implementazioneUso di dati polimorfici e di pattern matchingModellato sul lambda calcoloExpression OrientedPromuove la «lazy evaluation»Valutazione «pigra», il più tardi possibile (non «eager», «impaziente», «anticipato»)Riduce l’enfasi sull’approccio imperativoPreferisce la ricorsione all’iterazioneInnalza il livello di astrazione
- 13. Programmazione FunzionaleNella programmazione funzionale, i concetti principali sono:I valori e la loro immutabilità«Non ci sono variabili»Il lambda calcoloProsMigliore 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à...»ConsApproccio (forse) non «naturale» (?!?!?!)Lo usiamo, ma non sappiamo che lo stiamo facendo
- 14. Cos’è F#È un linguaggio funzionaleDeriva la sua sintassi dal linguaggio OcamlÈ il suo obiettivo principaleÈ un linguaggio imperativoSe non si può fare altrimentiÈ un linguaggio OOPPerchè deve essere interoperabile con .NETLinkshttp://msdn.microsoft.com/en-us/fsharp/default.aspxhttp://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 servicesF# 3.0F# 2.0Visual Studio 2010Asynchronous, Parallel, Units of Measure…Visual Studio 2008Interactive, ObjectsF# 1.0Functional, Generics (Microsoft Research)
- 16. StoriaIniziato nel 2002 in Microsoft Research ad opera principalmente di Don Symehttp://blogs.msdn.com/b/dsyme/http://en.wikipedia.org/wiki/Don_SymeA 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.aspxNel 2009 Somasegar annuncia l’inclusione di F# (2.0) in Visual Studio 2010http://blogs.msdn.com/b/somasegar/archive/2009/10/09/f-in-vs2010.aspxIl 4 novembre 2010 il source code di F# viene rilasciato come Open Sourcehttp://blogs.msdn.com/b/dsyme/archive/2010/11/04/announcing-the-f-compiler-library-source-code-drop.aspxSi può anche installare sotto Linux e Mac OSX con MONOhttp://fsxplat.codeplex.com/
- 17. Applicazioni tipiche per F#...fermo restando che F# è un General Purpose LanguageImplementa anche l’approccio imperativoAlcuni domini importantiFinancial ModelingData MiningScientific AnalisysAcademic
- 18. Caratteristiche di F#Shell per lo scripting interattivoOttimo per la prototipazioneConcisoType InferenceStrongly TypedAutomatic Generalization (sempre generico, se ha senso)Poca Type Annotation (attributi)First Class FunctionsCurrying, Lazy EvaluationsPattern matching
- 19. Scripting InterattivoUtilizzato in ambito amministrativo, matematico o Dynamic LanguagesCmd, PowerShell, Mathematica, (Iron)Python, (Iron)RubyL’utente inserisce i comandi uno alla volta, eseguendoliNormalmente, i linguaggi di scripting sono interpretatiF# è compilatoUno scripting è di successo quanto più semplice è scrivere il codiceIn F# è possibile avere la verifica (statica) dei tipi
- 20. L’ambiente interattivoDa riga di comando, digitare fsi.exeDa Visual Studio 2010, due opzioniCTRL+ALT+F per una console F# interactiveCreare un progetto F#, inserire un file .fsx ed eseguire «selezioni» di codice con ALT+INVIO
- 21. Shell interattivaIn una shell interattiva, i comandi vengono terminati con il doppio carattere ;;it è l’ultimo valore calcolatoIt non è itF# è 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
- 22. Elementi di F#Iniziare con F#
- 23. Elementi di F#ImmutabilityFunctions as “first class citizen”Composition / CurryingPattern MatchingType inferenceRecursionWorkflows
- 24. Valori, non variabililet permette di definire valori«=» non è assegnazione, ma uguaglianza, al fine della definizioneF# applica sempre la Type Inference (a : int)Simile a var in C#......ma il feeling è quello dello scripting...a è un valore, non una variabilea è immutabile> leta=4;;val a : int = 4> leta=5;;Script.fsx(5,5): error FS0037: Duplicate definition of value 'a'
- 25. Valori «mutabili», allora variabililet mutable permette di definire valori mutabilia è una variabileMotto:«se proprio serve...»> letmutable a=4;;val a : int = 4> a<-a + 1;;val a : int = 5
- 26. Perchè «immutabile»?Perchè la seguente istruzione (es. in C#)var a = 5;è fuorviante:«=» non significa «uguaglianza», ma assegnazione«==» (uguaglianza) dipende dal momento in cui vado a leggerloè vera solo in uno o più «momenti» non determinabiliPerchè ho bisogno della «mutabilità»?Perchè ho bisogno di mantenere un valore «transiente»?Es. Per un loopMa probabilmente il loop lo si può riscrivere con una funzione ricorsiva (vedi dopo)Approccio dichiarativo (se la funzione ricorsiva deve essere implementata con un loop oppure con una tail recursion, non è un problema del programmatore, che deve dichiarare la sua necessità)La definizione della variabile è un mezzo, non è il fineL’obiettivo è sempre lo stesso: la manutenibilitàSe so scrivere del codice «funzionale», permeante del concetto di «immutabilità», allora il riferimento al simbolo «a» sarà sempre «deterministico», avrà sempre quel valore.Questo è utile soprattutto quanto diversi task (asincronia, parallelismo) insistono sugli stessi valori (non variabiliÈ un presupposto matematico: ridiamo ad «=» il suo significato originaleÈ come un «code contract», una asserzione «state is evil»!Minimizziamo i side effects
- 27. Tipi di dati (immutabili)ListeTupleRecordArray>letlista=[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>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 valorilet permette di definire anche funzioniLe funzioni associano ad valori in ingresso dei valori in uscitaLe funzioni sono valoriLe funzioni sono elementi «first class» del linguaggio:Possono essere passate come parametriPossono essere restituite come risultatiPossono 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 |> fIn caso di due parametri, il parametro in pipelining è quello più a destray|>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*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
- 31. È 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 valoreIl 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>letfxy=x+y>letincrx=fx1>incr5val 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=fbSe si usa Reflector...F# e Immutability dal punto di vista di .NET
- 34. let restituisce sempre il pattern della definizione del valorePattern
- 35. Anche chiamate «option types»Simile all’ereditarietà in OOP«functional inheritance»Anche il tipo diventa un valoreSimile a una Enum???Discriminated Unions>typeVeicolo=|Auto|Moto|Camion;;>letveicolo=Auto;;val veicolo : Veicolo = Auto
- 36. È possibile adornare l’alternativa del tipo con degli attributiDiscriminated 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 tipoLa sequenza di tipo e di attributi è un «pattern» È uno dei meccanismi fondamentali di F#http://en.wikibooks.org/wiki/F_Sharp_Programming/Pattern_Matching_BasicsPattern MatchingtypeNome=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 stringletrec Evaluate (env:Map<string,int>) 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 expT1Un esempio notevole di pattern matchingtype 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
- 39. Osservare cosa F# ha generato a fronte del codice scritto prima, descrive molto bene il concetto di «declarative programming» detto all’inizioClassi già implementate (e spesso lo si faceva a mano)Uso estensivo di: IEquatable
- 41. IComparableSono i concetti trovati negli «anonymous types» in C# 3.0In C# lo si poteva fare, ma non siamo mai stati realmente abituati a farloDiscriminated Union, Pattern Matching e Reflector
- 42. Una funziona viene dichiarata ricorsiva con la parola chiave recÈ l’equivalente funzionale dell’iterazioneSi ha spesso paura di usare le funzioni ricorsive per le prestazioni e il «consumo» dello stackRicorsione> letrecfactorial=function|0|1->1|n->n*factorial(n-1)> factorial 10val it : int = 3628800
- 43. Tail RecursionTail Call Optimization è unacaratteristica del compilatoreF# (e in alcunicasianche del JITer .NET) chetrasformaunafunzionericorsiva in un ciclo while se la chiamataricorsiva è l’ultima.Questa ottimizzazionerisolveilproblemadello stack overflowBisognasempretentare di pensare ad unafunzioneaffinchèsia “tail optimizable”Perchèilcompilatore (o ilJITer) non fannotutto da soloIl TCO è disponibilenel CLR 4.0Quindianche in C#!Il codice che è applicabile a più tipi, viene automaticament generalizzatoÈ interessante notare come il codice generato dipenda fortemente da funzioni standard di libreriaAutomatic Generalization>letmaxab=ifa>bthenaelsebval max : 'a -> 'a -> 'a when 'a : comparison
- 44. NASA Mars Climate Orbiter, 1999[Source: PDC 2010 – Andrew Kennedy]
- 45. È un estensione al Type system extensionNon è invasivoÈ un meccanismo di annotazione basato sul processo di inferenzaNon ha costo a runtimeAttenzione!È una prima versione
- 46. Ci sono diverse cose da fare
- 47. Ma è già un gran bel lavoroUnità di Misura>[<Measure>]typem;;[<Measure>]type m>[<Measure>]types;;[<Measure>]type s>letspace=10.0<m>;;val space : float<m> = 10.0>lettime=2.0<s>;;val time : float<s> = 2.0>letspeed=space/time;;val speed : float<m/s> = 5.0>letacc=space/time/time;;valacc : float<m/s ^ 2> = 2.5
- 48. Computational WorkflowSono un concetto complicatoPermette di definire un DSLF# mette a disposizione delle parole chiave, integrate nel linguaggio (let, let!, use, use!, do, do!, for, while if, yield, yield!, return, return!)
- 49. «Mappa» queste parole chiave sui metodi di una classe «builder» (Let, Bind, Using, For, While, if, Combine, Yield, YieldFrom, Return, ReturnFrom)
- 50. Questi metodi possono essere implementati da un programma
- 51. 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_programmingI metodi (Let, Bind, ....) «osservano» l’esecuzione del programma e agiscono in background
- 52. Ad esempio per un logging...let bind value1 function1 = printfn "Bind %A." value1 function1 value1let result value1 = printfn "Returning result: %A" value1fun () -> value1let delay function1 =fun () -> function1()type TraceBuilder() =member x.Bind(value1, function1) = bind value1 function1member x.Return(value1) = result value1member x.Delay(function1) = printfn "Starting traced execution." delay function1let trace = new TraceBuilder()let trace1 = trace {let! x = 7let! y = 5let! sum = x + yreturn 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 : TraceBuilderStarting traced execution.val trace1 : (unit -> unit -> int)Bind 7.Bind 5.Bind 12.Returning result: 12val it : (unit -> int) = <fun:result@40>
- 54. Perchè apprendere l’approccio funzionaleMaggiore controllo del codiceMinimizzare lo stato (mutable)Esaltal’immutabilitàdeidatiOrganizzare il codiceApplicazione di Pattern
- 55. 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 .NETAlcune cose sono più sempliciApplicare i design patternsSintassi più succintaTask asincroni (workflow)Operazioni di trasformazioneComputazioniDomain Specific LanguagesAspect Oriented ProgrammingAlcune cose sono più complicateGUI programmingC’è già un sacco di codice F# in Internet da riusare
- 56. Considerazione sulle Prestazioni«Minime», sorry!Cons:Approccio dichiarativoCode GenerationÈ un codice efficace?Pros:Sintassi funzionale nativa, non syntactic sugar, no delegates (non sono tutte lambda expressions)Immutability: minimo numero di oggetti da collezionare da parte del GC
- 57. Libri & BlogBeginning F#Robert Pickering - APresshttp://www.amazon.com/Beginning-F-Robert-Pickering/dp/1430223898/ref=sr_1_1?ie=UTF8&s=books&qid=1290127128&sr=8-1-spellBlog: http://strangelights.com/blog/Expert F# 2.0Don Syme, Adam Granicz, Antonio Cisternino - APresshttp://www.amazon.com/Expert-2-0-Experts-Voice-Syme/dp/1430224312/ref=pd_sim_b_3Blog: http://blogs.msdn.com/b/dsyme/Programming F#Chris Smith - O’Reillyhttp://www.amazon.com/Programming-comprehensive-writing-complex-problems/dp/0596153643/ref=pd_bxgy_b_img_bBlog: http://blogs.msdn.com/b/chrsmith/Real World Functional Programming: With Examples in F# and C#Tomas Petricek – Manninghttp://www.amazon.com/Real-World-Functional-Programming-Examples/dp/1933988924/ref=pd_bxgy_b_img_bBlog: http://tomasp.net/Professional F#Ted Neward, Aaron Erickson, Talbott Crowll, Rick Minerich – Wroxhttp://www.amazon.com/Professional-F-2-0-Ted-Neward/dp/047052801X/ref=sr_1_1?ie=UTF8&s=books&qid=1290127457&sr=1-1Blog: http://blogs.tedneward.com/F Sharp Programminghttp://en.wikibooks.org/wiki/F_Sharp_Programming