Index

A

• aAalex library / Parsing and pretty-printing
• Aattoparsec library / Parsing and pretty-printing
• abstract-par library / Parallel and concurrent programming
• abstract data-types
  • marshalling / Marshalling abstract datatypes
• abstract loggers / More abstract loggers
• Accelerate
  • matrix multiplication, implementing / Example – Matrix multiplication
• Accelerate, concepts
  • kernels / Kernels – The motivation behind explicit use and run
  • elements / Working with elements and scalars
  • scalars / Working with elements and scalars
  • rudimentary array computations / Rudimentary array computations
  • flow control / Flow control and conditional execution
  • conditional execution / Flow control and conditional execution
  • tuples / Working with tuples
  • reducing / Folding, reducing, and segmenting
  • segmenting / Folding, reducing, and segmenting
  • folding / Folding, reducing, and segmenting
  • stencils / Accelerated stencils
  • permutation / Permutations in Accelerate
  • backend foreign function interface / Using the backend foreign function interface
• accelerate-cuda package / Running with the CUDA backend
• Accelerate programs
  • writing / Writing Accelerate programs
  • generated code, inspecting / Inspecting generated code
• accumulator parameters
  • about / Accumulator parameters
• accumulators
  • about / Recursion and accumulators
• acid-state package / Persistent storage, SQL, and NoSQL, acid-state and safecopy
• ad hoc polymorphic
  • about / Meeting lazy evaluation
• aeson library / Encoding to and from other formats
• affinity / Bounded threads and affinity
• aggressive inlining
  • about / Inlining and stream fusion
• Algebraic Data Types (GADT) / Phantom types
• alike package / Pretty-printing and text formatting
• allocations
  • minimizing / Increasing sharing and minimizing allocation
  • profiling / Profiling time and allocations
• amazonka Amazonka / Web technologies
• anatomy, Haskell project / The anatomy of a Haskell project
• array reductions
  • via folding / Reduction via folding
• arrays
  • mapping / Mapping and delayed arrays
  • extending / Indices, slicing, and extending arrays
• Async API
  • using / Using the Async API
  • examples, timeouts / Async example – Timeouts
• asynchronous errors
  • handling / Handling asynchronous errors
• asynchronous processing
  • about / Asynchronous processing
  • Async API, using / Using the Async API
  • composing, with Concurrently type / Composing with Concurrently
• attoparsec
  • example / An example of parsing using io-streams and attoparsec
• AWS / Web technologies

B

• base (module Data.Fixed) library / Numeric data for special use
• basic-prelude library / Control and utility libraries
• benchmarking
  • about / Benchmarking using the criterion library
  • with criterion / Benchmarking using the criterion library
• benchmarks / Test suites and benchmarks
• bidirectional channels
  • establishing / Establishing bidirectional channels
• binary and textual data, handling
  • about / Handling binary and textual data
  • bit arrays, representing / Representing bit arrays
  • bytes, handling / Handling bytes and blobs of bytes
  • blobs of bytes, handling / Handling bytes and blobs of bytes
  • characters, working with / Working with characters and strings
  • strings, working with / Working with characters and strings
  • builder abstractions, used for iterative construction / Builders for iterative construction
• binary I/O
  • about / Binary I/O
• binary library / Binary serialization of Haskell values
• binary serialization, libraries
  • binary / Binary serialization of Haskell values
  • cereal / Binary serialization of Haskell values
  • store / Binary serialization of Haskell values
• binary serialization, of Haskell values / Binary serialization of Haskell values
• biographical profiling
  • about / Biographical profiling
• blaze-html / Web technologies
• bounded thread / Bounded threads and affinity
• boxed types / Heap, stack, and memory management
• branching / Performance of GADTs and branching
• break-down subset, heap residencies
  • cost centres (-hc) / Heap profiling
  • per-module (-hm) / Heap profiling
  • closure descriptions (-hd) / Heap profiling
  • type description (-hy) / Heap profiling
  • retainers (-hr) / Heap profiling
  • biography (-hb) / Heap profiling
• buffering
  • about / File handles, buffering, and encoding
• buffering modes
  • BlockBuffering / File handles, buffering, and encoding
  • LineBuffering / File handles, buffering, and encoding
  • NoBuffering / File handles, buffering, and encoding
• builder abstractions
  • using, for iterative construction / Builders for iterative construction
  • using, for strings / Builders for strings
• ByteString Builder / Builders for iterative construction
• bytestring library / Representing data

C

• C
  • common types / Common types in Haskell and C
• cabal file
  • fields / Useful fields and flags in cabal files
  • flags / Useful fields and flags in cabal files
  / Preprocessing Haskell source code
• cassava library / Encoding to and from other formats
• cereal library / Binary serialization of Haskell values
• C functions
  • calling, from Haskell / From Haskell to C and C to Haskell
• Chan
  • used, for broadcasting / Broadcasting with Chan
• channels
  • using / Using channels
• characters
  • text library, using / Using the text library
• charts
  • creating / Creating charts and diagrams
• charts, libraries
  • Chart / Creating charts and diagrams
  • Chart-cairo / Creating charts and diagrams
  • Chart-diagrams / Creating charts and diagrams
• chunked-data library / Using a custom Prelude
• chunkedChunked-data library / Control and utility libraries
• classy-prelude library / Control and utility libraries
• closures / Spawning and closures
• Cloud Haskell
  • about / Processes and message-passing
• cmdargs library / Scripting and CLI applications
• Cmm
  • about / Interpreting GHC's internal representations
• code optimizations
  • state hack / The state hack
  • float-in / Floating lets in and out
  • float-out / Floating lets in and out
  • common subexpressions, eliminating / Eliminating common subexpressions
  • liberate case duplicates code / Liberate-case duplicates code
• Common Subexpression Elimination (CSE) / Eliminating common subexpressions
• common types, C / Common types in Haskell and C
• common types, Haskell / Common types in Haskell and C
• compiler code optimizations
  • about / Compiler code optimizations
• concurrency primitives
  • about / Threads and concurrency primitives
• conduit library / Control and utility libraries
• connectionConnection library / Networking and HTTP
• console-program / Scripting and CLI applications
• constant applicative form (CAF)
  • about / Constant applicative form
• Constant Applicative Form (CAF) / Setting cost centres manually
• containers library / Representing data
• Control.Concurrent (base) library / Parallel and concurrent programming
• control and utility libraries
  • pipes / Control and utility libraries
  • conduit / Control and utility libraries
  • io-streams / Control and utility libraries
  • lens / Control and utility libraries
  • convertibleConvertible / Control and utility libraries
  • classy-prelude / Control and utility libraries
  • basic-prelude / Control and utility libraries
  • chunkedChunked-data / Control and utility libraries
• control inlining
  • about / Control inlining
  • rewrite rules, using / Using rewrite rules
  • definitions, specializing / Specializing definitions
  • phase control / Phase control
• convertibleConvertible library / Control and utility libraries
• convolution operation
  • with stencils / Convolution with stencils
• Core / Using GHC like a pro
• cost centre-based heap profiling
  • about / Cost centre-based heap profiling
• cost centres
  • about / Profiling time and allocations
  • setting, manually / Setting cost centres manually
  • setting, automatically / Setting cost centres automatically
• C preprocessor (CPP)
  • about / Preprocessing Haskell source code
  • use cases / Preprocessing Haskell source code
• criterion benchmark suite
  • about / Benchmarking using the criterion library
• cryptography
  • about / Cryptography
• cryptography, libraries
  • SHA / Cryptography
  • RSA / Cryptography
  • HsOpenSSL / Cryptography
  • cryptonite / Cryptography
  • skeinSkein / Cryptography
• cryptonite package / Cryptography
• CSV input / CSV input and output
• CSV output / CSV input and output
• CUDA backend
  • using / Running with the CUDA backend
• CUDA programs
  • debugging / Debugging CUDA programs
• custom Prelude
  • using / Using a custom Prelude

D

• data-type generic programming
  • about / Datatype generic programming
  • generic sum example / Working example – A generic sum
• data marshal
  • about / Data marshal and stable pointers
• data parallel programming
  • about / Data parallel programming – Repa
• data representation
  • libraries / Representing data
• datatype fields
  • unpacking / Annotating strictness and unpacking datatype fields
• datatype generic programming
  • about / Datatype generic programming
• debugging
  • options / Options for profiling and debugging
• Decimal (module Data.Decimal) library / Numeric data for special use
• definitions
  • specializing / Specializing definitions
• delayed arrays / Mapping and delayed arrays
• delayed representations / Delayed representation and fusion
• diagrams
  • creating / Creating charts and diagrams
• Diagrams library / Creating charts and diagrams
• difference lists
  • using / Using difference lists
  • performance / Difference list performance
  • using, with writer monad / Difference list with the Writer monad
• discrete-time events
  • about / Switching and discrete-time events
• domain specific language (DSL)
  • about / Launching missiles during compilation

E

• ekg
  • used, for monitoring over HTTP / Monitoring over HTTP with ekg
• Elerea
  • about / The tiny discrete-time Elerea
  • performance / Performance and limitations in Elerea
  • limitations / Performance and limitations in Elerea
  / Functional Reactive Programming
• encoding / File handles, buffering, and encoding, Encoding and serialization
• encoding, libraries
  • cassava / Encoding to and from other formats
  • aeson / Encoding to and from other formats
  • yaml / Encoding to and from other formats
  • xml / Encoding to and from other formats
  • json-autotype / Encoding to and from other formats
• ephemeral data structures
  • about / Ephemeral data structures
  • mutable references / Mutable references are slow
  • mutable arrays, using / Using mutable arrays
  • mutable vectors, using / Using mutable vectors
• erroring
  • about / Erroring and handling exceptions
• errors
  • synchronous errors, handling / Handling synchronous errors
  • asynchronous errors, handling / Handling asynchronous errors
• esqueleto DSL / persistent and esqueleto
• esqueleto library / Persistent storage, SQL, and NoSQL, persistent and esqueleto
• Eval monad
  • about / The Eval monad and strategies
• eventlog
  • used, for tracing / Tracing using eventlog
• events, and behaviors
  • combining / Combining events and behaviors
  • switching / Switching events and behaviors
• examples, from image processing
  • about / Example from image processing
  • image, loading from file / Loading the image from file
  • letters, identifying with convolution / Identifying letters with convolution
  • strings, extracting from image / Extracting strings from an image
  • performance, testing / Testing and evaluating performance
  • performance, evaluating / Testing and evaluating performance
• exception hierarchy / The exception hierarchy
• exceptions
  • handling / Erroring and handling exceptions, Handling exceptions
• exceptions, libraries
  • exceptionsExceptions / Handling exceptions
  • safe-exceptions / Handling exceptions
• exceptionsExceptions library / Handling exceptions

F

• failure, handling
  • about / Handling failure
  • monitors, firing up / Firing up monitors
  • matching on message queue / Matching on the message queue
  • processes, linking together / Linking processes together
  • message-passing performance / Message-passing performance
• file handles
  • about / File handles, buffering, and encoding
• finger trees / Accessing both ends fast with Seq
• FlexibleInstances / Useful GHC extensions
• force
  • using / When in doubt, use the force
• formats
  • encoding to / Encoding to and from other formats
  • encoding from / Encoding to and from other formats
• FP Complete / Using the stack tool
• Frames library / Mathematics, statistics, and science
• functional dependencies
  • about / Functional dependencies
• Functional Graph Library (fgl) / Functional graphs
• functional graphs / Functional graphs
• Functional Reactive Programming, libraries
  • Elerea / Functional Reactive Programming
  • Yampa / Functional Reactive Programming
  • Reactive-banana / Functional Reactive Programming
• function pointers / Function pointers and wrappers
• fusion / Delayed representation and fusion
• futures
  • about / spawn for futures and promises

G

• GADTs
  • performance / Performance of GADTs and branching
• garbage collector
  • tuning / Tuning the garbage collector
  • parallel GC / Parallel GC
• general algebraic datatypes / Unbox with UNPACK
• getopt parsers / Scripting and CLI applications
• GHC
  • using, like pro / Using GHC like a pro
  • operating / Operating GHC
  • operating, circular dependency problem / Circular dependencies
  • code optimizations, adjusting / Adjusting optimizations and transformations
  • code transformations, adjusting / Adjusting optimizations and transformations
  • compiling, via LLVM route / Compiling via the LLVM route
  • shared libraries, linking / Linking and building shared libraries
  • shared libraries, building / Linking and building shared libraries
  • Haskell source code, preprocessing / Preprocessing Haskell source code
  • type-safety, enforcing with Safe Haskell / Enforcing type-safety using Safe Haskell
• GHC's internal representations
  • interpreting / Interpreting GHC's internal representations
  • GHC Core, reading / Reading GHC Core
  • Spineless tagless G-machine (STG) / Spineless tagless G-machine
• GHC-specific features
  • about / Primitive GHC-specific features
  • kinds encode type, representation / Kinds encode type representation
• GHC Core
  • considerations / Reading GHC Core
• GHC extensions
  • about / Useful GHC extensions
  • for patterns / Extensions for patterns and guards
  • for guards / Extensions for patterns and guards
• GHCi
  • tip / Inspecting time and space usage
  • Repa, working / Playing with Repa in GHCi
• GHC options
  • summaries / Summary of useful GHC options
  • flags / Basic usage
  • LLVM backend / The LLVM backend
  • optimization, turning on / Turn optimizations on and off
  • optimization, turning off / Turn optimizations on and off
  • Runtime System (compile-time), configuring / Configuring the Runtime System (compile-time)
  • Safe Haskell compilation, controlling / Safe Haskell
• GHC PrimOps
  • coding in / Coding in GHC PrimOps
• GHC Runtime System
  • and threads / Runtime System and threads
  • asynchronous exceptions, masking / Masking asynchronous exceptions
• GNU Multiple Precision Arithmetic Library (GMP) / Handling numerical data
• granularity
  • fine-tuning, with chunking / Fine-tune granularity with chunking and buffering
  • fine-tuning, with buffering / Fine-tune granularity with chunking and buffering
• green threads / Scheduler and green threads
• guarded recursion
  • about / Guarded recursion

H

• H (HaskellR) / Tools for research and sketching
• Hackage / Running with the CUDA backend
• Happstack / Web technologies
• happy library / Parsing and pretty-printing
• hashtables library / Representing data
• haskelineHaskeline library / Scripting and CLI applications
• Haskell
  • tests, writing for / Writing tests for Haskell
  • about / Reading, writing, and handling resources
  • evaluation stack, using / Evaluation stack in Haskell
  • generating / Generating Haskell with Haskell
  • splicing, with $(…) / Splicing with $(…)
  • names, in templates / Names in templates
  • smart template constructor / Smart template constructors
  • constN function / The constN function
  • code lifting to Q, with quotation brackets / Lifting Haskell code to Q with quotation brackets
  • missiles, launching on compilation / Launching missiles during compilation
  • data, reifying into template objects / Reifying Haskell data into template objects
  • setters, deriving with Template Haskell / Deriving setters with Template Haskell
  • quasiquoting, for DSLs / Quasi-quoting for DSLs
  • common types / Common types in Haskell and C
• Haskell callbacks, from C / Haskell callbacks from C
• Haskell functions
  • exporting / Exporting Haskell functions
• Haskell programs
  • time, inspecting / Inspecting time and space usage
  • space usage, inspecting / Inspecting time and space usage
• Haskell project
  • anatomy / The anatomy of a Haskell project
• HaskellR project
  • about / The HaskellR project
• HaTeX / Tools for research and sketching
• HDBC / Persistent storage, SQL, and NoSQL, HDBC and add-ons
• HDBC-odbc / Persistent storage, SQL, and NoSQL
• heap objects, biographical profiling
  • state LAG / Biographical profiling
  • state USE / Biographical profiling
  • state DRAG / Biographical profiling
  • state VOID / Biographical profiling
• heap profiling
  • about / Heap profiling
  • cost centre-based heap profiling / Cost centre-based heap profiling
• here library / Pretty-printing and text formatting
• hmatrix-gsl-stats library / Mathematics, statistics, and science
• hmatrix library / Mathematics, statistics, and science
• hpc command-line utility / Test frameworks
• HsOpenSSL library / Cryptography
• Hspec
  • about / Writing tests for Haskell, Test frameworks
  • reference / Test frameworks
• hstatistics library / Mathematics, statistics, and science
• http-client library / HTTP clients and servers
• HTTP clients and servers, libraries
  • http-client / HTTP clients and servers
  • httpHTTP-client-tls / HTTP clients and servers
  • wreq / HTTP clients and servers
  • wai / HTTP clients and servers
  • warp / HTTP clients and servers
• httpHTTP-client-tls library / HTTP clients and servers
• HUnit
  • used, for unit testing / Unit testing with HUnit

I

• I/O
  • lazy I/O / Traps of lazy I/O
  • binary I/O / Binary I/O
  • textual I/O / Textual I/O
  • lifting up from / Lifting up from I/O
  • top-level mutable references / Top-level mutable references
  • lifting, from base monad / Lifting from a base monad
  • lifting, base with exception handling / Lifting base with exception handling
• I/O performance
  • with filesystem objects / I/O performance with filesystem objects
• ihaskell / Tools for research and sketching
• indefinite blocking / Indefinite blocking and weak references
• indices / Indices, slicing, and extending arrays
• inlining
  • about / Inlining and stream fusion
  • considerations / Inlining and stream fusion
• Inter-process Communication (IPC) / Acting as a TCP server (Unix domain sockets)
• International Components for Unicode (ICU) / Using the text library
• interpolateInterpolate library / Pretty-printing and text formatting
• io-streams
  • example / An example of parsing using io-streams and attoparsec
• io-streams library / Control and utility libraries

J

• json-autotype library / Encoding to and from other formats
• JSON-RPC APIs / JSON remote procedure calls
• jsonJSON-rpc library / Supplementary HTTP libraries

L

• lazy evaluation schema
  • about / Meeting lazy evaluation
  • sum, writing correctly / Writing sum correctly
  • weak head normal form / Weak head normal form
  • folds / Folding correctly
• lazy I/O
  • about / Traps of lazy I/O
• lenses
  • using / Using lenses
• lens library / Control and utility libraries
• libraries
  • installing, with profiling / Installing libraries with profiling
• libraries, for data representation
  • vector / Representing data
  • text / Representing data
  • bytestring / Representing data
  • containers / Representing data
  • unordered-containers / Representing data
  • hashtables / Representing data
  • mutable-containers / Representing data
• libraries, for mathematics
  • hmatrix / Mathematics, statistics, and science
  • hmatrix-gsl-stats / Mathematics, statistics, and science
  • matrixMatrix / Mathematics, statistics, and science
• libraries, for monads and transformers
  • Lifted-base / Working with monads and transformers
  • stm-lifted / Working with monads and transformers
  • Monad-control / Working with monads and transformers
  • Monad-logger / Working with monads and transformers
  • LogicT / Working with monads and transformers
  • monadMonad-unlift / Working with monads and transformers
  • Monad-loops / Working with monads and transformers
• libraries, for parallel and concurrent programming
  • Control.Concurrent (base) / Parallel and concurrent programming
  • Parallel / Parallel and concurrent programming
  • monadMonad-par / Parallel and concurrent programming
  • monad-par-extras / Parallel and concurrent programming
  • abstract-par / Parallel and concurrent programming
  • repa / Parallel and concurrent programming
• libraries, for parsing and pretty-printing
  • parsec / Parsing and pretty-printing
  • Aattoparsec / Parsing and pretty-printing
  • megaparsec / Parsing and pretty-printing
  • happy / aAalex / Parsing and pretty-printing
  • pcre-heavy / Parsing and pretty-printing
• libraries, for pretty-printing and text formatting
  • wl-pprint / Pretty-printing and text formatting
  • alike / Pretty-printing and text formatting
  • text-format / Pretty-printing and text formatting
  • interpolateInterpolate / Pretty-printing and text formatting
  • here / Pretty-printing and text formatting
• libraries, for Scripting and CLI applications
  • shelly / Scripting and CLI applications
  • turtle / Scripting and CLI applications
  • cmdargs / Scripting and CLI applications
  • haskelineHaskeline / Scripting and CLI applications
  • console-program / Scripting and CLI applications
  • shakeShake / Scripting and CLI applications
  • propellor / Scripting and CLI applications
• libraries, for statistics
  • hstatistics / Mathematics, statistics, and science
  • statistics / Mathematics, statistics, and science
• libraries, for testing and benchmarking
  • QuickCheck / Testing and benchmarking
  • doctest / Testing and benchmarking
  • HSpec / Testing and benchmarking
  • HUnit / Testing and benchmarking
  • tasty / Testing and benchmarking
  • criterion / Testing and benchmarking
  • weigh / Testing and benchmarking
• libraries, Repa
  • repa-devil / Additional libraries
  • repa-io / Additional libraries
  • repa-algorithms / Additional libraries
  • repa-stream / Additional libraries
  • repa-flow / Additional libraries
• Lifted-base library / Working with monads and transformers
• logging, in Haskell
  • about / Logging in Haskell
  • with FastLogger / Logging with FastLogger
• LogicT library / Working with monads and transformers

M

• MagicHash language extension / Coding in GHC PrimOps
• manifest representations / Manifest representations
• marshalling
  • in standard libraries / Marshalling in standard libraries
• matrixMatrix library / Mathematics, statistics, and science
• megaparsec library / Parsing and pretty-printing
• memoization
  • about / Memoization and CAFs
• memory
  • allocating, outside heap / Allocating memory outside the heap
• mersenne-random library / Random number generators
• Mersenne Twister / Random number generators
• message-passing
  • about / Processes and message-passing
• message type
  • creating / Creating a message type
• migrator / persistent and esqueleto
• modules
  • Safe / Enforcing type-safety using Safe Haskell
  • Safe-Inferred / Enforcing type-safety using Safe Haskell
  • Trustworthy / Enforcing type-safety using Safe Haskell
  • UnSafe / Enforcing type-safety using Safe Haskell
• moments / Reactive-banana – Safe and simple semantics
  • observing, on demand / Observing moments on demand
• monad
  • working with / Working with monads and monad stacks
  • list monad / The list monad and its transformer
  • transformer / The list monad and its transformer
  • free monads / Free monads
  • transformers, working with / Working with monad transformers
  • speedup, via continuation-passing style / Speedup via continuation-passing style
• Monad-control library / Working with monads and transformers
• Monad-logger library / Working with monads and transformers
• Monad-loops library / Working with monads and transformers
• monad-par-extras library / Parallel and concurrent programming
• monad-unlift library
  • need for / Monad morphisms – monad-unlift
• monadic loggers
  • customizing / Customizing monadic loggers
• monadic logging / Monadic logging
• Monad instance / Reactive-banana – Safe and simple semantics
• monadMonad-par library / Parallel and concurrent programming
• monadMonad-unlift library / Working with monads and transformers
• MonadRandom library / Random number generators
• monads
  • throw function, implementing / Throw and catch in other monads besides IO
  • catch function, implementing / Throw and catch in other monads besides IO
  • working with / Working with monads and transformers
• monad stacks
  • working with / Working with monads and monad stacks
• monad transformer library (mtl) / Working with monad transformers
• monitoring
  • in realtime / Profile and monitor in real time
• monitoring, over HTTP
  • with ekg / Monitoring over HTTP with ekg
• monomorphism restriction (MR)
  • about / Monomorphism Restriction
• multi-package projects / Multi-package projects
• MultiParamTypeClasses / Useful GHC extensions
• mutable-containers library / Representing data
• mutable vectors
  • using / Using mutable vectors
  • bubble sort, using with / Bubble sort with vectors
• mutually recursive signals
  • about / Mutually recursive signals
  • side effects, signalling / Signalling side-effects
  • signal networks, changing dynamically / Dynamically changing signal networks
• MVars
  • about / MVar
  • features / MVars are fair
  • used, as building blocks / MVar as a building block
• mwc-random library / Random number generators

N

• network (module Network) library / Networking and HTTP
• network-transport library
  • about / Networking above the transport layer
• network-uri library / Networking and HTTP
• networking
  • about / Sockets and networking
  • above transport layer / Networking above the transport layer
  / Nodes and networking
• networking and HTTP, libraries
  • network (module Network) / Networking and HTTP
  • network-uri / Networking and HTTP
  • connectionConnection / Networking and HTTP
• nodes / Nodes and networking
• NoMonomorphismRestriction language extension
  • about / Monomorphism Restriction
• non-deterministic parallelism
  • with ParIO / Non-deterministic parallelism with ParIO
• Normal Form (NF) / Weak head normal form, When in doubt, use the force
• Normal Form Data (NFData) / Benchmarking using the criterion library
• numbers (modules Data.Number.*) library / Numeric data for special use
• numerical data
  • handling / Handling numerical data
• numeric data, libraries
  • base (module Data.Fixed) / Numeric data for special use
  • Decimal (module Data.Decimal) / Numeric data for special use
  • numbers (modules Data.Number.*) / Numeric data for special use
• numeric types, Haskell / Handling numerical data

O

• O(log n) / Using the containers package
• objects
  • outside heap / Objects outside the heap
  • pointing, in heap / Pointing to objects in the heap
• Operating System (OS) thread / Threads and mutable references

P

• parallelism
  • diagnosing / Diagnosing parallelism – ThreadScope
• Parallel library / Parallel and concurrent programming
• ParIO
  • using, for non-deterministic parallelism / Non-deterministic parallelism with ParIO
• Par monad
  • about / The Par monad and schedules
• parsec library / Parsing and pretty-printing
• parsing
  • about / Parsing and pretty-printing
• partial functions
  • about / Partial functions
• partitioned arrays
  • about / Cursored and partitioned arrays
• patricia / Functional graphs
• PatternGuards
  • about / Extensions for patterns and guards
• PatternSynonyms
  • about / Extensions for patterns and guards
• pcre-heavy library / Parsing and pretty-printing
• Perl 5 compatible regular expressions / Regular expressions in Haskell
• persistent-odbc / Persistent storage, SQL, and NoSQL
• persistent library / Persistent storage, SQL, and NoSQL, persistent and esqueleto
• phantom types
  • about / Phantom types
• pipes
  • benefits / Strengths and weaknesses of pipes
  • drawbacks / Strengths and weaknesses of pipes
• pipes library / Control and utility libraries
• polymorphic
  • about / Meeting lazy evaluation
• polymorphic programs / Polymorphism performance
• polymorphism performance / Polymorphism performance
• pretty-printing / Pretty-printing and text formatting
• primitive parallelism
  • about / Primitive parallelism and the Runtime System
• processes
  • about / Processes and message-passing
  • creating / Creating a Process
• profiler
  • unexpected crashes, debugging with / Debugging unexpected crashes with profiler
• profiling
  • about / Profiling time and allocations
  • libraries, installing with / Installing libraries with profiling
  • in realtime / Profile and monitor in real time
  • options / Options for profiling and debugging
• promises
  • about / spawn for futures and promises
• propellor library / Scripting and CLI applications
• property checks
  • about / Property checks
• pseq
  • about / Subtle evaluation – pseq

Q

• QuickCheck
  • about / Writing tests for Haskell

R

• random-fu library / Random number generators
• random number generators
  • about / Random number generators
• random number generators, libraries
  • MonadRandom / Random number generators
  • mwc-random / Random number generators
  • random-fu / Random number generators
  • mersenne-random / Random number generators
• raw UDP traffic
  • about / Raw UDP traffic
• reactimate
  • used, for performing output from network / Reactimate output
• Reactive-banana / Reactive-banana – Safe and simple semantics
  • first GUI application / Example – First GUI application
  • graphical display, with wxWidgets / Graphical display with wxWidgets
  • input, adding / Adding input and output
  • output, adding / Adding input and output
  • input, adding via polling / Input via polling or handlers
  • input, adding via handlers / Input via polling or handlers
  • input, adding dynamically / Input and output dynamically
  • output, adding dynamically / Input and output dynamically
• reactive-banana / Functional Reactive Programming
• Reader / Working with monads and monad stacks
• Reader Writer State (RWS) / Working with monad transformers
• recursion
  • about / Recursion and accumulators, Recursion and semantics
• regular expressions, in Haskell
  • about / Regular expressions in Haskell
• remote process
  • calling / Calling a remote process
• Repa
  • about / Data parallel programming – Repa
  • working with / Playing with Repa in GHCi
• repa-algorithms library
  • about / Additional libraries
• repa-devil library
  • about / Additional libraries
• repa-flow library
  • about / Additional libraries
• repa-io library
  • about / Additional libraries
• repa-stream library
  • about / Additional libraries
• Repa code
  • writing / Writing fast Repa code
• repa library / Parallel and concurrent programming
• resources
  • reading / Reading, writing, and handling resources
  • writing / Reading, writing, and handling resources
  • handling / Reading, writing, and handling resources
  • manging, with ResourceT / Managing resources with ResourceT
• ResourceT
  • resources, managing with / Managing resources with ResourceT
• REST API
  • programming / Programming a REST API
• Rest framework, Silk
  • reference / Programming a REST API
• Rest REST library / Supplementary HTTP libraries
• retainer profiling
  • about / Retainer profiling
• reverse polish notation (RPN)
  • about / Guarded recursion
• rewrite rules
  • using / Using rewrite rules
• RSA library / Cryptography
• RSpec
  • about / Test frameworks
• RTS options
  • summaries / Summary of useful RTS options
  • scheduler flags / Scheduler flags
  • memory management / Memory management
  • garbage collection / Garbage collection
  • runtime system statistics / Runtime System statistics
  • profiling / Profiling and debugging
  • debugging / Profiling and debugging
• runtime system
  • about / Primitive parallelism and the Runtime System
• runtime system, GHC
  • tuning / Tuning GHC's Runtime System
  • scheduler threads / Scheduler and green threads
  • green threads / Scheduler and green threads
  • heap management / Heap, stack, and memory management
  • stack management / Heap, stack, and memory management
  • memory management / Heap, stack, and memory management
  • garbage collector, tuning / Tuning the garbage collector
  • tracing options / Profiling and tracing options
  • profiling options / Profiling and tracing options

S

• safe-exceptions library / Handling exceptions
• safe-exceptions package / Handling exceptions
• safecopy package / Persistent storage, SQL, and NoSQL, acid-state and safecopy
• schedules
  • about / The Par monad and schedules
• ScopedTypeVariables
  • about / Extensions for patterns and guards
• semantics
  • about / Recursion and semantics
• Seq / Accessing both ends fast with Seq
• sequential data, handling
  • about / Handling sequential data
  • difference lists, using / Using difference lists
  • zippers, using / Using zippers
• serialization / Encoding and serialization
• Set Cost Centre (SCC) / Setting cost centres manually, Debugging unexpected crashes with profiler
• shakeShake library / Scripting and CLI applications
• SHA library / Cryptography
• shared library
  • compiling / Compiling a shared library
• sharing
  • increasing / Increasing sharing and minimizing allocation
• Shelly library / Scripting and CLI applications
• shelly library / Scripting and CLI applications
• signal functions
  • state, adding to / Adding state to signal functions
• SimpleLocalNet backend
  • running with / Running with the SimpleLocalNet backend
• Single Instruction, Multiple Data (SIMD) / Compiling via the LLVM route
  • about / Primitive GHC-specific features
• skeinSkein library / Cryptography
• slicing / Indices, slicing, and extending arrays
• SmallCheck
  • about / Writing tests for Haskell
• smap
  • about / Cursored and partitioned arrays
• Snap / Web technologies
• sockets
  • about / Sockets and networking
• Software Transactional Memory (STM)
  • about / Software Transactional Memory
  • bank account example / STM example – Bank accounts
  • alternative transactions / Alternative transactions
  • exceptions / Exceptions in STM
• spark / Sparks and spark pool
• spark pool
  • overflowed / Spark away
  • dud / Spark away
  • GC'd / Spark away
  • fizzled / Spark away
  / Sparks and spark pool
• sparks
  • about / Spark away
• sparse data, handling
  • about / Handling sparse data
  • containers package, using / Using the containers package
  • unordered-containers package, using / Using the unordered-containers package
• spawn function
  • for futures / spawn for futures and promises
  • for promises / spawn for futures and promises
• spawning / Spawning and closures
• spec testing
  • about / Writing tests for Haskell
• Spineless tagless G-machine (STG)
  • about / Interpreting GHC's internal representations, Spineless tagless G-machine
• Spineless Tagless G-machine (STG) / Using GHC like a pro
• stable pointers
  • about / Data marshal and stable pointers
• stack manual
  • reference / Using the stack tool
• stack tool
  • using / Using the stack tool
• state
  • adding, to signal functions / Adding state to signal functions
• static addresses
  • importing / Importing static functions and addresses
• static functions
  • importing / Importing static functions and addresses
• statistics library / Mathematics, statistics, and science
• stm-lifted library / Working with monads and transformers
• store library / Binary serialization of Haskell values
• strategies
  • about / The Eval monad and strategies
  • working / The Eval monad and strategies
  • composing / Composing strategies
• stream fusion
  • about / Inlining and stream fusion
  / Using the text library
• streaming
  • about / Streaming with side-effects
• streaming, with conduits
  • about / Streaming using conduits
  • resources, handling / Handling resources and exceptions in conduits
  • exceptions, handling / Handling resources and exceptions in conduits
  • conduits, resuming / Resuming conduits
• streaming, with io-streams
  • about / Simple streaming using io-streams
  • input streams, creating / Creating input streams
  • combinators, using / Using combinators and output streams
  • output streams, using / Using combinators and output streams
  • exceptions, handling / Handling exceptions and resources in streams
  • resources, handling / Handling exceptions and resources in streams
• streaming, with pipes
  • about / Streaming using pipes
  • pipes, composing / Composing and executing pipes
  • pipes, executing / Composing and executing pipes
  • for-loops / For loops and category theory in pipes
  • category theory / For loops and category theory in pipes
  • exceptions, handling / Handling exceptions in pipes
• streaming library
  • selecting / Choosing a streaming library
• stream monad / The list monad and its transformer
• StrictData
  • about / Strict-by-default Haskell
• strictness
  • annotating / Annotating strictness and unpacking datatype fields
• strings
  • text library, using / Using the text library
• subtle evaluation
  • with pseq / Subtle evaluation – pseq
• sum-type encoding / Encoding to and from other formats
• supplementary HTTP libraries
  • jsonJSON-rpc / Supplementary HTTP libraries
  • websocketsWebsockets / Supplementary HTTP libraries
  • wai-websockets / Supplementary HTTP libraries
  • Rest REST / Supplementary HTTP libraries
• switching
  • about / Switching and discrete-time events
• synchronous errors
  • handling / Handling synchronous errors
• szipWith
  • about / Cursored and partitioned arrays

T

• tabular data, handling
  • about / Handling tabular data
  • vector package, using / Using the vector package
• Tagsoup / Parsing XML
• Tasty
  • about / Test frameworks
  • reference / Test frameworks
• TCP/IP client
  • acting as / Acting as a TCP/IP client
• TCP server
  • acting as / Acting as a TCP server (Unix domain sockets)
• Template Haskell
  • used, for deriving setters / Deriving setters with Template Haskell
• test frameworks
  • about / Test frameworks
  • Hspec / Test frameworks
  • RSpec / Test frameworks
• tests
  • writing, for Haskell / Writing tests for Haskell
• test suites / Test suites and benchmarks
• text-format library / Pretty-printing and text formatting
• text formatting / Pretty-printing and text formatting
• text library / Representing data
• textual I/O
  • about / Textual I/O
• threads
  • about / Threads and concurrency primitives
  • and mutable references / Threads and mutable references
  • thunk accumulation, avoiding / Avoid accumulating thunks
  • atomic operations, performing with IORefs / Atomic operations with IORefs
• ThreadScope
  • about / Diagnosing parallelism – ThreadScope
  / Linking and building shared libraries, Tracing using eventlog
• Thread State Objects (TSOs) / Scheduler and green threads
• time
  • profiling / Profiling time and allocations
  • working with / Working with time
• timed log messages / Timed log messages
• tools, for research and sketching
  • ihaskell / Tools for research and sketching
  • HaTeX / Tools for research and sketching
  • H (HaskellR) / Tools for research and sketching
• tracing
  • eventlog, using / Tracing using eventlog
• transformers
  • working with / Working with monads and transformers
• Trivia, at term-level
  • about / Trivia at term-level
  • coding, in GHC PrimOps / Coding in GHC PrimOps
  • control inlining / Control inlining
• Trivia, at type-level
  • about / Trivia at type-level
  • phantom types / Phantom types
  • functional dependencies / Functional dependencies
  • associated types / Type families and associated types
  • type families / Type families and associated types
• turtle library / Scripting and CLI applications
• Turtle library / Scripting and CLI applications
• TypeFamilies / Useful GHC extensions
• types
  • converting between / Easily converting between types (convertible)

U

• UnboxedTuples extension / Coding in GHC PrimOps
• unboxing
  • about / Unbox with UNPACK
  • anonymous tuples, using / Using anonymous tuples
• unexpected crashes
  • debugging, with profiler / Debugging unexpected crashes with profiler
• Unicode-correct / Working with characters and strings
• unit testing
  • with HUnit / Unit testing with HUnit
• unordered-containers library / Representing data
• UNPACK
  • used, for unboxing / Unbox with UNPACK

V

• vector library / Representing data
• ViewPatterns
  • about / Extensions for patterns and guards

W

• wai-websockets library / Supplementary HTTP libraries
• wai library / HTTP clients and servers
• warp HTTP server
  • about / Using WebSockets
• warp library / HTTP clients and servers
• Weak Head Normal Form / Benchmarking using the criterion library
• Weak Head Normal Form (WHNF) / Weak head normal form
• weak references / Indefinite blocking and weak references
• Weak ThreadId / Indefinite blocking and weak references
• Web Application Interface / HTTP clients and servers
• WebSocket applications
  • about / Using WebSockets
• WebSockets
  • using / Using WebSockets
• websocketsWebsockets library / Supplementary HTTP libraries
• web technologies
  • about / Web technologies
• web technologies, libraries
  • Yesod framework / Web technologies
  • Snap / Happstack / Web technologies
  • blaze-html / Web technologies
  • amazonka Amazonka/ AWS / Web technologies
• windowing function / Using the vector package
• wl-pprint package / Pretty-printing and text formatting
• worker/wrapper transformation
  • about / The worker/wrapper idiom
• wrappers / Function pointers and wrappers
• wreq library / HTTP clients and servers
• Writer / Working with monads and monad stacks

X

• XML
  • parsing / Parsing XML
• xml library / Encoding to and from other formats

Y

• yaml library / Encoding to and from other formats
• Yampa
  • about / Events and signal functions with Yampa
  • signal functions / Events and signal functions with Yampa
  • events / Events and signal functions with Yampa
  • integrating, to real world / Integrating to the real world
  / Functional Reactive Programming
• Yesod framework / Web technologies
• Yesod web framework / Persistent storage, SQL, and NoSQL

Z

• zippers
  • using / Using zippers
  • both ends, accessing with Seq / Accessing both ends fast with Seq