Tipos y clases de tipos en haskell

Description

Programacion funcional Mind Map on Tipos y clases de tipos en haskell, created by tooon a on 03/10/2017.
tooon a
Mind Map by tooon a, updated more than 1 year ago
tooon a
Created by tooon a about 7 years ago
50
0

Resource summary

Tipos y clases de tipos en haskell
  1. Podemos definir nuestros propios tipos de datos
    1. se definen mediante la palabra reservada Data
      1. Al lado izquierdo se define el tipo de dato y al lado derecho su constructor
      2. por ejemplo
        1. Crear un tipo de dato "Figura"
          1. Podemos relacionar este tipo de dato con los "objetos" como en otros lenguajes de programación
            1. que este conformado por un circulo o un rectangulo
              1. Desde ahora un circulo o un rectangulo seran tratados como si fueran una figura
                1. Al tener dos tipos de dato posibles la "figura"
                  1. puede tener funciones con parametros diferentes
                    1. como por ejemplo una funcion para hallar el area
                      1. tanto como para el circulo como para el rectangulo
                  2. Data Figura = Circulo Float Float Float | Rectangulo Float Float Float Float
                  3. Si deseamos representar este tipo de dato debemos declararlo
                    1. con deriving (show) en el contructor del tipo
                      1. Lo que nos asegura poder mostrar su representacion en pantalla
              2. Consideremos el tipo de dato "Persona"
                1. Con sus distintos atributos , como nombre ,color favorito, edad
                  1. Podemos declarar este tipo de dato , de forma lineal , especificando cada atributo de tipo primitivo y String
                    1. Es decir , Persona = Persona String String Int
                      1. Declarar de esta forma se presta para confuciones
                        1. ya que los atributos no son representativos
                          1. por ejemplo el segundo parametro podria ser color de ojos cafe
                            1. cuando en realidad era el color favorito cafe
                        2. o Podemos declarar la persona con una sintaxis de registro
                          1. En la que especificamos directamente cuales van a ser exactamente los atributos
                            1. y sus respectivos tipos de datos , ya sean primitivos o compuestos
                              1. por ejemplo
                                1. Data Persona = Persona { nombre :: String , colorFavorito:: String, edad:: Int}
                                  1. Así evitamos confusiones en cuanto a los parametros
                                    1. Otra forma de evitar estas confuciones es con los sinonimos de tipo
                                      1. que no es mas que dar un sobrenombre a el parametro del tipo de dato
                                        1. por ejemplo
                                          1. type nombre = String
                                            1. type colorFavorito =String
                                              1. type Persona = { nombre , colorFavorito}
                                        2. declarar una persona seria sencillo y muy explícito
                                          1. por ejemplo
                                            1. Persona {nombre= "Lina" , colorFavorito= "negro", edad = 20}
                          2. Podemos declarar nuestros tipos de datos , haciendo que sus parametros puedan ser de tipos diferentes
                            1. Como por ejemplo
                              1. Data carro a b = carro { compañia :: a, modelo:: b}
                                1. En este caso el parametro a , podria se un tipo de dato compuesto o primitivo
                                  1. por ejemplo un entero , compañia = 1
                                    1. por ejemplo a podria ser un tipo de dato compañia( compuesto), que tenga
                                      1. nombre de la compañia y ubicacion
                                      2. De esta forma obtenemos flexibilidad en nuestros tipos de datos
                                        1. Esto es llamado Parámetros de tipo
                                2. Los tipos pueden derivar caracteristicas, comportamientos y condiciones
                                  1. por medio de:
                                    1. deriving( derivación ),
                                      1. al final del contructor del tipo, Por ejemplo
                                        1. Data Persona = Persona {nombre:: String, edad :: Int} deriving (Eq, Show , Read)
                                    2. Como por ejemplo
                                      1. Con "Eq"
                                        1. se podrán comparar dos valores == o /=, Haskell comprobará si los constructores de tipo coinciden.
                                        2. Con "Show"
                                          1. Se permite ver el valor del tipo por consola representando el valor como un cadena
                                          2. Con "read"
                                            1. se permite convertir el tipo en una cadena
                                            2. Ord
                                              1. Es para tipos de valores que puedan ser ordenados
                                            3. Este conjunto es llamado Clases de tipo
                                              1. Si querermos definir nuestras propias clases de tipo para alguna estructura de dato
                                                1. Debemos crear una instancia de ese tipo
                                                  1. por ejemplo
                                                    1. Data semaforo = Rojo | Amarillo | Verde
                                                      1. instance Eq semaforo where
                                                        1. Rojo == Rojo == true
                                                          1. Amarillo = Amarillo == true
                                                            1. Verde == verde == True
                                                              1. _ == _ == False
                                                              2. De esta manera tenemos nuestro propia clase de tipo y podriamos comparar dos luces
                                                                1. tenemos la opcion tambien de hacer tipos de clase si - no
                                                                  1. que nos arrojaran un valor boleano
                                                                    1. por ejemplo podemos definir una instancia si -no para valores enteros
                                                                      1. si el numero es 0 arrojariamos falso y si es cualquier otro numero devolvemos verdadero
                                                                        1. Instance YesNo Int where
                                                                          1. yesno 0 = False
                                                                            1. yesno _ = True
                                                                            2. Probando esta instancia tendriamos algo asi
                                                                              1. yesno 0
                                                                                1. False
                                                                        2. Por otra parte si queremos crear una instancia que aplique una función a una lista de un tipo
                                                                          1. necesitariamos implementar un functor
                                                                            1. esto tiene el mismo enfoque que la función map
                                                                              1. por ejemplo
                                                                                1. instance Functor [ ] where fmap = map
                                                                                  1. Probandola instancia
                                                                                    1. fmap ( 2* ) [1.. 3]
                                                                                      1. obtenemos
                                                                                        1. [ 2,4, 6]
                                                                                          1. podemos definir mas condiciones en la instancia si queremos
                                                                                            1. pero en escencia el functor aplica una funcion de un tipo , a una lista de otro tipo ( a )
                                                                                              1. y finalmente obtenemos una lista de un tipo diferente ( b )
                                                            2. Recordemos que haskell nos permite hacer recursión en distintos marcos
                                                              1. Uno de ellos es justamente cuando definimos estructuras o tipos de datos
                                                                1. por ejemplo
                                                                  1. Data lista a = Empty | Cons a (Lista a ) deriving ( show)
                                                                    1. Como podemos ver el tipo de dato lista puede contener listas o un valor vacio
                                                                      1. Este tipo de llamada hace que haskell tenga un nivel de recursividad bastante alto
                                                                      2. en este caso podemos declarar de forma infija una lista
                                                                        1. como por ejemplo
                                                                          1. 20 'Cons' (5 ' Const ' Empty )
                                                                            1. Y obtendriamos
                                                                              1. 20 : ( 5 : [ ] )
                                                                              2. Cons en estee caso equivale a (dos puntos ) ' : '
                                                                        2. Podemos generar facilmente una función para implementar arboles binario de busqueda
                                                                          1. definiendo el arbol así
                                                                            1. Data Arbol a = ArbolVacio | Nodo a ( Arbol a) (Arbol a )
                                                                            2. Difiniendo una funcion para insertar en el arbol
                                                                              1. que garantice que halla recursivdad a la hora de insertar los nodos ordenadamene
                                                                                1. por ejemplo cuando un nodo es menor se deberia insertar por la izquierda de la raiz
                                                                                  1. Caso x < a = Nodo a ( Insertar x ArbolIzquierdo) ArbolDerecho
                                                                        Show full summary Hide full summary

                                                                        Similar

                                                                        TERP10
                                                                        macmanuel
                                                                        Neurotransmisión, Aminoglucósidos e Inhibidores de la síntesis protéica - Farmacología 2015-V.
                                                                        Christian Vega
                                                                        Paridad del poder adquisitivo (PPA)
                                                                        Gerardo Trejo
                                                                        EL GERENTE COMO PLANIFICADOR Y ESTRATEGA Capítulo 8
                                                                        FER NOVA
                                                                        TYPE AND TYPECLASSES - HASKELL
                                                                        FONTALVO ROMERO EDUARDO JOSÉ
                                                                        Decreto Nº 66 - Capítulo Vlll
                                                                        felipe vera
                                                                        Inversiones y financiamiento
                                                                        Rafael Garcia
                                                                        Capítulo 8 La escapada
                                                                        jocs.elaxai
                                                                        Seguridad en los sistemas de información
                                                                        Kassandra Carbaj
                                                                        RECONOCIMIENTO DEL PROBLEMA Y BÚSQUEDA DE INFORMACIÓN
                                                                        aymet milagros alcahuaman torres
                                                                        ISO 9001 8.5: MEJORA
                                                                        diego vargas