Haskell编程艺术：函数式编程导论

3星 · 超过75%的资源需积分: 9 79 浏览量更新于2024-07-20 收藏 22.2MB PDF 举报

"Thompson_S._Haskell_the_craft_of_functional_programming" 《Thompson S. Haskell: The Craft of Functional Programming》是Simon Thompson撰写的一本关于函数式编程的书籍，特别是针对Haskell语言的深入介绍。这本书的第二版旨在帮助读者理解和掌握函数式编程的核心概念，并通过使用Haskell这一强大而纯函数式的编程语言来实践这些概念。在书中，作者首先介绍了函数式编程的基本理念。他探讨了计算机如何用于建模，解释了函数的本质，以及它们在处理问题时的作用。通过举例和图片处理，阐述了类型系统在编程中的重要性，特别是在Haskell中的应用。此外，书中还讨论了表达式和求值的过程，以及定义和函数定义的方式。书中的一个早期案例——模型化的图片处理，用于演示函数式编程的思维方式和解决问题的方法。接着，第二部分引导读者开始使用Haskell和Hugs（一个Haskell的交互式开发环境）。这部分涵盖了编写第一个Haskell程序、如何使用Hugs、标准预读库和Haskell库的使用、模块系统以及如何处理错误和错误信息。这些都是初学者在学习Haskell时需要掌握的基础技能。第三部分则深入讨论了Haskell的基本类型和定义，包括布尔类型（Bool）、整数（Int）、类型重载、卫语句（Guards）以及字符类型（Char）。此外，还涵盖了浮点数（Float）的使用，以及相关语法的讲解。这些内容构成了Haskell编程的基础，为后续更复杂的编程概念打下坚实的基础。设计和实现是函数式编程的重要方面，书中的后续章节会进一步深入到数据结构、模式匹配、高阶函数、类型类等高级主题，帮助读者熟练地运用Haskell进行程序设计，同时理解函数式编程的优雅与效率。《Thompson S. Haskell: The Craft of Functional Programming》是一本详尽的Haskell和函数式编程教程，适合希望深入了解该领域的学生和开发者。通过本书，读者不仅能学习到Haskell语言，还能掌握函数式编程的思维方式，从而提升软件设计和开发的能力。

Preface

xix

customary

and list variables are named

xs,

and so on.

Recursion, types and proof

As hinted earlier, recursion is given less emphasis than before.

The material on type checking now takes the approach of looking more explicitly at

the constraints put upon types by definitions, and emphasizes this through

sequence

of examples. This replaces an approach which stated typing rules but said less about

their application in practice.

Students have made the point that proof over lists seems more realistic and indecd

easier to understand than proof over the natural numbers. For that reason, proof over

lists is introduced in Chapter

rather than earlier. This has the advantage that practical

examples can be brought in right from the start, and the material on proof is linked with

the pictures case study.

Problem solving and patterns of definition

Because of a concern for 'getting students started' in solving problems, there is an

attempt

talk more explicitly about strategies for programming, reorganizing and

introducing new material in Chapters

and

11;

this material owes much to Polya's

problem-solving approach in mathematics. There is also explicit discussion about

various 'patterns of definition' of programs in Section 9.1.

Conclusion and appendices

The new edition contains a concluding chapter which looks to further

resources,

both

printed and on the Web, as well as discussing possible directions for functional pro-

gramming.

Some material from the appendices has been incorporated into the conclusion, whilc

the appendix that discusses links with other paradigms says rather more about links

with

ideas. Thc other appendices have been updated, while the one that deal1 with

'some useful functions' has been absorbed into the body of the text.

the

reader

This introduction to functional programming in Haskell is designed to be read from

start to finish, but some material can be omitted, or read in a different order.

The material is presented in an order that the author tinds natural, and while this also

reflects some of the logical dependencies between parts of the subject, some material

later in the text can be read earlier than it appears. Specifically, the introductions to

110

in the first four section\ of Chapter I8 and to algebraic types in the carly ~ection\ on

Chapter

can be tackled at any point after reading Chapter

Local definition\, givcn

where

and

let.

are introduced in Chapter

they can be covered at any point after

Chapter

Preface

is always an option to cover only a subset of the topics, and this can be achieved

by stopping before the end; the rest of this section discuswh

more detail other ways

of trimming the material.

There is a thread on program verification which begins with Chapter

and continues

in Sections 10.9, 14.7, 16.10 and 17.9; this thread is optional. Similarly, Chaptcr 19

gives

self-contained treatment of program time and space behaviour which is also

optional.

Some material is more technical. and can be omitted on (at least the) first reading.

This is signalled explicitly

the text, and is contained

Sections 8.7 and part of

Section 13.2.

Finally, it is possible to omit some

the examples and case studies. For example,

Scctions 6.3 and

6.4

are extended sets of exercises which need not be covered; the text

processing (Section 7.6) and indexing (Section 10.8) can also be omitted

their roles

are to provide reinforcement and to show the system used on rather larger examples.

the later chapters, the examples in Sections 14.6 and 16.7-16.9 and in Chapter 17 can

be skipped, but paring too many examples will run the risk of losing some motivating

material.

Chapter 15 introduces modules

the tirst two sections; the remainder is the Huffman

coding case study, which is optional. Finally, distributed through thc final chapters are

the calculator and simulation case studies. Thcsc are again optional, hut omission of

the calculator case study will remove an important illustration of parsing and algebraic

and abstract data types.

Acknowledgements

For feedback on the first edition,

am grateful particularly to Ham Richards, Bjorn von

Sydow and Kevin Hammond and indeed to all those who have pointed out errata in that

text. In reading drafts of the second edition, thanks to Tim Hopkins and Peter Kcnny

as well as the anonymous referees.

Emma Mitchell and Michael Stsang of Addison-Wesley have supported this second

edition from its inception; thanks very much to them.

Particular thanks to Jane for devotion beyond the call of duty

reading and com-

menting very helpfully on the first two chapters, as well as for her support over the last

year while

have been wr~ting this edition. Finally, thanks to Alice and Rory who have

more than readily shared our home PC with Haskell.

Sinwn

Tl~ompson

Cmzterbury,

January

I999

Introducing functional programming

Finally, we want to give

preview of some of the more powerful and distinctive

ideas in functional programming. This allows us to illustrate how it differs from other

approaches like object-oriented programming, and also to show why we consider

functional programming to be of central importance to anyone learning computing

science. As we proceed with this informal overview we will give pointers to later

chapters of the book where we explain these ideas more rigorously and in more detail.

(

1.1

)

Computers and modelling

In the last fifty years computers have moved from being enormous, expensive, scarce,

slow and unreliable to being small, cheap, common, fut and (relatively!) dependable.

The first computers were 'stand-alone' machines, but now computers can also play

different roles, being organized together into networks, or being embedded in domestic

machines like cars and washing machines, as well as appearing in personal computers

(PCs), organizers and so on.

Despite this, the fundamentals of computers have changed very little in this period:

the purpose of a computer is to manipulate symbolic information. This information can

represent a simple situation, such as the items bought in a supermarket shopping trip, or

more complicated ones, like the weather system above Europe. Given this information,

we are required to perform tasks like calculating the total cost of a supermarket trip, or

producing a 24-hour weather forecast for southern England.

How are these tasks achieved'? We need to write a description of how the information

is manipulated. This is called a

program

and it is written in

programming language.

programming language is

formal, artificial language used to give instructions to

computer. In other words the Ianguage is used to write the

software

which controls

the behaviour of the

hardware.

While the structure of computers has remained very

similar since their inception, the ways in which they are programmed have developed

substantially. Initially programs were written using instructions which controlled the

hardware directly, whereas modern programming languages aim to work closer

the

level of the problem

a 'high' level

rather than at the 'low' or machine level.

The programming language is made to work on a computer- by an

implementation,

which is itself a program and which runs programs written in the higher-level Ianguage

on the computer in question.

programs

implementation

computer

What

a function?

Our task in this text is programming, so we shall be occupied with the upper half of the

diagram above, and not the details of implementation (which are discussed in Peyton

Jones 1987; Peyton Jones and Lester 1992).

Our subject here is

functional

programming, which is one of a number of different

programming styles or

paradigms;

others include object-oriented (OO), structured and

logic programming. How can there be different paradigms, and how do they differ'? One

very fruitful way of looking at programming is that

is the task of

modelling

situations

-either real-world or imaginary -within

computer. Each programming paradigm will

provide us with different tools for building these models; these different tools allow us

or force us

to think about situations in different ways. A functional programmer

will concentrate on the relationships between values, while an

programmer will

concentrate on the objects, say. Before we can say anything more about functional

programming we need to examine what it means to be a function.

(

What

a function?

function

is something which we can picture as a box with some inputs and an output,

thus:

inputs

output

The function gives an

output

value which depends upon the

input

value(s). We will

often use the term

result

for the output, and the terms

arguments

parameters

for

the inputs.

simple example of a function is addition,

over numbers. Given input values 12

and

the corresponding output will be

46.

inputs

output

-1-

The process of giving particular inputs to a function is called

function application,

and (12

34)

represents the application of the function

to 12 and

34.

Addition is a mathematical example, but there are also functions in many other

situations; examples of these include

a function giving the distance by road (output) between two cities (inputs);

a supermarket check-out program, which calculates the bill (o~itput) from

list of

bar codes scanned in (input); and

a process controller, which controls valves in a chemical plant. Its inputs are the

information from sensors, and its output the signals sent to the valve actuators.

剩余503页未读，继续阅读

IMT_23

粉丝: 0
资源: 8

Haskell编程艺术：函数式编程导论

Haskell The Craft of Functional Programming 2nd edition

haskell the craft of functional programming

The_Horvitz_Thompson_Estimator.pdf

2017_Thompson_Daniel_Dissertation.pdf

The_design_of_the_unix_operating_system.pdf(文字版）

The_past_present_and_future_of_Go_英文.pdf

Wunderman Thompson：Building-Better-Experiences_2021.pdf

Life_with_Unix.pdf

Go编程语言_Go_C_下载.zip

信息安全_数据安全_Reflection_on_trusting_trust.pdf

最新资源