Corrección de Marina

ratones.hs

-- TP Funcional PdeP "Ratones Paranoicos"
-- Marina Wang
import Data.Char
instance Show (a -> b) where
         show a= "<function>"

{-
	o import Text.Show.Functions
-}         

type RequisitosPassword = String -> Bool
--un diccionario común y corriente:
diccionario = ["aaron", "abaco", "abecedario", "baliente", "beligerante"]

--A) Requisitos Password:

--Me dice si empieza con una palabra q le digo yo
--empiezaCon
empiezaCon :: String -> String -> Bool 
empiezaCon unString meContiene = all (==True) (compararLetraPorLetra (take (length meContiene) unString) meContiene)

{-
	ALERTA! 


	Siempre que nuestra función sea un == True o algo así nos tiene que hacer ruido. En el 99% de los casos 
	se puede reescribir correctamente.
	Por ejemplo (all (== True) . map even) [1,2,3]    	vs.    all even [1,2,3]

	empiezaCon unString palabra =  take (length unString) palabra  == unString


-}

--empiezaCon "papafritas" "papa"
compararLetraPorLetra ohString meContiene = zipWith (==) meContiene ohString
compararLetraPorLetra :: String -> String -> [Bool]

--Me dice si contiene la palabra q yo le digo
--contieneA
contieneA unString meContiene = (not.null) (evaluarTails unString meContiene)
contieneA :: String -> String -> Bool
--contieneA "elNombreaaronEsCorto00" "aaron"

{-
	contieneA unString palabra 
		| empiezaCon unString palabra = True
		| otherwise = contieneA unString (drop 1 palabra)

	> contieneA "asd" "pasd"

	La primera vez se fija compara "asd" vs "pasd" y en la segunda vuelta "asd" vs "asd" (que es palabra dropeando 
	la primer letra)
-}


evaluarTails unString meContiene = filter (flip esMismaPalabra meContiene) (filtrarContiene unString meContiene)
evaluarTails :: String -> String -> [String]

esMismaPalabra ohString meContiene = all (==True) (compararLetraPorLetra ohString meContiene )
esMismaPalabra :: String -> String -> Bool

filtrarContiene unString meContiene 
	| null unString = []
	| head meContiene == head unString = tails unString 
	| otherwise = filtrarContiene (tail unString) meContiene
filtrarContiene :: String -> String -> [String]

--tails
tails [x] = [[x]]
tails [] = [[]]
tails ohString = ohString : tails (tail ohString)
tails :: [a] -> [[a]]

--PUNTO 1 
empiezaConLetra letra password = (head password) == letra
empiezaConLetra :: Char -> RequisitosPassword
--empiezaConLetra 'a' "aaron"

{-
	empiezaConLetra letra = letra == . head
-}

--PUNTO 2
tieneAlMenosUnNumero = any isDigit 	
tieneAlMenosUnNumero :: RequisitosPassword
--tieneAlMenosUnNumero "dgfa0kghf"

--PUNTO 3
tieneXMayusculas cantidad password = length (filter (isUpper) password ) == cantidad
tieneXMayusculas :: Int -> RequisitosPassword
--tieneXMayusculas 3 "fsAdOdjSp"

{-
	tieneXMayusculas cantidad = >= cantidad . length . filter isUpper
-}
	
--PUNTO 4
esIndeducible password = null (filter (flip contieneA password) diccionario)
esIndeducible :: RequisitosPassword
--esIndeducible "dificilPassword"

{-
	esIndeducible  = all ( not . flip elem diccionario)	
-}

--B)
type Aplicacion = ([Usuario], [RequisitosPassword], (MetodoEncriptado))
type Usuario = (String, String)
type MetodoEncriptado = String -> String

--ejemplo aplicacion
-- si el Metodo de Encriptado fuera "cesar", hay pasarle un numero
bancoNacion = ([("juan","sdshdfjg"), ("robby","hfTRYR54366h")], [tieneAlMenosUnNumero,tieneXMayusculas 3], cesar 5)

--PUNTO 1
puedoUsar password (listaUsuarios, requisitosPassword, metodoEncriptado) = all (==True) (pamRequisito password requisitosPassword)
puedoUsar :: String -> Aplicacion -> Bool
--puedoUsar "asd2SASddx" bancoNacion

{-
	Devuelta el fantasma del == True ataca! Por que no hacer 

 	cumpleRequisitos password = all (flip ($) password )

	puedoUsar password = cumpleRequisitos password . requisitos

	requisitos ( _ , r , _ ) = r


 	o

	cumpleRequisitos password = all ($ password ) y después


	Como ($) es un chirimbolo puede ser usado tanto como 

	($) even 1	(forma prefija)		vs 				even $ 1 (forma infija)

-}

pamRequisito password requisitosPassword = map (flip ($) password) requisitosPassword
pamRequisito :: String -> [RequisitosPassword] -> [Bool]

--PUNTO 2 Metodos de Encriptamiento
cesar numero password = map (\x -> toEnum x :: Char) (convertirAAsciiYSumar numero password)
cesar :: Int -> MetodoEncriptado
--cesar 3 "CaBe0"

convertirAAsciiYSumar numero password = map ((numero+).(fromEnum)) password
convertirAAsciiYSumar :: Int -> String -> [Int]

textoHash password = show (foldl (+) 0 (map (fromEnum) password))
textoHash :: MetodoEncriptado
--textoHash "hola"
--devuelve la representacion taxtual del numero

{-
	textoHash = show . foldl1 (+) . map fromEnum
-}

--PUNTO 3
--registrarse :: String -> String -> Aplicacion -> Aplicacion
registrarse nombre password (listaUsuarios, requisitosPassword, metodoEncriptado) 
	| puedoUsar password (listaUsuarios, requisitosPassword, metodoEncriptado) = 
			(listaUsuarios ++ (generarUsuario nombre password metodoEncriptado), requisitosPassword, metodoEncriptado)
	| otherwise = (listaUsuarios, requisitosPassword, metodoEncriptado) 
-- registrarse "Pepe" "pePitOO2409" bancoNacion
-- clave encripatada (cesar 5) = "ujUnyTT794"

{-
	Si lo hubieses definido con data podría ser 
	
	registarse nombre pass aplicacion 
		| puedoUsar password aplicacion = 
			aplicacion { listaUsuarios = listaUsuarios aplicacion ++ 
			generarUsuario password (encriptado aplicacion) }
		| otherwise = aplicacion
-}
generarUsuario :: String -> String -> MetodoEncriptado -> [Usuario]
generarUsuario nombre password metodoEncriptado = [(nombre, metodoEncriptado password)] 

{-
	Y por que no un usuario?

	arriba lo concatenás con el constructor / deconstructor de listas a la lista de usuarios como 
	 (generarUsuario nombre pass metodo) : listaDeUsuarios
-}

--PUNTO 4
--a
paradigma = ([], [\x -> length x > 6, \y -> head y /= 't'], cesar 4)
--Cumple y se agrega a la lista de usuarios: 
--registrarse "Pepe" "abcdefg" paradigma
--No se cumple y devuelve la lista vacia original: 
--registrarse "Pepe" "tjsjj" paradigma

--b
facebutt = (map (\x -> ("usuario" ++ show x, ("laPasswordDificil" ++ show x))) [1..], [], \x -> x) 
-- registrarse "Pepe" "hOla1234" facebutt 
--no se va a poder visualizarse ya que la lista de usuarios va ser una lista infinita

--SI, ya que solo evalua la lista de requerimientos, siempre devolvera True
--SI, se agregara el usuario debido a la misma razon de arriba