Haskell - Modelos de datos básicos

Haskell es un lenguaje de programación puramente funcional, por lo que es mucho más interactivo e inteligente que otros lenguajes de programación. En este capítulo, aprenderemos sobre los modelos de datos básicos de Haskell que en realidad están predefinidos o de alguna manera decodificados inteligentemente en la memoria de la computadora.

A lo largo de este tutorial, utilizaremos la plataforma en línea de Haskell disponible en nuestro sitio web (https://www.tutorialspoint.com/codingground.htm).

Números

Haskell es lo suficientemente inteligente como para decodificar un número como un número. Por lo tanto, no es necesario mencionar su tipo externamente como solemos hacer en el caso de otros lenguajes de programación. Como por ejemplo, vaya al símbolo del sistema de preludio y simplemente ejecute "2 + 2" y presione enter.

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

Recibirá el siguiente resultado como resultado.

En el código anterior, pasamos dos números como argumentos al compilador GHCI sin predefinir su tipo, pero el compilador podría decodificar fácilmente estas dos entradas como números.

Ahora, intentemos un cálculo matemático un poco más complejo y veamos si nuestro compilador inteligente nos da la salida correcta o no. Prueba con "15+ (5 * 5) -40"

Prelude> 15+(5*5)-40

La expresión anterior produce "0" según el resultado esperado.

Caracteres

Al igual que los números, Haskell puede identificar de forma inteligente un carácter dado como entrada. Vaya a la línea de comandos de Haskell y escriba cualquier carácter con comillas simples o dobles.

Proporcionemos la siguiente línea como entrada y verifiquemos su salida.

Prelude> :t "a"

Producirá la siguiente salida:

"a" :: [Char]

Recuerde que usa (:t) mientras se suministra la entrada. En el ejemplo anterior,(:t)es incluir el tipo específico relacionado con las entradas. Aprenderemos más sobre este tipo en los próximos capítulos.

Eche un vistazo al siguiente ejemplo en el que estamos pasando una entrada no válida como un carácter que a su vez conduce a un error.

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

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

Con el mensaje de error "<interactivo>: 4: 1: Fuera del alcance:` a '", el compilador Haskell nos advierte que no puede reconocer su entrada. Haskell es un tipo de lenguaje donde todo se representa mediante un número.

Haskell sigue el estilo de codificación ASCII convencional. Echemos un vistazo al siguiente ejemplo para comprender más:

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

Mira cómo se decodifica tu entrada en formato ASCII.

Cuerda

UN stringno es más que una colección de personajes. No hay una sintaxis específica para usar una cadena, pero Haskell sigue el estilo convencional de representar una cadena con comillas dobles.

Eche un vistazo al siguiente ejemplo en el que estamos pasando la cadena "Tutorialspoint.com".

Prelude> :t "tutorialspoint.com"

Producirá el siguiente resultado en pantalla:

"tutorialspoint.com" :: [Char]

Vea cómo se ha decodificado toda la cadena como una matriz de Char solamente. Pasemos al otro tipo de datos y su sintaxis. Una vez que iniciemos nuestra práctica real, nos habituaremos a todo el tipo de datos y su uso.

Booleano

El tipo de datos booleanos también es bastante sencillo como otros tipos de datos. Mire el siguiente ejemplo donde usaremos diferentes operaciones booleanas usando algunas entradas booleanas como "Verdadero" o "Falso".

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

En el ejemplo anterior, no necesitamos mencionar que "Verdadero" y "Falso" son los valores booleanos. El propio Haskell puede decodificarlo y realizar las operaciones respectivas. Modifiquemos nuestras entradas con "verdadero" o "falso".

Prelude> true

Producirá la siguiente salida:

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

En el ejemplo anterior, Haskell no pudo diferenciar entre "verdadero" y un valor numérico, por lo tanto, nuestra entrada "verdadero" no es un número. Por lo tanto, el compilador de Haskell arroja un error que indica que nuestra entrada no es su alcance.

Lista y comprensión de listas

Como otros tipos de datos, Listtambién es un tipo de datos muy útil utilizado en Haskell. Por ejemplo, [a, b, c] es una lista de caracteres, por lo tanto, por definición, List es una colección del mismo tipo de datos separados por comas.

Al igual que otros tipos de datos, no es necesario declarar una lista como una lista. Haskell es lo suficientemente inteligente como para decodificar su entrada al observar la sintaxis utilizada en la expresión.

Eche un vistazo al siguiente ejemplo que muestra cómo Haskell trata una lista.

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

Producirá la siguiente salida:

[1,2,3,4,5]

Las listas en Haskell son de naturaleza homogénea, lo que significa que no le permitirán declarar una lista de diferentes tipos de datos. Cualquier lista como [1,2,3,4,5, a, b, c, d, e, f] producirá un error.

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

Este código producirá el siguiente error:

<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'

Comprensión de listas

La comprensión de listas es el proceso de generar una lista utilizando expresiones matemáticas. Mire el siguiente ejemplo donde estamos generando una lista usando una expresión matemática en el formato de [salida | rango, condición].

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]

Este método de crear una lista usando una expresión matemática se llama como List Comprehension.

Tupla

Haskell proporciona otra forma de declarar varios valores en un solo tipo de datos. Es conocido comoTuple. Una tupla puede considerarse como una lista, sin embargo, existen algunas diferencias técnicas entre una tupla y una lista.

Una tupla es un tipo de datos inmutable, ya que no podemos modificar el número de elementos en tiempo de ejecución, mientras que una lista es un tipo de datos mutable.

Por otro lado, List es un tipo de datos homogéneo, pero Tuple es de naturaleza heterogénea, porque un Tuple puede contener diferentes tipos de datos en su interior.

Las tuplas están representadas por un solo paréntesis. Eche un vistazo al siguiente ejemplo para ver cómo Haskell trata a una tupla.

Prelude> (1,1,'a')

Producirá la siguiente salida:

(1,1,'a')

En el ejemplo anterior, hemos utilizado una tupla con dos number tipo de variables, y un char tipo de variable.