Skip to content
GitLab
Explore
Sign in
Register
Primary navigation
Search or go to…
Project
V
Vorlesung2016
Manage
Activity
Members
Labels
Plan
Issues
Issue boards
Milestones
Wiki
Code
Merge requests
Repository
Branches
Commits
Tags
Repository graph
Compare revisions
Snippets
Build
Pipelines
Jobs
Pipeline schedules
Artifacts
Deploy
Releases
Container Registry
Model registry
Operate
Environments
Monitor
Incidents
Service Desk
Analyze
Value stream analytics
Contributor analytics
CI/CD analytics
Repository analytics
Model experiments
Help
Help
Support
GitLab documentation
Compare GitLab plans
Community forum
Contribute to GitLab
Provide feedback
Terms and privacy
Keyboard shortcuts
?
Snippets
Groups
Projects
Show more breadcrumbs
FFPiH
Vorlesung2016
Commits
7ddcd77b
Commit
7ddcd77b
authored
8 years ago
by
Nicole Dresselhaus
Browse files
Options
Downloads
Patches
Plain Diff
migrated changes to all other files
parent
b701278f
No related branches found
Branches containing commit
No related tags found
No related merge requests found
Changes
3
Hide whitespace changes
Inline
Side-by-side
Showing
3 changed files
Übungen/Blatt1.hs
+52
-39
52 additions, 39 deletions
Übungen/Blatt1.hs
Übungen/Blatt1.lhs
+32
-35
32 additions, 35 deletions
Übungen/Blatt1.lhs
Übungen/Blatt1.pdf
+0
-0
0 additions, 0 deletions
Übungen/Blatt1.pdf
with
84 additions
and
74 deletions
Übungen/Blatt1.hs
+
52
−
39
View file @
7ddcd77b
{-
{-
Übungsblatt 1
=============
Typtheorie
----------
Schreiben
s
ie alle **möglichen** Implementationen der folgenden
Schreiben
S
ie alle **möglichen** Implementationen der folgenden
Funktionen. Wozu könnte `fun2` nützlich sein?
-}
...
...
@@ -18,61 +18,71 @@ fun2 = _fun2
fun3
::
(
Eq
a
)
=>
a
->
a
->
Bool
fun3
=
_fun3
{- Wir haben in der Vorlesung parametrisierte Typen kennengelernt. Der
simpelste hiervon ist `Identity`, der genau gar nichts macht, sondern
nur einen anderen Typen einpackt.-}
{-
Wir haben in der Vorlesung parametrisierte Typen kennengelernt. Der
simpelste hiervon ist `Identity`, der nur einen anderen Typen einpackt.
-}
data
Identity
a
=
Identity
a
{- Diese Definition stellt uns automatisch den Konstruktor
`Identity :: a -> Identity a` zur Verfügung, der ein `a` einpackt.
Schreiben sie die Funktion -}
Schreiben Sie die Funktion
-}
unIdentity
::
Identity
a
->
a
unIdentity
=
_unIdentity
{- welche diesen Vorgang wieder rückgängig macht.
{-
welche diesen Vorgang wieder rückgängig macht.
Angenommen,
s
ie hätten nun ein Wert vom Typen `Identity a` und eine
Funktion mit dem Typen `a -> b`. Wie wenden
s
ie diese auf das `a`
Angenommen,
S
ie hätten nun ein Wert vom Typen `Identity a` und eine
Funktion mit dem Typen `a -> b`. Wie wenden
S
ie diese auf das `a`
"innerhalb" des `Identity` an um ein `Identity b` herzustellen?
Schreiben sie also eine Funktion-}
Schreiben Sie also eine Funktion
-}
mapIdentity
::
(
a
->
b
)
->
Identity
a
->
Identity
b
mapIdentity
=
_mapIdentity
{- **Hinweis:** Es gibt *zwei* prinzipielle Vorgehen dieses zu
implementieren. Kommen sie auf beide?
{-
**Hinweis:** Es gibt *zwei* prinzipielle Vorgehen dieses zu
implementieren. Kommen Sie auf beide?
Funktionen sind auch nur Typen
------------------------------
Datentypen können auch Funktionen enthalten. Sehen sie sich einmal den
Datentypen-}
Datentypen können auch Funktionen enthalten. Sehen Sie sich einmal den
Datentypen
-}
data
Pred
a
=
Pred
(
a
->
Bool
)
{- an. Hier wird ein Prädikat definiert, welches (gegeben einen Datentyp
{-
an. Hier wird ein Prädikat definiert, welches (gegeben einen Datentyp
`a`) eine Funktion gespeichert hat, die `a` in einen `Bool` umwandeln
kann (etwa um irgendwas zu filtern/selektieren/löschen/..., wenn man
dies an eine weitere Funktion übergibt).
Auch hier können sei eine Funktion schreiben, die das `Pred a` wieder
"auspackt". Definieren sie-}
Auch hier können Sie eine Funktion schreiben, die das `Pred a` wieder
"auspackt". Definieren Sie
-}
unPred
::
Pred
a
->
(
a
->
Bool
)
unPred
=
_unPred
{- Da Haskell-Funktionen aber "gecurried" sind, können sie die Klammern
hinten in der Signatur auch weglassen und erhalten
`unPred :: Pred a -> a -> Bool`, was man zugleich als "wende `Pred a`
an, wenn du ein `a` bekommst" lesen kann. In der Tat sind beide
Funktionen identisch (wieso?).
{-
Da Haskell-Funktionen aber "gecurried" sind (mehr dazu in der
Vorlesung), können Sie die Klammern hinten in der Signatur auch
weglassen und erhalten `unPred :: Pred a -> a -> Bool`, was man zugleich
als "wende `Pred a` an, wenn du ein `a` bekommst" lesen kann. In der Tat
sind beide Funktionen identisch (wieso?).
Bonus
Was für eine Funktion bräuchten sie um ein `Pred a` in ein `Pred b`
umzuwandeln? Können sie diese Implementieren?-}
Was für eine Funktion bräuchten Sie um ein `Pred a` in ein `Pred b`
umzuwandeln? Können Sie diese implementieren?
-}
mapPred
::
_fun
->
Pred
a
->
Pred
b
mapPred
=
_mapPred
...
...
@@ -82,26 +92,29 @@ Neue Typen erfinden
-------------------
In Haskell ist ein zentraler Vorgehenspunkt das Definieren und Verwenden
von eigenen Datentypen. Zur Erinnerung; es gibt
2
Möglichkeiten, die
man
miteinander kombinieren kann: `data Prod a b c = Prod a b c`
benötigt
sowohl `a`, `b` als auch `c` um einen Wert zu
erzeugen,
`data Sum a b = Sum1 a | Sum2 b` braucht entweder
ein `a` um durch den
Konstruktor `Sum1` ein `Sum a b` zu erzeugen oder
ein `b` um durch den
Konstruktor `Sum2` ein `Sum a b` zu erzeugen.
Definieren
s
ie einen Datentypen `Vielleicht a`, der zwei Konstruktoren
besitzt: Einen Konstruktor, de
r
durch ein `a` ein `Vielleicht a`
von eigenen Datentypen. Zur Erinnerung; es gibt
zwei
Möglichkeiten, die
man
miteinander kombinieren kann: `data Prod a b c = Prod a b c`
(Produkttyp) benötigt
sowohl `a`, `b` als auch `c` um einen Wert zu
erzeugen,
`data Sum a b = Sum1 a | Sum2 b`
(Summentyp)
braucht entweder
ein `a` um durch den
Konstruktor `Sum1` ein `Sum a b` zu erzeugen oder
ein `b` um durch den
Konstruktor `Sum2` ein `Sum a b` zu erzeugen.
Definieren
S
ie einen Datentypen `Vielleicht a`, der zwei Konstruktoren
besitzt: Einen Konstruktor,
mit
de
m
durch ein `a` ein `Vielleicht a`
konstruiert wird und ein zweiter Konstruktor, der keinen Wert nimmt,
sondern die "Abwesenheit eines `a`" symbolisieren soll.-}
sondern die "Abwesenheit eines `a`" symbolisieren soll.
-}
data
Vielleicht
a
=
Exercise
{- Können sie hier eine Funktion schreiben, die das `a` extrahiert? Wenn
ja, implementieren sie diese; wenn nein, geben sie eine kurze
{-
Können Sie hier eine Funktion schreiben, die das `a` extrahiert? Wenn
ja, implementieren Sie diese; wenn nein, geben Sie eine kurze
Begründung.
Wie würden sie mittels einer Funktion `a -> b` ein `Vielleicht a` in ein
`Vielleicht b` wandeln? Implementieren sie-}
Wie würden Sie mittels einer Funktion `a -> b` ein `Vielleicht a` in ein
`Vielleicht b` wandeln? Implementieren Sie
-}
mapVielleicht
::
(
a
->
b
)
->
Vielleicht
a
->
Vielleicht
b
mapVielleicht
=
_mapVielleicht
...
...
@@ -111,5 +124,5 @@ Bonus
Man kann Typen natürlich auch Schachteln. Worin liegt eigentlich der
Unterschied zwischen einem `Pred (Vielleicht a)` und einem
`Vielleicht (Pred a)`? Oder sind diese
I
dentisch?
`Vielleicht (Pred a)`? Oder sind diese
i
dentisch?
-}
This diff is collapsed.
Click to expand it.
Übungen/Blatt1.lhs
+
32
−
35
View file @
7ddcd77b
...
...
@@ -4,7 +4,7 @@
Typtheorie
----------
Schreiben
s
ie alle **möglichen** Implementationen der folgenden
Schreiben
S
ie alle **möglichen** Implementationen der folgenden
Funktionen. Wozu könnte `fun2` nützlich sein?
>
fun1
::
a
->
a
...
...
@@ -17,36 +17,35 @@ Funktionen. Wozu könnte `fun2` nützlich sein?
>
fun3
=
_fun3
Wir haben in der Vorlesung parametrisierte Typen kennengelernt. Der
simpelste hiervon ist `Identity`, der genau gar nichts macht, sondern
nur einen anderen Typen einpackt.
simpelste hiervon ist `Identity`, der nur einen anderen Typen einpackt.
>
data
Identity
a
=
Identity
a
Diese Definition stellt uns automatisch den Konstruktor
`Identity :: a -> Identity a` zur Verfügung, der ein `a` einpackt.
Schreiben
s
ie die Funktion
Schreiben
S
ie die Funktion
>
unIdentity
::
Identity
a
->
a
>
unIdentity
=
_unIdentity
welche diesen Vorgang wieder rückgängig macht.
Angenommen,
s
ie hätten nun ein Wert vom Typen `Identity a` und eine
Funktion mit dem Typen `a -> b`. Wie wenden
s
ie diese auf das `a`
Angenommen,
S
ie hätten nun ein Wert vom Typen `Identity a` und eine
Funktion mit dem Typen `a -> b`. Wie wenden
S
ie diese auf das `a`
"innerhalb" des `Identity` an um ein `Identity b` herzustellen?
Schreiben
s
ie also eine Funktion
Schreiben
S
ie also eine Funktion
>
mapIdentity
::
(
a
->
b
)
->
Identity
a
->
Identity
b
>
mapIdentity
=
_mapIdentity
**Hinweis:** Es gibt *zwei* prinzipielle Vorgehen dieses zu
implementieren. Kommen
s
ie auf beide?
implementieren. Kommen
S
ie auf beide?
Funktionen sind auch nur Typen
------------------------------
Datentypen können auch Funktionen enthalten. Sehen
s
ie sich einmal den
Datentype
Datentypen können auch Funktionen enthalten. Sehen
S
ie sich einmal den
Datentype
n
>
data
Pred
a
=
Pred
(
a
->
Bool
)
...
...
@@ -55,22 +54,22 @@ an. Hier wird ein Prädikat definiert, welches (gegeben einen Datentyp
kann (etwa um irgendwas zu filtern/selektieren/löschen/..., wenn man
dies an eine weitere Funktion übergibt).
Auch hier können
sei
eine Funktion schreiben, die das `Pred a` wieder
"auspackt". Definieren
s
ie
Auch hier können
Sie
eine Funktion schreiben, die das `Pred a` wieder
"auspackt". Definieren
S
ie
>
unPred
::
Pred
a
->
(
a
->
Bool
)
>
unPred
=
_unPred
Da Haskell-Funktionen aber "gecurried" sind
, können sie die Klamm
er
n
hinten in der Signatur auch
weglassen und erhalten
`unPred :: Pred a -> a -> Bool`, was man zugleich
als "wende `Pred a`
an, wenn du ein `a` bekommst" lesen kann. In der Tat
sind beide
Funktionen identisch (wieso?).
Da Haskell-Funktionen aber "gecurried" sind
(mehr dazu in d
er
Vorlesung), können Sie die Klammern
hinten in der Signatur auch
weglassen und erhalten
`unPred :: Pred a -> a -> Bool`, was man zugleich
als "wende `Pred a`
an, wenn du ein `a` bekommst" lesen kann. In der Tat
sind beide
Funktionen identisch (wieso?).
Bonus
Was für eine Funktion bräuchten
s
ie um ein `Pred a` in ein `Pred b`
umzuwandeln? Können
s
ie diese
I
mplementieren?
Was für eine Funktion bräuchten
S
ie um ein `Pred a` in ein `Pred b`
umzuwandeln? Können
S
ie diese
i
mplementieren?
>
mapPred
::
_fun
->
Pred
a
->
Pred
b
>
mapPred
=
_mapPred
...
...
@@ -79,26 +78,26 @@ Neue Typen erfinden
-------------------
In Haskell ist ein zentraler Vorgehenspunkt das Definieren und Verwenden
von eigenen Datentypen. Zur Erinnerung; es gibt
2
Möglichkeiten, die
man
miteinander kombinieren kann: `data Prod a b c = Prod a b c`
benötigt
sowohl `a`, `b` als auch `c` um einen Wert zu
erzeugen,
`data Sum a b = Sum1 a | Sum2 b` braucht entweder
ein `a` um durch den
Konstruktor `Sum1` ein `Sum a b` zu erzeugen oder
ein `b` um durch den
Konstruktor `Sum2` ein `Sum a b` zu erzeugen.
Definieren
s
ie einen Datentypen `Vielleicht a`, der zwei Konstruktoren
besitzt: Einen Konstruktor, de
r
durch ein `a` ein `Vielleicht a`
von eigenen Datentypen. Zur Erinnerung; es gibt
zwei
Möglichkeiten, die
man
miteinander kombinieren kann: `data Prod a b c = Prod a b c`
(Produkttyp) benötigt
sowohl `a`, `b` als auch `c` um einen Wert zu
erzeugen,
`data Sum a b = Sum1 a | Sum2 b`
(Summentyp)
braucht entweder
ein `a` um durch den
Konstruktor `Sum1` ein `Sum a b` zu erzeugen oder
ein `b` um durch den
Konstruktor `Sum2` ein `Sum a b` zu erzeugen.
Definieren
S
ie einen Datentypen `Vielleicht a`, der zwei Konstruktoren
besitzt: Einen Konstruktor,
mit
de
m
durch ein `a` ein `Vielleicht a`
konstruiert wird und ein zweiter Konstruktor, der keinen Wert nimmt,
sondern die "Abwesenheit eines `a`" symbolisieren soll.
>
data
Vielleicht
a
=
Exercise
Können
s
ie hier eine Funktion schreiben, die das `a` extrahiert? Wenn
ja, implementieren
s
ie diese; wenn nein, geben
s
ie eine kurze
Können
S
ie hier eine Funktion schreiben, die das `a` extrahiert? Wenn
ja, implementieren
S
ie diese; wenn nein, geben
S
ie eine kurze
Begründung.
Wie würden
s
ie mittels einer Funktion `a -> b` ein `Vielleicht a` in ein
`Vielleicht b` wandeln? Implementieren
s
ie
Wie würden
S
ie mittels einer Funktion `a -> b` ein `Vielleicht a` in ein
`Vielleicht b` wandeln? Implementieren
S
ie
>
mapVielleicht
::
(
a
->
b
)
->
Vielleicht
a
->
Vielleicht
b
>
mapVielleicht
=
_mapVielleicht
...
...
@@ -107,6 +106,4 @@ Bonus
Man kann Typen natürlich auch Schachteln. Worin liegt eigentlich der
Unterschied zwischen einem `Pred (Vielleicht a)` und einem
`Vielleicht (Pred a)`? Oder sind diese Identisch?
>
main
=
putStrLn
"compiles"
`Vielleicht (Pred a)`? Oder sind diese identisch?
This diff is collapsed.
Click to expand it.
Übungen/Blatt1.pdf
+
0
−
0
View file @
7ddcd77b
No preview for this file type
This diff is collapsed.
Click to expand it.
Preview
0%
Loading
Try again
or
attach a new file
.
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Save comment
Cancel
Please
register
or
sign in
to comment