Haskell Language
Creación de tipos de datos personalizados

Creando un tipo de datos simple

La forma más fácil de crear un tipo de datos personalizado en Haskell es usar la palabra clave data :

data Foo = Bar | Biz

El nombre del tipo se especifica entre data y = , y se denomina constructor de tipo . Después = especificamos todos los constructores de valor de nuestro tipo de datos, delimitados por | firmar. Hay una regla en Haskell según la cual todos los constructores de tipos y valores deben comenzar con una letra mayúscula. La declaración anterior se puede leer como sigue:

Defina un tipo llamado Foo , que tiene dos valores posibles: Bar y Biz .

Creando variables de nuestro tipo personalizado.

let x = Bar

La declaración anterior crea una variable llamada x de tipo Foo . Vamos a verificar esto comprobando su tipo.

:t x

huellas dactilares

x :: Foo

Creación de un tipo de datos con parámetros de constructor de valor.

Los constructores de valor son funciones que devuelven un valor de un tipo de datos. Debido a esto, al igual que cualquier otra función, pueden tomar uno o más parámetros:

data Foo = Bar String Int | Biz String

Vamos a comprobar el tipo de constructor del valor Bar .

:t Bar

huellas dactilares

Bar :: String -> Int -> Foo

Lo que prueba que Bar es de hecho una función.

Creando variables de nuestro tipo personalizado.

let x = Bar "Hello" 10
let y = Biz "Goodbye"

Creación de un tipo de datos con parámetros de tipo

Los constructores de tipos pueden tomar uno o más parámetros de tipo:

data Foo a b = Bar a b | Biz a b

Los parámetros de tipo en Haskell deben comenzar con una letra minúscula. Nuestro tipo de datos personalizado aún no es un tipo real. Para crear valores de nuestro tipo, debemos sustituir todos los parámetros de tipo con los tipos reales. Debido a b pueden ser de cualquier tipo, nuestros constructores de valores son funciones polimórficas.

Creando variables de nuestro tipo personalizado.

let x = Bar "Hello" 10      -- x :: Foo [Char] Integer
let y = Biz "Goodbye" 6.0   -- y :: Fractional b => Foo [Char] b
let z = Biz True False      -- z :: Foo Bool Bool

Tipo de datos personalizado con parámetros de registro

Supongamos que queremos crear un tipo de datos Persona, que tenga un nombre y apellido, una edad, un número de teléfono, una calle, un código postal y una ciudad.

Podriamos escribir

data Person = Person String String Int Int String String String

Si queremos obtener el número de teléfono ahora, necesitamos hacer una función

getPhone :: Person -> Int
getPhone (Person _ _ _ phone _ _ _) = phone

Bueno, esto no es divertido. Podemos hacerlo mejor utilizando parámetros:

data Person' = Person' { firstName     :: String
                       , lastName      :: String
                       , age           :: Int
                       , phone         :: Int
                       , street        :: String
                       , code          :: String
                       , town          :: String }

Ahora tenemos el phone función donde

:t phone
phone :: Person' -> Int

Ahora podemos hacer lo que queramos, por ejemplo:

printPhone :: Person' -> IO ()
printPhone = putStrLn . show . phone

También podemos vincular el número de teléfono por Coincidencia de patrones :

getPhone' :: Person' -> Int
getPhone' (Person {phone = p}) = p

Para facilitar el uso de los parámetros, consulte RecordWildCards