Back Matter

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Appendix: Time Travelling with Haskell

Now that you’ve come to this point, it’s time to tell you one secret that only Haskellers are allowed to know: our code can travel in time! To do so, you need to kindly ask the Doctor ¹ for his Tardis Time Machine . Gratefully, the machine has a Haskell form: it can be converted into a monad.

The Tardis monad is provided by the tardis package in Hackage. The interface is similar to a State monad, but you can work with state that travels in the normal way, from the current step of execution forward in time, and with state that works backward in time. For each of those states you have a pair of functions.

You move the state forward in time by updating it using sendFuture , and you are able to get it at other point in the execution via getPast .
The state that travels backward is updated via sendPast and obtained via getFuture .

In both cases, it’s important to understand that you can obtain only the last version of each state. For example, if you call sendFuture twice, any call to getPast will retrieve the second version of sendFuture .

It’s time to play the trick. Let’s code a function that, given a list of numbers, builds a new list of tuples, with each tuple showing the current sum up to that point from the beginning of the list, and the same but from the end of the list. You can see the result as two states traveling in opposite directions in time: the sum from the beginning goes forward, and the sum from the end travels backward. Figure A-1 shows this graphically.

Figure A-1

Forward and backward states in Tardis

The corresponding Haskell code follows:

{-# LANGUAGE RecursiveDo #-}

import Control.Monad.Tardis

sumListTardis :: [Int] -> [(Int,Int)]

sumListTardis lst = evalTardis (sumListTardis' lst) (0, 0)

sumListTardis' :: [Int] -> Tardis Int Int [(Int,Int)]

sumListTardis' (x:xs) = do

sumFw <- getPast

let newFw = sumFw + x

sendFuture $ newFw

rec let newBw = sumBw + x

sendPast $ newBw

sumBw <- getFuture

rest <- sumListTardis' xs

return $ (newFw, newBw):rest

sumListTardis' [] = return []

The forward state handling is straightforward. At each step, you just take the previous state from the past and send to the future a new value that sums the current number to the forward state.

The backward state is much more mysterious. As you can see, the information is sent to the past and then brought from the future. This way of working is needed because if you first send to the past and then try to bring from the future, you would try to get the value of the last call to getPast , which is the present moment. This is impossible because the state would depend on itself in a direct way. Instead, the code asks to create a recursive do block, which starts with the rec keyword and allows you to refer to a later value.

Note

Not all monads support the rec keyword. To use it, the monad you’re working on must be an instance of the MonadFix type class.

You can run the Tardis over some list and check that everything works:

*> sumListTardis [1,2,3,4]

[(1,10),(3,9),(6,7),(10,4)]

While Tardis seems like very weird stuff, with no real applications, there are cases in real life where a computation receives feedback from itself. The archetypical example is in circuits, where an output cable may be connected to an input port again. As in the previous case, in circuits you need to be careful not to create a dependence of a value on itself; you usually add some delay to make the input depend on the output in some previous moment. Another example is bowling, where the points scored after a strike or spare depends on the score in later rounds. ²

If only you had known that you could travel into the future! Instead of moving step-by-step through examples and exercises, you could have traveled and asked your future self to give you all your Haskell knowledge. But such is the mystery of laziness, of type classes, and of higher-order functions. It’s now time to have fun and explore the rest of the Haskell universe!

Index

A

Ad-hoc polymorphism, See also Type classes

Algebraic data types (ADTs)

Alternative (type class)

Anamorphism

Anonymous functions

Applicative (type class)

Apriori algorithm

Arrow syntax

Association list

Association rule learning

Apriori algorithm

confidence

frequent sets

minimum confidence

flattening values

support

transactions

attoparsec package

(<$>) and (<*>) combinators

Control.Applicative module

Data.Attoparsec.Combinator module

disjunction

functor

interpreter

notInClass function

sequence

string

Attribute grammars

advantage

AspectAG

attr block

block

boilerplate code

chained

data type declaration

disadvantage

execution

Hackage

higher-level model

inherited

integrating UUAGC and Cabal

local

modifications

purpose of

root node

semantics

copy rule

sem block

system, UUAGC

synthesized attribute

top-down and bottom-up flow

tree

UUAGC

build-type

Cabal stanza

code

compilation

haskellsyntax

installation

wrap_Expr function

B

Benchmarking

Binary tree documentation

haddock

feature

syntax

treeInsert function

HLint

Javadoc and Doxygen

Binary trees

graphical representation

leaf marker

monoidal cache

Data.Monoid

floating point

type classes

Ord instances

Ord type class

TravelGuide

treeFind function

TravelGuide type

Blaze-html package

Boolean operators

Building text

builder data type

ByteString library

client representation

OverloadedStrings

singleton function

toStrict function

C

Cabal (build tool)

build

execute with profiling

project creation

Category theory

Characters, Char

Combinator library

Concurrency

forkIO

MVar

STM ( see Software Transactional Memory (STM))

Conditional, if-then-else

Conduit

access files

allocate function

await

binary serialization

bracket function

ConduitM context

(.|) connect or fuse operator

Data.Conduit.List module

definition

feature

fold function

lazy input/output

hGetContents

iteratee and enumerator packages

seq/deepseq

MonadIO

networking

putStrLn

runTCPClient

runTCPServer

randomRIO function

runConduit

streaming data problem

unfold function

yield

Containers

graphs

stronglyConnComp

time machines

topological sort

Haskell browser

maps

built-in Prelude module

clients classification

Data.Map module

delete function

findWithDefault

HashMap

Haskell

IntMap

patterns

sets

Data.Set module

fromList function

HashSet

IntSet

trees

Boolean value

breadth-first fashions

Data.Tree

forest

post-order traversal

pre-order traversal

Coverage

Criterion (benchmarking tool)

D

Database access

connection

deletions

insertions

landscape

abstraction

libraries

Persistent and Esqueleto

libraries

queries

aggregation operators

count function

entities selection

expression

filters

identifier/uniqueness

joins

select function

selectList

schemas and migrations ( see Schemas and migrations)

updates

Database library

Data.Graph module

Data mining

association rules

Apriori algorithm

frequent set

clustering algorithms

K-means algorithm

centroid cluster

cluster assignment phase

clusters data set

initial centroid

kMeans function

multiparameter type classes

partition creation

testing

tuple algorithm

Vectorizables and Double pairs

lenses

boilerplate code

Client Double type

Client Int type

data structure

kMeans function

lens library

(^?) operator

(^.) operator

(.~) operator

(&) operator

Person data type

template Haskell

traversable type class

Data model declaration

ADTs

characters

data types ( see Data types)

functions ( see Function declarations)

lists

Boolean operators

cons

constructors and destructors

homogeneous

if expression

literals

nil [] operator

type variable

numeric constants

pattern matching ( see Pattern matching)

records ( see Records)

smart constructors and default values

strings

Data type generic programming

field, Rec0

generic (type class)

product, (*)

sum, (+)

Data types

ADTs

algebra ( see Fold)

automatic deriving

capitalization rules

clients

constructors

declaration

default deriving

Gender

generic programming ( see Data type generic programming)

parametric

Person

promotion, DataKinds

singleton

smart constructor

strictness annotation

strong typing

Dependent typing

Design patterns

adapter pattern

code templates

concurrency

Haskell benefits

higher-level abstraction

monadic

Digestive-functors (package)

form description

Spock, runForm

view, getForm

Distributed programming

Documentation, see Haddock (tool)

Domain specific language (DSL)

advantages

dependent type systems

expression language

EmptyDataDecls extension

GADTs

interpretation function

time traveling

types

external, stand-alone

internal, embedded

deep embedding

interpretation

shallow embedding

FDs ( see Functional dependencies (FDs))

Haskell

advantages

attoparsec

deep embedding

embedded/internal DSL

external/stand alone

host language

language interpretation

offers language

data declaration

duration rule

groups

presents rule

patterns

promotion and singletons

advantage

DataKinds extension

duration rule

Haskell programs

metaprogramming facilities

purpose

TFs

type-level literals

SQL

TFs ( see Type families (TFs))

type-level programming ( see Type-level programming)

E

Either (type, monad)

Except (type, monad)

Elm (language)

Elm architecture

Browser.element

Browser.sandbox

commands

model-update-view

JSON decoder

Eq (type class)

Error handling

catching exceptions

ArithException

Control.Exception module

exception filter

finally function

handle

IOException

vs . pure errors

pure errors

left/right constructor

Maybe/Either

MonadPlus

mtl package

safe package

throwError

throwing exceptions

Typeable type class

Esqueleto (package)

aggregation

query

set

Exception

bracket

catch

throw

F

First-class citizen

Floating-point numbers

double precision, Double

single precision, Float

Fold

algebra

left fold, foldr

over any data type

right fold, foldr

unfold

Foldable (type class)

Formal verification

Binary search tree

data type refinement

measure

refinement types ( see LiquidHaskell (tool))

Free monad

Function

anonymous

declaration

operator

section

partial application

predicate

Functional dependencies (FDs)

ambiguity problem

G

Generalized algebraic data type (GADT)

definition

type safety

GHC profiling

cost centers

heap profiling

run with-h

run with-hy

Main.hs file

memory profiling

putStrLn function

time profiling

Glasgow Haskell Compiler (GHC)

Graph

paths

H

Hackage

Haddock (tool)

documentation comment

section

syntax

Hamlet package

aeson library

internationalization

type-safe URLs

Hanging lambdas

Haskell platform

browser containers

data model declaration ( see Data model declaration)

ecosystem

history

installation

language

OCaml and F#

Origami

programming approach

TARDIS Time Machine

resources

Haskell programming

design patterns ( see Design patterns)

guidelines

enforce invariants

higher-order combinators

pure and polymorphic

refactor

type classes

projects

administration interface and Tetris

data mining library

monads

store network client

tools

benchmarking

code style

coverage

documentation

profiling

project and dependency management

remote monitoring

test and verification

Haskell web ecosystem

JavaScript compilation

web framework

Happstack

HTTP requests and responses

snap

WAI

Higher-order function

filter

fold ( see Fold)

map

HLint style tool

Hoogle

HUnit

I

Infinite structures

time machines

data type declaration

Fibonacci numbers

GHC interpreter

infinite lists

iterate function

timelyIncMachines

Input/Output files

directory package

do notation

error handling ( see Error handling)

filepath package

fmap

foldM code

haskeline library

Haskell’s prelude module

hSetBuffering

listOfActions

no escape hatch

program implementation

randomness

global random generator

randomRIO function

reading and writing

Data.String

getArgs function

hClose functions

hSetEncoding function

openFile operation

withFile function

runState function

splitExtensions

Integral numbers

bounded, Int

unbounded, Integer

Internal state, monads

Reader monad

RWS monad

state and lenses

lens library

State monad

zooming function

ST monad

Control.Monad.ST module

Data.STRef module

modifySTRef function

readSTRef function

traverseList function

writeSTRef function

Writer monad

Interpretation

attribute grammar, ( See also Attribute grammars)

computation rules

copy rules

describeOffer function

Expr data type

HTML description

advantages

Blaze-html library

chained

counter attribute

@lhs.counter

local variable

ordering

PercentDiscount/BetterOf constructors

siblings

string value

threading

monadic view

origami programming

anamorphism

catamorphisms

D-algebra

using Expr

guidelines

recursive

presents rule

copy rule

Monoid instance

present constructor

restrict constructor

Root data type

Interpreter, GHCi

type of an expression

IO (monad)

console I/O

getLine

Haskeline

putStrLn

file I/O

bracket

lazy (problems with)

System file path

System.IO

withFile

randomness

J

JSON

aeson (package)

DeriveGeneric extension

HashMap

lazy ByteStrings

lens-aeson package

object function

optparse-applicative

ToJSON and FromJSON function

K

K-means algorithm

L

Lambda calculus

Laziness

evaluation

constructor

in Haskell programs

head allNumbers

non-strict/lazy

repeat e

tail allNumbers

thunk

timelyIncMachines

pattern matching

BangPatterns

irrefutable pattern

lengthyOperation

problems

foldr evaluation

Laziness (evaluation model)

BangPatterns

Forcing

problems

thunk

Lazy evaluation

Lens

microlens (library)

over, (%~)

set, (.~)

view, (^.)

with State

LiquidHaskell (tool)

data type refinement

measure

refinement type

Lists

anonymous functions

comprehension

parallel

transformation

exporting and importing

expression comprehension

filter functions

fold ( see Fold)

foldr

guard comprehensions

Haskell Origami

unfolds

higher-order functions

infinite

iterate

repeat

module imports

hiding imports

permutations function

Prelude

qualified imports

rename

without qualification

monad

monadic functions

mapM

sequence

parallel comprehension

parametric polymorphism

data declaration

etymology

fst function

head function

type parameters

partial application

combinators

curried versions

list keyword

point-free style

section

two-argument function

predicates

compareClient function

compare function

declarative

dropWhile function

filter function

infix notation

isIndividual function

lexicographic comparison

qualifiers comprehension

smart constructors and views

takeWhile function

tuples

unfolds

Local bindings

let

where

Logic (type, monad)

M

Maps

Maybe (type, monad)

error handling

Migration

Module

declaration

exposed-modules of a library

import

qualified

hiding

MonadPlus (type class)

guard

Monads

association rules

association rules learning

bind, (>>=)

classes

combinators

comprehensions

Control.Monad module

dissecting combinators

Control.Monad module

Maybe monad

Monad type class

State s monad

thenDo combinator

do notation

access combinators

compiler

Control.Monad.State module

modify combinators

recursive do

failure concept

guard condition

mfilter function

MonadPlus type class

mplus operation

mzero function

filterM function

fmap and join function

foldM function

forM function

free

incomplete data

Data.Maybe module

NULL value

interpretation

internal state

Reader monad

RWS monad

state and lenses

ST monad

Writer monad

join

laws

liftM and ap function

list monad

mapM function

monad transformers

nondeterministic behavior

restrictive

return

roll your own ( see Free monad)

search problems

sequence, definition

summary

syntax

transformer ( see Monad transformer)

Monad transformer

lift

monad classes

mtl (package)

MonadTrans

transformers (package)

Monoid

Semigroup

Mutable reference

ST monad

STRef

N

Networking

using Conduit

Num (type class)

O

OCaml and F#

Ord (type class)

P

Packages

build ( see Cabal (build tool))

Cabal

data structures

Hackage package database

Versioning policy

definition

dependencies

Hackage

Stackage

stanza

executable

library

test-suite

Parallelism

Par ( see Par (monad))

parallel Apriori

Parametric polymorphism

IVar

Par (monad)

apriori algorithm

generateNextLk function

parMap function

dataflow parallelism

direct scheduler

graph

IVars

Par () function

definition

deterministic

futures

parallel Apriori

runtime thread

Parsing text

attoparsec package

(<$>) and (<*>) combinators

consumes part

Control.Applicative module

Data.Attoparsec.Combinator module

disjunction

functor parser

interpreter

many function

notInClass function

partial

sequence

string

JSON ( see JSON)

new type classes

Alternative

Applicative

Functor

Maybe

Monad

traversable

textual data types

ByteString values

conduit

Data.Text.Lazy/Data.ByteString.Lazy

encodeUtf8

(< >) operator

OverloadedStrings

strict and lazy version

String

Pattern matching

case-of

clientName

companyName function

data types

exhaustive

guards

Ackermann function

Fibonacci and binomial functions

unzip function

lists and tuples

neutral elements

n-th Fibonacci number

partial arguments

pragma

variables

view patterns

Patterns

Peano numerals

addition

successor

Persistent (package)

connection

pool

deletion

insertion

query

get

getBy

selectList

schema

entity description

migration

uniqueness constraint

update

Point-free style

Polymorphism

ad-hoc ( see Type classes)

parametric

Preprocessor

Profiling

heap

hp2ps

ThreadScope

time

Project creation, Cabal

command line

interpretation rules

modules

Pure expression

Q

Queries

count function

entities selection

Esqueleto

aggregation operators

expression

get, getBy, selectList and count

joins

select function

filters

identifier/uniqueness

selectList

Queue

message broker

AMQP

using STM

QuickCheck

R

Randomized testing

binary tree properties

(==>) combinator

Gen instance

oneof function

shrink

suchThat function

properties

QuickCheck

Rational numbers, Ratio

Reader (type, monad)

Read-eval-print loop (REPL)

Read (type class)

Records

Client and Person definitions

data declarations

field names

library and maintainability problem

pattern matching

puns

TimeMachine data types

Referential transparency

Regression testing

Remote monitoring

Representational State Transfer (REST)

RESTful structure

RWS (type, monad)

S

Schemas and migrations

database creation

entities description

definition

identifier

limitation

nullable

quasiquotation

uniqueness constraints

migration

Scotty, backend application

blaze-html package

hamlet package

product insertion, forms

digestive-functors

POST request method

products

simple skeleton

Search problems

graphs, paths in

logic monad

Serialization

binary

comma-separated values

JSON ( see JSON)

Sets

Shakespeare (package)

Show (type class)

SmallCheck

Smart constructors

Snaplets

Software transactional memory (STM)

atomic transactions

deadlocking

main function

money variable

stm package

stock variable

concurrent programming

forkDelay function

forkIO function

IO () function

newMVar function

putMVar function

randomRIO function

readMVar function

threads

producer-consumer queues

queue

rollback

cash-based transaction

definition

retry function

stm monad

STM (monad)

TVar

Spock (web framework)

database connection

form ( see Digestive-functors (package))

route definition

database connection

hookAnyAll

variable

Stack (build tool)

build

execute with profiling

new project

Stanzas

State (type, monad)

Strict evaluation model

Strictness

memory representation

strict field

unpacked fields

Strings

builder

ByteString

conversion

Hello world

OverloadedStrings

text

Stylish Haskell

T

TARDIS time machine

forward and backward state

rec keyword

Testing

exhaustive testing

SmallCheck

HSpec

randomized testing

arbitrary (type class)

generator

properties

QuickCheck

Tasty

test-suite stanza ( see Packages)

unit testing

HSpec

HUnit

The Monad Reader (magazine)

ThreadScope

Time machine store

Traversable (type class)

sequence

traverse

Trees

binary

monoidal cache

forest

traversal

Tuples

Type classes

associated type ( see Type family (TFs))

declaration

Haskell

instance type

Nameable

variable

default signature

foldables

functors

generic programming

Haskell

instance

multi-parameter

functional dependency ( see Functional dependencies (FDs))

number-related type classes

Ord and Eq classes

data declaration

default definitions

ease of instantiation

Haskell

Haskell’s type class

minimal complete definition

performance

overlap

Type families (TFs)

associated types

U, V

Unit testing

assertBool

assertion

cabal file

exitcode-stdio-1.0

test-suite stanza

cabal test

definition

frameworks

Hspec

HUnit tool

testGroup function

Utrecht University Attribute Grammar Compiler (UUAGC)

UUAGC

build-type

Cabal

code generation

compilation

haskellsyntax

installation

W, X, Y, Z

Web application interface (WAI)

Web applications

Fay, frontend application

Haskell web ecosystem ( see Haskell web ecosystem)

RESTful structure

Scotty, backend application

blaze-html package

hamlet package

local type signature

product insertion, forms

products

simple skeleton

Web framework

REST

request method

route

Spock ( see Spock (web framework))

Writer (type, monad)

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.

Table of Contents for Back Matter

Create new playlist

Sign In

Sign Up

Index

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

U, V

W, X, Y, Z

Table of Contents for
Back Matter