Get Programming with Haskell

Get Programming with Haskell......Page 1
Contents......Page 6
Preface......Page 8
Acknowledgments......Page 10
 Who should read this book......Page 11
 How this book is organized......Page 12
 Book forum......Page 14
About the author......Page 15
 1.1 Welcome to Haskell......Page 16
 1.2 The Glasgow Haskell Compiler......Page 17
 1.3 Interacting with Haskell?GHCi......Page 19
 1.4 Writing and working with Haskell code......Page 21
 Summary......Page 25
Unit 1 Foundations of functional programming......Page 26
 Lesson 2 Functions and functional programming......Page 28
  2.1 Functions......Page 29
  2.2 Functional programming......Page 30
  2.3 The value of functional programming in practice......Page 31
  Summary......Page 36
 Lesson 3 Lambda functions and lexical scope......Page 38
  3.1 Lambda functions......Page 39
  3.2 Writing your own where clause......Page 40
  3.3 From lambda to let: making your own variable variables!......Page 42
  3.4 Practical lambda functions and lexical scope......Page 44
  Summary......Page 46
 Lesson 4 First-class functions......Page 48
  4.1 Functions as arguments......Page 49
  4.2 Returning functions......Page 54
  Summary......Page 57
 Lesson 5 Closures and partial application......Page 58
  5.1 Closures?creating functions with functions......Page 59
  5.2 Example: Generating URLs for an API......Page 60
  5.3 Putting it all together......Page 65
  Summary......Page 67
 Lesson 6 Lists......Page 69
  6.1 The anatomy of a list......Page 70
  6.2 Lists and lazy evaluation......Page 72
  6.3 Common functions on lists......Page 74
  Summary......Page 79
 Lesson 7 Rules for recursion and pattern matching......Page 80
  7.1 Recursion......Page 81
  7.2 Rules for recursion......Page 82
  7.3 Your first recursive function: greatest common divisor......Page 83
  Summary......Page 87
 Lesson 8 Writing recursive functions......Page 89
  8.2 Recursion on lists......Page 90
  8.3 Pathological recursion: Ackerman function and the Collatz conjecture......Page 93
  Summary......Page 96
 Lesson 9 Higher-order functions......Page 98
  9.1 Using map......Page 99
  9.2 Abstracting away recursion with map......Page 100
  9.3 Filtering a list......Page 102
  9.4 Folding a list......Page 103
  Summary......Page 106
 Lesson 10 Capstone: Functional object- oriented programming with robots!......Page 107
  10.1 An object with one property: a cup of coffee......Page 108
  10.2 A more complex object: let?s build fighting robots!......Page 111
  10.3 Why stateless programming matters......Page 115
  10.4 Types?objects and so much more!......Page 117
  Summary......Page 118
Unit 2 Introducing types......Page 120
 Lesson 11 Type basics......Page 122
  11.1 Types in Haskell......Page 123
  11.2 Function types......Page 126
  11.3 Type variables......Page 131
  Summary......Page 133
 Lesson 12 Creating your own types......Page 135
  12.1 Using type synonyms......Page 136
  12.2 Creating new types......Page 138
  12.3 Using record syntax......Page 142
  Summary......Page 146
 Lesson 13 Type classes......Page 147
  13.2 Type classes......Page 148
  13.3 The benefits of type classes......Page 149
  13.4 Defining a type class......Page 150
  13.5 Common type classes......Page 151
  13.6 The Ord and Eq type classes......Page 152
  13.7 Deriving type classes......Page 155
  Summary......Page 156
 Lesson 14 Using type classes......Page 157
  14.1 A type in need of classes......Page 158
  14.2 Implementing Show......Page 159
  14.3 Type classes and polymorphism......Page 160
  14.4 Default implementation and minimum complete definitions......Page 161
  14.5 Implementing Ord......Page 163
  14.6 To derive or not to derive?......Page 164
  14.7 Type classes for more-complex types......Page 167
  Summary......Page 169
  15.1 Ciphers for beginners: ROT13......Page 170
  15.2 XOR: The magic of cryptography!......Page 177
  15.3 Representing values as bits......Page 179
  15.4 The one-time pad......Page 182
  15.5 A Cipher class......Page 184
  Summary......Page 186
Unit 3 Programming in types......Page 188
 Lesson 16 Creating types with ?and? and ?or?......Page 190
  16.1 Product types?combining types with ?and?......Page 191
  16.2 Sum types?combining types with ?or?......Page 195
  16.3 Putting together your bookstore......Page 198
  Summary......Page 201
 Lesson 17 Design by composition? Semigroups and Monoids......Page 202
  17.1 Intro to composability?combining functions......Page 203
  17.2 Combining like types: Semigroups......Page 204
  17.3 Composing with identity: Monoids......Page 208
  Summary......Page 215
 Lesson 18 Parameterized types......Page 216
  18.1 Types that take arguments......Page 217
  18.2 Types with more than one parameter......Page 222
  Summary......Page 228
 Lesson 19 The Maybe type: dealing with missing values......Page 229
  19.1 Introducing Maybe: solving missing values with types......Page 230
  19.2 The problem with null......Page 231
  19.3 Computing with Maybe......Page 234
  19.4 Back to the lab! More-complex computation with Maybe......Page 236
  Summary......Page 239
 Lesson 20 Capstone: Time series......Page 240
  20.1 Your data and the TS data type......Page 241
  20.2 Stitching together TS data with Semigroup and Monoid......Page 245
  20.3 Performing calculations on your time series......Page 250
  20.4 Transforming time series......Page 253
  Summary......Page 258
Unit 4 IO in Haskell......Page 260
 Lesson 21 Hello World!?introducing IO types......Page 264
  21.1 IO types?dealing with an impure world......Page 265
  21.2 Do-notation......Page 269
  21.3 An example: command-line pizza cost calculator......Page 271
  21.4 Summary......Page 275
 Lesson 22 Interacting with the command line and lazy I/O......Page 276
  22.1 Interacting with the command line the nonlazy way......Page 277
  22.2 Interacting with lazy I/O......Page 281
  Summary......Page 285
 Lesson 23 Working with text and Unicode......Page 286
  23.2 Using Data.Text......Page 287
  23.3 Text and Unicode......Page 293
  23.4 Text I/O......Page 295
  Summary......Page 296
 Lesson 24 Working with files......Page 297
  24.1 Opening and closing files......Page 298
  24.2 Simple I/O tools......Page 301
  24.3 The trouble with lazy I/O......Page 303
  24.4 Strict I/O......Page 306
  Summary......Page 307
 Lesson 25 Working with binary data......Page 309
  25.1 Working with binary data by using ByteString......Page 310
  25.2 Glitching JPEGs......Page 312
  25.3 ByteStrings, Char8, and Unicode......Page 321
  Summary......Page 322
 Lesson 26 Capstone: Processing binary files and book data......Page 323
  26.1 Working with book data......Page 325
  26.2 Working with MARC records......Page 328
  26.3 Putting it all together......Page 339
  Summary......Page 340
Unit 5 Working with type in a context......Page 342
 Lesson 27 The Functor type class......Page 346
  27.1 An example: computing in a Maybe......Page 347
  27.2 Using functions in context with the Functor type class......Page 348
  27.3 Functors are everywhere!......Page 351
  Summary......Page 357
 Lesson 28 A peek at the Applicative type class: using functions in a context......Page 358
  28.1 A command-line application for calculating the distance between cities......Page 359
  28.2 Using <*> for partial application in a context......Page 363
  28.3 Using <*> to create data in a context......Page 369
  Summary......Page 371
 Lesson 29 Lists as context: a deeper look at the Applicative type class......Page 372
  29.1 Introducing the Applicative type class......Page 373
  29.2 Containers vs. contexts......Page 376
  29.3 List as a context......Page 378
  Summary......Page 385
 Lesson 30 Introducing the Monad type class......Page 387
  30.1 The limitations of Applicative and Functor......Page 388
  30.2 The bind operator: >>=......Page 393
  30.3 The Monad type class......Page 396
  Summary......Page 400
 Lesson 31 Making Monads easier with do-notation......Page 402
  31.1 Do-notation revisited......Page 404
  31.2 Using do-notation to reuse the same code in different contexts......Page 406
  Summary......Page 415
 Lesson 32 The list monad and list comprehensions......Page 417
  32.1 Building lists with the list monad......Page 418
  32.2 List comprehensions......Page 422
  32.3 Monads: much more than just lists......Page 424
  Summary......Page 425
 Lesson 33 Capstone: SQL-like queries in Haskell......Page 426
  33.1 Getting started......Page 427
  33.2 Basic queries for your list: select and where......Page 430
  33.3 Joining Course and Teacher data types......Page 432
  33.4 Building your HINQ interface and example queries......Page 434
  33.5 Making a HINQ type for your queries......Page 436
  33.6 Running your HINQ queries......Page 437
  Summary......Page 442
Unit 6 Organizing code and building projects......Page 444
 Lesson 34 Organizing Haskell code with modules......Page 446
  34.1 What happens when you write a function with the same name as one in Prelude?......Page 447
  34.2 Building a multifile program with modules......Page 450
  Summary......Page 456
 Lesson 35 Building projects with stack......Page 457
  35.1 Starting a new stack project......Page 458
  35.2 Understanding the project structure......Page 459
  35.3 Writing your code......Page 462
  35.4 Building and running your project!......Page 464
  Summary......Page 466
 Lesson 36 Property testing with QuickCheck......Page 467
  36.1 Starting a new project......Page 468
  36.2 Different types of testing......Page 469
  36.3 Property testing QuickCheck......Page 474
  Summary......Page 480
 Lesson 37 Capstone: Building a prime-number library......Page 481
  37.1 Starting your new project......Page 482
  37.2 Modifying the default files......Page 483
  37.3 Writing your core library functions......Page 484
  37.4 Writing tests for your code......Page 488
  37.5 Adding code to factor numbers......Page 492
  Summary......Page 494
Unit 7 Practical Haskell......Page 496
 Lesson 38 Errors in Haskell and the Either type......Page 498
  38.1 Head, partial functions, and errors......Page 499
  38.2 Handling partial functions with Maybe......Page 503
  38.3 Introducing the Either type......Page 505
  Summary......Page 510
 Lesson 39 Making HTTP requests in Haskell......Page 512
  39.1 Getting your project set up......Page 513
  39.2 Using the HTTP.Simple module......Page 516
  39.3 Making an HTTP request......Page 518
  39.4 Putting it all together......Page 520
  Summary......Page 521
 Lesson 40 Working with JSON data by using Aeson......Page 522
  40.1 Getting set up......Page 524
  40.2 Using the Aeson library......Page 525
  40.3 Making your data types instances of FromJSON and ToJSON......Page 526
  40.4 Putting it all together: reading your NOAA data......Page 534
  Summary......Page 537
 Lesson 41 Using databases in Haskell......Page 539
  41.1 Setting up your project......Page 540
  41.2 Using SQLite and setting up your database......Page 541
  41.3 Creating data?inserting users and checking out tools......Page 545
  41.4 Reading data from the database and FromRow......Page 547
  41.5 Updating existing data......Page 551
  41.7 Putting it all together......Page 554
  Summary......Page 558
 Lesson 42 Efficient, stateful arrays in Haskell......Page 559
  42.1 Creating efficient arrays in Haskell with the UArray type......Page 561
  42.2 Mutating state with STUArray......Page 567
  42.3 Taking values out of the ST context......Page 570
  42.4 Implementing a bubble sort......Page 572
  Summary......Page 575
  A deeper dive into Haskell......Page 576
  More powerful type systems than Haskell?......Page 577
  Other functional programming languages......Page 578
  Unit 1......Page 581
  Unit 2......Page 585
  Unit 3......Page 588
  Unit 4......Page 591
  Unit 5......Page 595
  Unit 7......Page 600
 A......Page 604
 C......Page 605
 F......Page 606
 I......Page 607
 L......Page 608
 M......Page 609
 P......Page 610
 R......Page 611
 S......Page 612
 T......Page 613
 Z......Page 614