PUNTO 1

1) La función recibe algo que le llama pivote que debe ser ordenable o comparable, con el que quiere comparar a los elementos de la lista luego de aplicarles los operadores (que son 3 y tiene ahí en la otra lista), me devuelve una lista de listas en otras palabras con aquellos elementos que cumplían esa condición.
particion :: (Eq a, Ord a) => a -> [a] -> [[a]] obviamente acá a puede ser una lista también (las listas son ordenables y comparables)

2) No es necesario porque estamos aplicando parcialmente filtrarMultiples (la conversión eta me permite hacer esta reducción igual). Haskell entiende (porque tiene inferencia de tipos automática) que según nuestra implementación de filtrarMultiples le está faltando un parámetro. También entra en juego la currificación porque estamos armando una nueva función que recibe sólo un parámetro.

3) a) rompe porque [4] no es un elemento de la lista que le paso
b) funciona
c) rompe porque cuando quiere filtrar los mayores que 3 no deja de hacerlo nunca
d) estamos armando una nueva función que recibe un sólo parámetro. es currificar.
nota: si bien cuando lo prueben en el winghci les va a tirar un error, creo que se puede configurar para que no lo tire no me acuerdo bien igual si hacen :t particion 10 ahí les va a decir que es un funcion que espera 1 parámetro (una lista) y devuelve una lista de listas. obviamente no puse eso en el final porque son boludeces de la consola de haskell (?)
4) tenes composición del lambda con la aplicación del pivote a los operadores, hay menos repetición de código, hay expresiones lambda

PUNTO 2

1) el problema que tenemos acá es que contrajo no nos permite hacer una sola consulta, porque depende de la enfermedad tiene un parámetro de más o de menos entonces ¿? (cero polimorfismo). si hago dos consultas sí me va a devolver lo que quiera pero obvio tengo que saber que una tiene menos parámetros que la otra, en fin es horrible
2) tieneMalaSuerte(Persona):- esPersona(Persona), forall(contrajo(Persona,_,Enfermedad), esPeligrosa(Enfermedad)).

Lo que hice entonces fue hacer nuevos predicados para que haya polimorfismo y todos contentos. Primero que cambié como se modela contrajo

contrajo(Persona,Anio,Enfermedad).

tengo nuevos functores:

bacteriana(Nombre,Resistencia).
viral(Nombre,TardaEnDesaparecer,CelulasQueAfecta).
parasitaria(Nombre,SectorQueAfecta).

esPeligrosa(bacteriana(_,Resistencia)):- Resistencia > 5.
esPeligrosa(viral(_,TardaEnDesaparecer,_)):- TardaEnDesaparecer > 10.
esPeligrosa(viral(_,_,CelulasQueAfecta)):- CelulasQueAfecta > 1000000.

b) aprovechamos el orden superior del forall para poder ser más declarativos al resolver lo que nos pide el requerimiento. también tenemos polimorfismo que lo aprovecha tieneMalaSuerte al no tener que preguntar por cada tipo de enfermedad.

c) es inversible tieneMalaSuerte(Persona) porque llega ligada persona antes del forall, y se fija para CADA UNA si se cumple que todas las que ocntrajo fueron peligrosas.
si no estaba esa persona ligada el motor entiende que para todas las personas todas las enfermedades que contrajeron eran peligrosas y no es lo que queremos.

esPeligrosa(Enfermedad) no es inversible porque hay variables anónimas y no sabe que hacer prolog

3) #Persona vi: nombre, edad, enfermedades
>> tieneMalaSuerte
^ enfermedades allSatisfy: [:enfermedad | enfermedad esPeligrosa].

# Enfermedad -> clase abstracta vi: anio
# Bacteriana hereda de Enfermedad vi: resistencia
>> esPeligrosa
^ resisencia > 5.

# Viral hereda de Enfermedad
>> esPeligrosa
^ tardaEnDesaparecer > 10 or: [celulasQueAfecta > 1000000].

# Parasitaria hereda de Enfermedad
>> esPeligrosa
^ sector = 'interna'

4) tenemos polimorfismo, abstraccion, delegacion, en vez de pattern matching tenemos herencia en objetos, las relaciones de logico en objetos se implementan con una coleccion de enfemredades, en objetos poemos borrar o agregar enfermedades (asignacion destructiva) mientras que en lógico tengo que borrar o agregar un hecho, etc

5) cambie bastante a como estaba antes

#Enfermedad vi: anio, tipo -> es abstracta

# Infecciosa hereda de Enfermedad
>> esPeligrosa: persona // lo redefino a este metodo
^ persona edad between: 3 and: 80
(tambien podia hacer metodos en persona que me digan esBebe y esAnciano, era mas declarativo y expresivo, yo aclaré eso)

# NoInfecciosa hereda de Enfermedad
>> esPeligrosa: persona
^ tipo esPeligrosa: persona


#Tipo es una interface donde todos deben entender esPeligrosa: persona, dejo el codigo como estaba antes. Las que implementan esta interface son Bacteriana Viral y Parasitaria.

b) agregar un nuevo tipo de enfermedad es agregar una nueva clase que implemente el metodo esPeligrosa: persona
una nueva categoria es agregarle una subclase a Enfermedad y redefinir su comportamiento

c) se aplicó polimorfismo entre las enfermedades, Persona aprovecha eso en tieneMalaSuerte. También se aplicaron las interfaces y la herencia para reutilizar comportamiento.