Creando nuestros propios tipos y clases de tipos

Algebraic data types intro
1. data
  1. Ejemplo: data Bool = False | True
    1. Los constructores deben tener su primera letra en mayúscula
    2. Como se ve en ejemplo la parte Izquierda antes del igual es el tipo de dato, y la parte derecha son los valores que puede tomar el tipo de dato
  2. Palabra clave de Haskell para definir un nuevo tipo de dato
2. Para mostrar por consola se agrega al final de la declaración :deriving (Show)
Record syntax
1. Podemos almacenar información de una persona, datos personales como como características de ella
  1. ejemplo: data Person = Person String String Int Float String String deriving (Show) , tenemos 6 tipos de datos lo que indica que creamos un apersona con 6 datos: nombre , apellido, edad, estatura y un un dato de información personal
    1. ghci> let guy = Person "Javier" "Cardenas" 30 1.70 "2022669" "FResa" ghci> guy Person "Javier" "Cardenas" 30 1.7 "2022669" "FResa"
    2. Después de crear una persona, podemos crear funciones que obtengan información por separado de la clase persona que creamos anteriormente
      1. data Persona = Persona String String Int Float String String deriving (Show)
      2. primerNombre :: Persona -> String primerNombre Persona primerNombre _ _ _ _ _) =primerNombre
      3. apellido :: Persona -> String apellido (Persona _ apellido _ _ _ _) =apellido
      4. let persona = Persona "Carlos" "Gomez" 30 1.70 "2022668" "Cl. l1 # 20-25"
      5. *Main> primerNombre persona "Carlos" *Main> apellido persona "Gomez"
2. Método para de definir tipos de dato
  1. data Persona = Persona { primerNombre :: String , apellido :: String , edad :: Int , estatura :: Float , telefono :: String , direccion :: String } deriving (Show)
Type parameters
1. Un constructor de datos puede tomar algunos valores como parámetros y producir un nuevo valor, un constructor de tipos puede tomar tipos como parámetros y producir nuevos tipos
  1. data Maybe a = Nothing | Just a
    1. La (a) es un parámetro de tipo. Debido a que hay un parámetro de tipo involucrado en esta definición, llamamos a Maybe un constructor de tipos.
    2. Just puede tomar cualquier valor que le pasen que le pase Maybe
Derived instances
1. Clase de tipos es una especie de interfaz que define un comportamiento, Un tipo puede ser una instancia de esa clase si soporta ese comportamiento
  1. El tipo Int es una instancia de la clase Eq
    1. La utilidad real está en las funciones que actúan como interfaz de Eq, que son == y /=
2. La clase de tipos Eq define el comportamiento de cosas que se pueden equiparar
3. Haskell puede derivar el comportamiento de nuestros tipos en las siguientes clases: Eq, Ord, Enum, Bounded, Show y Read, si usamos la palabra clave deriving cuando los definimos, usando la palabra clave deriving cuando los definimos
  1. Al derivar una instancia de Eq para un tipo y luego se compara dos valores de ese tipo usando == o /=, Haskell comprobará si los constructores de tipo coinciden y luego comprobará si todos los campos de ese constructor coinciden utilizando el operador = para cada par de campos. Solo tenemos que tener en cuenta una cosa, todos los campos del tipo deben ser también miembros de la clase de tipos Eq.
  2. Las clases de tipos Show y Read son para cosas que pueden ser convertidas a o desde cadenas, respectivamente. si un constructor de tipos tiene campos, su tipo debe ser miembro de la clase Show o Read si queremos que también forme parte de estas clases.
    1. Show sirve para convertir nuestro tipo a una cadena, Read sirve para convertir una cadena a nuestro tipo su función es inversa. Aunque recuerda que cuando uses la función read hay que utilizar una anotación de tipo explícita para decirle a Haskell que tipo queremos como resultado. Si no ponemos el tipo que queremos como resultado explícitamente, Haskell no sabrá que tipo queremos.
  3. Podemos derivar instancias para la clase de tipo Ord, que es para tipos que tienen valores que se pueden pedir. Si comparamos dos valores del mismo tipo que se realizaron utilizando diferentes constructores, el valor que se definió primero es considerados más pequeños. Por ejemplo, considere el tipo Bool, que puede tener un valor de Falso o Verdadero. Con el propósito de ver cómo se comporta cuando comparado, ejem: data Bool = False | True deriving (Ord)
Type synonyms
1. Un sinónimo de tipo es un nuevo nombre para un tipo existente, Los valores de diferentes sinónimos del mismo tipo son totalmente compatibles. En Haskell puedes definir un sinónimo de tipo utilizando type: type MyChar = Char, type String = [Char]
  1. Los sinónimos de tipo también pueden ser parametrizados. Si queremos un tipo que represente las listas de asociación pero también queremos que sea lo suficientemente general como para utilizar cualquier tipo de clave y valor, Ejem: type AssocList k v = [(k,v)]
    1. Una función que tomara un valor por clave en una lista de asociación puede tener el tipo (Eq k) => k -> AssocList k v -> Maybe v. AssocList es un constructor de tipos que toma dos tipos y produce un tipo concreto, ejem: AssocList Int String
Recursive data structures
1. En haskell se pueden crear estructuras de datos recursivas, en el que un valor de un cierto tipo contenga valores de ese mismo tipo, el cual seguirá conteniendo valores del mismo tipo y así sucesivamente.
  1. ejemplo: data List a = Empty | Cons a (List a) deriving (Show, Read, Eq, Ord)
    1. Puede ser una lista vacía o una combinación de un elemento y otra lista.
      1. sintaxis de registro: data List a = Empty | Cons { listHead :: a, listTail :: List a} deriving (Show, Read, Eq, Ord)
Typeclasses 102
1. clase de tipos Eq es para cosas que pueden ser equiparadas. Define las funciones == y /=. Si tenemos un tipo (digamos, Car) y el comparar dos coches con la función == tiene sentido, entonces tiene sentido que Car sea una instancia de Eq.
  1. definición de la clase
    1. class Eq a where (==) :: a -> a -> Bool (/=) :: a -> a -> Bool x == y = not (x /= y) x /= y = not (x == y)
      1. class Eq a where: significa que estamos definiendo una clase de tipos nueva y que se va a llamar Eq
      2. La a es la variable de tipo y significa que a representará el tipo que dentro de poco hagamos instancia de Eq
      3. No es obligatorio implementar los cuerpos de las funciones, solo debemos especificar las declaraciones de tipo de las funciones.
      4. No necesariamente tiene que ser una a puede ser cualquier letra o palabra en minúscula
    2. data TrafficLight = Red | Yellow | Green
      1. instance Eq TrafficLight where Red == Red = True Green == Green = True Yellow == Yellow = True _ == _ = False
        se utiliza: class, para definir nuevas clases de tipos e instance, para hacer que nuestros tipos tengan una instancia para cierta clase de tipos.
        Cuando se define class Eq a where, a representa el tipo que hiciéramos instancia después. cuando se instancia, escribrimos instance Eq TrafficLight where, remplazando la a por el tipo actual.
        class Eq a where (==) :: a -> a -> Bool (/=) :: a -> a -> Bool
A yes-no typeclass
1. La clase de tipos YesNo define una función
  1. Esta función toma un valor de un tipo cualquiera que puede expresar algún valor de verdad y nos dice si es verdadero o no
    1. class YesNo a where yesno :: a -> Bool
      1. instancia
        instance YesNo Int where yesno 0 = False yesno _ = True
  2. La listas vacias son falsos
    1. instance YesNo [a] where yesno [] = False yesno _ = True
  3. listas no vacías son verdaderas
The Functor typeclass
1. Se usa para cosas que se pueden mapear
  1. implementación
    1. class Functor f where fmap :: (a -> b) -> f a -> f b
2. Toma una función de un tipo a otro y una lista de un tipo y devuelve una lista del otro tipo
  1. instance Functor [] where fmap = map
    1. hacer map o fmap sobre listas vacías se obtiene un alista vacía
Kinds and some type-foo
1. Kinds pueden ser un tipo de un tipo
  1. ghci> :k Int Int :: *
    1. * : significa que es de un tipo de dato concreto
      1. Concreto: que no toma parámetros o valores
2. ghci> :k Maybe Maybe :: * -> *
  1. toma tipo concreto com o Int y devuelve un tipo Maybe Int
3. ghci> :k Either Either :: * -> * -> *
  1. Either toma dos tipos concretos como parámetros de tipo y produce un tipo concret

Next up

Creando nuestros propios tipos y clases de tipos

Description

Resource summary

Similar

	Created by José Eduardo Bermúdez over 7 years ago