Index

“

• @“@ — Ch. 16

&

• & — Ch. 17

+

• O — Ch. 20

=

• => — Ch. 13

>

• >*> — Ch. 17, Operators
• >.> — Ch. 11, Operators
• >>= — Ch. 18, Operators
• >@> — Ch. 18

A

• abstract data type — Ch. 15, Ch. 16, Ch. 20, Appendix, Glossary
  • `wrapping up’ representation — Ch. 16
  • and classes — Ch. 16
  • modifying implementation — Ch. 16
  • queue — Ch. 16
    • as list — Ch. 16
    • as two lists — Ch. 16
  • search tree — Ch. 16
    • deletion — Ch. 16
    • insertion — Ch. 16
  • sets — see sets
  • signature — Ch. 16
  • store — see store
  • Store — Ch. 16
  • testing — Ch. 16
• abstraction — Ch. 17
  • type — Ch. 1
• action, I/O — Ch. 8
• actions — Ch. 18
• actual parameter — Ch. 1
• addition
  • function diagram — Ch. 1
  • type diagram — Ch. 1
• ADT — see abstract data type
• advantages of functional programming — Ch. 17
• Agda — Ch. 21
• algebraic type — Ch. 5, Ch. 14, Appendix, Glossary
  • alternatives — Ch. 5
  • compared with tuple — Ch. 5
  • general form — Ch. 5
  • general form of definition — Ch. 14
  • pattern matching — Ch. 5
  • polymorphic — Ch. 14
  • proofs — Ch. 14
  • recursive — see recursive type
  • vs ADT — Ch. 16
• ∀ — Ch. 9
• application — see function application
• application operator ($) — Ch. 11
  • and composition — Ch. 11
• argument — Ch. 1, Glossary
  • order of arguments — Ch. 11
  • tuple — Ch. 5
• assignment
  • and <- — Ch. 8
  • single — Ch. 8
• associativity — Ch. 3, Ch. 11, Ch. 14, Ch. 18, Glossary
  • arrow not associative — Ch. 11
  • left/right — Ch. 3
• assumptions — Ch. 9

B

• backquote (`) — Ch. 3
• backslash () — Ch. 3
• backtracking — Ch. 17
• (base) — Ch. 9
• behaviour — Ch. 12, Ch. 20
  • space — Ch. 20
    • local definitions — Ch. 20
  • time — Ch. 20
• binary tree — see tree
• binding power — Ch. 3
• Boole, George — Ch. 3
• Boolean — Ch. 3
  • conditional expression — Ch. 3
  • guard — see guard
• Booleans — Ch. 3, Glossary
• :browse — Ch. 2

C

• Cabal — Ch. 1, Ch. 2, Ch. 6
  • cabal commands — Ch. 6
• calculation — Ch. 1, Ch. 7, Ch. 12, Glossary
  • and recursion — Ch. 4
  • guards — Ch. 3
  • local definitions — Ch. 4
  • over graphs — Ch. 17
  • rules — Ch. 17
• calculator — Ch. 14, Ch. 16, Ch. 17, Ch. 18
• case studies
  • calculator — see calculator
  • Huffman codes — see Huffman codes
  • parsing — see parsing
  • pictures — see pictures
  • sets — see sets
  • simulation — see simulation
• characters — Ch. 1, Ch. 3, Glossary
  • ASCII coding — Ch. 3
  • end-of-file — Ch. 3
  • literal — Ch. 3
  • tab — Ch. 3
  • Unicode — Ch. 3
• classes — Ch. 13, Appendix, Glossary
  • and ADTs — Ch. 16
  • and algebraic types — Ch. 14
  • and OO programming — Ch. 13
  • as adjective — Ch. 13
  • context — Ch. 13
  • context simplification — Ch. 16
  • default definitions — Ch. 13
  • derived — Ch. 13
  • diagram for Haskell 2010 — Ch. 13
  • general form of definition — Ch. 13
  • instance — Ch. 13
  • limitations — Ch. 13
  • numeric — Ch. 13
  • overriding defaults — Ch. 14
  • putting together — Ch. 14
  • type checking — Ch. 13
• clause — Ch. 3, Glossary
• Codespaces — Other implementations
• coding — Ch. 15
  • Huffman — Ch. 15
  • prefix codes — Ch. 15
  • tree — Ch. 15
• combinator — Ch. 12, Ch. 19
• comment — Ch. 2, Glossary
  • nested — Ch. 2
  • symbol — Ch. 2
• compiler — Ch. 1
• complexity — Ch. 20, Glossary
  • ++ — Ch. 20
  • fac — Ch. 20
  • iSort — Ch. 20
  • linear — Ch. 20, Glossary
  • qSort — Ch. 20
  • quadratic — Ch. 20, Glossary
  • space — Ch. 20
  • time — Ch. 20
• composition — see function composition
• concatenate — Glossary
• conditional equation — Ch. 3, Glossary
• conditional expression — Ch. 3
• cons — Ch. 7
• constraint — Ch. 1, Ch. 6, Ch. 13
  • in type checking — Ch. 13
• constructor — Ch. 3, Ch. 5, Ch. 7, Ch. 14, Glossary
  • binary — Ch. 5
  • infix — Ch. 14
  • nullary — Ch. 5
  • pattern matching — Ch. 7
  • unary — Ch. 5
• context — Ch. 13, Glossary
  • multiple — Ch. 13
  • simplifying — Ch. 13, Ch. 16
• conventions
  • capitalizing internal words — Ch. 3
  • list variables — Ch. 7
  • local type declarations — Ch. 4
  • module file names — Ch. 15
  • names of properties — Ch. 10
  • type comments in module headers — Ch. 16
  • type variable names — Ch. 6
  • types specified — Ch. 3
• counting — Ch. 20
• Curry, Haskell B. — Ch. 1, Ch. 11
  • biography — Ch. 21
• currying — Ch. 11, Glossary
  • reasons for — Ch. 11

D

• data type — see algebraic type
• data-directed programming — Ch. 17, Appendix
• database — Ch. 6
• debugging — Ch. 9
• declaration — Glossary
• deep embedding — Ch. 19
• default — Glossary
• definedness — Ch. 9
• definition — Ch. 1, Glossary
  • constant
    • reason for — Ch. 6
  • function — Ch. 1
  • local — Ch. 4
  • visibility of — Ch. 15
• design — Ch. 4, Appendix, Glossary
  • abstract data types — Ch. 16
  • and algebraic types — Ch. 14
  • and behaviour — Ch. 20
  • and infinite lists — Ch. 17
  • bottom up — Ch. 7
  • choices in — Ch. 12
  • data-directed — Ch. 12, Ch. 17
  • divide and conquer — Ch. 4
  • error handling — Ch. 14
  • function composition — Ch. 12
  • Huffman coding system — Ch. 15
  • index example — Ch. 12
  • iterative — Ch. 4
  • list functions — Ch. 7
  • modules — Ch. 15
  • monads and — Ch. 18
  • top-down — Ch. 4, Ch. 7
  • type classes — Ch. 14
  • types — Ch. 4
  • what if? — Ch. 4
  • where do I start? — Ch. 4, Ch. 7
• div — Operators
• divide and conquer — Ch. 4, Ch. 15, Ch. 16, Ch. 20
• do notation — Ch. 8, Ch. 18
  • local definitions — Ch. 8
• Docker — Other implementations
• document index — Ch. 12, Ch. 16
• documentation — Ch. 15
  • GHCi — Ch. 6
  • Hackage — Ch. 6
  • Hoogle — Ch. 6
  • libraries — Ch. 6
  • prelude — Ch. 6
  • system — Ch. 6
• domain — Ch. 1
• domain-specific language — see DSL
• double quote (“) — Ch. 3
• downloading support materials — Ch. 2, Other implementations
• DSL — Ch. 1, Ch. 19
  • deep embedding — Ch. 19
  • embedded — Ch. 1, Ch. 19
  • examples — Ch. 19
  • extension — Ch. 19
  • hardware description — Ch. 19
  • monadic — Ch. 19
  • naming — Ch. 19
  • pictures — Ch. 1
  • project ideas — Projects
  • regular expressions — Ch. 19
  • shallow embedding — Ch. 19
  • shallow or deep? — Ch. 19
  • stand-alone — Ch. 19
  • taking it further — Ch. 19
  • transformation — Ch. 19
  • value recursion — Ch. 19
  • why in Haskell? — Ch. 19
• dummy values at errors — Ch. 14
• dynamic programming — Ch. 20

E

• Eddie — Ch. 16
• :edit — Ch. 2
• edit distance — Ch. 14
• editors for Haskell — Other implementations
• Electric Aunt Jemima — see Jemima, Electric Aunt
• elem — Operators
• enumerated type — Ch. 4, Ch. 5, Glossary
• equality — Ch. 3, Ch. 13, Ch. 17
  • infinite lists — Ch. 17
  • on pairs — Ch. 13
  • type of — Ch. 3
• equation — Ch. 1, Glossary
  • conditional — Glossary
• Eratosthenes — Ch. 17
• error handling — Ch. 14
  • error transmission — Ch. 14
  • error trapping — Ch. 14
  • error type — Ch. 14
• errors — Ch. 2, Errors
  • and classes — Ch. 13
  • error message — Ch. 2
  • layout — Ch. 3
  • module — Errors
  • offside rule — Ch. 3
  • program — Ch. 2, Errors
  • syntax — Ch. 2, Errors
  • type — Ch. 2, Errors
  • type abstraction — Ch. 16
  • type error messages — Ch. 13
• evaluation — Ch. 1, Glossary
  • definedness of — Ch. 9
  • interrupt — Ch. 5
  • interruption — Ch. 17
  • step-by-step — Ch. 1
  • symbolic — Ch. 9
• evaluation order — Ch. 17
• examples
  • document index — see document index
  • edit distance — see edit distance
  • library database — see library database
  • supermarket billing — see supermarket billing
  • text processing — see text processing
• exclusive or — Ch. 3
• export — Ch. 15, Glossary
• expression — Ch. 1, Glossary
  • conditional — Ch. 3
• expression type — see Expr
• extended exercise
  • card games — Ch. 6
  • picture implementations — Ch. 6
  • positioned pictures — Ch. 6
• extension — Ch. 2
• extensionality principle — Ch. 11, Ch. 17, Glossary

F

• factorial — Ch. 4, Ch. 17, Ch. 20
  • complexity of — Ch. 20
• feedback — Ch. 17
• Fibonacci numbers — Ch. 4, Ch. 5, Ch. 17, Ch. 20
• filter — Ch. 10, Ch. 11, Glossary
  • type of — Ch. 10
• finiteness — Ch. 9
• first-class citizens, functions — Ch. 1
• fixity — Ch. 3
  • declaration — Ch. 14, Operators
• Flo — Ch. 16
• floating point operators — Ch. 3, Operators
• floating-point operators — Ch. 13
• folding — Ch. 10, Ch. 20, Glossary
  • and primitive recursion — Ch. 10
  • designing folds — Ch. 20
• foldl — Ch. 20
  • type of — Ch. 20
• foldr — Ch. 10, Ch. 11, Ch. 13, Ch. 20
  • type of — Ch. 10, Ch. 13
• foldr1 — Ch. 10
  • type of — Ch. 10
• formal parameter — Ch. 1
• forward composition — Ch. 11, Glossary
• fp-list — Ch. 17
• Frank — Ch. 10
• free variable — Ch. 9
• function — Ch. 1, Appendix, Glossary
  • anonymous — Ch. 11
  • as data — Ch. 11, Ch. 12
  • binary — Ch. 3
  • box diagram — Ch. 1, Ch. 3
  • curried — see currying
  • definition — Ch. 1
  • definition of polymorphic — Ch. 6
  • first-class citizens — Ch. 1
  • higher-order — Ch. 10
  • infix — Ch. 10, Glossary
  • infix version of — Ch. 3
  • inverse — Ch. 11
  • lazy — Ch. 20
  • number of arguments — Ch. 11
  • overloaded — see overloading
  • prefix — Ch. 10, Glossary
  • representing properties — Ch. 10
  • selector — Ch. 5
  • strict — Ch. 20
• function application — Ch. 1, Ch. 3, Glossary
  • partial — see partial application
  • syntax — Ch. 11
• function composition — Ch. 1, Ch. 11, Ch. 12, Ch. 13, Ch. 18, Glossary
  • and application ($) — Ch. 11
  • as pipeline — Ch. 12
  • associative — Ch. 11
  • binding power of — Ch. 11
  • forward — Ch. 11
  • type of — Ch. 11
• function definition
  • as description — Ch. 9
  • general case
    • single equation — Ch. 1
  • general form — Ch. 3, Ch. 4
  • layout — see layout
  • redefining prelude functions — Ch. 3
• functional pictures — Ch. 1
• functional program — Ch. 1
• functional programming — Ch. 1
  • advantages of — Ch. 21
  • future direction of — Ch. 21
  • other languages — Ch. 21
  • pure — Glossary

G

• general recursion — Ch. 4
  • over lists — Ch. 7
• generalization — Ch. 10, Ch. 12, Ch. 16, Glossary
• generator — Ch. 19
• genericity — Ch. 6
• GHC — Ch. 2
  • languages within — Ch. 19
  • performance measurement — Ch. 20
• GHCi — Ch. 1, Ch. 2
  • commands — Ch. 2
    • shortened form — Ch. 2
  • documentation — Ch. 2, Ch. 6, Other implementations
  • editing — Ch. 2
  • errors — Errors
  • expression evaluation — Ch. 2
  • first session — Ch. 2
  • help — Ch. 2
  • modules in — Ch. 2
  • understanding error messages — Ch. 3
• GHCup — Ch. 1, Ch. 2, Ch. 6, Other implementations
  • first steps — Ch. 2
• Glasgow Haskell Compiler — see GHC
• graph — Ch. 16
  • path in — Ch. 16
  • routes through — Ch. 17
  • search — Ch. 16
    • breadth-first — Ch. 16
    • depth-first — Ch. 16
  • strongly connected components — Ch. 16
• greedy algorithm — Ch. 20
• Greggery Peccary — see Peccary, Greggery
• guard — Ch. 3, Glossary
  • calculation — Ch. 17

H

• Hackage — Ch. 2
  • Craft3e — Ch. 2
• HackageDB — Ch. 1, Ch. 6
• Haddock — Ch. 6
• Hamming numbers — Ch. 17
• hardware — Ch. 1
• Haskell — Ch. 1
  • further features — Ch. 21
  • implementations — Other implementations
  • prospects — Ch. 21
  • what to read next — Ch. 21
• Haskell 2010 — Ch. 6, Ch. 21
  • and GHC Haskell — Ch. 13
  • classes diagram — Ch. 13
• Haskell Language Server — Ch. 2
• +Haskell Stores+ — Ch. 6
• haskell.org — Ch. 1
• higher-order function — Ch. 10, Ch. 11, Appendix, Glossary
  • defining HOFs — Ch. 11, Ch. 12
  • graphics — Ch. 12
  • proofs — Ch. 11
  • QuickCheck — Ch. 11
• HLS — Ch. 2
• Hoogle — Ch. 6
• .hs — Ch. 2
• Huffman codes — Ch. 15, Ch. 20
• (hyp) — Ch. 9

I

• I/O — Ch. 2, Ch. 8, Ch. 18
  • as lazy lists — Ch. 18
  • basics — Ch. 8
  • capturing values read — Ch. 8
  • do notation — Ch. 8
  • errors — Ch. 18
  • files — Ch. 18
  • history — Ch. 8
  • imperative programs — Ch. 8
  • input — Ch. 8
  • local definitions — Ch. 8
  • loops and recursion — Ch. 8
  • output — Ch. 8
  • returning a value — Ch. 8
  • running a program — Ch. 8
• idempotence — Ch. 11
• identifier — Ch. 1, Ch. 3, Glossary
  • reserved — Errors
• identity — Ch. 9, Ch. 18
• if — Ch. 3, Ch. 13
• IHaskell — Other implementations
• imperative programming — Appendix
  • and monads — Ch. 18
• implementation — Ch. 1
• implication () — Ch. 9
• inclusive or — Ch. 3
• (ind) — Ch. 9
• induction — Ch. 9, Glossary
  • base case — Ch. 9
  • choice of induction variable — Ch. 9
  • finding proofs — Ch. 9
  • for lists — Ch. 9
  • generalizing the goal — Ch. 9
  • induction hypothesis — Ch. 9
  • induction step — Ch. 9
  • justification of — Ch. 9
• infinite lists — see lists, infinite
• infix version of a function — Ch. 3
• :info — Ch. 2
• infoCheck — Ch. 13
• information hiding — Ch. 15
• inheritance — Ch. 13, Glossary
  • multiple — Ch. 13
• input — Ch. 1, Glossary
• input/output — see I/O
• instance — Ch. 6, Glossary
  • default — Ch. 13
  • derived — Ch. 13, Glossary
  • different meanings in Haskell — Ch. 13
  • of class — Ch. 13, Glossary
  • of variable — Glossary
• intensionality — Ch. 11
• interactive programs — Ch. 18
• interface — Ch. 13, Ch. 15, Ch. 16, Appendix, Glossary
• interpreter — Ch. 1, Ch. 19
• invariant — Ch. 16
• IO — see I/O

J

• Jemima, Electric Aunt — Ch. 5
• juxtaposition — Glossary

K

• keyword — Errors
• Kleisli composition — Ch. 18

L

• lambda abstraction — Ch. 11
• lambda calculus — Ch. 1
• lambda expression — Glossary
• layout — Ch. 3
  • recommended — Ch. 3, Ch. 4
• lazy evaluation — Ch. 17, Appendix, Glossary
• libraries, finding your way around — Ch. 6
• library database — Ch. 5, Ch. 10, Ch. 14
• list comprehensions — Ch. 5, Ch. 6, Ch. 10, Ch. 17, Appendix
  • calculation rules — Ch. 17
  • generator — Ch. 5, Ch. 17
  • infinite — Ch. 17
  • infinite generators — Ch. 17
  • library database — Ch. 5
  • multiple generators — Ch. 17
  • pitfalls — Ch. 5
  • refutable patterns — Ch. 17
  • syntax — Ch. 17
  • test — Ch. 5, Ch. 17
• list of successes method — Ch. 17
• lists — Ch. 1, Ch. 5, Glossary
  • algebraic type of — Ch. 14
  • and sets — Ch. 16
  • approach taken — Ch. 5
  • as Pascal type — Appendix
  • as processes — Ch. 17, Ch. 20
  • as sets — Ch. 20
  • bisection of — Ch. 20
  • constructor — Ch. 7
  • defined — Ch. 17
  • defining functions — Ch. 7
  • finite/partial — Ch. 17
  • head — Ch. 7
  • infinite — Ch. 9, Ch. 17, Appendix
    • approximation to — Ch. 17
    • why? — Ch. 17
  • minimum of — Ch. 17
  • partial — Ch. 17
  • partially defined — Ch. 9
  • permutations — Ch. 17
  • prelude functions — Ch. 6
  • tail — Ch. 7
• literal — Ch. 3, Glossary
  • negative — Ch. 3
  • overloaded — Ch. 3
• :load — Ch. 2
• local definitions — Glossary
  • calculation — Ch. 17

M

• map — Ch. 1, Ch. 10, Ch. 11, Ch. 14
  • defined using foldr — Ch. 20
  • type of — Ch. 10
• mapping — Ch. 10, Glossary
• mathematical induction — Ch. 17, Appendix, Glossary
• maximal common subsequence — Ch. 20
• memoization — Ch. 20, Glossary
• Miranda — Ch. 21
• mod — Operators
• modelling — Ch. 1
• modules — Ch. 2, Ch. 15, Glossary
  • ADT via export list — Ch. 16
  • errors — Errors
  • export list — Ch. 15
  • hierarchical names — Ch. 6
  • import list — Ch. 15
  • instance declarations — Ch. 16
  • interface documentation — Ch. 15
  • introduction — Ch. 2
  • local name on import — Ch. 15
  • multiple-module projects — Ch. 2
  • structure diagram — Ch. 15
• monad — Ch. 18, Appendix, Glossary
  • advantages of monads — Ch. 18
  • and imperative programming — Ch. 18
  • definition — Ch. 18
  • examples — Ch. 18
  • failure in (fail) — Ch. 18
  • further reading — Ch. 18
  • identity — Ch. 18
  • list — Ch. 18
  • Maybe — Ch. 18
  • parsing — Ch. 18
  • properties — Ch. 18
  • state — Ch. 18
  • terminology — Ch. 18
  • trees — Ch. 18
• monotype — Ch. 13
• multiplicity — Ch. 16

N

• name — Ch. 1, Ch. 3, Ch. 17, Glossary
  • and strings and characters — Ch. 3
  • overloading of — Ch. 3
  • qualified — Ch. 15
  • type — Ch. 1
  • value — Ch. 1
• naming newtypes — Ch. 16
• newline (n) — Ch. 3
• notElem — Operators
• numbers
  • conversion between types — Ch. 3
  • defined — Ch. 17
  • floating point — Ch. 3, Glossary
  • floating-point — Ch. 13
  • Fractional — Ch. 13
  • integer literals — Ch. 13
  • integers — Ch. 3, Glossary
  • Integral — Ch. 13
  • natural numbers — Ch. 3, Ch. 12, Glossary
  • non-numerical results — Ch. 3
  • Num — Ch. 13
  • prime — Ch. 17
  • random — Ch. 17
  • scientific notation — Ch. 3

O

• object-oriented — Ch. 13
• offside rule — Ch. 3, Ch. 4, Glossary
• operation — Ch. 1
• operator — Ch. 1, Ch. 3, Glossary
  • as function — Ch. 1
  • associativity of — Ch. 3
  • binding power of — Ch. 3, Glossary
  • calculation — Ch. 17
  • definitions of — Ch. 3
  • floating point — Ch. 3
  • infix — Ch. 3
  • table of properties — Operators
  • type checking — Ch. 13
• operator sections — Ch. 11, Ch. 20, Glossary
• order — Ch. 3, Ch. 20
  • lexicographic — Ch. 7
  • partial — Ch. 16
  • total — Ch. 16
• output — Ch. 1, Glossary
• overloaded literals
  • integer — Ch. 13
• overloading — Ch. 3, Ch. 13, Glossary
  • advantages of — Ch. 14
  • and polymorphism — Ch. 6
  • literals — Ch. 3
  • reason for — Ch. 13

P

• package — Ch. 6
• palindrome — Ch. 12
• Paradise — Ch. 19
• parameter — Ch. 1, Glossary
  • actual — Ch. 1
  • formal — Ch. 1
• parentheses — Ch. 7
  • different roles in Haskell — Ch. 11
• parsing — Ch. 17, Glossary
  • and read — Ch. 17
  • basic parsers — Ch. 17
  • combinators — Ch. 17
  • expressions — Ch. 17
  • library — Ch. 17
  • monad — Ch. 18
  • top-level parser — Ch. 17
• partial application — Ch. 11, Glossary
  • and currying — Ch. 11
  • type of — Ch. 11
• pattern — Ch. 5, Glossary
  • consistent with type — Ch. 13
  • nested — Ch. 5
  • refutable — Ch. 17
  • wild card — Glossary
• pattern matching — Ch. 3, Ch. 5, Ch. 7, Ch. 14, Ch. 17
  • “@: `as’ pattern — Ch. 16
  • algebraic type — Ch. 5
  • and parentheses — Ch. 7
  • calculation — Ch. 17
  • conformal — Glossary
  • constructors — Ch. 7
  • in expressions — Ch. 7
  • literals — Ch. 7
  • repeated variables — Ch. 7
  • sequentiality — Ch. 7
  • sequentiality of — Ch. 7
  • variables — Ch. 7
  • wildcard (`_’) — Ch. 7
• pattern of computation — Ch. 10
  • over lists — Ch. 10
• Peccary, Greggery — Ch. 6, Ch. 10
• performance
  • measurement in GHC — Ch. 20
• pictures — Ch. 1, Ch. 2, Ch. 6, Ch. 10, Ch. 11, Ch. 12, Ch. 19
  • alternative representation of — Ch. 6
  • extended exercise — Ch. 4
  • horse — Ch. 1
• pipeline — Ch. 12
• pitfalls
  • ; in error message — Ch. 3
  • Char and String — Ch. 3
  • function application — Ch. 3
  • infinite list generators — Ch. 17
  • list comprehensions — Ch. 5
  • module names — Ch. 6
  • negative literals — Ch. 3
  • numeric conversions — Ch. 3
  • paired arguments — Ch. 5
  • repeated variables in patterns — Ch. 7
  • type and constructor names — Ch. 5
  • type and data — Ch. 5
• playground — Other implementations
• plumbing — Ch. 11
• point-free programming — Ch. 11
• pointer — Appendix
• polymorphism — Ch. 1, Ch. 6, Appendix, Glossary
  • and overloading — Ch. 6
  • function definition — Ch. 6
  • type checking — Ch. 13
• prelude, redefining functions in — Ch. 3
• primitive recursion — Ch. 4, Ch. 14, Ch. 17, Glossary
  • and folding — Ch. 10
  • base case — Ch. 14
  • examples on numbers — Ch. 4
  • finding definitions — Ch. 7
  • list — Ch. 7
  • recursive case — Ch. 14
  • template — Ch. 4
• processes — Ch. 17
• product type — Ch. 5
• program — Ch. 1
• program development — Ch. 12
  • in practice — Ch. 12
• program error — Ch. 2, Errors
• program modification — Ch. 16
• program transformation — Ch. 1, Ch. 11, Ch. 19, Glossary
• programming language — Ch. 1, Ch. 19
  • high-level — Ch. 1
• programming paradigm — Ch. 1
• programming paradigms
  • comparison — Ch. 1
• project ideas — Projects
• prompt — Ch. 2
• proof — Ch. 1, Ch. 9, Ch. 12, Appendix, Glossary
  • abstract data types and — Ch. 16
  • algebraic types — Ch. 14
  • and QuickCheck — Ch. 9
  • and testing — Ch. 9
  • as documentation — Ch. 15
  • by cases — Ch. 11
  • function level — Ch. 11
  • higher-level — Ch. 11
  • higher-order functions — Ch. 11
  • libraries of theorems — Ch. 11
  • non-primitive recursive — Ch. 14
• properties as functions — Ch. 10
• property — Ch. 1, Ch. 9, Ch. 10
  • incorrect — Ch. 3
• property-based testing — Ch. 1
  • shrinking — Ch. 1
• pseudo-random numbers — Ch. 17
• Pythagoras’s theorem — Ch. 1
• Pythagorean triple — Ch. 17

Q

• quadratic equation — Ch. 3
• qualified names — Ch. 7, Ch. 15
• qualifier — Ch. 17
• quantifier, universal — Ch. 9
• QuickCheck — Ch. 1, Ch. 7, Ch. 9, Ch. 12, Ch. 19
  • and higher-order functions — Ch. 11, Ch. 19
  • and proof — Ch. 9
  • generator — Ch. 19
  • going further — Ch. 19
  • Huffman codes — Ch. 15
  • infoCheck clone — Ch. 13
  • Int and Integer — Ch. 4
  • library database — Ch. 5
  • pictures — Ch. 6
  • properties of trees — Ch. 14
  • properties over [a] — Ch. 9
  • showing functions — Ch. 19
  • testing ADTs — Ch. 16
  • testing edit distance — Ch. 14
• quicksort — Ch. 7
• :quit — Ch. 2
• quot — Operators

R

• random numbers — Ch. 18
• reading `::’ — Ch. 1
• reasoning — see proof
• recogniser — Ch. 17
• records — Appendix
• recursion — Ch. 4, Ch. 17, Glossary
  • and calculation — Ch. 4
  • base case — Ch. 4
  • bottom-up — Ch. 4
  • general — Ch. 4
  • justification — Ch. 4
  • mutual — Ch. 14, Ch. 16, Glossary
  • primitive — Ch. 4
  • recursion step — Ch. 4
  • top-down — Ch. 4
• recursive type — Ch. 14
  • mutually recursive — Ch. 14
• reference point — Ch. 6
• regular expressions — Ch. 12, Ch. 19
  • enumerating — Ch. 19
• relation — Ch. 16
  • composition — Ch. 16
  • family relations — Ch. 16
  • operations — Ch. 16
  • transitive — Ch. 16
  • transitive closure — Ch. 16
• relations — Ch. 16
• :reload — Ch. 2
• rem — Operators
• reserved words — Ch. 3
• residency — Ch. 20
• result — Ch. 1, Glossary
• reuse — Ch. 14, Ch. 15
• Rock - Paper - Scissors — Ch. 4, Ch. 8, Ch. 10
• RPS — see Rock - Paper - Scissors
• run-length encoding — Ch. 6

S

• scale — Ch. 1, Ch. 6
  • type declaration — Ch. 1
  • type diagram — Ch. 1
• scanl’ — Ch. 17
• Scheme — Ch. 21
• scope — Ch. 4, Glossary
  • nested — Ch. 4
• script — Ch. 2, Glossary
• search tree — Ch. 16, Ch. 20
  • deletion — Ch. 16
  • insertion — Ch. 16
  • operations — Ch. 16
• selector — Ch. 5
• seq — Operators
• sequencing — see do
• :set — Ch. 2
• sets — Ch. 5, Ch. 16, Glossary
  • and lists — Ch. 16
  • behaviour of implementations — Ch. 20
  • operations — Ch. 16
  • product — Ch. 16
• shallow embedding — Ch. 19
• show — Ch. 3, Ch. 5, Ch. 13
  • Expr — Ch. 14
• side-effect — Ch. 1, Glossary
• signature — Ch. 13, Ch. 16, Glossary
  • for Tree — Ch. 16
• simplification — Ch. 12
• simulation — Ch. 14, Ch. 16, Ch. 17
  • experimenting — Ch. 17
  • the queue — Ch. 16
  • the server — Ch. 16
• single quote (’) — Ch. 3
• smart constructor — Ch. 19
• software — Ch. 1
• sorting — Ch. 7
  • insertion — Ch. 7, Ch. 10
  • merge sort — Ch. 15
  • quicksort — Ch. 7, Ch. 12, Ch. 20
• space leak — Ch. 20
• specialization — Ch. 11
• specification — Ch. 4
• Stack — Other implementations
• Stackage — Ch. 6
• standard libraries — Ch. 2
  • location of — Ch. 2
• Standard ML — Ch. 21
• standard prelude — see Prelude.hs
• state — Appendix
• store — Ch. 16
  • as a ADT — Ch. 16
  • as a list — Ch. 16
  • as function — Ch. 16
• strategies — Ch. 8, Ch. 12
• stream — Glossary
• strings — Ch. 5, Glossary
• structural induction — Ch. 9, Ch. 11, Ch. 17, Glossary
  • expression type — Ch. 14
  • for lists — Ch. 9
  • Maybe type — Ch. 14
  • trees — Ch. 14
• substitution — Ch. 17, Glossary
  • duplication on — Ch. 17
• suit — Ch. 6
• sum type — Ch. 14
• supermarket billing — Ch. 6, Ch. 10
• SVG — Ch. 1
  • display in browser — Ch. 2
• symbolic evaluation — Ch. 9
• synonym — Ch. 5
• syntax — Ch. 2, Ch. 3, Glossary
  • of application — Ch. 11
• syntax error — Ch. 2, Errors
• system messages — Errors

T

• tab (t) — Ch. 3
• termination — Ch. 4, Ch. 9, Ch. 14
• testing — Ch. 4
  • ADTs — Ch. 16
  • and proof — Ch. 9
  • black box — Ch. 4
  • coverage — Ch. 1
  • failing case — Ch. 4
  • library database — Ch. 5
  • property-based — Ch. 1
  • special cases — Ch. 4
  • testing groups — Ch. 4
  • white box — Ch. 4
• text processing — Ch. 7, Ch. 20
  • filling — Ch. 7
  • justification — Ch. 7
  • splitting into words — Ch. 7, Ch. 10
• toInteger — Ch. 3
• tree — Ch. 14
  • balanced — Ch. 20
  • binary — Ch. 14
  • branch length — Ch. 20
  • numeric — Ch. 14
• trick — Ch. 6
• trump — Ch. 6
• truth table — Ch. 3
• tuples — Ch. 5, Appendix, Glossary
  • and lists — Ch. 5
  • compared with algebraic type — Ch. 5
• type — Ch. 1, Ch. 2, Ch. 5, Ch. 6, Ch. 13, Glossary
  • abstract — Ch. 1
  • algebraic — see algebraic type
  • base — Glossary
  • constraint — Ch. 1, Ch. 6
  • dependent types — Ch. 21
  • enumerated — Ch. 4
  • importance of types — Ch. 1, Ch. 6
  • instance — Ch. 6
  • monomorphic — Glossary
  • most general — Ch. 6, Glossary
  • numeric types — Ch. 13
  • one element — Ch. 8
  • tuples and data types — Ch. 5
• type checking — Ch. 1, Ch. 13
  • and classes — Ch. 13
  • constraints — Ch. 13
  • function definitions — Ch. 13
  • instance error — Ch. 13
  • monomorphic — Ch. 13
  • polymorphic — Ch. 13
  • polymorphic definitions — Ch. 13
  • polymorphic function application — Ch. 13
  • rule of cancellation — Ch. 11, Glossary
  • tuples and lists — Ch. 5
• type classes — see classes
• type declaration — Ch. 1, Ch. 4, Ch. 12
  • for function — Ch. 1
  • understanding — Ch. 1
  • why to write them — Ch. 13
• type error — Ch. 1, Ch. 2, Ch. 5, Errors
  • ADT — Ch. 16
  • in application — Ch. 13
  • instance error — Ch. 13
• type synonym — Glossary
• type variable — Ch. 6, Glossary
• type-checking — Ch. 5

U

• uncurrying — Ch. 11
• undefinedness — Ch. 4, Ch. 17, Glossary
• underlining — Ch. 1, Ch. 20
• understanding programs — Ch. 12
• Unicode — Ch. 3
• unification — Ch. 13, Glossary
• union type — Ch. 14
• universal quantifier — Ch. 9
• unknown — Ch. 1

V

• value — Ch. 1, Appendix, Glossary
  • defined — Ch. 17
  • error — Ch. 4
  • literal — Ch. 3
  • undefined — Ch. 4, Ch. 17
• variable — Ch. 1, Ch. 20, Appendix, Glossary
  • free — Ch. 9
  • type — Ch. 6
• visibility of definitions — Ch. 15

W

• Web site
  • for Haskell — Ch. 1
  • sites with further information — Ch. 21
• website — Ch. 1
• wildcard (`_’) — Ch. 7

Z

• zipWith — Ch. 1, Ch. 10, Ch. 17
  • type of — Ch. 10

~

• ~> — Ch. 1

⇒

• ⇒ — Ch. 9

∀

• ∀ — Ch. 9

⬛

• ⬛ — Ch. 9