• Epub Libros Gratis

Epub Libros Gratis

This course will introduce the basic concepts of Haskell and move on to discuss how Haskell can be used to solve the issues by using the real-world data. Alejandro Serrano Mena: Beginning Haskell, Paperback / eBook: 498 pages, Apress (January 2014), English, ISBN: 978-1-43026-250-3. ≫ PDF Gratis Real World Java EE PatternsRethinking Best Practices Adam Bien 316 Books Real World Java EE PatternsRethinking Best Practices Adam Bien 316 Books Download As PDF: Real World Java EE PatternsRethinking.

I've been programming in haskell for over a year now, but still have yet to pick up Real World Haskell and read it all the way through. I finally decided that I would make the effort and read it all the way through, but because it came out 6 years ago I'm wondering if some parts of it might now be outdated and obsolete.

In the interest of not picking up bad practices, I come to you: are there any sections of Real World Haskell that may have outdated-enough content to warrant me not applying them to real projects?

Thank you!

1. Chapter 1 Getting Started

   1. Your Haskell Environment

   2. Getting Started with ghci, the Interpreter

   3. Basic Interaction: Using ghci as a Calculator

   4. Command-Line Editing in ghci

   5. Lists

   6. Strings and Characters

   7. First Steps with Types

   8. A Simple Program

2. Chapter 2 Types and Functions

   1. Why Care About Types?

   2. Haskell’s Type System

   3. What to Expect from the Type System

   4. Some Common Basic Types

   5. Function Application

   6. Useful Composite Data Types: Lists and Tuples

   7. Functions over Lists and Tuples

   8. Function Types and Purity

   9. Haskell Source Files, and Writing Simple Functions

   10. Understanding Evaluation by Example

   11. Polymorphism in Haskell

   12. The Type of a Function of More Than One Argument

   13. Why the Fuss over Purity?

   14. Conclusion

3. Chapter 3 Defining Types, Streamlining Functions

   1. Defining a New Data Type

   2. Type Synonyms

   3. Algebraic Data Types

   4. Pattern Matching

   5. Record Syntax

   6. Parameterized Types

   7. Recursive Types

   8. Reporting Errors

   9. Introducing Local Variables

   10. The Offside Rule and Whitespace in an Expression

   11. The case Expression

   12. Common Beginner Mistakes with Patterns

   13. Conditional Evaluation with Guards

4. Chapter 4 Functional Programming

   1. Thinking in Haskell

   2. A Simple Command-Line Framework

   3. Warming Up: Portably Splitting Lines of Text

   4. Infix Functions

   5. Working with Lists

   6. How to Think About Loops

   7. Anonymous (lambda) Functions

   8. Partial Function Application and Currying

   9. As-patterns

   10. Code Reuse Through Composition

   11. Tips for Writing Readable Code

   12. Space Leaks and Strict Evaluation

5. Chapter 5 Writing a Library: Working with JSON Data

   1. A Whirlwind Tour of JSON

   2. Representing JSON Data in Haskell

   3. The Anatomy of a Haskell Module

   4. Compiling Haskell Source

   5. Generating a Haskell Program and Importing Modules

   6. Printing JSON Data

   7. Type Inference Is a Double-Edged Sword

   8. A More General Look at Rendering

   9. Developing Haskell Code Without Going Nuts

   10. Pretty Printing a String

   11. Arrays and Objects, and the Module Header

   12. Writing a Module Header

   13. Fleshing Out the Pretty-Printing Library

   14. Creating a Package

   15. Practical Pointers and Further Reading

6. Chapter 6 Using Typeclasses

   1. The Need for Typeclasses

   2. What Are Typeclasses?

   3. Declaring Typeclass Instances

   4. Important Built-in Typeclasses

   5. Automatic Derivation

   6. Typeclasses at Work: Making JSON Easier to Use

   7. Living in an Open World

   8. How to Give a Type a New Identity

   9. JSON Typeclasses Without Overlapping Instances

   10. The Dreaded Monomorphism Restriction

   11. Conclusion

7. Chapter 7 I/O

   1. Classic I/O in Haskell

   2. Working with Files and Handles

   3. Extended Example: Functional I/O and Temporary Files

   4. Lazy I/O

   5. The IO Monad

   6. Is Haskell Really Imperative?

   7. Side Effects with Lazy I/O

   8. Buffering

   9. Reading Command-Line Arguments

   10. Environment Variables

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

   1. Efficient File Processing

   2. Filename Matching

   3. Regular Expressions in Haskell

   4. More About Regular Expressions

   5. Translating a glob Pattern into a Regular Expression

   6. An important Aside: Writing Lazy Functions

   7. Making Use of Our Pattern Matcher

   8. Handling Errors Through API Design

   9. Putting Our Code to Work

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

   1. The find Command

   2. Starting Simple: Recursively Listing a Directory

   3. A Naive Finding Function

   4. Predicates: From Poverty to Riches, While Remaining Pure

   5. Sizing a File Safely

   6. A Domain-Specific Language for Predicates

   7. Controlling Traversal

   8. Density, Readability, and the Learning Process

   9. Another Way of Looking at Traversal

   10. Useful Coding Guidelines

10. Chapter 10 Code Case Study: Parsing a Binary Data Format

    1. Grayscale Files

    2. Parsing a Raw PGM File

    3. Getting Rid of Boilerplate Code

    4. Implicit State

    5. Introducing Functors

    6. Writing a Functor Instance for Parse

    7. Using Functors for Parsing

    8. Rewriting Our PGM Parser

    9. Future Directions

11. Chapter 11 Testing and Quality Assurance

    1. QuickCheck: Type-Based Testing

    2. Testing Case Study: Specifying a Pretty Printer

    3. Measuring Test Coverage with HPC

12. Chapter 12 Barcode Recognition

    1. A Little Bit About Barcodes

    2. Introducing Arrays

    3. Encoding an EAN-13 Barcode

    4. Constraints on Our Decoder

    5. Divide and Conquer

    6. Turning a Color Image into Something Tractable

    7. What Have We Done to Our Image?

    8. Finding Matching Digits

    9. Life Without Arrays or Hash Tables

    10. Turning Digit Soup into an Answer

    11. Working with Row Data

    12. Pulling It All Together

    13. A Few Comments on Development Style

13. Chapter 13 Data Structures

    1. Association Lists

    2. Maps

    3. Functions Are Data, Too

    4. Extended Example: /etc/passwd

    5. Extended Example: Numeric Types

    6. Taking Advantage of Functions as Data

    7. General-Purpose Sequences

14. Chapter 14 Monads

    1. Revisiting Earlier Code Examples

    2. Looking for Shared Patterns

    3. The Monad Typeclass

    4. And Now, a Jargon Moment

    5. Using a New Monad: Show Your Work!

    6. Mixing Pure and Monadic Code

    7. Putting a Few Misconceptions to Rest

    8. Building the Logger Monad

    9. The Maybe Monad

    10. The List Monad

    11. Desugaring of do Blocks

    12. The State Monad

    13. Monads and Functors

    14. The Monad Laws and Good Coding Style

15. Chapter 15 Programming with Monads

    1. Golfing Practice: Association Lists

    2. Generalized Lifting

    3. Looking for Alternatives

    4. Adventures in Hiding the Plumbing

    5. Separating Interface from Implementation

    6. The Reader Monad

    7. A Return to Automated Deriving

    8. Hiding the IO Monad

16. Chapter 16 Using Parsec

    1. First Steps with Parsec: Simple CSV Parsing

    2. The sepBy and endBy Combinators

    3. Choices and Errors

    4. Extended Example: Full CSV Parser

    5. Parsec and MonadPlus

    6. Parsing a URL-Encoded Query String

    7. Supplanting Regular Expressions for Casual Parsing

    8. Parsing Without Variables

    9. Applicative Functors for Parsing

    10. Applicative Parsing by Example

    11. Parsing JSON Data

    12. Parsing a HTTP Request

17. Chapter 17 Interfacing with C: The FFI

    1. Foreign Language Bindings: The Basics

    2. Regular Expressions for Haskell: A Binding for PCRE

    3. Passing String Data Between Haskell and C

    4. Matching on Strings

18. Chapter 18 Monad Transformers

    1. Motivation: Boilerplate Avoidance

    2. A Simple Monad Transformer Example

    3. Common Patterns in Monads and Monad Transformers

    4. Stacking Multiple Monad Transformers

    5. Moving Down the Stack

    6. Understanding Monad Transformers by Building One

    7. Transformer Stacking Order Is Important

    8. Putting Monads and Monad Transformers into Perspective

19. Chapter 19 Error Handling

    1. Error Handling with Data Types

    2. Exceptions

    3. Error Handling in Monads

20. Chapter 20 Systems Programming in Haskell

    1. Running External Programs

    2. Directory and File Information

    3. Program Termination

    4. Dates and Times

    5. Extended Example: Piping

21. Chapter 21 Using Databases

    1. Overview of HDBC

    2. Installing HDBC and Drivers

    3. Connecting to Databases

    4. Transactions

    5. Simple Queries

    6. SqlValue

    7. Query Parameters

    8. Prepared Statements

    9. Reading Results

    10. Database Metadata

    11. Error Handling

22. Chapter 22 Extended Example: Web Client Programming

    1. Basic Types

    2. The Database

    3. The Parser

    4. Downloading

    5. Main Program

23. Chapter 23 GUI Programming with gtk2hs

    1. Installing gtk2hs

    2. Overview of the GTK+ Stack

    3. User Interface Design with Glade

    4. Event-Driven Programming

    5. Initializing the GUI

    6. The Add Podcast Window

    7. Long-Running Tasks

    8. Using Cabal

24. Chapter 24 Concurrent and Multicore Programming

    1. Defining Concurrency and Parallelism

    2. Concurrent Programming with Threads

    3. Simple Communication Between Threads

    4. The Main Thread and Waiting for Other Threads

    5. Communicating over Channels

    6. Useful Things to Know About

    7. Shared-State Concurrency Is Still Hard

    8. Using Multiple Cores with GHC

    9. Parallel Programming in Haskell

    10. Parallel Strategies and MapReduce

25. Chapter 25 Profiling and Optimization

    1. Profiling Haskell Programs

    2. Controlling Evaluation

    3. Understanding Core

    4. Advanced Techniques: Fusion

26. Chapter 26 Advanced Library Design: Building a Bloom Filter

    1. Introducing the Bloom Filter

    2. Use Cases and Package Layout

    3. Basic Design

    4. The ST Monad

    5. Designing an API for Qualified Import

    6. Creating a Mutable Bloom Filter

    7. The Immutable API

    8. Creating a Friendly Interface

    9. Creating a Cabal Package

    10. Testing with QuickCheck

    11. Performance Analysis and Tuning

27. Chapter 27 Sockets and Syslog

    1. Basic Networking

    2. Communicating with UDP

    3. Communicating with TCP

28. Chapter 28 Software Transactional Memory

    1. The Basics

    2. Some Simple Examples

    3. STM and Safety

    4. Retrying a Transaction

    5. Choosing Between Alternatives

    6. I/O and STM

    7. Communication Between Threads

    8. A Concurrent Web Link Checker

    9. Practical Aspects of STM

1. Appendix Installing GHC and Haskell Libraries

   1. Installing GHC

   2. Installing Haskell Software

2. Appendix Characters, Strings, and Escaping Rules

   1. Writing Character and String Literals

   2. International Language Support

   3. Escaping Text

3. Colophon