Commit 288242e2 authored by autopawn's avatar autopawn

Updated up to lecture 14.

parent 5aa75f89
node_modules
pl_lectures_old
......@@ -36,7 +36,7 @@ Programming Languages
![center h:300](figures/two_paradigms.png)
:arrow_right: Lisp (1058) was based on **lambda calculus**.
:arrow_right: Lisp (1958) was based on **lambda calculus**.
---
......@@ -157,13 +157,13 @@ $\Rightarrow$ This allows almost free **parallelization**.
:arrow_forward: Functional quicksort:
$$
\text{qsort} \quad : \quad [\mathbb{N}] \rightarrow [\mathbb{N}]
\text{qsort} \quad : \quad [\mathbb{Z}] \rightarrow [\mathbb{Z}]
$$
$$
\text{qsort}(\mathbf{x}) = \begin{cases}
[] &, n = 0 \\
\text{qsort}(\mathbf{x}_\text{left}) {+}{+} [x_0] {+}{+} \text{qsort}(\mathbf{x}_\text{right}) &,n \geq 1
\text{qsort}(\mathbf{x}_\text{left}) {+}{+} [x_0] {+}{+} \text{qsort}(\mathbf{x}_\text{right}) &,n \geq 1
\end{cases}
$$
......@@ -172,10 +172,10 @@ $$
\mathbf{x} = [x_0,x_1,...,x_{n-1}]
$$
$$
\mathbf{x}_\text{right} = [x_i : \, x_i > x_0,\, x_i \in [x_1,x_2,...,x_{n-1}]]
\mathbf{x}_\text{right} = [x_i : \, x_i > x_0,\, x_i \in [x_1,x_2,...,x_{n-1}]]
$$
$$
\mathbf{x}_\text{left} = [x_i : \, x_i \leq x_0,\, x_i \in [x_1,x_2,...,x_{n-1}]]
\mathbf{x}_\text{left} = [x_i : \, x_i \leq x_0,\, x_i \in [x_1,x_2,...,x_{n-1}]]
$$
---
......@@ -183,9 +183,9 @@ $$
:arrow_forward: Functional quicksort (now in code):
```haskell
qsort :: [Int] -> [Int]
qsort :: [Int] -> [Int]
qsort [] = []
qsort (x0:xs) = qsort xsLeft ++ [x0] ++ qsort xsRight
qsort (x0:xs) = qsort xsLeft ++ [x0] ++ qsort xsRight
where
xsLeft = [a | a <- xs, a <= x0]
xsRight = [a | a <- xs, a > x0]
......
......@@ -23,14 +23,19 @@ Lenguajes de Programación
Necesitaremos:
* The Glasgow Haskell Compiler:
```bash
$ dnf install ghc
```
* Cabal: El *instalador de paquetes* de Haskell.
```bash
$ dnf install cabal-install
```
* **The Glasgow Haskell Compiler** (GHC):
<!-- ```bash
$ sudo dnf install ghc
``` -->
* **Cabal**: El *instalador de paquetes* de Haskell.
<!-- ```bash
$ sudo dnf install cabal-install
``` -->
Instalar todo en Ubuntu:
```
$ sudo apt-get install haskell-platform
```
:link: [Página de descargas de haskell.org](https://www.haskell.org/downloads)
......@@ -43,7 +48,7 @@ Necesitaremos:
* **Puramente funcional**.
* Tiene **tipificado fuerte estático**, pero **inferencia de tipo**.
* Permite **programación genérica**.
* Tiene **evaluación no estricta**.
* Tiene **evaluación no estricta** y **lazyness**.
* Adicionalmente, usa **pattern matching**.
---
......@@ -104,31 +109,32 @@ Pensemos en un **sort**:
:arrow_right: **Haskell** aprovecha la programación genérica para tener un **sort** que funciona con cualquier tipo `a`, siempre que sea de la *clase* `Ord` (pues necesita que el operador de comparación esté definido para ese tipo):
```haskell
import Data.List (sort)
sort :: Ord a => [a] -> [a]
```
:arrow_right: También podemos usar `sortBy` y usando nuestra propia función de comparación
```haskell
import Data.List (sortBy)
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
```
---
# Non-strictness
:arrow_right: Las expresiones **no** se evalúan desde las más **internas** como en un lenguaje imperativo, sino que desde las más **externas**.
:arrow_right: A partir de ese punto, se resuelven las más internas, **según se necesita**.
:arrow_right: A partir de ese punto, se van resolviendo expresiones más internas, **según se necesita**.
```haskell
Prelude> 6*5*(error "This is an error")*4*3*2*1
*** Exception: This is an error
Prelude> 6*5*(error "This is an error")*0*3*2*1
0
Prelude> take 4 [1, 2, 3, div 8 2, div 1 0, 6]
[1,2,3,4]
Prelude> take 5 [1, 2, 3, div 8 2, div 1 0, 6]
[1,2,3,4,*** Exception: divide by zero
```
:alien: El operador `*` multiplica de derecha a izquierda.
:alien: Si se encuentra con un $0$, no necesita seguir multiplicando, porque sabe que el resultado será $0$.
:arrow_right: En lenguajes **no estrictos** el corto-circuíto es el comportamiento por defecto, no un caso especial *programado* en el lenguaje.
---
......@@ -154,10 +160,10 @@ Prelude> 6*5*(error "This is an error")*0*3*2*1
Supongamos que `xs` es una lista con 500000 elementos.
```haskell
sum xs -- 0.16 ms
sum (take 50 xs) -- 0.00 ms
sum (sort xs) -- 2.32 ms
sum (take 50 (sort xs)) -- 0.31 ms !?
sum xs -- 0.16 s
sum (take 50 xs) -- 0.00 s
sum (sort xs) -- 2.32 s
sum (take 50 (sort xs)) -- 0.31 s !?
```
:alien: Se puede ahorrar trabajo incluso en funciones que no conocemos.
......@@ -166,6 +172,26 @@ sum (take 50 (sort xs)) -- 0.31 ms !?
---
:arrow_forward: Supongamos que queremos:
```haskell
take 5 (sort [9,3,7,12,11,1,16,5,13,8,6,15,10,4,2])
```
:arrow_forward: Se realizará el siguiente reemplazo:
```
sort [9,3,7,12,11,1,16,5,13,8,6,15,10,4,2]
sort [3,7,1,5,8,6,4,2] ++ [9] ++ sort [12,11,16,13,15,10]
```
:arrow_forward: No se evaluará `sort [12,11,16,13,15,10]` puesto que no es necesario para obtener los primeros 5 valores de la lista ordenada.
:arrow_forward: De la misma manera, habrán otros `sort` que no será necesario evaluar en niveles más produndos.
---
![center h:600px](figures/sort_tree.png)
---
## Un ejemplo de estructuras de datos infinitas
```haskell
......@@ -211,12 +237,16 @@ take' n (x:xs) = x : take' (n-1) xs
```haskell
subsets :: [a] -> [[a]]
subsets [] = [[]]
subsets (x:xs) =
subsets (x:xs) =
let sub = subsets xs
in sub ++ [x:ys | ys <- sub]
```
```haskell
*Main> subsets [1,2,3,4]
[[],[4],[3],[3,4],[2],[2,4],[2,3],[2,3,4],
[1],[1,4],[1,3],[1,3,4],[1,2],[1,2,4],[1,2,3],[1,2,3,4]]
```
---
......@@ -110,7 +110,7 @@ nombrar li = case li of
Prelude> [2,5..22]
[2,5,8,11,14,17,20]
```
---
```haskell
......@@ -127,8 +127,8 @@ Prelude> [21,42..60000000]
```haskell
ghci> [1..10]
[1,2,3,4,5,6,7,8,9,10]
ghci> ['a'..'z']
[1,2,3,4,5,6,7,8,9,10]
ghci> ['a'..'z']
"abcdefghijklmnopqrstuvwxyz"
```
......@@ -204,8 +204,8 @@ hipoten x y = let
## Binding en list comprehensions
```haskell
calcImc :: [(Float, Float)] -> [Float]
calcImc xs = [imc | (w, h) <- xs, let imc = w/h^2]
calcImc :: [(Float, Float)] -> [Float]
calcImc xs = [imc | (w, h) <- xs, let imc = w/h^2]
```
---
......@@ -213,18 +213,18 @@ calcImc xs = [imc | (w, h) <- xs, let imc = w/h^2]
## Binding `where`
```haskell
describirLista :: [a] -> String
describirLista xs = "La lista es " ++ what xs
describirLista :: [a] -> String
describirLista xs = "La lista es " ++ what xs
where what [] = "vacía."
what [x] = "un singleton."
what xs = "larga."
what xs = "larga."
```
Tiene más sentido utilizarlo junto con **guards**.
```haskell
tellImc :: Float -> Float -> String
tellImc peso altura
tellImc :: Float -> Float -> String
tellImc peso altura
| imc <= 18.5 = "Flaco."
| imc <= 25.0 = "Normal."
| imc <= 30.0 = "Gordo."
......@@ -273,7 +273,7 @@ tellImc peso altura
e.g. : `String` en realidad es un sinónimo para `[Char]`.
### :arrow_right: `String` [:book:](https://hackage.haskell.org/package/base-4.9.0.0/docs/Data-String.html)
Es un *type synonym* de `[Char]`, sin embargo, tiene varias funciones exclusivas.
Es un *type synonym* de `[Char]`, sin embargo, tiene varias funciones exclusivas.
---
......@@ -285,12 +285,12 @@ El más simple de todos los tipos, enumeración con sólo valor posible: `()`.
## :arrow_right: `Bool`
Enumeración con dos valores posibles: `True` y `False`.
## :arrow_right: `Ordering`
## :arrow_right: `Ordering`
Enumeración que puede tener 3 posibles valores como resultado de una comparación (`LT`,`GT` o `EQ`).
---
## :arrow_right: `Char` [:book:](http://hackage.haskell.org/package/base-4.9.1.0/docs/Data-Char.html)
## :arrow_right: `Char` [:book:](http://hackage.haskell.org/package/base-4.9.1.0/docs/Data-Char.html)
Enumeración cuyos valores representan los caracteres Unicode.
## :arrow_right: `Int` [:book:](https://hackage.haskell.org/package/base-4.7.0.1/docs/Data-Int.html)
......@@ -301,7 +301,7 @@ Número entero que puede ser infinitamente grande.
## :arrow_right: `Float` y `Double` [:book:](https://hackage.haskell.org/package/base-4.7.0.1/docs/Prelude.html#t:Float)
Números de coma flotante de precisión simple y doble.
Números de coma flotante de precisión simple y doble.
---
......@@ -430,20 +430,27 @@ elem :: (Eq a, Foldable t) => a -> t a -> Bool
# Import
:arrow_right: Para acceder a todas las funciones de estos **tipos** en la mayoría de los casos será necesario hacer un:
:arrow_right: Para importar todo un módulo, podemos hacer:
```haskell
import Data.<tipo>
import Data.Maybe
```
o, para evitar colisiones de nombres:
:warning: No podemos hacer esto con módulos que generan colisiones de nombres.
:arrow_right: Para evitar colisiones de nombres:
```haskell
import qualified Data.Set as S
```
:arrow_right: Para acceder sólo a ciertas funciones, podemos hacer:
```haskell
import qualified Data.<tipo> as <abreviación>
import Data.List (sort)
```
---
# Listas
Las listas funcionan como listas enlazadas, y en términos de complejidad debemos pensar en ellas como **pilas**, en que la parte más accesible está al frente y la más **"inaccesible"** está al fondo.
:arrow_forward: Las listas funcionan como listas enlazadas, y en términos de complejidad debemos pensar en ellas como **pilas**, en que la parte más accesible está al frente y la más **"inaccesible"** está al fondo.
## :arrow_right: Operador `cons (:)`
......@@ -454,12 +461,12 @@ pairs [] = []
pairs (x:y:rest) = (x,y) : pairs rest
```
---
## :arrow_right: Operador `++`
Concadena dos listas, tiene complejidad igual al tamaño de la lista **izquierda**.
---
## :arrow_right: Operador `!!`
Accede a una posición en particular de una lista, tiene **complejidad** igual a dicha posición.
......
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment