ParadigmaS

Paradigma El joven conoce las reglas
pero el viejo las excepciones..!! (Wilucha)

Paradigma Funcional:
Lenguaje HASKELL
Haskell Curry


	Haskell opera: - Funciones de alto orden. - Inferencia de tipos - Polimorfismo paramétrico - Semántica no estricta, evaluación perezosa - Listas por comprensión - Propiedades nuevas - Clases de tipos, sobrecarga. - Entrada/salida funcional.

El entorno HUGS:
funciona como calculadora interactiva entre el ordenador y usuario. Donde
- Al inicio el sistema muestra un prompt " Prelude>" y
espera que el usuario introduzca una expresión (Expresión inicial y presione la tecla < R E T U R N >.

- Luego, el sistema evalúa la expresión e imprime su valor.
Antes de volver a mostrar el prompt para esperar la siguiente expresión. Ejemplo:


   Prelude> (2+3)*8
   40

Expresión evaluada por el sistema imprimiendo como resultado el valor "40".


   Prelude> sum[1..10]
   55

Expresión de la lista de enteros que van de 1 hasta 10,
sum es una función estándar que devuelve la suma de una lista de enteros. Es decir:


 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 = 55

Se usó funciones estándar, incluidas un fichero denominado "estándar prelude", cargado al arrancar el sistema.
- El usuario puede definir sus propias funciones y almacenarlas para utilizarlas en el proceso de evaluación.
- Para evaluar tomar una expresión que transforma mediante funciones, hasta que no pueda transformarse más.
- La expresión resultante se denomina representación canónica y es mostrada al usuario.
- El proceso de evaluación puede seguir diversas trayectorias: Ejemplo:


    cuadrado (3+4)
    =               { usa la suma }
    cuadrado 7

    =               { usa cuadrado x = x * x }
     7 * 7

   =                { evalua multiplicación }
            49

Se evaluó expresiones internas antes de la aplicación de la función.
Argumentos antes de llamar por valor la función y se asocia con la evaluación ansiosa.

Otra posibilidad es usar la definición de función antes de evaluar argumentos.


   cuadrado (3+4)

   =       { usa cuadrado x = x * x }
   (3+4) * (3+4)

   =       { evalua parte izquierda de la multiplicación }
    7 * (3+4)

   =       { evalua parte derecha de la multiplicación }
           7 * 7

  = { evalua la multiplicación }
           49

HASKELL: COMANDOS DEL INTERPRETE
Además de :edit y :load, otros comandos se envían directamente al interprete.
Todos empiezan por dos puntos. Algunos de comandos son:
- load fichero(s)
  Se conoce las funciones que están definidas en los ficheros especificados.
- also fichero(s)
  Permite añadir definiciones de otros ficheros, sin eliminar las definiciones existentes.
- edit fichero ´
  Crea o modifica un fichero.
  Sin nombre, edit usa el ultimo fichero que se ha recuperado.
  Al salir del procesador de textos, se carga otra vez.
  Ejemplo, si se hicieron cambios en otra ‘ventana’).
- type expresion
  Se determina el tipo de la expresion dada.
- set ±letra
  Se pueden aplicar o eliminar algunas opciones.
  Activa/desactiva número de reducciones y la memoria usada.
  Con :set -s deja de hacerlo. Con :set +s da otra vez esta información.
  Las opciones son: s, t, g en i:
  - s: Información estadística (reducciones y memoria).
  - t: Tipo de cada resultado de una computación.
  - g: Informe sobre Garbage collection.
  - i: Constantes de enteros se manejan de forma especial.
HASKELL: FUNCIONES y OPERADORES
Las palabras reservadas:
```
   Case, class, data, else, if, in, infix, infixl, infixr, 

   instance, let, of, primitive, tden, type, where
```
Para definir una función se antepone ‘:edit’.
Luego el nombre del fichero: Prelude> :edit nuevo
EJ: El fichero ‘nuevo’ de la función factorial: fac n = product [1..n]
Se usa
- Notación para ‘lista de números entre dos valores’ y la función estándar product.
- Se guarda como nuevo.hs y se puede salir del procesador de textos.
- Para usar la nueva función, se usa el comando: Prelude> : load nuevo
- En el fichero prelude están las definiciones de las funciones estándar.
- Lo primero que hace el interprete es analizar estas funciones estándar.
- ‘Prelude’ significa ‘preludio’: este archivo se examina antes de que se puedan definir nuevas funciones.
- Finalmente, el interprete comunica que se puede teclear .
```
   Type :? for help

   Prelude>   
```
- Signo ? Indica que el interprete esta listo para calcular valor de una expresion.
- Prelude define, las funciones aritméticas.
- Se puede usar el interprete como calculadora.
```
   Prelude> 5+2*3
   
   11

   (5 reductions, 9 cells)
   
   Prelude>
```
Interprete:
Calcula el valor de la expresion (el operador * indica multiplicación).
Luego indica que fue necesario para el calculo:
- ‘5 reductions’ (medida del tiempo utilizado) y
- ‘9 cells’ (medida para memoria utilizada).
- Prelude> ,indica que el interprete esta listo para el próximo cálculo.
Nombres de funciones y parámetros empiezan en minúscula.
(minúsculas y mayúsculas son diferentes para el interprete).
Luego pueden seguir minúsculas o mayúsculas, números, el símbolo ’ y el símbolo _.
Ejemplos:
```
    f               sum            x3               g’             

    tot_de_macht                 nombreLargo
```
Símbolos que se pueden usar para formar operadores:
```
  :       #        $    %    

  &    *    +    -    =    .    

  /    /    <    >    ?    !    

  @    ^    |

  +      ++      &&      
  
  ||    <=    ==    /=     .    //

  @@     -*-        / /           

  / /              ...            
  
  <+>         :->
```
Si a y b son tipos: a->b es función con argumento tipo a y devuelve un valor de tipo b.
La función Haskell es objeto de 1ra clase
Puede ser argumento de otra función o ser componente de estructuras de datos.
La función suma tiene el tipo:
- (+) :: Int->(Int->Int) ó Se podría escribir simplemente
- (+)::Int->Int->Int, puesto que el operador -> es asociativo a la derecha.
- (+) Función de argumento tipo Int que devuelve una función tipo: Int->Int.
- HASKELL: FUNCIONES SOBRE NÚMEROS
  Para números reales las operaciones primitivas son:
```
  sqrt la función raíz cuadrada
  sin  la función seno
  log  la función logaritmo natural
  exp  la función exponente (e-elevado-a)
```
  Funciones que convierten enteros en números reales y viceversa:
```
  fromInteger entero a numero real

  round redondear un numero real a un entero
```
- HASKELL: FUNCIONES BOOLEANAS
```
   < (menor que),  
   > (mayor que), 
   <= (menor o igual que), 
   >= (mayor o igual que), 
   == (igual a) y 
   /= (distinto de).
```
  El operador < comprueba si un numero es menor que otro numero.
  El resultado es la constante True (si es menor) o la constante False (si no):
```
  Ej.1:
       Prelude>1<2
       True

  Ej.2:
       Prelude> 2<1
       False
```
- HASKELL: FUNCIONES SOBRE LISTAS
  - Lengtd : determina el tamaño de una lista,
  - sum :calcula la suma de los números en la lista,
  - ++ :concatena dos listas en una sola,
  - null : función booleana que comprueba si la lista esta vacía (lista sin elementos)
  - take :tiene dos parámetros: un numero y una lista.
  - - Si el numero es n, el resultado es una lista con los primeros n elementos de la lista.
  - reverse : Pone los elementos en orden inverso.
  - sort : Ordena los elementos de menor a mayor.
HASKELL: TIPOS
El sistema de tipos es utilizado para detectar errores en expresiones y definiciones de función.
Cada tipo tiene asociadas un conjunto de operaciones que no tienen significado para otros tipos,
Ejemplo, se puede aplicar la función (+) entre enteros pero no entre caracteres o funciones.
Una propiedad de Haskell: Es posible asociar un único tipo a toda expresión bien formada.
Esta propiedad hace que el Haskell sea un lenguaje fuertemente tipado.
Cualquier expresión que no se asociarse a un tipo es rechazada como incorrecta antes de la evaluación.
El análisis tiene dos fases:
- Análisis sintáctico: Verifica la corrección sintáctica de expresiones.
- Análisis de tipo: Verifica que las expresiones tienen un tipo correcto.
Información de tipo
Además se puede incluir información de tipo con una expresión:
A : : B
para indicar al sistema que A es de tipo B.
Por Ej.: cuadrado:: Int -> Int
Dice que la función cuadrado es del tipo "función que toma un entero y devuelve un entero".
cuadrado x = x * x
TIPOS PREDEFINIDOS
Los tipos predefinidos de Haskell son:
I - Tipos básicos, cuyos valores se toman como primitivos.
II - Tipos compuestos.
I.- TIPOS BÁSICOS DE DATOS
Deben escribirse con mayúsculas:
- Int [Int]
- Float [Float]
- Bool [Bool]
- Char [Char]
I.a - ENTEROS
Tipo "Int": Incluyen enteros positivos y negativos, como: -273, el 0 ó el 383.
El rango de los enteros utilizables está restringido.
Puede usar el tipo Integer: Enteros sin límites superior ni inferior.
prelude Incluye operadores y funciones que manipulan enteros:
- (+): Suma,
- (*): Multiplicación,
- (-): Substracción,
- (^): Potenciación, etc.
I.b - FLOTANTES
Float: Representa fraccionarios o cantidades muy largas o muy pequeñas.
Un valor numérico es un flotante si:
- Incluye un punto en su representación
- Cuando es demasiado grande para ser representado por un entero.
Notación científica: Ejemplo 1.0e3 equivale a 1000.0, mientras que 5.0e-2 equivale a 0.05.
Prelude: Incluye para flotantes: pi, exp, log, sqrt, sin, cos, tan, asin, acos, atan, etc.
I.c - CARACTERES
Char: Representa caracteres individuales. Ejemplo: 'a', '0', '.' y 'Z'.
Algunos caracteres especiales deben ser introducidos utilizando un código de escape;
cada uno de éstos comienza con el caracter de barra invertida (/) ,
seguido de uno o más caracteres que seleccionan el caracter requerido.
Ejemplo:
```
		   '//' barra invertida
		
		   '/'' comilla simple
		
		   '/"' comilla doble
		   
		   '/n' salto de línea
		   etc.
```
II.- TIPOS COMPUESTOS:
Se construyen utilizando otros tipos, por ejemplo, listas, funciones y tuplas.
HASKELL: LISTAS
[a] representa el tipo de listas cuyos elementos son valores de tipo a.
Puede escribirse como, Lista:
-| Vacía: mediante [].
-| No vacías:
- - Enunciando explícitamente sus elementos (por ejemplo, [1,3,10]) o
- - Poniendo un elemento al principio de otra lista con el operador (:).
Son equivalentes: [1,3,10] = 1:[3,10] = 1:(3:[10]) = 1:(3:(10:[]))
(:) Es asociativo a la derecha, así: 1:3:10:[] equivale a (1:(3:(10:[])))
Una lista cuyo primer elemento es 1, el segundo 3 y el último 10.
Prelude incluye un amplio conjunto de funciones de manejo de listas.
Por Ej.: lengtd xs devuelve el número de elementos de xs
```
   Prelude>lengtd [1,3,10]
  
   3
```
Notar que todos los elementos de una lista deben ser del mismo tipo.
La expresión ['a',2,False] no está permitida en Haskell
HASKELL: CADENAS
Las cadenas son:
- Secuencias de caracteres encerradas entre comillas dobles.
- Lista de caracteres y el tipo String es abreviación de [Char].
Los códigos de escape pueden utilizarse para cadenas. Ejemplo:
```
    Prelude>"hola" 
    
    hola
```
Prelude para listas pueden utilizarse con cadenas.
Ejemplo:
```
		   Prelude> lengtd "Hola"
		   4
		
		   Prelude> "Hola, " ++ "amigo"
		   Hola, amigo
```
HASKELL: TUPLAS
Los elementos de una tupla, cuyo tamaño es fijo; pueden tener tipos diferentes.
Ej: Si t1, t2, ..., tn son tipos y n >= 2, entonces hay un tipo de n-tuplas escrito: (t1, t2, ..., tn) Cuyos elementos pueden ser escritos como: (x1, x2, ..., xn)
donde cada x1, x2, ..., xn tiene tipos t1,t2, ..., tn respectivamente.
Ejemplo:
```
		   (1, [2], 3) :: (Int, [Int], Int)
		
		   ('a', False) :: (Char, Bool)
		
		   ((1,2),(3,4)) :: ((Int, Int), (Int, Int))
```
Existe una tupla especial con 0 elementos denominada tipo unidad y se escribe como ().
HASKELL: INDUCCION Y RECURSIVIDAD
En la definición de una función se pueden usar:
- Las funciones estándar y las funciones definidas por el usuario.
- La propia función definida en su definición (definición recursiva). Ejemplo: f x = f x
La funciones recursiva tienen sentido si:
1 - El parámetro de la llamada recursiva es mas simple.
2 - Existe una definición no recursiva para un caso base.
Una definición recursiva de la función factorial es:
```
   fac n | n==0 = 1

   | n>0 = n * fac (n-1)
```
Si n==0 se puede calcular el resultado directamente (sin recursión).
En el caso n > 0 existe una llamada recursiva, es decir fac (n-1).
El parámetro de esta llamada (n-1) es menor que n.
Otra manera es usando patrones:
```
   fac 0 = 1
   
   fac (n+1) = (n+1) * fac n
```
Usar patrones tiene relación con la tradición matemática del usar inducción.
Ejemplo:
Definición matemática de función potencia es usada directamente como función
```
   x ^ 0 = 1

   x ^ (n+1) = x * x^n
```
Las funciones sobre listas también pueden ser recursivas.
Una lista es ‘menor’ que otra si tiene menos elementos. Ejemplo:
función suma, puede ser definida de diferentes maneras.
Una definición recursiva con expresiones booleanas es:
```
   suma lista | lista==[] = 0   
                        (Sume lista; si esta vacía de por resultado igual a cero)

   | otderwise = head lista + suma (tail lista) 
                        (sino suma la cabeza de lista más la suma de la cola)
```
También es posible obtener una version inductiva (usando patrones):
```
   suma [] = 0

   suma (cabeza:cola) = cabeza + suma cola
```
La versión recursiva de suma necesita funciones head y tail para distinguir las diferentes partes en lista.
PATRONES
- HASKELL: DEFINICIÓN POR ANÁLISIS DE PATRONES:
  Parámetros formales son los parámetros de una función en la definición de la misma. Ejemplo
```
   x e y en
   
   f x y = x * y
```
  En una llamada a la función se dan parámetros actuales a la función. Ejemplo: f 17 (1+g 6)
  -| 17 es el parámetro actual que corresponde a x,
  -| (1+g 6) es el parámetro actual que corresponde a y.
  -| Los parámetros actuales se sustituyen en lugares de parámetros formales cuando se llama a una función.
  -| El resultado del anterior ejemplo es por tanto 17*(1+g 6).
  Por tanto, los parámetros actuales son expresiones. Los parámetros formales eran hasta ahora solamente nombres.
- HASKELL: ENCAJE DE PATRONES SIMPLE:
  Declaración de una función f está formada por un conjunto de ecuaciones con el formato: f < pat1> < pat2> . . . < patn> = < expresion>
  Si f fuese un operador sería: < pat1> f < pat2> = < expresion>
  Donde cada una de las expresiones < pat1> < pat2> . . . < patn> es un argumento de función, denominado patrón.
  El número n de argumentos se denomina paridad.
  Si la función se define con más de una ecuación, se evaluan una o más argumentos de la función para determinar cuál ecuacion aplicar.
  Este proceso se denomina encaje de patrones. En los ejemplos anteriores se utilizó el patrón más simple: una variable.
  Ej: En la definición de factorial: fact n = product [1..n]
  Si se desea evaluar la expresión "fact 6" es necesario:
  - Encajar la expresión "6" con el patrón "n" y
  - Luego evaluar la expresión obtenida a partir de "product [1..n]" substituyendo la "n" con el "6".
- HASKELL: OTROS TIPOS ÚTILES:
  - ANÓNIMOS:
    Se representan por el caracter (_) y encajan con cualquier valor, pero no es posible referirse posteriormente a dicho valor.
    Ejemplo
```
    cabeza (x:_) = x
    
    cola (_:xs) = xs
```
  - HASKELL: PATRONES CON NOMBRE:
    Para poder referirnos al valor que está encajando, por ejemplo, en lugar de definir f como: f (x:xs) = x:x:xs
    Podría darse un nombre a x:xs mediante un patrón con nombre: f p@(x:xs) = x:p
  - PATRONES n+k :
    Encajan con un valor entero mayor o igual que k.
    El valor referido por la variable n es el valor encajado menos k. Ejemplo
```
   x ^ 0 = 1
   
   x ^ (n+1) = x * (x ^ n)
```
HASKELL: FUNCIONES DE ORDEN SUPERIOR SOBRE LISTAS:
Las funciones pueden ser más flexibles utilizando funciones como parámetros.
Ej: map, filter y foldr
a) map:
Función de orden superior basada en el principio general ‘recorrer todos los elementos de una lista’.
La función parámetro de map se aplica a cada elemento de la lista.
La función map aplica su parámetro función a todos los elementos de una lista.
Ejemplo: xs = [ 1 , 2 , 3 , 4 , 5 ]
```
      Ejemplo: Prelude>map (1+) [1..10]
      
      [2,3,4,5,6,7,8,9,10,11]      
```
b) filter: (filtro).
Devuelve los elementos de una lista que cumplen alguna condición.
Esta condición se da a la función filter en forma de una función booleana. Ejemplo: xs = [ 1 , 2 , 3 , 4 , 5 ]
```
     Ejemplo: Prelude> filter even [1..10]

     [2, 4, 6, 8, 10]
```
c) foldr:
‘pliega’ la lista al valor colocando un operador, entre los elementos de la lista.
La función empieza por la derecha con el valor inicial (el otro parámetro).
Existe también una función foldl, que empieza por la izquierda.
foldr inserta un operador entre todos los elementos de una lista, empezando a la derecha con un valor dado:
xs = [ 1 , 2 , 3 , 4 , 5 ]

Paradigma
Hay hombres que de su ciencia
tienen la cabeza llena
Hay sabios de todas mentas
Mas digo sin ser muy ducho
Que es mejor que aprender mucho
El aprender cosas buenas..!!
José Hernández

Paradigmas I M P R E S O S:
Lenguajes	Gramáticas	Autómatas	Series
Laplace	Ecuación	Operador	Compilador

Te espero en: wilocarpio@gmail.com

Esta page está en: www.wilocarpio.com

11/11/2018