pde tp comentarios

type Pelicula = (String, [Int])
type Maraton = [Pelicula]

titulo :: (String, [Int]) -> String
titulo = fst

calificaciones :: (String, [Int]) -> [Int]
calificaciones = snd

cantidadCalificaciones :: Pelicula -> Int
cantidadCalificaciones = length . calificaciones
--Comentario / Correccion:
--Esto es mas que nada un comentario, si querias utilizar pattern matching podrias haber hecho:
--cantidadCalificaciones :: Pelicula -> Int
--cantidadCalificaciones (_, calificaciones) = length calificaciones
--Va lo mismo para cualquier funcion del tipo Pelicula -> Algo
--En el parcial cualquiera de las dos opciones esta bien

sumaCalificaciones :: Pelicula -> Int
sumaCalificaciones = sum . calificaciones

laMejorCalificacion :: Pelicula -> Int
laMejorCalificacion = maximum . calificaciones

laPeorCalificacion :: Pelicula -> Int
laPeorCalificacion = minimum . calificaciones

esPopular :: Pelicula -> Bool
esPopular = (>5) . cantidadCalificaciones

estaBuena :: Pelicula -> Bool
estaBuena pelicula = ((>7) . length . titulo) pelicula && (esPopular pelicula)

-- ### ERROR por el tipo de numero Int
puntaje :: Pelicula -> Int
--puntaje pelicula = (sumaCalificaciones pelicula) / (cantidadCalificaciones pelicula)

--Comentario / Correccion:
--Lo que vos hiciste en un parcial es totalmente valido, pero para hacerlo en codigo hay que hacer una cosa mas, la funcion te deberia quedar como:
--puntaje :: Pelicula -> Int
--puntaje (_, calificaciones) = promedio calificaciones

--promedio algo = fromIntegral(sum algo) / fromIntegral(length algo)

--Esto te lo digo mas que nada para que lo tengas en cuenta por si en el TP se les pide algo parecido
--Tambien como mas adelante vas a tener que sacar otro promedio, te convendria abstraer ese comportamiento para evitar repetir logica



dispersion :: Pelicula -> Int
dispersion pelicula = (laMejorCalificacion pelicula) - (laPeorCalificacion pelicula)



-- ###
-- no se me ocurrió como agregar la cola, y a la vez devolver el tipo Pelicula
--calificar :: Int -> Pelicula
calificar numero pelicula = (calificaciones pelicula) : numero

--Comentario / Correccion:
--Bien, aca podrias haber hecho algo como esto:
--calificar :: Int -> Pelicula -> Pelicula
--calificar calificacion (titulo, calificaciones) = (titulo, calificaciones : calificacion)



-- ###
-- recuerdo que habian dicho q se podia hacer con pattern matching,
-- pero es como se me ocurrió
sumaCalificacion :: Int -> Int
sumaCalificacion numero
    | numero == 9 || numero == 10 = 10
    | numero == 1 = 1
    | otherwise = numero + 2

-- Comentario / Correccion:
-- Si bien lo tuyo no esta mal, para este caso, es mas simple y mas declarativo optar por la resolucion con pattern matching, quedaria algo como:
--sumarSegunCalificacion :: Int -> Int
--sumarSegunCalificacion 1 = 1
--sumarSegunCalificacion calificacion = min 10 (calificacion + 2)
--Otra cosa que estaria bueno que tengas en cuenta es que el nombre de la funcion tiene que ser acorde con lo que va a hacer la funcion, si bien el nombre sumaCalificacion no esta mal y describe
--mas o menos el comportamiento de la funcion, lo podrias mejorar poniendo algo como sumarSegunCalificacion



-- ###
-- Entiendo que estoy devolviendo las calificaciones en vez la pelicula (que es quien
-- contiene a las calificaciones)
--manijear :: Pelicula -> Pelicula
manijear pelicula = map (sumaCalificacion) (calificaciones pelicula)

--Comentario / Correccion:
--La solucion a esto es mas o menos parecida a la de la funcion calificar, seria algo asi:
--manijear (titulo, calificaciones) = (titulo, map sumarSegunCalificacion calificaciones)



valeLaPena :: Maraton -> Bool
valeLaPena peliculas = (estaBuena (head peliculas)) && (estaBuena (last peliculas))

--Comentario / Correccion:
--Aca podrias sacar algunos parentesis, te queria asi:
--valeLaPena peliculas = estaBuena (head pelicular) && estaBuena (last peliculas)



coincideNombre :: String -> Pelicula -> Bool
coincideNombre nombre pelicula = nombre == (titulo pelicula)

pertenece :: String -> Maraton -> Bool
pertenece nombrePelicula maraton = any (coincideNombre nombrePelicula) maraton

valoracion :: Maraton -> Int
--valoracion maraton = sum (map (sumaCalificaciones) maraton)
valoracion = sum . (map (sumaCalificaciones))

--Comentario / Correccion:
--Este punto era medio confuso con lo que pedia, la resolucion seria algo asi:
--valoracion :: Maraton -> Float
--valoracion maraton = (promedio . map puntaje) maraton



dispersionMenorADos :: Maraton -> Maraton
dispersionMenorADos = filter ((<2) . dispersion)

maratonDeOscar :: Maraton -> Bool
maratonDeOscar maraton = all ((>8) . puntaje) (dispersionMenorADos maraton)
--Comentario / Correccion:
--Aca vuelvo a insistir con lo de la declaracion, si bien estas delegando parte de la solucion, sigue quedando algo de detalle algoritmico que se puede abstraer en una nueva funcion y hacer que quede
--una solucion mas "limpia", por ejemplo asi:
--maratonDeOscar :: Maraton -> Bool
--maratonDeOscar maraton = all puntajeSuperiorA8 (dispersionMenorADos maraton)

--puntajeSuperiorA8 :: Pelicula -> Bool
--puntajeSuperiorA8 pelicula = ((>8) . puntaje) pelicula



{- Ultimas Aclaraciones

Estaba bastante bien, todavia te falta aplicar un poco mas el concepto de delegar y abstraer comportamientos.
Por otro lado, veo que entendiste bastante bien el tema de la composicion, bien ahi!
Como esto no era un TP, sino un ejercicio integrador, no tiene nota :P

-}