Programmazione funzionale: un primo approccio attraverso F#

F#FIRENZE – 25 FEBBRAIO 2016

Mario De Ghetto Visual Studio and Development TechnologiesBlog http://deghetto.wordpress.com Internet sites http://deghetto.bell1.net http://books.bell1.net E-mail [email protected]

Programmazione funzionale: un primo approccio attraverso

http://deghetto.wordpress.com/

http://deghetto.bell1.net/

http://books.bell1.net/

mailto:[email protected]

Prima di iniziare…

2

Alcuni esempi di codice di questa presentazione:http://bit.ly/firenze2016

Frammenti di codice di queste slide:File: Slide_Firenze_25-02-2016.fs

Tutorial (progetto disponibile online)File: FsharpIntroductionTutorial.fs

FsharpSamples101 (progetto disponibile online)Cartella: FsharpSamples101

Example of Math (progetto disponibile online)File: Example_of_Math.fs

Excel Financial func (progetto disponibile online)Cartella: ExcelFinancialFunc

http://bit.ly/firenze2016




Che cos’è la programmazione funzionale (PF) e che cos’è F#?

Programmazione funzionale in F# Alcuni utili elementi di linguaggio funzionale Scripting interattivo Interoperabilità tra F# e altri linguaggi .NET F# come linguaggio per ASP.NET Meta-programmazione in F#

Di cosa parliamo...

3

4

Perché la programmazione funzionale in Italia non decolla (ancora)?

Per capire davvero quanto più potente e uniforme il linguaggio sia davvero visitate http://fsharpforfunandprofit.com/fppatterns/Certe mostruosità di Java/C# semplicemente spariscono in nome di eleganza e uniformità.

La difficoltà più grossa del linguaggio è la sua relativa difficoltà: per arrivare ad un buon livello e raccogliere i frutti della sua potenza, serve purtroppo non poco investimento di formazione.Le Università sono i posti in cui si ha il massimo apprezzamento: in molti insegnano functional programming in giro per l’Italia e apprezzano talk su un linguaggio funzionale pragmatico.

http://l.facebook.com/l.php?u=http://fsharpforfunandprofit.com/fppatterns/&h=qAQHZEN5SAQHLgRmo_cF1Ro46MGGzmGiwl5doKoMcTn7YPg




Perché F#?

SKILL DI UNOSVILUPPATORE

.NET

C#

ASP.NET

LINQ

DATABASE SQL / NoSQL

VISUAL BASIC

XML

SICUREZZAOFFICE

WPF – WCF - WF

MOBILEAZURE(cloud

computing)

ENTITY FRAMEWORK

HTML CSS

ARCHITETTURA

INTEROPERABILITA’

DOCUMENTAZIONE

INTEGRAZIONEDI SISTEMI

LIBRERIE DI TERZE PARTI

TEST & DEBUG

DISTRIBUZIONE

.NET FRAMEWORK

5

CONOSCENZE DI ALTRE DISCIPLINE E

AMBITO APPLICATIVO

Che cos’è la PF e che cos’è F#?

Un po’ di storia…

6

1930 Alonzo Church elabora una teoria matematica denominata «calcolo lambda»: fornisce una notazione e valutazione di funzioni più semplice e pratica1950 Paradigma della programmazione dichiarativa/funzionale1950 Paradigma della programmazione imperativa/procedurale1970 Paradigma della programmazione orientata agli oggetti (OOP)

(specializzazione della programmazione imperativa)

Linguaggi che supportano la programmazione funzionale:LISP (con varianti Logo, Dylan, Clojure) – Scala – Erlang –

MathematicaClean – Miranda – Ruby – Python – Perl – TCL – Haskell – OCAML – ML

F#

Un po’ di storia…

7

2005 Don Syme inizia a sviluppare F# 1.0 in Microsoft Research2010 Appare F# 2.0 in VS 2010: programmazione asincrona e unità di misura2012 VS 2012 con F# 3.0: type providers2013 VS 2013 con F# 3.1: aggiornamenti con la F# community (open source)2015 VS 2015 con F# 4.0: ulteriori estensioni e miglioramenti

F# ora può veramente essere considerato

un linguaggio maturo e produttivo


8

Che cos’è la PF e che cos’è F#?«In informatica la programmazione funzionale è un paradigma di programmazione in cui il flusso di esecuzione del programma assume la forma di una serie di valutazioni di funzioni matematiche. Il punto di forza principale di questo paradigma è la mancanza di effetti collaterali (side-effect) delle funzioni, il che comporta una più facile verifica della correttezza e della mancanza di bug del programma e la possibilità di una maggiore ottimizzazione dello stesso. Un uso particolare del paradigma, per l'ottimizzazione dei programmi, è quello di trasformare gli stessi per utilizzarli nella programmazione parallela.

La programmazione funzionale pone maggior accento sulla definizione di funzioni, rispetto ai paradigmi procedurali e imperativi, che invece prediligono la specifica di una sequenza di comandi da eseguire. In questi ultimi, i valori vengono calcolati cambiando lo stato del programma attraverso delle assegnazioni; un programma funzionale, invece, è immutabile: i valori non vengono trovati cambiando lo stato del programma, ma costruendo nuovi stati a partire dai precedenti.»

9

Dove troviamo elementi di PFal di fuori dei linguaggi funzionali?


• SQL• .NET (VB e C#):

• LINQ• Lambda expressions• Async/Await (programmazione parallela)

10

SQL è funzionale?


Algebra relazionale:• Selezione• Proiezione• Ridenominazione• Unione• Differenza• Prodotto cartesiano

σF(R)

πY(R)

R1 - R2

R1 X R2

11

LINQ è funzionale?


C# Visual Basic

12

Le Lambda expressions sono funzionali?


Visual BasicC#

13

La programmazione parallela è funzionale?


• Multi-threading ecomunicazione tradiversi thread

• Crittografia /crittoanalisi(forza bruta)

• Algoritmi eottimizzazione

/// Scarica pagine in parallelo e stampa i risultatilet comparePages = async { let! results = [| "http://www.google.com" "http://www.bing.com" "http://www.yahoo.com" |] |> Array.map downloadPage |> Async.Parallel for title, length in results do Console.WriteLine("{0} (lung. {1})", title, length) }

// Avvia l’elaborazione nel thread correntedo comparePages |> Async.RunSynchronously

(N.B. va implementato il

codice di «downloadPage»

14

F# è un linguaggio multiparadigma:

- Programmazione imperativa:- procedurale- orientata agli oggetti

- Programmazione dichiarativa:- funzionale


15

Programmazione imperativa / procedurale

Es.: supporta cicli (loop), esecuzione condizionale ecc.

Concettualmente uguale a molti altri linguaggi (Visual Basic, C#, Java…)


16

Programmazione imperativa / orientata agli oggetti

Ampio uso di oggetti attraverso classi, metodi, attributi, proprietà ecc. … F# supporta pienamente .NET FrameworkSupporta l’interoperabilità con gli altri linguaggi .NET

Concettualmente uguale ad altri linguaggi .NET (Visual Basic, C#...)


17

Programmazione dichiarativa / funzionale

Si considera tutto come una funzione, anzi: TUTTO è una funzione!Uso della ricorsione (anche per i cicli)Le funzioni possono essere concatenate (piping)Deve essere sempre restituito un valore

Nel .NET Framework ha caratteristiche uniche


18


fonte: http://fsharpforfunandprofit.com/fppatterns/

http://fsharpforfunandprofit.com/fppatterns/



19

Interoperabilità e relazione con altri linguaggi .NET

È un linguaggio .NET completamente aperto:È possibile utilizzare qualsiasi libreria .NET da F#È possibile utilizzare le librerie F# da altri linguaggi .NET

Alcune caratteristiche di F# sono successivamente apparse negli altri linguaggi .NET (LINQ, Async, Generics…)

È possibile usarlo in parti di progetti di qualunque dimensione

(può essere una buona idea per alcuni tipi di attività)


20

Perché con F# è meglio?I programmi di oggi sono difficili da parallelizzare

L’uso di thread causa comportamenti non deterministiciLa modificabilità delle variabili causa “problemi collaterali”

Alcune idee sono difficili da esprimereLa programmazione dichiarativa è più facile da capire

In OOP si possono scrivere facilmente tipi riutilizzabili… ma scrivere funzioni/algoritmi riutilizzabili non è facile


21

Approccio funzionale:

Basato sulla ricorsivitàIl valore degli identificatori (non ”variabili”!) non cambia (valori immutabili)Usa l’inferenza dei tipi di dato (tipizzazione forte, implicita)Per utilizzare variabili bisogna dichiararlo esplicitamente (mutable)Le pure funzioni di tipo funzionale non hanno effetti collaterali:

Facili da testare e correggere (debug)Possono essere eseguite in parallelo

Approccio imperativo (procedurale o orientato agli oggetti):

L’operazione più importante e frequente è l’assegnazioneLa tipizzazione forte richiede l’indicazione del tipo di dato


22


// C#int a = 10

// F#let a = 10

// C#static int a(){ return 10;

}

Queste operazioni sembrano uguali, ma non lo sono:

Concettualmente, queste lo sono di più :

// F#let a = 10

23

F# è un linguaggio elegante e pulito (matematico)

Permette l’abbattimento del numero di errori (e dei bug), anche perché è un linguaggio poco «verboso» (meno codice c’è, meno errori ci sono e meno tempo serve per scrivere = meno €)


24

Che cos’è la PF e che cos’è F#?// C#using Systemnamespace ConsoleApplication1{class Program{static int a(){ return 10;}}

}

// F#open Systemlet a = 10Console.Writeline a

25

Non richiede la chiusura dei blocchi con ‘ ; ’, parentesi graffe o parole chiave (usa l’indentazione)

Nel pattern matching (simile a select case o switch ma più potente) non compila se non sono stati esplicitati tutti i rami (warning)

Se necessario possiamo rinunciare al rigore della programmazione funzionale e utilizzare le librerie .NET o altre (lo facciamo a nostro rischio e pericolo)

Nessun uso di null = bassissima possibilità di ottenere NullReferenceException


26

F# è ottimo per analisi su un grande numero di dati (numerici o testo) [big data…]

F# è ottimo per la programmazione parallela e asincrona

F# è ottimo per creare librerie di funzioni da affiancare ad altri linguaggi .NET

F# è ottimo per sviluppare programmi di qualunque genere

PUNTI DI FORZA


27

F# non ha un designer di UI quindi non è pratico per creare controlli e finestre (ma in qualche modo si può fare)

PUNTI DI DEBOLEZZA


In MicrosoftVerifica di driver (analisi di codice)

In Microsoft ResearchProve automaticheAnalisi di applicazioni multithreadEsperimenti nel team di sviluppo di giochi

Altri...

28

CHI LO USA NEL MONDO REALE?

Analisi di dati finanziari

Analisi di dati assicurativi

Analisi di dati pubblicitari

Data mining

Analisi di immagini digitali

29


AMBITI APPLICATIVIApplicazioni di ingegneria

Sviluppo di librerie di funzioni

Algoritmi e ottimizzazione

Sviluppo di giochi

ERLANG• Sviluppato e

pesantemente utilizzato da Ericsson per sviluppare sistemi in tempo reale a larga scala

LISP• AutoCAD• Editor Emacs

30


ESEMPI DI SUCCESSO

F#• Punteggi di gioco in

HALO 3 su Xbox(molto meno codice di C#)


Programmazione funzionale in F#

Alcuni utili elementi di linguaggio funzionale Scripting interattivo Interoperabilità tra F# e altri linguaggi .NET F# come linguaggio per ASP.NET Meta-programmazione in F#

Di cosa parliamo...

31

32

Solitamente non è necessario specificare esplicitamente il tipoI tipi sono inferiti dal contesto

// Valore numerico intero (int)let n = 42

// Valore di tipo stringa (string)let str = “Ciao mondo!"

// Funzione (int -> int)let add10(n) = n + 10


// Valore numerico intero a 64 bit (int64)let n = 42L

33

Programmazione funzionale in F#Una funzione è un tipocome gli altri:

- può essere passata come parametro o restituita da una funzione

- può essere creata ovunque nel codice

// Funzione (int -> int)let add10_a(n) = n + 10

// Funzione scritta con la sintassi più lunga (int -> int)let add10_b = fun n -> n + 10 // Funzione che accetta una funzione come parametro// Type: (int -> int -> int) -> intlet volani(func) = 1 + func 2 3

// Passaggio di funzione ‘anonima’ come parametrovolani(fun a b -> a + b)

34

Programmazione funzionale in F#Funzionale vs. imperativo

Approccioimperativo

In F# si possono combinare entrambi gli approcciL’approccio imperativo va bene per l’interoperabilità .NET

// Fattorialelet rec fac_f n = if (n = 0) then 1 else n * fac_f(n – 1)

// Fattorialelet fac_i n = let ret = ref 1 for i = 1 to n do ret := !ret * i done !ret

Approcciofunzionale

36


Tuple – combinazione di molti tipi differenti

// Tupla(int * string)let tup = (1, “Ciao a tutti!”)

// Funzione che lavora con una tuplalet func tup = let (n, s) = tup // ...

37


List – collezione di elementi dello stesso tipo

// Lista di numeri (int list)let list = [1; 2; 3; 4; 5]

// Rappresentazione interna di listatype int_list = | Nil | Cons of int * int_list

F# permette di lavorare anche con array .NET

38


Unione discriminata (1)

type Shape = | Rectangle of width : float * length : float | Circle of radius : float | Prism of width : float * float * height : float

let rect = Rectangle(length = 1.3, width = 10.0)let circ = Circle (1.0)let prism = Prism(5., 2.0, height = 3.0)

39


Unione discriminata (2)rappresentazione di strutture ad alberotype Tree =

| Tip | Node of int * Tree * Tree

let rec sumTree tree = match tree with | Tip -> 0 | Node(value, left, right) -> value + sumTree(left) + sumTree(right)

let myTree = Node(0, Node(1, Node(2, Tip, Tip), Node(3, Tip, Tip)), Node(4, Tip, Tip))let resultSumTree = sumTree myTree


Programmazione funzionale in F# Alcuni utili elementi di linguaggio funzionale

Scripting interattivo Interoperabilità tra F# e altri linguaggi .NET F# come linguaggio per ASP.NET Meta-programmazione in F#

Di cosa parliamo...

40

41

Alcuni utili elementi di linguaggio funzionaleFunzioni map (Select), filter

(Where), foldllet list = [0; 1; 2; 3; 4; 5; 6; 7; 8; 9]

// “Filter and map”// Risultato: result = [0; 9; 36; 81]let result = list |> List.filter ( fun n -> n%3 = 0) |> List.map ( fun n -> n*n )

// “Foldl”// Somma: sum = 126let sum = result |> List.fold_left ( fun acc v -> acc + v ) 0

Nota: L’operatore “|>” rappresenta un concatenamento (piping) – il risultato della prima operazione passata come parametro a quella successiva

42

Alcuni utili elementi di linguaggio funzionaleI parametri delle funzioni sono sostituiti con delegati

(l’implementazione di Iter e Map è simile)public delegate T Func<A0, T>(A0 arg0);public delegate T Func<A0, A1, T>(A0 arg0, A1 arg1);

public IEnumerable<T> Filter<T> (IEnumerable<T> e, Func<T, bool> filterFunc) { foreach(T el in e) if (filterFunc(el)) yield return el;}

public R FoldLeft<T, R>(IEnumerable<T> en, Func<R,T,R> accFunc, R init) { R ret = init; foreach(T el in en) ret = accFunc(ret, el); return ret;}

43

Alcuni utili elementi di linguaggio funzionale

Valutazione lenta (lazy)Rinvia il calcolo finché il risultato è realmente necessario

let a = Lazy.lazy_from_func ( fun () -> (* calc. *) 42 )let b = Lazy.lazy_from_func ( fun () -> (* calc. *) 84 )

let func (x:Lazy<int>) (y:Lazy<int>) = // calcolo... if (use_x_value) then Lazy.force x else Lazy.force y

// chiamata alla funzione ‘func’func a b



Di cosa parliamo...

44

45

Utilizzato in ambito amministrativo o in applicazioni matematiche

Cmd, Bash, PowerShell, Mathematica

L’utente inserisce comandi uno alla voltaI tipici linguaggi di scripting sono interpretatiF# è, ovviamente, compilato

Quali sono i requisiti per un linguaggio di scripting di successo?

Il codice deve essere semplice il più possibileIn F# si ottiene una verifica di base grazie al controllo dei tipi!

Scripting interattivo

46

Scripting interattivo/// Ottiene tutti i file in una cartella data

open System.IO

let rec allFilesUnder baseFolder = seq { yield! Directory.GetFiles(baseFolder) for subDir in Directory.GetDirectories(baseFolder) do yield! allFilesUnder subDir }

/// Active Pattern per determinate estensioni di filelet (|EndsWith|_|) extension (file : string) = if file.EndsWith(extension) then Some() else None

47


/// Esecuzione di un programma

open System.Diagnostics

let shellExecute program args = let startInfo = new ProcessStartInfo() startInfo.FileName <- program startInfo.Arguments <- args startInfo.UseShellExecute <- true

let proc = Process.Start(startInfo) proc.WaitForExit() ()



Di cosa parliamo...

49

50

In F# si può utilizzare qualsiasi oggetto.NETOperatore “<-” per assegnare valori alle proprietàOperatore “.” per chiamare metodi, accedere alle proprietà

// importazione namespace di .NETopen Systemopen System.Windows.Forms

// attributi .NET[<STAThread>] let main() = // Crea un nuovo Form e imposta i valori let form = new Form() form.Width <- 400 form.Height <- 300 form.Text <- "Form ciao mondo" Application.Run(form)

do main()

Interoperabilità tra F# e altri linguaggi .NET

ATTENZIONE !!

X = X + 151

Interoperabilità tra F# e altri linguaggi .NET

Notate come vengono assegnati dei valori alle proprietà:... form.Width <- 400 form.Height <- 300 form.Text <- “Form ciao mondo“...

Il simbolo utilizzato (“<-”) è una freccia che parte dal valore che viene assegnato e arriva alla proprietà che viene modificata.

E’ una notazione più chiara per un matematico, al contrario di questa:

52

Interoperabilità tra F# e altri linguaggi .NETLe funzioni sono esportate come metodi statici

Potete usare moduli per impostare il nome della classe

namespace MyFSharp.Export

module Math = begin

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

end

L’uso può essere difficile con alcuni tipi F#

53

Interoperabilità tra F# e altri linguaggi .NETF# ha standard OOP compatibile con altri linguaggi .NET

La visibilità è determinata dall’intestazione di file “FSI”

type Cliente = class val nome:String val mutable reddito:int new(n,a) = { nome = n; reddito = 10000 } override this.ToString() = String.Format("(Nome={0}, Reddito={2})", this.nome, this. reddito); member this.reddito with get() = this.reddito and set(v) = this.reddito <- v

member this.Nome with get() = this.nomeend


Programmazione funzionale in F# Alcuni utili elementi di linguaggio funzionale Scripting interattivo Interoperabilità tra F# e altri linguaggi .NET F# come linguaggio per ASP.NET

Meta-programmazione in F#

Di cosa parliamo...

54

55

F# come linguaggio per ASP.NET

Due possibilitàScrivere solo classi code-behind in F# (ASP.NET 1.1)Scrivere l’intero sito in F# (solo ASP.NET 2.0+)

Grazie all’estensibilità ASP.NETE’ possibile aggiungere il supporto a qualsiasi linguaggio Object Oriented

L’uso di CodeDomProviderPer generare codice da file ASPX/ASCXPer la compilazione di sorgenti generate

56

F# come linguaggio per ASP.NETSu AZURE, F# è ottimoper creare un WorkerRole



Di cosa parliamo...

57

58


La scrittura di programmi che generano o manipolanoaltri programmi (o essi stessi) come se fossero dati

Cosa significa ciò?E’ possibile accedere a parti del programma come datiLa struttura dati restituita rappresenta un programma F# valido

A cosa serve?Il codice può essere analizzatoIl codice può essere tradotto in un altro linguaggio

59

Il programma è rappresentato come una struttura ad albero

>> <@ 1 + 2 * 4 @>

> val it : expr = <@ > Microsoft.FSharp.MLLib.Pervasives.op_Addition (Int32 1)> Microsoft.FSharp.MLLib.Pervasives.op_Multiply (Int32 2) (Int32 4))> @>

op_Addition

op_Multiply(Int32 1)

(Int32 2) (Int32 4)


60

Meta-programmazione in F#Il codice scritto in F# può essere tradotto in un altro linguaggio

– Per esempio in SQL!– Le espressioni utilizzate per filtrare, proiezioni ecc. sono tradotte

// Northwind è generato per mezzo di tool del progetto LINQlet db = new nwind.Northwind ("Database=Northwind;Server=.;Integrated Security=SSPI")

// Query verso un database in F#let query = db.Customers |> where <@ fun c -> c.Country=“ITA" @> |> select <@ fun c -> (c.CompanyName, c.City, c.Country) @>

61

Riferimenti utili…

62

E-book gratuiti:http://www.syncfusion.com/resources/techportal/ebooks

http://www.syncfusion.com/resources/techportal/ebooks



Blog di Don Syme http://blogs.msdn.com/b/dsyme/

F# for fun and profit http://fsharpforfunandprofit.com/

Esempi su CodePlex http://fsharpsamples.codeplex.com/

50 slide su docslide.it http://docslide.it/technology/20101126-f-questo-sconosciuto.html

dotNET {podcast}http://www.dotnetpodcast.com/show/card/31

FsLab http://fslab.org/FsLab è una collezione di Librerie per la “data-science”

63

http://fsharpforfunandprofit.com/



http://docslide.it/technology/20101126-f-questo-sconosciuto.html



http://www.dotnetpodcast.com/show/card/31

http://www.dotnetpodcast.com/show/card/31

http://fslab.org/

http://fslab.org/

http://fslab.org/

64

FsLab

Channel9https://channel9.msdn.com/Search?term=Fsharp#ch9Search&lang-it=it&lang-en=en

JOHNNYCODER (presentazione in 10 parti)http://johnnycoder.com/blog/2009/05/01/functional-programming-part-10/

WikiBookshttps://en.wikibooks.org/wiki/F_Sharp_Programming

65

https://channel9.msdn.com/Search?term=Fsharp#ch9Search&lang-it=it&lang-en=en




https://en.wikibooks.org/wiki/F_Sharp_Programming

66

let str = "Grazie per l’attenzione!"

Programmazione funzionale: un primo approccio attraverso F#

Engineering

Transcript of Programmazione funzionale: un primo approccio attraverso F#