Beginning haskell

THÔNG TIN TÀI LIỆU

Thông tin cơ bản

Định dạng
Số trang	408
Dung lượng	4,82 MB

Nội dung

www.it-ebooks.info For your convenience Apress has placed some of the front matter material after the index Please use the Bookmarks and Contents at a Glance links to access them www.it-ebooks.info Contents at a Glance About the Author�� xvii About the Technical Reviewer�� xix Acknowledgments�� xxi Introduction�� xxiii ■■Part 1: First Steps�� ■■Chapter 1: Going Functional��3 ■■Chapter 2: Declaring the Data Model��15 ■■Chapter 3: Reusing Code Through Lists��47 ■■Chapter 4: Using Containers and Type Classes��77 ■■Chapter 5: Laziness and Infinite Structures��111 ■■Part 2: Data Mining�� 131 ■■Chapter 6: Knowing Your Clients Using Monads ��133 ■■Chapter 7: More Monads: Now for Recommendations��161 ■■Chapter 8: Working in Several Cores��187 ■■Part 3: Resource Handling�� 207 ■■Chapter 9: Dealing with Files: IO and Conduit��209 ■■Chapter 10: Building and Parsing Text��235 ■■Chapter 11: Safe Database Access��259 ■■Chapter 12: Web Applications��277 v www.it-ebooks.info ■ Contents at a Glance ■■Part 4: Domain Specific Languages�� 295 ■■Chapter 13: Strong Types for Describing Offers��297 ■■Chapter 14: Interpreting Offers with Attributes��331 ■■Part 5: Engineering the Store�� 353 ■■Chapter 15: Documenting, Testing, and Verifying��355 ■■Chapter 16: Architecting Your Application��373 ■■Appendix A: Looking Further��389 ■■Appendix B: Time Traveling with Haskell��391 Index��393 vi www.it-ebooks.info Introduction Functional programming is gathering momentum Mainstream languages such as Java and C# are adopting features from this paradigm; and languages such as Haskell, Scala, Clojure, or OCaml, which embody functional programming from the very beginning, are being used in industry Haskell is a noise-free, pure functional language with a long history, having a huge number of library contributors and an active community This makes Haskell a great tool for both learning and applying functional programming Why You Should Learn Functional Programming The rise in functional programming comes from two fronts Nowadays, most applications are heavily concurrent or need to be parallelized to perform better Think of any web server that needs to handle thousands of connections at the same time The way you express the intent of your code using Haskell makes it easier to move from a single-thread application to a multi-threaded one at a negligible cost Apart from becoming more concurrent, applications are becoming much larger You would like your development environment to help you catch bugs and ensure interoperation between all modules of your system Haskell has a very strong type system, which means that you can express a wide range of invariants in your code, which are checked at compile time Many of the bugs, which previously would be caught using tests, are now completely forbidden by the compiler Refactoring becomes easier, as you can ensure that changes in your code not affect those invariants Learning functional programming will put you in a much better position as a developer Functional thinking will continue permeating through mainstream programming in the near future You’ll be prepared to develop larger and faster applications that bring satisfaction to your customers Why You Should Read this Book This book focuses both on the ideas underlying and in the practicalities of Haskell programming The chapters show you how to apply functional programming concepts in real-world scenarios They also teach you about the tools and libraries that Haskell provides for each specific task Newcomers to functional programming will not be the only ones who will benefit from reading this book Developers of Scala, Clojure, Lisp, or ML will be also able to see what sets Haskell apart from other languages The book revolves around the project of building a web-based strorefront In each of the five parts the focus is on a subsystem of this store: representing clients and products in-memory, data mining (including parallelization and concurrency), persistent storage, discount and offers, and the general architecture of the application The topics have been carefully selected for you to get a glimpse of the whole Haskell ecosystem xxiii www.it-ebooks.info Part First Steps www.it-ebooks.info Chapter Going Functional Welcome to the world of Haskell Before going deeply into the language itself, we will look at what makes Haskell different from other languages, and which benefits come with those changes Haskell belongs to the family of functional languages, a broad set which includes ML, Lisp, Scala or Clojure If you have a background in imperative or object-oriented languages, such as C, C++, or Java, you will be introduced to the new ideas present in languages of this family If you already have experience with functional languages, you will see how other features in Haskell, such as lazy evaluation or type classes, gives this language a different taste to any other This book requires no previous experience about the functional paradigm However, some general knowledge about programming, such as the concept of loops and conditionals, and some minimal practice with the shell or console, is assumed After introducing Haskell, we will review the process of getting a ready and complete Haskell installation in your system, including the EclipseFP development environment that brings Haskell and Eclipse IDE together Finally, you will take your first steps with the language in the Glasgow Haskell Compiler (GHC) interpreter, a powerful tool that executes expressions in an interactive way Throuhout the book we will develop parts of a time machine web store: as with many things in life, the best way to learn Haskell is by writing Haskell programs! Why Haskell? If you are reading this book it means that you are interested in learning Haskell But what makes this language special? Its approach to programming can be summarized in five points: • Haskell belongs to the family of functional languages, • It embodies in its core the concept of purity, separating the code with side-effects from the rest of the application, • The evaluation model is based on laziness, • Types are statically checked by the compiler Also, Haskell features a type system which is much stronger and expressive than usual, • Its approach to polymorphism is based on parametricity (similar to generics in Java and C#) and type classes In the rest of this section you will understand what the terms in this list mean and their implications Also, you will get a broad view of the entire Haskell ecosystem: the compiler, the libraries, and the available tools in a typical distribution www.it-ebooks.info Chapter ■ Going Functional Why Pure Functional Programming? Functional programming is one of the styles or paradigms of programming A programming paradigm is a set of ideas and concepts shared by different programming languages For example, Pascal and C are part of the imperative paradigm, and Java and C++ mix the imperative paradigm with the object-oriented one The fundamental emphasis of functional programming is the empowerment of functions as first-class citizens This means that functions can be manipulated as any other data in a program Functions can be passed as argument to another function, returned as a result, or assigned to a variable This ability to treat functions as data allows a higher level of abstraction, and therefore more opportunities for reuse For example, consider the task of iterating through a data structure, performing some action over each element In an object-oriented language, the implementor of the structure would have surely followed the iterator pattern, and you as a consumer would write code similar to the following Java code: Iterator it = listOfThings.iterator(); while (it.hasNext()) { Element e = it.next(); action(e); // perform the action } As you can see, there is a lot of boilerplate code in the example In Haskell, you would use the map function, which takes as argument the action to perform on each element The corresponding code is: map listOfThings action The code now is much more concise, and the actual intention of the programmer is explicit from the use of the map function Furthermore, you prevent any possible issue related to a bad application of the the iterator pattern, because all the details have been abstracted in a function Actually, a function like map is very common in functional code, which gives us confidence that any bug in its implementation will be found quickly Performing the same task in Java requires, in the provider side, creating an interface for containing the function performing the operation Then, on the user side, you need to implement that interface through a class, or use an anonymous class This code will be much larger than the one-line version you have seen above In fact, new versions of Java, C++ or C# are embracing functional concepts and will allow writing code much more similar to the previous one In Haskell, a piece of code consists of expressions which are evaluated in a similar fashion to mathematical expressions On the other hand, in an imperative language, methods consist of statements that change a global state This is an important distinction, because in an imperative program the same piece of code may have different results depending on the initial state when it is executed It’s important to notice here that elements outside of the program control, known as side effects, like input and output, network communication or randomness are also part of this global state that may change between executions of the same function Expressions in Haskell cannot have side effects by default: we say that these expressions are pure A common misunderstanding about functional programming is that it disallows any kind of change to the outer state This is not true: side-effects are possible in Haskell, but the language forces the programmer to separate the pure, side-effect free, parts from the impure ones The main benefit of purity is the improved ability to reason about the code and an easier approach towards testing the code We can be sure that the outcome of a pure function only depends on its parameters and that every run with the same inputs will give the same result This property is called referential transparency, and it’s the ground for the application of formal verification techniques, as we will see briefly in Chapter and into detail in Chapter 15 Pure functions are easier to compose, as it is sure that no interference comes to life in their execution Actually, the evaluation of pure expressions is not dependent on the order in which it is done, so it opens the door to different execution strategies for the same piece of code This is taken advantage of by the Haskell libraries providing parallel and concurrent execution, and has been even used for scheduling code in a GPU in the Accelerate library www.it-ebooks.info Chapter ■ Going Functional By default, Haskell uses an execution strategy called lazy evaluation Under laziness, an expression is never evaluated until it is needed for the evaluation of a larger one Once it has been evaluated, the result is saved for further computation, or discarded if it’s not needed in any other running code This has a obvious benefit, because only the minimal amount of computation is performed during program execution, but also has drawbacks because all the suspended expressions that have not yet been evaluated must be saved in memory Laz evaluation is very powerful but can become tricky, as we will see in Chapter Why Strong Static Typing? Type systems come in various formats in almost all programming languages A type system is an abstraction that categorizes the values that could appear during execution, tagging them with a so-called type These types are normally used to restrict the possible set of actions that could be applied to a value For example, it may allow concatenating two strings, but forbid using the division operator between them This tagging can be checked, broadly speaking, at two times: at execution time (dynamic typing), which usually comes with languages with looser typing and which admits implicit conversions between things like integers and string; or at the moment of compilation (static typing), in which case programs must be validated to be completely well-typed in terms of the language rules before generating the target outputcode (usually machine code or byecode) and being allowed to run Haskell falls into this second category: all your programs will be typechecked before executed Within statically typed languages, some of them, like Java or C#, need to perform extra type checking at run-time In contrast, once a Haskell program has been compiled, no more type checks have to be done, so performance is vastly increased Haskell’s type system is very strong Strength here means the amount of invariants that can be caught at compile time, before an error materializes while the application is running This increases the confidence in code that is type checked, and it’s very common to hear in Haskell circles: “once it compiles, it works” This strong typing gives rise to a way of programming dubbed type-oriented programming Basically, the programmer knows the type of the function she is developing, and has a broad idea of the structure of the code Then, she “fills the holes” with those expressions from the surrounding environment that fit into it This approach has actually been formalized, and there is another language similar to Haskell, called Agda,1 which comes with an interactive programming environment which helps in filling the holes, and even does so automatically if only one option is available at one place By the end of the book we will move a bit from Haskell to Idris,2 a language with a similar syntax, which features dependent typing Dependent typing is an even stronger form of type checking, where you can actually express invariants such as “if I concatenate a list of n elements to a list with m elements, I get back a list with n+m element” or “I cannot get the first element of an empty list” Then, you will see how some of these techniques can be transferred as patterns into Haskell The last difference in Haskell with respect to typing comes from polymorphism The problem is two-fold First of all, we want to write functions on lists without caring about the type of the elements contained in them This is known as parametric polymorphism, and you will explore it in Chapter In other cases, we want to express the fact that some types allow some specific operations on their values For example, the idea of applying a function to all elements in a list, as you did before with map, can be generalized into the concept of having an operation that applies a function to all elements in some data structure, like a tree or a graph The solution here is called type classes, which group different types with a common interface We will look at it in Chapter 4, where we will also realize that this concept is a very high-level one, and allows expressing several abstract ideas (functors, monads) that gives an interesting flavor to Haskell code Agda website: http://wiki.portal.chalmers.se/agda Idris website: http://www.idris-lang.org/ www.it-ebooks.info Chapter ■ Going Functional The Haskell Ecosystem Until now we have only spoken about Haskell, the languge But the benefits of Haskell don’t come only from the language, but also from the large and growing set of tools and libraries that can be used with the language There are several compilers for Haskell available, which usually take the name of a city: GHC3 (from Glasgow), UHC4 (from Utrecht) and JHC5 are the maintained ones at the moment of writing Of those, GHC is usually taken as the standard, and it’s the one with the biggest number of features We will follow this path, and will work with GHC all throughout the book As any other popular programming language, Haskell has an on-line repository of libraries It is called Hackage and it’s available at http://hackage.haskell.org/ Hackage integrates seamlessly with Cabal, the building tool specific for Haskell projects In Hackage you can find libraries ranging from bioinformatics to game programming, window managers and much more Apart from GHC and Cabal, in the book we will look at some tools that aim to help the developer writing better code faster The first one will be the GHC profiler: we will learn about it in Chapter to detect space and time leaks We will also look at Hoogle and Haddock, which are used to browse and create documentation In the last part, in Chapter 14, we will use the UU Attribute Grammar System to help us building domain specific languages The History of Haskell Haskell is usually considered the successor of the Miranda programming language, which was one of the most important lazy functional programming languages in the 1980s However, at that time lots of other languages of the same kind existed in the wild That made difficult for researchers to have a common base in which to perform experiments in this paradigm So, by the end of that decade, they decided to build a completely new language that would become the ground for that research During the 1990s, several versions of the language were produced During this time Haskell evolved and incorporated some of the features that give the language its particular taste, like type classes and monads for managing input and output In 1998, a report defined Haskell 98, which was taken as the standard for any compliant Haskell compiler This is the version targeted by most of library developers However, new ideas from researchers and compiler writers had been integrated in Haskell compilers, mostly in GHC Some of these extensions have become very widely used, which make the case for a revised Haskell standard, which came of in 2010 By the time of writing, GHC targets this version of the language As the language has become more popular, more extensions have been added to GHC and other compilers, which usually can be switched on or off at the developer’s will As a result, a more disciplined schedule has been created for issuing revised Haskell standards in a timely basis Your Working Environment At this point you must be feeling the need to actually try Haskell on your own computer The first step for this is, of course, to have a working Haskell installation in your system Haskell developers have worried in the past about how to get people ready fast and easily And they have created the Haskell Platform, a distribution containing the GHC compiler, the Cabal build and library system, and a comprehensive set of libraries To get the Platform, go to http://www.haskell.org/platform/ Then, follow the steps that correspond to the operating system you will be using GHC website: http://www.haskell.org/ghc/ UHC website: http://www.cs.uu.nl/wiki/UHC JHC website: http://repetae.net/computer/jhc/ www.it-ebooks.info Beginning Haskell: A Project-Based Approach Copyright © 2014 by Alejandro Serrano Mena This work is subject to copyright All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed Exempted from this legal reservation are brief excerpts in connection with reviews or scholarly analysis or material supplied specifically for the purpose of being entered and executed on a computer system, for exclusive use by the purchaser of the work Duplication of this publication or parts thereof is permitted only under the provisions of the Copyright Law of the Publisher’s location, in its current version, and permission for use must always be obtained from Springer Permissions for use may be obtained through RightsLink at the Copyright Clearance Center Violations are liable to prosecution under the respective Copyright Law ISBN-13 (pbk): 978-1-4302-6250-3 ISBN-13 (electronic): 978-1-4302-6251-0 Trademarked names, logos, and images may appear in this book Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made The publisher makes no warranty, express or implied, with respect to the material contained herein President and Publisher: Paul Manning Lead Editor: Jonathan Gennick Technical Reviewer: Jean-Philippe Moresmau Editorial Board: Steve Anglin, Mark Beckner, Ewan Buckingham, Gary Cornell, Louise Corrigan, Jim DeWolf, Jonathan Gennick, Jonathan Hassell, Robert Hutchinson, Michelle Lowman, James Markham, Matthew Moodie, Jeff Olson, Jeffrey Pepper, Douglas Pundick, Ben Renow-Clarke, Dominic Shakeshaft, Gwenan Spearing, Matt Wade, Steve Weiss Coordinating Editor: Kevin Shea Copy Editor: Michael Sandlin Compositor: SPi Global Indexer: SPi Global Artist: SPi Global Cover Designer: Anna Ishchenko Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013 Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail orders-ny@springer-sbm.com, or visit www.springeronline.com Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc) SSBM Finance Inc is a Delaware corporation For information on translations, please e-mail rights@apress.com, or visit www.apress.com Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use eBook versions and licenses are also available for most titles For more information, reference our Special Bulk Sales–eBook Licensing web page at www.apress.com/bulk-sales Any source code or other supplementary material referenced by the author in this text is available to readers at www.apress.com For detailed information about how to locate your book’s source code, go to www.apress.com/source-code/ www.it-ebooks.info For my parents, who support me in everything I (and who bought me my first computer!) And for Elena, who makes my life wonderful (and helped with examples!) www.it-ebooks.info Contents About the Author�� xvii About the Technical Reviewer�� xix Acknowledgments�� xxi Introduction�� xxiii ■■Part 1: First Steps�� ■■Chapter 1: Going Functional��3 Why Haskell?��3 Why Pure Functional Programming?�� Why Strong Static Typing?�� The Haskell Ecosystem�� The History of Haskell��6 Your Working Environment��6 Installing on Windows�� Installing on Mac OS X�� Installing on Linux�� Installing on Linux from Source�� Checking That the Installation is Successful�� Installing EclipseFP�� First steps with GHCi��11 The Time Machine Store��12 Summary��13 vii www.it-ebooks.info ■ Contents ■■Chapter 2: Declaring the Data Model��15 Working with Characters, Numbers, and Lists��15 Characters�� 15 Numbers�� 16 Strings�� 18 Lists�� 18 Lists Operations�� 19 Creating a New Project��22 Creating a Project from the Command Line�� 22 Creating a Project from EclipseFP�� 23 Understanding Modules�� 25 Defining Simple Functions��26 Creating a Simple Function�� 26 Specifying the Function’s Type�� 27 Developing a Robust Example�� 27 Returning More than One Value�� 29 Working with Data Types��30 Pattern Matching��33 Simple Patterns�� 33 Lists and Tuples�� 37 Guards�� 38 View Patterns�� 40 Records��41 Creation and Use�� 41 The “Default Values” Idiom�� 43 Summary��45 viii www.it-ebooks.info ■ Contents ■■Chapter 3: Reusing Code Through Lists��47 Parametric Polymorphism��47 Functions as Parameters��50 Higher-Order Functions�� 50 Anonymous Functions�� 52 Partial Application of a Function�� 54 More on Modules��57 Module Imports�� 57 Smart Constructors and Views�� 59 Diving into Lists��61 Folds�� 61 Lists and Predicates�� 64 Lists Containing Tuples�� 69 List Comprehensions��70 Haskell Origami��73 Summary��76 ■■Chapter 4: Using Containers and Type Classes��77 Using Packages��77 Managing Packages with Cabal and EclipseFP�� 77 Sandboxed Environments�� 82 Containers: Maps, Sets, Trees, Graphs��84 Maps�� 84 Sets�� 87 Trees�� 89 Graphs�� 91 Obtaining Help�� 93 Ad-hoc Polymorphism: Type Classes��94 Declaring Classes and Instances�� 94 Built-in Type Classes�� 97 ix www.it-ebooks.info ■ Contents Binary Tress for the Minimum Price��101 Step 1: Simple Binary Trees�� 101 Step 2: Polymorphic Binary Trees�� 103 Step 3: Binary Trees with Monoidal Cache�� 104 Container-related Type Classes��106 Functors�� 106 Foldables�� 108 Summary��109 ■■Chapter 5: Laziness and Infinite Structures��111 An Infinite Number of Time Machines��111 Lazy Evaluation Model��115 Understanding Evaluation in Haskell�� 115 Problems with Laziness�� 119 Pattern Matching and Laziness�� 120 Profiling with GHC��122 Strictness Annotations��127 Summary��129 ■■Part 2: Data Mining�� 131 ■■Chapter 6: Knowing Your Clients Using Monads ��133 Data Mining��133 Implementing K-means�� 134 Lenses�� 138 Discovering Monads��143 Watching out for Incomplete Data�� 143 Combinators for State�� 145 Dissecting the Combinators�� 148 Notation�� 150 Monad Laws�� 152 x www.it-ebooks.info ■ Contents Different Sorts of State��153 State and Lenses�� 153 Reader, Writer, and RWS�� 155 Mutable References with ST�� 158 Summary��159 ■■Chapter 7: More Monads: Now for Recommendations��161 Returning More Than One Value��161 The List Monad�� 162 A New View Over Monads�� 163 Failures and Alternatives��164 Association Rules Learning.��167 Flattening Values into Transactions�� 167 The Apriori Algorithm�� 169 Search Problems��171 Paths in a Graph�� 172 The Logic Monad�� 173 Monads and Lists Redux��175 Combining Values Under a Monad�� 175 Monad Comprehensions�� 177 Combining Monads��179 Monad Transformers�� 180 Monad Classes�� 183 Summary��185 ■■Chapter 8: Working in Several Cores��187 Parallelism, Concurrency, Distribution��187 The Par Monad��188 Futures�� 188 Dataflow Parallelism with IVars�� 190 Parallelizing the Apriori Algorithm�� 192 xi www.it-ebooks.info ■ Contents Software Transactional Memory��194 Concurrent Use of Resources�� 194 Atomic Transactions�� 196 Rolling Back Transactions�� 197 Producer-Consumer Queues�� 199 Cloud Haskell��200 Looking for Galaxies�� 200 Looking for Typed Galaxies�� 204 Extra Features�� 205 Summary��206 ■■Part 3: Resource Handling�� 207 ■■Chapter 9: Dealing with Files: IO and Conduit��209 Basic Input and Output��209 Randomness��213 Working with Files��215 Reading and Writing�� 215 Handling Files�� 217 Error Handling��218 Pure Errors�� 218 Catching Exceptions�� 221 Throwing Exceptions�� 224 Streaming Data with Conduit��225 Problems with Lazy Input/Output�� 225 Introducing Conduits�� 226 Accessing Files via Conduit�� 229 Looking Further than Text Files��231 Basic Networking�� 231 Binary Serialization�� 232 Summary��234 xii www.it-ebooks.info ■ Contents ■■Chapter 10: Building and Parsing Text��235 The Five Textual Data Types��235 Building as Fast as the Wind��239 Parsing with attoparsec��241 Introducing New Type Classes��246 Applicative�� 247 Functors, Applicatives, and Monads�� 248 Alternative�� 250 Traversable�� 251 Don’t Overengineer: Just Use JSON��253 Summary��258 ■■Chapter 11: Safe Database Access��259 Database Access Landscape��259 Abstracting over Several DBMSs�� 260 Introducing Persistent and Esqueleto�� 260 Connection��261 Schemas and Migrations��262 Describing the Entities�� 263 Creating the Database�� 266 Queries��269 Queries by Identifier or Uniqueness�� 269 Selecting Several Entities�� 270 SQL Queries with Esqueleto�� 271 Insertions, Updates, and Deletions��274 Summary��276 ■■Chapter 12: Web Applications��277 Haskell Web Ecosystem��277 Web Frameworks�� 277 Compilation to Javascript�� 278 RESTful Structure��279 xiii www.it-ebooks.info ■ Contents Backend with Scotty��280 Simple Skeleton�� 280 Showing Products from the Database�� 281 Inserting New Products Using Forms�� 285 Frontend with Fay��289 Foreign Function Interface�� 290 Fay and jQuery�� 291 Summary��293 ■■Part 4: Domain Specific Languages�� 295 ■■Chapter 13: Strong Types for Describing Offers��297 Domain Specific Languages��297 Embedding Your Language in Haskell�� 298 The Offers Language�� 299 Adding Safety to the Expression Language��301 Dependent Typing��304 Introducing Idris�� 305 Enforcing the Presents Rule in Idris�� 308 Type-level Programming in Haskell��309 Two Styles of Programming�� 309 Representing Natural Numbers�� 310 Functional Dependencies��311 Categories of Products with FDs�� 311 Enforcing the Presents Rule with FDs�� 314 Type Families��317 Enforcing the Presents Rule with TFs�� 317 Categories of Products with TFs�� 319 Data Type Promotion and Singletons��322 A Further Refinement to the Presents Rule�� 323 Enforcing the Duration Rule�� 325 Summary��330 xiv www.it-ebooks.info ■ Contents ■■Chapter 14: Interpreting Offers with Attributes��331 Interpretations and Attribute Grammars��331 A Simple Interpretation�� 331 Introducing Attribute Grammars�� 332 Your First Attribute Grammar��333 Synthesizing the Result�� 334 Executing the Attribute Grammar�� 335 Integrating UUAGC in Your Package��336 Installing UUAGC�� 336 UUAGC and Cabal�� 336 Expressions Interpretation��338 Using an Attribute Grammar�� 338 Precomputing Some Values�� 341 A Different (Monadic) View�� 342 Offer Interpretations��343 Checking the Presents Rule�� 343 Showing a HTML Description�� 345 Origami Programming Over Any Data Type��348 Summary��350 ■■Part 5: Engineering the Store�� 353 ■■Chapter 15: Documenting, Testing, and Verifying��355 Documenting Binary Trees with Haddock��355 Unit Testing with HUnit��359 Declaring Tests in Cabal�� 359 Writing Unit Tests�� 360 Randomized Testing with QuickCheck��363 Testing List Properties�� 364 Testing Binary Tree Properties�� 365 Formal Verification with Idris��367 Summary��371 xv www.it-ebooks.info ■ Contents ■■Chapter 16: Architecting Your Application��373 Design Patterns and Functional Programming��373 Medium-Level Guidelines��374 Use Higher-Order Combinators�� 374 Refactor�� 375 Use Type Classes Wisely�� 375 Enforce Invariants via the Type System�� 375 Stay (as) Pure and Polymorphic (as Possible)�� 375 Tools��376 Project and Dependency Management�� 376 Code Style�� 376 Documentation�� 376 Test and Verification�� 377 Benchmarking�� 377 Profiling�� 377 Coverage�� 377 Remote Monitoring�� 377 Projects��378 Data Mining Library�� 378 Store Network Client�� 379 Administration Interface and Tetris�� 384 Roll Your Own Monad�� 384 Summary��387 ■■Appendix A: Looking Further��389 Haskell Resources��389 Other Functional Languages�� 390 ■■Appendix B: Time Traveling with Haskell��391 Index��393 xvi www.it-ebooks.info About the Author Alejandro Serrano Mena is passionate about functional programming and has been coding Haskell for personal and professional projects for more than five years He is currently working toward his Ph.D in the Software Technology group at Utrecht University His research involves enhancing the way developers get feedback and interact with strong type systems such as Haskell He has contributed to several open source projects, including Mono and Nemerle In 2011 he took part in the Google Summer of Code program, enhancing EclipseFP, the Haskell plug-in for the popular development environment Eclipse In 2012 he founded Nublic with two friends, a start-up focused on bringing cloud tools to home environments Much of the software in this project was built using Scala, a language that combines object-oriented and functional aspects He received a degree in computer science and mathematics from the Autonomous University of Madrid, the city where he grew up During his college years he was active in promoting free software and functional paradigm among students He was also a technical writer in the Spanish technical magazine Todo Programación xvii www.it-ebooks.info About the Technical Reviewer JP Moresmau has been working for more than fifteen years as a programmer, both in object-oriented and functional technologies He’s been working on web applications since 1996 and always had an interest in IDEs and language analysis He’s heavily involved in the Haskell open source community and is the maintainer of the EclipseFP project JP’s technical blog can be found at http://jpmoresmau.blogspot.com He lives in the South of France with his wife and two children xix www.it-ebooks.info Acknowledgments First of all, I would like to acknowledge the great work of the technical reviewer and the editorial board Their comments and suggestions have been extremely valuable for making the book better and more helpful Apart from that, Jean-Philippe Moresmau’s work on EclipseFP is simply wonderful Writing a book is a very rewarding task, but it’s also quite a consuming one For those times where the mood goes sour, there has not been anything better than the support that Elena brought to me She was there while I was thinking, refining the examples, and reviewing the text one more time My family and my friends have also encouraged me the entire time, so a bit of thanks to all of them too My parents Carmen and Julián deserve a very special mention: they’ve supported me during every single project, and as crazy as it may sound, throughout my whole life They bought me the first computer I worked with, which was the computer I started programming in an old Visual Basic environment It’s fair to say that without their help, you wouldn’t be reading this book The entire Haskell community is wonderful Having great mailing lists and IRC rooms full of (quite clever!) people always willing to help, encourages you to be curious and to learn more Every single library and compiler discussed in this book has been carefuly crafted by this community: they are the reason why Haskell is such a great language Finally, I would like to thank my professors and colleages at Utrecht University Even though I’ve only known them for a couple of months, their passion for functional programming has already made an impact on this book xxi www.it-ebooks.info ... things in life, the best way to learn Haskell is by writing Haskell programs! Why Haskell? If you are reading this book it means that you are interested in learning Haskell But what makes this language... After introducing Haskell, we will review the process of getting a ready and complete Haskell installation in your system, including the EclipseFP development environment that brings Haskell and Eclipse... this paradigm; and languages such as Haskell, Scala, Clojure, or OCaml, which embody functional programming from the very beginning, are being used in industry Haskell is a noise-free, pure functional

Ngày đăng: 19/04/2019, 11:16