book

Learn You a Haskell for Great Good!

by Miran Lipovaca

April 2011

Beginner

400 pages

12h 45m

English

No Starch Press

Read now

Unlock full access

So, What’s Haskell?What You Need to Dive InAcknowledgments
Calling FunctionsBaby’s First FunctionsAn Intro to ListsConcatenationAccessing List ElementsLists Inside ListsComparing ListsMore List OperationsTexas RangesI’m a List ComprehensionTuplesUsing TuplesUsing PairsFinding the Right Triangle
Explicit Type DeclarationCommon Haskell TypesType VariablesType Classes 101The Eq Type ClassThe Ord Type ClassThe Show Type ClassThe Read Type ClassThe Enum Type ClassThe Bounded Type ClassThe Num Type ClassThe Floating Type ClassThe Integral Type ClassSome Final Notes on Type Classes
Pattern MatchingPattern Matching with TuplesPattern Matching with Lists and List ComprehensionsAs-patternsGuards, Guards!where?!where’s ScopePattern Matching with whereFunctions in where Blockslet It Belet in List Comprehensionslet in GHCicase Expressions
Maximum AwesomeA Few More Recursive FunctionsreplicatetakereverserepeatzipelemQuick, Sort!The AlgorithmThe CodeThinking Recursively
Curried FunctionsSectionsPrinting FunctionsSome Higher-Orderism Is in OrderImplementing zipWithImplementing flipThe Functional Programmer’s ToolboxThe map FunctionThe filter FunctionMore Examples of map and filterMapping Functions with Multiple ParametersLambdasI Fold You SoLeft Folds with foldlRight Folds with foldrThe foldl and foldr1 FunctionsSome Fold ExamplesAnother Way to Look at FoldsFolding Infinite ListsScansFunction Application with $Function CompositionFunction Composition with Multiple ParametersPoint-Free Style
Importing ModulesSolving Problems with Module FunctionsCounting WordsNeedle in the HaystackCaesar Cipher SaladOn Strict Left FoldsLet’s Find Some Cool NumbersMapping Keys to ValuesAlmost As Good: Association ListsEnter Data.MapMaking Our Own ModulesA Geometry ModuleHierarchical Modules
Defining a New Data TypeShaping UpImproving Shape with the Point Data TypeExporting Our Shapes in a ModuleRecord SyntaxType ParametersShould We Parameterize Our Car?Vector von DoomDerived InstancesEquating PeopleShow Me How to ReadOrder in the Court!Any Day of the WeekType SynonymsMaking Our Phonebook PrettierParameterizing Type SynonymsGo Left, Then RightRecursive Data StructuresImproving Our ListLet’s Plant a TreeType Classes 102Inside the Eq Type ClassA Traffic Light Data TypeSubclassingParameterized Types As Instances of Type ClassesA Yes-No Type ClassThe Functor Type ClassMaybe As a FunctorTrees Are Functors, TooEither a As a FunctorKinds and Some Type-Foo
Separating the Pure from the ImpureHello, World!Gluing I/O Actions TogetherUsing let Inside I/O ActionsPutting It in ReverseSome Useful I/O FunctionsputStrputCharprintwhensequencemapMforeverforMI/O Action Review

Files and StreamsInput RedirectionGetting Strings from Input StreamsTransforming InputReading and Writing FilesUsing the withFile FunctionIt’s Bracket TimeGrab the Handles!To-Do ListsDeleting ItemsCleaning UpCommand-Line ArgumentsMore Fun with To-Do ListsA Multitasking Task ListDealing with Bad InputRandomnessTossing a CoinMore Random FunctionsRandomness and I/OBytestringsStrict and Lazy BytestringsCopying Files with Bytestrings
Reverse Polish Notation CalculatorCalculating RPN ExpressionsWriting an RPN FunctionAdding More OperatorsHeathrow to LondonCalculating the Quickest PathRepresenting the Road System in HaskellWriting the Optimal Path FunctionGetting a Road System from the Input
Functors ReduxI/O Actions As FunctorsFunctions As FunctorsFunctor LawsLaw 1Law 2Breaking the LawUsing Applicative FunctorsSay Hello to ApplicativeMaybe the Applicative FunctorThe Applicative StyleListsIO Is An Applicative Functor, TooFunctions As ApplicativesZip ListsApplicative LawsUseful Functions for Applicatives
Wrapping an Existing Type into a New TypeUsing newtype to Make Type Class InstancesOn newtype Lazinesstype vs. newtype vs. dataAbout Those MonoidsThe Monoid Type ClassThe Monoid LawsMeet Some MonoidsLists Are MonoidsProduct and SumAny and AllThe Ordering MonoidMaybe the MonoidFolding with Monoids
Upgrading Our Applicative FunctorsGetting Your Feet Wet with MaybeThe Monad Type ClassWalk the LineCode, Code, CodeI’ll Fly AwayBanana on a Wiredo NotationDo As I DoPierre ReturnsPattern Matching and FailureThe List Monaddo Notation and List ComprehensionsMonadPlus and the guard FunctionA Knight’s QuestMonad LawsLeft IdentityRight IdentityAssociativity
Writer? I Hardly Knew Her!Monoids to the RescueThe Writer TypeUsing do Notation with WriterAdding Logging to ProgramsInefficient List ConstructionUsing Difference ListsComparing PerformanceReader? Ugh, Not This Joke AgainFunctions As MonadsThe Reader MonadTasteful Stateful ComputationsStateful ComputationsStacks and StonesThe State MonadGetting and Setting StateRandomness and the State MonadError Error on the WallSome Useful Monadic FunctionsliftM and FriendsThe join FunctionfilterMfoldMMaking a Safe RPN CalculatorComposing Monadic FunctionsMaking Monads
Taking a WalkA Trail of BreadcrumbsGoing Back UpManipulating Trees Under FocusGoing Straight to the Top, Where the Air Is Fresh and Clean!Focusing on ListsA Very Simple FilesystemMaking a Zipper for Our FilesystemManipulating a FilesystemWatch Your StepThanks for Reading!

Content preview from Learn You a Haskell for Great Good!

Chapter 3. Syntax in Functions

In this chapter, we’ll take a look at the syntax that enables you to write Haskell functions in a readable and sensible manner. We’ll look at how to quickly deconstruct values, avoid big if else chains, and store the results of intermediate computations so that you can reuse them multiple times.

Pattern Matching

Pattern matching is used to specify patterns to which some data should conform and to deconstruct the data according to those patterns.

When defining functions in Haskell, you can create separate function bodies for different patterns. This leads to simple, readable code. You can pattern match on pretty much any ...