F# - Variabili e tipi

Come è stato detto nell'introduzione, F# è un linguaggio giovanissimo, che come abbiamo visto si vanta di alcuni punti di forza rispetto ai linguaggi di programmazione già esistenti. Un'altro punto di forza di questo linguaggio è quello di non dover specificare il tipo della variabile, o meglio, del nome che vogliamo creare, perché è il compilatore a capre il tipo del nome a seconda dei valori che gli viene attribuito, tuttavia non permettendo l'esecuzione di operazioni tra tipi diversi, allo scopo di evitare errori di precisione. Questo comportamento del compilatore facilità notevolmente lo sviluppo dei programmi, specie per i programmatori novellini.

Le variabili (nomi)

In F# dichiarare un nuovo nome è molto semplice, perché il programmatore non deve preoccuparsi del tipo della  variabile che andrà a creare, visto che il compilatore si prende la responsabilità di fare questo lavoro, ma nonostante ciò dobbiamo dichiarare esplicitamente che vogliamo introdurre un nuovo nome. Per fare ciò viene usata la parola chiave let, che può essere tradotto in italiano come sia. Vediamo, allora, come vengono dichiarate le variabili:

let numero = 5;;
let decimale = 3.452;;
let booleano = true;;
let carattere = 'a';;
let stringa = "una sequenza di caratteri";;

Dal codice possiamo vedere che ogni riga inizia con la parola let, che dice sia numero uguale a 5 e sia decimale uguale a 3.452 e così via. Dopo questa definizione per il compilatore il nome numero e 5 sono la stessa cosa. Un'altra cosa che si può notare analizzando il codice è che ogni riga finisce con ;;. In questo modo viene indicata la fine dell'istruzione, tuttavia in F# non è strettamente necessario l'utilizzo di questo delimitatore. 

Il tipo booleano

Il tipo booleano è un tipo nativo di F#, ovvero è un tipo predefinito, che non deve essere costruito e può essere usato per la reazione di altri tipi, non nativi. Questo tipo rappresenta un insieme che contiene solamente 2 elementi: true e false. Viene usato molto per risolvere problemi di tipo logico, perché possono indicare se una condizione è vera oppure è falsa. Esistono tre operazioni che possono essere applicate ai booleani. Le operazioni booleane sono state elencate e descritte in basso:

Operazione: and

Simbolo: &&

Descrizione: questa operazione può essere fatta tra due valori booleani e come risultato si può ottenere true se entrambi i termini valgono true, oppure false in tutti gli altri casi.

Operazion: or

Simbolo: ||

Descrizione: l'operazione può essere fatta tra due valori booleani e restituisce come risultato false se entrambi i termini valgono false e true altrimenti.

Operazione: not

Simbolo: not

Descrizione: la seguente operazione viene eseguita su un termine di tipo booleano, restituendo come risultato la negazione del suo valore, ovvero se il termine vale true, allora il risultato varrà false e viceversa. 

Il tipo intero

Si può intuire dal titolo l'insieme che identifica questo tipo, cioè l'insieme dei numeri interi, ovvero in numeri che vanno teoricamente da -infinito a +infinito, ma in F# sono limitati con un intervallo più stretto, a causa della memoria finita del computer. Ad ogni modo sono i numeri con segno senza la parte decimale, quindi ...,-3,-2,-1,0,1,2,3,... Le operazioni che possono essere applicati a questi tipi sono:

somma:       +  -> esegue la somma tra numeri interi

sottrazione: -  -> esegue la sottrazione tra numeri interi 

prodotto:    *  -> esegue il prodotto tra numeri interi

quoziente:   /  -> restituisce la parte intera del quoziente
modulo:      %  -> restituisce il resto della divisione

Il tipo float

Questo tipo nativo rappresenta l'insieme dei numeri con virgola mobile, ovvero l'insieme dei numeri decimali, con l'eccezione di avere un insieme finito a causa del limite imposto dalla memoria. Le operazioni che si possono eseguire con i numeri con virgola mobile sono le stesse dei numeri interi, tranne il modulo, perché nei numeri decimali non c'è il resto della divisione. D'altronde per i numeri float c'è l'operatore per l'elevamento a potenza, che si indica con **. Però bisogna tener ben presente il fatto che non possono essere eseguite operazioni su termini che sono di tipi diversi. Ma a questo punto sorge un problema, perché se per esempio come risultato di una operazione abbiamo ottenuto un valore intero, però dopo dobbiamo eseguire un'operazione di cui un termine è intero e l'altro è float, come facciamo? La risposta è molto semplice: usiamo la funzione float(int), che converte un numero intero in uno di tipo float, oppure la funzione int(float), che permette di convertire un numero con virgola mobile in un numero intero. In questo modo il programmatore è costretto a decidere quale tipo devono avere i termini prima di eseguire un'operazione, evitando errori di precisione.


Il tipo carattere

Spesso nella programmazione viene incontrata la necessità di utilizzare il tipo carattere, ad esempio per confrontare due parole, che non è altro che una sequenza di caratteri. In F# ci sono 256 caratteri diversi, nominati anche caratteri ASCII. Essi comprendono le cifre, le lettere minuscole e maiuscole del alfabeto inglese e del alfabeto cirillico, inoltre contengono una serie di caratteri speciali, come lo spazio, il punto la virgola e cosi via. Ad ogni carattere corrisponde un codice, che non è altro che un numero intero da 0 a 255, che identifica quel particolare carattere. Visto che esiste la corrispondenza tra tipi interi e caratteri esiste anche la possibilità di convertire l'uno nel corrispondente dell'altro mediante le funzioni int(char) e char(int). L'unica operazione che può essere eseguita su di un carattere è l'operazione di somma, che permette di ottenere un'altro carattere, però appartenente ad un'altro insieme di caratteri, chiamato Unicode, che contiene tutti i caratteri del codice ASCII e gli alfabeti delle lingue del mondo.


Il tipo stringa

La stringa non è altro che una sequenza di caratteri. Esso è un tipo molto usato nella programmazione, perché nel momento in cui il programma deve comunicare qualche cosa all'utente in modo testuale, vengono usate le stringhe. Inoltre, F# possiede già un insieme di funzioni per permettere al programmatore di eseguire diverse operazioni sulle stringhe, senza doverle definire. L'operazione di base che può essere eseguito sulle stringhe è l'operazione di concatenazione, la cui funzione è di restituire una stringa formata dalla prima, seguita dalla seconda. Questa operazione può essere fatta mediante l'operatore +.


Gli operatori di confronto

Oltre agli operatori presentati in precedenza, che permettono di calcolare un nuovo valore dello stesso tipo esistono anche operatori di confronto, che dati due termini dello stesso tipo restituiscono un valore booleano. Questi operatori sono applicabili a tutti i tipi nativi e restituiscono sempre un valore true oppure false. Gli operatori di confronto sono 6:

uguale:            =    -> true se i termini sono uguali
non uguale:        <>   -> true se i termini non sono uguali
maggiore:          >    -> true se il termine a sinistra è maggiore di quello a destra
minore:            <    -> true se il termine a sinistra è minore di quello a destra
maggiore o uguale: >=   -> true se il termine a sinistra è maggiore o uguale a quello di destra
minore o uguale:   <=   -> true se il termine a sinistra è minore o uguale a quello di destra

Gli operatori di confronto vengono usati molto per eseguire delle scelte in base ai valori che abbiamo e scegliere di eseguire un'istruzione o un gruppo di istruzioni, oppure un'altra istruzione o gruppo di istruzioni.