Haskell - Tipos y clase de tipo

Haskell es un lenguaje funcional y está estrictamente escrito, lo que significa que el compilador conocerá el tipo de datos utilizado en toda la aplicación en el momento de la compilación.

Clase de tipo incorporada

En Haskell, cada declaración se considera una expresión matemática y la categoría de esta expresión se llama como Type. Puede decir que "Tipo" es el tipo de datos de la expresión utilizada en el momento de la compilación.

Para obtener más información sobre Type, usaremos el comando ": t". De forma genéricaType puede considerarse como un valor, mientras que Type Classse puede considerar como un conjunto de tipos similares. En este capítulo, aprenderemos sobre diferentes tipos incorporados.

En t

Intes una clase de tipo que representa los datos de tipos Integer. Cada número entero dentro del rango de 2147483647 a -2147483647 se incluye en elIntclase de tipo. En el siguiente ejemplo, la funciónfType() se comportará según su tipo definido.

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

Aquí, hemos establecido el tipo de función fType() como int. La función toma dosint valores y devuelve uno intvalor. Si compila y ejecuta este fragmento de código, producirá el siguiente resultado:

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

Entero

Integer puede considerarse como un superconjunto de Int. Este valor no está limitado por ningún número, por lo tanto, un entero puede tener cualquier longitud sin ninguna limitación. Para ver la diferencia básica entreInt y Integer tipos, modifiquemos el código anterior de la siguiente manera:

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

Si compila el código anterior, aparecerá el siguiente mensaje de error:

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

Este error se produjo porque nuestra función fType () esperaba un valor de tipo Int, y estamos pasando un valor de tipo Int muy grande. Para evitar este error, modifiquemos el tipo "Int" con "Integer" y observemos la diferencia.

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

Ahora, producirá la siguiente salida:

sh-4.3$ main
1984297512562793395882644631364297686099210302577374055141

Flotador

Eche un vistazo al siguiente fragmento de código. Muestra cómo funciona el tipo Float en Haskell:

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

La función toma dos valores flotantes como entrada y produce otro valor flotante como salida. Cuando compile y ejecute este código, producirá el siguiente resultado:

sh-4.3$ main
20.689999

Doble

Doublees un número de coma flotante con doble precisión al final. Eche un vistazo al siguiente ejemplo:

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

Cuando ejecute el fragmento de código anterior, generará la siguiente salida:

sh-4.3$ main 
21.0697

Bool

Booles un tipo booleano. Puede ser Verdadero o Falso. Ejecute el siguiente código para comprender cómo funciona el tipo Bool en Haskell:

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

Aquí, definimos una variable "x" como un bool y la comparamos con otro valor booleano para comprobar su originalidad. Producirá la siguiente salida:

sh-4.3$ main
X is not a Bool Type

Carbonizarse

Char representan personajes. Todo lo que esté dentro de una sola cita se considera un personaje. En el siguiente código, hemos modificado nuestro anteriorfType() función para aceptar el valor de Char y devolver el valor de Char como salida.

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

La pieza de código anterior llamará fType() funcionar con un charvalor de 'v' pero devuelve otro valor char, es decir, 'K'. Aquí está su salida:

sh-4.3$ main 
'K'

Tenga en cuenta que no vamos a utilizar estos tipos explícitamente porque Haskell es lo suficientemente inteligente como para detectar el tipo antes de que se declare. En los capítulos siguientes de este tutorial, veremos cómo los diferentes tipos y clases de tipos hacen de Haskell un lenguaje fuertemente tipado.

Clase de tipo EQ

EQLa clase de tipo es una interfaz que proporciona la funcionalidad para probar la igualdad de una expresión. Cualquier clase de tipo que desee comprobar la igualdad de una expresión debe formar parte de esta clase de tipo EQ.

Todas las clases de tipo estándar mencionadas anteriormente son parte de este EQclase. Siempre que verificamos cualquier igualdad utilizando cualquiera de los tipos mencionados anteriormente, en realidad estamos haciendo una llamada aEQ clase de tipo.

En el siguiente ejemplo, estamos usando el EQ Escriba internamente usando la operación "==" o "/ =".

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

Producirá el siguiente resultado:

sh-4.3$ main 
The values are not Equal

Clase de tipo Ord

Ordes otra clase de interfaz que nos da la funcionalidad de ordenar. Todostypes que hemos usado hasta ahora son parte de esto Ordinterfaz. Como la interfaz EQ, la interfaz Ord se puede llamar usando ">", "<", "<=", "> =", "comparar".

A continuación, encontrará un ejemplo en el que utilizamos la función "comparar" de esta clase de tipo.

main = print (4 <= 2)

Aquí, el compilador de Haskell verificará si 4 es menor o igual que 2. Como no lo es, el código producirá la siguiente salida:

sh-4.3$ main 
False

mostrar

Showtiene una funcionalidad para imprimir su argumento como una cadena. Cualquiera que sea su argumento, siempre imprime el resultado como una cadena. En el siguiente ejemplo, imprimiremos la lista completa usando esta interfaz. "show" se puede utilizar para llamar a esta interfaz.

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

Producirá la siguiente salida en la consola. Aquí, las comillas dobles indican que es un valor de tipo String.

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

Leer

ReadLa interfaz hace lo mismo que Show, pero no imprime el resultado en formato String. En el siguiente código, hemos utilizado elread interfaz para leer un valor de cadena y convertir el mismo en un valor Int.

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

Aquí, estamos pasando una variable de cadena ("12") al readIntmétodo que a su vez devuelve 12 (un valor Int) después de la conversión. Aquí está su salida:

sh-4.3$ main 
12

Enum

Enumes otro tipo de clase Type que habilita la funcionalidad secuencial u ordenada en Haskell. Se puede acceder a esta clase de tipo mediante comandos comoSucc, Pred, Bool, Charetc.

El siguiente código muestra cómo encontrar el valor sucesor de 12.

main = print (succ 12)

Producirá la siguiente salida:

sh-4.3$ main
13

Encerrado

Todos los tipos que tienen límites superior e inferior se incluyen en esta clase de tipo. Por ejemplo,Int Los datos de tipo tienen un límite máximo de "9223372036854775807" y un límite mínimo de "-9223372036854775808".

El siguiente código muestra cómo Haskell determina el límite máximo y mínimo del tipo Int.

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

Producirá la siguiente salida:

sh-4.3$ main
9223372036854775807
-9223372036854775808

Ahora, intente encontrar el límite máximo y mínimo de los tipos Char, Float y Bool.

Num

Esta clase de tipo se utiliza para operaciones numéricas. Los tipos como Int, Integer, Float y Double pertenecen a esta clase Type. Eche un vistazo al siguiente código:

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

Producirá la siguiente salida:

sh-4.3$ main
2
2.0

Integral

Integralpuede considerarse como una subclase de la clase de tipo numérico. La clase de tipo numérico contiene todos los tipos de números, mientras que la clase de tipo integral se usa solo para números enteros. Int y Integer son los tipos de esta clase Type.

Flotante

Como Integral, Floating también es parte de la clase Num Type, pero solo contiene números de punto flotante. Por lo tanto,Float y Double entran en esta clase de tipo.

Clase de tipo personalizado

Como cualquier otro lenguaje de programación, Haskell permite a los desarrolladores definir tipos definidos por el usuario. En el siguiente ejemplo, crearemos un tipo definido por el usuario y lo usaremos.

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

Aquí, hemos creado un nuevo tipo llamado Area. A continuación, usamos este tipo para calcular el área de un círculo. En el ejemplo anterior, "superficie" es una función que tomaArea como insumo y produce Float como salida.

Tenga en cuenta que "datos" es una palabra clave aquí y todos los tipos definidos por el usuario en Haskell siempre comienzan con una letra mayúscula.

Producirá la siguiente salida:

sh-4.3$ main
314.15927