Aufgabe1.hs

-- Aufgabe 1
-- =========

module Aufgabe1 where  

import AdressSys  


-- Applicative style – an abstract pattern for everyday use. 
-- --------------------------
-- 
-- Wiederholung: 
-- -----------------------------------
-- (<$>) ::   (a -> b)   -> f a -> f b
-- (<*>) :: f (a -> b)   -> f a -> f b
-- (=<<) ::   (a -> m b) -> m a -> m b  -- (=<<) == flip (>>=)
-- -----------------------------------
-- 
-- Aus der Vorlesung wissen Sie bereits, dass `[]` und `Maybe` `Applicative`s sind und 
-- dass `Applicative` ermöglicht, 'Funktionen im Kontext' auf Werte im Kontext anzuwenden. 
-- Außerdem haben Sie `Currying` kennen gelernt. Ein praktisches Muster, das sich hieraus 
-- ableiten lässt, ist das folgende: 
-- 
-- pure f <*> x1 <*> x2 <*> .. <*> xn 
--   wobei f  :: t1 -> t2 -> .. -> tn -> t' 
--         x1 :: Applicative m => m t1 
--         x2 :: Applicative m => m t2 
--         .
--         .
--         xn :: Applicative m => m tn 
-- 
-- 
-- `pure` hebt die Funktion f in den Kontext m und `<*>` wendet f nach und nach auf alle ihre 
-- im Kontext liegenden Argumente t1 bis tn an. Vor dem Hintergrund, dass jedes `Applicative` 
-- auch ein `Functor` ist, lässt sich das Muster noch etwas verkürzen: 
-- 
-- pure f <*> x1 <*> x2 <*> ... <*> xn 
--      f <$> x1 <*> x2 <*> ... <*> xn 
-- 
-- 
-- Importiert aus dem Modul AdressSys sind die folgenden Datentypen und Funktionen, die ein 
-- ein Datenbanksystem zur Verwaltung persönlicher Daten repräsentieren: 
-- 
-- type ID = Integer
-- type DB = [(ID,[Datum])]
-- 
-- newtype Age      = Age      Integer
-- newtype Name     = Name     String
-- newtype City     = City     String
-- newtype Email    = Email    String
-- newtype Phone    = Phone    String
-- newtype Street   = Street   String
-- newtype Gender   = Gender   String
-- newtype Postcode = Postcode String
-- 
-- data Adress = Adress Name Street PostCode City deriving (Show,Eq)
-- data Public = Public Name (Maybe Age) (Maybe Email) deriving (Show,Eq)
-- 
-- data Datum  = DName     Name
--             | DStreet   Street
--             | DPostcode Postcode
--             | DEmail    Email
--             | DPhone    Phone
--             | DGender   Gender
--             | DCity     City
--             | DAge      Age
--             deriving (Show,Eq)
-- 
-- getName     :: [Datum] -> Maybe Name 
-- getStreet   :: [Datum] -> Maybe Street
-- getPostcode :: [Datum] -> Maybe Postcode
-- getEmail    :: [Datum] -> Maybe Email
-- getPhone    :: [Datum] -> Maybe Phone
-- getGender   :: [Datum] -> Maybe Gender
-- getAge      :: [Datum] -> Maybe Age
-- getCity     :: [Datum] -> Maybe City
-- -- suchen jeweils das erste Vorkommen aus; gehen Sie davon aus, die Datenstruktur erlaube nur einmaliges Vorkommen
-- 
-- getDataFromID :: ID -> DB -> Maybe [Datum]
-- -- sucht die zu einer ID zugehörigen Daten aus einer Datenbank aus 

db1 = [(1,[DAge (Age 99),DCity (City "Portland,Oregano"),DName (Name "Mona D."),DPostcode (Postcode "42317"),DStreet (Street "Intuition 6")]),(2,[DStreet (Street "Jahnplatz 5"),DName (Name "Alfred Plickateff"),DAge (Age 22),DEmail (Email "a.plickateff@hackage.com")]),(3,[DName (Name "Gerhard Zeh")]),(4,[])]
db2 = [(2,[DAge (Age 54),DCity (City "Bielefeld"),DName (Name "Hans Joachim Meyer"),DPostcode (Postcode "33602"),DStreet (Street "Viktoriastraße 22")]),(6,[DStreet (Street "Dönerteller 1a"),DName (Name "Hannelore Hacker"),DAge (Age 76)]),(3,[DName (Name "Lisa Lista"),DEmail (Email "lisa.lista@web.de"),DAge (Age 7)]),(5,[DName (Name "Alonzo Storch"),DStreet (Street "Antenne 2"),DCity (City "Dingenskirchen"),DPostcode (Postcode "12346")])]
-- zwei Beispieldatenbanken

-- Gegeben eine Liste von persönlichen Daten fassen die folgenden Funktionen `getAdressM` und 
-- `getPublicDataM` Adress- bzw. öffentliche Daten zu einem entsprechenden Wert `Adress` bzw. 
-- `Public` zusammen; falls nicht alle nötigen Informationen gefunden werden, geben sie `Nothing` 
-- zurück. 

getAdressM :: [Datum] -> Maybe Adress  
getAdressM ds = do   
  name   <- getName     ds  
  street <- getStreet   ds  
  pcode  <- getPostcode ds  
  city   <- getCity     ds    
  return (Adress name street pcode city)  

getPublicM :: [Datum] -> Maybe Public  
getPublicM ds = getName ds >>= \name -> return (Public name (getAge ds) (getEmail ds))


-- Implementieren Sie nun zwei Funktionen `getAdressA` und `getPublicDataA`, die das gleiche tun, 
-- im Applicative style, d.h. indem Sie das oben beschriebene Muster verwenden. 

getAdressA :: [Datum] -> Maybe Adress  
getAdressA ds = undefined

getPublicA :: [Datum] -> Maybe Public  
getPublicA ds = undefined


-- Definieren Sie abschließend eine Funktion `getManyAdresses` im Applicative style, die unter 
-- Verwendung von `getAdressFromID :: ID -> DB -> Maybe Adress` Adressen für eine ganze Liste 
-- von `ID`s aus einer Liste von Datenbanken `DB`s aussucht und ausgibt.  

getAdressFromID :: ID -> DB -> Maybe Adress
getAdressFromID iD db = getDataFromID iD db >>= getAdressM

getManyAdresses :: [ID] -> [DB] -> [Maybe Adress]  
getManyAdresses iDs dbs = undefined


result = unlines $
          ["Adressen für Nutzer 1 bis 5 (ID) aus db1 und db2: ",  
          (show $ getManyAdresses [1..5] [db1,db2]),  
          "Öffentliche Daten für ID 1 db1: ",  
          (show $ (getDataFromID 1 db1 >>= getPublicA))]