Haskell Cookbook

Overview of this book

Haskell is a purely functional language that has the great ability to develop large and difficult, but easily maintainable software. Haskell Cookbook provides recipes that start by illustrating the principles of functional programming in Haskell, and then gradually build up your expertise in creating industrial-strength programs to accomplish any goal. The book covers topics such as Functors, Applicatives, Monads, and Transformers. You will learn various ways to handle state in your application and explore advanced topics such as Generalized Algebraic Data Types, higher kind types, existential types, and type families. The book will discuss the association of lenses with type classes such as Functor, Foldable, and Traversable to help you manage deep data structures. With the help of the wide selection of examples in this book, you will be able to upgrade your Haskell programming skills and develop scalable software idiomatically.

Preface

What this book covers

What you need for this book

Free Chapter

Foundations of Haskell

Introduction

Getting started with Haskell

Working with data types

Working with pure functions and user-defined data types

Working with list functions

Getting Functional

Introduction

Working with recursive functions

Reversing a list - Recursive worker function pattern

Creating maps and filters

Working with laziness and recursion

Working with folds

Sorting a list

Implementing merge sort

Implementing Eratosthenes Sieve

Defining Data

Introduction

Defining a product type

Defining a sum type

Defining a binary tree and traversing it

Defining data with functions

Using Maybe

Using Either

Working with type classes

Working with Monoid

Working with Functors, Applicatives, and Monads

Introduction

Working with Functors

Binary tree as Functor

Working with Applicatives

Binary tree as Applicative

Working with monad

List as monad

Working with IO monad

Writing INI parser

Errors and exception handling

More about Monads

Introduction

Writing a State Monad

Computing a fibonacci number with State Monad

Writing a State Monad transformer

Working with the Reader monad transformer

Working with the Writer monad transformer

Combining monad transformers

Working with Common Containers and Strings

Introduction

Working with sets

Shopping cart as a set

Working with maps

Log analysis with map

Working with vector

Working with text and bytestring

Creating and testing a priority queue

Working with Foldable and Traversable

Working with Relational and NoSQL Databases

Introduction

Working with Persistent

Managing migrations

Creating custom data types

Using Esqueleto to do advanced SQL queries

Using hedis to work with redis (key-value, list and hash)

Using hashsets and sorted sets in redis to create a Trie

Working with HTML and Templates

Introduction

Using blaze to create an HTML template

Using blaze to reverse engineer an HTML page

Use blaze-html with Bootstrap to create HTML template

Using heist as a template engine

Working with splice in Heist

Working with Snap Framework

Introduction

Getting started with Snap

Routing in Snap

Serving static contents in Snap

Form handling in Snap

Creating and composing snaplets

Session handling in Snap

Authentication in Snap

File upload with Snap

Working with Advanced Haskell

Introduction

Working with existentially quantified type

Working with Rank-N type

Working with type family

Working with GADTs

Working with Lens and Prism

Introduction

Creating lenses

Working with lenses

Working with Traversal

Working with Iso

Working with Prism

Working with predefined lenses

Concurrent and Distributed Programming in Haskell

Working with strategies

Working with monad-par

Working with Cloud Haskell

Using Cloud Haskell to start master and slave nodes

Using closure to communicate between nodes

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Implementing Eratosthenes Sieve

In this recipe, we will look at a prime number calculator called Eratosthenes Sieve. It is an old algorithm for finding prime numbers. The prime numbers are found by crossing out composite numbers. The sieve works as follows:

Start with 2, a known prime. Strike out all the numbers that are multiples of 2.
Start with the next unmarked number, which will be the next prime (since it is not divided by any prime before). Repeat the procedure of marking all the multiples.
Repeat the procedure.

For more information, visit https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes.

Getting ready

Create a new project, eratosthenes, using the simple Stack template. Change into the project directory and build...

Haskell Cookbook

Haskell Cookbook

Overview of this book

Related Content you might be interested in

Current Title:

Haskell Cookbook

Soar with Haskell

Learning Functional Data Structures and Algorithms