Aufgabe3.hs

-- Aufgabe 3
-- =========

module Aufgabe3 where

import FunPB  
import DataPB  
import AreaCode
import Data.Char  

-- Functor – ein Container? 
-- --------------------------

-- Zur Erinnerung:


-- class Functor f where  
--   fmap :: (a -> b) -> f a -> f b  

-- Aus der Vorlesung 2 kennen Sie bereits die `Functor`-Instanzen für `[]`, `Identity` 
-- und einen binären Baum. Außerdem haben Sie gelernt, dass Sie auch für Ihre eigenen
-- Typen `Functor`-Instanzen definieren können. Eine Intuition dafür, ob sich für einen 
-- Typ eine `Functor`-Instanz schreiben lässt, erhalten Sie, indem Sie sich fragen, ob 
-- der Typ "eine Art Container" ist, auf deren Inhalte sich Funktionen (a -> b) anwenden 
-- lassen. Was bedeutet dies in Haskell-Syntax? Hierfür ist es dienlich, sich den 
-- `type constructor` des betreffenden Datentyps anzuschauen. Handelt es sich um einen 
-- polymorphen Datentyp stehen die Chancen gut, dass es ein `Functor` ist. 

-- data Bool = False | True  

-- data Maybe a = Nothing | Just a  

-- data (,) a b = (a,b)  

-- `Bool` ist offenbar kein `Functor`, denn der Typkonstruktor `Bool` hat keine Parameter –
-- hier ist nur Platz für True und False. `Maybe a` dagegen hat einen Parameter, einen freien 
-- Slot für alles mögliche. Der Tupeltyp `(,) a b` hat sogar zwei Parameter – er kann Dinge von 
-- zwei verschiedenen Typen enthalten. Hier stellt sich die Frage, für welchen Container die 
-- Functorinstanz definiert ist. Ähnlich wie Funktionen, lassen sich auch Typkonstruktoren 
-- partiell anwenden. Für die Instanziierung werden dem Typkonstruktor daher alle bis auf ein 
-- Parameter übergeben. Dieser letzte, freie Parameter legt dann den Inhalt des "Container" 
-- fest. Beispiel:  

-- instance Functor ((,) a) where --Die Functor-Instanz ist für (,) a definiert
--     fmap f (x,y) = (x, f y)    --Also wird über Tupelslot 2 "gemapt"

-- Implementieren Sie `Functor`-Instanzen für die folgenden Datentypen: 


data Vielleicht a = Nichts | Etwas a  
    deriving (Show,Eq)  

instance Functor Vielleicht where  
   fmap = undefined


data Entweder a b = Jenes a | Dieses b  
    deriving (Show,Eq)  

instance Functor (Entweder a) where  
    fmap = undefined  


data Konstant a b = Konstant a  
    deriving (Show,Eq)  

instance Functor (Konstant a) where  
    fmap = undefined  


-- Achtung: Die "Container"-Metapher hat ihre Grenzen. Betrachten Sie hierzu noch einmal den 
-- Datentyp Pred a von Zettel 1: `data Pred a = Pred (\a -> Bool)`. 

data Pred a = Pred (a -> Bool)  
runPred :: Pred a -> (a -> Bool)  
runPred (Pred p) = p  

-- `Pred a` macht den Anschein als handele es sich auch hier um einen Container mit Inhalt a. 
-- Trotzdem lässt sich `Functor` hierfür nicht instanziieren. Der Unterschied liegt darin, 
-- dass der Typaramter `a` als Input und nicht als Ergebnis in der vom Konstruktor `Pred` 
-- "eingepackten" Berechnung auftaucht. Allerdings lässt sich hier auf eine sehr ähnliche 
-- Eigenschaft abstrahieren, die wir für's Erste `InputFunctor` nennen wollen. 

class InputFunctor f where
    inputmap :: (a -> b) -> f b -> f a

-- Schreiben Sie eine `InputFunctor`-Instanz für `Pred a`. 

instance InputFunctor Pred where  
    inputmap = undefined  

-- Hiermit lässt sich nun bequem die folgende Funktion definieren, welche aus einem 
-- `Pred Int` ein `Pred String` macht, das prüft, ob ein Eingabestring wenigstens die Länge 5 hat. 

atLeast5 :: Pred Int  
atLeast5 = Pred $ (\x -> x>=5)  

atLeast5Char :: Pred String  
atLeast5Char = inputmap length atLeast5  

-- Functorial phone book
-- ---------------------

-- Jetzt noch einmal zurück zu PhoneBook aus Aufgabe 1. 

type Number = String  
type Name = String  
type Entry = [Number]  

newtype PhoneBook = PB (Name -> Entry)  

-- `PhoneBook` hat keinen Parameter, aber die allgemeinere Version `FunPB` hat sogar zwei: 
--    data FunPB a b = FunPB (a -> (a,[b]))  

-- Beachten Sie, dass sich auch der Rückgabetyp ein wenig unterscheidet. Die Idee ist, 
-- dass FunPB zusätzlich zu den assoziierten `Number`s (angenommen `b` ist `Number`) auch 
-- den gesuchten `Name` (angenommen `a` ist `Name`) zurückgibt. 

-- Implementieren Sie eine `Functor`-Instanz für `FunPB`. 
-- Hinweis: Sie können benutzen, dass für `[]`, `((,) a)` und sogar für den "function arrow" 
-- `((->) a)` bereits `Functor`-Instanzen in der [`GHC.Base`](https://hackage.haskell.org/package/base "GHC.Base") existieren. 

instance Functor (FunPB a) where  
    fmap = undefined

-- Die Functor-Instanz erlaubt uns nun die Funktionen 
-- `separateAreaCode :: Number -> (AreaCode,Number)` und `snd` zu verwenden, um ein 
-- TelefonBuch mit separiertem bzw. ganz ohne AreaCode zu erhalten. 

areaCodeFunPB :: FunPB Name String -> FunPB Name (AreaCode,Number)  
areaCodeFunPB = fmap separateAreaCode  

withoutAreaCodeFunPB :: FunPB Name Number -> FunPB Name Number  
withoutAreaCodeFunPB = fmap (snd.separateAreaCode)  


result = "Suche \"Paula\" in (FunPB Name Number): \n"  
      ++ (show $ runFunPB (dataToFunPB simpleData) "Paula") ++ "\n"  
      ++ "Suche \"Paula\" in (FunPB Name (AreaCode,Number)): \n"  
      ++ (show $ runFunPB (areaCodeFunPB $ dataToFunPB simpleData) "Paula") ++ "\n"  
      ++ "Suche \"Paula\" in (FunPB Name Number) ohne Vorwahl: \n"  
      ++ (show $ runFunPB (withoutAreaCodeFunPB $ dataToFunPB simpleData) "Paula")