Corrección Rocío TP individual

dave.hs

import Data.Char
instance Show (a -> b) where
         show _ = "<function>"
		 
data Barbaro = Barbaro {nombre :: String,fuerza :: Int, habilidades :: [String], objetos :: [Barbaro -> Barbaro]} deriving (Show)
type TransformacionBarbaro = Barbaro -> Barbaro

{-   
	Objeto? :p Mantené los nombres del dominio
-}

type Aventura = Barbaro -> Bool
dave :: Barbaro
dave = (Barbaro "Dave" 100 ["tejer","escribirPoesia"] [ardilla])
faffy :: Barbaro
faffy = (Barbaro "Faffy" 9023 ["Escribir Poesia Atroz","robar"] [ardilla,(amuletosMisticos "saltar")])
astro :: Barbaro
astro = (Barbaro "Astro" 20 ["Nadar en el lago","Remar con escarbadientes"] [varitasDefectuosas])
rego :: Barbaro
rego = (Barbaro "Rego" 10 ["volar"] [ardilla,(espadas 10)])

--PRUEBAS
--espadas 2323 dave
--amuletosMisticos "correr" dave
--varitasDefectuosas dave
--ardilla dave
--megafono dave
--megafonoBarbarico dave
--invasionDeSuciosDuendes dave
--invasionDeSuciosDuendes faffy
--cremalleraDelTiempo dave
--cremalleraDelTiempo faffy
--saqueo dave
--saqueo faffy
--gritoDeGuerra dave
--caligrafia astro
--caligrafia dave
--ritualDeFechorias faffy
--ritualDeFechorias rego
--sinRepetidos [1,2,2,3,4,5,5,6,7]
--sobrevivientes [dave, faffy, rego, astro] ritualDeFechorias
--take 5 (descendientes dave)

--PUNTO 1
aumentarFuerza fuerza = (+ fuerza).(*2)
aumentarFuerza :: Int -> Int -> Int

espadas peso (Barbaro nombre fuerza habilidades objetos) = (Barbaro nombre (aumentarFuerza fuerza peso) habilidades objetos)
espadas :: Int -> TransformacionBarbaro

{-   
		TIP

	Quizás no tiene tanto sentido hacer aumentar fuerza ya que si bien aumenta la fuerza, no es taaaan transparente 
	el nombre ya que lo multiplica por dos.

	Sería un aumentar fuerza extraño.

	Pensar en aumentarFuerza me suena a que debería tener la firma Int -> Barbaro -> Barbaro.

	Podés usar esta sintaxis con data si la definiste con las llaves (se llama record syntax).

	espadas peso barbaro = barbaro { fuerza = aumentarFuerza (fuerza barbaro) peso}
-}



agregarHabilidad habilidadNueva = (++) [habilidadNueva]
agregarHabilidad :: String -> [String] -> [String]

{-   
		TIP

	Quizás el operador que necesitás es el de contrucción/deconstrucción de listas

	agregarHabilidad habilidadNueva habilidades = habilidadNueva : habilidades

-}


amuletosMisticos habilidadNueva (Barbaro nombre fuerza habilidades objetos) = (Barbaro nombre fuerza (agregarHabilidad habilidadNueva habilidades) objetos)
amuletosMisticos :: String -> TransformacionBarbaro

{-   
	Copado que hayas visto el crear la idea de transformación

	amuletosMisticos h barbaro = barbaro { habilidades = agregarHabilidad h (habilidades barbaro)}

-}

varitasDefectuosas (Barbaro nombre fuerza habilidades objetos) = (Barbaro nombre fuerza (agregarHabilidad "hacerMagia" habilidades) [])
varitasDefectuosas :: TransformacionBarbaro

ardilla = id
ardilla :: TransformacionBarbaro

cuerda = (.)
cuerda :: TransformacionBarbaro -> TransformacionBarbaro -> TransformacionBarbaro

--PUNTO 2
potenciarHabilidades habilidades = [(map toUpper.concat) habilidades]
potenciarHabilidades :: [String] -> [String]

megafono (Barbaro nombre fuerza habilidades objetos) = (Barbaro nombre fuerza (potenciarHabilidades habilidades) objetos) 
megafono :: TransformacionBarbaro

megafonoBarbarico = cuerda ardilla megafono
megafonoBarbarico :: TransformacionBarbaro

--PUNTO 3
invasionDeSuciosDuendes (Barbaro _ _ habilidades _) = any (== "Escribir Poesia Atroz") habilidades
invasionDeSuciosDuendes :: Aventura

{-   
	Abusando de la syntax record notation. Cada campo que definimos nos "regala" una función que funciona como el fst o snd 
	para conseguir el valor de ese campo

	invasionDeSuciosDuendes = any (== "Escribir Poesia Atroz") . habilidades

-}

cremalleraDelTiempo (Barbaro nombre _ _ _) = (nombre == "Faffy") || (nombre == "Astro")
cremalleraDelTiempo :: Aventura

{-   
	cremalleraDelTiempo = flip elem ["faffy", "astro"] . nombre 
-}


saqueo (Barbaro _ fuerza habilidades _) = (any (== "robar") habilidades) && (fuerza > 80)
saqueo :: Aventura

poderGrito = length.concat
poderGrito :: [String] -> Int

poderAprobado = (*4).length
poderAprobado :: [(TransformacionBarbaro)] -> Int

gritoDeGuerra (Barbaro _ _ habilidades objetos) = (poderGrito habilidades) > (poderAprobado objetos)
gritoDeGuerra :: Aventura

esVocal 'a' = True
esVocal 'e' = True
esVocal 'i' = True
esVocal 'o' = True
esVocal 'u' = True
esVocal 'A' = True
esVocal 'E' = True
esVocal 'I' = True
esVocal 'O' = True
esVocal 'U' = True
esVocal _ = False
esVocal :: Char -> Bool

{-   
	esVocal  = flip elem "aeiouAEIOU"

	(Acordate que "ab" es igual a ['a','b'])
-}


habMasDeTresVocales = all ((>3).length.filter (esVocal))
habMasDeTresVocales :: [String] -> Bool

{-   
	Delegarlo un poroto más!
-}


habComienzanConMayus = all (isUpper.head)
habComienzanConMayus :: [String] -> Bool

caligrafia (Barbaro _ _ habilidades _) = (habMasDeTresVocales habilidades) && (habComienzanConMayus habilidades)
caligrafia :: Aventura

ritualDeFechorias barbaro = (saqueo barbaro) || (gritoDeGuerra barbaro) || (caligrafia barbaro)
ritualDeFechorias :: Aventura

{-   
	ritualDeFechorias barbaro = any ($barbaro) [saqueo,gritoDeGuerra,caligrafía]

	ritualDeFechorias barbaro = any (flip ($) barbaro) [saqueo,gritoDeGuerra,caligrafía]

	$ también es un chirimbolito, entonces se puede usar tanto como:

	($) even 2 (prefija)

	even $ 2 (infija)
-}

--invasionDeSuciosDuendes dave
--invasionDeSuciosDuendes faffy
--cremalleraDelTiempo dave
--cremalleraDelTiempo faffy
--ritualDeFechorias faffy
--ritualDeFechorias rego

sobrevivientes muchosBarbaros aventura = filter aventura muchosBarbaros
sobrevivientes :: [Barbaro] -> Aventura -> [Barbaro]
--sobrevivientes [dave, faffy, rego, astro] ritualDeFechorias

--PUNTO 4
--A
sinRepetidos lista
	| null lista = []
	| any (== head lista) (tail lista) = sinRepetidos (tail lista)
	| otherwise = [head lista] ++ sinRepetidos (tail lista)
sinRepetidos :: (Eq a) => [a] -> [a]

{-   
	Te tweakeo un poco la función utilizando patrones

	sinRepetidos [] = []
	sinRepetidos (x:xs) 
		| any (== x) xs = sinRepetidos xs
		| otherwise = x : sinRepetidos xs
-}


--B
aplicarObjetos objetos barbaro = (head.drop (length objetos - 1).map (\objeto -> objeto barbaro)) objetos
aplicarObjetos :: [TransformacionBarbaro] -> TransformacionBarbaro

{-   
	Esa lambda que hiciste está genial! Funciona igual a un flip ($) barbaro. Mientras te des cuenta que si no te acordás
	podés crear tu propia función miAplicar que haga lo que necesitás yo soy feliz.

	También 

	aplicarObjetos objetos barbaro = (foldl1 (.) objetos) barbaro
-}

descendientes (Barbaro nombre fuerza habilidades objetos) = [aplicarObjetos objetos (Barbaro nombre fuerza (sinRepetidos habilidades) objetos)] ++ descendientes (Barbaro (nombre ++ "*") fuerza habilidades objetos)
descendientes :: Barbaro -> [Barbaro]

{-   
	Se puede ver muuy claro utilizando un iterate

descendientes  = iterate (\ barbaro -> aplicarObjetos (objetos barbaro) barbaro )

-}

--C
--No, no se puede aplicar sinRepetidos sobre una lista de objetos porque las funciones no son comparables en Haskell y cada objeto es una función.
--Sí se puede aplicar sobre una lista de nombre de Barbaros porque son strings y cada string es una lista de char que cada char puede ser comparable con otro char. Al permitir la comparacion se puede implementar la función sinRepetidos sin problema.
--Cabe destacar que si se aplica la funcion sinRepetidos a un unico nombre de un Barbaro lo que hará es comparar los chars que componen a ese string, entonces quedará el nombre sin letras repetidas.