Haskell Intensivkurs: ein kompakter Einstieg in die funktionale Programmierung
Gespeichert in:
| Hauptverfasser: | , |
|---|---|
| Format: | Buch |
| Sprache: | German |
| Veröffentlicht: |
Heidelberg [u.a.]
Springer
2011
|
| Schriftenreihe: | Xpert.press
|
| Schlagworte: | |
| Online-Zugang: | Inhaltsverzeichnis |
| Beschreibung: | XIX, 292 S. Ill., graph. Darst. |
| ISBN: | 9783642047176 |
Internformat
MARC
| LEADER | 00000nam a2200000 c 4500 | ||
|---|---|---|---|
| 001 | BV035772145 | ||
| 003 | DE-604 | ||
| 005 | 20211211 | ||
| 007 | t | ||
| 008 | 091015s2011 gw ad|| |||| 00||| ger d | ||
| 015 | |a 09,N37,0018 |2 dnb | ||
| 016 | 7 | |a 996247602 |2 DE-101 | |
| 020 | |a 9783642047176 |c PB. : EUR 29.95, sfr 43.50 (freier Pr.) |9 978-3-642-04717-6 | ||
| 024 | 3 | |a 9783642047176 | |
| 028 | 5 | 2 | |a 12769216 |
| 035 | |a (OCoLC)608825893 | ||
| 035 | |a (DE-599)DNB996247602 | ||
| 040 | |a DE-604 |b ger |e rakddb | ||
| 041 | 0 | |a ger | |
| 044 | |a gw |c XA-DE-BE | ||
| 049 | |a DE-473 |a DE-20 |a DE-19 |a DE-91G |a DE-634 |a DE-11 |a DE-188 |a DE-1051 |a DE-Aug4 |a DE-739 | ||
| 082 | 0 | |a 005.133 |2 22/ger | |
| 084 | |a ST 250 |0 (DE-625)143626: |2 rvk | ||
| 084 | |a DAT 362f |2 stub | ||
| 084 | |a 004 |2 sdnb | ||
| 100 | 1 | |a Block-Berlitz, Marco |d 1978- |e Verfasser |0 (DE-588)138680116 |4 aut | |
| 245 | 1 | 0 | |a Haskell Intensivkurs |b ein kompakter Einstieg in die funktionale Programmierung |c Marco Block ; Adrian Neumann |
| 246 | 1 | 3 | |a Haskell |
| 264 | 1 | |a Heidelberg [u.a.] |b Springer |c 2011 | |
| 300 | |a XIX, 292 S. |b Ill., graph. Darst. | ||
| 336 | |b txt |2 rdacontent | ||
| 337 | |b n |2 rdamedia | ||
| 338 | |b nc |2 rdacarrier | ||
| 490 | 0 | |a Xpert.press | |
| 650 | 0 | 7 | |a Haskell 98 |0 (DE-588)4742681-0 |2 gnd |9 rswk-swf |
| 650 | 0 | 7 | |a HASKELL |0 (DE-588)4318275-6 |2 gnd |9 rswk-swf |
| 689 | 0 | 0 | |a Haskell 98 |0 (DE-588)4742681-0 |D s |
| 689 | 0 | |5 DE-604 | |
| 689 | 1 | 0 | |a HASKELL |0 (DE-588)4318275-6 |D s |
| 689 | 1 | |8 1\p |5 DE-604 | |
| 700 | 1 | |a Neumann, Adrian |e Verfasser |0 (DE-588)1018069860 |4 aut | |
| 776 | 0 | 8 | |i Erscheint auch als |n Online-Ausgabe |z 978-3-642-04718-3 |
| 856 | 4 | 2 | |m Digitalisierung UB Passau - ADAM Catalogue Enrichment |q application/pdf |u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=018631821&sequence=000004&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |3 Inhaltsverzeichnis |
| 999 | |a oai:aleph.bib-bvb.de:BVB01-018631821 | ||
| 883 | 1 | |8 1\p |a cgwrk |d 20201028 |q DE-101 |u https://d-nb.info/provenance/plan#cgwrk | |
Datensatz im Suchindex
| _version_ | 1804140702391599104 |
|---|---|
| adam_text | Inhaltsverzeichnis
1 Motivation und Einführung..................................... 1
1.1 Funktionale Programmierung................................ 2
1.1.1 Motivation und Anwendung.......................... 2
1.1.2 Warum gerade Haskell? ............................. 3
1.2 Grundbegriffe und Prinzipien der Programmentwicklung......... 3
1.3 Installation und Verwendung von Haskell...................... 4
1.3.1 Installation der aktuellen Version...................... 5
1.3.2 Die ersten Schritte in
Hugs
........................... 6
1.3.3 Arbeiten auf der Konsole............................ 6
1.3.4 Die Entwicklungsumgebung winhugs.................. 7
1.3.5 Erstellung und Verwendung von Skripten............... 8
1.4 Haskell ist mehr als ein Taschenrechner....................... 9
1.5 Vordefinierte Funktionen der
Prelude
......................... 10
Teil
I
Haskell-Grundlagen
2 Einfache Datentypen........................................... 15
2.1 Wahrheitswerte............................................ 16
2.1.1 Negation.......................................... 17
2.1.2 Konjunktion....................................... 17
2.1.3 Disjunktion........................................ 18
2.1.4 Exklusiv-Oder..................................... 18
IX
Inhaltsverzeichnis
2.1.5 Boolesche Algebra.................................. 19
2.1.6 Boolesche Gesetze.................................. 19
2.2 Zahlentypen.............................................. 21
2.2.1 Datentyp Int....................................... 21
2.2.2 Datentyp Integer.................................... 22
2.2.3 Datentypen
Float
und Double......................... 23
2.3 Zeichen und Symbole...................................... 23
2.4 Übungsaufgaben........................................... 24
Funktionen und Operatoren...................................... 25
3.1 Funktionen definieren...................................... 26
3.1.1 Parameterübergabe.................................. 27
3.1.2 Reservierte Schlüsselwörter.......................... 28
3.1.3 Wildcards......................................... 28
3.1.4 Signaturen und Typsicherheit......................... 29
3.1.5
Pattern matching
................................... 30
3.1.6
Pattern matching
mit
case
............................ 31
3.1.7 Lokale Definitionen mit
where
........................ 31
3.1.8 Lokale Definitionen mit let-in........................ 32
3.1.9 Fallunterscheidungen mit
Guards
...................... 33
3.1.10 Fallunterscheidungen mit if-then-else.................. 34
3.1.11 Kommentare angeben............................... 34
3.2 Operatoren definieren...................................... 35
3.2.1 Assoziativität und Bindungsstärke..................... 35
3.2.2 Präfixschreibweise — Operatoren zu Funktionen......... 36
3.2.3 Infixschreibweise — Funktionen zu Operatoren .......... 37
3.2.4 Eigene Operatoren definieren......................... 37
3.3
Lambda-Notation
.......................................... 38
3.4 Übungsaufgaben........................................... 39
Inhaltsverzeichnis xi
4 Rekursion als Entwurfstechnik.................................. 41
4.1 Rekursive Fakultätsfunktion................................. 42
4.2 Lineare Rekursion......................................... 43
4.3 Kaskadenförmige Rekursion................................. 44
4.4 Verschachtelte Rekursion................................... 45
4.5 Wechselseitige Rekursion................................... 46
4.6 Endständige Rekursion..................................... 46
4.7 Übungsaufgaben........................................... 46
5 Einfache Datenstrukturen....................................... 49
5.1 Listen.................................................... 50
5.1.1 Zerlegung in Kopf und Rest.......................... 51
5.1.2 Rekursive Listenfunktionen.......................... 53
5.1.3 Zusammenfassen von Listen.......................... 55
5.1.4 Automatische Erzeugung von Listen................... 56
5.1.5 Automatisches Aufzählen von Elementen............... 57
5.1.6
Lazy evaluation....................................
59
5.1.6.1 Unendliche Listen.......................... 59
5.1.6.2 Das Sieb des
Eratosthenes
................... 60
5.1.7 Listen zerlegen..................................... 61
5.2 Tupel.................................................... 62
5.2.1 Beispiel pythagoräisches Tripel....................... 63
5.2.2 Beispiel n-Dameproblem............................ 64
5.3 Zeichenketten............................................. 65
5.4 Übungsaufgaben........................................... 67
6 Funktionen höherer Ordnung................................... 69
6.1
Mapping
................................................. 71
6.2 Filtern................................................... 72
6.3 Faltung .................................................. 73
6.3.1 Faltung von rechts mit Startwert...................... 74
6.3.2 Faltung von rechts ohne Startwert..................... 77
xii Inhaltsverzeichnis
6.3.3 Faltung von links mit Startwert....................... 78
6.3.4 Faltung von links ohne Startwert...................... 79
6.3.5 Unterschied zwischen Links- und Rechtsfaltung......... 79
6.4 Entfaltung................................................ 80
6.4.1 Definition von
unfold
............................... 80
6.4.2
Mapping
durch
unfold...............................
81
6.5 Zip...................................................... 82
6.6
Unzip....................................................
82
6.7 Funktionskompositionen.................................... 83
6.8
Currying.................................................
85
6.9 Übungsaufgaben........................................... 87
Eigene Typen und Typklassen definieren.......................... 89
7.1 Typsynonyme mit type..................................... 90
7.2 Einfache algebraische Typen mit
data
und newtype.............. 91
7.2.1 Datentyp Tupel .................................... 94
7.2.2 Datentyp
Either
.................................... 94
7.2.3 Datentyp
Maybe
................................... 95
7.2.4 Datentypen mit mehreren Feldern ..................... 96
7.3 Rekursive Algebraische Typen............................... 98
7.4 Automatische Instanzen von Typklassen....................... 99
7.4.1 Typklasse Show....................................100
7.4.2 Typklasse
Read
....................................100
7.4.3 Typklasse Eq ......................................101
7.4.4 Typklasse
Ord
......................................101
7.4.5 Typklasse Enum ...................................101
7.4.6 Typklasse
Bounded
.................................102
7.5 Eingeschränkte
Polymorphic
................................102
7.6 Manuelles Instanziieren.....................................102
7.7 Projekt: Symbolische Differentiation..........................105
7.7.1 Operatorbaum......................................106
Inhaltsverzeichnis xiii
7.7.2 Polynome berechnen................................107
7.7.3 Ableitungsregeln...................................107
7.7.4 Automatisches Auswerten ...........................108
7.8 Eigene Klassen definieren...................................109
7.9 Übungsaufgaben...........................................110
8 Modularisierung und Schnittstellen..............................111
8.1 Module definieren.........................................112
8.2 Sichtbarkeit von Funktionen.................................112
8.3
Qualified imports
..........................................114
8.4 Projekt: Adressbuch........................................114
8.4.1 Modul Woerterbuch.................................114
8.4.2 Modul Adressbuch..................................115
8.4.3 Modul TestAdressbuch..............................116
8.5 Übungsaufgaben...........................................117
Teil
II
Fortgeschrittene Haskell-Konzepte
9 Laufzeitanalyse von Algorithmen................................121
9.1 Motivation................................................122
9.2 Landau-Symbole..........................................123
9.2.1 Obere Schranken
О
.................................123
9.2.2 Starke obere Schranken
о
............................124
9.2.3 Untere Schranken
Ω
................................124
9.2.4 Starke untere Schranken
ω
...........................125
9.2.5 Asymptotisch gleiches Wachstum
Θ
...................125
9.2.6 Definition über Grenzwerte von Quotientenfolgen .......125
9.3 Umgang mit Schranken und Regeln...........................125
9.4 Übersicht wichtiger Laufzeiten...............................127
9.5 Best,
Worst
und
Average Case...............................
127
9.6 Analysieren der Laufzeit....................................127
9.6.1 Fakultätsfunktion...................................128
xiv Inhaltsverzeichnis
9.6.2 Elemente in Listen finden............................129
9.6.3 Listen umdrehen ...................................130
9.6.4 Potenzen..........................................131
9.6.5 Minimum einer Liste................................133
9.7 Übungsaufgaben...........................................135
10
Arrays,
Listen und Stacks.......................................137
10.1
Arrays
...................................................138
10.1.1 Statische
Arrays
....................................138
10.1.2 Dynamische
Arrays
.................................140
10.2 Liste und Stack............................................141
10.3 Listen sortieren............................................142
10.3.1 SelectionSort......................................142
10.3.2 InsertionSort.......................................143
10.3.3 BubbleSort........................................144
10.3.4
Quicksort
.........................................146
10.3.5 MergeSort.........................................148
10.3.6 BucketSort........................................149
10.3.7 RadixSort.........................................150
10.4 Algorithmen auf Stacks.....................................152
10.4.1 Umgekehrte Polnische Notation.......................152
10.4.2 Projekt: Klammertest................................153
10.5 Übungsaufgaben...........................................155
11 Warteschlangen................................................157
11.1 Implementierung über Listen................................158
11.2 Amortisierte Laufzeitanalyse................................159
11.2.1 Bankiermethode....................................159
11.2.2 Analyse der Warteschlange...........................160
11.3 Erweiterung um
Lazy
Evaluation.............................160
11.4 Angepasste amortisierte Analyse.............................161
11.5 Beispielanwendung........................................163
11.6 Übungsaufgaben...........................................163
Inhaltsverzeichnis xv
12 Bäume........................................................165
12.1 Implementierung der Datenstruktur Baum.....................166
12.2 Balancierte Bäume.........................................167
12.3 Traversierungen...........................................168
12.3.1
Pre-,
In- und Postorder..............................168
12.3.2 Levelorder.........................................169
12.4 Übungsaufgaben...........................................170
13 Wörterbücher.................................................171
13.1 Analyse und Vorüberlegungen...............................172
13.2 Implementierung..........................................173
13.3 Laufzeitanalyse...........................................174
13.4 Übungsaufgaben...........................................175
14 Prioritätswarteschlangen.......................................177
14.1 Operationen und mögliche Umsetzungen......................178
14.2 Realisierung mit einer Liste.................................178
14.3 Realisierung mit einem Binärbaum...........................178
14.4 Zwei Bäume verschmelzen..................................180
14.5 Amortisierte Laufzeitanalyse von
merge
.......................181
14.6 Beispielanwendung........................................182
14.7 Übungsaufgaben...........................................183
15 Random-Access Listen..........................................185
15.1 Realisierung mit einem Suchbaum............................186
15.1.1 Preorder versus Inorder bei Binärbäumen...............186
15.1.2 Liste vollständiger Binärbäume.......................187
15.1.3 Verschmelzen mit Greedy-Strategie....................187
15.2 Implementierung der grundlegenden Listenfunktionen...........189
15.3 Implementierung von elementAn.............................190
15.4 Beispielanwendung........................................191
15.5 Übungsaufgaben...........................................192
xvi Inhaltsverzeichnis
16 Graphen......................................................193
16.1 Definition und wichtige Begriffe.............................194
16.2 Abstrakter Datentyp Graph..................................195
16.2.1 Adjazenzliste und Adjazenzmatrix ....................195
16.2.2 Implementierung der Adjazenzliste....................196
16.3 Algorithmen auf Graphen...................................197
16.3.1
Traversieren
von Graphen ...........................198
16.3.1.1 Tiefensuche im Graphen.....................199
16.3.1.2 Breitensuche im Graphen....................200
16.3.1.3 Implementierung von Tiefen-und Breitensuche .200
16.3.2 Topologisches Sortieren.............................204
16.4 Übungsaufgaben...........................................207
17 Monaden......................................................209
17.1 Einführung und Beispiele...................................210
17.1.1 Debug-Ausgaben ..................................210
17.1.1.1 Rückgabewert und Funktionskomposition......210
17.1.1.2 Eigene Eingabetypen definieren...............211
17.1.1.3 Identitätsfunktion...........................211
17.1.2 Zufallszahlen......................................212
17.2 Monaden sind eine Typklasse................................213
17.3 do-Notation...............................................214
17.3.1 Allgemeine Umwandlungsregeln......................214
17.3.2 Umwandlungsregeln für if-then-else...................215
17.3.3 Beispiel...........................................216
17.4 Vordefinierte Monaden.....................................217
17.4.1 Monade
Writer
.....................................217
17.4.2 Monade Reader....................................218
17.4.3 Monade State......................................220
17.4.4 Monade List.......................................222
Inhaltsverzeichnis xvii
17.5 Ein- und Ausgaben.........................................224
17.5.1 Stream-basierte Eingaben............................224
17.5.2 Monade
IO
........................................225
17.5.2.1 Bildschirmausgaben........................226
17.5.2.2 Tastatureingaben...........................227
17.5.2.3 Eingabepufferung ..........................227
17.5.2.4 Beispiel:
Hangman
.........................228
17.5.3 Dateien ein- und auslesen............................230
17.6 Übungsaufgaben...........................................231
18 Programme verifizieren und testen...............................233
18.1 Beweis durch vollständige Induktion..........................234
18.1.1 Die fünf Peano-Axiome.............................234
18.1.2 Beweiskonzept.....................................235
18.1.2.1 Gaußsche Summenformel....................235
18.1.2.2 Vier- und Fünf-Euro-Münze..................236
18.1.2.3 Fakultätsfunktion...........................236
18.1.3 Vollständige Induktion über Strukturen.................237
18.1.3.1 Induktion über Listen.......................238
18.1.3.2 Induktion über Bäume.......................239
18.2 QuickCheck..............................................240
18.2.1 Beispiel: Sortieren..................................241
18.2.2 QuickCheck für eigene Typen verwenden...............242
18.2.3 Testdatengeneratoren................................242
18.3 Übungsaufgaben...........................................243
19 Berechenbarkeit und Lambda-Kalkül............................245
19.1 Der Lambda-Kalkül........................................246
19.2 Formale Sprachdefinition...................................246
19.2.1 Bezeichner........................................246
19.2.2
λ
-Funktion
........................................247
19.2.3 Applikation........................................247
xviii Inhaltsverzeichnis
19.2.4 Reguläre
λ
-Ausdrücke
...............................247
19.3 Freie und gebundene Variablen...............................248
19.4
λ
-Ausdrücke
auswerten.....................................248
19.4.1
α
-Konversion......................................248
19.4.2 ß-Reduktion.......................................249
19.5 Boolesche Algebra.........................................250
19.5.1
True
und
False
.....................................250
19.5.2 Negation..........................................251
19.5.3 Konjunktion und Disjunktion.........................251
19.6 Tupel....................................................251
19.6.1 2-Tupel...........................................252
19.6.2 First und
Second
...................................252
19.7 Listen....................................................252
19.7.1
Head
- Kopf einer Liste.............................253
19.7.2
Tail
- Rest einer Liste...............................253
19.7.3
Empty
- Test auf eine leere Liste und Nil...............253
19.8 Arithmetik................................................254
19.8.1 Natürliche Zahlen..................................254
19.8.2
Zero
- Der Test auf Null.............................254
19.8.3
S
- Die Nachfolgerfunktion..........................255
19.8.4 Die Addition.......................................256
19.8.5 Die Multiplikation..................................257
19.8.6 Die Vorgängerfunktion..............................257
19.9 Rekursion................................................258
19.9.1 Alternative zu Funktionsnamen.......................258
19.9.2 Fixpunktkombinatoren..............................259
19.10 Projekt:
λ
-Interpreter
.......................................260
19.10.1
λ
-Ausdrücke
repräsentieren..........................261
19.10.2 Auswerten von
λ
-Ausdrücken
........................261
19.10.3 Freie und gebundene Variablen.......................263
19.10.4 Wörterbuch für Substitutionen........................263
19.10.5
λ
-Parser
...........................................265
19.11 Übungsaufgaben...........................................267
Inhaltsverzeichnis xix
Lösungen der Aufgaben.............................................269
Literaturverzeichnis................................................277
Sachverzeichnis....................................................281
|
| any_adam_object | 1 |
| author | Block-Berlitz, Marco 1978- Neumann, Adrian |
| author_GND | (DE-588)138680116 (DE-588)1018069860 |
| author_facet | Block-Berlitz, Marco 1978- Neumann, Adrian |
| author_role | aut aut |
| author_sort | Block-Berlitz, Marco 1978- |
| author_variant | m b b mbb a n an |
| building | Verbundindex |
| bvnumber | BV035772145 |
| classification_rvk | ST 250 |
| classification_tum | DAT 362f |
| ctrlnum | (OCoLC)608825893 (DE-599)DNB996247602 |
| dewey-full | 005.133 |
| dewey-hundreds | 000 - Computer science, information, general works |
| dewey-ones | 005 - Computer programming, programs, data, security |
| dewey-raw | 005.133 |
| dewey-search | 005.133 |
| dewey-sort | 15.133 |
| dewey-tens | 000 - Computer science, information, general works |
| discipline | Informatik |
| format | Book |
| fullrecord | <?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>02028nam a2200505 c 4500</leader><controlfield tag="001">BV035772145</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20211211 </controlfield><controlfield tag="007">t</controlfield><controlfield tag="008">091015s2011 gw ad|| |||| 00||| ger d</controlfield><datafield tag="015" ind1=" " ind2=" "><subfield code="a">09,N37,0018</subfield><subfield code="2">dnb</subfield></datafield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">996247602</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9783642047176</subfield><subfield code="c">PB. : EUR 29.95, sfr 43.50 (freier Pr.)</subfield><subfield code="9">978-3-642-04717-6</subfield></datafield><datafield tag="024" ind1="3" ind2=" "><subfield code="a">9783642047176</subfield></datafield><datafield tag="028" ind1="5" ind2="2"><subfield code="a">12769216</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)608825893</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)DNB996247602</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rakddb</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">ger</subfield></datafield><datafield tag="044" ind1=" " ind2=" "><subfield code="a">gw</subfield><subfield code="c">XA-DE-BE</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-473</subfield><subfield code="a">DE-20</subfield><subfield code="a">DE-19</subfield><subfield code="a">DE-91G</subfield><subfield code="a">DE-634</subfield><subfield code="a">DE-11</subfield><subfield code="a">DE-188</subfield><subfield code="a">DE-1051</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-739</subfield></datafield><datafield tag="082" ind1="0" ind2=" "><subfield code="a">005.133</subfield><subfield code="2">22/ger</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 250</subfield><subfield code="0">(DE-625)143626:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">DAT 362f</subfield><subfield code="2">stub</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">004</subfield><subfield code="2">sdnb</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Block-Berlitz, Marco</subfield><subfield code="d">1978-</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)138680116</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Haskell Intensivkurs</subfield><subfield code="b">ein kompakter Einstieg in die funktionale Programmierung</subfield><subfield code="c">Marco Block ; Adrian Neumann</subfield></datafield><datafield tag="246" ind1="1" ind2="3"><subfield code="a">Haskell</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Heidelberg [u.a.]</subfield><subfield code="b">Springer</subfield><subfield code="c">2011</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">XIX, 292 S.</subfield><subfield code="b">Ill., graph. Darst.</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="490" ind1="0" ind2=" "><subfield code="a">Xpert.press</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Haskell 98</subfield><subfield code="0">(DE-588)4742681-0</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">HASKELL</subfield><subfield code="0">(DE-588)4318275-6</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">Haskell 98</subfield><subfield code="0">(DE-588)4742681-0</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="1" ind2="0"><subfield code="a">HASKELL</subfield><subfield code="0">(DE-588)4318275-6</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2=" "><subfield code="8">1\p</subfield><subfield code="5">DE-604</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Neumann, Adrian</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)1018069860</subfield><subfield code="4">aut</subfield></datafield><datafield tag="776" ind1="0" ind2="8"><subfield code="i">Erscheint auch als</subfield><subfield code="n">Online-Ausgabe</subfield><subfield code="z">978-3-642-04718-3</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">Digitalisierung UB Passau - ADAM Catalogue Enrichment</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=018631821&sequence=000004&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="999" ind1=" " ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-018631821</subfield></datafield><datafield tag="883" ind1="1" ind2=" "><subfield code="8">1\p</subfield><subfield code="a">cgwrk</subfield><subfield code="d">20201028</subfield><subfield code="q">DE-101</subfield><subfield code="u">https://d-nb.info/provenance/plan#cgwrk</subfield></datafield></record></collection> |
| id | DE-604.BV035772145 |
| illustrated | Illustrated |
| indexdate | 2024-07-09T22:04:11Z |
| institution | BVB |
| isbn | 9783642047176 |
| language | German |
| oai_aleph_id | oai:aleph.bib-bvb.de:BVB01-018631821 |
| oclc_num | 608825893 |
| open_access_boolean | |
| owner | DE-473 DE-BY-UBG DE-20 DE-19 DE-BY-UBM DE-91G DE-BY-TUM DE-634 DE-11 DE-188 DE-1051 DE-Aug4 DE-739 |
| owner_facet | DE-473 DE-BY-UBG DE-20 DE-19 DE-BY-UBM DE-91G DE-BY-TUM DE-634 DE-11 DE-188 DE-1051 DE-Aug4 DE-739 |
| physical | XIX, 292 S. Ill., graph. Darst. |
| publishDate | 2011 |
| publishDateSearch | 2011 |
| publishDateSort | 2011 |
| publisher | Springer |
| record_format | marc |
| series2 | Xpert.press |
| spelling | Block-Berlitz, Marco 1978- Verfasser (DE-588)138680116 aut Haskell Intensivkurs ein kompakter Einstieg in die funktionale Programmierung Marco Block ; Adrian Neumann Haskell Heidelberg [u.a.] Springer 2011 XIX, 292 S. Ill., graph. Darst. txt rdacontent n rdamedia nc rdacarrier Xpert.press Haskell 98 (DE-588)4742681-0 gnd rswk-swf HASKELL (DE-588)4318275-6 gnd rswk-swf Haskell 98 (DE-588)4742681-0 s DE-604 HASKELL (DE-588)4318275-6 s 1\p DE-604 Neumann, Adrian Verfasser (DE-588)1018069860 aut Erscheint auch als Online-Ausgabe 978-3-642-04718-3 Digitalisierung UB Passau - ADAM Catalogue Enrichment application/pdf http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=018631821&sequence=000004&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA Inhaltsverzeichnis 1\p cgwrk 20201028 DE-101 https://d-nb.info/provenance/plan#cgwrk |
| spellingShingle | Block-Berlitz, Marco 1978- Neumann, Adrian Haskell Intensivkurs ein kompakter Einstieg in die funktionale Programmierung Haskell 98 (DE-588)4742681-0 gnd HASKELL (DE-588)4318275-6 gnd |
| subject_GND | (DE-588)4742681-0 (DE-588)4318275-6 |
| title | Haskell Intensivkurs ein kompakter Einstieg in die funktionale Programmierung |
| title_alt | Haskell |
| title_auth | Haskell Intensivkurs ein kompakter Einstieg in die funktionale Programmierung |
| title_exact_search | Haskell Intensivkurs ein kompakter Einstieg in die funktionale Programmierung |
| title_full | Haskell Intensivkurs ein kompakter Einstieg in die funktionale Programmierung Marco Block ; Adrian Neumann |
| title_fullStr | Haskell Intensivkurs ein kompakter Einstieg in die funktionale Programmierung Marco Block ; Adrian Neumann |
| title_full_unstemmed | Haskell Intensivkurs ein kompakter Einstieg in die funktionale Programmierung Marco Block ; Adrian Neumann |
| title_short | Haskell Intensivkurs |
| title_sort | haskell intensivkurs ein kompakter einstieg in die funktionale programmierung |
| title_sub | ein kompakter Einstieg in die funktionale Programmierung |
| topic | Haskell 98 (DE-588)4742681-0 gnd HASKELL (DE-588)4318275-6 gnd |
| topic_facet | Haskell 98 HASKELL |
| url | http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=018631821&sequence=000004&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |
| work_keys_str_mv | AT blockberlitzmarco haskellintensivkurseinkompaktereinstiegindiefunktionaleprogrammierung AT neumannadrian haskellintensivkurseinkompaktereinstiegindiefunktionaleprogrammierung AT blockberlitzmarco haskell AT neumannadrian haskell |