Haskell - Tipi e classe di tipo

Haskell è un linguaggio funzionale ed è strettamente tipizzato, il che significa che il tipo di dati utilizzato nell'intera applicazione sarà noto al compilatore in fase di compilazione.

Classe di tipo integrato

In Haskell, ogni affermazione è considerata come un'espressione matematica e la categoria di questa espressione è chiamata come a Type. Puoi dire che "Tipo" è il tipo di dati dell'espressione utilizzata in fase di compilazione.

Per saperne di più sul Type, useremo il comando ": t". In modo generico,Type può essere considerato un valore, mentre Type Classpuò essere considerato come un insieme di tipi simili di tipi. In questo capitolo, impareremo a conoscere diversi tipi incorporati.

Int

Intè una classe di tipo che rappresenta i dati dei tipi Integer. Ogni numero intero compreso tra 2147483647 e -2147483647 rientra nelInttipo di classe. Nell'esempio seguente, la funzionefType() si comporterà in base al tipo definito.

fType :: Int -> Int -> Int 
fType x y = x*x + y*y
main = print (fType 2 4)

Qui abbiamo impostato il tipo di funzione fType() come int. La funzione richiede dueint valori e ne restituisce uno intvalore. Se compili ed esegui questo pezzo di codice, produrrà il seguente output:

sh-4.3$ ghc -O2 --make *.hs -o main -threaded -rtsopts 
sh-4.3$ main
20

Numero intero

Integer può essere considerato come un superset di Int. Questo valore non è limitato da alcun numero, quindi un numero intero può essere di qualsiasi lunghezza senza alcuna limitazione. Per vedere la differenza fondamentale traInt e Integer tipi, modifichiamo il codice sopra come segue:

fType :: Int -> Int -> Int 
fType x y = x*x + y*y 
main = print (fType 212124454 44545454454554545445454544545)

Se compili la parte di codice sopra, verrà visualizzato il seguente messaggio di errore:

main.hs:3:31: Warning:            
   Literal 44545454454554545445454544545 is out of the Int range -
   9223372036854775808..9223372036854775807 
Linking main ...

Questo errore si è verificato perché la nostra funzione fType () si aspettava un valore di tipo Int e stiamo passando un valore di tipo Int davvero grande. Per evitare questo errore, modifichiamo il tipo "Int" con "Integer" e osserviamo la differenza.

fType :: Integer -> Integer -> Integer 
fType x y = x*x + y*y 
main = print (fType 212124454 4454545445455454545445445454544545)

Ora, produrrà il seguente output:

sh-4.3$ main
1984297512562793395882644631364297686099210302577374055141

Galleggiante

Dai un'occhiata al seguente pezzo di codice. Mostra come funziona il tipo Float in Haskell -

fType :: Float -> Float -> Float 
fType x y = x*x + y*y 
main = print (fType 2.5 3.8)

La funzione accetta due valori float come input e restituisce un altro valore float come output. Quando compili ed esegui questo codice, produrrà il seguente output:

sh-4.3$ main
20.689999

Doppio

Doubleè un numero in virgola mobile con doppia precisione alla fine. Dai un'occhiata al seguente esempio:

fType :: Double -> Double -> Double 
fType x y = x*x + y*y 
main = print (fType 2.56 3.81)

Quando esegui la parte di codice sopra, genererà il seguente output:

sh-4.3$ main 
21.0697

Bool

Boolè un tipo booleano. Può essere vero o falso. Esegui il codice seguente per capire come funziona il tipo Bool in Haskell -

main = do  
   let x = True 
   
   if x == False 
      then putStrLn "X matches with Bool Type" 
   else putStrLn "X is not a Bool Type"

Qui stiamo definendo una variabile "x" come bool e confrontandola con un altro valore booleano per verificarne l'originalità. Produrrà il seguente output:

sh-4.3$ main
X is not a Bool Type

Char

I caratteri rappresentano i personaggi. Qualsiasi cosa all'interno di una singola citazione è considerata come un personaggio. Nel codice seguente, abbiamo modificato il nostro precedentefType() funzione per accettare il valore Char e restituire il valore Char come output.

fType :: Char-> Char 
fType x = 'K' 
main = do  
   let x = 'v' 
   print (fType x)

La parte di codice sopra verrà chiamata fType() funzione con a charvalore di "v" ma restituisce un altro valore di carattere, ovvero "K". Ecco il suo output:

sh-4.3$ main 
'K'

Nota che non useremo questi tipi esplicitamente perché Haskell è abbastanza intelligente da catturare il tipo prima che venga dichiarato. Nei capitoli successivi di questo tutorial, vedremo come diversi tipi e classi Type rendono Haskell un linguaggio fortemente tipizzato.

Classe di tipo EQ

EQtype class è un'interfaccia che fornisce la funzionalità per testare l'uguaglianza di un'espressione. Qualsiasi classe Type che desideri verificare l'uguaglianza di un'espressione dovrebbe far parte di questa classe EQ Type.

Tutte le classi Type standard sopra menzionate ne fanno parte EQclasse. Ogni volta che controlliamo un'uguaglianza utilizzando uno dei tipi sopra menzionati, stiamo effettivamente effettuando una chiamata aEQ tipo di classe.

Nell'esempio seguente, stiamo usando il EQ Digitare internamente utilizzando l'operazione "==" o "/ =".

main = do 
   if 8 /= 8 
      then putStrLn "The values are Equal" 
   else putStrLn "The values are not Equal"

Produrrà il seguente output:

sh-4.3$ main 
The values are not Equal

Ord Type Class

Ordè un'altra classe di interfaccia che ci offre la funzionalità di ordinamento. Tutti itypes che abbiamo utilizzato finora ne fanno parte Ordinterfaccia. Come l'interfaccia EQ, l'interfaccia Ord può essere chiamata usando ">", "<", "<=", "> =", "compare".

Di seguito è riportato l'esempio in cui è stata utilizzata la funzionalità di "confronto" di questa classe di tipo.

main = print (4 <= 2)

Qui, il compilatore Haskell controllerà se 4 è minore o uguale a 2. Poiché non lo è, il codice produrrà il seguente output:

sh-4.3$ main 
False

Spettacolo

Showha una funzionalità per stampare il suo argomento come una stringa. Qualunque sia il suo argomento, stampa sempre il risultato come una stringa. Nell'esempio seguente, stamperemo l'intero elenco utilizzando questa interfaccia. "show" può essere utilizzato per chiamare questa interfaccia.

main = print (show [1..10])

Produrrà il seguente output sulla console. Qui, le virgolette doppie indicano che si tratta di un valore di tipo String.

sh-4.3$ main 
"[1,2,3,4,5,6,7,8,9,10]"

Leggere

Readl'interfaccia fa la stessa cosa di Show, ma non stampa il risultato in formato String. Nel codice seguente, abbiamo usato ilread interfaccia per leggere un valore di stringa e convertire lo stesso in un valore Int.

main = print (readInt "12") 
readInt :: String -> Int 
readInt = read

Qui, stiamo passando una variabile String ("12") al file readIntmetodo che a sua volta restituisce 12 (un valore Int) dopo la conversione. Ecco il suo output:

sh-4.3$ main 
12

Enum

Enumè un altro tipo di classe Type che abilita la funzionalità sequenziale o ordinata in Haskell. È possibile accedere a questa classe Type tramite comandi comeSucc, Pred, Bool, Char, eccetera.

Il codice seguente mostra come trovare il valore successore di 12.

main = print (succ 12)

Produrrà il seguente output:

sh-4.3$ main
13

Delimitato

Tutti i tipi con limiti superiori e inferiori rientrano in questa classe di tipo. Per esempio,Int i dati di tipo hanno un limite massimo di "9223372036854775807" e un limite minimo di "-9223372036854775808".

Il codice seguente mostra come Haskell determina il limite massimo e minimo del tipo Int.

main = do 
   print (maxBound :: Int) 
   print (minBound :: Int)

Produrrà il seguente output:

sh-4.3$ main
9223372036854775807
-9223372036854775808

Ora, prova a trovare il limite massimo e minimo dei tipi Char, Float e Bool.

Num

Questa classe di tipo viene utilizzata per le operazioni numeriche. Tipi come Int, Integer, Float e Double rientrano in questa classe Type. Dai un'occhiata al seguente codice:

main = do 
   print(2 :: Int)  
   print(2 :: Float)

Produrrà il seguente output:

sh-4.3$ main
2
2.0

Integrante

Integralpuò essere considerato come una sottoclasse della classe Num Type. La classe Num Type contiene tutti i tipi di numeri, mentre la classe Integral viene utilizzata solo per i numeri interi. Int e Integer sono i tipi in questa classe Type.

Galleggiante

Come Integral, anche Floating fa parte della classe Num Type, ma contiene solo numeri in virgola mobile. Quindi,Float e Double rientrare in questo tipo di classe.

Classe di tipo personalizzato

Come qualsiasi altro linguaggio di programmazione, Haskell consente agli sviluppatori di definire tipi definiti dall'utente. Nell'esempio seguente, creeremo un tipo definito dall'utente e lo useremo.

data Area = Circle Float Float Float  
surface :: Area -> Float   
surface (Circle _ _ r) = pi * r ^ 2   
main = print (surface $ Circle 10 20 10 )

Qui abbiamo creato un nuovo tipo chiamato Area. Successivamente, utilizziamo questo tipo per calcolare l'area di un cerchio. Nell'esempio precedente, "surface" è una funzione che accettaArea come input e produce Float come output.

Tieni presente che "dati" è una parola chiave qui e tutti i tipi definiti dall'utente in Haskell iniziano sempre con una lettera maiuscola.

Produrrà il seguente output:

sh-4.3$ main
314.15927