Slang Library Reference

by Sean P. Miller

std.alg

std.basic

std.alg

The definitions in this file are designed to fulfill the following purposes:

high-level sequence manipulation,
generation of integer-valued sequences, and
general-purpose sorts.

Functions

Signature	Description
filter (pred: `a -> bool, seq: [`a]): [`a]	Collects all elements in seq that satisfy pred.
foldl (f: `a * `b -> `a, init: `a, seq: [`b]): `a	Left-to-right accumulation of seq.
foldr (f: `a * `b -> `b, init: `b, seq: [`a]): `b	Right-to-left accumulation of seq.
foreach (f: `a -> void, seq: [`a]): void	Applies f to each element in seq.
map (f: `a -> `b, seq: [`a]): [`b]	Returns the results of f applied to each element in seq.
zip (xs: [`a], ys: [`b]): [`a * `b]	Pairs corresponding elements of xs and ys.
partition (pred: `a -> bool, seq: [`a]): [`a] * [`a]	Returns a pair of sequences (T,F) where T contains the elements in seq that satisfy pred and F contains the rest.
generate (gen: void -> `a, count: int): [`a]	Creates a sequence of length count initialized with calls to gen.
range (lower: int, upper: int): [int]	Returns all integers in the half-open range [lower, upper).
mapMaybe (f: `a -> `b maybe, seq: [`a]): [`b]	A specialized transform that discards Nothing results.
merge (cmp: `a * `a -> order, left: [`a], right: [`a]): [`a]	Merges two sequences into ascending order.
mergeSort (cmp: `a * `a -> order, seq: [`a]): [`a]	A stable, safe, slower sort.
quickSort (cmp: `a * `a -> order, seq: [`a]): [`a]	An unstable, unsafe, faster sort.
find (pred: `a -> bool, seq: [`a]): `a maybe	Attempts to find an element in seq that satisfies pred.
findAll (pred: `a -> bool, seq: [`a]): [`a]	Collects all elements in seq that satisfy pred.
binarySearch (cmp: `a * `a -> order, e: `a, seq: [`a]): `a maybe	Fast lookup for presorted sequences.

filter

filter (pred: `a -> bool, seq: [`a]): [`a]

(* r1 contains ss with empty strings removed *)
def r1 = filter (lambda (s) { return s <> ""; }, ss);

Parameters:

pred: any unary predicate function consistent with seq's type
seq: any sequence

Returns:

a sequence containing all elements in seq for which pred returns true

foldl

foldl (f: `a * `b -> `a, init: `a, seq: [`b]): `a

Parameters:

f: a binary transform function
init: an initial value for accumulation
seq: any sequence

Returns:

the left-to-right accumulation of f applied to each element of seq and a "running total" beginning with init

Notes:

also known in some languages/libraries as reduce
this is the correct fold for left-associative noncommutative operations such as subtraction

foldr

foldr (f: `a * `b -> `b, init: `b, seq: [`a]): `b

Parameters:

f: a binary transform function
init: an initial value for accumulation
seq: any sequence

Returns:

the right-to-left accumulation of f applied to each element of seq and a "running total" beginning with init

Notes:

also known in some languages/libraries as reduce
this is the correct fold for right-associative noncommutative operations

foreach

foreach (f: `a -> void, seq: [`a]): void

Parameters:

f: a unary void-valued function
seq: any sequence

Notes:

applies f to each of seq's elements in left-to-right order
designed for side-effectful operations

map

map (f: `a -> `b, seq: [`a]): [`b]

Parameters:

f: a unary transform function
seq: any sequence

Returns:

a sequence containing the results of left-to-right application of f to each of seq's elements

zip

zip (xs: [`a], ys: [`b]): [`a * `b]

Parameters:

xs: any sequence
ys: any sequence

Returns:

a sequence containing the pairwise combination of corresponding elements in xs and ys

Notes:

if the sequences are of unequal length, all extraneous elements in the longer sequence are discarded
therefore, the sequence returned by this function always has length min (len xs, len ys)

partition

partition (pred: `a -> bool, seq: [`a]): [`a] * [`a]

Parameters:

pred: a unary predicate function
seq: any sequence

Returns:

a pair of sequences (T,F) where T contains the elements in seq for which pred returns true and F contains the rest

generate

generate (gen: void -> `a, count: int): [`a]

Parameters:

gen: a unary predicate function
count: any sequence

Returns:

a sequence of length count initialized left-to-right with calls to gen

range

range (lower: int, upper: int): [int]

Parameters:

lower: an integer less than or equal to upper
upper: an integer greater than or equal to lower

Returns:

a sequence containing all integers in the half-open range [lower, upper)

Notes:

will eventually throw an exception if lower > upper

mapMaybe

mapMaybe (f: `a -> `b maybe, seq: [`a]): [`b]

(* r1 will be [1,2,4] *)
def r1 = mapMaybe (str2int, ["1", "2", "xx", "4"]);

Parameters:

f: a unary transform function yielding a maybe construction
seq: any sequence

Returns:

a sequence containing only the successful applications of f (those that yield Some constructions) to elements of seq

Notes:

designed for transformations that might fail silently on individual elements

merge

merge (cmp: `a * `a -> order, left: [`a], right: [`a]): [`a]

Parameters:

cmp: a binary comparator function
left: any sequence
right: any sequence

Returns:

the sequences merged in ascending order

Notes:

stable
linear time in sum of sequence lengths

mergeSort

mergeSort (cmp: `a * `a -> order, seq: [`a]): [`a]

Parameters:

cmp: a binary comparator function
seq: any sequence

Returns:

a sequence containing seq's elements in ascending order

Notes:

stable
time complexity is Θ(n lg n) where n = len seq, but average-case performance is worse than quickSort
use when sorting potentially-malicious data

quickSort

quickSort (cmp: `a * `a -> order, seq: [`a]): [`a]

Parameters:

cmp: a binary comparator function
seq: any sequence

Returns:

a sequence containing seq's elements in ascending order

Notes:

unstable
worst-case time complexity is quadratic, but average-case performance is better than mergeSort

find

find (pred: `a -> bool, seq: [`a]): `a maybe

Parameters:

pred: a unary predicate function
seq: any sequence

Returns:

Some parameterized by the first element in seq for which pred returns true; else, Nothing if pred returns false for all elements in seq

Notes:

linear time

findAll

findAll (pred: `a -> bool, seq: [`a]): [`a]

Parameters:

pred: a unary predicate function
seq: any sequence

Returns:

all elements in seq for which pred returns true

Notes:

linear time

binarySearch

binarySearch (cmp: `a * `a -> order, e: `a, seq: [`a]): `a maybe

Parameters:

cmp: a binary comparator function
e: any value
seq: any sequence

Returns:

Some parameterized by any element in seq for which cmp returns Equal; else, returns Nothing

Notes:

dilogarithmic time
for correct behavior, seq must be sorted in ascending order

std.basic

The definitions in this file are designed to fulfill the following purposes:

conversions between primitive types,
elementary string and sequence manipulation, and
access to underlying details such as real precision.

Generic exceptions, maybe, and order are also provided.

Note that this file is automatically included in other headers.

Constructors

Data Constructor	Type Constructor	Parameterization	Description
Arithmetic	BasicException	string	Thrown when various mathematical errata occur.
OutOfBounds	BasicException	string	Thrown when a numeric argument is outside expected bounds.
Empty	BasicException	string	Thrown when an empty sequence is unacceptable.
BadArgument	BasicException	string	Thrown when an argument is malformed.
RuntimeFailure	BasicException	string	Thrown when an internal error occurs.
Interrupted	BasicException	string	Thrown when blocked operation is interrupted.
StackOverflow	BasicException	string	Thrown when stack exhausted.
Existential	BasicException		Thrown when Nothing is unacceptable.
Nothing	`a maybe		Represents a failed computation.
Some	`a maybe	`a	Wraps the result of a successful computation.
Less	order		Less-than comparison result.
Equal	order		Equal-to comparison result.
Greater	order		Greater-than comparison result.

Functions

Signature	Description
int2str (n: int): string	Produces a human-readable base-ten string from n.
int2radix (n: int, radix: int): string	Produces a human-readable base-radix string from n.
int2char (n: int): char maybe	Interprets n as a Unicode codepoint.
real2str (x: real): string	Produces a human-readable base-ten string from x.
getprec (x: real): int	Returns x's precision.
setprec (x: real, prec: int): real	Creates a new real with x's value and precision prec.
float2str (f: float): string	Produces a human-readable base-ten string from f.
str2int (s: string): int maybe	Converts base-ten string s into an integer.
str2real (s: string): real maybe	Converts s into a real.
str2float (s: string): float maybe	Converts s into a float.
sub (s: string, index: int): char	Returns the character from s at position index.
substr (s: string, index: int, count: int): string	Returns a substring of s of length count beginning at position index.
strlen (s: string): int	Returns the number of characters in s.
explode (s: string): [char]	Converts s into an equivalent sequence of characters.
char2str (c: char): string	Converts c into an equivalent string.
char2int (c: char): int	Returns an integer equal to c's Unicode codepoint.
bool2str (b: bool): string	Produces a human-readable string from b.
head (seq: [`a]): `a	Returns seq's leftmost element.
tail (seq: [`a]): [`a]	Returns seq without its leftmost element.
rhead (seq: [`a]): `a	Returns seq's rightmost element.
rtail (seq: [`a]): [`a]	Returns seq without its rightmost element.
len (seq: [`a]): int	Returns the number of elements in seq.
implode (charSeq: [char]): string	Converts charSeq into an equivalent string.
split (index: int, seq: [`a]): [`a] * [`a]	Returns (L,R) where L is all elements in seq before position index and R is those at or after index.
at (index: int, seq: [`a]): `a	Returns the element in seq at position index.
take (count: int, seq: [`a]): [`a]	Returns the first count elements of seq.
drop (count: int, seq: [`a]): [`a]	Discards the first count elements of seq and returns the rest.
insert (index: int, e: `a, seq: [`a]): [`a]	Returns seq with element e inserted at position index.
delete (index: int, seq: [`a]): [`a]	Returns seq without the element at position index.
slice (begin: int, end: int, seq: [`a]): [`a]	Returns the subsequence of seq from position begin to position end, inclusive.
rev (seq: [`a]): [`a]	Returns seq in reverse order.
val (e: `a maybe): `a	Extracts the argument from a maybe construction.
isNothing (e: `a maybe): bool	If given Nothing, returns true; else, returns false.
isSome (e: `a maybe): bool	If given any Some construction, returns true; else, returns false.
compare (a: `a, b: `a): order	Defines a total ordering over most types.
send (ch: `a channel, msg: `a): void	Queues msg in FIFO ch.
recv (ch: `a channel): `a	Pulls the first available message from ch.

int2str

int2str (n: int): string

Parameters:

n: any integer

Returns:

a human-readable base-ten string

int2radix

int2radix (n: int, radix: int): string

Parameters:

n: any integer
radix: an integer between 2 and 64, inclusive

Returns:

a human-readable base-radix string

Exceptions:

OutOfBounds: when radix < 2 or radix > 64

int2char

int2char (n: int): char maybe

Parameters:

n: an integer representing a Unicode codepoint (between 0 and 10FFFF₁₆, inclusive)

Returns:

either Nothing (if n < 0 or n > 10FFFF₁₆) or Some parameterized by the character corresponding to the given codepoint

Notes:

in other languages, this function is often called chr

getprec

getprec (x: real): int

Parameters:

x: any real

Returns:

x's precision

setprec

setprec (x: real, prec: int): real

Parameters:

x: any real
prec: any positive integer

Returns:

a real with x's value to precision prec

Exceptions:

OutOfBounds: when prec <= 0

Notes:

If the requested precision less than this number's current precision, the functionality is quite obvious: the precision is simply truncated, and e.g. comparison and equality checking will work as expected. Some rounding errors in e.g. addition and subtraction may still occur, as "invisible" trailing digits can remain in the number. [from apfloat docs: http://www.apfloat.org/apfloat_java/docs/org/apfloat/Apfloat.html#precision(long)]
If the requested precision more than this number's current precision, the functionality is quite undefined: the digits up to this number's current precision are guaranteed to be the same, but the "new" digits are undefined: they may be zero, or they may be digits that have been previously discarded with a call to precision() with a smaller number of digits, or they may be something else, or any combination of these. [ditto]

float2str

float2str (f: float): string

Parameters:

f: any float

Returns:

a base-ten string equivalent to f

str2int

str2int (s: string): int maybe

Parameters:

s: a string containing any well-formed base-ten integer literal

Returns:

either Nothing (if s is malformed) or Some parameterized by the integer value of s

str2real

str2real (s: string): real maybe

Parameters:

s: a string containing any well-formed real literal

Returns:

either Nothing (if s is malformed) or Some parameterized by the real value of s

str2float

str2float (s: string): float maybe

Parameters:

s: a string containing any well-formed float literal

Returns:

either Nothing (if s is malformed) or Some parameterized by the float value of s

sub

sub (s: string, index: int): char

Parameters:

s: a nonempty string
index: a nonnegative integer strictly less than s's length

Returns:

the character in s at position index

Exceptions:

Empty: when s is the empty string
OutOfBounds: when index < 0 or index >= s's length

Notes:

linear time over the number of codepoints in s

substr

substr (s: string, index: int, count: int): string

Parameters:

s: a nonempty string
index: a nonnegative integer strictly less than s's length
count: a nonnegative integer such that (index + count) <= s's length

Returns:

a substring of s of length count beginning at position index

Exceptions:

Empty: when s is the empty string
OutOfBounds: when index < 0 or index >= s's length or count < 0 or (index + count) > s's length

Notes:

for all strings s, the following is always true: substr (s, 0, len s) == s

strlen

strlen (s: string): int

Parameters:

s: any string

Returns:

the number of characters in s

Notes:

linear time over the number of codepoints in s

explode

explode (s: string): [char]

Parameters:

s: any string

Returns:

a sequence containing the characters in s

Notes:

for performance reasons, it is preferable to convert strings to and from character-sequences for manipulation

char2str

char2str (c: char): string

Parameters:

c: any character

Returns:

a one-length string whose first character is c

char2int

char2int (c: char): int

Parameters:

c: any character

Returns:

an integer equal to c's codepoint

Notes:

in other languages, this function is often called ord, short for ordinal

bool2str

bool2str (b: bool): string

Parameters:

b: any Boolean value

Returns:

if b is true, returns "true"; else, returns "false"

head

head (seq: [`a]): `a

Parameters:

seq: a nonempty sequence

Returns:

seq's leftmost element

Exceptions:

Empty: if seq is the empty sequence

tail

tail (seq: [`a]): [`a]

Parameters:

seq: a nonempty sequence

Returns:

seq without its leftmost element

Exceptions:

Empty: if seq is the empty sequence

rhead

rhead (seq: [`a]): `a

Parameters:

seq: a nonempty sequence

Returns:

seq's rightmost element

Exceptions:

Empty: if seq is the empty sequence

rtail

rtail (seq: [`a]): [`a]

Parameters:

seq: a nonempty sequence

Returns:

seq without its rightmost element

Exceptions:

Empty: if seq is the empty sequence

len

len (seq: [`a]): int

Parameters:

seq: any sequence

Returns:

the number of elements in seq

Notes:

constant time

implode

implode (charSeq: [char]): string

Parameters:

charSeq: any sequence of characters

Returns:

a string with the same characters as charSeq

Notes:

for performance reasons, it is preferable to convert strings to and from character-sequences for manipulation

split

split (index: int, seq: [`a]): [`a] * [`a]

Parameters:

index: a nonnegative integer strictly less than seq's length
seq: a nonempty sequence

Returns:

two-tuple (L,R) where L is all elements in seq before position index and R is those at or after index

Exceptions:

Empty: if seq is the empty sequence
OutOfBounds: if index < 0 or index >= seq's length

Notes:

time complexity is O(log₂(min(index, len seq - index)))
many of the following operations are defined in terms of this function, so their time complexity is also logarithmic

at

at (index: int, seq: [`a]): `a

Parameters:

index: a nonnegative integer strictly less than seq's length
seq: a nonempty sequence

Returns:

the element in seq at position index

Exceptions:

Empty: if seq is the empty sequence
OutOfBounds: if index < 0 or index >= seq's length

Notes:

equivalent to head (split (index, seq))#2

take

take (count: int, seq: [`a]): [`a]

Parameters:

count: a nonnegative integer less than or equal to seq's length
seq: any sequence

Returns:

all elements in seq appearing before position index

Exceptions:

OutOfBounds: if count < 0 or count > seq's length

Notes:

equivalent to (split (count, seq))#1
for all sequences seq, the following is always true: take (0, seq) == []

drop

drop (count: int, seq: [`a]): [`a]

Parameters:

count: a nonnegative integer less than or equal to seq's length
seq: any sequence

Returns:

all elements in seq appearing at or after position index

Exceptions:

OutOfBounds: if count < 0 or count > seq's length

Notes:

equivalent to (split (count, seq))#2
for all sequences seq, the following is always true: drop (0, seq) == seq

insert

insert (index: int, e: `a, seq: [`a]): [`a]

Parameters:

index: a nonnegative integer strictly less than seq's length
e: a value whose type is consistent with seq's type
seq: any sequence

Returns:

seq with e inserted at position index

Exceptions:

OutOfBounds: if index < 0 or index >= seq's length

Notes:

equivalent to ((split (index, seq))#1 <+ element) @ (split (index, seq))#2
for all values e, the following is always true: insert (0, e, []) == [e]

delete

delete (index: int, seq: [`a]): [`a]

Parameters:

index: a nonnegative integer strictly less than seq's length
seq: a nonempty sequence

Returns:

seq without the element at position index

Exceptions:

Empty: if seq is the empty sequence
OutOfBounds: if index < 0 or index >= seq's length

Notes:

equivalent to (split (index, seq))#1 @ tail ((split (index, seq))#2)

slice

slice (begin: int, end: int, seq: [`a]): [`a]

Parameters:

begin: a nonnegative integer strictly less than seq's length
end: an integer in the half-open range [begin, len seq)
seq: a nonempty sequence

Returns:

the subsequence of seq from position begin to position end, inclusive

Exceptions:

Empty: if seq is the empty sequence
OutOfBounds: if begin < 0 or end < begin or end >= seq's length

Notes:

equivalent to split (end - begin, (split (begin, seq))#2)

rev

rev (seq: [`a]): [`a]

Parameters:

seq: any sequence

Returns:

seq in reverse order

Notes:

linear time

val

val (e: `a maybe): `a

Parameters:

e: a maybe construction of the form (Some ?)

Returns:

the argument wrapped by Some

Exceptions:

Existential: if e is Nothing

isNothing

isNothing (e: `a maybe): bool

Parameters:

e: any maybe construction

Returns:

true if e is Nothing; else, false

isSome

isSome (e: `a maybe): bool

Parameters:

e: any maybe construction

Returns:

false if e is Nothing; else, true

compare

compare (a: `a, b: `a): order

Parameters:

a: any value
b: any value

Returns:

one of the three order constructors specifying the relative ordering of a and b

Exceptions:

RuntimeFailure: if called with invalid arguments

Notes:

only defined over built-in types int, real, char, and string

send

send (ch: `a channel, msg: `a): void

Parameters:

ch: any channel
msg: any value

Notes:

only blocks if ch's FIFO is full

recv

recv (ch: `a channel): `a

Parameters:

ch: any channel

Returns:

the first message available from ch

Exceptions:

Interrupted: if interrupted while blocking

Notes:

blocks until message is available

std.io

The definitions in this file are designed to fulfill the following purposes:

console I/O and
file I/O.

Constructors

Data Constructor	Type Constructor	Parameterization	Description
FileNotFound	IOException	string	Thrown when file cannot be found.
IOFailure	IOException	string	Thrown when unspecified I/O error occurs.
BadFd	IOException	string	Thrown when given invalid file descriptor.
BadOpenmode	IOException	string	Thrown when given invalid openmode.

Type Aliases

Name	Value
fd	{loc: string, mode: openmode, id: int}
openmode	int

Constants

Definition	Value
MODE_IN: openmode	1
MODE_OUT: openmode	1 << 1
MODE_APP: openmode	1 << 2
MODE_TRUNC: openmode	1 << 3
STDIN: fd	{loc="<STDIN>", mode=MODE_IN, id=0}
STDOUT: fd	{loc="<STDOUT>", mode=MODE_OUT, id=1}
STDERR: fd	{loc="<STDERR>", mode=MODE_OUT, id=2}

Functions

Signature	Description
print (s: string): void	Writes s to STDOUT.
getline (): string	Reads all characters up to a newline from STDIN.
open (fileName: string, mode: openmode): fd	Opens the file identified by fileName.
close (des: fd): void	Closes a file that has already been opened.
eof (des: fd): bool	Returns true if the file stream is at the end.
read (des: fd, count: int): string	Reads count characters from a file stream.
write (des: fd, data: string): void	Writes data to a file stream.

print

print (s: string): void

Parameters:

s: any string

Notes:

writes s to STDOUT
therefore, equivalent to write (STDOUT, s)

getline

getline (): string

Notes:

reads characters from STDIN until newline reached

open

open (fileName: string, mode: openmode): fd

try {
    def is = open ("some_file.txt", MODE_IN);

    try {
        (* read from the file *)
    } catch (e: IOException) {
        (* handle read errors *)
    } finally {
        close is;
    }
} catch (e: IOException) {
    (* handle open failure *)
}

Parameters:

fileName: a string specifying the name and location of a file on disk
mode: a valid combination of openmode values

Returns:

a file descriptor

Exceptions:

FileNotFound: if fileName is empty, malformed, or otherwise invalid
BadOpenmode: if mode is invalid

Notes:

creates a file stream corresponding to the returned file descriptor that persists until closed
the modes have the following meanings:
- MODE_IN: open file for input operations
- MODE_OUT: open file for output operations
- MODE_APP: initialize stream position to end-of-file
- MODE_TRUNC: erase all file contents
to construct a compound openmode, bitwise-or two or more modes together

close

close (des: fd): void

Parameters:

des: a file descriptor referring to a valid file stream

Exceptions:

BadFd: if des does not represent a valid file stream

Notes:

closes the file stream associated with des

eof

eof (des: fd): bool

Parameters:

des: a file descriptor referring to a valid file stream

Returns:

true if the stream's position is at the end of the file; else, false

Exceptions:

BadFd: if des does not represent a valid file stream

read

read (des: fd, count: int): string

Parameters:

des: a file descriptor referring to a valid file stream
count: the number of characters to read

Returns:

a string containing what was read from des

Exceptions:

BadFd: if des does not represent a valid file stream
IOFailure: if the read operation fails for any reason, including prematurely reaching end-of-file

Notes:

if successful, advances the stream position by count characters

write

write (des: fd, data: string): void

Parameters:

des: a file descriptor referring to a valid file stream
data: the string to write

Exceptions:

BadFd: if des does not represent a valid file stream
IOFailure: if the write operation fails for any reason

Notes:

attempts to write all the characters in data to the indicated file stream
if successful, advances the stream position by strlen data characters

std.math

Functions

Signature	Description
abs (n: int): int	Absolute value.
promote (n: int): real	Converts an int to a real (avoid if possible).
gcd (a: int, b: int): int	Greatest common divisor.
extEuclid (a: int, b: int): int * int * int	Extended Euclidean algorithm.
lcm (a: int, b: int): int	Least common multiple.
max (a: int, b: int): int	The larger of two arguments.
min (a: int, b: int): int	The smaller of two arguments.
powMod (base: int, exponent: int, p: int): int	base^exponent (mod p)
invMod (a: int, m: int): int	Modular multiplicative inverse.
nextProbablePrime (n: int, trials: int): int	Finds the smallest prime larger than n with probability (1 - 0.25^trials).
isProbablePrime (n: int, trials: int): int	Determines whether n is prime with probability (1 - 0.25^trials).
div3 (dividend: int): int	Fast routine to find quotient of dividend / 3.
mod3 (n: int): int	Fast routine to find n (mod 3).
ceil (x: real): int	Finds smallest integer greater than x.
floor (x: real): int	Finds largest integer less than x.
round (x: real): int	Returns the integer closest to x.
pi (precision: int): real	Calculates precision digits of the number π.
sqrt (x: real): real	Returns the principal (nonnegative) square root of x.
exp (x: real): real	e^x
log (x: real): real	ln x
sin (x: real): real	sin x
cos (x: real): real	cos x
tan (x: real): real	tan x
fpromote (n: int): float	Converts an int to a float.
isNaN (f: float): bool	Returns true if f is not-a-number.
isInf (f: float): bool	Returns true if f is either positive or negative infinity.
fsqrt (f: float): float	Float-valued principal square root.
modf (f: float): int * float	Decomposes argument into integer and fraction parts.

abs

abs (n: int): int

Parameters:

n: any integer

Returns:

promote

promote (n: int): real

Parameters:

n: any integer

Returns:

the real that best approximates n

Notes:

highly inefficient, so avoid at all costs

gcd

gcd (a: int, b: int): int

Parameters:

a: a nonzero integer
b: a nonzero integer

Returns:

the greatest common divisor of a and b

Notes:

will eventually throw Arithmetic if either argument is zero

extEuclid

extEuclid (a: int, b: int): int * int * int

Parameters:

a: a nonzero integer
b: a nonzero integer

Returns:

(X,Y,Z) where aX + bY = gcd(a,b) = Z

Notes:

will eventually throw Arithmetic if either argument is zero

lcm

lcm (a: int, b: int): int

Parameters:

a: a nonzero integer
b: a nonzero integer

Returns:

the least common multiple of a and b

Notes:

will eventually throw Arithmetic if either argument is zero

max

max (a: int, b: int): int

Parameters:

a: any integer
b: any integer

Returns:

the larger value of a and b

min

max (a: int, b: int): int

Parameters:

a: any integer
b: any integer

Returns:

the smaller value of a and b

powMod

powMod (base: int, exponent: int, p: int): int

Parameters:

base: any integer
exponent: any integer
p: a positive integer

Returns:

base^exponent (mod p)

Exceptions:

Arithmetic: if p < 1

invMod

invMod (a: int, m: int): int

Parameters:

a: any integer
m: a positive integer

Returns:

an integer x such that a^-1 = x (mod m)

Exceptions:

Arithmetic: if m < 1

nextProbablePrime

nextProbablePrime (n: int, trials: int): int

Parameters:

n: any integer
trials: an integer in the closed range [1,256]

Returns:

the smallest prime larger than n with probability (1 - 0.25^trials)

Exceptions:

OutOfBounds: if trials < 1 or trials > 256

Notes:

performs trials iterations of the Miller-Rabin test

isProbablePrime

isProbablePrime (n: int, trials: int): int

Parameters:

n: any integer
trials: an integer in the closed range [1,256]

Returns:

true if n is prime with probability (1 - 0.25^trials); else, false

Exceptions:

OutOfBounds: if trials < 1 or trials > 256

Notes:

performs trials iterations of the Miller-Rabin test

div3

div3 (dividend: int): int

Parameters:

dividend: any integer

Returns:

the quotient of dividend / 3

Notes:

faster than basic division for very large arguments

mod3

mod3 (n: int): int

Parameters:

n: any integer

Returns:

n (mod 3)

Notes:

faster than basic modulo for very large arguments

ceil

ceil (x: real): int

Parameters:

x: any real

Returns:

smallest integer greater than x

floor

floor (x: real): int

Parameters:

x: any real

Returns:

largest integer less than x

round

round (x: real): int

Parameters:

x: any real

Returns:

the integer closest to x

Notes:

Equivalent to floor (x + 0.5).

pi

pi (precision: int): real

Parameters:

precision: a positive integer

Returns:

precision digits of the number π

Exceptions:

OutOfBounds: if precision < 1
Arithmetic: if result overflows or is otherwise too large

sqrt

sqrt (x: real): real

Parameters:

x: a nonnegative real

Returns:

the principal (nonnegative) square root of x

Exceptions:

OutOfBounds: if x < 0

exp

exp (x: real): real

Parameters:

x: any real

Returns:

log

log (x: real): real

Parameters:

x: a positive real

Returns:

ln x

Exceptions:

OutOfBounds: if x <= 0

sin

sin (x: real): real

Parameters:

x: any real

Returns:

sin x

cos

cos (x: real): real

Parameters:

x: any real

Returns:

cos x

tan

tan (x: real): real

Parameters:

x: any real

Returns:

tan x

fpromote

fpromote (n: int): float

Parameters:

n: an integer in the closed range [-2³¹, 2³¹ - 1]

Returns:

a float equal to n

Exceptions:

RuntimeFailure: if n cannot fit into a 32-bit signed integer

isNaN

isNaN (f: float): bool

Parameters:

f: any float

Returns:

true only if f is not-a-number, else false

isInf

isInf (f: float): bool

Parameters:

f: any float

Returns:

true only if f is either positive or negative infinity, else false

fsqrt

fsqrt (f: float): float

Parameters:

f: a nonnegative float

Returns:

the principal (nonnegative) square root of f

Exceptions:

OutOfBounds: if f < 0

modf

modf (f: float): int * float

Parameters:

f: any float

Returns:

a pair (I,F) where I is the integer part of f and F is the fractional part

std.rand

The definitions in this file are designed to fulfill the following purposes:

generation of random numbers.

Functions

Signature	Description
rand (n: int): int	Generates a random integer in the closed range [0, n * 2³⁰].
randPrime (n: int): int	Generates a random prime integer guaranteed to be n bytes in size.

rand

rand (n: int): int

Parameters:

n: a positive integer

Returns:

a random integer in the closed range [0, n * 2³⁰]

Notes:

exponent on upper bound of range defined by internal constant Integer.MP_DIGIT_BIT

randPrime

randPrime (n: int): int

Parameters:

n: a positive integer

Returns:

a random prime integer guaranteed to be n bytes in size

Notes:

prime numbers are always integers greater than one

std.sys

Functions

Signature	Description
coresAvailable (): int	Returns the number of CPU cores currently available to the runtime.

coresAvailable

coresAvailable (): int

Returns:

the number of CPU cores currently available to the runtime

Notes:

On multicore systems, this value can and sometimes will change over time.
The result is (perhaps obviously) guaranteed to be a positive integer.

std.text

The definitions in this file are designed to fulfill the following purposes:

text-processing and formatting facilities.

Functions

Signature	Description
join (delimiter: string, words: [string]): string	Concatenates the elements of words, separated by delimiter, into a single string.
rjust (width: int, fill: char, s: string): string	Right-justifies s in a field width characters wide.
ljust (width: int, fill: char, s: string): string	Left-justifies s in a field width characters wide.
fformat (form: string, f: float): string	Formats f according to format form.

join

join (delimiter: string, words: [string]): string

Parameters:

delimiter: any string
words: a sequence of strings

Returns:

the elements in words delimited by delimiter concatenated into a single string

rjust

rjust (width: int, fill: char, s: string): string

Parameters:

width: an integer greater than or equal to s's length
fill: any character
s: any string

Returns:

a string of length width where the first (width - strlen s) characters are fill and the rest are s

ljust

ljust (width: int, fill: char, s: string): string

Parameters:

width: an integer greater than or equal to s's length
fill: any character
s: any string

Returns:

a string of length width where the first (strlen s) characters are s and the rest are fill

fformat

fformat (form: string, f: float): string

Parameters:

form: a string representing a well-formed format
f: any float

Returns:

a string containing the value of f formatted as requested

Exceptions:

BadArgument: if form is malformed

Notes:

for format syntax, see http://download.oracle.com/javase/6/docs/api/java/text/DecimalFormat.html

std.thread

This header provides an interface to a simple thread-management system.

Constructors

Data Constructor	Type Constructor	Parameterization	Description
BadThreadId	ThreadException	string	Thrown on invalid thread id.

Functions

Signature	Description
isRunning (threadId: string): bool	Returns true if the specified thread is running; else, returns false
wait (threadId: string): void	Blocks this thread until the specified thread terminates, then reclaims its resources.
self (): string	Returns this thread's id.
sleep (msec: int): void	Suspends this thread's execution for at least msec milliseconds.
spawn (threadId: string, arg: `a, f: `a -> void): void	Spins off a new thread named threadId beginning execution with the function call (f arg).
yield (): void	Abandons the remainder of this thread's timeslice.

isRunning

isRunning (threadId: string): bool

Parameters:

threadId: a valid thread id

Returns:

true if this thread's mailbox is not empty; else, false

Exceptions:

BadThreadId: if threadId is invalid

wait

wait (threadId: string): void

Parameters:

threadId: a valid thread id

Exceptions:

BadThreadId: if threadId is invalid
Interrupted: if this operation has been interrupted

Notes:

blocks until the specified thread terminates, then reclaims its resources

self

self (): string

Returns:

this thread's id

sleep

sleep (msec: int): void

Parameters:

msec: a nonnegative integer

Exceptions:

OutOfRange: if msec < 0
Interrupted: if this operation has been interrupted

Notes:

suspends this thread's execution for at least msec milliseconds

spawn

spawn (threadId: string, arg: `a, f: `a -> void): void

Parameters:

threadId: a valid thread id
arg: any value
f: an entry-point function

Notes:

spins off a new thread named threadId beginning execution with the function call (f arg)

yield

yield (): void

Notes:

abandons the remainder of this thread's timeslice

[ sean.p.miller at gmail dot com ]

[ last updated Saturn's Day, 7 Apr 2012 ]

Slang Library Reference

Contents

std.alg

Functions

filter

foldl

foldr

foreach

map

zip

partition

generate

range

mapMaybe

merge

mergeSort

quickSort

find

findAll

binarySearch

std.basic

Constructors

Functions

int2str

int2radix

int2char

getprec

setprec

float2str

str2int

str2real

str2float

sub

substr

strlen

explode

char2str

char2int

bool2str

head

tail

rhead

rtail

len

implode

split

at

take

drop

insert

delete

slice

rev

val

isNothing

isSome

compare

send

recv

std.io

Constructors

Type Aliases

Constants

Functions

print

getline

open

close

eof

read

write

std.math

Functions

abs

promote

gcd

extEuclid

lcm

max

min