函数式编程入门：以StandardML'97为例

下载需积分: 10 | PDF格式 | 410KB | 更新于2024-07-23 | 177 浏览量 | 举报

1 收藏

"标准ML'97编程教程：一个初学者的指南" 本文档是对标准函数式编程语言Standard ML（1997版）的入门教程，由Stephen Gilmore撰写，来自爱丁堡大学计算机科学基础实验室。该教程旨在介绍函数式编程的基本概念和实践，适合初学者学习。教程内容可能经过多次修订，以保持其时效性和准确性。函数式编程是一种编程范式，它借鉴了数学中函数的概念，将程序视为一系列计算或函数的组合。在函数式编程中，程序、函数和过程被视为等价的，可以像处理其他数据一样处理函数。这种编程风格强调无副作用的纯函数，以及通过函数组合来构建复杂逻辑，而非改变状态或使用循环。 Standard ML是一种强类型、静态类型的函数式编程语言，具有丰富的类型系统，支持模式匹配、高阶函数和类型推断等特性。在本教程中，读者将学习如何定义和使用函数，以及如何处理数据结构如列表、元组和树。此外，教程可能还会涵盖类型系统、异常处理、模块系统和递归等核心概念。在学习函数式编程时，理解纯函数的重要性是关键。纯函数不依赖于外部状态，每次给定相同的输入时总是返回相同的结果，这有助于编写可预测且易于测试的代码。此外，高阶函数允许将函数作为参数传递给其他函数，或者将函数作为结果返回，增加了代码的灵活性。 Standard ML还支持类型推断，这意味着编译器可以根据函数定义和使用情况自动推断变量的类型，减少了显式的类型声明，同时增强了代码的安全性。模式匹配则是一种强大的工具，使得解构数据结构和处理多种情况变得简单。在教程中，读者可能会遇到一系列示例函数和程序，这些例子旨在教育和实用，但作者明确指出，这些程序未经彻底测试，可能存在错误，且不提供任何保修。这意味着在实际应用时，开发者仍需自行验证和调试代码。 Standard ML '97编程教程是学习函数式编程的宝贵资源，特别是对那些希望深入理解这一编程范式的初学者而言。通过学习，开发者将能够掌握函数式编程的核心原理，并能够在实际项目中应用这些概念。

CHAPTER 2. SIMPLE APPLICATIVE PROGRAMMING 13

2.6.3 The Char structure

Operations on characters are found in the Char structure. These include the integer equiva-

lents of the word-to-character conversion functions, Char.chr and Char.ord. Also included

are successor and predecessor functions, Char.succ and Char.pred. Many functions perform

obvious tests on characters, such as Char.isAlpha, Char.isUpper, Char.isLower, Char.isDigit,

Char.isHexDigit and Char.isAlphaNum. Some exhibit slightly more complicated behaviour,

such as Char.isAscii which identiﬁes seven-bit ASCII characters; and Char.isSpace which

identiﬁes whitespace (spaces, tabulate characters, line break and page break characters);

Char.isPrint identiﬁes printable characters and Char.isGraph identiﬁes printable, non-

whitespace characters. The functions Char.toUpper and Char.toLower behave as expected,

leaving non-lowercase (respectively non-uppercase) characters unchanged. The pair of comple-

mentary functions Char.conta ins and Char.notContains may be used to determine the

presence or absence of a character in a string. Relational operators on characters are also

provided in the Char structure.

2.6.4 The Int structure

The Int structure contains many arithmetic operators. Some of these, such as Int.quot and

Int.rem, are subtle variants on more familiar operators such as div and mod . Quotient

and remainder diﬀer from divisor and modulus in their behaviour with negative operands.

Other operations on integers include Int.abs and Int.min and Int.max, which behave as

expected. This structure also provides conversions to and from strings, named Int.toString

and Int.fromString, of course. An additional formatting function provides the ability to

represent integers in bases other than decimal. The chosen base is speciﬁed using a type

which is deﬁned in another library structure, the string convertors structure, StringCvt. This

permits very convenient formatting of integers in binary, octal, decimal or hexadecimal, as

shown below.

Int.fmt StringCvt.BIN 1024 = "10000000000"

Int.fmt StringCvt.OCT 1024 = "2000"

Int.fmt StringCvt.DEC 1024 = "1024"

Int.fmt StringCvt.HEX 1024 = "400"

The Int structure may deﬁne largest and smallest integer values. This is not to say that

structures may arbitrarily shrink or grow in size, Int.maxInt either takes the value NONE

or SOME i, with i being an integer value. Int .minInt has the same type.

2.6.5 The Real structure

It would not be very misleading to say that the Real structure contains all of the corre-

sponding real equivalents of the integer functions from the Int structure. In addition to

these, it provides conversions to and from integers. For the former we have Real.trunc, which

truncates; Real.round, which rounds up; Real.ﬂoor which returns the greatest integer less

than its argument; and Real.ceil, which returns the least integer greater than its argument.

For the latter we have Real.fromInt, which we have already seen. One function which is

CHAPTER 2. SIMPLE APPLICATIVE PROGRAMMING 14

necessarily a little more complicated than the integer equivalent is the Real.fmt function

which allows the programmer to select between scientiﬁc and ﬁxed-point notation or to allow

the more appropriate format to be used for the value being formatted. In addition to this

a number may be speciﬁed; it will default to six for scientiﬁc or ﬁxed-point notation and

twelve otherwise. The ﬁne distinction between the import of the numbers is that it speciﬁes

decimal places for scientiﬁc and ﬁxed-point notation and signiﬁcant digits otherwise. Func-

tions cannot vary the number of arguments which they take so once again the option type

is used to signify the number of required digits. Here are some examples of the use of this

function. Note that the parentheses are needed in all cases.

Real.fmt ( Str ingCvt.FIX NONE) 3.1415 = "3.141500"

Real.fmt ( Str ingCvt.SC I NONE) 3.1415 = "3.141500E00"

Real.fmt ( Str ingCvt.GEN NONE) 3.1415 = "3.1415"

Real.fmt ( Str ingCvt.FIX (SOME 3)) 3.1415 = "3.142"

Real.fmt ( Str ingCvt.SC I (SOME 3)) 3.1415 = "3.142E00"

Real.fmt ( Str ingCvt.GEN (SOME 3)) 3.1415 = "3.14"

2.6.6 The String structure

The String structure provides functions to extract substrings and to process strings at a

character-by-character level. These include String.substring which takes a triple of a string

and two integers to denote the start of the substring and its length. Indexing is from zero,

a convention which is used throughout the library. The String.extract function enables the

programmer to leave the end point of the substring unspeciﬁed using the option NONE. The

meaning of this is that there is to be no limit on the amount of the string which is taken, save

that imposed by the string itself. Thus for example, String.extract (s, 0, NONE) is always

the same as s itself, even if s is empty. The String.sub function may be used to subscript

a string to obtain the character at a given position. Lists of strings may be concatenated

using String.concat.

Several high-level functions are provided for working with strings. Two of the most useful

are a tokeniser, String.tokens, and a separator, String.ﬁelds. These are parameterised by a

function which can be used to specify the delimiter which comes between tokens or between

ﬁelds. The principal distinction between a token and a ﬁeld is that a token may not be empty,

whereas a ﬁeld may. Used together with the character classiﬁcation functions from the Char

structure these functions provide a simple method to perform an initial processing step on a

string, such as dividing it into separate words. Another useful function is String.translate

which maps individual characters of a string to strings which are then joined. Used together

with String.tokens, this function provides a very simple method to write an accurate and

eﬃcient lexical analyser for a formal language. The method is simply to pad out special

characters with spaces and then to tokenize the result na¨ıvely.

2.6.7 The StringCvt structure

In the string convertors structure, StringCvt, are several of the speciﬁers for forms of conver-

sion from numbers to strings but also some simple functions which work on strings, such as

Chapter 3

Higher-order programming

As we have seen, functions deﬁned by pattern matching associate patterns and expressions.

Functions deﬁned in this way are checked by Standard ML. One form of checking is to ensure

that all of the patterns describe values from the same data type and all of the expressions

produce values of the same type. Both of the functions below will be rejected because they

do not pass these checks.

(* error *)

val wrong_pat = fn 1

> 1

| true

> 1

(* error *)

val wrong_exp = fn 1

> true

| n

> "false"

Pattern matching provides subsequent checking which, if failed, will not cause the function

to be rejected but will generate warning messages to call attention to the possibility of error.

This subsequent checking investigates both the extent of the patterns and the overlap between

them. The ﬁrst version of the boolean negation function below is incomplete because the

matches in the patterns are not exhaustive; there is no match for true. The second version

has a redundant pattern; the last one. Both produce compiler warning messages.

(* warning *)

val not

= fn false

> true

(* warning *)

val not

= fn false

> true

| true

> false

| false

> false

Both functions can be used. The ﬁrst will only produce a result for false but because of the

ﬁrst-ﬁt pattern matching discipline the second will behave exactly like the Bool.not function

in the Standard ML library. The warning message given for the second version signals the

presence of so-called dead code which will never be executed.

The checking of pattern matching by Standard ML detects ﬂawed and potentially ﬂawed

deﬁnitions. However, this checking is only possible because the allowable patterns are much

simpler than the expressions of the language. Patterns may contain constants and variables

and the wild card which is denoted by the underscore symbol. They may also use constructors

from a data type—so far we have only met a few of these including false and true from

the bool data type and SOME and NONE from the option data type. Constructors are

distinct from variables in patterns because constructors can denote only themselves, not

剩余93页未读，继续阅读

身份认证购VIP最低享 7 折!

30元优惠券

qq_14983427

粉丝: 0

函数式编程入门：以StandardML'97为例

JavaScript轻量级函数式编程指南

深入探究函数式编程的核心理念

函数式编程报告：数函数式编程特点，高阶函数与引用透明性

Python函数式编程指南（一）：函数式编程概述

函数式编程和命令式编程

12.7 命令式编程vs函数式编程｜函数式编程： 匿名函数、高阶函数、装饰器｜Python3.8入门 & 进阶 & 原生爬虫实战完全解读

JavaScript函数式编程

js函数式编程

Python函数式编程

Scala函数式编程

最新资源

12.7 命令式编程vs函数式编程｜函数式编程：匿名函数、高阶函数、装饰器｜Python3.8入门 & 进阶 & 原生爬虫实战完全解读