NEXT ·  UP ·  PREVIOUS ·  CONTENTS

Index

A· B· C· D· E· F· G· H· I· K· L· M· N· O· P· R· S· T· U· V· W· X· Z

CORE KEYWORDS · MODULES KEYWORDS · LIBRARY UNITS

A

abs
Types, values and functions | Higher-order programming
absorb
Ill-typed functions
addfour
Curried functions
addset
Abstract data types | Programming with abstract data | Signatures | Structures | Representation independence and equality
addtwo
Curried functions
age
Function types and type
amber
Defining datatypes
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
Input/output
base64decode
Input/output
BigInt.int
Default overloading
blue
Defining datatypes
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
Reading material
byte
Types, values and functions | The Byte structure
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
Types, values and functions
char
Types, values and functions | The Char structure | The String structure
Char.chr
The Char structure
Char.contains
The Char structure
Char.isAlpha
The Char structure
Char.isAlphaNum
The Char structure
Char.isAscii
The Char structure
Char.isDigit
The Char structure
Char.isGraph
The Char structure
Char.isHexDigit
The Char structure
Char.isLower
The Char structure
Char.isPrint
The Char structure
Char.isSpace
The Char structure
Char.isUpper
The Char structure
Char.notContains
The Char structure
Char.ord
The Char structure
Char.pred
The Char structure
Char.succ
The Char structure
Char.toLower
The Char structure
Char.toUpper
The Char structure
charToWord
Input/output
chr
Types, values and functions
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
Reading material
closeIn
see TextIO.closeIn
closeOut
see TextIO.closeOut
colour
Defining datatypes
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
Delaying evaluation
conditional expression
Derived forms
short-circuit
Derived forms
cons
Lazy datatypes
constructors
Higher-order programming | Defining datatypes
nullary
Defining datatypes
cos
see Math.cos
create
Ill-typed functions
curried functions
Curried functions
curry
Curried functions
Curry, Haskell B.
Curried functions

D

date_of_birth
Function types and type
day
Defining a function by cases | The vector datatype
dead code
Higher-order programming
default overloading
List processing
delay
Forcing evaluation | Assignment
delayed
Forcing evaluation
dereferencing
References
derived forms
Derived forms | Pairs and record types | Defining datatypes
destructors
Lists
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
Defining datatypes

E

Empty
Lists | see List.Empty
Abstract data types | Programming with abstract data | References | Signatures | Structures | Representation independence and equality
endOfStream
see TextIO.endOfStream
equal
Abstract data types | Programming with abstract data
equality types
List processing
eval_int_exp
Defining datatypes
eval_int_term
Defining datatypes
eval_int_factor
Defining datatypes
even
Higher-order programming | Defining datatypes
exception
Lists
exn
Lists
explode
Types, values and functions
expressions
expansive
Implementing type safety
non-expansive
Implementing type safety
extensional equality
List processing
extract
see Vector.extract

F

fac
Higher-order functions | Delaying evaluation | Iteration
facbody
Delaying evaluation
factorial function
Higher-order functions
false
Types, values and functions | Programming with abstract data
fastrev
Implementing type safety
filter
The takewhile function | Sorting lists
first-fit pattern matching
Higher-order programming
FIX and FIX'
Delaying evaluation
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
Lazy datatypes
fromList
see Vector.fromList | see Array.fromList
fst
Polymorphism
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
Defining datatypes

H

handled
Lists
Harper, Robert
Reading material
hd
Lists | see List.hd
hd_tst
Lists
head
Lazy datatypes
Henglein, Fritz
Computing types
heterogeneous
Defining datatypes
higher-order function
Higher-order functions
Hindley, Roger
Type inference
hitchcock
Representation independence and equality
Hoare, C.A.R.
Sorting lists
Hughes, John
Standard ML
hundreds
Lazy datatypes

I

idempotent functions
Curried functions
identity function
Higher-order functions | Curried functions
ifac
Iteration
implode
Types, values and functions
induction
Recursion
structural
Aggregates
initials
Function types and type | Default overloading
inorder
Converting trees to lists
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
The Int structure
Int.fmt
The Int structure
Int.fromString
The Int structure
Int.max
The Int structure
Int.maxInt
The Int structure
Int.min
The Int structure
Int.minInt
The Int structure
Int.quot
The Int structure
Int.rem
The Int structure
Int.toString
The Int structure
int_exp
Defining datatypes
int_term
Defining datatypes
int_factor
Defining datatypes
intensional equality
List processing
interchange law
Induction for lists
inttree
Defining datatypes
Io
Input/output
is_identity
Higher-order programming
iter
Curried functions | Derived forms
iter'
Derived forms

K

Kahrs, Stefan
Ill-typed functions

L

last
Lists | see List.last
last_tst
Lists
last_tst
Lists
lcons
Lazy datatypes
leaf
The tree datatype
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
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
listid
Left and right folding
ListPair
The ListPair structure
listrev
Left and right folding | Left and right folding
ListUtils
Representation independence and equality
long identifier
Scoping revisited
lookahead
see TextIO.lookahead
loop
Polymorphism

M

MacQueen, Dave
Reading material
map
The map function | Left and right folding
map_f
The map function
mapbody
Delaying evaluation
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
The tree datatype
member
List processing | Representation independence and equality
memberset
Abstract data types | Programming with abstract data | Signatures | Structures | Representation independence and equality
memo
Memoisation
memoisation
Memoisation
mf
Memoisation
Michaelson, Greg
Reading material
Milner, Robin
Reading material | Type inference | Evaluation
min
see Int.min
mindepth
The tree datatype
Mitchell, Kevin
Memoisation
mk_set
Programming with abstract data
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
Reading material
myset
Programming with abstract data

N

nats
Lazy datatypes
next
Lazy datatypes
nil
Defining datatypes
nodes
The tree datatype
NONE
The Bool structure | The Int structure | The Real structure | The String structure | Lists | The mapPartial function
notb
The Word and Word8
nth
Selecting from a list | see List.nth
null
see List.null | Abstract data types
null_eq
List processing
nullary constructors
Defining datatypes

O

o
Function composition
odd
Defining datatypes
ones
Lazy datatypes
oneszeroes
Lazy datatypes
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
Types, values and functions
ordered
Default overloading
ordered_set
Programming with abstract data
output
see TextIO.output
outstream
see TextIO.outstream
Overflow
Lists | Selecting from a list | The take function
overloading
Default overloading

P

pair
Polymorphism
paren
Polymorphism
path
The tree datatype
pattern matching
Higher-order programming | Defining a function by
wild card
Higher-order programming
Paulson, Larry
Reading material
perfectly balanced
The tree datatype
perm
Sorting lists
person
Function types and type
polymorphic
Polymorphism
Poon, Ellen
Reading material
postorder
Converting trees to lists
prefix
Sorting lists
preorder
Converting trees to lists

R

radix
Scoping revisited
raised
Lists
rap
Type safety conditions
Reade, Chris
Reading material
real
Types, values and functions | Scope | The Real structure | The Word and Word8 structures
Real.ceil
The Real structure
Real.floor
Scope | The Real structure
Real.fmt
The Real structure
Real.fromInt
Scope | The Real structure
Real.round
The Real structure
Real.trunc
The Real structure
records
Pairs and record types
red
Defining datatypes
reduce
Higher-order functions | Derived forms
ref
References | Implementing type safety
references
References
Retrieve
List processing
rev
Lists | see List.rev | Implementing type safety
revAppend
Lists | see List.revAppend

S

same
Higher-order programming
set
Function types and type | Abstract data types | Programming with abstract data | Signatures | Structures | Representation independence and equality
Set.addset
Structures
Set.emptyset
Structures
Set.memberset
Structures
Set.set
Structures
sin
see Math.sin
singleton
Sorting lists
size
Types, values and functions
SML basis
Simple applicative programming
SML library
Simple applicative programming
snd
Polymorphism
Sokolowski, Stefan
Reading material
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
Types, values and functions
strict
Derived forms
string
Types, values and functions | Scoping revisited | The String structure | Input/output
String.concat
The String structure
String.extract
The String structure
String.fields
The String structure
String.sub
The String structure | Function types and type
String.substring
The String structure
String.tokens
The String structure
String.translate
The String structure
StringCvt
The Int structure | The StringCvt structure
StringCvt.BIN
The Int structure
StringCvt.DEC
The Int structure
StringCvt.FIX
The Real structure
StringCvt.GEN
The Real structure
StringCvt.HEX
The Int structure
StringCvt.OCT
The Int structure
StringCvt.padLeft
The StringCvt structure
StringCvt.padRight
The StringCvt structure
StringCvt.SCI
The Real structure
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
Function types and type
succ
Types, values and functions | Derived forms
successor function
Types, values and functions | Curried functions
sum
Recursion
surname
Function types and type
syntactic sugar
Derived forms

T

tail
Lazy datatypes
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
Lazy datatypes
tentimes
Lazy datatypes
tester
Lists
testing
Recursion
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
Lists
Tofte, Mads
Reading material | Ill-typed functions | Implementing type safety
tokeniser
The String structure
traffic_light
Defining datatypes
traversal
inorder
Converting trees to lists
postorder
Converting trees to lists
preorder
Converting trees to lists
traversal strategies
Converting trees to lists
tree
Defining datatypes | The tree datatype | Converting trees to lists
true
Types, values and functions | Programming with abstract data
ttree
Defining datatypes
twice
Curried functions
type coercions
Types, values and functions
type inference
Types and type inference
type variable
Function types and type

U

Ullman, Jeffrey
Reading material
uncurry
Curried functions
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
Reading material
word
Types, values and functions | The Word and Word8 structures
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
Higher-order programming
wrong_exp
Higher-order programming

X

xorb
The Word and Word8

Z

zc
Scope
zeller
Scope | Scoping revisited
Zeller's congruence
Scope

A· B· C· D· E· F· G· H· I· K· L· M· N· O· P· R· S· T· U· V· W· X· Z

CORE KEYWORDS · MODULES KEYWORDS · LIBRARY UNITS

NEXT ·  UP ·  PREVIOUS ·  CONTENTS