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
- 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 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
- 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 / 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
- 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
- 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
- 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
- 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
- domain specific language (DSL)
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
- 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
- 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
- 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
- network-uri library / Networking and HTTP
- networking
- about / Sockets and networking
- above transport layer / Networking above the transport layer
- 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
- PatternSynonyms
- 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
- 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
- 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
- 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
- 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
- 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)
- 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
- 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
- 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 / 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
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
- 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