Übungsblatt 2
=============

Throat-Clearing
---------------

a.k.a. Imports, damit der Code funktioniert.

``` {.haskell}
import Data.Functor
import Data.Monoid
```

Functor
-------

Sie haben in der Vorlesung die Typklasse `Functor` kennengelernt. Zur
Erinnerung:

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

Nehmen sie an, sie hätten folgende Datentypen gegeben, für die alle eine
`Functor`-Instanz existiert und eindeutig ist:

``` {.haskell}
data Identity a = Identity { unIdentity :: a }

data Vielleicht a = Etwas a
                  | Nichts

data EntwederOder b a = Entweder a
                      | Oder b

data GameVector b a = V3 a a a
                    | VStrange [a]
                    | Neighbours [GameVector b a]
                    | EntwederOder b (GameVector b a)
```

Schreiben sie hierzu die jeweiligen `Functor`-Instanzen.

Besser und allgemeiner
----------------------

Vereinfachen und verallgemeinern sie folgenden Ausdrücke so weit wie
möglich und geben die sie dadurch entstehenden Typsignaturen an.
Bedenken sie, dass wenn sie auf eine Typklasse abstrahieren, sie die
gesamten Gesetze der Typklasse benutzen können.

Kann die Funktion nachher mehr als vorher?

*Bonus*: Hat sich an der Laufzeit etwas verändert?

``` {.haskell}
mystery1 :: [[a]] -> [[a]]
mystery1 = map (++[])

mystery2 :: (Eq a) => a -> a -> a -> Bool
mystery2 x y z
  | x == y || y == z = True
  | x == y && y == z = True
  | x /= z           = False
  | y /= z           = False
  | x == y || y /= z = True
  | otherwise        = False

mystery3 :: Eq a => (a -> a) -> a -> [a] -> [a]
mystery3 f a l = post a l'
   where
     l' = map f l
     post a (x:xs)
         | a == x    = x ++ post a xs
         | otherwise =      post a xs
     post _ [] = []

mystery4 :: (Int -> Bool)
         -> Vielleicht (EntwederOder String Int)
         -> Vielleicht (EntwederOder String Bool)
mystery4 f (Etwas (Entweder a)) = Etwas . Entweder . f $ a
mystery4 _ (Etwas (Oder b))     = Etwas (Oder b)
mystery4 _  Nichts              = Nichts
```

Bonus
-----

Es gibt von dem bekannten Spiel 2048 eine Haskell-Implementation für die
Kommandozeile in unter 100 Zeilen. Diese ist zu finde unter
https://github.com/gregorulm/h2048/blob/master/h2048.hs

Sie können diesen Code mit `GHC` kompilieren oder im `ghci` ausführen
(`main` ist die Start-Funktion).

Was für Prinzipielle Vorgehenspunkte können sie erkennen? Eine kleine
Erklärung gibt es im Blog der Erstellers:
http://gregorulm.com/2048-in-90-lines-haskell/

Keine Angst, sie müssen dies noch nicht verstehen, aber es soll
verdeutlichen, wie viel man mit extrem wenig erreichen kann. Viele der
Abgabeprojekte werden in dieser Größenordnung liegen (aber meist noch so
etwas wie ein GUI o.ä. benötigen). Versuchen sie einfach den Code
kaputtzuspielen (z.b. Tasten ändern, Siegbedingung ändern, Cheats
einbauen, ...).

Viel Spass beim Spielen! :)