Haskell - Modelli di dati di base

Haskell è un linguaggio di programmazione puramente funzionale, quindi è molto più interattivo e intelligente di altri linguaggi di programmazione. In questo capitolo, impareremo i modelli di dati di base di Haskell che sono effettivamente predefiniti o in qualche modo decodificati in modo intelligente nella memoria del computer.

Durante questo tutorial, utilizzeremo la piattaforma online Haskell disponibile sul nostro sito Web (https://www.tutorialspoint.com/codingground.htm).

Numeri

Haskell è abbastanza intelligente da decodificare un numero come numero. Pertanto, non è necessario menzionare il suo tipo esternamente come facciamo di solito nel caso di altri linguaggi di programmazione. Come per esempio, vai al prompt dei comandi di preludio, esegui semplicemente "2 + 2" e premi invio.

sh-4.3$ ghci 
GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help 
Loading package ghc-prim ... linking ... done. 
Loading package integer-gmp ... linking ... done. 
Loading package base ... linking ... done. 
Prelude> 2+2

Riceverai il seguente output come risultato.

4

Nel codice precedente, abbiamo appena passato due numeri come argomenti al compilatore GHCI senza predefinirne il tipo, ma il compilatore potrebbe facilmente decodificare queste due voci come numeri.

Ora, proviamo un calcolo matematico un po 'più complesso e vediamo se il nostro compilatore intelligente ci fornisce l'output corretto o meno. Prova con "15+ (5 * 5) -40"

Prelude> 15+(5*5)-40

L'espressione sopra restituisce "0" in base all'output previsto.

0

Personaggi

Come i numeri, Haskell può identificare in modo intelligente un carattere dato come input per esso. Vai al prompt dei comandi Haskell e digita qualsiasi carattere con virgolette doppie o singole.

Forniamo la seguente riga come input e controlliamo il suo output.

Prelude> :t "a"

Produrrà il seguente output:

"a" :: [Char]

Ricorda che usi (:t) fornendo l'input. Nell'esempio sopra,(:t)consiste nell'includere il tipo specifico relativo agli input. Impareremo di più su questo tipo nei prossimi capitoli.

Dai un'occhiata al seguente esempio in cui stiamo passando un input non valido come carattere che a sua volta porta a un errore.

Prelude> :t a 
<interactive>:1:1: Not in scope: 'a'  

Prelude> a 
<interactive>:4:1: Not in scope: 'a'

Con il messaggio di errore "<interactive>: 4: 1: Not in scope:` a '"il compilatore Haskell ci avverte che non è in grado di riconoscere il tuo input. Haskell è un tipo di linguaggio in cui tutto è rappresentato utilizzando un numero.

Haskell segue lo stile di codifica ASCII convenzionale. Diamo un'occhiata al seguente esempio per capirne di più:

Prelude> '\97' 
'a'  
Prelude> '\67' 
'C'

Guarda come il tuo input viene decodificato in formato ASCII.

Corda

UN stringnon è altro che una raccolta di personaggi. Non esiste una sintassi specifica per l'utilizzo di stringhe, ma Haskell segue lo stile convenzionale di rappresentare una stringa con virgolette doppie.

Dai un'occhiata al seguente esempio in cui stiamo passando la stringa "Tutorialspoint.com".

Prelude> :t "tutorialspoint.com"

Produrrà il seguente output sullo schermo:

"tutorialspoint.com" :: [Char]

Guarda come l'intera stringa è stata decodificata solo come array di Char. Passiamo all'altro tipo di dati e alla sua sintassi. Una volta che avremo iniziato la nostra pratica effettiva, saremo abituati a tutti i tipi di dati e al loro utilizzo.

Booleano

Anche il tipo di dati booleano è molto semplice come gli altri tipi di dati. Guarda il seguente esempio in cui useremo diverse operazioni booleane utilizzando alcuni input booleani come "True" o "False".

Prelude> True && True 
True  
Prelude> True && False 
False   
Prelude> True || True 
True  
Prelude> True || False 
True

Nell'esempio precedente, non è necessario menzionare che "True" e "False" sono i valori booleani. Haskell stesso può decodificarlo e fare le rispettive operazioni. Modifichiamo i nostri input con "true" o "false".

Prelude> true

Produrrà il seguente output:

<interactive>:9:1: Not in scope: 'true'

Nell'esempio precedente, Haskell non poteva distinguere tra "true" e un valore numerico, quindi il nostro input "true" non è un numero. Quindi, il compilatore Haskell genera un errore che indica che il nostro input non è il suo ambito.

Elenco e comprensione degli elenchi

Come altri tipi di dati, Listè anche un tipo di dati molto utile utilizzato in Haskell. Ad esempio, [a, b, c] è un elenco di caratteri, quindi, per definizione, List è una raccolta dello stesso tipo di dati separato da virgola.

Come altri tipi di dati, non è necessario dichiarare un elenco come elenco. Haskell è abbastanza intelligente da decodificare l'input guardando la sintassi usata nell'espressione.

Dai un'occhiata al seguente esempio che mostra come Haskell tratta una lista.

Prelude> [1,2,3,4,5]

Produrrà il seguente output:

[1,2,3,4,5]

Gli elenchi in Haskell sono di natura omogenea, il che significa che non ti consentiranno di dichiarare un elenco di diversi tipi di dati. Qualsiasi elenco come [1,2,3,4,5, a, b, c, d, e, f] produrrà un errore.

Prelude> [1,2,3,4,5,a,b,c,d,e,f]

Questo codice produrrà il seguente errore:

<interactive>:17:12: Not in scope: 'a' 
<interactive>:17:14: Not in scope: 'b' 
<interactive>:17:16: Not in scope: 'c' 
<interactive>:17:18: Not in scope: 'd' 
<interactive>:17:20: Not in scope: 'e' 
<interactive>:17:22: Not in scope: 'f'

Comprensione delle liste

La comprensione dell'elenco è il processo di generazione di un elenco utilizzando un'espressione matematica. Guarda il seguente esempio in cui stiamo generando un elenco utilizzando un'espressione matematica nel formato [output | intervallo, condizione].

Prelude> [x*2| x<-[1..10]] 
[2,4,6,8,10,12,14,16,18,20]  
Prelude> [x*2| x<-[1..5]] 
[2,4,6,8,10]  
Prelude> [x| x<-[1..5]] 
[1,2,3,4,5]

Questo metodo per creare una lista usando un'espressione matematica è chiamato come List Comprehension.

Tupla

Haskell fornisce un altro modo per dichiarare più valori in un singolo tipo di dati. È noto comeTuple. Una tupla può essere considerata come una lista, tuttavia ci sono alcune differenze tecniche tra una tupla e una lista.

Una tupla è un tipo di dati immutabile, poiché non possiamo modificare il numero di elementi in fase di runtime, mentre una lista è un tipo di dati mutabile.

D'altra parte, List è un tipo di dati omogeneo, ma Tuple è di natura eterogenea, perché una tupla può contenere diversi tipi di dati al suo interno.

Le tuple sono rappresentate da parentesi singole. Dai un'occhiata al seguente esempio per vedere come Haskell tratta una tupla.

Prelude> (1,1,'a')

Produrrà il seguente output:

(1,1,'a')

Nell'esempio sopra, abbiamo usato una tupla con due number digitare le variabili e un file char tipo variabile.