Corrección de Matías

dave.hs

import Text.Show.Functions
import Data.Char (toLower, toUpper)
import Data.List

data Barbaro = Barbaro {nombre::String, fuerza::Int, habilidades::[String], objetos::[Objeto]} deriving (Show)
type Objeto = Barbaro -> Barbaro
type Aventura = Barbaro -> Bool

-- ejemplos de barbaro

dave = Barbaro "Dave" 100 ["tejer","escribirPoesia"] [ardilla, libroPedking]
john = Barbaro "John" 80 ["escribirPoesiaAtroz", "robar"] []
faffy = Barbaro "Faffy" 20 [] []
astro = Barbaro "Astro" 10 [] []
rick = Barbaro "Rick" 5 ["Hablarconlosanimales"] []

-- 1

espada :: Int -> Objeto
espada pesoEnKilogramosEspada barbaro = barbaro {fuerza = (fuerza barbaro)+pesoEnKilogramosEspada*2} 
-- *Main> espada 5 dave
-- Barbaro {nombre = "Dave", fuerza = 110, habilidades = ["tejer","escribirPoesia"], objetos = [<function>,<function>]}

{-
	Genial que tengas la abstracción de objeto. 
	Toma un int y devuelve un objeto / toma un int y un bárbaro y devuelve otro bárbaro
-}

amuletosMisticos :: String -> Objeto
amuletosMisticos unaHabilidad barbaro = barbaro {habilidades = (habilidades barbaro)++[unaHabilidad]}
-- *Main> amuletosMisticos "hablarConLosAnimales" dave
-- Barbaro {nombre = "Dave", fuerza = 100, habilidades = ["tejer","escribirPoesia","hablarConLosAnimales"], objetos = [<function>,<function>]}

{-
	O quizás te sirva usar el operador constructor/deconstructor de listas

	... = barbaro {habilidades = (habilidades barbaro) : unaHabilidad }	
-}

varitasDefectuosas :: Objeto
varitasDefectuosas barbaro = barbaro {habilidades = (habilidades barbaro) ++ ["magia"]} 
-- *Main> varitasDefectuosas dave
-- Barbaro {nombre = "Dave", fuerza = 100, habilidades = ["tejer","escribirPoesia","magia"], objetos = []}

{-
	Te faltó vaciar los objetos y usar el punto anterior

	... = amuletosMisticos "magia"  barbaro { objetos = [] }
-}

ardilla :: Objeto
ardilla = id
-- *Main> ardilla john
-- Barbaro {nombre = "John", fuerza = 80, habilidades = ["escribirPoesiaAtroz","robar"], objetos = []}

libroPedking :: Objeto
libroPedking = id
-- *Main Data.Char> libroPedking john 
-- Barbaro {nombre = "John", fuerza = 80, habilidades = ["escribirPoesiaAtroz","robar"], objetos = []}

{-
	Al pedo, no lo tenías que definir
-}

cuerda :: Objeto -> Objeto -> Objeto
cuerda objeto1 objeto2 barbaro = (objeto2.objeto1) barbaro 
-- *Main> cuerda (espada 5) (amuletosMisticos "hablarConLosAnimales") john
-- Barbaro {nombre = "John", fuerza = 90, habilidades = ["escribirPoesiaAtroz","robar","hablarConLosAnimales"], objetos = []}

{-
	Podés ignorar al bárbaro y a los objetos! Que función toma dos funciones y te devuelve una que hace lo mismo que las otras?
	cuerda  = (.)
-}

-- 2

megafono :: Objeto
megafono barbaro = barbaro {habilidades = [(concatenarHabilidades.habilidades) barbaro]}

concatenarHabilidades :: [String] -> String
concatenarHabilidades = map toUpper.concat
-- *Main Data.Char> megafono dave
-- Barbaro {nombre = "Dave", fuerza = 100, habilidades = ["TEJERESCRIBIRPOESIA"], objetos = [<function>,<function>]}

megafonoBarbarico :: Objeto
megafonoBarbarico = cuerda ardilla megafono 
-- *Main Data.Char> megafonoBarbarico dave
-- Barbaro {nombre = "Dave", fuerza = 100, habilidades = ["TEJERESCRIBIRPOESIA"], objetos = [<function>,<function>]}
 
-- 3 

invasionDeSuciosDuendes :: Barbaro -> Bool
invasionDeSuciosDuendes =  (elem "escribirPoesiaAtroz").habilidades
-- *Main> invasionDeSuciosDuendes dave
-- False
-- *Main> invasionDeSuciosDuendes john
-- True

cremalleraDelTiempo :: Barbaro -> Bool
cremalleraDelTiempo barbaro = (nombre barbaro)=="Faffy"|| (nombre barbaro)=="Astro"
-- *Main> cremalleraDelTiempo dave
-- False
-- *Main> cremalleraDelTiempo john
-- False
-- *Main> cremalleraDelTiempo faffy
-- True
-- *Main> cremalleraDelTiempo astro
-- True

{-
	cremalleraDelTiempo  = flip elem ["Faffy","Astro"] . nombre
-}


saqueo :: Aventura
saqueo barbaro = elem "robar" (habilidades barbaro) && (fuerza barbaro)>=80
-- *Main> saqueo dave
-- False
-- *Main> saqueo john
-- True

gritoDeGuerra :: Aventura
gritoDeGuerra barbaro = poderDelGrito (habilidades barbaro) >= cantidadDeObjetos (objetos barbaro)
poderDelGrito :: [String] -> Int
poderDelGrito = sum.map length 
cantidadDeObjetos :: [Objeto] -> Int
cantidadDeObjetos = (*4).length
-- *Main Data.Char> gritoDeGuerra dave
-- True

caligrafiaPerfecta :: Aventura
caligrafiaPerfecta barbaro = cantidadDeVocales (habilidades barbaro) && comienzanConMayusculas (habilidades barbaro) 
cantidadDeVocales :: [String] -> Bool
cantidadDeVocales = (>3).length.filter(==True).map esVocal.foldl1 (++)

{-
	Un filter (== true) siempre es una señal de alarma. Fijate que antes le mapeaste esVocal. Por que no le pasas esa función directamente al filter?
	El nombre cantidadDeVocales me hace pensar que devuelve un Int. Habría que pensar un nombre mejor
	El punto pedía que todas tengan más de tres vocales

	todasMasDeTresVocales = all masDeTresVocales

	masDeTresVocales = >3 .length . filter esVocal


-}

comienzanConMayusculas :: [String] -> Bool
comienzanConMayusculas = all esMayusculas.map head
esVocal :: Char -> Bool
esVocal letra = elem letra "aeiouAEIOU"
esMayusculas :: Char -> Bool
esMayusculas letra = elem letra ['A'..'Z']
-- *Main Data.Char> caligrafiaPerfecta dave
-- False
-- *Main Data.Char> caligrafiaPerfecta rick
-- True

ritualDeFechorias :: [Aventura] -> Barbaro -> Bool
ritualDeFechorias listaDeAventuras barbaro = (pasaAlMenosUnaPrueba barbaro) listaDeAventuras
pasaAlMenosUnaPrueba :: Barbaro -> [Aventura] -> Bool
pasaAlMenosUnaPrueba barbaro = any (==True).map ($ barbaro) 
-- *Main Data.Char> ritualDeFechorias [saqueo, gritoDeGuerra, caligrafiaPerfecta] dave
-- True

{-
	Mismo caso que arriba. Un any (== True) despus de un map


-}



sobrevivientes :: [Barbaro] -> Aventura -> [String]
sobrevivientes barbaros aventura = (map nombre.filter aventura) barbaros
-- *Main> sobrevivientes [dave, rick, john] caligrafiaPerfecta
-- ["Rick"]

-- 4 A

sinRepetidos :: (Eq a) => [a] -> [a]
sinRepetidos [] = [] 
sinRepetidos (x1:xs) | elem x1 xs = sinRepetidos xs
                     | otherwise = x1 : sinRepetidos xs				 
-- *Main> sinRepetidos [1,1,2,3]
-- [1,2,3]

-- 4 B
                       
descendientes :: Barbaro -> [Barbaro]                                        
descendientes (Barbaro nombre fuerza habilidades objetos) = iterate (\ (Barbaro n f h o) -> (Barbaro(n++"*") f h o)) (Barbaro nombre fuerza habilidades objetos)
-- *Main> take 3 (descendientes dave)
-- [Barbaro {nombre = "Dave", fuerza = 100, habilidades = ["tejer","escribirPoesia"], objetos = [<function>,<function>]},Barbaro {nombre = "Dave*", fuerza = 100, habilidades = ["tejer","escribirPoesia"], objetos = [<function>,<function>]},Barbaro {nombre = "Dave**", fuerza = 100, habilidades = ["tejer","escribirPoesia"], objetos = [<function>,<function>]}]

{-
	En realidad tenía que aplicar todos los objetos, no solo agregarle el *

-}


-- 4 C

-- No se podria usar sobre la lista de objetos ya que esta compuesta por funciones y las funciones no son comparables. Tampoco se podria con los nombres ya que son String, no son una lista de String.