F# cenni teorici

Affrontiamo adesso un po' di cenni teorici su F# per focalizzare meglio le idee. Abbiamo visto nell’introduzione che utilizzeremo F# – interactive per eseguire il nostro codice, ma sappiate che questa tipologia di linguaggio va compilato prima di essere eseguito dal computer. Vederemo più avanti come compilare ed eseguire i nostri programmi tramite Visual Studio.

Poiché F# è un linguaggio che si basa essenzialmente sulle funzioni, per cominciare a capire i suoi concetti dobbiamo partire dalle operazioni matematiche, cosa che ci accompagnerà per quasi tutta la durata di questo “viaggio”.

Per coloro che non sanno cosa sia una funzione o ne hanno una vaga idea vi consiglio di leggevi la definizione su Wikipedia o di fare una ricerca su internet, non tratterò questo argomento qui perché diventerebbe troppo lungo e discorsivo.

Un po’ di teoria

Una funzione in F# si può scrivere in questo modo:

funzione_somma  (x, y)  ->  x + y

Se gli diamo in pasto 2 valori, per esempio 1 e 2, restituirà 3. Questo è il concetto di funzione all’interno di F# dove associamo al nome “funzione_somma” l’operazione di somma di 2 valori. Un’altra caratteristica che possiede questo linguaggio è la forte “tipicizzazione”, ossia non possiamo combinare valori di diversa natura all’interno di una stessa funzione. Vi riporto una tabella per riassumere i tipi più usati, ma ce ne sono anche di più specifici:

Esempio F# Tipo Descrizione
0, 1, 2, 3, ... int numeri naturali di tipo intero
0.0, 1.0, 2.0 ... float numeri a virgola mobile
a, b, c, .... char solo caratteri
"ciao" string stringa di testo
true / false bool stato booleano

In pratica non possiamo pensare di utilizzare in una funzione di tipo float il tipo int altrimenti F# Interactive o il compilatore ci darebbe un errore. Per capire meglio vi propongo un esempio:

let  funzione_somma  =  fun (x, y) -> x + y ;;
val funzione_somma : x:int * y:int -> int

Una volta copiato il codice scritto in bianco su F# Interactive e dato invio vi comparirà la scritta sotto. Per eseguire la funzione con dei valori dobbiamo richiamarla con il suo nome e specificare i valori da sommare:

funzione_somma (1, 2) ;;
val it : int = 3

La funzione_somma ha restituito 3 che è un tipo intero, non possiamo infatti dargli in pasto i valori (1, 2.3) perché ci restituirebbe un errore. Il valore dei tipi che possiamo assegnare alla funzione vengono descritti sotto (val funzione_somma : x:int * y:int -> int). In questo caso non abbiamo specificato il tipo di valori che vogliamo assegnare e F# per default assegna sempre il tipo int, ma possiamo benissimo specificare il valore float e da li in poi dovremmo sempre usare i numeri con la virgola mobile.

let funzione_somma = fun (x:float, y:float) -> x + y ;;
val funzione_somma : x:float * y:float -> float

Un'altro modo per scrivere una funzione o in questo caso la somma di 2 numeri è:

let funzione_somma (x, y) = x + y ;;
val funzione_somma : x:int * y:int -> int

Analizziamo parola per parola il codice scritto sopra cosi da imparare meglio il suo significato:

let Assegna o definisce il nome della funzione
funzione_somma nome assegnato alla funzione o al parametro
(x, y) nome e numero di valori che assegneremo alla funzione
x + y corpo della funzione

Per eseguire una operazione non dobbiamo per forza associarla ad una funzione ma possiamo benissimo utilizzarla come se fosse una calcolatrice, in questo modo:

5 + 4 ;;
 val it : int = 9

Ci sono 2 metodi per scrivere una somma o una operazione, la prima si chiama notazione infissa e la abbiamo appena descritta sopra, la seconda è la notazione prefissa che prevede il segno dell'operazione prima del corpo della funzione, si noti come in quest'ultima scrittura assomigli ad una funzione:

  •    notazione infissa        3 + 4
  •    notazione prefissa     (+)  3  4

 

Vediamo alcuni esempi:
 

(+) 5 4 ;;
 val it : int = 9

(+) 3 (5 + 4) ;;
 val it : int = 12

(+) 3.0 (5.0 + 4.0) ;;
 val it : float = 12.0

(-) ((+) 5.0 5.0) ((+) 3.0 (5.0 + 4.0)) ;;
 val it : float = -2.0