The Standard ML Basis Library

The `General` structure

The structure General defines exceptions, datatypes and functions that are used throughout the SML Basis Library, and that are useful in a wide range of programs.

All of the types and values defined in General are available unqualified at the top-level.

Synopsis

signature GENERAL structure General : GENERAL

Interface

eqtype unit type exn exception Bind exception Chr exception Div exception Domain exception Fail of string exception Match exception Overflow exception Size exception Span exception Subscript val exnName : exn -> string val exnMessage : exn -> string datatype order = LESS | EQUAL | GREATER val ! : 'a ref -> 'a val := : ('a ref * 'a) -> unit val o : (('b -> 'c) * ('a -> 'b)) -> 'a -> 'c val before : ('a * unit) -> 'a val ignore : 'a -> unit

Description

eqtype unit

The type containing a single value denoted (), which is typically used as a trivial argument or as a return value for a side-effecting function.

type exn

The type of values transmitted when an exception is raised and handled. This type is special in that it behaves like a datatype with an extensible set of data constructors, where new constructors are created by exception declarations.

exception Bind

indicates that pattern matching failed in a val binding.

exception Chr

indicates an attempt to create a character with a code outside the range supported by the underlying character type.

exception Div

indicates an attempt to divide by zero. (Replaces the Mod exception required by the Definition).

exception Domain

indicates that the argument of a mathematical function is outside the domain of the function. Raised by functions in structures matching the MATH or INT_INF signatures. (Replaces the Sqrt and Ln exceptions required by the Definition).

exception Fail

A general-purpose exception to signify the failure of an operation. Not raised by any function built into the SML Standard Library.

exception Match

indicates that pattern matching failed in a case expression or function application.

exception Overflow

indicates that the result of an arithmetic function is not representable, e.g., is too large. (Replaces the Abs, Exp, Neg, Prod, Quot, and Sum exceptions required by the Definition).

exception Size

indicates an attempt to create an aggregate data structure (such as an array, string or vector) whose size is too large or negative.

exception Span

indicates an attempt to apply SUBSTRING.span to two incompatible substrings.

exception Subscript

indicates that an index is out of range, typically arising when the program is accessing an element in an aggregate data structure (such as a list, string, array or vector).

exnName ex

returns a name for the exception ex. The name returned may be that of any exception constructor aliasing with ex. For instance, let exception E1; exception E2 = E1 in exnName E2 end might evaluate to "E1" or "E2".

exnMessage ex

returns a message corresponding to exception ex. The precise format of the message may vary between implementations and locales, but will at least contain the string exnName ex.

Example:

exnMessage Div = "Div"
exnMessage (OS.SysErr ("No such file or directory", NONE)) = 
  "OS.SysErr \"No such file or directory\""

datatype order

Values of type order are used when comparing elements of a type that has a linear ordering.

! re

returns the value referred to by the reference re.

re := a

makes the reference re refer to the value a.

f o g

is the function composition of f and g. Thus, (f o g) a is equivalent to f(g a).

a before b

returns a. It provides a notational shorthand for evaluating a, then b, before returning the value of a.

ignore a

returns (). The purpose of ignore is to discard the result of a computation, returning () instead. This is useful, for example, when a higher-order function, such as List.app, requires a function returning unit, but the function to be used returns values of some other type.

Discussion

Some systems may provide a compatibility mode in which the replaced exceptions (e.g., Abs, Sqrt) are provided at top-level as aliases for the new exceptions.