FFPiH/Vorlesung2016
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

added Blatt3

Browse Source
This commit is contained in:
Nicole Dresselhaus 2016-05-02 15:50:59 +02:00
parent ae9eade752
commit cb8456060e
No known key found for this signature in database
GPG Key ID: BC16D887851A1A80
4 changed files with 327 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
Übungen/Blatt3.hs Normal file
View File

@ -0,0 +1,113 @@
-- Übungsblatt 3
-- =============
--
-- Throat-Clearing
-- ---------------
--
-- a.k.a. Imports, damit der Code funktioniert.
module MonadExercise where
import Control.Applicative
import Control.Monad
import Data.Monoid
-- Vorwort
-- -------
--
-- Die Typklassen, die auf diesem Zettel implementiert werden sollen sind
-- teilweise nicht eindeutig. Ein gutes *Indiz* für eine falsche
-- implementation kann sein, dass Informationen "weggeschmissen" werden -
-- allerdings muss man bei anderen Implementationen genau dies machen.
--
-- Applicative
-- -----------
--
-- Nachdem wir uns letzte Woche ausführlich mit der Typklasse `Functor`
-- beschäftigt haben, bauen wir nun darauf auf und definieren die
-- Applicative-Instanz. Zur Erinnerung:
--
-- class Functor f => Applicative f where
-- pure :: a -> f a
-- <*> :: f (a -> b) -> f a -> f b
--
-- Nehmen sie an, sie hätten folgende Datentypen mit ihren
-- `Functor`-Instanzen gegeben. Schreiben sie jeweils die
-- Applicative-Instanz:
data Identity a = Identity { unIdentity :: a }
deriving (Show, Eq)
instance Functor Identity where
fmap f (Identity a) = Identity (f a)
data Vielleicht a = Etwas a
| Nichts
deriving (Show, Eq)
instance Functor Vielleicht where
fmap f (Etwas a) = Etwas (f a)
fmap _ Nichts = Nichts
data EntwederOder b a = Entweder a
| Oder b
deriving (Show, Eq)
instance Functor (EntwederOder b) where
fmap f (Entweder a) = Entweder (f a)
fmap _ (Oder b) = Oder b
data List a = Cons a (List a)
| Nil
deriving (Show, Eq)
instance Functor List where
fmap f (Cons a r) = Cons (f a) (fmap f r)
fmap _ Nil = Nil
instance Monoid (List a) where
mempty = Nil
mappend Nil bs = bs
mappend (Cons a as) bs = Cons a (mappend as bs)
data V3 a = V3 a a a
instance Functor V3 where
fmap f (V3 x y z) = V3 (f x) (f y) (f z)
-- Monad
-- -----
--
-- Zu welchen der oben aufgeführten Typen gibt es eine Monaden-Instanz? Wie
-- sieht diese aus? Schreiben sie diese (falls möglich).
--
-- Bonus
-- -----
data Account = Account
data Inbox = Inbox
data Mail = Mail
-- Seien folgende Funktionen gegeben:
login :: Maybe Account
login = undefined
getInbox :: Account -> Maybe Inbox
getInbox = undefined
getMails :: Inbox -> [Mail]
getMails = undefined
safeHead :: [a] -> Maybe a
safeHead = undefined
-- Schreiben sie eine Funktion:
getFirstMail :: Maybe Mail
getFirstMail = undefined
-- welche die oben genannten 4 Funktionen nutzt um die erste Mail aus dem
-- gegebenen Account zurückzuliefern, sofern alles erfolgreich war.
--
-- Können sie beide Varianten (einmal mittels `do`-notation und einmal mit
-- `>>=`) schreiben?

113
Übungen/Blatt3.lhs Normal file
View File

@ -0,0 +1,113 @@
Übungsblatt 3
=============
Throat-Clearing
---------------
a.k.a. Imports, damit der Code funktioniert.
> module MonadExercise where
> import Control.Applicative
> import Control.Monad
> import Data.Monoid
Vorwort
-------
Die Typklassen, die auf diesem Zettel implementiert werden sollen sind
teilweise nicht eindeutig. Ein gutes *Indiz* für eine falsche
implementation kann sein, dass Informationen "weggeschmissen" werden -
allerdings muss man bei anderen Implementationen genau dies machen.
Applicative
-----------
Nachdem wir uns letzte Woche ausführlich mit der Typklasse `Functor`
beschäftigt haben, bauen wir nun darauf auf und definieren die
Applicative-Instanz. Zur Erinnerung:
class Functor f => Applicative f where
pure :: a -> f a
<*> :: f (a -> b) -> f a -> f b
Nehmen sie an, sie hätten folgende Datentypen mit ihren
`Functor`-Instanzen gegeben. Schreiben sie jeweils die
Applicative-Instanz:
> data Identity a = Identity { unIdentity :: a }
> deriving (Show, Eq)
>
> instance Functor Identity where
> fmap f (Identity a) = Identity (f a)
>
> data Vielleicht a = Etwas a
> | Nichts
> deriving (Show, Eq)
>
> instance Functor Vielleicht where
> fmap f (Etwas a) = Etwas (f a)
> fmap _ Nichts = Nichts
>
> data EntwederOder b a = Entweder a
> | Oder b
> deriving (Show, Eq)
>
> instance Functor (EntwederOder b) where
> fmap f (Entweder a) = Entweder (f a)
> fmap _ (Oder b) = Oder b
>
> data List a = Cons a (List a)
> | Nil
> deriving (Show, Eq)
>
> instance Functor List where
> fmap f (Cons a r) = Cons (f a) (fmap f r)
> fmap _ Nil = Nil
>
> instance Monoid (List a) where
> mempty = Nil
> mappend Nil bs = bs
> mappend (Cons a as) bs = Cons a (mappend as bs)
>
> data V3 a = V3 a a a
>
> instance Functor V3 where
> fmap f (V3 x y z) = V3 (f x) (f y) (f z)
Monad
-----
Zu welchen der oben aufgeführten Typen gibt es eine Monaden-Instanz? Wie
sieht diese aus? Schreiben sie diese (falls möglich).
Bonus
-----
> data Account = Account
> data Inbox = Inbox
> data Mail = Mail
Seien folgende Funktionen gegeben:
> login :: Maybe Account
> login = undefined
>
> getInbox :: Account -> Maybe Inbox
> getInbox = undefined
>
> getMails :: Inbox -> [Mail]
> getMails = undefined
>
> safeHead :: [a] -> Maybe a
> safeHead = undefined
Schreiben sie eine Funktion:
> getFirstMail :: Maybe Mail
> getFirstMail = undefined
welche die oben genannten 4 Funktionen nutzt um die erste Mail aus dem
gegebenen Account zurückzuliefern, sofern alles erfolgreich war.
Können sie beide Varianten (einmal mittels `do`-notation und einmal mit
`>>=`) schreiben?

101
Übungen/Blatt3.md Normal file
View File

@ -0,0 +1,101 @@
# Übungsblatt 3
## Throat-Clearing
a.k.a. Imports, damit der Code funktioniert.
```haskell
import Control.Applicative
import Control.Monad
import Data.Monoid
```
## Vorwort
Die Typklassen, die auf diesem Zettel implementiert werden sollen sind teilweise nicht eindeutig. Ein gutes *Indiz* für eine falsche implementation kann sein, dass Informationen "weggeschmissen" werden - allerdings muss man bei anderen Implementationen genau dies machen.
## Applicative
Nachdem wir uns letzte Woche ausführlich mit der Typklasse `Functor` beschäftigt haben, bauen wir nun darauf auf und definieren die Applicative-Instanz.
Zur Erinnerung:
class Functor f => Applicative f where
pure :: a -> f a
<*> :: f (a -> b) -> f a -> f b
Nehmen sie an, sie hätten folgende Datentypen mit ihren `Functor`-Instanzen gegeben. Schreiben sie jeweils die Applicative-Instanz:
```haskell
data Identity a = Identity { unIdentity :: a }
deriving (Show, Eq)
instance Functor Identity where
fmap f (Identity a) = Identity (f a)
data Vielleicht a = Etwas a
| Nichts
deriving (Show, Eq)
instance Functor Vielleicht where
fmap f (Etwas a) = Etwas (f a)
fmap _ Nichts = Nichts
data EntwederOder b a = Entweder a
| Oder b
deriving (Show, Eq)
instance Functor (EntwederOder b) where
fmap f (Entweder a) = Entweder (f a)
fmap _ (Oder b) = Oder b
data List a = Cons a (List a)
| Nil
deriving (Show, Eq)
instance Functor List where
fmap f (Cons a r) = Cons (f a) (fmap f r)
fmap _ Nil = Nil
instance Monoid List where
mempty = Nil
mappend Nil bs = bs
mappend (Cons a as) bs = Cons a (mappend as bs)
data V3 a = V3 a a a
instance Functor V3 where
fmap f (V3 x y z) = V3 (f x) (f y) (f z)
```
## Monad
Zu welchen der oben aufgeführten Typen gibt es eine Monaden-Instanz? Wie sieht diese aus? Schreiben sie diese (falls möglich).
## Bonus
Seien folgende Funktionen gegeben:
```haskell
login :: Maybe Account
login = undefined
getInbox :: Account -> Maybe Inbox
getInbox = undefined
getMails :: Inbox -> [Mail]
getMails = undefined
safeHead :: [a] -> Maybe a
safeHead = undefined
```
Schreiben sie eine Funktion:
```haskell
getFirstMail :: Maybe Mail
```
welche die oben genannten 4 Funktionen nutzt um die erste Mail aus dem gegebenen Account zurückzuliefern, sofern alles erfolgreich war.
Können sie beide Varianten (einmal mittels `do`-notation und einmal mit `>>=`) schreiben?

BIN
Übungen/Blatt3.pdf Normal file
View File

Binary file not shown.