Correción de Fede

ratones.hs

import Data.List
import Text.Show.Functions

--A
isAlfa x = elem x ['a'..'Z']
isUpper x = elem x ['A'..'Z']
isDigit x = elem x ['0'..'9'] 
diccionario = ["aaron", "abaco", "abecedario", "baliente", "beligerante"] 

empiezaCon :: String -> String -> Bool
empiezaCon lista listaComienzo = take (length listaComienzo) lista == listaComienzo
contieneA :: String -> [Char] -> Bool
contieneA lista listaQueContiene = any (flip empiezaCon listaQueContiene) (tails lista)

type Password = String
--1
empiezaConLetra :: Char -> Password -> Bool
empiezaConLetra letra password = head password == letra

--2
tieneAlMenosUnNumero :: Password -> Bool
tieneAlMenosUnNumero password = any isDigit password

{-
    Con point free
    tieneAlMenosUnNumero  = any isDigit 
-}

--3
tieneXMayusculas :: Int -> Password -> Bool
tieneXMayusculas cantidad password = (length.filter isUpper) password == cantidad

{-
    tieneXMayusculas cantidad  = (==) cantidad . length . filter isUpper
-}


--4
esIndeducible :: Password -> Bool
esIndeducible password = (not.any (contieneA password)) diccionario


bancoNacion = ([("juan","sdsdiulwd"), ("robby","sxwrhotxhlhh")], [tieneAlMenosUnNumero, esIndeducible], textoHash) 

type Aplicacion = ([Usuario] , [RequisitosDePassword], MetodoDeEncriptado)
type Usuario = (Nombre, PasswordEncriptado)
type Nombre = String
type PasswordEncriptado = Password
type MetodoDeEncriptado = Password -> PasswordEncriptado
type RequisitosDePassword = Password -> Bool

listaDeUsuarios :: Aplicacion -> [Usuario]
listaDeUsuarios (usuarios,_,_) = usuarios
requisitosPassword :: Aplicacion -> [RequisitosDePassword]
requisitosPassword (_,requisitos,_) = requisitos
metodoEncriptado :: Aplicacion -> MetodoDeEncriptado
metodoEncriptado (_,_,metodo) = metodo

--1
puedoUsar :: Password -> Aplicacion -> Bool
puedoUsar password aplicacion = (all (==True).pam (requisitosPassword aplicacion)) password

{-
    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]

    puedoUsar password  = all  ( flip $ password) . requisitosPassword 
-}

pam :: [elemento -> resultado] -> elemento -> [resultado]
pam listaDeFunciones elemento = map (flip ($) elemento) listaDeFunciones

--2
cesar :: Int -> Password -> PasswordEncriptado
cesar n password = map (toEnum.(+n).fromEnum) password

textoHash :: Password -> PasswordEncriptado
textoHash password = show (sumaDeCodigosASCII password)
sumaDeCodigosASCII:: Password -> Int
sumaDeCodigosASCII password = (foldl1 (+).map fromEnum) password

{-
    Point free   
-}

--3
registrarse :: Nombre -> Password -> Aplicacion -> Aplicacion
registrarse nombre password aplicacion
 | puedoUsar password aplicacion = ((listaDeUsuarios aplicacion) ++ [(nombre,(metodoEncriptado aplicacion) password)], requisitosPassword aplicacion, metodoEncriptado aplicacion)
 | otherwise =  aplicacion
 
--4
paradigama :: Aplicacion
paradigama = ([],[((>6).length),(not.(empiezaConLetra 't'))],cesar 4)

{-
    paradigama = ([],[ (>6) . length, not . empiezaConLetra 't'], cesar 4)
-}

facebutt :: Aplicacion
facebutt = ([("usuario" ++ (show n), textoHash ("laPasswordDificil" ++ (show n))) | n<- [1..]],[],\password->password)
--en la aplicacion facebutt puedo usar "puedoUsar" y "registrarse" ya que no hay requisitos
--en el caso de "registrarse" nunca llega a agregarse el usuario al final de la lista ya que es infinita

{- 
    Copado que uses listas por comprensión
-}