Index

addset

Abstract data types | Programming with abstract data | Signatures | Structures | Representation independence and equality

addtwo

age

amber

andb

The Word and Word8 structures | see Word.andb

Anderson, Stuart

Computing types

app

Computing types

Array

Array.array
Arrays | Arrays
Array.fromList
Arrays
Array.sub
Arrays
Array.update
Arrays

atan

see Math.atan

B

Base 64

base64decode

BigInt.int

blue

bool

Types, values and functions | The Bool structure | Defining datatypes

Bool.fromString

The Bool structure

Bool.not

The Bool structure | Higher-order programming

Bool.toString

The Bool structure

Bosworth, Richard

Types, values and functions | The Byte structure

byte

Byte.byteToChar

The Byte structure

Byte.charToByte

The Byte structure

C

call-by-name

Call-by-value, call-by-name and call-by-need

call-by-need

Call-by-value, call-by-name and call-by-need

call-by-value

Call-by-value, call-by-name and call-by-need

case-sensitive language

char

Types, values and functions | The Char structure | The String structure

Char.chr

Char.contains

Char.isAlpha

Char.isAlphaNum

Char.isAscii

Char.isDigit

Char.isGraph

Char.isHexDigit

Char.isLower

Char.isPrint

Char.isSpace

Char.isUpper

Char.notContains

Char.ord

Char.pred

Char.succ

Char.toLower

Char.toUpper

charToWord

chr

Church Rosser Theorems

First Theorem: Call-by-value, call-by-name and call-by-need
Second Theorem: Call-by-value, call-by-name and call-by-need

Clack, Chris

closeIn

see TextIO.closeIn

closeOut

see TextIO.closeOut

colour

compose

Function composition | Derived forms | Function composition

composition

Function composition

in diagrammatic order: Function composition
in functional order: Function composition

concat

Left and right folding | see List.concat | Implementing type safety

cond

conditional expression

short-circuit: Derived forms

cons

constructors

Higher-order programming | Defining datatypes

nullary: Defining datatypes

cos

see Math.cos

create

Ill-typed functions

curried functions

curry

Curry, Haskell B.

D

date_of_birth

Defining a function by cases | The vector datatype

day

dead code

default overloading

delay

Forcing evaluation | Assignment

delayed

Forcing evaluation

dereferencing

References

derived forms

Derived forms | Pairs and record types | Defining datatypes

destructors

Dijkstra, Edsger W.

An example: Computing e

div

The Int structure

drop

Selecting from a list | The take function | see List.drop

dropwhile

Selecting from a list | The takewhile function

Duba, Bruce

Abstract data types | Programming with abstract data

E

Empty

Lists | see List.Empty

endOfStream

see TextIO.endOfStream

equal

equality types

eval_int_exp

eval_int_term

eval_int_factor

even

Higher-order programming | Defining datatypes

exception

exn

explode

expressions

expansive: Implementing type safety
non-expansive: Implementing type safety

extensional equality

extract

see Vector.extract

F

fac

Higher-order functions | Delaying evaluation | Iteration

facbody

Types, values and functions | Programming with abstract data

factorial function

Higher-order functions

false

fastrev

Implementing type safety

filter

The takewhile function | Sorting lists

first-fit pattern matching

FIX and FIX'

floor

Scope

foldl

Left and right folding | see List.foldl

foldli

see Vector.foldli

foldr

Left and right folding | see List.foldr

foldri

see Vector.foldri

for loops

The Vector structure

force

Forcing evaluation | Lazy datatypes | Assignment

from

fromList

see Vector.fromList | see Array.fromList

fst

function

fibonacci: Memoisation
integer maximum: The tree datatype

functions

composition of: Function composition
curried: Curried functions
factorial: Higher-order functions
higher-order: Higher-order functions
homogeneous: Polymorphism
idempotent: Curried functions
identity: Higher-order functions | Curried functions
polymorphic: Polymorphism
successor: Types, values and functions | Curried functions

G

green

H

handled

Harper, Robert

Representation independence and equality

hd

Lists | see List.hd

hd_tst

head

Henglein, Fritz

heterogeneous

higher-order function

Higher-order functions

Hindley, Roger

Type inference

hitchcock

Hoare, C.A.R.

Hughes, John

Standard ML

hundreds

I

idempotent functions

identity function

Higher-order functions | Curried functions

ifac

Iteration

implode

induction

Recursion

structural: Aggregates

initials

Function types and type | Default overloading

inorder

input

see TextIO.input

inputN

see TextIO.input

ins

Abstract data types

insert

Sorting lists | Left and right folding

instream

see TextIO.instream

int

Types, values and functions | The Int structure | The Real structure | The Word and Word8 structures

Int.max and Int.min: The tree datatype

Int.abs

Int.fmt

Int.fromString

Int.max

Int.maxInt

Int.min

Int.minInt

Int.quot

Int.rem

Int.toString

int_exp

int_term

int_factor

intensional equality

interchange law

inttree

Io

is_identity

iter

Curried functions | Derived forms

iter'

Representation independence and equality

K

Kahrs, Stefan

Ill-typed functions

L

last

Lists | see List.last

last_tst

last_tst

lcons

leaf

length

Defining datatypes | Lists | The take function | Left and right folding | see List.length

length'

Left and right folding

list

Defining datatypes | Converting trees to lists | The List structure

listid

Left and right folding

ListPair

The ListPair structure

listrev

Left and right folding | Left and right folding

ListUtils

long identifier

Scoping revisited

lookahead

see TextIO.lookahead

loop

M

MacQueen, Dave

map

The map function | Left and right folding

map_f

The map function

mapbody

mapPartial

The mapPartial function | see List.mapPartial

masks

Input/output

Math

Math.atan: List processing
Math.cos: List processing
Math.sin: List processing
Math.tan: List processing

max

see Int.max

maxdepth

List processing | Representation independence and equality

member

memberset

Abstract data types | Programming with abstract data | Signatures | Structures | Representation independence and equality

memo

memoisation

mf

Michaelson, Greg

Milner, Robin

Reading material | Type inference | Evaluation

min

see Int.min

mindepth

Programming with abstract data

Mitchell, Kevin

Memoisation

mk_set

ML keywords (index of first use)

abstype: Abstract data types
and: Defining datatypes
andalso: Derived forms
as: Sorting lists
case: Derived forms
datatype: Defining datatypes
do: Iteration
else: List processing
end: Scope
exception: Lists
fn: Types, values and functions
fun: Derived forms
handle: Lists
if: List processing
in: Scope
infix: Defining datatypes
infixr: Defining datatypes
let: Scoping revisited
local: Scope
of: Derived forms
op: Higher-order functions
orelse: Derived forms
raise: Lists
rec: Recursion
then: List processing
type: Function types and type
val: Types, values and functions
while: Iteration
with: Abstract data types

ML library units

Array

Array.array: Arrays | Arrays
Array.fromList: Arrays | Arrays
Array.sub: Arrays
Array.update: Arrays

Int

Int.max: The tree datatype | The tree datatype
Int.min: The tree datatype

List

List.concat: The List structure
List.drop: The List structure
List.Empty: The List structure
List.foldl: The List structure
List.foldr: The List structure
List.hd: The List structure
List.last: The List structure
List.length: The List structure
List.mapPartial: The List structure
List.nth: The vector datatype | The List structure
List.null: The List structure
List.rev: The List structure
List.revAppend: The List structure
List.take: The List structure
List.tl: The List structure

Math

Math.atan: List processing
Math.cos: List processing
Math.sin: List processing
Math.tan: List processing

TextIO

TextIO.closeIn: Input/output
TextIO.closeOut: Input/output
TextIO.endOfStream: Input/output
TextIO.input: Input/output
TextIO.inputN: Input/output
TextIO.instream: Input/output | Input/output
TextIO.lookahead: Input/output
TextIO.openIn: Input/output
TextIO.openOut: Input/output
TextIO.output: Input/output
TextIO.outstream: Input/output | Input/output
TextIO.stdIn: Input/output
TextIO.stdOut: Input/output

Vector

Vector.extract: The vector datatype
Vector.foldli: The Vector structure | The Vector structure
Vector.foldri: The Vector structure | The Vector structure
Vector.fromList: The vector datatype
Vector.sub: The vector datatype

Word

Word.>>: Input/output
Word.<<: Input/output
Word.andb: Input/output
Word.orb: Input/output

ML modules keywords

sig: Signatures | Structures
signature: Signatures | Structures
struct: Structures | Representation independence and equality
structure: Structures | Representation independence and equality

mod

The Int structure

Myers, Colin

myset

Programming with abstract data

N

nats

next

nil

nodes

NONE

notb

The Word and Word8

nth

Selecting from a list | see List.nth

null

see List.null | Abstract data types

null_eq

nullary constructors

O

o

odd

ones

oneszeroes

openIn

see TextIO.openIn

openOut

see TextIO.openOut

operators

overloaded: Default overloading

option

The Bool structure | The Real structure | Lists

orb

The Word and Word8 structures | see Word.orb

ord

Programming with abstract data

ordered

Default overloading

ordered_set

output

see TextIO.output

outstream

see TextIO.outstream

Overflow

Lists | Selecting from a list | The take function

overloading

Default overloading

P

pair

paren

path

Higher-order programming | Defining a function by

pattern matching

wild card: Higher-order programming

Paulson, Larry

perfectly balanced

perm

person

polymorphic

Poon, Ellen

postorder

prefix

preorder

R

radix

Scoping revisited

raised

rap

Type safety conditions

Reade, Chris

real

Types, values and functions | Scope | The Real structure | The Word and Word8 structures

Real.ceil

Real.floor

Scope | The Real structure

Real.fmt

Real.fromInt

Scope | The Real structure

Real.round

Real.trunc

records

Pairs and record types

red

reduce

Higher-order functions | Derived forms

ref

References | Implementing type safety

references

References

Retrieve

rev

Lists | see List.rev | Implementing type safety

revAppend

Lists | see List.revAppend

S

same

set

Set.addset

Set.emptyset

Set.memberset

Set.set

sin

see Math.sin

singleton

size

Simple applicative programming

SML basis

SML library

Simple applicative programming

snd

Sokolowski, Stefan

SOME

The Bool structure | The Int structure | The Real structure | Lists | The mapPartial function

sort

Sorting lists | Left and right folding

sort'

Left and right folding

sorting

insertion sort: Sorting lists

sq

Scoping revisited | Higher-order functions

square

Default overloading

Standard ML library

The Standard ML library

statically typed

Types and type inference

stdIn

see TextIO.stdIn

stdOut

see TextIO.stdOut

str

strict

string

Types, values and functions | Scoping revisited | The String structure | Input/output

String.concat

String.extract

String.fields

String.sub

The String structure | Function types and type

String.substring

String.tokens

String.translate

StringCvt

The Int structure | The StringCvt structure

StringCvt.BIN

StringCvt.DEC

StringCvt.FIX

StringCvt.GEN

StringCvt.HEX

StringCvt.OCT

StringCvt.padLeft

The StringCvt structure

StringCvt.padRight

The StringCvt structure

StringCvt.SCI

strongly typed

Types and type inference

structures in the Standard ML library

The Standard ML library

sub

Scoping revisited | see Vector.sub | see Array.sub

Subscript

Lists | Selecting from a list | The take function | Arrays

subset

Abstract data types

subtyping

succ

Types, values and functions | Derived forms

successor function

Types, values and functions | Curried functions

sum

Recursion

surname

syntactic sugar

T

tail

take

Selecting from a list | The take function | see List.take

takewhile

Selecting from a list | The takewhile function | Delaying evaluation

tan

see Math.tan

tens

tentimes

tester

testing

TextIO

TextIO.closeIn: Input/output
TextIO.closeOut: Input/output
TextIO.endOfStream: Input/output
TextIO.input: Input/output
TextIO.inputN: Input/output
TextIO.instream: Input/output
TextIO.lookahead: Input/output
TextIO.openIn: Input/output
TextIO.openOut: Input/output
TextIO.output: Input/output
TextIO.outstream: Input/output
TextIO.stdIn: Input/output
TextIO.stdOut: Input/output

tl

Lists | see List.tl

tl_tst

Tofte, Mads

Reading material | Ill-typed functions | Implementing type safety

tokeniser

traffic_light

traversal

inorder: Converting trees to lists
postorder: Converting trees to lists
preorder: Converting trees to lists

traversal strategies

Types, values and functions | Programming with abstract data

tree

Defining datatypes | The tree datatype | Converting trees to lists

true

ttree

twice

type coercions

type inference

Types and type inference

type variable

U

Ullman, Jeffrey

uncurry

unit

Forcing evaluation | Assignment | Input/output

update

see Array.update

V

value polymorphism

Implementing type safety

Vector | The vector datatype | The Vector structure

Vector.extract
The vector datatype
Vector.foldli
The Vector structure | The Vector structure
Vector.foldri
The Vector structure | The Vector structure
Vector.fromList
The vector datatype
Vector.sub
The vector datatype

vector slice

The vector datatype

W

Wikström, Åke

Types, values and functions | The Word and Word8 structures

word

Word.>>: Input/output
Word.<<: Input/output
Word.andb: Input/output
Word.orb: Input/output

Word.word

The Word and Word8 structures

Word8

The Word and Word8 structures

Word8.word

The Word and Word8 structures

wordListToVector

Input/output

Wright, Andrew

Implementing type safety

wrong_pat

wrong_exp