CLEAN语言入门：函数式编程实战教程

需积分: 14 149 浏览量更新于2024-07-31 1 收藏 1.86MB PDF 举报

"使用clean函数式编程" 本文档是一本关于Clean语言的教程，面向已有函数式编程基础的学习者，旨在介绍如何在Clean中进行函数式编程。Clean是一种纯函数式编程语言，它强调将程序员的注意力集中在解决问题的本质上，而不是被琐碎的实现细节所困扰。函数式编程的一个关键特性是，程序可以被视为可执行的规范，这使得这类语言在教育和研究环境中广受欢迎，因为它们非常适合教授编程的基本原理，并用于快速原型设计。在研究领域，函数式语言常用于复杂系统的快速原型开发。随着实施技术的进步和对输入/输出处理等基本概念的新理解，现代函数式语言现在也能够应用于实际世界的软件开发。例如，Clean语言就具有与其他现代函数式语言相似的多个方面，它支持并发编程，这在处理多任务和并行计算时特别有用。本书的目标是通过Clean语言教授实用的编程技巧，其中包括以下几个核心知识点： 1. **纯函数式编程**：Clean是纯函数式的，意味着函数不会产生副作用，且对于相同的输入总是返回相同的输出。这有助于编写可预测、可测试和易于维护的代码。 2. **类型系统**：Clean拥有强大的静态类型系统，可以在编译时捕捉错误，提高程序的可靠性。 3. **数据不可变性**：Clean中的数据结构是不可变的，这意味着一旦创建，就不能修改。这种特性有助于避免并发环境中的数据冲突。 4. **模式匹配**：Clean支持模式匹配，允许开发者根据不同的数据结构模式执行不同的操作，提高了代码的简洁性和可读性。 5. **高阶函数**：Clean鼓励使用高阶函数，即可以接受其他函数作为参数或返回函数的函数。这使得代码更模块化，更容易复用。 6. **并发与并行**：Clean的语言设计允许自然地表达并发和并行，通过消息传递机制实现并发执行，降低了同步和线程管理的复杂性。 7. **类型推导**：Clean具有类型推导能力，意味着程序员通常不需要显式声明变量的类型，编译器可以根据上下文自动推断。 8. **错误处理**：Clean使用异常处理来处理错误，这与函数式编程的风格相吻合，保持了代码的纯粹性。通过学习这本书，读者将能够掌握Clean语言的这些核心概念，并将其应用于实际的项目开发中，从而利用函数式编程的优势来解决实际问题。此外，Clean的并发特性使得它在处理现代多核处理器的计算需求时尤其有价值。

6 FUNCTIONAL PROGRAMMING IN CLEAN

^ raising a number to a power

Some standard functions on real numbers are:

sqrt the square root function

sin the sine function

ln the natural logarithm

exp the exponential function (e-to-the-power-of)

1.3.3 Predefined functions on Booleans

The operator < determines whether a number is smaller than another number. The result is

the constant True (if it is true) or the constant False (if it is false). For example, the value of

1<2 is True.

The values True and False are the only elements of the set of truth values or Boolean values

(named after the English mathematician George Boole, who lived from 1815 till 1864).

Functions (and operators) resulting such a value are called Boolean functions or predicates.

Next to < there is also an operator > (greater than), an operator <= (smaller or equal to), and

an operator >= (greater or equal to). Furthermore, there is the operator == (equal to) and an

operator <> (not equal to).

Results of Boolean functions can be combined with the operators && (`and') and || (`or').

The operator && only returns True if the results left and right are true:

Start = 1<2 && 3<4

will show the result True to the user. The `or' operator needs only one of the two state-

ments to be true (both may be true as well), so 1==1 || 2==3 will yield True. There is a func-

tion not swapping True and False. Furthermore there is a function isEven which checks whe-

ther an integer number is even.

1.3.4 Predefined functions on lists

In the standard module StdList a number of functions operating on lists is defined. Some

functions on lists have already been discussed: length determines the length of a list, sum cal-

culates the sum of a list of whole numbers.

The operator ++ concatenates two lists. For example,

Start = [1,2] ++ [3,4,5]

will show the list [1,2,3,4,5].

The function and operates on a list of which the elements are Booleans; and checks if all the

elements in the list are True. For example, the expression and [1<2, 2<3, 1==0] returns False.

Some functions have two parameters. The function take operates on a number and a list. If

the number is n, the function will return the first n elements of the list. For example, take 3

[2..10] returns the list [2,3,4].

1.3.5 Predefined functions on functions

In the functions discussed so far, the parameters were numbers, Booleans or lists. Howe-

ver, the argument of a function can be a function itself, too! An example of that is the

function map, which takes two arguments: a function and a list. The function map applies the

argument function to all the elements of the list. It is defined in the standard module

StdList.

Some examples of the use of the map functions are:

Start = map fac [1,2,3,4,5]

Applying the fac function to all five numbers, this shows the list [1,2,6,24,120].

Running the program

Start = map sqrt [1.0,2.0,3.0,4.0]

I.1 INTRODUCTION TO FUNCTIONAL PROGRAMMING 7

shows the list [1.0, 1.41421, 1.73205, 2.0], and the program

Start = map isEven [1..8]

checks all eight numbers for even-ness, yielding a list of Boolean values: [False, True, False,

True, False, True, False, True].

1.4 Defining functions

1.4.1 Definition by combination

The easiest way to define functions is by combining other functions and operators, for ex-

ample by applying predefined functions that have been imported:

fac n = prod [1..n]

square x = x * x

Functions can also have more than one argument:

over n k = fac n / (fac k * fac (n-k))

roots a b c = [ (~b+sqrt(b*b-4.0*a*c)) / (2.0*a)

, (~b-sqrt(b*b-4.0*a*c)) / (2.0*a)

]

The operator ~ negates its argument. See 1.3.2 and Chapter 2 for the difference between 2

and 2.0.

Functions without arguments are commonly known as `constants':

pi = 3.1415926535

e = exp 1.0

These examples illustrate the general form of a function definition:

• the name of the function being defined

• names for the formal arguments (if there are any)

• the symbol =

• an expression, in which the arguments may be used, together with functions (either

functions imported form another module or defined elsewhere in the module) and

elementary values (like 42).

In definitions of functions with a Boolean result, at the right hand side of the =-symbol an

expression of Boolean value is given:

negative x = x < 0

positive x = x > 0

isZero x = x == 0

Note, in this last definition, the difference between the =-symbol and the ==-operator. A

single `equals'-symbol (=) separates the left-hand side from the right-hand side in function

definitions. A double `equals'-symbol (==) is an operator with a Boolean result, just as <

and >.

In the definition of the roots function in the example above, the expressions sqrt(b*b-

4.0*a*c) and (2.0*a) occur twice. Apart from being boring to type, evaluation of this kind of

expression is needlessly time-consuming: the identical subexpressions are evaluated twice.

To prevent this, in CLEAN it is possible to name a subexpression, and denote it only once.

A more efficient definition of the function roots would be:

roots a b c = [ (~b+s)/d

, (~b-s)/d

]

where

s = sqrt (b*b-4.0*a*c)

d = 2.0*a

The word where is not the name of a function. It is one of the `reserved words' that where

mentioned in subsection 1.3.1. Following the word where in the definition, again some defi-

nitions are given. In this case the constants s and d are defined. These constants may be

used in the expression preceding the where. They cannot be used elsewhere in the program;

8 FUNCTIONAL PROGRAMMING IN CLEAN

they are local definitions. You may wonder why s and d are called `constants', although their

value can be different on different uses of the roots function. The word `constants' is justi-

fied however, as the value of the constants is fixed during each invocation of roots.

1.4.2 Definition by cases

In some occasions it is necessary to distinguish a number of cases in a function definition.

The function that calculates the absolute value of a number is an example of this: for nega-

tive arguments the result is calculated differently than for positive arguments. In CLEAN,

this is written as follows:

abs x

| x<0 = ~x

| x>=0 = x

You may also distinguish more than two cases, as in the definition of the signum function

below:

signum x

| x>0 = 1

| x==0 = 0

| x<0 = -1

The expressions in the three cases are `guarded' by Boolean expressions, which are there-

fore called guards. When a function that is defined using guarded expressions is called, the

guards are tried one by one, in the order they are written in the program. For the first guard

that evaluates to True, the expression at the right hand side of the =-symbol is evaluated.

Because the guards are tried in textual order, you may write True instead of the last guard.

For clarity, you can also use the keyword otherwise.

abs x

| x<0 = ~x

| otherwise = x

A guard which yields always true, like True or otherwise, is in principle superfluous and may

be omitted.

abs x

| x<0 = ~x

= x

The description of allowed forms of function definition (the `syntax' of a function defini-

tion) is therefore more complicated than was suggested in the previous subsection. A more

adequate description of a function definition is:

• the name of the function;

• the names of zero or more arguments;

• an =-symbol and an expression, or: one ore more `guarded expressions';

• (optional:) the word where followed by local definitions.

A `guarded expression' consists of a |-symbol, a Boolean expression, a =-symbol, and an

expression. But still, this description of the syntax of a function definition is not com-

plete…

1.4.3 Definition using patterns

Until now, we used only variable names as formal arguments. In most programming lan-

guages, formal arguments may only be variables. But in CLEAN, there are other possibili-

ties: a formal argument may also be a pattern.

An example of a function definition in which a pattern is used as a formal argument is

h [1,x,y] = x+y

This function can only be applied to lists with exactly three elements, of which the first

must be 1. Of such a list, the second and third elements are added. Thus, the function is

not defined for shorter and longer list, nor for lists of which the first element is not 1. It is

a common phenomenon that functions are not defined for all possible arguments. For ex-

I.1 INTRODUCTION TO FUNCTIONAL PROGRAMMING 9

ample, the sqrt function is not defined for negative numbers, and the / operator is not de-

fined for 0 as its second argument. These functions are called partial functions.

You can define functions with different patterns as formal argument:

sum [] = 0

sum [x] = x

sum [x,y] = x+y

sum [x,y,z] = x+y+z

This function can be applied to lists with zero, one, two or three elements (in the next sub-

section this definition is extended to lists of arbitrary length). In each case, the elements of

the list are added. On use of this function, it is checked whether the actual argument

`matches' one of the patterns. Again, the definitions are tried in textual order. For example,

the call sum [3,4] matches the pattern in the third line of the definition: The 3 corresponds

to the x and the 4 to the y.

As a pattern, the following constructions are allowed:

• numbers (e.g. 3);

• the Boolean constants True and False;

• names (e.g. x);

• list enumeration's, of which the elements must be patterns (e.g. [1,x,y]);

• lists patterns in which a distinction is made between the first element and the rest of

the list (e.g. [a:b]).

Using patterns, we could for example define the logical conjunction of two Boolean func-

tions:

AND False False = False

AND False True = False

AND True False = False

AND True True = True

By naming the first element of a list, two useful functions can be defined, as is done in the

module StdList:

hd [x:y] = x

tl [x:y] = y

The function hd returns the first element of a list (its `head'), while the function tl returns

all but the first element (the `tail' of the list). These functions can be applied to almost all

lists. They are not defined, however, for the empty list (a list without elements): an empty

list has no first element, let alone a `tail'. This makes hd and tl partial functions.

Note the difference in the patterns (and expressions) [x:y] and [x,y]. The pattern [x:y] de-

notes a list with first element (head) x and rest (tail) y. This tail can be any list, including the

empty list []. The pattern [x,y] denotes a list of exactly two elements, the first one is called

x, and the other one y.

1.4.4 Definition by induction or recursion

In definitions of functions, other functions may be used. But also the function being defi-

ned may be used in it's own definition! A function which is used in its own definition is

called a recursive function (because its name `re-(oc)curs' in its definition). Here is an example

of a recursive definition:

fac n

| n==0 = 1

| n>0 = n * fac (n-1)

The name of the function being defined (fac) occurs in the defining expression on the right

hand side of the =-symbol.

Another example of a recursively defined function is `raising to an integer power'. It can be

defined as:

power x n

10 FUNCTIONAL PROGRAMMING IN CLEAN

| n==0 = 1

| n>0 = x * power x (n-1)

Also, functions operating on lists can be recursive. In the previous subsection we intro-

duced a function to determine the length of some lists. Using recursion we can define a

function sum for lists of arbitrary length:

sum list

| list == [] = 0

| otherwise = hd list + sum (tl list)

Using patterns we can also define this function in a much more readable way:

sum [] = 0

sum [first: rest] = first + sum rest

Using patterns, you can give the relevant parts of the list a name directly (like first and rest

in this example). In the definition that uses guarded expressions to distinguish the cases,

auxiliary functions hd and tl are necessary.

Using patterns, we can define a function length that operates on lists:

length [] = 0

length [first:rest] = 1 + length rest

The value of the first element is not used (only the fact that a first element exists). For

cases like this, it is allowed to use the ‘_’ symbol instead of an identifier:

length [] = 0

length [_:rest] = 1 + length rest

Recursive functions are generally used with two restrictions:

• for a base case there is a non-recursive definition;

• the actual argument of the recursive call is closer to the base case (e.g., numerically smaller,

or a shorter list) than the formal argument of the function being defined.

In the definition of fac given above, the base case is n==0; in this case the result can be de-

termined directly (without using the function recursively). In the case that n>0, there is a

recursive call, namely fac (n-1). The argument in the recursive call (n-1) is, as required,

smaller than n.

For lists, the recursive call must have a shorter list as argumen. There should be a non-

recursive definition for some finite list, usually the empty list.

1.4.5 Local definitions, scope and lay-out

If you want to define a function to solve a certain problem you often need to define a

number of additional functions each solving a part of the original problem. Functions fol-

lowing the keyword where are locally defined which means that they only have a meaning

within the surrounding function. It is a good habit to define functions that are only used in

a particular function definition, locally to the function they belong. In this way you make it

clear to the reader that these functions are not used elsewhere in the program. The scope of

a definition is the piece of program text where the definition can be used. The box in figure

1.1 shows the scope of a local function definition, i.e. the area in which the locally defined

function is known and can be applied. The figure also shows the scope of the arguments of

a function. If a name of a function or argument is used in an expression one has to look for

a corresponding definition in the smallest surrounding scope (box). If the name is not de-

fined there one has to look for a definition in the nearest surrounding scope and so on.

function args

| guard1 = expression1

| guard2 = expression2

where

function args = expression

Figure 1.1: Defining functions and values locally for a function alternative.

剩余236页未读，继续阅读

yntcsb

粉丝: 4
资源: 4

CLEAN语言入门：函数式编程实战教程

CS1807-U201814745-朱槐志函数式编程1

Clean语言教程Functional Programming in CLEAN

excel，CLEAN函数

excel clean函数

curl_global_cleanup函数介绍

def clean_data函数的使用

excel 中clean 函数，在xlwings如何实现

clean_信道冲激函数_验证输入卷积冲激函数得到输出_clean信号_clean_

module 'toad' has no attribute 'clean'

lvgl V7中lv_canvas_clean函数实现

最新资源