Real World Haskell: Code You Can Believe In 1st Edition

Real World Haskell: Code You Can Believe In 1st Edition
Real+World+Haskell%3A+Code+You+Can+Believe+In+1st+Edition - фото 1
750 грн
O'Reilly Media
70х100 1/16 (170х240 мм)
Тип бумаги 
С иллюстрациями
Срок поставки
7-10 дней
  • По ХарьковуДоставка курьером - 60 грн
    Бесплатно - от 1000 грн
  • По УкраинеБесплатно - от 1000 грн
    Новая Почта - от 40 грн
    Укрпочта - от 25 грн
  • Международная доставкаУкрпочта...
Подробнее о доставке

This easy-to-use, fast-moving tutorial introduces you to functional programming with Haskell. You'll learn how to use Haskell in a variety of practical ways, from short scripts to large and demanding applications. Real World Haskell takes you through the basics of functional programming at a brisk pace, and then helps you increase your understanding of Haskell in real-world issues like I/O, performance, dealing with data, concurrency, and more as you move through each chapter.

About the Author

Bryan O'Sullivan is an Irish hacker and writer who likes distributed systems, open source software, and programming languages. He was a member of the initial design team for the Jini network service architecture (subsequently open sourced as Apache River). He has made significant contributions to, and written a book about, the popular Mercurial revision control system. He lives in San Francisco with his wife and sons. Whenever he can, he runs off to climb rocks.

John Goerzen is an American hacker and author. He has written a number of real-world Haskell libraries and applications, including the HDBC database interface, the ConfigFile configuration file interface, a podcast downloader, and various other libraries relating to networks, parsing, logging, and POSIX code. John has been a developer for the Debian GNU/Linux operating system project for over 10 years and maintains numerous Haskell libraries and code for Debian. He also served as President of Software in the Public Interest, Inc., the legal parent organization of Debian. John lives in rural Kansas with his wife and son, where he enjoys photography and geocaching.

Don Stewart is an Australian hacker based in Portland, Oregon. Don has been involved in a diverse range of Haskell projects, including practical libraries, such as Data.ByteString and Data.Binary, as well as applying the Haskell philosophy to real-world applications including compilers, linkers, text editors, network servers, and systems software. His recent work has focused on optimizing Haskell for high-performance scenarios, using techniques from term rewriting.

Table of Contents

Chapter 1 Getting Started

Your Haskell Environment

Getting Started with ghci, the Interpreter

Basic Interaction: Using ghci as a Calculator

Command-Line Editing in ghci


Strings and Characters

First Steps with Types

A Simple Program

Chapter 2 Types and Functions

Why Care About Types?

Haskell’s Type System

What to Expect from the Type System

Some Common Basic Types

Function Application

Useful Composite Data Types: Lists and Tuples

Functions over Lists and Tuples

Function Types and Purity

Haskell Source Files, and Writing Simple Functions

Understanding Evaluation by Example

Polymorphism in Haskell

The Type of a Function of More Than One Argument

Why the Fuss over Purity?


Chapter 3 Defining Types, Streamlining Functions

Defining a New Data Type

Type Synonyms

Algebraic Data Types

Pattern Matching

Record Syntax

Parameterized Types

Recursive Types

Reporting Errors

Introducing Local Variables

The Offside Rule and Whitespace in an Expression

The case Expression

Common Beginner Mistakes with Patterns

Conditional Evaluation with Guards

Chapter 4 Functional Programming

Thinking in Haskell

A Simple Command-Line Framework

Warming Up: Portably Splitting Lines of Text

Infix Functions

Working with Lists

How to Think About Loops

Anonymous (lambda) Functions

Partial Function Application and Currying


Code Reuse Through Composition

Tips for Writing Readable Code

Space Leaks and Strict Evaluation

Chapter 5 Writing a Library: Working with JSON Data

A Whirlwind Tour of JSON

Representing JSON Data in Haskell

The Anatomy of a Haskell Module

Compiling Haskell Source

Generating a Haskell Program and Importing Modules

Printing JSON Data

Type Inference Is a Double-Edged Sword

A More General Look at Rendering

Developing Haskell Code Without Going Nuts

Pretty Printing a String

Arrays and Objects, and the Module Header

Writing a Module Header

Fleshing Out the Pretty-Printing Library

Creating a Package

Practical Pointers and Further Reading

Chapter 6 Using Typeclasses

The Need for Typeclasses

What Are Typeclasses?

Declaring Typeclass Instances

Important Built-in Typeclasses

Automatic Derivation

Typeclasses at Work: Making JSON Easier to Use

Living in an Open World

How to Give a Type a New Identity

JSON Typeclasses Without Overlapping Instances

The Dreaded Monomorphism Restriction


Chapter 7 I/O

Classic I/O in Haskell

Working with Files and Handles

Extended Example: Functional I/O and Temporary Files

Lazy I/O

The IO Monad

Is Haskell Really Imperative?

Side Effects with Lazy I/O


Reading Command-Line Arguments

Environment Variables

Chapter 8 Efficient File Processing, Regular Expressions, and Filename Matching

Efficient File Processing

Filename Matching

Regular Expressions in Haskell

More About Regular Expressions

Translating a glob Pattern into a Regular Expression

An important Aside: Writing Lazy Functions

Making Use of Our Pattern Matcher

Handling Errors Through API Design

Putting Our Code to Work

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

The find Command

Starting Simple: Recursively Listing a Directory

A Naive Finding Function

Predicates: From Poverty to Riches, While Remaining Pure

Sizing a File Safely

A Domain-Specific Language for Predicates

Controlling Traversal

Density, Readability, and the Learning Process

Another Way of Looking at Traversal

Useful Coding Guidelines

Chapter 10 Code Case Study: Parsing a Binary Data Format

Grayscale Files

Parsing a Raw PGM File

Getting Rid of Boilerplate Code

Implicit State

Introducing Functors

Writing a Functor Instance for Parse

Using Functors for Parsing

Rewriting Our PGM Parser

Future Directions

Chapter 11 Testing and Quality Assurance

QuickCheck: Type-Based Testing

Testing Case Study: Specifying a Pretty Printer

Measuring Test Coverage with HPC

Chapter 12 Barcode Recognition

A Little Bit About Barcodes

Introducing Arrays

Encoding an EAN-13 Barcode

Constraints on Our Decoder

Divide and Conquer

Turning a Color Image into Something Tractable

What Have We Done to Our Image?

Finding Matching Digits

Life Without Arrays or Hash Tables

Turning Digit Soup into an Answer

Working with Row Data

Pulling It All Together

A Few Comments on Development Style

Chapter 13 Data Structures

Association Lists


Functions Are Data, Too

Extended Example: /etc/passwd

Extended Example: Numeric Types

Taking Advantage of Functions as Data

General-Purpose Sequences

Chapter 14 Monads

Revisiting Earlier Code Examples

Looking for Shared Patterns

The Monad Typeclass

And Now, a Jargon Moment

Using a New Monad: Show Your Work!

Mixing Pure and Monadic Code

Putting a Few Misconceptions to Rest

Building the Logger Monad

The Maybe Monad

The List Monad

Desugaring of do Blocks

The State Monad

Monads and Functors

The Monad Laws and Good Coding Style

Chapter 15 Programming with Monads

Golfing Practice: Association Lists

Generalized Lifting

Looking for Alternatives

Adventures in Hiding the Plumbing

Separating Interface from Implementation

The Reader Monad

A Return to Automated Deriving

Hiding the IO Monad

Chapter 16 Using Parsec

First Steps with Parsec: Simple CSV Parsing

The sepBy and endBy Combinators

Choices and Errors

Extended Example: Full CSV Parser

Parsec and MonadPlus

Parsing a URL-Encoded Query String

Supplanting Regular Expressions for Casual Parsing

Parsing Without Variables

Applicative Functors for Parsing

Applicative Parsing by Example

Parsing JSON Data

Parsing a HTTP Request

Chapter 17 Interfacing with C: The FFI

Foreign Language Bindings: The Basics

Regular Expressions for Haskell: A Binding for PCRE

Passing String Data Between Haskell and C

Matching on Strings

Chapter 18 Monad Transformers

Motivation: Boilerplate Avoidance

A Simple Monad Transformer Example

Common Patterns in Monads and Monad Transformers

Stacking Multiple Monad Transformers

Moving Down the Stack

Understanding Monad Transformers by Building One

Transformer Stacking Order Is Important

Putting Monads and Monad Transformers into Perspective

Chapter 19 Error Handling

Error Handling with Data Types


Error Handling in Monads

Chapter 20 Systems Programming in Haskell

Running External Programs

Directory and File Information

Program Termination

Dates and Times

Extended Example: Piping

Chapter 21 Using Databases

Overview of HDBC

Installing HDBC and Drivers

Connecting to Databases


Simple Queries


Query Parameters

Prepared Statements

Reading Results

Database Metadata

Error Handling

Chapter 22 Extended Example: Web Client Programming

Basic Types

The Database

The Parser


Main Program

Chapter 23 GUI Programming with gtk2hs

Installing gtk2hs

Overview of the GTK+ Stack

User Interface Design with Glade

Event-Driven Programming

Initializing the GUI

The Add Podcast Window

Long-Running Tasks

Using Cabal

Chapter 24 Concurrent and Multicore Programming

Defining Concurrency and Parallelism

Concurrent Programming with Threads

Simple Communication Between Threads

The Main Thread and Waiting for Other Threads

Communicating over Channels

Useful Things to Know About

Shared-State Concurrency Is Still Hard

Using Multiple Cores with GHC

Parallel Programming in Haskell

Parallel Strategies and MapReduce

Chapter 25 Profiling and Optimization

Profiling Haskell Programs

Controlling Evaluation

Understanding Core

Advanced Techniques: Fusion

Chapter 26 Advanced Library Design: Building a Bloom Filter

Introducing the Bloom Filter

Use Cases and Package Layout

Basic Design

The ST Monad

Designing an API for Qualified Import

Creating a Mutable Bloom Filter

The Immutable API

Creating a Friendly Interface

Creating a Cabal Package

Testing with QuickCheck

Performance Analysis and Tuning

Chapter 27 Sockets and Syslog

Basic Networking

Communicating with UDP

Communicating with TCP

Chapter 28 Software Transactional Memory

The Basics

Some Simple Examples

STM and Safety

Retrying a Transaction

Choosing Between Alternatives

I/O and STM

Communication Between Threads

A Concurrent Web Link Checker

Practical Aspects of STM

Appendix Installing GHC and Haskell Libraries

Installing GHC

Installing Haskell Software

Appendix Characters, Strings, and Escaping Rules

Writing Character and String Literals

International Language Support

Escaping Text


Товар входит в категории

Вы можете купить книгу с доставкой курьером новой поштой укрпочтой Кривой Рог, Львов, Полтава, Житомир, Черкассы, Харьков, Чернигов, Винница, Тернополь, Киев, Луцк, Ровно, Хмельницкий, Херсон, Кировоград, Николаев, Днепропетровск, Ужгород, Запорожье, Суммы, Черновцы, Одесса, Ивано-франковск, другие города Украины. только в нашем магазине низкие цены, возможен торг, прямые поступления от издательства,книги под заказ, печать книг на заказ, компьютерные книги на английском языке.

Ви можете купити придбати книгу з доставкою кур'єром нова пошта Укрпошта Кривий Ріг, Львів, Полтава, Житомир, Харків, Чернігів, Вінниця, Тернопіль, Київ, Луцьк, Рівне, Хмельницький, Херсон, Кіровоград, Миколаїв, Дніпропетровськ, Ужгород , Запоріжжя, Суми, Чернівці, Черкаси, Одеса, Івано-франківськ, інші міста України. тільки в нашому магазині низькі ціни, можливий торг, прямі надходження від видавництва, книги під замовлення, друк книг на замовлення, комп'ютерні книги англійською мовою.