Paradigmas de Programación

Introducción a la materia
1er cuatrimestre de 2024
Departamento de Computación
Facultad de Ciencias Exactas y Naturales
Universidad de Buenos Aires

1
Presentación de la materia

Introducción a la programación funcional

2
Docentes

Profesores Ayudantes de segunda

I Pablo Barenbaum I Lucas Di Salvo
I Alejandro Dı́az-Caro I Sebastián Felgueras
Jefes de trabajos prácticos I Fernando Frassia
I Christian Cossio Mercado I Damián Huaier
I Daniela Marottoli I Juan Pablo Miceli
I Gabriela Steren I Rafael Romani
Ayudantes de primera I Daniel Wappner
I Gonzalo Pablo Fernández
(“Perla”)
I Malena Ivnisky
I Edgardo Zoppi

3
Dı́as y horarios de cursada

I Martes de 17:00 a 22:00 generalmente práctica

I Viernes de 17:00 a 22:00 generalmente teórica

4
Modalidad de evaluación

Parciales
I Primer parcial martes 21 de mayo
I Segundo parcial viernes 5 de julio
I Recuperatorio del primer parcial martes 16 de julio
I Recuperatorio del segundo parcial martes 23 de julio

Trabajos prácticos
I TP 1 (con su recuperatorio)
I TP 2 (con su recuperatorio)

Los TPs son en grupos de 4 integrantes.

Examen final
(La materia no es promocionable).

5
Vı́as de comunicación

Docentes → alumnxs
Avisos a través del campus.

Alumnxs → docentes
Lista de correo: [email protected]
(para consultas administrativas)

Discusión entre estudiantes fuera del horario de la materia

Servidor de Discord: https://tinyurl.com/plpdiscord
(con eventual participación de docentes)

Página web de la materia

https://campus.exactas.uba.ar/course/view.php?id=4170

6
Contenidos

Tres aspectos de los lenguajes de programación:

programación

semántica implementación

7
Cronograma

Programación funcional 1,5 semanas

Razonamiento ecuacional 1 semana
Lógica proposicional 1 semana
Cálculo-λ 2 semanas
Interpretación y compilación 2 semanas
(Repaso)
Primer parcial
Lógica de primer orden 1 semana
Resolución 1 semana
Programación lógica 1,5 semanas
Programación orientada a objetos 1 semana
(Repaso)
Segundo parcial

8
Motivación: programación
Los lenguajes de programación tienen distintas caracterı́sticas.
I Etiquetado dinámico vs. tipado estático.
I Administración manual vs. automática de memoria.
I Funciones de primer orden vs. funciones de orden superior.
I Mutabilidad vs. inmutabilidad.
I Alcance dinámico vs. estático.
I Resolución de nombres temprana vs. tardı́a.
I Inferencia de tipos.
I Determinismo vs. no determinismo.
I Pasaje de parámetros por copia o por referencia.
I Evaluación estricta (por valor) o diferida (por necesidad).
I Tipos de datos inductivos, co-inductivos, GADTs, familias dependientes.
I Pattern matching, unificación.
I Polimorfismo paramétrico.
I Subclasificación, polimorfismo de subtipos, herencia simple vs. múltiple.
I Estructuras de control no local.
I ...
9
Motivación: programación
Distintas caracterı́sticas permiten abordar un mismo problema de
distintas maneras.

CMXXIV 924
+ MCXLI + 1141

C = {(x, y ) | x 2 + y 2 = r 2 } C = {(r sin θ, r cos θ) | 0 ≤ θ < 2π}

r := 1
while n > 0 {
r := r * n foldl (*) 1 [1..n]
n := n - 1
}

10
Motivación: semántica

Dependemos del software en aplicaciones crı́ticas.

I Telecomunicaciones.
I Procesos industriales.
I Reactores nucleares.
I Equipamiento médico.
I Previsión meteorológica.
I Aeronáutica.
I Vehı́culos autónomos.
I Transacciones monetarias.
I Análisis de datos en ciencia o toma de decisiones.
I ...
Las fallas cuestan recursos monetarios y vidas humanas.

11
Motivación: semántica

¿Podemos confiar en que un programa hace lo que queremos?

¿Y si el programa está escrito por el enemigo?
¿Y si el programa está escrito por un gran modelo de lenguaje?

Objetivo
I Probar teoremas sobre el comportamiento de los programas.
I ¿Cómo darle significado matemático a los programas?
I En AED vimos una manera de hacerlo (triplas de Hoare).
I En PLP veremos otras maneras de dar semántica.

12
Motivación: implementación

Una computadora fı́sica ejecuta programas escritos en un lenguaje.

(El “código máquina”).

¿Cómo es capaz de ejecutar programas escritos en otros lenguajes?

I Interpretación (o evaluación).
I Chequeo e inferencia de tipos.
I Compilación (traducción de un lenguaje a otro).

13
Bibliografı́a (no exhaustiva)
Lógica proposicional y de primer orden
Logic and Structure
D. van Dalen.
Semántica y fundamentos de la implementación
Introduction to the Theory of Programming Languages
J.-J. Lévy, G. Dowek. Springer, 2010.
Types and Programming Languages
B. Pierce. The MIT Press, 2002.
Programación funcional
Introduction to Functional Programming using Haskell
R. Bird. Prentice Hall, 1998.
Programación lógica
Logic Programming with Prolog
M. Bramer. Springer-Verlag, 2013.
Programación orientada a objetos
Smalltalk-80 the Language and its Implementation
A. Goldberg, D. Robson. Addison-Wesley, 1983.
14
Presentación de la materia

Introducción a la programación funcional

15
Programación funcional
Un problema central en computación es el de procesar información:
pregunta respuesta
O
modelado interpretación
 cómputo
programa + entrada / salida

La programación funcional consiste en definir funciones y aplicarlas

para procesar información.
Las “funciones” son verdaderamente funciones (parciales):
I Aplicar una función no tiene efectos secundarios.
I A una misma entrada corresponde siempre la misma salida.
I Las estructuras de datos son inmutables.
Las funciones son datos como cualquier otro:
I Se pueden pasar como parámetros.
I Se pueden devolver como resultados.
I Pueden formar parte de estructuras de datos.
(Ej. árbol binario en cuyos nodos hay funciones). 16
Programación funcional

Un programa funcional está dado por un conjunto de ecuaciones:

Ejemplo
longitud [] = 0
longitud (x : xs) = 1 + longitud xs
longitud [10, 20, 30]
≡ longitud (10 : (20 : (30 : [])))
= 1 + longitud (20 : (30 : []))
= 1 + (1 + (longitud (30 : [])))
= 1 + (1 + (1 + longitud []))
= 1 + (1 + (1 + 0))
= 1 + (1 + 1)
= 1 + 2
= 3

17
Expresiones
Las expresiones son secuencias de sı́mbolos que sirven para
representar datos, funciones y funciones aplicadas a los datos.
(Recordemos: las funciones también son datos).

Una expresión puede ser:

1. Un constructor:
True False [] (:) 0 1 2 ...
2. Una variable:
longitud ordenar x xs (+) (*) ...
3. La aplicación de una expresión a otra:
ordenar lista
not True
not (not True)
(+) 1
((+) 1) (alCuadrado 5)
4. También hay expresiones de otras formas, como veremos.
Las tres de arriba son las fundamentales. 18
Expresiones

Convenimos en que la aplicación es asociativa a izquierda:

f x y ≡ (f x) y ≡ f (x y)
Z

f a b c d ≡ (((f a) b) c) d

Ejemplo

[1, 2]
≡ 1 : [2]
≡ (:) 1 [2]
≡ ((:) 1) [2]
≡ ((:) 1) (2 : [])
≡ ((:) 1) ((:) 2 [])
≡ ((:) 1) (((:) 2) [])

19
Expresiones

Ejemplo
sumarUno = (+) 1
sumarUno (sumarUno 5)
= ((+) 1) (sumarUno 5)
≡ 1 + sumarUno 5
= 1 + ((+) 1) 5
≡ 1 + (1 + 5)
= 1 + 6
= 7

20
Tipos

Hay secuencias de sı́mbolos que no son expresiones bien formadas.

Ejemplo

1,,2 )f x(

Hay expresiones que están bien formadas pero no tienen sentido.

Ejemplo
True + 1
0 1
[[], (+)]

21
Tipos

Un tipo es una especificación del invariante de un dato o de una

función.
Ejemplo

99 :: Int
not :: Bool -> Bool
not True :: Bool
(+) :: Int -> (Int -> Int)
(+) 1 :: Int -> Int
((+) 1) 2 :: Int

El tipo de una función expresa un contrato.

22
Tipos

Condiciones de tipado
Para que un programa esté bien tipado:
1. Todas las expresiones deben tener tipo.
2. Cada variable se debe usar siempre con un mismo tipo.
3. Los dos lados de una ecuación deben tener el mismo tipo.
4. El argumento de una función debe tener el tipo del dominio.
5. El resultado de una función debe tener el tipo del codominio.

f :: a -> b x :: a
f x :: b
Sólo tienen sentido los programas bien tipados.

No es necesario escribir explı́citamente los tipos. (Inferencia).

23
Tipos

Convenimos en que “->” es asociativo a derecha:

a -> b -> c ≡ a -> (b -> c) ≡ (a -> b) -> c

Z

a -> b -> c -> d ≡ a -> (b -> (c -> d))

Ejemplo
suma4 :: Int -> Int -> Int -> Int -> Int
suma4 a b c d = a + b + c + d
Se puede pensar ası́:
suma4 :: Int -> (Int -> (Int -> (Int -> Int)))
(((suma4 a) b) c) d = a + b + c + d

24
Polimorfismo
Hay expresiones que tienen más de un tipo.
Usamos variables de tipo a, b, c para denotar tipos desconocidos:

id :: a -> a
[] :: [a]
(:) :: a -> [a] -> [a]
fst :: (a, b) -> a
snd :: (a, b) -> b

Ejemplo
flip f x y = f y x
¿Qué tipo tiene flip?

flip (:) [2, 3] 1

= (:) 1 [2, 3]
≡ 1 : [2, 3]
= [1, 2, 3]
25
Modelo de cómputo

Dada una expresión, se computa su valor usando las ecuaciones:

Expresiones Valores

3 + 2
5
5
(+)
+
id (+)

Hay expresiones bien tipadas que no tienen valor. Ej.: 1 / 0.

Decimos que dichas expresiones se indefinen o que tienen valor ⊥.

26
Modelo de cómputo

Un programa funcional está dado por un conjunto de ecuaciones.

Más precisamente, por un conjunto de ecuaciones orientadas.

Una ecuación e1 = e2 se interpreta desde dos puntos de vista:

1. Punto de vista denotacional.
Declara que e1 y e2 tienen el mismo significado.
2. Punto de vista operacional.
Computar el valor de e1 se reduce a computar el valor de e2.

27
Modelo de cómputo
El lado izquierdo de una ecuación no es una expresión arbitraria.
Debe ser una función aplicada a patrones.

Un patrón puede ser:

1. Una variable.
2. Un comodı́n _.
3. Un constructor aplicado a patrones.
El lado izquierdo no debe contener variables repetidas.

Ejemplo
¿Cuáles ecuaciones están sintácticamente bien formadas?
sumaPrimeros (x : y : z : _) = x + y + z
predecesor (n + 1) = n
iguales x x = True

28
Modelo de cómputo
Evaluar una expresión consiste en:
1. Buscar la subexpresión más externa que coincida con el lado
izquierdo de una ecuación.
2. Reemplazar la subexpresión que coincide con el lado izquierdo
de la ecuación por la expresión correspondiente al lado
derecho.
3. Continuar evaluando la expresión resultante.

La evaluación se detiene cuando se da uno de los siguientes casos:

1. La expresión es un constructor o un constructor aplicado.
True (:) 1 [1, 2, 3]
2. La expresión es una función parcialmente aplicada.
(+) (+) 5
3. Se alcanza un estado de error.
Un estado de error es una expresión que no coincide con las
ecuaciones que definen a la función aplicada.
29
Modelo de cómputo

Ejemplo: resultado — constructor

tail :: [a] -> [a]
tail (_ : xs) = xs
tail (tail [1, 2, 3]) tail [2, 3] [3]

Ejemplo: resultado — función parcialmente aplicada

const :: a -> b -> a
const x y = x

const (const 1) 2 const 1

30
Modelo de cómputo
Ejemplo: indefinición — error
head :: [a] -> a
head (x : _) = x
head (head [[], [1], [1, 1]]) head []
⊥

Ejemplo: indefinición — no terminación

loop :: Int -> a
loop n = loop (n + 1)
loop 0 loop (1 + 0)
loop (1 + (1 + 0))
loop (1 + (1 + (1 + 0)))
...

31
Modelo de cómputo

Ejemplo: evaluación no estricta

indefinido :: Int
indefinido = indefinido
head (tail [indefinido, 1, indefinido])
head [1, indefinido]
1

32
Modelo de cómputo
Ejemplo: listas infinitas
desde :: Int -> [Int]
desde n = n : desde (n + 1)

desde 0
0 : desde 1
0 : (1 : desde 2)
0 : (1 : (2 : desde 3)) ...

head (tail (desde 0))

head (tail (0 : desde 1))
head (desde 1)
head (1 : desde 2)
1

33
Modelo de cómputo

Nota. En Haskell, el orden de las ecuaciones es relevante.

Si hay varias ecuaciones que coinciden se usa siempre la primera.
Ejemplo
esCorta (_ : _ : _) = False
esCorta _ = True
esCorta [] True
esCorta [1] True
esCorta [1, 2] False

34
Funciones de orden superior

Definamos la composición de funciones (“g . f”).

(.) :: (b -> c) -> (a -> b) -> a -> c
(g . f) x = g (f x)
Otra forma de definirla (usando la notación “lambda”):
(.) :: (b -> c) -> (a -> b) -> a -> c
g . f = \ x -> g (f x)

35
Funciones de orden superior
¿Qué tienen en común las siguientes funciones?
dobleL :: [Float] -> [Float]
dobleL [] = []
dobleL (x : xs) = x * 2 : dobleL xs

esParL :: [Int] -> [Bool]

esParL [] = []
esParL (x : xs) = x ‘mod‘ 2 == 0 : esParL xs

longitudL :: [[a]] -> [Int]

longitudL [] = []
longitudL (x : xs) = length x : longitudL xs
Todas ellas siguen el esquema:
g [] = []
g (x : xs) = f x : g xs

36
Funciones de orden superior

¿Cómo se puede abstraer el esquema?

map :: (a -> b) -> [a] -> [b]
map f [] = []
map f (x : xs) = f x : map f xs

dobleL xs = map (\ x -> x * 2) xs

esParL xs = map (\ x -> x ‘mod‘ 2 == 0) xs
longitudL xs = map length xs
Otra manera:
dobleL = map (* 2)
esParL = map ((== 0) . (‘mod‘ 2))
longitudL = map length

37
Funciones de orden superior
¿Qué relación hay entre las siguientes funciones?
suma :: Int -> Int -> Int
suma x y = x + y

suma’ :: (Int, Int) -> Int

suma’ (x, y) = x + y
Están relacionadas del siguiente modo:
curry :: ((a, b) -> c) -> a -> b -> c
curry f x y = f (x, y)

uncurry :: (a -> b -> c) -> (a, b) -> c

uncurry f (x, y) = f x y
Dentro de algunas clases, veremos que se puede demostrar:

suma = curry suma’ suma’ = uncurry suma

38
Funciones de orden superior
¿Qué relación hay entre las siguientes funciones?
negativos :: [Int] -> [Int]
negativos [] = []
negativos (x : xs) = if x < 0
then x : negativos xs
else negativos xs
noVacias :: [[a]] -> [[a]]
noVacias [] = []
noVacias (x : xs) = if not (null x)
then x : noVacias xs
else noVacias xs
Ambas siguen el esquema:
g [] = []
g (x : xs) = if p x
then x : g xs
else g xs
39
Funciones de orden superior

¿Cómo se puede abstraer el esquema?

filter :: (a -> Bool) -> [a] -> [a]
filter p [] = []
filter p (x : xs) = if p x
then x : filter p xs
else filter p xs

negativos = filter (< 0)

noVacias = filter (not . null)

40
Ejercicio
merge :: (a -> a -> Bool) -> [a] -> [a] -> [a]
mergesort :: (a -> a -> Bool) -> [a] -> [a]
El primer parámetro es una función que determina una relación de
orden total entre los elementos de tipo a.

41
¿ ¿ ¿ ¿¿ ¿¿ ¿ ¿? ? ? ? ? ? ? ? ?

42
Comentarios: tipos
Ojo. Dijimos:

“Cada variable se debe usar siempre con un mismo tipo.”

¿Está bien tipado el siguiente programa?

sucesor :: Int -> Int
sucesor x = x + 1

opuesto :: Bool -> Bool

opuesto x = not x
Sı́. Hay dos “x” con distinto tipo pero son variables distintas.
El programa se podrı́a reescribir ası́:
sucesor x = x + 1
opuesto y = not y

43