Chapter 26: The base library domains

26.1 : Array S

Description:
`Array(S)' is the domain of mono-dimensional arrays over S. The arrays are 1-based, i.e. if `v' is an array then `v.1' is its first element. See also `ArrayCategory'.

Parameter:

• S: BasicType

Returns:

• ArrayCategory(S) with exports

Categories satisfied:
Aggregate(S), ArrayCategory(S), BasicType, FiniteAggregate(S), FiniteLinearAggregate(S), LinearAggregate(S)

Cascaded exports: S

Exports:

• array : Tuple(S) -> %
  `array(t)' creates an array from a tuple.
• array : Generator(S) -> %
  `array(g)' creates an array from a generator.
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• # : % -> SingleInteger from FiniteAggregate(S)
• empty! : % -> ()
  `empty!(v)' resets `v' to have no elements.
• extend! : (%, S) -> ()
  `extend!(v,s)' adds the element `s' to the end of `v'.
• new : (SingleInteger, S) -> %
  `new(n,s)' creates a new array with `n' elements, each initialized to `s'.
• set! : (%, SingleInteger, S) -> S from ArrayCategory
• dispose! : % -> () from ArrayCategory
• empty? : % -> Boolean from Aggregate(S)
• generator : % -> Generator(S) from Aggregate(S)
• map : (S -> S, %) -> % from Aggregate(S)
• empty : () -> % from LinearAggregate(S)
• bracket : Generator(S) -> % from LinearAggregate(S)
• bracket : Tuple(S) -> % from LinearAggregate(S)
• map : ((S, S) -> S, %, %) -> % from LinearAggregate(S)
• apply : (%, SingleInteger) -> S from LinearAggregate(S)
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.2 : BinaryPowering(T, *, E)

Description:
`BinaryPowering' provides efficient exponentiation in a general setting. For mutable data-structures, an in-place method is obtained by giving a multiplication which updates its first argument.

Parameters:

• T: Type

• *: (T,T) -> T

• E: with {
  0: %;
  1: %;
  integer: Literal -> %;
  length: % -> SingleInteger;
  bit: (%, SingleInteger) -> Boolean;
  =: (%, %) -> Boolean;
  }

Returns:

• with exports

Exports:

• power : (T, T, E) -> T
  `power(u,x,n)' computes `u*x^n'. If desired, `*' is permitted to update its first argument to contain the product. In this case `x' is modified, and `u' is updated to contain the final result.

26.3 : Boolean

Description:
The Boolean datatype supports logical operations. Both arguments of the binary operations are always evaluated.

Returns:

• Join(Conditional, Logic, OrderedFinite) with exports

Categories satisfied:
BasicType, Conditional, Finite, Logic, Order, OrderedFinite

Exports:

• false : %
• true : %
  false is the constant representing logical falsity. true is the constant representing logical truth.
• coerce : (Bool$Machine) -> %
• coerce : % -> (Bool$Machine)
  Cast from and to the internal builtin representation.
• /\ : (%, %) -> % from Logic
• \/ : (%, %) -> % from Logic
  Logical `and' and `or' operations. Note that both the arguments are evaluated.
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• ~ : % -> % from Logic
• # : Integer
  Number of elements in the domain. In this case, 2.
• test : % -> Boolean from Conditional
• > : (%, %) -> Boolean
• < : (%, %) -> Boolean
• >= : (%, %) -> Boolean
• <= : (%, %) -> Boolean
• <,>,>=, <= : (%, %) -> Boolean from Order
• <,>,>=, <= : (%, %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Boolean from Order
• min, max : % from OrderedFinite
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.4 : Byte

Description:
Byte implements single byte integers, typically 8 bits.

Returns:

• Join(Logic, OrderedFinite, OrderedRing)

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, Finite, Logic, Monoid, Order, OrderedAbelianGroup, OrderedAbelianMonoid, OrderedFinite, OrderedRing, Ring

Exports:

• coerce : (XByte$Machine) -> %
• coerce : % -> (XByte$Machine)
• coerce : Integer -> % from ArithmeticSystem
• coerce : SingleInteger -> % from ArithmeticSystem
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• ~ : % -> % from Logic
• /\ : (%, %) -> % from Logic
• \/ : (%, %) -> % from Logic
• # : Integer from Finite
• <,>,>=, <= : (%, %) -> Boolean from Order
• <,>,>=, <= : (%, %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Boolean from Order
• min, max : % from OrderedFinite
• 0 : % from AbelianMonoid
• 1 : % from ArithmeticSystem
• + : % -> % from AbelianMonoid
• + : (%, %) -> % from AbelianMonoid
• - : % -> % from AbelianGroup
• - : (%, %) -> % from AbelianGroup
• * : (%, %) -> % from ArithmeticSystem
• ^ : (%, Integer) -> % from ArithmeticSystem
• zero? : % -> Boolean from AbelianMonoid
• negative? : % -> Boolean from OrderedRing
• positive? : % -> Boolean from OrderedRing
• abs : % -> % from OrderedRing
• sign : % -> % from OrderedRing
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.5 : Character

Description:
Characters for natural language text. In the portable byte code files, characters are represented in ASCII. In a running program, characters are represented according to the machine's native character set, e.g. ASCII or EBCDIC.

Returns:

• OrderedFinite with exports

Categories satisfied:
BasicType, Finite, Order, OrderedFinite

Exports:

• char : String -> %
  `char(s)' returns the character corresponding to the first letter of `s'.
• char : SingleInteger -> %
  `char(s)' returns the character whose code is `s', e.g.~the letter `a' has code 97.
• coerce : (Char$Machine) -> %
• coerce : % -> (Char$Machine)
  Coerce from and to the internal builtin representation
• ord : % -> SingleInteger
  `ord(s)' returns the code for character `s'.
• =, ~= : (%, %) -> Boolean from BasicType
• space, newline : %
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• digit? : % -> Boolean
• letter? : % -> Boolean
  `digit?(c)' returns true if and only if `c' is in 0..9. `letter?(c)' returns true if and only if `c' is in a..z or in A..Z.
• lower : % -> %
• upper : % -> %
  `lower(c)' returns the corresponding lower case letter if `c' is an upper case letter, otherwise `c'.
  `upper(c)' returns the corresponding upper case letter if `c' is a lower case letter, otherwise `c'.
  
• # : Integer from Finite
• <,>,>=, <= : (%, %) -> Boolean from Order
• <,>,>=, <= : (%, %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Boolean from Order
• min, max : % from OrderedFinite
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.6 : CommandLine

Description:
`CommandLine' provides the operations to access the command line arguments to a program.

Returns:

• with exports

Exports:

• command : String
• arguments : Array(String)

26.7 : Complex R

Description:
Complex(R) implements complex numbers over a field, `R'. Domains created by the constructor are fields and implement additional operations to manipulate the real and imaginary parts of complex numbers.

Parameter:

• R: Field

Returns:

• Field with exports

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, EuclideanDomain, Field, Group, Monoid, Ring

Cascaded exports: R

Exports:

• complex : (R, R) -> %
  `complex(r, i)' creates a complex number with real part `r' and imaginary part `i'.
• real : % -> R
• imag : % -> R
  `real(c)' returns the real part of the complex number `c'. `imag(c)' returns the imaginary part of the complex number `c'.
• coerce : R -> %
• coerce : Integer -> % from ArithmeticSystem
• coerce : SingleInteger -> % from ArithmeticSystem
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• * : (R, %) -> %
  `r * c' is the product of the real number `r' and the complex number `c'.
• * : (%, R) -> %
  `c * r' is the product of the complex number `c' and the real number `r'.
• / : (%, R) -> %
  `c / r' is the quotient of the complex number `c' and the real number `r'.
• %i : %
  `%i' is the literal constant `i = complex(0,1)'.
• norm : % -> R
  `norm(c)' computes the algebraic norm of `c'. This is `real(c)^2 + imag(c)^2'.
• conjugate : % -> %
  `conjugate(c)' returns the complex conjugate of the complex number `c'.
• 0 : % from ArithmeticSystem
• 1 : % from ArithmeticSystem
• + : % -> % from ArithmeticSystem
• + : (%, %) -> % from ArithmeticSystem
• - : % -> % from ArithmeticSystem
• - : (%, %) -> % from ArithmeticSystem
• * : (%, %) -> % from ArithmeticSystem
• ^ : (%, Integer) -> % from ArithmeticSystem
• / : (%, %) -> % from Group
• \ : (%, %) -> % from Group
• zero? : % -> Boolean from AbelianMonoid
• gcd : (%, %) -> % from EuclideanDomain
• quo : (%, %) -> % from EuclideanDomain
• rem : (%, %) -> % from EuclideanDomain
• divide : (%, %) -> (%, %) from EuclideanDomain
• inv : % -> % from Group
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.8 : DoubleFloat

Description:
`DoubleFloat' implements double-precision floating point numbers. In the portable byte code files, double precision floats are represented in a format capable of representing IEEE extended double precision. In a running program, double precision floats are represented according to the machine's native arithmetic.

Returns:

• Join(OrderedFinite, FloatingPointNumberSystem) with exports

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, EuclideanDomain, Field, Finite, FloatingPointNumberSystem, Group, Monoid, Order, OrderedAbelianGroup, OrderedAbelianMonoid, OrderedFinite, OrderedRing, Ring

Cascaded exports: RoundingMode

Exports:

• float : Literal -> % from FloatingPointNumberSystem
• step : SingleInteger -> (%, %) -> Generator(%) from FloatingPointNumberSystem
• coerce : (DFlo$Machine) -> %
• coerce : % -> (DFlo$Machine)
  Coerce from and to the internal builtin representation
• coerce : Integer -> % from ArithmeticSystem
• coerce : SingleInteger -> % from ArithmeticSystem
• integer : % -> Integer from FloatingPointNumberSystem
• fraction : % -> % from FloatingPointNumberSystem
• round : (%, RoundingMode) -> Integer from FloatingPointNumberSystem
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• # : Integer from Finite
• 0 : % from AbelianMonoid
• 1 : % from ArithmeticSystem
• + : % -> % from AbelianMonoid
• + : (%, %) -> % from AbelianMonoid
• - : % -> % from AbelianGroup
• - : (%, %) -> % from AbelianGroup
• * : (%, %) -> % from ArithmeticSystem
• ^ : (%, Integer) -> % from ArithmeticSystem
• / : (%, %) -> % from Group
• \ : (%, %) -> % from Group
• <,>,>=, <= : (%, %) -> Boolean from Order
• <,>,>=, <= : (%, %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Boolean from Order
• << : (%, %) -> Boolean from FloatingPointNumberSystem
• >> : (%, %) -> Boolean from FloatingPointNumberSystem
• min, max : % from OrderedFinite
• zero? : % -> Boolean from AbelianMonoid
• negative? : % -> Boolean from OrderedRing
• positive? : % -> Boolean from OrderedRing
• abs : % -> % from OrderedRing
• sign : % -> % from OrderedRing
• gcd : (%, %) -> % from EuclideanDomain
• quo : (%, %) -> % from EuclideanDomain
• rem : (%, %) -> % from EuclideanDomain
• divide : (%, %) -> (%, %) from EuclideanDomain
• inv : % -> % from Group
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.9 : DoubleFloatElementaryFunctions

Description:
`DoubleFloatElementaryFunctions' provides elementary functions for `DoubleFloat'.

Returns:

• with exports

Exports:

• sqrt : DoubleFloat -> DoubleFloat
• sqrt : Complex(DoubleFloat) -> Complex(DoubleFloat)
• ^ : (DoubleFloat, DoubleFloat) -> DoubleFloat
• ^ : (Complex(DoubleFloat), Complex(DoubleFloat)) -> Complex(DoubleFloat)
• log : DoubleFloat -> DoubleFloat
• log : (DoubleFloat, DoubleFloat) -> DoubleFloat
• log : Complex(DoubleFloat) -> Complex(DoubleFloat)
• log : (Complex(DoubleFloat),Complex(DoubleFloat)) -> Complex(DoubleFloat)
• exp : DoubleFloat -> DoubleFloat
• exp : Complex(DoubleFloat) -> Complex(DoubleFloat)
• sin, cos, tan : DoubleFloat -> DoubleFloat
• sin, cos, tan : Complex(DoubleFloat) -> Complex(DoubleFloat)
• sinh, cosh, tanh : DoubleFloat -> DoubleFloat
• sinh, cosh, tanh : Complex(DoubleFloat) -> Complex(DoubleFloat)
• asin, acos, atan : DoubleFloat -> DoubleFloat
• asin, acos, atan : Complex(DoubleFloat) -> Complex(DoubleFloat)
• asinh, acosh, atanh : DoubleFloat -> DoubleFloat
• asinh, acosh, atanh : Complex(DoubleFloat) -> Complex(DoubleFloat)
• atan : (DoubleFloat, DoubleFloat) -> DoubleFloat
• abs : Complex(DoubleFloat) -> DoubleFloat
• phase : Complex(DoubleFloat) -> DoubleFloat

26.10 : FileName

Description:
`FileName' provides a set of operations for portable file name manipulation. Generally used with the operations exported by `InFile' and `OutFile'.

Returns:

• BasicType with exports

Exports:

• filename : String -> %
• filename : (String, String, String) -> %
  `filename(dir,name,type)' creates a complete filename (i.e. including the directory path) where `dir' is the directory path, `name' is the name of the file and `type' is it's extension. Example:

   filename("/usr/include", "stdio", "h")
  

  refers to the file ``/usr/include/stdio.h''.
• dir : % -> String
• name : % -> String
• type : % -> String
  Given an object of type filename, access to its directory, name or type component.
• unparse : % -> String
  `unparse(fn)' return the string corresponding to the filename `fn'.
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.11 : Float

Description:
`Float' implements arbitrary precision floating point arithmetic. The number of significant digits of each operation can be set to an arbitrary value (the default is 20 decimal digits).
The operation `float(significand, exponent, base)' for integer `significand', `exponent' specifies the number `significand * base <sup>(exponent)</sup>'. The underlying representation for floats is binary not decimal. The implications of this are described below.
The model adopted is that arithmetic operations are rounded to the nearest unit in the last place, that is, accurate to within `2^(-bits)'. Also, the elementary functions and constants are accurate to one unit in the last place. A float is represented as a record of two integers, the significand and the exponent. The base of the representation is binary, hence a `Record(m: significand, e: exponent)' represents the number `m * 2^e'. Though it is not assumed that the underlying integers are represented with a binary base, the code will be most efficient when this is the the case. The decision to choose the base to be binary has some unfortunate consequences. First, decimal numbers like 0.3 cannot be represented exactly. Second, there is a further loss of accuracy during conversion to decimal for output. To compensate for this, if d digits of precision are specified, `1 + ceiling(log₂ d)' bits are used. Two numbers that are displayed identically may therefore not in fact be equal. On the other hand, a significant efficiency loss would be incurred if we chose to use a decimal base when the underlying integer base is binary.

Returns:

• Join(OrderedRing, Field) with exports

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, EuclideanDomain, Field, Group, Monoid, Order, OrderedAbelianGroup, OrderedAbelianMonoid, OrderedRing, Ring

Cascaded exports: RoundingMode

Exports:

• float : Literal -> % from FloatingPointNumberSystem
• step : SingleInteger -> (%, %) -> Generator(%) from FloatingPointNumberSystem
• makeFloat : Integer -> %
• makeFloat : SingleInteger -> %
• integer : % -> Integer
• fraction : % -> %
  `integer(f)' returns the integer part of `f'. `fraction(f)' returns the fractional part of `f' as a float.
• round : (%, mode: RoundingMode == nearest()) -> Integer
• coerce : Integer -> %
• coerce : SingleInteger -> %
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• 0 : % from AbelianMonoid
• 1 : % from ArithmeticSystem
• + : % -> % from AbelianMonoid
• + : (%, %) -> % from AbelianMonoid
• - : % -> % from AbelianGroup
• - : (%, %) -> % from AbelianGroup
• exponent, significand : % -> Integer
• <,>,>=, <= : (%, %) -> Boolean from Order
• <,>,>=, <= : (%, %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Boolean from Order
• min, max : (%, %) -> % from Order
• zero? : % -> Boolean from AbelianMonoid
• one? : % -> Boolean
• * : (%, %) -> % from ArithmeticSystem
• ^ : (%, Integer) -> % from ArithmeticSystem
• abs : % -> % from OrderedRing
• sign : % -> % from OrderedRing
• negative?, positive? : % -> Boolean from OrderedRing
• gcd : (%, %) -> % from EuclideanDomain
• quo, rem : (%, %) -> % from EuclideanDomain
• divide : (%, %) -> (%, %) from EuclideanDomain
• / : (%, %) -> % from Group
• \ : (%, %) -> % from Group
• inv : % -> % from Group
• decreasePrecision, increasePrecision : Integer -> Integer
• bits : () -> Integer
  `bits()' returns the current precision in bits.
• bits : Integer -> Integer
  `bits(n)' sets the current precision to `n' bits.
• sqrt : % -> %
• / : (%, Integer) -> %
• ^ : (%, %) -> %
• normalize : % -> %
  `normalize(f)' normalizes `f' at the current precision.
• relerror : (%, %) -> Integer
  `relerror(x,y)' computes the absolute value of `(x-y)/y' when `y' is non-zero.
• atan : (%, %) -> %
• atan : % -> %
• acos : % -> %
• sin, cos, tan : % -> %
• pi : () -> %
• exp : % -> %
• exp1 : () -> %
• log, log2, log10 : % -> %
• log2, log10 : () -> %
• outputFloating : () -> ()
  `outputFloating()' sets the output mode to floating (scientific) notation, i.e. `mantissa * 10 exponent' is displayed as `0.mantissa E exponent'.
• outputFloating : Integer -> ()
  `outputFloating(n)' sets the output mode to floating (scientific) notation with `n' significant digits displayed after the decimal point.
• outputFixed : () -> ()
  `outputFixed()' sets the output mode to fixed point notation; the output will contain a decimal point.
• outputFixed : Integer -> ()
  `outputFixed(n)' sets the output mode to fixed point notation, with `n' digits displayed after the decimal point.
• outputGeneral : () -> ()
  `outputGeneral()' sets the output mode (default mode) to general notation; numbers will be displayed in either fixed or floating (scientific) notation depending on the magnitude.
• outputGeneral : Integer -> ()
  `outputGeneral(n)' sets the output mode to general notation with `n' significant digits displayed.
• outputSpacing : SingleInteger -> ()
  `outputSpacing(n) 'inserts a space after `n' (default 10) digits on output; `outputSpacing(0)' means no spaces are inserted.
• digits : () -> Integer
  `digits()' returns the current precision in decimal digits.
• digits : Integer -> Integer
  `digits(n)' sets the current precision to `n' decimal digits.
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.12 : Format

Description:
`Format' provides the basic operation for conversion of numbers to and from strings.

Returns:

• with exports

Exports:

• format : (SingleFloat, String, SingleInteger) -> SingleInteger
• format : (DoubleFloat, String, SingleInteger) -> SingleInteger
• format : (SingleInteger, String, SingleInteger) -> SingleInteger
• format : (Integer, String, SingleInteger) -> SingleInteger
  `format(n,s,i)' convert `n' into a string and write the result in `s' starting at position `i'. The return value is the new length of the string plus 1. Note that strings are 1-based.
• scan : (String, SingleInteger) -> (SingleFloat, SingleInteger)
• scan : (String, SingleInteger) -> (DoubleFloat, SingleInteger)
• scan : (String, SingleInteger) -> (SingleInteger, SingleInteger)
• scan : (String, SingleInteger) -> (Integer, SingleInteger)
  `scan(s,n)' returns the object of the appropriate type contained in `s' starting at position `n'.

26.13 : FormattedOutput

Description:
`FormattedOutput' provides functions which format their arguments according to a control string. The control characters are:

• "~n" put a newline.
• "~~" put a `~' character.
• "~ia" put the ith argument.
• "~a" put the next argument.
• "~1",...,"~9" shorthand for "~1a",...,"~9a"

Returns:

• with exports

Exports:

• print : (String,TextWriter == print) -> Tuple(TextWriter -> TextWriter) -> TextWriter
• count : (String, TextWriter == sink()) -> Tuple(TextWriter -> TextWriter) -> SingleInteger
• string : String -> Tuple(TextWriter -> TextWriter) -> String
  `string "format-string" (<< a, << b)' creates a new string which contains `a' and `b', formatted according to `format-string'.

26.14 : Generator T

Description:
`Generator(T)' is a type which allows `T' values to be obtained serially in a `repeat' or `collect' form. This is an "extend" of the language-defined Generator.

Parameter:

• T: Type

Returns:

• with exports

Cascaded exports: T

Exports:

• step! : % -> %
  `step!(I)' runs the generator function, updating its environment.
• empty? : % -> Boolean
  `empty?(I)' tests whether there are any values remaining. This can be tested after calling `step!'.
• value : % -> T
  `value(I)' returns the next value in the generator and is valid if not `empty?(I)', and `step!' has been called at least once.
• bound : % -> SingleInteger
  An upper bound on the number of elements to be generated
• generator : % -> %
• generator : ()->(()->Boolean,()->(),()->T,()->SingleInteger) -> %
• generator : (()->Boolean,()->(),()->T,()->SingleInteger) -> %
  `generator(I)' is the identity function, allowing direct iteration. `generator(F)' is a primitive constructor for a generator. `generator(f1,f2,f3,f4)' creates a generator from its constituent functions.

26.15 : HalfInteger

Description:
`HalfInteger' implements half-precision integers, typically 16 bits.

Returns:

• Join(Logic, OrderedFinite, OrderedRing)

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, Finite, Logic, Monoid, Order, OrderedAbelianGroup, OrderedAbelianMonoid, OrderedFinite, OrderedRing, Ring

Exports:

• coerce : (HInt$Machine) -> %
• coerce : % -> (HInt$Machine)
  Coerce from and to the internal builtin representation
• coerce : Integer -> % from ArithmeticSystem
• coerce : SingleInteger -> % from ArithmeticSystem
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• ~ : % -> % from Logic
• /\ : (%, %) -> % from Logic
• \/ : (%, %) -> % from Logic
• # : Integer from Finite
• <,>,>=, <= : (%, %) -> Boolean from Order
• <,>,>=, <= : (%, %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Boolean from Order
• min, max : % from OrderedFinite
• 0 : % from AbelianMonoid
• 1 : % from ArithmeticSystem
• + : % -> % from AbelianMonoid
• + : (%, %) -> % from AbelianMonoid
• - : % -> % from AbelianGroup
• - : (%, %) -> % from AbelianGroup
• * : (%, %) -> % from ArithmeticSystem
• ^ : (%, Integer) -> % from ArithmeticSystem
• zero? : % -> Boolean from AbelianMonoid
• negative? : % -> Boolean from OrderedRing
• positive? : % -> Boolean from OrderedRing
• abs : % -> % from OrderedRing
• sign : % -> % from OrderedRing
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.16 : HashTable(Key, Value)

Description:
`HashTable(Key, Val)' provides a parameterized hash-table datatype.

Parameters:

• Key: BasicType

• Value: BasicType

Returns:

• BasicType with exports

Categories satisfied:
BasicType

Cascaded exports: Key, Value

Exports:

• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• table : () -> %
• table : ((Key, Key) -> Boolean, Key -> SingleInteger) -> %
  `table()' creates a new table using the equality test `=' and the hash function `hash' from the `Key' type. `table(=, hash)' creates a new hash table using the equality test `=' and the hash function `hash'.
• eqtable : () -> %
  `eqtable()' creates a new table using instance equality.
• copy : % -> %
  `copy(t)' creates a copy of the table `t'.
• # : % -> SingleInteger
  `#t' returns the number of elements in `t'.
• search : (%, Key, Value) -> (Boolean, Value)
  `(b,v) := search(t,k,d)' searches table `t' for the value associated with key `k'. If there is such a value, `vk', then `b' is set to `true' and `v' is set to `vk'. Otherwise `b' is `false' and `v' is set to `d'.
• apply : (%, Key) -> Value
  `t.k' searches the table `t' for the value associated with the key `k'. It is an error if there is no value for `k'.
• set! : (%, Key, Value) -> Value
  `t.k := val' associates `val' with `k' in `t'.
• drop! : (%, Key) -> Value
  `drop!(t, k)' removes the entry for `k' in `t'.
• dispose! : % -> ()
  `dispose! t' indicates a table will no longer be used.
• generator : % -> Generator(Cross(Key, Value))
  `generator(t)' is a generator which produces all the `(key, value)' pairs from `t'.
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.17 : InFile

Description:
`InFile' is the domain of input text files.

Returns:

• with exports

Exports:

• open : FileName -> %
• close : % -> ()
• open? : % -> Boolean
• readchar! : (%, eof: Character == char(0)) -> Character
  `readchar!(f, EOF)' returns the next character from the file `f'. If the end of file has been reached, then the character EOF is returned.
• readline! : % -> String
• readline! : (%,String,SingleInteger,SingleInteger)->SingleInteger
  `readline!(f)' reads a line from the given file and returns a new string containing it. The string will end with a newline character, unless the end of the file is reached without one. `readline!(f, s, start, limit)' reads characters from the file `f' into the portion of the string `s' lying in the range `start..limit-1'. The string `s' must have space for at least `limit' characters. The function places characters into the string until `limit' is reached, a newline is read, or the end of file is reached. The function returns the number of characters read, which will be `0' if the end of file has been reached.

26.18 : Integer

Description:
`Integer' provides operations for arbitrary precision (big) integer arithmetic.

Returns:

• Join(Steppable, IntegerNumberSystem) with exports

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, EuclideanDomain, IntegerNumberSystem, Monoid, Order, OrderedAbelianGroup, OrderedAbelianMonoid, OrderedRing, Ring, Steppable

Cascaded exports: Segment Integer

Exports:

• integer : Literal -> %
• coerce : SingleInteger -> %
• coerce : Integer -> % from ArithmeticSystem
• coerce : % -> (BInt$Machine)
• coerce : (BInt$Machine) -> %
  Coerce from and to the internal builtin representation
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• <,>,>=, <= : (%, %) -> Boolean from Order
• <,>,>=, <= : (%, %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Boolean from Order
• min,max : (%, %) -> % from Order
• 0 : % from AbelianMonoid
• 1 : % from ArithmeticSystem
• + : % -> % from AbelianMonoid
• + : (%, %) -> % from AbelianMonoid
• - : % -> % from AbelianGroup
• - : (%, %) -> % from AbelianGroup
• * : (%, %) -> % from ArithmeticSystem
• ^ : (%, Integer) -> % from ArithmeticSystem
• zero? : % -> Boolean from AbelianMonoid
• negative? : % -> Boolean from OrderedRing
• positive? : % -> Boolean from OrderedRing
• even? : % -> Boolean from IntegerNumberSystem
• odd? : % -> Boolean from IntegerNumberSystem
• single? : % -> Boolean from IntegerNumberSystem
• prev : % -> % from IntegerNumberSystem
• next : % -> % from IntegerNumberSystem
• mod : (%, %) -> % from IntegerNumberSystem
• length : % -> SingleInteger from IntegerNumberSystem
• shift : (%, SingleInteger) -> % from IntegerNumberSystem
• bit : (%, SingleInteger) -> Boolean from IntegerNumberSystem
• retract : % -> SingleInteger from IntegerNumberSystem
• gcd : (%, %) -> % from EuclideanDomain
• quo : (%, %) -> % from EuclideanDomain
• rem : (%, %) -> % from EuclideanDomain
• divide : (%, %) -> (%, %) from EuclideanDomain
• stepsBetween : (%, %, %) -> SingleInteger from Steppable
• stepsBetween : (%, %) -> SingleInteger from Steppable
• abs : % -> % from OrderedRing
• sign : % -> % from OrderedRing
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.19 : IntegerMod(n)

Parameter:

• n: Integer

Returns:

• Ring with exports

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, Monoid, Ring
ModularIntegerNumberSystem

Exports:

• 0, 1 : % from ArithmeticSystem
• coerce : Integer -> %
• coerce : SingleInteger -> %
• integer : Literal -> %
• -, + : % -> % from ArithmeticSystem
• -, + : (%, %) -> % from ArithmeticSystem
• * : (%, %) -> % from ArithmeticSystem
• ^ : (%, Integer) -> % from ArithmeticSystem
• zero? : % -> Boolean from AbelianMonoid
• inv : % -> %
• / : (%, %) -> %
• lift : % -> Integer
  `lift(n)' transforms `n' into an `Integer'.
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.20 : List S

Description:
`List(S)' is the domain of linked lists.

Parameter:

• S: Type

Returns:

• ListCategory S

Categories satisfied:
Aggregate(S), BasicType, Conditional, FiniteAggregate(S), FiniteLinearAggregate(S), LinearAggregate(S), ListCategory(S)

Cascaded exports: 'first', 'rest'

Exports:

• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType
• empty? : % -> Boolean from Aggregate(S)
• generator : % -> Generator(S) from Aggregate(S)
• map : (S -> S, %) -> % from Aggregate(S)
• # : % -> SingleInteger from FiniteAggregate(S)
• empty : () -> % from LinearAggregate(S)
• bracket : Generator(S) -> % from LinearAggregate(S)
• bracket : Tuple(S) -> % from LinearAggregate(S)
• map : ((S, S) -> S, %, %) -> % from LinearAggregate(S)
• apply : (%, SingleInteger) -> S from LinearAggregate(S)
• test : % -> Boolean from Conditional
• nil : % from ListCategory(S)
• cons : (S, %) -> % from ListCategory(S)
• list : Tuple(S) -> % from ListCategory(S)
• list : Generator(S) -> % from ListCategory(S)
• first : % -> S from ListCategory(S)
• rest : % -> % from ListCategory(S)
• setFirst! : (%, S) -> S from ListCategory(S)
• setRest! : (%, %) -> % from ListCategory(S)
• apply : (%, 'first') -> S from ListCategory(S)
• apply : (%, 'rest') -> % from ListCategory(S)
• set! : (%, 'first'), S) -> S from ListCategory(S)
• set! : (%, 'rest', %) -> % from ListCategory(S)
• copy : % -> % from ListCategory(S)
• last : % -> S from ListCategory(S)
• reverse : % -> % from ListCategory(S)
• reverse! : % -> % from ListCategory(S)
• concat! : (%, %) -> % from ListCategory(S)
• concat : (%, %) -> % from ListCategory(S)
• reduce : ((S, S) -> S, %, S) -> S from ListCategory(S)
• member? : (S, %) -> Boolean from ListCategory(S)
• rest : (%, SingleInteger) -> % from ListCategory(S)
• tails : % -> Generator(%) from ListCategory(S)
• dispose! : % -> () from ListCategory(S)
• disposeHead! : % -> % from ListCategory(S)

26.21 : ListSort S

Description:
`ListSort(S)' provides functions to sort linked lists.

Parameter:

• S: BasicType

Returns:

• with exports

Exports:

• sort! : ((S, S) -> Boolean, List(S)) -> List(S)
• sort : ((S, S) -> Boolean, List(S)) -> List(S)

26.22 : ModularIntegerNumberRep(I)(n)

Description:
`ModularIntegerNumberRep(I)(n)' provides operations for modular integer arithmetic.

Parameters:

• I: IntegerNumberSystem

• n: I

Returns:

• with exports

Exports:

• 0, 1 : %
• integer : Literal -> %
• coerce : I -> %
• << : (TextWriter, %) -> TextWriter
• =, ~= : (%, %) -> Boolean
• + : % -> %
• + : (%, %) -> %
• - : % -> %
• - : (%, %) -> %
• zero? : % -> Boolean
• inv : % -> %
• lift : % -> I

26.23 : NumberScanPackage R

Parameter:

• R: with {
  {*}: (%, %) -> %;
  ^: (%, Integer) -> %;
  coerce: Integer -> %;
  }
  

Returns:

• with exports

Exports:

• scanNumber : String -> R
  `scanNumber(s)' reads a number of type `R' from `s' starting from the begining of `s'. If no such number exists then 0 (coerced into `R') is returned.

26.24 : Object C

Parameter:

• C: Category

Returns:

• with exports

Exports:

• object : (T: C, T) -> %
  `object(T, t)', where the type of `t' is `T', creates on object of the domain.
• avail : % -> (T: C, T)

26.25 : OperatingSystemInterface

Description:
`OperatingSystemInterface' provides a platform-independent method for accessing some operating system services, for example file and directory manipulation. This is a very low-level interface --- the functions avoid allocating storage and consequently are more complicated to use.

Returns:

• with exports

Exports:

• run : String -> SingleInteger
  Run the command given as a string argument. A return value of 0 indicates success.
• run : (String, Record(val:Pointer), Record(val:Pointer),Record(val:Pointer)) -> SingleInteger
  If possible, spawn an asynchronous process and communicate with it. The three reference parameters correspond the to stdin, stdout and stderr of the process. Suppose, e.g. foo is run by:

   run("foo", fin, fout, nil pretend Record(val:Pointer));
  

  Then anything written to fin becomes available to foo on its stdin and anything which foo writes to stdout can be read from fout. The last argument, nil, causes foo's stderr to remain uncaptured. A return code of 0 indicates success spawning. Failure gives -1. To determine whether the platform supports concurrent processes, call "run" with the command string `nil pretend String' or call the function "canRunConcurrent?".
• runQuoteWord : (String, Pointer) -> SingleInteger
  Quote a string to be a suitable word in a string to `run'. The characters of the result are delivered one by one to the functional argument. The return value is number of characters delivered. e.g.: On Unix the string ``$>$1ドル'' is converted to '$>$1ドル' and 5 is returned.
• cpuTime : () -> SingleInteger
  The time accounted to this process, in milliseconds. On systems where it counts, this is user time + system time.
• date : () -> String
  `date()' returns a static string containing a human-readable date. The exact format is system dependent.
• getenv : String -> String
  `getenv(``FOO'')' gets the value for the name "FOO" from the environment. The resulting string is owned by the environment and later calls may modify it and you must not.
• putenv : String -> SingleInteger
  `putenv(``FOO=xxx'')' sets the string associated with the name "FOO". The string might be modified by the `putenv' call. A result of -1 indicates failure, 0 success.
• putenvIsKept? : () -> Boolean
  `putenvIsKept?()' returns true iff a call to putenv causes its argument to become owned by the environment. If so, a program should not then update or free it.
• ioRdMode : String
• ioWrMode : String
• ioApMode : String
• ioRbMode : String
• ioWbMode : String
• ioAbMode : String
• ioRubMode : String
• ioWubMode : String
• ioAubMode : String
• objectFileType : String
• execFileType : String
• curDirName : () -> String
  Current directory name, that doesn't change as the program executes and moves around.
• tmpDirName : () -> String
  Temporary directory name, that doesn't change as the program executes and moves around.
• fnameDirEqual : (String, String) -> Boolean
  `fnameDirEqual(d1,d2)' determines whether d1 and d2 are equal as directories. For example on Unix "foo/." is considered equal to "foo".
• subdir : (String, String, String) -> ()
  `subdir(buf,relativeTo,subdir)' place the name of a subdirectory of ``relativeTo''. This may or may not be disctinct from the original, e.g. on DOS subdir("c:\foo","bar") would be "c:\foo\bar" while on CMS subDir("A", "lib") would be "A".
• subdirLength : (String, String) -> SingleInteger
  `subdirLength(relativeTo,subdir)' determine the number of characters needed for the subdirectory name.
• fnameNParts : SingleInteger
  `fnameNParts(n)' is the number of parts file names have on this platform. This number is $>=$ 3 and the meaning of parts 1..3 are fixed: partv.1 = directory, partv.2 = name, partv.3 = extension. On some platforms additional parts, such as version numbers or host names, may be part of the name.
• fnameParse : (PrimitiveArray(String),String,String,String) -> ()
  `fnameParse(partv,buffer,fname,relativeTo)' The argument `partv' must have `fnameNParts()' slots. The size required for `buffer' can be found by `fnameParseSize'. The argument `relativeTo' may be 0, which means either that the name is relative to the current directory or that the name is absolute.
• fnameParseSize : (String, String) -> SingleInteger
  `fnameParseSize(fname, relativeto)' determines how many characters are needed for the buffer to parse a file name (including trailing 0s, etc).
• fnameUnparse : (String, PrimitiveArray(String), Boolean) -> String
  `fnameUnparse(b,pv,f)' fills the buffer `b' with a file name having the operating system's syntax. If `f' is true, then the full name is used, instead of using current directory conventions.
• fnameUnparseSize : (PrimitiveArray(String), Boolean) -> SingleInteger
  `fnameUnparseSize(pv,f)' determines how many characters are needed to unparse a file name (including trailing 0, etc). If `f' is true, then the full name is used, instead of using current directory conventions.
• fnameTempSeed : () -> SingleInteger
  `fnameTempSeed()' returns a process seed for contructing temporary file names.
• fnameTempDir : String -> String
  `fnameTempDir(r)' returns a directory name for temporary files relative to `r'.
• interactive? : Pointer -> Boolean
  `interactive?(p)' determines whether an input stream is interactive, e.g. a keyboard.
• fileRemove : String -> SingleInteger
• fileRename : (String, String) -> SingleInteger
• fileExists? : String -> Boolean
  `fileRemove(s)' and `fileRename(s1,s2) return 0 on success, -1 on error. `fileExists?(s)' tests whether the file exists.
• fileHash : String -> SingleInteger
• fileSize : String -> SingleInteger
• dirExists? : String -> Boolean
  `dirExists?(s)' tests whether the directory `s' exists.
• dirSwap : (String, String, SingleInteger) -> SingleInteger
  `dirSwap(newwd,oldwd,oldwdlen)' changes the current directory. If the String `oldwd' is non-null, then the string is filled with the name of the original directory. This name can then be used to swap back or to form file names relative to the original directory. Returns 0 on success and -1 on failure.
• includePath : () -> String
  `includePath()' returns a list of directories searched for include files. The result may be volatile.
• libraryPath : () -> String
  `libraryPath()' returns a list of directories searched for object files. The result may be volatile.
• executePath : () -> String
  `executePath()' returns a list of directories searched for executable programs. The result may be volatile.
• pathLength : String -> SingleInteger
  `pathLength(path)' returns the number of directory names in `path'.
• pathParse : (PrimitiveArray(String), String, String) -> ()
  `pathParse(partv,buffer,path)' splits path into its constituent directories, using space from `buffer', and placing the String pointers in `partv'.
• setBreakHandler : Pointer -> Pointer
  `setBreakHandler(f)' sets the handler for interactive interrupts, e.g. user breaks generated from the terminal.
• setFaultHandler : Pointer -> Pointer
  `setFaultHandler(f)' sets the handler for faults which normally cause the program to terminate, e.g. illegal instruction or segmentation faults.
• setLimitHandler : Pointer -> Pointer
  `setLimitHandler(f)' sets the handler for interrupts which arise when resource limits are exceeded, e.g. cpu or file size limits. In each case, the default handler can be reinstated by passing a null function pointer. The previous handler (or null for default) is returned.
• setDangerHandler : Pointer -> Pointer
  `setDangerHandler(f)' sets the handler for ``DANGER'' signals which arise when some resource such as paging space is getting critically low, and the process is about to be killed. Not all platforms support such signals.
• alloc : Record(val: SingleInteger) -> Pointer
  `alloc(val)' gets more dynamic storage from the operating system. This function should be called only occasionally to get large pieces of memory. The return value is an appropriately aligned pointer to the low address of the new store. The argument is updated to contain the number of bytes actually obtained. On failure, a null pointer and byte count of zero are returned.
• release : Pointer -> ()
  `release(p)' gives back store obtained from `alloc'.
• allocAlignHint : SingleInteger -> ()
  `allocAlignHint(n)' provides the low-level allocation code with a hint about the desired alignment. Subsequent allocations will be aligned to multiples of this quantity, if convenient.
• allocShow : () -> ()
  `allocShow()', in some implementations, provides detailed information about the low-level storage use. For implementations where this information is not available the call does nothing.
• memMap : SingleInteger -> PrimitiveArray(Pointer)
  %`memMap(n)' returns a pointer to a static array containing a %map of memory at the time it was called. %% Avoiding overlength line: `memMap(n)' returns a pointer to a static array, which contains a map of memory at the time "memMap" was called. The array is terminated by an element of class MEM_END (see below). Each element of the array, `e', is a structure indicating that the address range `[e.lo, e.hi)' is used for `e.use'. On some platforms it is not possible to distinguish the classes MEM_IDATA/MEM_DDATA. In these cases it is all counted as MEM_DDATA. The argument to "memMap" is a mask indicating the uses to report. If the information is not available the pointer 0 is returned.
  • MEM_IDATA 1 -- initial static data.
  • MEM_DDATA 2 -- dynamic data, e.g. from sbrk malloc.
  • MEM_STACK 4 -- call-stack.
  • MEM_END 0 -- end.

26.26 : OutFile

Description:
`OutFile' is the domain of output text files.

Returns:

• with exports

Exports:

• open : FileName -> %
• open? : % -> Boolean
• close : % -> ()
• write! : (%, Character) -> ()
• write! : (%, String, start: SingleInteger == 1, limit: SingleInteger == 0) -> SingleInteger
  `write(f,c)' write the character `c' to the file `f'. `write(f,s,start,limit)' writes the portion of the `s' lying in the range `start..limit-1' to the file `f'. A limit of `0' means to write everything up to the end of `s'. The number of characters written is returned.

26.27 : Partial T

Description:
`Partial' is a type which allows values of soft failures to be returned.

Parameter:

• T: Type

Returns:

• with exports

Exports:

• failed : %
• failed? : % -> Boolean
• coerce : T -> %
• coerce : % -> T
• retract : % -> T
• bracket : T -> %
• case : (%, String) -> Boolean
• case : (%, Type) -> Boolean
  Needed to support the old syntax for `Union(%, "failed")'.

26.28 : Pointer

Description:
`Pointer' provides basic operations for pointer addressing.

Returns:

• Conditional with exports

Categories satisfied:
BasicType, Conditional

Exports:

• nil : %
  `nil' represents the null pointer.
• nil? : % -> Boolean
  nil?(p) returns true if the value of `p' is `nil', false otherwise.
• test : % -> Boolean from Conditional
• coerce : (Ptr$Machine) -> %
• coerce : % -> (Ptr$Machine)
  Coerce from and to the internal builtin representation
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.29 : PrimitiveArray S

Description:
`PrimitiveArray(S)' is the domain of mono-dimensional arrays. Unlike the `Array(S)' domain, primitive-arrays contain no size information. Note that the indexing is 1-based (see `Array').

Parameter:

• S: Type

Returns:

• with exports

Cascaded exports: S

Exports:

• new : SingleInteger -> %
• new : (SingleInteger, S) -> %
  `new(n)' creates a new empty array with space for `n' elements. `new(n,s)' creates a new array with `n' elements, each initialized to `s'.
• dispose! : % -> ()
  `dispose!(a)' indicates that `a' will no longer be used.
• set! : (%, SingleInteger, S) -> S
  `v.n := s' sets the nth element of `v' to `s'.
• apply : (%, SingleInteger) -> S
  `v.n' extracts the nth element of `v'.
• resize! : (%, osz: SingleInteger, nsz: SingleInteger) -> %
  `resize!(v, oldsize, newsize)' returns an array with the number of elements equal to newsize and containing the first m elements of `v', where m is the minimum of `newsize' and `oldsize'. The value `v' must no longer be used.

26.30 : Ratio I

Description:
`Ratio(I)' defines arithmetic on fractions over an IntegerNumberSystem.

Parameter:

• I: IntegerNumberSystem

Returns:

• Join(OrderedRing, Field) with exports

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, EuclideanDomain, Field, Group, Monoid, Order, OrderedAbelianGroup, OrderedAbelianMonoid, OrderedRing, Ring

Cascaded exports: I

Exports:

• / : (I, I) -> %
  `n / d' gives the rational number `n/d'. Note that the minimal representation is chosen, so, for example, `3333/6666' is represented by `1/2'.
• numer : % -> I
• denom : % -> I
  `numer(r)' returns the numerator of the rational number `r'. `denom(r)' returns the denominator of the rational number `r'.
• * : (I, %) -> %
• coerce : I -> %
• coerce : Integer -> % from ArithmeticSystem
• coerce : SingleInteger -> % from ArithmeticSystem
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• <,>,>=, <= : (%, %) -> Boolean from Order
• <,>,>=, <= : (%, %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Boolean from Order
• min, max : (%, %) -> % from Order
• 0 : % from AbelianMonoid
• 1 : % from ArithmeticSystem
• + : % -> % from AbelianMonoid
• + : (%, %) -> % from AbelianMonoid
• - : % -> % from AbelianGroup
• - : (%, %) -> % from AbelianGroup
• * : (%, %) -> % from ArithmeticSystem
• / : (%, %) -> % from Group
• \ : (%, %) -> % from Group
• ^ : (%, Integer) -> % from ArithmeticSystem
• zero? : % -> Boolean from AbelianMonoid
• negative? : % -> Boolean from OrderedRing
• positive? : % -> Boolean from OrderedRing
• gcd : (%, %) -> % from EuclideanDomain
• quo : (%, %) -> % from EuclideanDomain
• rem : (%, %) -> % from EuclideanDomain
• divide : (%, %) -> (%, %) from EuclideanDomain
• inv : % -> % from Group
• sign : % -> % from OrderedRing
• abs : % -> % from OrderedRing
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.31 : RoundingMode

Description:
Modes for rounding.

Returns:

• with exports

Exports:

• nearest : () -> %
• zero : () -> %
• up : () -> %
• down : () -> %
• any : () -> %
• coerce : % -> BSInt
• =, ~= : (%, %) -> Boolean
• << : (TextWriter, %) -> TextWriter

26.32 : Segment S

Description:
`Segment(S)' provides ranges for indexing or iteration.

Parameter:

• S: Steppable

Returns:

• BasicType with exports

Exports:

• .. : S -> OpenSegment(S)
• .. : (S, S) -> ClosedSegment(S)
  `a..' defines an open segment. `a..b' defines a closed segment.
• coerce : OpenSegment(S) -> %
• coerce : ClosedSegment(S) -> %
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• by : (%, S) -> %
• by : (OpenSegment(S), S) -> %
• by : (ClosedSegment(S), S) -> %
  `s by n' indicates that segment `s' will be traversed in steps of size `n'.
• open? : % -> Boolean
  `open?(s)' returns true if `s' is an open segment, false otherwise.
• low, high, step : % -> S
• generator : OpenSegment(S) -> Generator(S)
• generator : ClosedSegment(S) -> Generator(S)
• generator : % -> Generator(S)
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.33 : SingleFloat

Description:
`SingleFloat' implements single-precision floating point numbers. In the portable byte code files, single-precision floats are represented in a format capable of representing IEEE extended single-precision. In a running program, single-precision floats are represented according to the machine's native arithmetic.

Returns:

• Join(OrderedFinite, FloatingPointNumberSystem) with exports

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, EuclideanDomain, Field, Finite, FloatingPointNumberSystem, Group, Monoid, Order, OrderedAbelianGroup, OrderedAbelianMonoid, OrderedFinite, OrderedRing, Ring

Cascaded exports: RoundingMode

Exports:

• coerce : (SFlo$Machine) -> %
• coerce : % -> (SFlo$Machine)
  Coerce from and to the internal builtin representation
• coerce : Integer -> % from ArithmeticSystem
• coerce : SingleInteger -> % from ArithmeticSystem
• integer : % -> Integer from FloatingPointNumberSystem
• fraction : % -> % from FloatingPointNumberSystem
• round : (%, RoundingMode) -> Integer from FloatingPointNumberSystem
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• # : Integer from Finite
• <,>,>=, <= : (%, %) -> Boolean from Order
• <,>,>=, <= : (%, %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Boolean from Order
• min, max : % from OrderedFinite
• << : (%, %) -> Boolean from FloatingPointNumberSystem
• >> : (%, %) -> Boolean from FloatingPointNumberSystem
• + : % -> % from AbelianMonoid
• + : (%, %) -> % from AbelianMonoid
• - : % -> % from AbelianGroup
• - : (%, %) -> % from AbelianGroup
• 0 : % from AbelianMonoid
• 1 : % from ArithmeticSystem
• * : (%, %) -> % from ArithmeticSystem
• / : (%, %) -> % from Group
• \ : (%, %) -> % from Group
• ^ : (%, Integer) -> % from ArithmeticSystem
• abs : % -> % from OrderedRing
• sign : % -> % from OrderedRing
• zero? : % -> Boolean from AbelianMonoid
• negative? : % -> Boolean from OrderedRing
• positive? : % -> Boolean from OrderedRing
• gcd : (%, %) -> % from EuclideanDomain
• quo : (%, %) -> % from EuclideanDomain
• rem : (%, %) -> % from EuclideanDomain
• divide : (%, %) -> (%, %) from EuclideanDomain
• inv : % -> % from Group
• float : Literal -> % from FloatingPointNumberSystem
• step SingleInteger -> (%, %) -> Generator(%) from FloatingPointNumberSystem
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.34 : SingleInteger

Description:
`SingleInteger' implements single-precision integers, typically 32 bits.

Returns:

• Join(Logic, OrderedFinite, IntegerNumberSystem, Steppable) with exports

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, EuclideanDomain, IntegerNumberSystem, Monoid, Order, OrderedAbelianGroup, OrderedAbelianMonoid, OrderedRing, Ring, Steppable

Cascaded exports: Segment SingleInteger

Exports:

• integer : Literal -> % from IntegerNumberSystem
• coerce : Boolean -> %
• coerce : Byte -> %
• coerce : HalfInteger -> %
• coerce : % -> (SInt$Machine
• coerce : (SInt$Machine) -> %
  Coerce from and to the internal builtin representation
• coerce : Integer -> % from ArithmeticSystem
• coerce : SingleInteger -> % from ArithmeticSystem
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• ~ : % -> % from Logic
• /\ : (%, %) -> % from Logic
• \/ : (%, %) -> % from Logic
• # : Integer from Finite
• <,>,>=, <= : (%, %) -> Boolean from Order
• <,>,>=, <= : (%, %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Cross(Boolean, %) from Order
• <,>,>=, <= : (Cross(Boolean, %), %) -> Boolean from Order
• min, max : % from OrderedFinite
• 0 : % from AbelianMonoid
• 1 : % from ArithmeticSystem
• + : % -> % from AbelianMonoid
• + : (%, %) -> % from AbelianMonoid
• - : % -> % from AbelianGroup
• - : (%, %) -> % from AbelianGroup
• * : (%, %) -> % from ArithmeticSystem
• ^ : (%, Integer) -> % from ArithmeticSystem
• ^ : (%, %) -> %
• zero? : % -> Boolean from AbelianMonoid
• negative? : % -> Boolean from OrderedRing
• positive? : % -> Boolean from OrderedRing
• even? : % -> Boolean from IntegerNumberSystem
• odd? : % -> Boolean from IntegerNumberSystem
• single? : % -> Boolean from IntegerNumberSystem
• abs : % -> % from OrderedRing
• sign : % -> % from OrderedRing
• gcd : (%, %) -> % from EuclideanDomain
• quo : (%, %) -> % from EuclideanDomain
• rem : (%, %) -> % from EuclideanDomain
• divide : (%, %) -> (%, % from EuclideanDomain
• prev : % -> % from IntegerNumberSystem
• next : % -> % from IntegerNumberSystem
• mod : (%, %) -> % from IntegerNumberSystem
• length : % -> SingleInteger from IntegerNumberSystem
• shift : (%, SingleInteger) -> % from IntegerNumberSystem
• bit : (%, SingleInteger) -> Boolean from IntegerNumberSystem
• retract : % -> SingleInteger from IntegerNumberSystem
• mod_+, mod_-, mod_*, mod_^ : (%, %, %) -> %
• stepsBetween : (%, %, %) -> SingleInteger
• stepsBetween : (%, %) -> SingleInteger from Steppable
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.35 : SingleIntegerMod(n)

Parameter:

• n: SingleInteger

Returns:

• Ring with exports

Categories satisfied:
AbelianGroup, AbelianMonoid, ArithmeticSystem, BasicType, Monoid, Ring

Exports:

• 0, 1 : % from ArithmeticSystem
• coerce : Integer -> %
• coerce : SingleInteger -> %
• integer : Literal -> %
• -, + : % -> % from ArithmeticSystem
• -, + : (%, %) -> % from ArithmeticSystem
• * : (%, %) -> % from ArithmeticSystem
• ^ : (%, Integer) -> % from ArithmeticSystem
• zero? : % -> Boolean from AbelianMonoid
• lift : % -> SingleInteger
• inv : % -> %
• / : (%, %) -> %
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter from BasicType
• << : % -> TextWriter -> TextWriter from BasicType
• sample : % from BasicType
• hash : % -> SingleInteger from BasicType

26.36 : StandardIO

Returns:

• with exports

Exports:

• stdin : InFile
• stdout : OutFile
• stderr : OutFile
• stdsink : OutFile

26.37 : String

Description:
`String' is the type of character strings for natural language text.

Returns:

• BasicType with exports

Categories satisfied:
BasicType

Exports:

• string : Literal -> %
  "hello" is a string-style literal constant.
• string : Array(Character) -> %
  `string ac' creates a string out of an array of characters.
• # : % -> SingleInteger
  `#s' returns the number of characters in the string `s'.
• end? : (%, SingleInteger) -> Boolean
  `end?(s,i)' is true when `i = #s+1'. This function may be called with values of `i' in the range `1..#s+1'.
• empty : SingleInteger -> %
  `empty n' allocates a new string with room for upto `n' characters.
• data : % -> (Arr$Machine)
  `data s' returns a structure with the raw data for `s'.
• end! : (%, SingleInteger) -> ()
  `end!(s,i)' causes the contents of `s' to end at position `i'.
• dispose! : % -> ()
  `dispose! s' indicates that `s' will no longer be used.
• apply : (%, SingleInteger) -> Character
  `s.i' returns the ith character from the string `s'. The index `i' may take any value from `1' to `#s'.
• set! : (%, SingleInteger, Character) -> Character
  `s.i := c' updates the ith character position in `s' to contain the value `c'.
• =, ~= : (%, %) -> Boolean from BasicType
• << : (TextWriter, %) -> TextWriter
  `w << s' emits the string `s' on the writer `w'.
• << : % -> TextWriter -> TextWriter from BasicType
• new : (SingleInteger, fill: Character == space) -> %
  `new(n, c)' creates a new string filled with `c' characters. If no character is given, ` ' (space) is used as a default.
• copy : % -> %
  `copy(s)' creates a new string containing a copy of `s'.
• concat : Tuple(%) -> %
  `concat(s1,s2,...)' creates a new string containing the characters of `s1' followed by the characters of `s2', etc.
• apply : (%, OpenSegment(SingleInteger)) -> %
• apply : (%, ClosedSegment(SingleInteger)) -> %
  `s.(i..)' allocates a new string containing the substring with characters `s.i' to `s.(#s)'. `s.(i..j)' allocates a new string containing the substring with characters `s.i' to `s.j'.
• generator : % -> Generator(Character)
  Generates all the characters in the string.
• map : (Character -> Character, %) -> %
• map! : (Character -> Character, %) -> %
  `map(f, s)' forms a new string from `s' with each character `c' of the old string replaced by `f c' in the new. `map!(f, s)' modifies the string `s' so that each character `c' is replaced by `f c'.
• fill! : (%, Segment(SingleInteger), Character) -> %
  `fill!(s, i0..iN, c)' set all the characters from `s.i0' to `s.iN' to be equal to `c'.
• replace! : (%, SingleInteger, %) -> SingleInteger
  `replace!(s1, i0, s2)' replaces characters in `s1' beginning at position `i0' with characters from `s2'. Returns the next available position in `s1'.
• substring : (%, SingleInteger, SingleInteger) -> %
  `substring(s, start, len)' returns the substring of `s' of length `len' beginning at position `start'.
• rightTrim : (%, Character) -> %
• leftTrim : (%, Character) -> %
  `rightTrim(s,c)' removes trailing occurrences of `c' from `s'. `leftTrim(s,c)' removes leading occurrences of `c' from `s'.
• sample : % from BasicType
• hash : % -> SingleInteger(default) from BasicType

26.38 : TextReader

Description:
`TextReader' provides operations for generic text input sources.

Returns:

• with exports

Exports:

• reader : FileName -> %
• reader : InFile -> %
• reader : (
  (eof: Character == char(0)) -> Character, (String, SingleInteger, SingleInteger) -> SingleInteger ) -> %}{}
• readchar! : (%, eof: Character == char(0)) -> Character
  `readchar!(t, EOF)' returns the next character from the TextReader. If the end has been reached, then the character EOF is returned.
• readline! : % -> String
  `readline! t' reads a line from TextReader and returns a new string containing it. The string will end with a newline character, unless the end of the TextReader is reached without one.
• readline! : (%,String,SingleInteger,SingleInteger)->SingleInteger
  `readline!(t, s, start, limit)' reads characters from the TextReader `t' into the portion of the string `s' lying in the range `start..limit-1'. The string `s' must have space for at least `limit' characters. The function places characters into the string until `limit' is reached, a newline is read, or the end of file is reached. The function returns the number of characters read, which will be `0' if the end of file has been reached.
• generator : % -> Generator(Character)
• lines : % -> Generator(String)

26.39 : TextWriter

Description:
`TextWriter' is the domain of writable text streams.

Returns:

• with exports

Exports:

• writer : (Character -> (), (String, SingleInteger, SingleInteger) -> SingleInteger) -> %
  `writer' forms a new TextWriter from functions. The first function writes a character. The second function takes parameters `(s,i1,iL)' and writes the substring `s(i1..min(iL-1, #s))'. If `iL=0' it writes everything up to the end of `s'.
• write! : (%, Character) -> ()
• write! : (%, String) -> ()
• write! : (%, String, SingleInteger, SingleInteger) -> SingleInteger
  `write!(w, c)' puts the Character `c' on the TextWriter `w'. `write!(w, s)' puts the String `s' on the TextWriter `w'. `write!(w,s,i1,iL)' puts `s(i1..min(iL-1, #s))' on the TextWriter `w' and returns the number of characters written. If `iL=0' it writes everything up to the end of `s'.
• # : % -> SingleInteger
• writer : FileName -> %
• writer : OutFile -> %
• writer : Array(Character) -> %
• print : %
• error : %
• sink : () -> %

26.40 : Tuple T

Description:
`Tuple(T)' provides functions for values of type `Tuple T'. This is an "extend" of the language-defined Tuple.

Parameter:

• T: Type

Returns:

• with exports

Cascaded exports: T

Exports:

• tuple : (SingleInteger, Pointer) -> %
  `tuple(s, p)' forms a tuple of length s. The tuple values are in the array pointed to by `p'.
• length : % -> SingleInteger
  `length(t)' returns the number of components in the tuple `t'.
• element : (%, SingleInteger) -> T
  `element(t, s)' extracts the element in position `s' from the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1. the tuple `t'. The first element is in position 1.