Beginning Haskell : a project-based approach /

Beginning Haskell provides a broad-based introduction to the Haskell language, its libraries and environment, and to the functional programming paradigm that is fast growing in importance in the software industry. The book takes a project-based approach to learning the language that is unified aroun...

Descripción completa

Detalles Bibliográficos
Clasificación:Libro Electrónico
Autor principal: Mena, Alejandro Serrano
Formato: Electrónico eBook
Idioma:Inglés
Publicado: [New York] : Apress, ©2014.
Colección:Expert's voice in programming.
Temas:
Haskell (Computer program language)
Functional programming (Computer science)
Haskell (Langage de programmation)
Programmation fonctionnelle.
COMPUTERS > Programming Languages > General.
COMPUTERS > Programming > General.
HASKELL
Haskell (programmeertaal)
Acceso en línea:Texto completo (Requiere registro previo con correo institucional)
Tabla de Contenidos:
  • At a Glance
  • Contents
  • About the Author
  • About the Technical Reviewer
  • Acknowledgments
  • Introduction
  • Part 1: First Steps
  • Chapter 1: Going Functional
  • Why Haskell?
  • Why Pure Functional Programming?
  • Why Strong Static Typing?
  • The Haskell Ecosystem
  • The History of Haskell
  • Your Working Environment
  • Installing on Windows
  • Installing on Mac OS X
  • Installing on Linux
  • Installing on Linux from Source
  • Checking That the Installation is Successful
  • Installing EclipseFP
  • First steps with GHCi
  • The Time Machine Store
  • Summary
  • Chapter 2: Declaring the Data Model
  • Working with Characters, Numbers, and Lists
  • Characters
  • Numbers
  • Strings
  • Lists
  • Lists Operations
  • Creating a New Project
  • Creating a Project from the Command Line
  • Creating a Project from EclipseFP
  • Understanding Modules
  • Defining Simple Functions
  • Creating a Simple Function
  • Specifying the Function's Type
  • Developing a Robust Example
  • Returning More than One Value
  • Working with Data Types
  • Pattern Matching
  • Simple Patterns
  • Lists and Tuples
  • Guards
  • View Patterns
  • Records
  • Creation and Use
  • The "Default Values" Idiom
  • Summary
  • Chapter 3: Reusing Code Through Lists
  • Parametric Polymorphism
  • Functions as Parameters
  • Higher-Order Functions
  • Anonymous Functions
  • Partial Application of a Function
  • More on Modules
  • Module Imports
  • Smart Constructors and Views
  • Diving into Lists
  • Folds
  • Lists and Predicates
  • Lists Containing Tuples
  • List Comprehensions
  • Haskell Origami
  • Summary
  • Chapter 4: Using Containers and Type Classes
  • Using Packages
  • Managing Packages with Cabal and EclipseFP
  • Sandboxed Environments
  • Containers: Maps, Sets, Trees, Graphs
  • Maps
  • Sets
  • Trees
  • Graphs
  • Obtaining Help
  • Ad-hoc Polymorphism: Type Classes.
  • Declaring Classes and Instances
  • Built-in Type Classes
  • Binary Tress for the Minimum Price
  • Step 1: Simple Binary Trees
  • Step 2: Polymorphic Binary Trees
  • Step 3: Binary Trees with Monoidal Cache
  • Container-related Type Classes
  • Functors
  • Foldables
  • Summary
  • Chapter 5: Laziness and Infinite Structures
  • An Infinite Number of Time Machines
  • Lazy Evaluation Model
  • Understanding Evaluation in Haskell
  • Problems with Laziness
  • Pattern Matching and Laziness
  • Profiling with GHC
  • Strictness Annotations
  • Summary
  • Part 2: Data Mining
  • Chapter 6: Knowing Your Clients Using Monads
  • Data Mining
  • Implementing K-means
  • Lenses
  • Discovering Monads
  • Watching out for Incomplete Data
  • Combinators for State
  • Dissecting the Combinators
  • do Notation
  • Monad Laws
  • Different Sorts of State
  • State and Lenses
  • Reader, Writer, and RWS
  • Mutable References with ST
  • Summary
  • Chapter 7: More Monads: Now for Recommendations
  • Returning More Than One Value
  • The List Monad
  • A New View Over Monads
  • Failures and Alternatives
  • Association Rules Learning.
  • Flattening Values into Transactions
  • The Apriori Algorithm
  • Search Problems
  • Paths in a Graph
  • The Logic Monad
  • Monads and Lists Redux
  • Combining Values Under a Monad
  • Monad Comprehensions
  • Combining Monads
  • Monad Transformers
  • Monad Classes
  • Summary
  • Chapter 8: Working in Several Cores
  • Parallelism, Concurrency, Distribution
  • The Par Monad
  • Futures
  • Dataflow Parallelism with IVars
  • Parallelizing the Apriori Algorithm
  • Software Transactional Memory
  • Concurrent Use of Resources
  • Atomic Transactions
  • Rolling Back Transactions
  • Producer-Consumer Queues
  • Cloud Haskell
  • Looking for Galaxies
  • Looking for Typed Galaxies
  • Extra Features
  • Summary
  • Part 3: Resource Handling.
  • Chapter 9: Dealing with Files: IO and Conduit
  • Basic Input and Output
  • Randomness
  • Working with Files
  • Reading and Writing
  • Handling Files
  • Error Handling
  • Pure Errors
  • Catching Exceptions
  • Throwing Exceptions
  • Streaming Data with Conduit
  • Problems with Lazy Input/Output
  • Introducing Conduits
  • Accessing Files via Conduit
  • Looking Further than Text Files
  • Basic Networking
  • Binary Serialization
  • Summary
  • Chapter 10: Building and Parsing Text
  • The Five Textual Data Types
  • Building as Fast as the Wind
  • Parsing with attoparsec
  • Introducing New Type Classes
  • Applicative
  • Functors, Applicatives, and Monads
  • Alternative
  • Traversable
  • Don't Overengineer: Just Use JSON
  • Summary
  • Chapter 11: Safe Database Access
  • Database Access Landscape
  • Abstracting over Several DBMSs
  • Introducing Persistent and Esqueleto
  • Connection
  • Schemas and Migrations
  • Describing the Entities
  • Creating the Database
  • Queries
  • Queries by Identifier or Uniqueness
  • Selecting Several Entities
  • SQL Queries with Esqueleto
  • Insertions, Updates, and Deletions
  • Summary
  • Chapter 12: Web Applications
  • Haskell Web Ecosystem
  • Web Frameworks
  • Compilation to Javascript
  • RESTful Structure
  • Backend with Scotty
  • Simple Skeleton
  • Showing Products from the Database
  • Inserting New Products Using Forms
  • Frontend with Fay
  • Foreign Function Interface
  • Fay and jQuery
  • Summary
  • Part 4: Domain Specific Languages
  • Chapter 13: Strong Types for Describing Offers
  • Domain Specific Languages
  • Embedding Your Language in Haskell
  • The Offers Language
  • Adding Safety to the Expression Language
  • Dependent Typing
  • Introducing Idris
  • Enforcing the Presents Rule in Idris
  • Type-level Programming in Haskell
  • Two Styles of Programming
  • Representing Natural Numbers
  • Functional Dependencies.
  • Categories of Products with FDs
  • Enforcing the Presents Rule with FDs
  • Type Families
  • Enforcing the Presents Rule with TFs
  • Categories of Products with TFs
  • Data Type Promotion and Singletons
  • A Further Refinement to the Presents Rule
  • Enforcing the Duration Rule
  • Summary
  • Chapter 14: Interpreting Offers with Attributes
  • Interpretations and Attribute Grammars
  • A Simple Interpretation
  • Introducing Attribute Grammars
  • Your First Attribute Grammar
  • Synthesizing the Result
  • Executing the Attribute Grammar
  • Integrating UUAGC in Your Package
  • Installing UUAGC
  • UUAGC and Cabal
  • Expressions Interpretation
  • Using an Attribute Grammar
  • Precomputing Some Values
  • A Different (Monadic) View
  • Offer Interpretations
  • Checking the Presents Rule
  • Showing a HTML Description
  • Origami Programming Over Any Data Type
  • Summary
  • Part 5: Engineering the Store
  • Chapter 15: Documenting, Testing, and Verifying
  • Documenting Binary Trees with Haddock
  • Unit Testing with HUnit
  • Declaring Tests in Cabal
  • Writing Unit Tests
  • Randomized Testing with QuickCheck
  • Testing List Properties
  • Testing Binary Tree Properties
  • Formal Verification with Idris
  • Summary
  • Chapter 16: Architecting Your Application
  • Design Patterns and Functional Programming
  • Medium-Level Guidelines
  • Use Higher-Order Combinators
  • Refactor
  • Use Type Classes Wisely
  • Enforce Invariants via the Type System
  • Stay (as) Pure and Polymorphic (as Possible)
  • Tools
  • Project and Dependency Management
  • Code Style
  • Documentation
  • Test and Verification
  • Benchmarking
  • Profiling
  • Coverage
  • Remote Monitoring
  • Projects
  • Data Mining Library
  • Store Network Client
  • Administration Interface and Tetris
  • Roll Your Own Monad
  • Summary
  • APPENDIX A: Looking Further
  • Haskell Resources
  • Other Functional Languages.
  • APPENDIX B: Time Traveling with Haskell
  • Index.

Ejemplares similares