真实世界的HaskellPDF电子书下载

1．Getting Started 1

Your Haskell Environment 1

Getting Started with ghci,the Interpreter 2

Basic Interaction:Using ghci as a Calculator 3

Simple Arithmetic 3

An Arithmetic Quirk:Writing Negative Numbers 4

Boolean Logic,Operators,and Value Comparisons 5

Operator Precedence and Associativity 7

Undefined Values,and Introducing Variables 8

Dealing with Precedence and Associativity Rules 8

Command-Line Editing in ghci 9

Lists 9

Operators on Lists 11

Strings and Characters 11

First Steps with Types 12

A Simple Program 15

2．Typesand Functions 17

Why Care About Types? 17

Haskell's Type System 18

Strong Types 18

Static Types 19

Type Inference 20

What to Expect from the Type System 20

Some Common Basic Types 21

Function Application 22

Useful Composite Data Types:Lists and Tuples 23

Functions over Lists and Tuples 25

Passing an Expression to a Function 26

Function Types and Purity 27

Haskell Source Files,and Writing Simple Functions 27

Just What Is a Variable,Anyway? 28

Conditional Evaluation 29

Understanding Evaluation by Example 32

Lazy Evaluation 32

A More Involved Example 33

Recursion 34

Ending the Recursion 35

Returning from the Recursion 35

What Have We Learned? 36

Polymorphism in Haskell 36

Reasoning About Polymorphic Functions 38

Further Reading 38

The Type of a Function of More Than One Argument 38

Why the Fuss over Purity? 39

Conclusion 40

3．Defining Types,Streamlining Functions 41

Defining a New Data Type 41

Naming Types and Values 43

Type Synonyms 43

Algebraic Data Types 44

Tuples,Algebraic Data Types,and When to Use Each 45

Analogues to Algebraic Data Types in Other Languages 47

Pattern Matching 50

Construction and Deconstruction 51

Further Adventures 52

Variable Naming in Patterns 53

The Wild Card Pattern 53

Exhaustive Patterns and Wild Cards 54

Record Syntax 55

Parameterized Types 57

Recursive Types 58

Reporting Errors 60

A More Controlled Approach 61

Introducing Local Variables 61

Shadowing 62

The where Clause 63

Local Functions、Global Variables 63

The Offside Rule and Whitespace in an Expression 64

A Note About Tabs Versus Spaces 66

The Offside Rule Is Not Mandatory 66

The case Expression 66

Common Beginner Mistakes with Patterns 67

Incorrectly Matching Against a Variable 67

Incorrectly Trying to Compare for Equality 68

Conditional Evaluation with Guards 68

4．Functional Programming 71

Thinking in Haskell 71

A Simple Command-Line Framework 71

Warming Up:Portably Splitting Lines of Text 72

A Line-Ending Conversion Program 75

Infix Functions 76

Working with Lists 77

Basic List Manipulation 78

Safely and Sanely Working with Crashy Functions 79

Partial and Total Functions 79

More Simple List Manipulations 80

Working with Sublists 81

Searching Lists 82

Working with Several Lists at Once 83

Special String-Handling Functions 84

How to Think About Loops 84

Explicit Recursion 85

Transforming Every Piece of Input 87

Mapping over a List 88

Selecting Pieces of Input 90

Computing One Answer over a Collection 90

The Left Fold 92

Why Use Folds,Maps,and Filters? 93

Folding from the Right 94

Left Folds,Laziness,and Space Leaks 96

Further Reading 99

Anonymous(lambda)Functions 99

Partial Function Application and Currying 100

Sections 102

As-patterns 103

Code Reuse Through Composition 104

Use Your Head Wisely 107

Tips for Writing Readable Code 107

Space Leaks and Strict Evaluation 108

Avoiding Space Leaks with seq 108

Learning to Use seq 109

5．Writing a Library:Working with JSONData 111

A Whirlwind Tour of JSON 111

Representing JSON Data in Haskell 111

The Anatomy of a Haskell Module 113

Compiling Haskell Source 114

Generating a Haskell Program and Importing Modules 114

Printing JSON Data 115

Type Inference Is a Double-Edged Sword 117

A More General Look at Rendering 118

Developing Haskell Code Without Going Nuts 119

Pretty Printing a String 120

Arrays and Objects,and the Module Header 122

Writing a Module Header 123

Fleshing Out the Pretty-Printing Library 124

Compact Rendering 127

True Pretty Printing 128

Following the Pretty Printer 129

Creating a Package 131

Writing a Package Description 131

GHC's Package Manager 133

Setting Up,Building,and Installing 133

Practical Pointers and Further Reading 134

6．Using Typeclasses 135

The Need for Typeclasses 135

What Are Typeclasses? 136

Declaring Typeclass Instances 139

Important Built-in Typeclasses 139

Show 139

Read 141

Serialization with read and show 143

Numeric Types 144

Equality,Ordering,and Comparisons 148

Automatic Derivation 148

Typeclasses at Work:Making JSON Easier to Use 149

More Helpful Errors 151

Making an Instance with a Type Synonym 151

Living in an Open World 152

When Do Overlapping Instances Cause Problems? 153

Relaxing Some Restrictions on Typeclasses 154

How Does Show Work for Strings? 155

How to Give a Type a New Identity 155

Differences Between Data and Newtype Declarations 157

Summary:The Three Ways of Naming Types 158

JSON Typeclasses Without Overlapping Instances 159

The Dreaded Monomorphism Restriction 162

Conclusion 163

7．I/O 165

Classic I/O in Haskell 165

Pure Versus I/O 168

Why Purity Matters 169

Working with Files and Handles 169

More on openFile 171

Closing Handles 172

Seek and Tell 172

Standard Input,Output,and Error 173

Deleting and Renaming Files 174

Temporary Files 174

Extended Example:Functional I/O and Temporary Files 175

Lazy I/O 178

hGetContents 178

readFile and writeFile 180

A Word on Lazy Output 181

interact 181

The IO Monad 183

Actions 183

Sequencing 186

The True Nature of Return 187

Is Haskell Really Imperative? 188

Side Effects with Lazy I/O 188

Buffering 189

Buffering Modes 189

Flushing The Buffer 190

Reading Command-Line Arguments 190

Environment Variables 191

8．Efficient File Processing,Regular Expressions,and Filenarne Matching 193

Efficient File Processing 193

Binary I/O and Qualified Imports 194

Text I/O 195

Filename Matching 197

Regular Expressions in Haskell 198

The Many Types of Result 198

More About Regular Expressions 200

Mixing and Matching String Types 200

Other Things You Should Know 201

Translating a glob Pattern into a Regular Expression 202

An important Aside:Writing Lazy Functions 205

Making Use of Our Pattern Matcher 206

Handling Errors Through API Design 210

Putting Our Code to Work 211

9．I/O Case Study:A Library for Searching the Filesystem 213

The find Command 213

Starting Simple:Recursively Listing a Directory 213

Revisiting Anonymous and Named Functions 214

Why Provide Both mapM and forM? 215

A Naive Finding Function 215

Predicates:From Poverty to Riches,While Remaining Pure 217

Sizing a File Safely 219

The Acquire-Use-Release Cycle 221

A Domain-Specific Language for Predicates 221

Avoiding Boilerplate with Lifting 223

Gluing Predicates Together 224

Defining and Using New Operators 225

Controlling Traversal 226

Density,Readability,and the Learning Process 228

Another Way of Looking at Traversal 229

Useful Coding Guidelines 232

Common Layout Styles 233

10．Code Case Study:Parsing a Binary Data Format 235

Grayscale Files 235

Parsing a Raw PGM File 236

Getting Rid of Boilerplate Code 238

Implicit State 239

The Identity Parser 240

Record Syntax,Updates,and Pattern Matching 241

A More Interesting Parser 242

Obtaining and Modifying the Parse State 242

Reporting Parse Errors 243

Chaining Parsers Together 243

Introducing Functors 244

Constraints on Type Definitions Are Bad 247

Infix Use of fmap 248

Flexible Instances 248

Thinking More About Functors 249

Writing a Functor Instance for Parse 250

Using Functors for Parsing 251

Rewriting Our PGM Parser 252

Future Directions 254

11．Testing and Quality Assurance 255

QuickCheck:Type-Based Testing 256

Testing for Properties 257

Testing Against a Model 259

Testing Case Study:Specifying a Pretty Printer 259

Generating Test Data 259

Testing Document Construction 262

Using Lists as a Model 263

Putting It All Together 264

Measuring Test Coverage with HPC 265

12．Barcode Recognition 269

A Little Bit About Barcodes 269

EAN-13 Encoding 270

Introducing Arrays 270

Arrays and Laziness 273

Folding over Arrays 273

Modifying Array Elements 274

Encoding an EAN-13 Barcode 275

Constraints on Our Decoder 275

Divide and Conquer 276

Turning a Color Image into Something Tractable 278

Parsing a Color Image 278

Grayscale Conversion 279

Grayscale to Binary and Type Safety 279

What Have We Done to Our Image? 280

Finding Matching Digits 282

Run Length Encoding 282

Scaling Run Lengths,and Finding Approximate Matches 283

List Comprehensions 284

Remembering a Match's Parity 285

Chunking a List 287

Generating a List of Candidate Digits 287

Life Without Arrays or Hash Tables 288

A Forest of Solutions 288

A Brief Introduction to Maps 289

Further Reading 292

Turning Digit Soup into an Answer 292

Solvvng for Check Digits in Parallel 292

Completing the Solution Map with the First Digit 294

Finding the Correct Sequence 295

Working with Row Data 295

Pulling It All Together 296

A Few Comments on Development Style 297

13．Data Structures 299

Association Lists 299

Maps 301

Functions Are Data,Too 303

Extended Example:/etc/passwd 304

Extended Example:Numeric Types 307

First Steps 309

Completed Code 311

Taking Advantage of Functions as Data 317

Turning Difference Lists into a Proper Library 318

Lists,Difference Lists,and Monoids 320

General-Purpose Sequences 322

14．Monads 325

Revisiting Earlier Code Examples 325

Maybe Chaining 325

Implicit State 326

Looking for Shared Patterns 327

The Monad Typeclass 329

And Now,a Jargon Moment 330

Using a New Monad:Show Your Work! 331

Information Hiding 331

Controlled Escape 332

Leaving a Trace 332

Using the Logger Monad 333

Mixing Pure and Monadic Code 334

Putting a Few Misconceptions to Rest 336

Building the Logger Monad 336

Sequential Logging,Not Sequential Evaluation 337

The Writer Monad 337

The Maybe Monad 338

Executing the Maybe Monad 338

Maybe at Work,and Good API Design 338

The List Monad 340

Understanding the List Monad 342

Putting the List Monad to Work 343

Desugaring of do Blocks 344

Monads as a Programmable Semicolon 345

Why Go Sugar-Free? 346

The State Monad 346

Almost a State Monad 347

Reading and Modifying the State 348

Will the Real State Monad Please Stand Up? 348

Using the State Monad:Generating Random Values 349

A First Attempt at Purity 350

Random Values in the State Monad 351

Running the State Monad 352

What About a Bit More State? 352

Monads and Functors 354

Another Way of Looking at Monads 354

The Monad Laws and Good Coding Style 355

15．Programming with Monads 359

Golfing Practice:Association Lists 359

Generalized Lifting 360

Looking for Alternatives 362

The Name mplus Does Not Imply Addition 364

Rules for Working with MonadPlus 364

Failing Safely with MonadPlus 364

Adventures in Hiding the Plumbing 365

Supplying Random Numbers 368

Another Round of Golf 369

Separating Interface from Implementation 369

Multiparameter Typeclasses 370

FunctionaI Dependencies 370

Rounding Out Our Module 371

Programming to a Monad's Interface 372

The Reader Monad 373

A Return to Automated Deriving 374

Hiding the IO Monad 375

Using a newtype 376

Designing for Unexpected Uses 377

Using Typeclasses 378

Isolation and Testing 379

The Writer Monad and Lists 380

Arbitrary I/O Revisited 381

16．Using Parsec 383

First Steps with Parsec:Simple CSV Parsing 383

The sepBy and endBy Combinators 386

Choices and Errors 387

Lookahead 389

Error Handling 390

Extended Example:Full CSV Parser 391

Parsec and MonadPlus 393

Parsing a URL-Encoded Query String 393

Supplanting Regular Expressions for Casual Parsing 395

Parsing Without Variables 395

Applicative Functors for Parsing 395

Applicative Parsing by Example 396

Parsing JSON Data 398

Parsing a HTTP Request 401

Backtracking and Its Discontents 402

Parsing Headers 402

17．Interfacing with C:The FFI 405

Foreign Language Bindings:The Basics 406

Be Careful of Side Efiects 407

A High-Level Wrapper 408

Regular Expressions for Haskell:A Binding for PCRE 409

Simple Tasks:Using the C Preprocessor 410

Binding Haskell to C with hsc2hs 411

Adding Type Safety to PCRE 411

Binding to Constants 412

Automating the Binding 413

Passing String Data Between Haskell and C 414

Typed Pointers 416

Memory Management:Let the Garbage Collector Do the Work 417

A High-Level Interface:Marshaling Data 418

Marshaling ByteStrings 419

Allocaring Local C Data:The Storable Class 419

Putting It All Together 420

Matching on Strings 422

Extracting Information About the Pattern 423

Pattern Matching with Substrings 424

The Real Deal:Compiling and Matching Regular Expressions 426

18．Monad Transformers 429

Motivation:Boilerplate Avoidance 429

A Simple Monad Transformer Example 430

Common Patterns in Monads and Monad Transformers 431

Stacking Multiple Monad Transformers 433

Hiding Onr Work 435

Moving Down the Stack 436

When Explicit Lifting Is Necessary 437

Understanding Monad Transformers by Building One 438

Creating a Monad Transformer 439

More Typeclass Instances 440

Replacing the Parse Type with a Monad Stack 440

Transformer Stacking Order Is Important 441

Putting Monads and Monad Transformers into Perspective 443

Interference with Pure Code 443

Overdetermined Ordering 444

Runtime Overhead 444

Unwieldy Interfaces 444

Pulling It All Together 445

19．Error Handling 447

Error Handling with Data Types 447

Use of Maybe 448

Use of Either 452

Exceptions 454

First Steps with Exceptions 454

Laziness and Exception Handling 455

Using handle 456

Selective Handling of Exceptions 456

I/O Exceptions 457

Throwing Exceptions 459

Dynamic Exceptions 459

Error Handling in Monads 462

A Tiny Parsing Framework 463

20．Systems Programming in Haskell 467

Running External Programs 467

Directory and File Information 468

Program Termination 469

Dates and Times 470

ClockTime and CalendarTime 470

File Modification Times 475

Extended Example:Piping 476

Using Pipes for Redirection 477

Better Piping 483

Final Words on Pipes 491

21．Using Databases 493

Overview of HDBC 493

Installing HDBC and Drivers 494

Connecting to Databases 495

Transactions 495

Simple Queries 496

SqlValue 497

Query Parameters 497

Prepared Statements 498

Reading Results 499

Reading with Statements 501

Lazy Reading 501

Database Metadata 502

Error Handling 503

22．Extended Example:Web Client Programming 505

Basic Types 506

The Database 506

The Parser 510

Downloading 513

Main Program 515

23．GUI Programming with gtk2hs 517

Installing gtk2hs 517

Overview of the GTK+Stack 517

User Interface Design with Glade 518

Glade Concepts 518

Event-Driven Programming 519

Initializing the GUI 520

The Add Podcast Window 524

Long-Running Tasks 525

Using Cabal 528

24．Concurrent and Multicore Programming 531

Defining Concurrency and Parallelism 531

Concurrent Programming with Threads 532

Threads Are Nondeterministic 532

Hiding Latency 532

Simple Communication Between Threads 533

The Main Thread and Waiting for Other Threads 534

SafelyModifying an MVar 536

Safe Resource Management:A Good Idea,and Easy Besides 536

Finding the Status of a Thread 537

Writing Tighter Code 538

Communicating over Channels 539

Useful Things to Know About 539

MVar and Chan Are Nonstrict 539

Chan Is Unbounded 540

Shared-State Concurrency Is Still Hard 540

Deadlock 541

Starvation 541

Is There Any Hope? 542

Using Multiple Cores with GHC 542

Runtime Options 543

Finding the Number of Available Cores from Haskell 543

Choosing the Right Runtime 544

Parallel Programming in Haskell 544

Normal Form and Head Normal Form 545

Sequential Sorting 545

Transforming Our Code into Parallel Code 545

Knowing What to Evaluate in Parallel 546

What Promises Does par Make? 547

Running Our Code and Measuring Performance 547

Tuning for Performance 550

Parallel Strategies and MapReduce 551

Separating Algorithm from Evaluation 552

Separating Algorithm from Strategy 554

Writing a Simple MapReduce Definition 554

MapReduce and Strategies 555

Sizing Work Appropriately 555

Efficiently Finding Line-Aligned Chunks 557

Counting Lines 558

Finding the Most Popular URLs 559

Conclusions 560

25．Profiling and Optimization 561

Profiling Haskell Programs 561

Collecting Runtime Statistics 562

Time Profiling 563

Space Profiling 566

Controlling Evaluation 570

Strictness and Tail Recursion 571

Adding Strictness 572

Understanding Core 575

Advanced Techniques:Fusion 578

Tuning the Generated Assembly 579

Conclusions 580

26．Advanced Library Design:Building a Bloom Filter 581

Introducing the Bloom Filter 581

Use Cases and Package Layout 582

Basic Design 583

Unboxing,Lifting,and Bottom 583

The ST Monad 584

Designing an API for Qualified Import 585

Creating a Mutable Bloom Filter 586

The Immutable API 587

Creating a Friendly Interface 588

Re-Exporting Names for Convenience 589

Hashing Values 589

Turning Two Hashes into Many 593

Implementing the Easy Creation Function 593

Creating a Cabal Package 595

Dealing with Different Build Setups 596

Compilation Options and Interfacing to C 598

Testing with QuickCheck 599

Polymorphic Testing 600

Writing Arbitrary Instances for ByteStrings 601

Are Suggested Sizes Correct? 602

Performance Analysis and Tuning 604

Profile-Driven Performance Tuning 605

27．Sockets and Syslog 611

Basic Networking 611

Communicating with UDP 611

UDP Client Example:syslog 612

UDP Syslog Server 615

Communicating with TCP 616

Handling Multiple TCP Streams 616

TCP Syslog Server 617

TCP Syslog Client 619

28．Software Transactional Memory 623

The Basics 623

Some Simple Examples 624

STM and Safety 626

Retrying a Transaction 626

What Happens When We Retry? 628

Choosing Between Alternatives 628

Using Higher Order Code with Transactions 628

I/O and STM 629

Communication Between Threads 630

A Concurrent Web Link Checker 631

Checking a Link 633

Worker Threads 634

Finding Links 635

Command-Line Parsing 636

Pattern Guards 637

Practical Aspects of STM 638

Getting Comfortable with Giving Up Control 638

Using Invariants 639

A．Installing GHCand Haskell Libraries 641

B．Characters,Strings,and Escaping Rules 649

Index 655