# Haskell

Haskell is a functional programming language. It is distinct in a few ways:
* Haskell is pure. A function when invoked using the same arguments will return the same result every time.
* Haskell is lazy. Evaluations are performed only when needed.
* Haskell provides a modern type system with state-of-the-art features like type classes and generalized algebraic data types (soon enough, terms like those will roll smoothly off your tongue).
Haskell is enjoyable to use because dealing with pure functions makes code much easier to reason about, and the advanced type system helps catch silly and profound mistakes.
Our aim in this book is to introduce you to the Haskell programming language — from the very basics to advanced features — and to computer programming in general. We urge seasoned programmers to be especially patient with this process. The languages you are familiar with are likely to differ greatly from Haskell, and the habits acquired from those languages might make it difficult to understand how things work — Haskell is simple, but different. Learning to see the world through the warped mindset of a functional programmer is an adventure in a brave new world, which brings knowledge valuable far beyond the boundaries of any language.

## Overview

The book is divided into three sections: a Beginner's Track, an Advanced Track, and a section called Haskell in Practice. The last section, which covers practical use cases, depends only on the Beginner's Track. Seasoned programmers may read the overview to quickly evaluate what makes Haskell unique and different from other languages.

## Beginner's Track

This section introduces you to Haskell basics and some commonly used libraries. At the end of this track, you should be able to write simple Haskell programs. Most chapters include exercises, with solutions, for your practice.
| Haskell Basics Getting set up Variables and functions Truth values Type basics Lists and tuples Type basics II Next steps Building vocabulary Simple input and output | Elementary Haskell Recursion Lists II (map) Lists III (folds, comprehensions) Type declarations Pattern matching Control structures More on functions Higher-order functions Using GHCi effectively | Intermediate Haskell Modules Standalone programs Indentation More on datatypes Other data structures Classes and types The Functor class | Monads Prologue: IO, an applicative functor Understanding monads Maybe - List do notation IO - State Alternative and MonadPlus Monad transformers |

## Advanced Track

This section introduces wider functional programming concepts such as different data structures and type theory. It will also cover more practical topics like concurrency.
| Welcome to Haskell Monoids Applicative functors Foldable Traversable Arrow tutorial Understanding arrows Continuation passing style Zippers Lenses Comonads Value recursion (MonadFix) Effectful streaming Mutable objects Concurrency Template Haskell Type Families | Fun with Types Polymorphism Existentially quantified types Advanced type classes Phantom types Generalised algebraic data-types (GADT) Datatype algebra Type constructors & Kinds | Wider Theory Denotational semantics Equational reasoning Program derivation Category theory The Curry–Howard isomorphism fix and recursion | Haskell Performance Introduction Step by step examples Graph reduction Laziness Time and space profiling Strictness Algorithm complexity Data structures Parallelism |

## Haskell in Practice

Day-to-day issues of working with Haskell include items such as knowing the standard libraries, building graphical interfaces, and working with databases. You should be able to jump directly to this section from the beginner's track.
| Libraries Reference Introduction Maybe - IO - Random Data structures primer Arrays - Maps | General Practices Debugging Testing Packaging your software (Cabal) Using the Foreign Function Interface (FFI) Generic programming: Scrap your boilerplate | Specialised Tasks Graphical user interfaces (GUI) Databases Working with XML Parsing mathematical expressions Writing a basic type checker |

## Appendices

* Syntactic sugar
* Answers to exercises
* Authors and Acknowledgements

## About the book

* Notes for contributors
* Style conventions
* To do
* Templates for the Haskell wikibook
* Experimental Modules
* List of topics

## Other Haskell tutorials

* Haskell Meta-tutorial — the tutorial to find other tutorials
* Learn You a Haskell for Great Good — Tutorial aimed at beginners who may have experience in imperative programming languages but haven't programmed in a functional language before. Available online at no charge (CC BY-NC-SA license); also released as a conventional book.
* Real World Haskell — an O'Reilly book, available online at no charge (CC BY-NC license). Built around case studies of practical applications.

## Tutorials that have been incorporated into the Haskell Wikibook

The following may be read independently, but their content has been imported and adapted already into the Wikibook here
* Write Yourself a Scheme in 48 Hours — An alternate approach to teaching Haskell (and perhaps Scheme), aimed at a more advanced audience (though not necessarily one that knows how to program!)
* Yet Another Haskell Tutorial — aimed at beginners and takes a practical approach to things.

## Additional resources

* Learning Haskell at haskell.org
* What I Wish I Knew When Learning Haskell — A wide-ranging collection of concise summaries of many intermediate and advanced Haskell topics. Released in the public domain.