Spesso programmando ci si ritrova di fronte ad un fatto poco gradevole, quale la ripetizione di una sequenza di istruzione all'interno del programma, rendendo il codice poco elegante e comprensibile. Il modo più semplice di evitare che ciò accada è quello di creare delle funzioni, che contengano la sequenza delle istruzioni che si ripetono e raggrupparle sotto un'unico nome. F# è uno dei linguaggi in cui le funzioni vengono usate molto spesso, per cui è un argomento molto importante per chi ha deciso di programmare in questo linguaggio.
Esistono due modi per scrivere una funzione, che in fondo hanno più o meno la stessa identica struttura e differiscono soltanto per il modo in cui viene indicato che si sta per definire una funzione.
Vediamo il primo modo in cui può essere definita una funzione:
let somma = fun a b -> a + b;;
Con questa istruzione abbiamo creato un nuovo nome, che e una funzione e che ha due argomenti a e b. Una volta ottenuti i due argomenti la funzione restituisce la somma di (a+b). In questo modo quando scriviamo il nome somma il compilatore si aspetta che noi gli diamo altri due valori dello stesso tipo e che supportano l'operazione di somma. Di default il compilatore decide che a e b devono essere interi, per cui anche il risultato della funzione sarà un intero.
Il secondo modo per scrivere una funzione è il seguente:
let somma a b = a+b;;
Questo modo è più corto di quello mostrato in precedenza e di conseguenza viene anche maggiormente usato. Dal punto di vista di funzionalità non c'è alcuna differenza tra usare il primo modo, oppure il secondo, perché il concetto è sempre lo stesso, visto che nel primo caso diciamo esplicitamente che la somma corrisponde a una funzione che ha due argomenti, mentre nel secondo caso diciamo che dopo il nome somma ci aspettiamo altri due argomenti, che devono essere di tipo intero, perché nel corpo viene usato l'operatore di somma.
Ma vediamo ora cosa succede se scriviamo la seguente istruzione:
let incrementa = somma 1;;
Proviamo ad analizzare questa istruzione e vedere come si comporta il compilatore di F#. In poche parole viene introdotto il nome incrementa ed è uguale alla funzione somma, però abbiamo indicato che il primo parametro della funzione somma deve valere 1, ma il compilatore si aspetta che alla funzione somma vengano passati due argomenti, quindi il secondo verrà richiesto nel momento in cui chiameremo la funzione incrementa. In questo modo abbiamo ottenuto un'altra funzione, che non fa altro che incrementare di 1 un numero intero, passato come argomento.
E questo è un modo per definire nuove funzioni sulla base di una già definita, mantenendo costante uno dei suoi argomenti.
Per provare ad eseguire queste istruzioni basta aprire Visual Studio e aprire F# Interactive dal menu View->Other Windows->F# Interactive, oppure premere Ctrl+Alt+F. Verrà aperta una nuova finestra come questa:
Subito dopo il carattere > digitate l'istruzione che volete provare, terminando ogni istruzione con ;; e dando Invio. Così scrivendo una delle istruzioni per la creazione della funzione somma otterremo la seguente risposta dal compilatore:
val somma : int -> int -> int
che ci dice che è stato introdotto il nome somma, che prende un argomento di tipo intero, dopodiché ne prende un'altro argomento intero e restituisce un risultato sempre intero. Mentre se proviamo a scrivere l'istruzione relativa alla dichiarazione della funzione incrementa, otteniamo il seguente risultato:
val incrementa : (int -> int)
che ci indica che è stato introdotto il nome incrementa, uguale ad una funzione che prende un argomento di tipo intero e restituisce un valore intero, che guarda caso è proprio lo stampo della funzione incrementa, la quale prende in input un numero intero, lo incrementa di 1 e restituisce il risultato, che è sempre intero.
Nessun commento:
Posta un commento