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 6. Modules

A Haskell module is essentially a file that defines some functions, types, and type classes. A Has-kell program is a collection of modules.

A module can have many functions and types defined inside it, and it exports some of them. This means that it makes them available for the outside world to see and use.

Having code split up into several modules has many advantages. If a module is generic enough, the functions it exports can be used in a multitude of different programs. If your own code is separated into self-contained modules that don’t rely on each other too much (we also say they are loosely coupled), you can reuse them later. ...