Alejandro Serrano Mena
Practical HaskellA Real World Guide to Programming2nd ed.
Alejandro Serrano Mena
Utrecht, The Netherlands
ISBN 978-1-4842-4479-1e-ISBN 978-1-4842-4480-7
https://doi.org/10.1007/978-1-4842-4480-7
© Alejandro Serrano Mena 2019
This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed.
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights.
While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein.
Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation.

To Elena, and my two boys Quique and Julio, which bring me joy every single day.

Introduction

Functional programming is gathering momentum. Mainstream languages such as Java and C# are adopting features from this paradigm; and languages such as Haskell, Scala, Rust, Clojure, or OCaml, which embody functional programming from the very beginning, are being used in industry. Haskell is a noise-free, pure functional language with a long history, having a huge number of library contributors and an active community. This makes Haskell a great tool for both learning and applying functional programming.

Why You Should Learn Functional Programming

The rise in functional programming comes from two fronts. Nowadays, most applications are heavily concurrent or need to be parallelized to perform better. Think of any web server that needs to handle thousands of connections at the same time. The way you express the intent of your code using Haskell makes it easier to move from a single-thread application to a multi-threaded one at a negligible cost.

Apart from becoming more concurrent, applications are becoming much larger. You would like your development environment to help you catch bugs and ensure interoperation between all modules of your system. Haskell has a very strong type system, which means that you can express a wide range of invariants in your code, which are checked at compile time. Many of the bugs, which previously would be caught using tests, are now completely forbidden by the compiler. Refactoring becomes easier, as you can ensure that changes in your code do not affect those invariants.

Learning functional programming will put you in a much better position as a developer. Functional thinking will continue permeating through mainstream programming in the near future. You’ll be prepared to develop larger and faster applications that bring satisfaction to your customers.

Why You Should Read This Book

This book focuses both on the ideas underlying and on the practicalities of Haskell programming. The chapters show you how to apply functional programming concepts in real-world scenarios. They also teach you about the tools and libraries that Haskell provides for each specific task. Newcomers to functional programming will not be the only ones who will benefit from reading this book. Developers of Scala, Clojure, Lisp, or ML will be also able to see what sets Haskell apart from other languages.

The book revolves around the project of building a web-based strorefront. In each of the five parts, the focus is on a subsystem of this store: representing clients and products in-memory, data mining (including parallelization and concurrency), persistent storage, discounts and offers, and the general architecture of the application. The topics have been carefully selected for you to get a glimpse of the whole Haskell ecosystem.

Acknowledgments

These acknowledgments have been transported almost unchanged from the first to the second edition of the book. It is great to see how the people that supported you on your first writing adventure are still around and even more supportive than the first time.

First of all, I would like to acknowledge the great work of the technical reviewer and the editorial board. Their comments and suggestions have been extremely valuable for making the book better and more helpful. Jean-Philippe Moresmau did a great job in the first edition; this time Germán has taken his witness and the result is even better.

Writing a book is a very rewarding task, but it’s also quite a consuming one. For those times where the mood goes sour, there has not been anything better than the support that Elena brought to me. She was there while I was thinking, refining the examples, and reviewing the text one more time.

My family and my friends have also encouraged me the entire time, so a bit of thanks to all of them too. My parents Carmen and Julián deserve a very special mention: they’ve supported me during every single project, and as crazy as it may sound, throughout my whole life. They bought me the first computer I worked with, which was the computer I started programming in an old Visual Basic environment. It’s fair to say that without their help, you wouldn’t be reading this book.

Being surrounded by people who share your passion is the best way to stay motivated to learn and communicate what you know; my colleagues at Utrecht University are a prime example. Many ideas in this book have their roots in that department, and I feel honored to be part of it.

The entire Haskell community is wonderful. Having great mailing lists and IRC rooms full of (quite clever!) people always willing to help encourages you to be curious and to learn more. Every single library and compiler discussed in this book has been carefuly crafted by this community: they are the reason why Haskell is such a great language.

Table of Contents

Part I: First Steps
Chapter 1:​ Going Functional 3
Why Haskell?​ 3
Why Pure Functional Programming?​ 4
Why Strong Static Typing?​ 6
The Haskell Ecosystem 7
The History of Haskell 8
Your Working Environment 8
Installing on Windows or Mac OS X 9
Installing on Linux 9
First Steps with GHCi 11
The Time Machine Store 13
Summary 14
Chapter 2:​ Declaring the Data Model 17
Characters, Numbers, and Lists 17
Characters 18
Numbers 19
Strings 21
Lists 22
Creating a New Project 27
Creating a Project with Cabal 27
Creating a Project with Stack 29
Understanding Modules 31
Cabal and Stack 33
Defining Simple Functions 33
Creating a Simple Function 34
Specifying the Function’s Type 34
Developing a Robust Example 35
Returning More Than One Value 38
Working with Data Types 40
Pattern Matching 44
Records 56
Summary 62
Chapter 3:​ Increasing Code Reuse 63
Parametric Polymorphism 64
Functions As Parameters 67
Higher-Order Functions 68
Anonymous Functions 70
Partial Application of a Function 73
More on Modules 77
Module Imports 77
Smart Constructors and Views 79
Diving into Lists 82
Folds 83
Lists and Predicates 87
Lists Containing Tuples 95
List Comprehensions 96
Haskell Origami 101
Summary 106
Chapter 4:​ Using Containers and Type Classes 109
Using Packages 110
Managing Dependencies 111
Building Packages 113
Obtaining Help 118
Containers:​ Maps, Sets, Trees, Graphs 118
Maps 119
Sets 124
Trees 126
Graphs 129
Ad Hoc Polymorphism:​ Type Classes 132
Declaring Classes and Instances 133
Built-in Type Classes 137
Binary Trees for the Minimum Price 143
Step 1:​ Simple Binary Trees 143
Step 2:​ Polymorphic Binary Trees 145
Step 3:​ Binary Trees with Monoidal Cache 147
Container-Related Type Classes 150
Functors 150
Foldables 153
Summary 155
Chapter 5:​ Laziness and Infinite Structures 157
An Infinite Number of Time Machines 158
Lazy Evaluation Model 163
Understanding Evaluation in Haskell 163
Problems with Laziness 168
Pattern Matching and Laziness 171
Profiling with GHC 173
Strictness Annotations 179
Summary 182
Part II: Data Mining
Chapter 6:​ Knowing Your Clients Using Monads 185
Data Mining 186
Implementing K-means 186
Lenses 193
Discovering Monads 202
Watching Out for Incomplete Data 202
Combinators for State 205
Dissecting the Combinators 209
do Notation 212
Monad Laws 216
Different Sorts of State 217
State and Lenses 218
Reader, Writer, and RWS 220
Mutable References with ST 224
Summary 227
Chapter 7:​ More Monads:​ Now for Recommendations 229
Returning More Than One Value 230
The List Monad 230
A New View Over Monads 232
Failures and Alternatives 233
Association Rules Learning 237
Flattening Values into Transactions 238
The Apriori Algorithm 241
Search Problems 247
Paths in a Graph 247
The Logic Monad 249
Monads and Lists Redux 252
Combining Values Under a Monad 252
Monad Comprehensions 256
Combining Monads 259
Monad Transformers 260
Monad Classes 265
Summary 268
Chapter 8:​ Working in Several Cores 269
Parallelism, Concurrency, and Distribution 269
The Par Monad 271
Futures 271
Dataflow Parallelism with IVars 274
Parallelizing the Apriori Algorithm 276
Software Transactional Memory 279
Concurrent Use of Resources 280
Atomic Transactions 282
Rolling Back Transactions 286
Producer-Consumer Queues 288
Single-Process Queues 288
Message Queues Using AMQP 290
AMQP in Haskell 293
Summary 296
Part III: Resource Handling
Chapter 9:​ Dealing with Files:​ IO and Conduit 301
Basic Input and Output 302
Randomness 307
Working with Files 310
Reading and Writing 310
Handling Files 314
Error Handling 316
Pure Errors 316
Catching Exceptions 319
Throwing Exceptions 324
Streaming Data with Conduit 326
Problems with Lazy Input/​Output 326
Introducing Conduits 328
Accessing Files via Conduit 332
Looking Further Than Text Files 335
Basic Networking 335
Binary Serialization 337
Comma-Separated Values 339
Summary 341
Chapter 10:​ Building and Parsing Text 343
The Five Textual Data Types 343
Building as Fast as the Wind 349
Parsing with attoparsec 353
Introducing New Type Classes 360
Applicative 361
Functors, Applicatives, and Monads 363
Alternative 366
Traversable 367
Don’t Overengineer:​ Just Use JSON 370
Summary 378
Chapter 11:​ Safe Database Access 379
Database Access Landscape 379
Abstracting Over Several DBMSs 380
Introducing Persistent and Esqueleto 381
Connection 382
Schemas and Migrations 385
Describing the Entities 386
Creating the Database 391
Queries 395
Queries by Identifier or Uniqueness 395
Selecting Several Entities 397
SQL Queries with Esqueleto 400
Insertions, Updates, and Deletions 404
Summary 408
Chapter 12:​ Web Applications 409
Haskell Web Ecosystem 409
Web Frameworks 410
Compilation to JavaScript 412
RESTful Structure 414
Back End with Spock 415
Simple Skeleton 415
Showing Products from the Database 417
Inserting New Products Using Forms 423
Front End with Elm 428
Retrieving Products 432
Summary 437
Part IV: Domain Specific Languages
Chapter 13:​ Strong Types for Describing Offers 441
Domain-Specific Languages 441
Embedding Your Language in Haskell 442
The Offers Language 445
Adding Safety to the Expression Language 448
Type-Level Programming 452
Two Styles of Programming 454
Representing Natural Numbers 455
Functional Dependencies 457
Categories of Products with FDs 457
Vectors Using FDs 461
Enforcing the Presents Rule with FDs 464
Type Families 466
Vectors Using TFs 466
Enforcing the Presents Rule with TFs 468
Categories of Products with TFs 469
Data Type Promotion and Singletons 474
A Further Refinement to the Presents Rule 474
Cooking with Singletons 477
Enforcing the Duration Rule 478
Summary 485
Chapter 14:​ Interpreting Offers with Attributes 487
Interpretations and Attribute Grammars 488
A Simple Interpretation 488
Introducing Attribute Grammars 488
Your First Attribute Grammar 491
Synthesizing the Result 491
Executing the Attribute Grammar 494
Integrating UUAGC in Your Package 495
Expressions Interpretation 498
Using an Attribute Grammar 498
Precomputing Some Values 501
A Different (Monadic) View 503
Offer Interpretations 505
Checking the Presents Rule 505
Showing an HTML Description 507
Programming with Data Types 513
Origami Programming Over Any Data Type 513
Data Type-Generic Programming 516
Summary 520
Part V: Engineering the Store
Chapter 15:​ Documenting, Testing, and Verifying 525
Documenting Binary Trees with Haddock 526
Unit Testing with HUnit 530
Declaring Tests in Cabal 531
Writing Unit Tests 532
Randomized Testing with QuickCheck 536
Testing List Properties 537
Testing Binary Tree Properties 538
Formal Verification with LiquidHaskell 541
Describing Binary Search Trees 544
Summary 546
Chapter 16:​ Architecting Your Application 547
Tools 547
Project and Dependency Management 548
Code Style 548
Documentation 549
Test and Verification 549
Benchmarking 549
Profiling 550
Coverage 550
Remote Monitoring 550
Design Patterns and Functional Programming 551
Medium-Level Guidelines 553
Use Higher-Order Combinators 553
Refactor 553
Use Type Classes Wisely 553
Enforce Invariants via the Type System 554
Stay (As) Pure and Polymorphic (As Possible) 554
Patterns with Monads 555
Summary of Monads 555
Restrictive Monad Classes 561
Roll Your Own Monad 562
Summary 565
Chapter 17:​ Looking Further 567
Projects 567
Data Mining Library 568
Store Network Client 570
Administration Interface and Tetris 571
Additional Haskell Resources 573
Other Functional Languages 574
Appendix:​ Time Travelling with Haskell 575
Index 579

About the Author and About the Technical Reviewer

About the Author

Alejandro Serrano Mena

works as a lecturer and researcher at the Department of Information and Computing Sciences in Utrecht University. He is passionate about functional programming and has been coding in Haskell for personal and professional projects for more than 10 years. His current research focuses on how to increase the usefulness of type systems while decreasing their costs and their learning curve; his PhD dissertation discusses how to enhance error reporting in Haskell.

Alejandro has been very active in promoting functional languages, already since his college years. In addition to his duties as a lecturer, he participates actively in both academic and industry-oriented conferences, such as Lambda World and LambdaConf.

 

About the Technical Reviewer

Germán González-Morris

is a polyglot Software Architect/Engineer with more than 20 years in the field, with knowledge in Java(EE), Spring, Haskell, C, Python, and Javascript, among others. He works with web-distributed applications. Germán loves math puzzles (including reading Knuth) and swimming. He has tech-reviewed several books, including an application container book (Weblogic), as well as titles covering various programming languages (Haskell, Typescript, WebAssembly, Math for coders, and regexp). You can find more details at his blog site ( https://devwebcl.blogspot.com/ ) or twitter account ( @devwebcl ).

 
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.149.234.118