2016年Haskell编程进阶教程：清晰、高效与最新特性的探索

需积分: 41 134 浏览量更新于2024-07-18 收藏 7.37MB PDF 举报

《Haskell编程：2016年第二版》是一本经典的函数式编程语言教程，由经验丰富的教授Graham Hutton撰写，他有着超过二十年的教学经验。Haskell作为一种纯函数式语言，强调代码的清晰、简洁和正确性，近年来在教学和业界都得到了广泛的认可。本书的第一部分（Part I）是基础篇，主要围绕Haskell的核心特性展开，为读者提供从零开始学习的坚实基础。作者以基本概念为核心，从原理出发进行讲解，即使没有编程背景的读者也能轻松上手，使得这本书成为面向广大读者群体的理想教材。章节内包含大量的编程实例，以及配套的练习题和进一步阅读的建议，帮助读者逐步掌握语言的各个方面。第二部分（Part II）则深入探讨了不纯编程和一系列高级主题。随着技术的发展，这本书在新的版本中进行了大量更新和扩展，增添了Haskell的最新特性和功能，例如更复杂的Applicative、Monad、Foldable和Traversable类型等。这些新内容不仅提升了读者的专业技能，也为实际项目开发提供了前瞻性的指导。此外，新版本还提供了精选的解决方案、可免费下载的讲座幻灯片和示例代码，使得学习者能够跟随书中的指导进行实践，加深对理论知识的理解。Graham Hutton教授以其丰富的教学经验和生动的授课风格，确保了这本书在保持学术严谨性的同时，也具有易读性和实用性。《Programming in Haskell 2016年第二版》是一本全面且与时俱进的Haskell学习指南，无论你是初学者还是进阶开发者，都能从中收获丰富的知识和实践经验，助力你在函数式编程的世界中游刃有余。

Part I

Basic Concepts

Alternatively, the same result can also be calculated by starting with the outer

application of the function

double

rather than the inner:

double (double 2)

={ applying the outer

double

}

double 2 + double 2

={ applying the first

double

}

(2 + 2) + double 2

={ applying the first

}

4 + double 2

={ applying

double

}

4 + (2 + 2)

={ applying the second

}

4 + 4

={ applying

}

However, this approach requires two more steps than our original version, because

the expression

double 2

is duplicated in the first step and hence simplified twice.

In general, the order in which functions are applied in a calculation does not affect the

value of the final result, but it may affect the number of steps required, and whether

the calculation process terminates. These issues are explored in more detail when we

consider how expressions are evaluated in chapter 15.

1.2Functional programming

What is functional programming? Opinions differ, and it is difficult to give a precise

definition. Generally speaking, however, functional programming can be viewed as

a style of programming in which the basic method of computation is the application

of functions to arguments. In turn, a functional programming language is one that

supports and encourages the functional style.

To illustrate these ideas, let us consider the task of computing the sum of the

integers (whole numbers) between one and some larger number

. In many current

programming languages, this would normally be achieved using two integer variables

whose values can be changed over time by means of the assignment operator

, with

one such variable used to accumulate the total, and the other used to count from

. For example, in Java the following program computes the required sum using

this approach:

int total = 0;

for (int count = 1; count <= n; count++)

total = total + count;

That is, we first initialise an integer variable

total

to zero, and then enter a loop

that ranges an integer variable

count

from

, adding the current value of the

counter to the total each time round the loop.

In the above program, the basic method of computation is changing stored values,

in the sense that executing the program results in a sequence of assignments. For

example, the case of

gives the following sequence, in which the final value

assigned to the variable

total

is the required sum:

total = 0;

count = 1;

total = 1;

count = 2;

total = 3;

count = 3;

total = 6;

count = 4;

total = 10;

count = 5;

total = 15;

In general, programming languages such as Java in which the basic method of

computation is changing stored values are called imperative languages, because

programs in such languages are constructed from imperative instructions that specify

precisely how the computation should proceed.

Now let us consider computing the sum of the numbers between one and

using

Haskell. This would normally be achieved using two library functions, one called

[..]

that is used to produce the list of numbers between

and

, and the other called

sum

that is used to produce the sum of this list:

sum [1..n]

In this program, the basic method of computation is applying functions to arguments,

in the sense that executing the program results in a sequence of applications. For

example, the case of

gives the following sequence, in which the final value in

the sequence is the required sum:

sum [1..5]

={ applying

[..]

}

sum [1,2,3,4,5]

={ applying

sum

}

1 + 2 + 3 + 4 + 5

={ applying

}

Most imperative languages provide some form of support for programming with

functions, so the Haskell program

sum [1..n]

could be translated into such

languages. However, many imperative languages do not encourage programming in

the functional style. For example, many such languages discourage or prohibit

functions from being stored in data structures such as lists, from constructing

intermediate structures such as the list of numbers in the above example, from taking

functions as arguments or producing functions as results, or from being defined in

terms of themselves. In contrast, Haskell imposes no such restrictions on how

functions can be used, and provides a range of features to make programming with

functions both simple and powerful.

1.3Features of Haskell

For reference, the main features of Haskell are listed below, along with particular

chapters of this book that give further details.

• Concise programs (chapters 2 and chapters 4)

Due to the high-level nature of the functional style, programs written in

Haskell are often much more concise than programs written in other

languages, as illustrated by the example in the previous section. Moreover,

the syntax of Haskell has been designed with concise programs in mind,

in particular by having few keywords, and by allowing indentation to be

used to indicate the structure of programs. Although it is difficult to make

an objective comparison, Haskell programs are often between two and ten

times shorter than programs written in other languages.

• Powerful type system (chapters 3 and chapters 8)

Most modern programming languages include some form of type system to

detect incompatibility errors, such as erroneously attempting to add a number

and a character. Haskell has a type system that usually requires little type

information from the programmer, but allows a large class of incompatibility

errors in programs to be automatically detected prior to their execution, using

a sophisticated process called type inference. The Haskell type system is

also more powerful than most languages, supporting very general forms of

polymorphism and overloading, and providing a wide range of special

purpose features concerning types.

• List comprehensions (chapter 5)

One of the most common ways to structure and manipulate data in computing

is using lists of values. To this end, Haskell provides lists as a basic concept

in the language, together with a simple but powerful comprehension notation

that constructs new lists by selecting and filtering elements from one or more

existing lists. Using the comprehension notation allows many common

functions on lists to be defined in a clear and concise manner, without the

need for explicit recursion.

• Recursive functions (chapter 6)

Most programs involve some form of looping. In Haskell, the basic

mechanism by which looping is achieved is through recursive functions that

are defined in terms of themselves. It can take some time to get used to

recursion, particularly for those with experience of programming in other

styles. But as we shall see, many computations have a simple and natural

definition in terms of recursive functions, especially when pattern matching

and guards are used to separate different cases into different equations.

• Higher-order functions (chapter 7)

Haskell is a higher-order functional language, which means that functions

can freely take functions as arguments and produce functions as results.

Using higher-order functions allows common programming patterns, such

剩余292页未读，继续阅读

luk8luk8

粉丝: 1
资源: 8

2016年Haskell编程进阶教程：清晰、高效与最新特性的探索

Programming-in-Haskell-2nd-Edition.pdf

Programming in Haskell 2nd version Graham Hutton

programming-in-haskell:Haskell编程练习书

Hutton_Programming_in_Haskell

Parallel_and_Concurrent_Programming_in_Haskell

programming_in_haskell

IF1210_Programming_Fundamentals:Haskell的函数式编程范例和Python的过程式编程范例

guess_number.zip_Haskell_haskell 猜数字_haskell猜数字

faktory_worker_haskell：Haskell的Faktory Worker

haskell_examples.rar_Haskell

最新资源