book

Soar with Haskell

by Tom Schrijvers

December 2023

Intermediate to advanced

418 pages

9h 25m

English

Packt Publishing

Read now

Unlock full access

About the author
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Technical requirementsWhat is FP?Programming with functionsBrief history of FPHaskellOther contemporary FP languagesProminent application areasWriting basic functionsOur first functionA two-parameter functionCustom operatorsProgramming with primitive typesInt and IntegerFloat and DoubleBooleansChar and StringConverting between primitive typesPutting the type checker to workChecking function callsChecking function definitionsDisambiguating overloaded functionsInferring typesCombining functionsCalling functions from within functionsNaming intermediate resultsLocal function definitionsSummaryQuestionsFurther readingAnswers
EnumerationsA game of rock-paper-scissorsDon’t-care patternsBooleans revisitedRecordsPeopleNamed fieldsNested recordsFull-blown algebraic datatypesShapesCardsShowing cardsParametric polymorphismThe identity functionThe constant functionParametric ADTsTuplesType synonymsMaybeEitherThe unit typeSummaryQuestionsAnswers
Standard librariesListsList syntaxList syntax desugaredPredefined list functionsList comprehensionsStrings revisitedCustom list processingRecursive datatypesArithmetic expressionsParametric recursive datatypesStructural recursionStructural recursion on listsStructural recursion on other algebraic datatypesVariants on structural recursionPrimitive recursionRecursion on integersAdditional parametersVarying parameters and the worker/wrapper structureAccumulationRecursion on nested datatypesMutual recursionSimultaneous recursion on multiple structuresCombining variationsNon-structural recursionNon-terminationUnbounded searchSummaryQuestionsAnswers
Abstracting over functionsDropping a prefixSorting in ascending and descending orderAn abstraction for structural recursionFolding listsFolds for other algebraic datatypesVariations on structural recursionCommon HOFsTaking instead of droppingMappingFilteringAny and allFolding from the leftScanning left and rightWriting compact code with HOFStandard deviationOdds and evensAll you can buySummaryQuestionsAnswers

Anonymous functionsAnonymous function syntaxAnonymous function useMulti-parameter anonymous functionsPattern matching without equationsCurrying and partial applicationOne parameter is enoughPartial applicationOperator sectionsFlipping function parametersEta reductionBasic eta reductionEta reduction with partial applicationEta reduction of two-parameter functionsIrreducible casesFunction compositionBasic function compositionPipelinesFunctions as data structuresEvaluation with many variablesAssociation listFunctional environmentsSummaryQuestionsAnswers
Ad hoc polymorphismWhat is ad hoc polymorphism?Type classesType class constraints are contagiousType class instancesType class instantiationDefault implementations and minimal complete definitionsInstances for composite valuesEquality of functionsRecursive instancesDeriving structural instancesSemantic equality instancesLawful instancesCommon type classesOrdShowReadBounded and EnumNumeric type classesLibrary uses of type classesList membership functionsThe Map libraryCustom type class exampleText boxesBox combinatorsBoxable thingsSummaryQuestionsFurther readingAnswers
Evaluation strategiesBeta reductionEvaluationEvaluation strategiesCall by ValueCall by NameCall by NeedSharingThunksBottomStructured dataProgramming with lazy evaluationStreamingInfinite listsCorecursive programsLazy memory leaksThe leaking accumulatorStrictness annotationsIncreased lazinessSummaryQuestionsAnswers
Technical requirementsHaskell versus I/O – a thought experimentLazy evaluation versus I/OPure functions versus I/OThe IO approachDescribing I/OPerforming I/OComposing I/OMixing I/O and control flowThe do notationImperative StyleCommon syntax errorsA more flexible layoutLibrary functions by exampleSumming numbersGuessing gameSummaryQuestionsFurther readingAnswers
Semigroups and monoidsSemigroupsMonoidsKinds and type constructorsProper typesType constructorsType constructor parametersFoldablesThe Foldable type classListable collectionsAggregation into a monoidDeriving the Foldable instanceStandard library instancesCase study – SortednessSorted listsAn attempt with structural recursionA richer approach with structural recursionThe Sortedness monoidSummaryQuestionsFurther readingAnswers
FunctorsThe functor lawsFunctor instancesApplicative functorsA family of zip functionsThe Applicative type classThe applicative lawApplicative functors and effectsFailing computations with MaybeErroneous computations with EitherImplicitly parameterized computations with functionsAnalyzing computations with the Const functorLogging computations with tuplesStateful computations with StateNondeterministic computations with listsNo effectCompositionsTraversablesThe Traversable classInstancesThe traversable lawsCase study – word countSummaryQuestionsFurther readingAnswers
Failing with MaybeState-passingThe monad type classMonads vs applicative functorsThe monad lawsThe do notationMore monadsThe Identity monadThe Error (aka Exception) monadThe Reader (aka environment) monadThe Writer monadThe list (aka nondeterminism) monadSummaryQuestionsAnswers
Combining monadic effectsLogging revisitedA custom monadChanged requirementsChanges to the custom monadMonad transformersThe Reader transformerThe MonadTrans type classThe Reader monad revisitedOther monad transformersThe StateT and WriterT transformersThe MaybeT and ExceptT transformersThe ListT transformerMonad subclassesThe MonadReader type classMore Monad subclassesMonad transformer gotchasEffect interactionMultiple copiesSummaryQuestionsFurther readingAnswers
A DSL for formattingOverviewData format exampleA DSL for financial contractsCompositional contractsZero-coupon bondsContract combinatorsInterpreting contractsImplementing DSLsRunning exampleDeep embeddingShallow embeddingThe best of both worldsSummaryQuestionsFurther readingAnswers
ParsingWhat is parsing?How to get a parserParser combinatorsA parser for sumsParsers under the hoodThe Parsec libraryDifferent types of parsersParsec particularsParsing challenges – expressions revisitedSummaryQuestionsFurther readingAnswers
Technical requirementsRecords and deep accessLenses and their compositionBasic lensesLens compositionChange of representationLens operatorsGenerating boilerplatePolymorphic lensesProgrammatic data accessVirtual fieldsSide effectsAdvanced lensesGetters and settersTraversalsPrismsSummaryQuestionsFurther readingAnswers
Unit testing versus property-based testingUnit testingProperty-based testingGeneratorsArbitraryGeneratorsCustom generatorsShrinkingShrinking in actionUser-defined shrinkingTest properties – a case studySystem under testPropertiesShrinkingSummaryQuestionsFurther readingAnswers
Other Books You May EnjoyPackt is searching for authors like youShare Your ThoughtsDownload a free PDF copy of this book

Overview

"Soar with Haskell" is a comprehensive guide for aspiring functional programmers, walking you from the basics to advanced topics of the Haskell language. By reading this book, you will not only learn to write efficient and idiomatic Haskell code, but also gain deep insights into the principles of functional programming. Suitable for all curious learners at a beginner or intermediate level.

What this Book will help me do

Write pure and higher-order functions in the idiomatic Haskell style.
Employ algebraic datatypes to model complex data structures.
Leverage Haskell's laziness and functional purity to achieve expressive software designs.
Master type classes, functors, monads, and other core functional abstractions.
Design and simulate domain-specific languages and gain expertise in property-based testing.

Author(s)

None Schrijvers, a renowned lecturer and researcher in functional programming, has dedicated years to the exploration of Haskell and its broader foundations. With a clear pedagogical approach, Schrijvers brings to life the practicality and elegance of Haskell, making challenging concepts accessible to all. His extensive teaching experience ensures precise yet approachable explanations designed for learners of all levels.

Who is it for?

This book is perfect for software developers interested in transitioning into or deepening their understanding of functional programming. Beginners with a basic grasp of programming will find clear and structured lessons, while experienced coders will appreciate the nuanced exploration of Haskell's advanced capabilities. Anyone aiming to harness the power of functional programming will find this book their ideal companion.