Haskell-Intensivkurs 1. Auflage, Springer-Verlag
Marco Block und Adrian Neumann

Aktualisierte Errata (Stand 04.04.2011)

-----------------------------------------------
Abschnitt 2.1.6 (Seite 20)
	Die abschließende Umformung hat einen Fehler.
	Es sollte in der zweiten Zeile korrekterweise 
	heißen:

	(!a & a) | (!a & !b)

	mit ! für not, & für and und | für or.

	Danke an Wolfgang Nádasi-Donner
-----------------------------------------------
Abschnitt 3.2.2 (Seite 37)
	Durch die Bindungsstärke der Operatoren (== vor &&)
	wird das Beispiel:

	Hugs> True && True == (&&) True True

	wie folgt ausgewertet:
	> True && (True == (&&) True True)
	> True && True
	> True

	Da das Beispiel aber der Auswertung der Präfixschreibweise
	dienen soll, müsste es korrekt wie folgt angegeben werden:

	Hugs> (True && True) == ((&&) True True)

	Danke an Wolfgang Nádasi-Donner 
-----------------------------------------------
Abschnitt 4.1 (Seite 43)
	Bei der Umwandlung der Fakultätsfunktion in die Lambda-Notation
	hat sich ein kleiner Fehler eingeschlichen:
	
	fakultaet = \n -> (if n==1 then 1 else (n*fakultaet (n-1)))
	
	Es sollte selbstverständlich nicht n==1 sondern n==0 heißen:
	
	fakultaet = \n -> (if n==0 then 1 else (n*fakultaet (n-1)))
	
	Danke an Rolf Speer
-----------------------------------------------
Abschnitt 5.1.7 (Seite 62)
	Es sollte im ersten Satz analog zum nachfolgenden Programmcode 
	heißen:

	nimm :: [Int] -> [a] -> [a]

	Danke an Jürgen Peters
-----------------------------------------------
Abschnitt 6.3.5 (Seite 80)
	Im Beispiel zur Rechtsfaltung sollte es 
	heißen:

	foldr (-) 1 [1 .. 3] = - 1 (- 2 (- 3 1))
						 = - 1 (- 2 2)
						 = - 1 0
						 = 1	

	Danke an Baris Top					 
-----------------------------------------------
Abschnitt 10.2 (Seite 142)
	Hier wurden die Prinzipien der Warteschlange und
	mit dem Stack vertauscht. Es sollte richtig heißen:
	
	... entfernt werden (LIFO-Prinzip, last-in-first-out).
	
	Danke an Robert Philipps
-----------------------------------------------
Abschnitt 19.4.2 (Seite 249)
	Ein Fehler in der letzten Umformung (L = Lambda). Es
	sollte heißen:

	... = y ((La.b)(La.b))
	    = y b
	
	Danke an Tobias Nelsen
-----------------------------------------------
Anhang A - Lösungen der Aufgaben (Seite 269)
Kapitel 2, Aufgabe 1
	Da Wildcards zu diesem Zeitpunkt noch garnicht
	bekannt sind, sollten die Lösungen ohne && und ||
	vollständig wie folgt aussehen:

	and, or :: Bool -> Bool -> Bool
	and True  True  = True
	and True  False = False
	and False True  = False
	and False False = False

	or  True  True  = True
	or  True  False = True
	or  False True  = True
	or  False False = False

	Danke an Wolfgang Nádasi-Donner
-----------------------------------------------

Vielen Dank für das intensive Lesen! Für jeden Hinweis, 
der das Buch besser machen kann, sind wir dankbar.

"Aus den Fehlern der anderen lernt der Weise."/
"Ex vitio alterius sapius emendat suum."
[Publilius Syrus, Sententiae 150]