liveBookmanning.com

What you will learn in Learn Haskell by Example

by Philipp Hagenlocher

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• parserA parser is a program or component that analyzes input according to an expected structure, validates it, and produces a structured result.
• (:>)(:>) is a Servant type operator that combines route or request information into the description of one API operation.
• IOAn IO action is a Haskell computation that describes interaction with the external world and may produce input/output effects.
• HaskellHaskell is a statically typed, purely functional programming language with non-strict evaluation and strong support for abstraction.
• QuickCheckQuickCheck is a Haskell library for property-based testing that generates test data and checks properties across many inputs.
• functorFunctor is the Haskell type class for types whose parameterized values support structure-preserving mapping over their contents.
• PNMA PNM file is an image file encoded using a format in the Portable AnyMap family.
• side effectA side effect is an observable interaction or state change performed by a computation beyond producing its return value.
• applicative functorApplicative is a Haskell type class for applying functions in a computational context to values in that context and sequencing the resulting computations.
• type classA type class defines a set of operations and laws that types can implement to support ad hoc polymorphism.
• magic numberA magic number is a distinctive value in a file header that identifies the file format and sometimes its encoding variant.
• TextData.Text is the Haskell library module providing the Text type and operations for processing packed Unicode text.
• maybe functionThe maybe function eliminates a Maybe value by returning a default for Nothing or applying a handler to the contained value.
• audioAudio data is digital information representing sound through sampled signal values and associated recording parameters.
• fmapfmap is the standard Haskell function that applies a function to the contents of a value in a Functor while preserving the surrounding structure.
• ServantServant is a Haskell library ecosystem for defining type-safe web APIs and generating server and client implementations from API descriptions.
• do notationDo notation, or a do block, is Haskell syntax for sequencing monadic computations and binding their intermediate results.
• frequencyFrequency is the rate at which a periodic signal repeats, measured here in hertz and corresponding to perceived musical pitch.
• graphA graph is a data structure consisting of nodes and edges that represent entities and relationships between them.
• liftIOliftIO embeds an IO action into a monadic context that supports the MonadIO interface.
• monadA monad is an abstraction that sequences computations while encapsulating a computational context.
• moduleA Haskell module is a source-code unit that groups related definitions and controls their visibility through imports and exports.
• MapAn associative list is a list of key-value pair elements that represents mappings between values.
• EitherEither is a parameterized Haskell type representing a value with one of two alternatives, conventionally an error value or a successful result.
• functional, stateless philosophyFunctional programming is a programming paradigm that treats computation primarily as the evaluation of functions and the transformation of values.
• algebraic lawProperty is the QuickCheck type representing a testable property, including properties augmented with conditions or classifications.
• stringA string is an ordered sequence of characters represented as a value in a programming language.
• pattern matchingPattern matching is a language mechanism that selects computation branches by comparing values against structural patterns.
• sampling rateSample rate is the number of audio samples represented or processed per second.
• bitmap imageA bitmap is an image representation whose pixels have two possible values, typically corresponding to on and off.
• mapmap is a standard Haskell function that applies a function independently to every element of a list and returns the resulting list.
• functionA function is a program construct that computes a result from supplied inputs according to its definition.
• property-based testingProperty testing checks whether program behavior satisfies general properties across automatically generated or varied inputs.
• headerA header is the initial structured portion of an image file that identifies its format and describes basic image properties.
• CsvCsv is a book-specific data type representing a CSV table with an optional header and columns of cell values.
• (^) operatorThe (^) operator performs exponentiation with an integral exponent and does not allow negative exponents.
• pixelA pixel is an individual picture element whose value represents visual information at a position in a digital image.
• command-line argumentA command-line argument is a value supplied to a program when it is launched from a command-line interface.
• AttoparsecAttoparsec is a Haskell parser-combinator library optimized for efficient parsing of text and binary input.
• ByteStringByteString is a Haskell byte-sequence type provided in strict and lazy variants.
• recordA record is a structured value whose fields are identified by names and for which field-access functions can be generated automatically.
• return-type polymorphismReturn-type polymorphism is polymorphism in which the caller's expected result type determines the concrete return type of an expression or function application.
• listA list is an ordered sequence data structure whose elements can be processed recursively from its first element and remaining tail.
• arbitrary instanceArbitrary is the QuickCheck type class whose instances specify how to generate and shrink values of a type for property testing.
• purepure injects a value into an Applicative context without consuming input or otherwise adding an operation-specific effect.
• portable graymap formatA graymap is a PNM image format in which each pixel is represented by a single grayscale sample.
• samplesample is a QuickCheck operation that displays generated values across a range of generator sizes.
• declarative programmingDeclarative programming is a programming paradigm that specifies what results or relationships are desired rather than prescribing an explicit sequence of operations.
• validationValidation is the process of checking data against specified conditions to determine whether it is acceptable or well-formed.
• EvalThe Eval monad is the computation context provided by Haskell's parallel evaluation support for composing controlled evaluations.
• rparrpar is a Haskell parallel-evaluation combinator that sparks evaluation of an argument while returning an Eval computation.
• strategy typeA Strategy is a type synonym for a function that specifies how a value should be evaluated through the Eval monad.
• partial applicationPartial function application is the evaluation of a function with fewer arguments than its full arity, producing a function that accepts the remaining arguments.
• contractAn application programming interface is a defined set of operations and data representations through which software components interact.
• digital imageAn image file is a digital file containing encoded visual data such as pixels or vector descriptions.
• optparse-applicativeoptparse-applicative is a Haskell library for declaratively defining and parsing command-line options and arguments.
• domain-specific languageA domain-specific language is a programming language specialized for a particular application domain or problem class.
• genericsA function that can operate with values of more than one type through generalized type behavior.
• :type:type is a GHCi command that displays the inferred type of an expression or name.
• edgeAn edge is a graph relationship that connects one node to another, optionally with a specified direction.
• abstractionA programming abstraction is a simplified interface or representation that hides implementation details while exposing useful behavior.
• qualified importA qualified import is an import declaration that requires definitions from a module to be referenced through that module's name or an alias.
• MonoidMonoid is a Haskell type class extending Semigroup with a neutral element and operations for combining collections of values.
• SemigroupSemigroup is a Haskell type class for types with an associative binary combination operation.
• pseudo-random number generatorA random value generator is a computation that produces random or pseudo-random values, often with controlled variation in size or complexity.
• derivingA deriving strategy is Haskell syntax that selects how type-class instances are automatically generated for a type.
• propertyTestpropertyTest is a book-defined testing function that evaluates a Boolean predicate against generated random inputs.
• type expressionA type expression is syntactic notation that describes the type of a value or expression, including the element type of a list or the component types of a tuple.
• sequenceSequence is a book-defined composition structure that represents musical elements arranged in succession.
• recursionRecursion is a technique in which a computation is defined in terms of applications of itself to smaller or simpler inputs.
• ToJSONToJSON is the aeson type class whose instances define how Haskell values are converted to JSON values.
• Word8Word8 is Haskell's unsigned 8-bit integer type, representing values from 0 through 255.
• mapMmapM is a standard Haskell function that applies an action-producing function to each element of a list, sequences the resulting actions, and collects their results in a list.
• file synchronizationFile synchronization is the process of copying or reconciling files between a source location and a destination location so that their contents correspond.
• bindbind is the Monad operation that applies a function to the value produced by a monadic computation and returns the resulting monadic computation.
• nodeA node is an entity represented as a vertex in a graph and connected to zero or more other nodes.
• GHCiGHCi is the interactive interpreter and read-evaluate-print environment for Haskell provided with the Glasgow Haskell Compiler.
• pixmapA pixmap is an image representation whose pixels are encoded using multiple color or channel values.
• forallforAll is a QuickCheck combinator that attaches an explicitly supplied generator to a property test.
• NaturalNatural is an arbitrary-precision nonnegative integer type in Haskell.
• type inferenceType inference is the automatic determination of expression and variable types from their usage and surrounding context.
• invariantAn invariant is a property that must remain true for every valid state of a data structure or computation.
• Control.Parallel.StrategiesControl.Parallel.Strategies is a Haskell module that provides combinators for expressing parallel evaluation strategies.
• sparkA spark is a runtime request for a Haskell computation to be evaluated speculatively in parallel.
• spark poolA spark pool is the runtime-managed collection of pending sparks awaiting available parallel execution capacity.
• randomrandom is a Haskell function that generates a value and an updated random generator for a type with a Random instance.
• FromJSONFromJSON is an aeson type class whose instances define how JSON values are parsed into Haskell values.
• pure functionA pure function is a function whose result depends only on its inputs and that produces no observable side effects.
• ApplicationApplication is the WAI web-application interface representing a function that handles an HTTP request and produces a response.
• HandleHandle is a Haskell runtime-managed value representing an open connection to a file or stream together with its access, position, and buffering properties.
• type-class instanceA type-class instance is a declaration that supplies an implementation of a type class's operations for a particular type.
• operator precedenceOperator precedence is the ranking that determines which operators bind and are evaluated before others in an expression.
• generalized algebraic data typeA generalized algebraic data type allows data constructors to specify more precise type information than ordinary algebraic data types.
• JuicyPixelsJuicyPixels is a Haskell library for decoding, encoding, and manipulating common raster image formats.
• ladder graphA ladder graph in a word-ladder problem is a graph whose vertices are valid words and whose edges represent permitted word transformations.
• ServerErrorServerError is a Servant error type describing an HTTP failure response, including its status, headers, body, and reason phrase.
• directed graphA directed graph is a graph whose edges have orientations that constrain traversal to one direction.
• generatorA generator is a list-comprehension clause that supplies values from a list or other sequence for subsequent comprehension clauses.
• higher-order functionA higher-order function is a function that receives one or more functions as arguments or returns a function as its result.
• pitchPitch is the perceptual property of a musical sound associated with its perceived highness or lowness and position in the system of musical tones.
• type constraintConstraint is the Haskell kind-level type representing a type-class constraint.
• predecessor graphA predecessor graph is a graph in which each node records at most one predecessor, allowing a route to be reconstructed by following predecessor links.
• DynamicImageDynamicImage is the JuicyPixels image type that represents images while retaining their pixel depth and color model at runtime.
• musical noteA musical note is a discrete sound event with a defined pitch or rest identity and duration in musical notation.
• permutation mapA permutation map is a mapping from a sorted word representation to the permutations of that word found in a word list.
• Caesar cipherA Caesar cipher is a substitution cipher that replaces each letter with another letter a fixed distance away in an ordered alphabet.
• exceptionAn exception type is a Haskell type with an instance of the Exception type class whose values represent abnormal computational conditions.
• pathA path is an ordered sequence of connected elements linking one element or state to another.
• AudioAudio is an HCodecs record type containing audio sample data, sample-rate information, and channel information.
• duty cycleA duty cycle is the fraction of each period during which a pulse signal remains in its high or low state.
• exportFileexportFile is an HCodecs function that writes audio data to a WAV file.
• HCodecsHCodecs is a Haskell library for reading, encoding, and writing audio codec formats including WAV files.
• pulse waveA pulse wave is a periodic waveform that alternates between low and high levels for configurable portions of each period.
• SampleDataSampleData is an HCodecs representation of audio samples backed internally by arrays.
• sawtooth waveA sawtooth wave is a periodic waveform formed by a linear slope followed by a discontinuous reset.
• sinusoidal functionA sine wave is a periodic waveform whose value follows the mathematical sine function.
• square waveA square wave is a periodic waveform that switches between two constant levels.
• timbreTimbre is the qualitative character of a sound that distinguishes sounds with similar pitch and loudness.
• triangle waveA triangle wave is a periodic waveform formed by two opposing linear slopes.
• WAVThe WAV file format is a standard container format for storing digital audio data, commonly with uncompressed PCM samples.
• waveformA waveform is the shape of a signal as it varies over time, especially the periodic shape used to define a tone.
• counterexampleA counterexample is an input that causes a tested property to fail, demonstrating that the property does not hold universally.
• shrinkingShrinking is the technique of systematically reducing a failing test input and rechecking it to find a smaller counterexample.
• HTTP GETGET is the HTTP method for requesting a representation of a resource without intending to modify it.
• benchmarkBenchmarking is the systematic measurement of program performance under specified conditions.
• evalListevalList is a strategy combinator that applies an element strategy to the elements of a list.
• evalTraversableevalTraversable is a strategy combinator that applies an element strategy across a Traversable structure.
• haskell execution contextA Haskell execution context is a runtime execution context that evaluates sparks, typically on an operating-system thread.
• parallel packageThe parallel package is a Haskell library providing parallel evaluation primitives and evaluation strategies.
• parListChunkparListChunk is a parallel strategy combinator that evaluates list elements in chunks of a specified size.
• rseqrseq is an evaluation strategy that evaluates a value to weak head normal form sequentially.
• spark overflowSpark overflow is the condition in which a full spark pool discards newly created sparks.
• work stealingWork stealing is a scheduling technique in which an idle execution worker takes available work from a shared pool.
• Charchar is an Attoparsec parser that consumes a specified character and returns that character.
• referential transparencyReferential transparency is the property that an expression can be replaced by the value it evaluates to without changing program behavior.
• vectorvector is a QuickCheck generator combinator that produces a list of a specified length using the element type's Arbitrary instance.
• performanceA performance is a book-specific representation of musical events that can be transformed into a generated sound signal.
• monad transformerA monad transformer is a type constructor that augments an underlying monad with additional computational effects while preserving monadic composition.
• parallelismParallelism is the simultaneous execution of independent computations to reduce elapsed computation time.
• let keywordA let binding is a local Haskell definition that associates an identifier with an expression or function definition.
• comprehensionA list comprehension is a Haskell expression that constructs a list by evaluating an element expression over values generated and conditionally selected by its clauses.
• existential typeAn existentially quantified type packages a value whose concrete type is hidden while exposing only operations guaranteed by specified constraints.
• servant serverA Servant Server is a collection of endpoint handlers implementing the complete specification of an API.
• logAn event log is an ordered record of events produced during computation.
• ProxyData.Proxy is the Haskell library module that provides the Proxy type for carrying type information without a corresponding runtime value.
• lazy evaluationLazy evaluation delays evaluating an expression until its value is required.
• enumAn enumeration type is an algebraic data type whose constructors are all nullary and whose values form a finite enumerable set.
• read-execute-print loopAn execution mode in which program expressions or commands are entered and evaluated incrementally.
• StdGenStdGen is a Haskell generator-state type representing the state of a pseudo-random number generator.
• type aliasA type synonym gives an existing type an alternate name without creating a distinct representation or type identity.
• GenGen is a QuickCheck type representing a computation that generates randomized values of a specified type.
• clippingAudio clipping is distortion caused when a signal exceeds the allowed or representable amplitude range and is truncated.
• EqEq is a Haskell type class defining equality and inequality operations for values that can be compared.
• binary dataBinary encoding represents data using sequences of bits and bytes rather than textual character representations.
• testBittestBit is a Haskell bit operation that reports whether a value has a one at a specified bit offset.
• Data.BitsThe Bits type class defines bitwise operations for Haskell types that support bit-level representation.
• eventAn event is a timed musical occurrence representing either a tone with a frequency or a period of silence.
• aesonaeson is a Haskell library for encoding and decoding JSON data.
• StateTStateT is a Haskell monad transformer that threads and updates state through computations in an underlying monad.
• WriterTWriterT is a Haskell monad transformer that accumulates output alongside the result of computations in an underlying monad.
• middlewareMiddleware is a function or component that wraps a web application to inspect or transform requests and responses before delegating to the wrapped application.
• note lengthA note length is the duration value assigned to a musical note, such as whole or half.
• FailFail is an Attoparsec Result constructor representing a failed parse together with remaining input and error information.
• preconditionA precondition is a condition that causes generated test cases failing the condition to be discarded before the property is evaluated.
• transpositiontranspose is a list operation that exchanges the row-and-column orientation of a rectangular collection.
• numbered lineA numbered line is a line of text represented together with its associated line-numbering information.
• rational numberRational is a Haskell numeric type representing ratios of integers.
• profilingProfiling is the measurement and analysis of a program's runtime behavior and resource consumption to identify performance characteristics and bottlenecks.
• command-line interfaceA command-line interface is a text-based interface in which users interact with programs by entering commands.
• decodedecode is an aeson function that parses a lazy ByteString as JSON and decodes it into a value with a FromJSON instance.
• encodeencode is an aeson function that serializes a value with a ToJSON instance into JSON represented as a ByteString.
• JSON valueValue is aeson's Haskell data type representing any possible JSON value.
• import/export syntaxA module export is a definition made visible to code that imports the module containing it.
• language extensionA language extension is an optional compiler-supported addition that expands a programming language's syntax, semantics, or available features.
• field selectorA field selector is a function generated from a record field declaration that retrieves that field's value from a record.
• guardA guard is a conditional expression attached to a function or pattern definition that selects a case when its Boolean condition holds.
• curryingcurry is a Haskell function that converts a function taking a pair into a function taking two arguments.
• headerA CSV header is an optional first line whose fields provide titles for the columns of a CSV file.
• algebraic data typeAn algebraic data type is a user-defined type formed from one or more named constructors, potentially carrying fields.
• MonadFailControl.Monad.Fail is a Haskell library module defining the MonadFail type class and related functionality.
• purely functional languageA pure functional programming language is a language in which computations are primarily expressed through functions without observable side effects.
• ShowThe Show type class is a Haskell type class whose instances provide textual representations of values.
• readMaybereadMaybe is a Haskell function that parses a String into a value of a Read instance and returns Nothing when parsing fails.
• alternativeAlternative is a Haskell type class for applicative computations that support an identity failure value and an associative choice operation.
• database connectionA database connection is an object representing an active communication channel to a database.
• GeneralizedNewtypeDerivingGeneralizedNewtypeDeriving is a Haskell language extension that derives instances for a newtype from instances of its underlying type.
• modifymodify is a StateT operation that transforms the current state with a supplied function.
• putput is a StateT operation that replaces the current state with a supplied value.
• telltell is a WriterT operation that adds a value to the accumulated output.
• takeWhiletakeWhile is an Attoparsec parser combinator that consumes consecutive input characters satisfying a predicate.
• wildcardA wildcard pattern is a pattern that matches any input without binding that input to an identifier.
• quickCheckAllquickCheckAll is a QuickCheck function that discovers properties in a module by naming convention and checks them automatically.
• heterogeneous data structureA heterogeneous list is a list whose elements have different concrete types while sharing a common existential interface.
• fieldfield is a sqlite-simple function that creates a RowParser for a value whose type has a FromField instance.
• function typeA function type specifies the input and output types of a function value.
• type operatorTypeOperators is a GHC language extension that permits operators in type-level syntax and declarations.
• eta reductionAn eta reduction is a transformation that removes a redundant parameter and its immediate application from a function definition.
• breadth-first searchBreadth-first search explores a graph level by level from a starting node, visiting all nodes at one distance before proceeding to the next.
• read-only environmentA read-only environment is shared contextual data that computations can inspect or access without modifying.
• FromRowFromRow is a sqlite-simple type class whose instances define parsing of SQL row data into Haskell values.
• ToRowToRow is a sqlite-simple type class for converting Haskell values into parameters that can be bound to SQL statements.
• list constructorA list constructor is a Haskell constructor that builds a list either as the empty list or by prepending an element to an existing list.
• parser combinator libraryparser-combinators is a Haskell library providing reusable parser combinator functions.
• import statementAn import declaration is a Haskell declaration that makes definitions from another module available in the importing module.
• evaluation suiteA test suite is a collection of automated tests executed together to evaluate a program or component.
• ParserInfoParserInfo is the optparse-applicative type that packages a parser together with metadata for executing it and generating help text.
• chromatic note nameA chromatic note name identifies one of the twelve semitone-spaced note names within an octave.
• concert AConcert A is the musical reference pitch conventionally assigned a frequency of 440 Hz.
• semitoneSemitone is a book-specific Haskell type representing an integer distance from concert A in musical semitone intervals.
• octaveAn octave is a musical interval spanning a frequency ratio of two to one.
• conditional logicAn if-then-else expression is a conditional expression that evaluates one of two branches based on a Boolean condition and must produce a value.
• FractionalFractional is a Haskell type class for numeric types that support division and reciprocals.
• IntegralIntegral is a Haskell type class for whole-number types that support integer division, remainders, and related conversions.
• RealFracRealFrac is the Haskell type class for fractional real-number types that support conversion to integral values and decomposition into integral and fractional parts.
• right foldA right fold reduces a data structure by associating its accumulating function from the right.
• csv parsingCSV parsing is the technique of interpreting delimited text as records and fields according to CSV-format rules.
• delimiterA delimiter is a character or sequence that separates fields within records in a delimited text format.
• toneA tone is a sustained musical sound characterized by a particular frequency and waveform.
• associativityAn associative function is a binary operation whose grouping does not affect the result.
• StandaloneDerivingStandaloneDeriving is a GHC language extension that permits deriving clauses and type-class instances to be declared separately from data type declarations.
• envelopeAn envelope is a time-varying contour that shapes a characteristic of a synthesized sound, such as its amplitude.
• executeNamedexecuteNamed is a sqlite-simple function that executes an SQL statement using named parameters supplied from a Haskell value.
• stackstack is a build tool and project-management toolchain for Haskell projects.
• rangeRange syntax is Haskell list notation that denotes enumeration of values between specified bounds or from a starting value.
• SimpleCheckSimpleCheck is the book's simplified Haskell property-testing framework used to reimplement and experiment with QuickCheck functionality.
• System.RandomSystem.Random is a Haskell library module providing functions, types, and type classes for generating random values.
• System.Random.StatefulSystem.Random.Stateful is a Haskell library module providing stateful random-generation interfaces designed to support safer concurrent use.
• configurationA configuration is structured application data containing settings such as paths, file restrictions, and resource bounds.
• asumasum is a Haskell function that combines a foldable collection of alternative applicative computations using Alternative choice semantics.
• emptyempty is the Alternative operation that represents failure or the identity element for applicative choice.
• manymany is an Alternative operation that applies an applicative computation zero or more times and collects the successful results.
• somesome is an Alternative operation that applies an applicative computation one or more times and collects the successful results.
• maximumThe maximum sample value is the header-specified upper numeric limit for a pixel sample in a PNM graymap or pixmap.
• hClosehClose is a Haskell System.IO function that closes a Handle and completes pending buffered output.
• static typingStatic typing is a language property in which types are determined or checked before program execution and do not change dynamically during runtime.
• infinite data structureAn infinite list is a lazily generated list with no finite endpoint whose finite prefixes can be evaluated on demand.
• asynchronous exceptionAsyncException is a Haskell exception type whose constructors represent asynchronous runtime events such as stack overflow, thread termination, and user interruption.
• generategenerate is a QuickCheck function that runs a Gen to produce a random value within an IO action.
• generator sizeGenerator size is a QuickCheck parameter that controls size-related characteristics of generated values.
• getSizegetSize is a QuickCheck generator operation that retrieves the generator's current size parameter.
• parseJSONparseJSON is the FromJSON class method that converts a JSON value into a Haskell value or reports a parsing failure.
• resizeresize is a QuickCheck combinator that changes the size parameter used by a generator.
• constconst is a standard Haskell function that returns its first argument while ignoring its second argument.
• smart constructorA smart constructor is a constructor-like function that creates values while enforcing validity conditions or representation invariants.
• CaptureCapture is a Servant combinator that declares a typed variable segment captured from an endpoint route.
• endpointAn API endpoint is a network-accessible operation identified by a route and HTTP method at which an API accepts requests.
• HTTP methodAn HTTP verb is a standardized method token specifying the intended operation of an HTTP request.
• memptymempty is the Haskell Monoid value that acts as the neutral element for the monoidal operation.
• neutral elementA neutral element is a value that leaves another value unchanged when combined with an operation.
• PostCreatedPostCreated is a Servant response type representing a successful HTTP resource-creation response with status code 201.
• ReqBodyReqBody is a Servant combinator that specifies the type and media representation expected in an HTTP request body.
• routingA route is a URL path pattern that identifies an API operation and may contain variable segments.
• JustJust is the Maybe constructor that contains a value of a parameterized type.
• NothingNothing is the Maybe constructor representing the absence of a contained value.
• number roundinground is a Haskell function that converts a fractional value to the nearest integral value according to its rounding rules.
• Template HaskellTemplate Haskell is a GHC language extension for compile-time metaprogramming and manipulation of Haskell abstract syntax.
• applicative styleApplicative style is a functional programming style that combines independent computations using an applicative interface.
• frontierA frontier is the collection of graph nodes currently being explored or awaiting expansion in a search.
• compositionFunction composition is the construction of a function whose result is obtained by applying one function to the result of another.
• ReaderT monadReaderT is a Haskell monad transformer that adds access to a read-only environment to an underlying monad.
• foldableFoldable is a Haskell type class for data structures whose elements can be traversed and reduced by folding operations.
• first-class objectA first-class function is a function that can be treated as a value, including being passed, returned, named, stored, or composed.
• ExistentialQuantificationAn existentially quantified type variable is a type variable whose concrete type is hidden inside a packaged value.
• adjacency listAn adjacency map is a graph representation that maps each node to a list of nodes connected from it.
• polymorphic typeA polymorphic type is a type expression containing type variables so that one definition can apply to values of multiple concrete types.
• shortest pathA shortest path is a path between two graph nodes having minimal total length or cost.
• undirected graphAn undirected graph is a graph whose edges have no orientation and can be traversed in either direction.
• catchcatches is a Haskell exception-handling function that applies multiple exception handlers to a computation.
• DeriveAnyClassDeriveAnyClass is a GHC language extension that permits automatic derivation of type-class instances when their minimal definitions are empty.
• shrinkshrink is the QuickCheck type-class method that produces smaller candidate values to simplify a failing test case.
• testTesting is the process of evaluating software behavior to find defects or verify requirements.
• rot13ROT13 is a Caesar cipher that rotates letters by 13 positions in the basic Latin alphabet, making the same transformation serve as encryption and decryption.
• hash mapA hash map is a key-value data structure that uses a hash function to support fast average-case lookup, insertion, and deletion.
• stateProgram state is the collection of values and conditions describing a computation at a particular point during its execution.
• recursive definitionA recursive definition is a definition that refers directly or indirectly to itself.
• commentA comment is non-data text embedded in a file format and delimited according to that format's syntax.
• Data.Attoparsec.ByteString.Char8Data.Attoparsec.ByteString.Char8 is an Attoparsec module that provides character-oriented parsers for ASCII data stored in ByteString.
• decimaldecimal is an Attoparsec parser that reads a decimal integer value polymorphically over integral result types.
• satisfysatisfy is an Attoparsec parser combinator that accepts an input character when a supplied predicate succeeds.
• skipMany1skipMany1 is an Attoparsec combinator that applies a parser at least once and discards all parsed results.
• whitespace characterWhitespace is text consisting of spacing characters that separate or format other characters.
• lookup operationlookup is a standard Haskell function that searches an associative list for a key and returns its associated value when present.
• union typeA sum type is a data type whose value is one of several alternative constructors, with only one constructor choice present at a time.
• zipzip is a standard Haskell function that combines two lists element-wise into a list of pairs, stopping when the shorter list ends.
• zipWithzipWith is a standard Haskell function that combines corresponding elements of two lists using a supplied combining function, stopping when the shorter list ends.
• FloatingFloating is a Haskell type class for floating-point types that provide trigonometric, logarithmic, and related mathematical operations.
• Data.Text.IOData.Text.IO is the Haskell library module providing text-oriented file input and output operations.
• pretty printingPretty printing is the rendering of structured information in a human-readable textual format.
• lastInsertRowIdlastInsertRowId is a sqlite-simple function that returns the identifier assigned to the most recently inserted row on a connection.
• primary keyA primary key is a column or set of columns whose values uniquely identify rows in a database table.
• databaseA database is an organized system for storing, retrieving, and managing structured data.
• database transactionA database transaction is a sequence of operations treated as one atomic unit that can be committed or rolled back.
• withTransactionwithTransaction is a sqlite-simple function that runs an action within a database transaction and rolls it back if the action fails.
• newtype idiomnewtype is Haskell syntax for defining a distinct type with exactly one constructor containing exactly one field.
• askask retrieves the complete reader environment from a reader-like monadic computation.
• liftlift is a monad-transformer operation that embeds an action from an underlying monad into a transformed monad.
• MonadIOMonadIO is a Haskell type class for monads whose computations can execute IO actions.
• MonadTransMonadTrans is a Haskell type class for monad transformers that lift computations from an underlying monad.
• reader monadA Reader monad is a monadic computation that can read a shared environment without modifying it.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.