The Standard ML Basis Library

Unified identifier index

OTHER

`!, GENERAL`		<<		`/, REAL`
`!=, REAL`			`INT_INF`	`::, LIST`
>			`WORD`	`:=, GENERAL`
	`CHAR`	<=		`==, REAL`
	`INTEGER`		`CHAR`	`?=, REAL`
	`REAL`		`INTEGER`	`@, LIST`
	`STRING`		`REAL`	`^, STRING`
	`TIME`		`STRING`	~
	`WORD`		`TIME`		`INTEGER`
`>>, WORD`			`WORD`		`REAL`
>=		*			`WORD`
	`CHAR`		`INTEGER`	~>>
	`INTEGER`		`REAL`		`INT_INF`
	`REAL`		`WORD`		`WORD`
	`STRING`	`*+, REAL`
	`TIME`	`*-, REAL`
	`WORD`	+
<			`INTEGER`
	`CHAR`		`REAL`
	`INTEGER`		`TIME`
	`REAL`		`WORD`
	`STRING`	-
	`TIME`		`INTEGER`
	`WORD`		`REAL`
			`TIME`
			`WORD`

A

A_EXEC		`allAccess, WINDOWS.Key`		Array
	`OS_FILE_SYS`	`allEq, LIST_PAIR`			`<top level>`
	`POSIX_FILE_SYS`	`allSet, BIT_FLAGS`			`ImperativeIO`
A_READ		`alrm, POSIX_SIGNAL`			`PrimIO`
	`OS_FILE_SYS`	andb			`StreamIO`
	`POSIX_FILE_SYS`		`INT_INF`	array
A_WRITE			`WORD`		`ARRAY`
	`OS_FILE_SYS`	`any, INET_SOCK`			`ARRAY2`
	`POSIX_FILE_SYS`	`anySet, BIT_FLAGS`			`MONO_ARRAY`
`abrt, POSIX_SIGNAL`		app			`MONO_ARRAY2`
abs			`ARRAY`		`MONO_ARRAY_SLICE`
	`INTEGER`		`ARRAY2`		`PRIM_IO`
	`REAL`		`ARRAY_SLICE`	array
`accept, SOCKET`			`LIST`		`ARRAY`
`acceptNB, SOCKET`			`LIST_PAIR`		`ARRAY2`
`acces, POSIX_ERROR`			`MONO_ARRAY`		`MONO_ARRAY`
access			`MONO_ARRAY2`		`MONO_ARRAY2`
	`OS_FILE_SYS`		`MONO_ARRAY_SLICE`	`ARRAY2`
	`POSIX_FILE_SYS`		`MONO_VECTOR`	`Array2`
access_mode			`MONO_VECTOR_SLICE`	`ARRAY_SLICE`
	`OS_FILE_SYS`		`OPTION`	`array_slice, PRIM_IO`
	`POSIX_FILE_SYS`		`SUBSTRING`	`arrayBoundsExceeded, WINDOWS.Status`
`accessViolation, WINDOWS.Status`			`VECTOR`	ArraySlice
`acos, MATH`			`VECTOR_SLICE`		`<top level>`
`active, SOCKET`		append			`PrimIO`
`addr, NET_HOST_DB`			`POSIX_FILE_SYS.O`	`asin, MATH`
addr_family			`POSIX_IO.O`	`atan, MATH`
	`NET_HOST_DB`	`appEq, LIST_PAIR`		`atan2, MATH`
	`SOCKET.AF`	appi		`atExit, OS_PROCESS`
`addrs, NET_HOST_DB`			`ARRAY`	`atime, POSIX_FILE_SYS.ST`
`addrType, NET_HOST_DB`			`ARRAY2`	`Aug, DATE`
`AF, SOCKET`			`ARRAY_SLICE`	`augmentReader, PRIM_IO`
`again, POSIX_ERROR`			`MONO_ARRAY`	`augmentWriter, PRIM_IO`
`alarm, POSIX_PROCESS`			`MONO_ARRAY2`
aliases			`MONO_ARRAY_SLICE`
	`NET_HOST_DB`		`MONO_VECTOR`
	`NET_PROT_DB`		`MONO_VECTOR_SLICE`
	`NET_SERV_DB`		`VECTOR`
all			`VECTOR_SLICE`
	`ARRAY`	`Apr, DATE`
	`ARRAY_SLICE`	`arguments, COMMAND_LINE`
	`BIT_FLAGS`	`ARRAY`
	`LIST`
	`LIST_PAIR`
	`MONO_ARRAY`
	`MONO_ARRAY_SLICE`
	`MONO_VECTOR`
	`MONO_VECTOR_SLICE`
	`VECTOR`
	`VECTOR_SLICE`

B

`b0, POSIX_TTY`		`before, GENERAL`		`BoolArray2`
`b110, POSIX_TTY`		`BIN, STRING_CVT`		`BoolArraySlice`
`b1200, POSIX_TTY`		`BIN_IO`		`BoolVector`
`b134, POSIX_TTY`		`BINARY, WINDOWS.Reg`		`BoolVectorSlice`
`b150, POSIX_TTY`		`Bind, GENERAL`		`breakpoint, WINDOWS.Status`
`b1800, POSIX_TTY`		`bind, SOCKET`		`brkint, POSIX_TTY.I`
`b19200, POSIX_TTY`		binInstreamOf		`buffer_mode, IO`
`b200, POSIX_TTY`			`UNIX`	`bus, POSIX_SIGNAL`
`b2400, POSIX_TTY`			`WINDOWS`	`busy, POSIX_ERROR`
`b300, POSIX_TTY`		`BinIO`		`BYTE`
`b38400, POSIX_TTY`		binOutstreamOf		`Byte`
`b4800, POSIX_TTY`			`UNIX`	bytesPerElem
`b50, POSIX_TTY`			`WINDOWS`		`PACK_REAL`
`b600, POSIX_TTY`		`BinPrimIO`			`PACK_WORD`
`b75, POSIX_TTY`		`BIT_FLAGS`		`bytesToString, BYTE`
`b9600, POSIX_TTY`		`BLOCK_BUF, IO`		`byteToChar, BYTE`
`badf, POSIX_ERROR`		`BlockingNotSupported, IO`
`badmsg, POSIX_ERROR`		`BOOL`
base		`Bool`
	`ARRAY_SLICE`	`bool, BOOL`
	`MONO_ARRAY_SLICE`	`BoolArray`
	`MONO_VECTOR_SLICE`
	`OS_PATH`
	`SUBSTRING`
	`VECTOR_SLICE`

C

`C, POSIX_TTY`		`closeDir, OS_FILE_SYS`		concatWith
`canceled, POSIX_ERROR`		`closedir, POSIX_FILE_SYS`			`STRING`
canInput		`ClosedStream, IO`			`SUBSTRING`
	`IMPERATIVE_IO`	closeIn		`Config, WINDOWS`
	`STREAM_IO`		`IMPERATIVE_IO`	`connect, SOCKET`
`cc, POSIX_TTY.V`			`STREAM_IO`	`connectNB, SOCKET`
`cc, POSIX_TTY.V`		`closeKey, WINDOWS.Reg`		`cont, POSIX_SIGNAL`
`ceil, REAL`		closeOut		`contains, CHAR`
`CF, POSIX_TTY`			`IMPERATIVE_IO`	`controlCExit, WINDOWS.Status`
`CHAR`			`STREAM_IO`	copy
Char		collate			`ARRAY`
	`<top level>`		`ARRAY`		`ARRAY2`
	`TEXT`		`ARRAY_SLICE`		`ARRAY_SLICE`
char			`LIST`		`MONO_ARRAY`
	`CHAR`		`MONO_ARRAY`		`MONO_ARRAY2`
	`STRING`		`MONO_ARRAY_SLICE`		`MONO_ARRAY_SLICE`
	`SUBSTRING`		`MONO_VECTOR`	`copySign, REAL`
CharArray			`MONO_VECTOR_SLICE`	copyVec
	`<top level>`		`STRING`		`ARRAY`
	`TEXT`		`SUBSTRING`		`ARRAY_SLICE`
`CharArray2`			`VECTOR`		`MONO_ARRAY`
CharArraySlice			`VECTOR_SLICE`		`MONO_ARRAY_SLICE`
	`<top level>`	`ColMajor, ARRAY2`		`cos, MATH`
	`TEXT`	column		`cosh, MATH`
`charToByte, BYTE`			`ARRAY2`	`cpu_timer, TIMER`
CharVector			`MONO_ARRAY2`	`cread, POSIX_TTY.C`
	`<top level>`	`COMMAND_LINE`		`creat, POSIX_FILE_SYS`
	`TEXT`	`CommandLine`		`create_result, WINDOWS.Reg`
CharVectorSlice		compare		`CREATED_NEW_KEY, WINDOWS.Reg`
	`<top level>`		`CHAR`	`createf, POSIX_FILE_SYS`
	`TEXT`		`DATE`	`createKeyEx, WINDOWS.Reg`
`chDir, OS_FILE_SYS`			`INTEGER`	`createLink, WINDOWS.Key`
`chdir, POSIX_FILE_SYS`			`OS_FILE_SYS`	`createSubKey, WINDOWS.Key`
`checkCPUTimer, TIMER`			`OS_IO`	`cs, STRING_CVT`
`checkFloat, REAL`			`PRIM_IO`	`cs5, POSIX_TTY.C`
`checkGCTime, TIMER`			`PrimIO`	`cs6, POSIX_TTY.C`
`checkRealTimer, TIMER`			`REAL`	`cs7, POSIX_TTY.C`
`child, POSIX_ERROR`			`STRING`	`cs8, POSIX_TTY.C`
`chld, POSIX_SIGNAL`			`SUBSTRING`	`csize, POSIX_TTY.C`
`chmod, POSIX_FILE_SYS`			`TIME`	`cstopb, POSIX_TTY.C`
`chown, POSIX_FILE_SYS`			`WORD`	`ctermid, POSIX_PROC_ENV`
`Chr, GENERAL`		`compareReal, REAL`		`ctime, POSIX_FILE_SYS.ST`
`chr, CHAR`		`compareSpeed, POSIX_TTY`		`Ctl, SOCKET`
`class, REAL`		`compose, OPTION`		`currentArc, OS_PATH`
`classesRoot, WINDOWS.Reg`		`composePartial, OPTION`		`currentConfig, WINDOWS.Reg`
`clear, BIT_FLAGS`		concat		`currentUser, WINDOWS.Reg`
`clocal, POSIX_TTY.C`			`LIST`
`cloexec, POSIX_IO.FD`			`MONO_VECTOR`
close			`MONO_VECTOR_SLICE`
	`POSIX_IO`		`OS_PATH`
	`SOCKET`		`STRING`
			`SUBSTRING`
			`VECTOR`
			`VECTOR_SLICE`

D

`datatypeMisalignment, WINDOWS.Status`	`devToWord, POSIX_FILE_SYS`		div
`DATE`	`dgram, SOCKET`			`INTEGER`
`Date`	`dgram, SOCKET.SOCK`			`WORD`
`Date, DATE`	dgram_sock		`divMod, INT_INF`
`date, DATE`		`INET_SOCK`	`dom, POSIX_ERROR`
`date, DATE`		`UNIX_SOCK`	`Domain, GENERAL`
`day, DATE`	`DGrm, UNIX_SOCK`		`drain, POSIX_TTY.TC`
`DDE, WINDOWS`	dimensions		`drop, LIST`
`deadlk, POSIX_ERROR`		`ARRAY2`	dropl
`DEC, STRING_CVT`		`MONO_ARRAY2`		`STRING_CVT`
`Dec, DATE`	dir			`SUBSTRING`
`decimal_approx, IEEE_REAL`		`OS_IO.Kind`	`dropr, SUBSTRING`
`deleteKey, WINDOWS.Reg`		`OS_PATH`	`dup, POSIX_IO`
`deleteValue, WINDOWS.Reg`	dirstream		`dup2, POSIX_IO`
`dev, POSIX_FILE_SYS`		`OS_FILE_SYS`	`dupfd, POSIX_IO`
`dev, POSIX_FILE_SYS.ST`		`POSIX_FILE_SYS`	`DWORD, WINDOWS.Reg`
`device, OS_IO.Kind`	`Div, GENERAL`		`dynData, WINDOWS.Reg`

E

`e, MATH`		EQUAL		exit
`echo, POSIX_TTY.L`			`GENERAL`		`OS_PROCESS`
`echoe, POSIX_TTY.L`			`IEEE_REAL`		`POSIX_PROCESS`
`echok, POSIX_TTY.L`		`erase, POSIX_TTY.V`			`UNIX`
`echonl, POSIX_TTY.L`		`Error, POSIX`			`WINDOWS`
elem		errorMsg		exit_status
	`IMPERATIVE_IO`		`OS`		`POSIX_PROCESS`
	`MONO_ARRAY`		`POSIX_ERROR`		`UNIX`
	`MONO_ARRAY2`	errorName		`exn, GENERAL`
	`MONO_ARRAY_SLICE`		`OS`	`exnMessage, GENERAL`
	`MONO_VECTOR`		`POSIX_ERROR`	`exnName, GENERAL`
	`MONO_VECTOR_SLICE`	`EXACT, STRING_CVT`		`exp, MATH`
	`PRIM_IO`	`excl, POSIX_FILE_SYS.O`		`EXPAND_SZ, WINDOWS.Reg`
	`STREAM_IO`	`exec, POSIX_PROCESS`		explode
`Empty, LIST`		`exece, POSIX_PROCESS`			`STRING`
endOfStream		`execp, POSIX_PROCESS`			`SUBSTRING`
	`IMPERATIVE_IO`	execute		`ext, OS_PATH`
	`STREAM_IO`		`UNIX`	extract
entry			`WINDOWS`		`STRING`
	`NET_HOST_DB`		`WINDOWS.Key`		`SUBSTRING`
	`NET_PROT_DB`	`executeInEnv, UNIX`
	`NET_SERV_DB`	`executeString, WINDOWS.DDE`
`enumerateSubKeys, WINDOWS.Key`		`exist, POSIX_ERROR`
`enumKeyEx, WINDOWS.Reg`		exists
`enumValueEx, WINDOWS.Reg`			`ARRAY`
`environ, POSIX_PROC_ENV`			`ARRAY_SLICE`
`eof, POSIX_TTY.V`			`LIST`
`eol, POSIX_TTY.V`			`LIST_PAIR`
			`MONO_ARRAY`
			`MONO_ARRAY_SLICE`
			`MONO_VECTOR`
			`MONO_VECTOR_SLICE`
			`VECTOR`
			`VECTOR_SLICE`

F

`F_RDLCK, POSIX_IO`		`floatUnderflow, WINDOWS.Status`		`Fri, DATE`
`F_UNLCK, POSIX_IO`		`FLock, POSIX_IO`		fromAddr
`F_WRLCK, POSIX_IO`		`flock, POSIX_IO.FLock`			`INET_SOCK`
`Fail, GENERAL`		`flock, POSIX_IO.FLock`			`UNIX_SOCK`
`failure, OS_PROCESS`		`floor, REAL`		`fromBytes, PACK_REAL`
`false, BOOL`		`flow, POSIX_TTY.TC`		fromCString
`familyOfAddr, SOCKET`		`flow_action, POSIX_TTY.TC`			`CHAR`
`fault, POSIX_ERROR`		`flush, POSIX_TTY.TC`			`STRING`
`fbig, POSIX_ERROR`		flushOut		`fromDecimal, REAL`
`fchmod, POSIX_FILE_SYS`			`IMPERATIVE_IO`	fromInt
`fchown, POSIX_FILE_SYS`			`STREAM_IO`		`INTEGER`
`FD, POSIX_IO`		fmt			`REAL`
`fdToIOD, POSIX_FILE_SYS`			`DATE`		`WORD`
`fdToWord, POSIX_FILE_SYS`			`INTEGER`	fromLarge
`Feb, DATE`			`REAL`		`INTEGER`
fields			`TIME`		`REAL`
	`STRING`		`WORD`		`WORD`
	`SUBSTRING`	fold		fromLargeInt
`fieldsOf, POSIX_TTY`			`ARRAY2`		`REAL`
file			`MONO_ARRAY2`		`WORD`
	`OS_IO.Kind`	foldi		`fromLargeWord, WORD`
	`OS_PATH`		`ARRAY2`	fromList
file_desc			`MONO_ARRAY2`		`ARRAY`
	`POSIX_FILE_SYS`	foldl			`ARRAY2`
	`POSIX_IO`		`ARRAY`		`MONO_ARRAY`
	`POSIX_PROC_ENV`		`ARRAY_SLICE`		`MONO_ARRAY2`
	`POSIX_TTY`		`LIST`		`MONO_VECTOR`
`file_id, OS_FILE_SYS`			`LIST_PAIR`		`VECTOR`
`fileId, OS_FILE_SYS`			`MONO_ARRAY`	`fromManExp, REAL`
`filePosIn, STREAM_IO`			`MONO_ARRAY_SLICE`	`fromMicroseconds, TIME`
`filePosOut, STREAM_IO`			`MONO_VECTOR`	`fromMilliseconds, TIME`
`fileSize, OS_FILE_SYS`			`MONO_VECTOR_SLICE`	`fromNanoseconds, TIME`
FileSys			`SUBSTRING`	`fromReal, TIME`
	`OS`		`VECTOR`	`fromSeconds, TIME`
	`POSIX`		`VECTOR_SLICE`	fromStatus
filter		`foldlEq, LIST_PAIR`			`POSIX_PROCESS`
	`LIST`	foldli			`UNIX`
	`OPTION`		`ARRAY`		`WINDOWS`
find			`ARRAY_SLICE`	fromString
	`ARRAY`		`MONO_ARRAY`		`BOOL`
	`ARRAY_SLICE`		`MONO_ARRAY_SLICE`		`CHAR`
	`LIST`		`MONO_VECTOR`		`DATE`
	`MONO_ARRAY`		`MONO_VECTOR_SLICE`		`IEEE_REAL`
	`MONO_ARRAY_SLICE`		`VECTOR`		`INTEGER`
	`MONO_VECTOR`		`VECTOR_SLICE`		`NET_HOST_DB`
	`MONO_VECTOR_SLICE`	foldr			`OS_PATH`
	`VECTOR`		`ARRAY`		`REAL`
	`VECTOR_SLICE`		`ARRAY_SLICE`		`SOCKET.AF`
`findExecutable, WINDOWS`			`LIST`		`SOCKET.SOCK`
findi			`LIST_PAIR`		`STRING`
	`ARRAY`		`MONO_ARRAY`		`TIME`
	`ARRAY_SLICE`		`MONO_ARRAY_SLICE`		`WORD`
	`MONO_ARRAY`		`MONO_VECTOR`	`fromTimeLocal, DATE`
	`MONO_ARRAY_SLICE`		`MONO_VECTOR_SLICE`	`fromTimeUniv, DATE`
	`MONO_VECTOR`		`SUBSTRING`	`fromUnixPath, OS_PATH`
	`MONO_VECTOR_SLICE`		`VECTOR`	fromWord
	`VECTOR`		`VECTOR_SLICE`		`BIT_FLAGS`
	`VECTOR_SLICE`	`foldrEq, LIST_PAIR`			`POSIX_ERROR`
`first, SUBSTRING`		foldri			`POSIX_SIGNAL`
`FIX, STRING_CVT`			`ARRAY`	`fstat, POSIX_FILE_SYS`
`FixedInt`			`ARRAY_SLICE`	`fsync, POSIX_IO`
`flags, BIT_FLAGS`			`MONO_ARRAY`	`ftruncate, POSIX_FILE_SYS`
`flags, BIT_FLAGS`			`MONO_ARRAY_SLICE`	full
`float_class, IEEE_REAL`			`MONO_VECTOR`		`ARRAY_SLICE`
`floatDenormalOperand, WINDOWS.Status`			`MONO_VECTOR_SLICE`		`MONO_ARRAY_SLICE`
`floatDivideByZero, WINDOWS.Status`			`VECTOR`		`MONO_VECTOR_SLICE`
`floatInexactResult, WINDOWS.Status`			`VECTOR_SLICE`		`SUBSTRING`
`floatInvalidOperation, WINDOWS.Status`		`fork, POSIX_PROCESS`			`VECTOR_SLICE`
`floatOverflow, WINDOWS.Status`		`fpathconf, POSIX_FILE_SYS`		`fullPath, OS_FILE_SYS`
`floatStackCheck, WINDOWS.Status`		`fpe, POSIX_SIGNAL`

G

`GEN, STRING_CVT`		`getgrnam, POSIX_SYS_DB`		`getppid, POSIX_PROC_ENV`
`GENERAL`		`getgroups, POSIX_PROC_ENV`		`getpwnam, POSIX_SYS_DB`
`General`		`getHostName, NET_HOST_DB`		`getpwuid, POSIX_SYS_DB`
`GENERIC_SOCK`		`getiflag, POSIX_TTY`		`getRCVBUF, SOCKET.Ctl`
`GenericSock`		`getInstream, IMPERATIVE_IO`		`getReader, STREAM_IO`
`getATMARK, SOCKET.Ctl`		`getispeed, POSIX_TTY.CF`		`getREUSEADDR, SOCKET.Ctl`
`getattr, POSIX_TTY.TC`		getItem		`getRoundingMode, IEEE_REAL`
`getBROADCAST, SOCKET.Ctl`			`ARRAY_SLICE`	`getSNDBUF, SOCKET.Ctl`
`getBufferMode, STREAM_IO`			`LIST`	`getSockName, SOCKET.Ctl`
`getByAddr, NET_HOST_DB`			`MONO_ARRAY_SLICE`	`getSystemDirectory, WINDOWS.Config`
getByName			`MONO_VECTOR_SLICE`	`getTYPE, SOCKET.Ctl`
	`NET_HOST_DB`		`VECTOR_SLICE`	`getuid, POSIX_PROC_ENV`
	`NET_PROT_DB`	`getKEEPALIVE, SOCKET.Ctl`		`getUserName, WINDOWS.Config`
	`NET_SERV_DB`	`getlflag, POSIX_TTY`		`getVersionEx, WINDOWS.Config`
`getByNumber, NET_PROT_DB`		`getLINGER, SOCKET.Ctl`		`getVolume, OS_PATH`
`getByPort, NET_SERV_DB`		`getlk, POSIX_IO`		`getVolumeInformation, WINDOWS`
`getc, SUBSTRING`		`getlogin, POSIX_PROC_ENV`		`getWindowsDirectory, WINDOWS.Config`
`getcc, POSIX_TTY`		`getNODELAY, INET_SOCK.TCP`		`getWriter, STREAM_IO`
`getcflag, POSIX_TTY`		`getNREAD, SOCKET.Ctl`		gid
`getComputerName, WINDOWS.Config`		`getoflag, POSIX_TTY`			`POSIX_FILE_SYS`
`getcwd, POSIX_FILE_SYS`		`getOOBINLINE, SOCKET.Ctl`			`POSIX_PROC_ENV`
`getDEBUG, SOCKET.Ctl`		`getOpt, OPTION`			`POSIX_SYS_DB`
`getDir, OS_FILE_SYS`		`getospeed, POSIX_TTY.CF`		gid
`getDONTROUTE, SOCKET.Ctl`		`getOutstream, IMPERATIVE_IO`			`POSIX_FILE_SYS.ST`
`getegid, POSIX_PROC_ENV`		`getParent, OS_PATH`			`POSIX_SYS_DB.Group`
`getEnv, OS_PROCESS`		`getPeerName, SOCKET.Ctl`			`POSIX_SYS_DB.Passwd`
`getenv, POSIX_PROC_ENV`		getpgrp		`gidToWord, POSIX_PROC_ENV`
`getERROR, SOCKET.Ctl`			`POSIX_PROC_ENV`	GREATER
`geteuid, POSIX_PROC_ENV`			`POSIX_TTY.TC`		`GENERAL`
`getfd, POSIX_IO`		`getpid, POSIX_PROC_ENV`			`IEEE_REAL`
`getfl, POSIX_IO`		getPosOut		`Group, POSIX_SYS_DB`
`getgid, POSIX_PROC_ENV`			`IMPERATIVE_IO`	`group, POSIX_SYS_DB.Group`
`getgrgid, POSIX_SYS_DB`			`STREAM_IO`	`guardPageViolation, WINDOWS.Status`

H

hash		`HEX, STRING_CVT`	`hup, POSIX_SIGNAL`
	`OS_FILE_SYS`	`hkey, WINDOWS.Reg`	`hupcl, POSIX_TTY.C`
	`OS_IO`	`home, POSIX_SYS_DB.Passwd`
`hd, LIST`		`hour, DATE`

I

`I, POSIX_TTY`		`Int{N}Array`		isDir
`icanon, POSIX_TTY.L`		`Int{N}Array2`			`OS_FILE_SYS`
`icrnl, POSIX_TTY.I`		`Int{N}ArraySlice`			`POSIX_FILE_SYS.ST`
`IEEE_REAL`		`Int{N}Vector`		`isdir, POSIX_ERROR`
`IEEEReal`		`Int{N}VectorSlice`		`isDst, DATE`
`iexten, POSIX_TTY.L`		`IntArray`		isEmpty
`iflush, POSIX_TTY.TC`		`IntArray2`			`ARRAY_SLICE`
`ignbrk, POSIX_TTY.I`		`IntArraySlice`			`MONO_ARRAY_SLICE`
`igncr, POSIX_TTY.I`		`INTEGER`			`MONO_VECTOR_SLICE`
`ignore, GENERAL`		`integerDivideByZero, WINDOWS.Status`			`SUBSTRING`
`ignpar, POSIX_TTY.I`		`integerOverflow, WINDOWS.Status`			`VECTOR_SLICE`
`ill, POSIX_SIGNAL`		`intersect, BIT_FLAGS`		`isFIFO, POSIX_FILE_SYS.ST`
`illegalInstruction, WINDOWS.Status`		`IntInf`		`isFinite, REAL`
`IMPERATIVE_IO`		intr		`isgid, POSIX_FILE_SYS.S`
`ImperativeIO`			`POSIX_ERROR`	`isGraph, CHAR`
`implode, STRING`			`POSIX_TTY.V`	`isHexDigit, CHAR`
`in_addr, NET_HOST_DB`		`IntVector`		`isig, POSIX_TTY.L`
`in_flags, SOCKET`		`IntVectorSlice`		`isIn, OS_IO`
`inet, INET_SOCK`		`inval, POSIX_ERROR`		isLink
`INET_SOCK`		`InvalidArc, OS_PATH`			`OS_FILE_SYS`
`inetAF, INET_SOCK`		`invalidDisposition, WINDOWS.Status`			`POSIX_FILE_SYS.ST`
`INetSock`		`invalidHandle, WINDOWS.Status`		`isLower, CHAR`
`INF, IEEE_REAL`		`IO`		`isNan, REAL`
`info, WINDOWS.DDE`		IO		`isNormal, REAL`
`infoToPollDesc, OS_IO`			`<top level>`	`isOut, OS_IO`
`inlcr, POSIX_TTY.I`			`OS`	isPrefix
`ino, POSIX_FILE_SYS`			`POSIX`		`STRING`
`ino, POSIX_FILE_SYS.ST`		`Io, IO`			`SUBSTRING`
`inoToWord, POSIX_FILE_SYS`		`io, POSIX_ERROR`		`isPri, OS_IO`
`inPageError, WINDOWS.Status`		`ioDesc, SOCKET`		`isPrint, CHAR`
`inpck, POSIX_TTY.I`		`iodesc, OS_IO`		`isPunct, CHAR`
`inprogress, POSIX_ERROR`		`iodesc_kind, OS_IO`		`isReg, POSIX_FILE_SYS.ST`
input		`iodToFD, POSIX_FILE_SYS`		`isRelative, OS_PATH`
	`IMPERATIVE_IO`	`ioff, POSIX_TTY.TC`		`isRoot, OS_PATH`
	`STREAM_IO`	`ioflush, POSIX_TTY.TC`		`isSock, POSIX_FILE_SYS.ST`
input1		`ion, POSIX_TTY.TC`		`isSome, OPTION`
	`IMPERATIVE_IO`	`irgrp, POSIX_FILE_SYS.S`		`isSpace, CHAR`
	`STREAM_IO`	`iroth, POSIX_FILE_SYS.S`		isSubstring
inputAll		`irusr, POSIX_FILE_SYS.S`			`STRING`
	`IMPERATIVE_IO`	`irwxg, POSIX_FILE_SYS.S`			`SUBSTRING`
	`STREAM_IO`	`irwxo, POSIX_FILE_SYS.S`		`isSuccess, OS_PROCESS`
inputLine		`irwxu, POSIX_FILE_SYS.S`		isSuffix
	`TEXT_IO`	`isAbsolute, OS_PATH`			`STRING`
	`TEXT_STREAM_IO`	`isAlpha, CHAR`			`SUBSTRING`
inputN		`isAlphaNum, CHAR`		`istrip, POSIX_TTY.I`
	`IMPERATIVE_IO`	`isAscii, CHAR`		`isuid, POSIX_FILE_SYS.S`
	`STREAM_IO`	`isatty, POSIX_PROC_ENV`		`isUpper, CHAR`
instream		isBigEndian		`iwgrp, POSIX_FILE_SYS.S`
	`IMPERATIVE_IO`		`PACK_REAL`	`iwoth, POSIX_FILE_SYS.S`
	`STREAM_IO`		`PACK_WORD`	`iwusr, POSIX_FILE_SYS.S`
`Int`		`isBlk, POSIX_FILE_SYS.ST`		`ixgrp, POSIX_FILE_SYS.S`
`int, INTEGER`		`isCanonical, OS_PATH`		`ixoff, POSIX_TTY.I`
`int, POSIX_SIGNAL`		`isChr, POSIX_FILE_SYS.ST`		`ixon, POSIX_TTY.I`
`INT_INF`		`isCntrl, CHAR`		`ixoth, POSIX_FILE_SYS.S`
`Int{N}`		`isDigit, CHAR`		`ixusr, POSIX_FILE_SYS.S`

J

`Jan, DATE`		`joinBaseExt, OS_PATH`		`Jul, DATE`
`join, OPTION`		`joinDirFile, OS_PATH`		`Jun, DATE`

K

`K_GROUP, POSIX_PROCESS`	kill		`killpid_arg, POSIX_PROCESS`
`K_PROC, POSIX_PROCESS`		`POSIX_PROCESS`	`Kind, OS_IO`
`K_SAME_GROUP, POSIX_PROCESS`		`POSIX_SIGNAL`	`kind, OS_IO`
`Key, WINDOWS`		`POSIX_TTY.V`
		`UNIX`

L

`L, POSIX_TTY`	`last, LIST`		`List`
`LargeInt`	`launchApplication, WINDOWS`		`list, LIST`
`LargeIntArray`	`len, POSIX_IO.FLock`		list
`LargeIntArray2`	length			`SOCKET.AF`
`LargeIntArraySlice`		`ARRAY`		`SOCKET.SOCK`
`LargeIntVector`		`ARRAY_SLICE`	`LIST_PAIR`
`LargeIntVectorSlice`		`LIST`	`listen, SOCKET`
`LargeReal`		`MONO_ARRAY`	`ListPair`
`LargeRealArray`		`MONO_ARRAY_SLICE`	`ln, MATH`
`LargeRealArray2`		`MONO_VECTOR`	`localMachine, WINDOWS.Reg`
`LargeRealArraySlice`		`MONO_VECTOR_SLICE`	`localOffset, DATE`
`LargeRealVector`		`VECTOR`	`lock_type, POSIX_IO`
`LargeRealVectorSlice`		`VECTOR_SLICE`	`log10, MATH`
`LargeWord`	LESS		`log2, INT_INF`
`LargeWordArray`		`GENERAL`	`lookahead, IMPERATIVE_IO`
`LargeWordArray2`		`IEEE_REAL`	`loop, POSIX_ERROR`
`LargeWordArraySlice`	`LINE_BUF, IO`		`lseek, POSIX_IO`
`LargeWordVector`	`link, POSIX_FILE_SYS`		`lstat, POSIX_FILE_SYS`
`LargeWordVectorSlice`	`LIST`		`ltype, POSIX_IO.FLock`

M

map		`maxOrd, CHAR`		`mode, POSIX_FILE_SYS.S`
	`LIST`	`maxSize, STRING`		`mode, POSIX_FILE_SYS.ST`
	`LIST_PAIR`	`May, DATE`		modify
	`MONO_VECTOR`	`members, POSIX_SYS_DB.Group`			`ARRAY`
	`MONO_VECTOR_SLICE`	`mfile, POSIX_ERROR`			`ARRAY2`
	`OPTION`	min			`ARRAY_SLICE`
	`STRING`		`INTEGER`		`MONO_ARRAY`
	`VECTOR`		`POSIX_TTY.V`		`MONO_ARRAY2`
	`VECTOR_SLICE`		`REAL`		`MONO_ARRAY_SLICE`
`mapEq, LIST_PAIR`			`WORD`	modifyi
mapi		`minChar, CHAR`			`ARRAY`
	`MONO_VECTOR`	`minInt, INTEGER`			`ARRAY2`
	`MONO_VECTOR_SLICE`	`minNormalPos, REAL`			`ARRAY_SLICE`
	`VECTOR`	`minPos, REAL`			`MONO_ARRAY`
	`VECTOR_SLICE`	`minute, DATE`			`MONO_ARRAY2`
mapPartial		`mkAbsolute, OS_PATH`			`MONO_ARRAY_SLICE`
	`LIST`	`mkBinReader, POSIX_IO`		`modTime, OS_FILE_SYS`
	`OPTION`	`mkBinWriter, POSIX_IO`		`Mon, DATE`
`Mar, DATE`		`mkCanonical, OS_PATH`		`MONO_ARRAY`
`Match, GENERAL`		`mkDir, OS_FILE_SYS`		`MONO_ARRAY2`
`MATH`		`mkdir, POSIX_FILE_SYS`		`MONO_ARRAY_SLICE`
Math		`mkfifo, POSIX_FILE_SYS`		`MONO_VECTOR`
	`<top level>`	mkInstream		`MONO_VECTOR_SLICE`
	`REAL`		`IMPERATIVE_IO`	`month, DATE`
max			`STREAM_IO`	`month, DATE`
	`INTEGER`	mkOutstream		`msgsize, POSIX_ERROR`
	`REAL`		`IMPERATIVE_IO`	`mtime, POSIX_FILE_SYS.ST`
	`WORD`		`STREAM_IO`	`MULTI_SZ, WINDOWS.Reg`
`maxChar, CHAR`		`mkRelative, OS_PATH`
`maxFinite, REAL`		`mkTextReader, POSIX_IO`
`maxInt, INTEGER`		`mkTextWriter, POSIX_IO`
maxLen		`mlink, POSIX_ERROR`
	`ARRAY`	mod
	`MONO_ARRAY`		`INTEGER`
	`MONO_VECTOR`		`WORD`
	`VECTOR`

N

name		`nil, LIST`		`not, BOOL`
	`COMMAND_LINE`	`nlink, POSIX_FILE_SYS.ST`		notb
	`NET_HOST_DB`	`NO_BUF, IO`			`INT_INF`
	`NET_PROT_DB`	`NO_RECVS, SOCKET`			`WORD`
	`NET_SERV_DB`	`NO_RECVS_OR_SENDS, SOCKET`		`notContains, CHAR`
	`POSIX_SYS_DB.Group`	`NO_SENDS, SOCKET`		`notdir, POSIX_ERROR`
	`POSIX_SYS_DB.Passwd`	`noctty, POSIX_FILE_SYS.O`		`notempty, POSIX_ERROR`
`nametoolong, POSIX_ERROR`		`nodev, POSIX_ERROR`		`notify, WINDOWS.Key`
`NAN, IEEE_REAL`		`noent, POSIX_ERROR`		`notsup, POSIX_ERROR`
`nccs, POSIX_TTY.V`		`noexec, POSIX_ERROR`		`notty, POSIX_ERROR`
nCols		`noflsh, POSIX_TTY.L`		`Nov, DATE`
	`ARRAY2`	`nolck, POSIX_ERROR`		`now, TIME`
	`MONO_ARRAY2`	`nomem, POSIX_ERROR`		nRows
`negInf, REAL`		nonblock			`ARRAY2`
`NET_HOST_DB`			`POSIX_FILE_SYS.O`		`MONO_ARRAY2`
`NET_PROT_DB`			`POSIX_IO.O`	`nth, LIST`
`NET_SERV_DB`		`NonblockingNotSupported, IO`		`null, LIST`
`NetHostDB`		`noncontinuableException, WINDOWS.Status`		`nullRd, PRIM_IO`
`NetProtDB`		`NONE, OPTION`		`nullWr, PRIM_IO`
`NetServDB`		`NORMAL, IEEE_REAL`		`nxio, POSIX_ERROR`
`nextAfter, REAL`		`nospc, POSIX_ERROR`
`nfile, POSIX_ERROR`		`nosys, POSIX_ERROR`

O

O		`openDir, OS_FILE_SYS`		`OS`
	`POSIX_FILE_SYS`	`opendir, POSIX_FILE_SYS`		`OS`
	`POSIX_IO`	`openDocument, WINDOWS`		`OS_FILE_SYS`
	`POSIX_TTY`	`OPENED_EXISTING_KEY, WINDOWS.Reg`		`OS_IO`
`o, GENERAL`		`openf, POSIX_FILE_SYS`		`OS_PATH`
O_RDONLY		openIn		`OS_PROCESS`
	`POSIX_FILE_SYS`		`BIN_IO`	`out_flags, SOCKET`
	`POSIX_IO`		`TEXT_IO`	`out_pos, STREAM_IO`
O_RDWR		`openKeyEx, WINDOWS.Reg`		output
	`POSIX_FILE_SYS`	openOut			`IMPERATIVE_IO`
	`POSIX_IO`		`BIN_IO`		`STREAM_IO`
O_WRONLY			`TEXT_IO`	output1
	`POSIX_FILE_SYS`	`openString, TEXT_IO`			`IMPERATIVE_IO`
	`POSIX_IO`	`openVector, PRIM_IO`			`STREAM_IO`
`OCT, STRING_CVT`		`opost, POSIX_TTY.O`		outputSubstr
`Oct, DATE`		`OPTION`			`TEXT_IO`
`offset, DATE`		`Option`			`TEXT_STREAM_IO`
`oflush, POSIX_TTY.TC`		`Option, OPTION`		outstream
`ooff, POSIX_TTY.TC`		`option, OPTION`			`IMPERATIVE_IO`
`oon, POSIX_TTY.TC`		orb			`STREAM_IO`
open_mode			`INT_INF`	`Overflow, GENERAL`
	`POSIX_FILE_SYS`		`WORD`
	`POSIX_IO`	`ord, CHAR`
openAppend		`order, GENERAL`
	`BIN_IO`
	`TEXT_IO`

P

`PACK_REAL`		`pid, POSIX_IO.FLock`		`POSIX_FILE_SYS`
`PACK_WORD`		`pidToWord, POSIX_PROCESS`		`POSIX_IO`
`PackReal{N}Big`		pipe		`POSIX_PROC_ENV`
`PackReal{N}Little`			`OS_IO.Kind`	`POSIX_PROCESS`
`PackRealBig`			`POSIX_ERROR`	`POSIX_SIGNAL`
`PackRealLittle`			`POSIX_IO`	`POSIX_SYS_DB`
`packString, BYTE`			`POSIX_SIGNAL`	`POSIX_TTY`
`PackWord{N}Big`		`platformWin32CE, WINDOWS.Config`		pow
`PackWord{N}Little`		`platformWin32NT, WINDOWS.Config`			`INT_INF`
`padLeft, STRING_CVT`		`platformWin32s, WINDOWS.Config`			`MATH`
`padRight, STRING_CVT`		`platformWin32Windows, WINDOWS.Config`		precision
`parenb, POSIX_TTY.C`		`Poll, OS_IO`			`INTEGER`
`parentArc, OS_PATH`		`poll, OS_IO`			`REAL`
`parmrk, POSIX_TTY.I`		`poll_desc, OS_IO`		`pred, CHAR`
`parodd, POSIX_TTY.C`		`poll_info, OS_IO`		`PRIM_IO`
`partition, LIST`		`pollDesc, OS_IO`		`PrimIO, StreamIO`
`passive, SOCKET`		`pollIn, OS_IO`		`PrimIO`
`Passwd, POSIX_SYS_DB`		`pollOut, OS_IO`		`print, TEXT_IO`
`passwd, POSIX_SYS_DB.Passwd`		`pollPri, OS_IO`		`privilegedInstruction, WINDOWS.Status`
`Path, OS`		`pollToIODesc, OS_IO`		proc
`Path, OS_PATH`		`port, NET_SERV_DB`			`UNIX`
`pathconf, POSIX_FILE_SYS`		pos			`WINDOWS`
`pause, POSIX_PROCESS`			`PRIM_IO`	`ProcEnv, POSIX`
`pending, WINDOWS.Status`			`PrimIO`	Process
`performanceData, WINDOWS.Reg`			`STREAM_IO`		`OS`
`perm, POSIX_ERROR`		`posInf, REAL`			`POSIX`
`pi, MATH`		`Position`		protocol
pid		`position, SUBSTRING`			`NET_PROT_DB`
	`POSIX_IO`	`POSIX`			`NET_SERV_DB`
	`POSIX_PROCESS`	`Posix`
	`POSIX_PROC_ENV`	`POSIX_ERROR`
	`POSIX_TTY`

Q

`queryValue, WINDOWS.Key`	quit		`quot, INTEGER`
`queryValueEx, WINDOWS.Reg`		`POSIX_SIGNAL`	`quotRem, INT_INF`
`queue_sel, POSIX_TTY.TC`		`POSIX_TTY.V`

R

`radix, STRING_CVT`		`Real{N}VectorSlice`		`recvVecFromNB', SOCKET`
`radix, REAL`		`RealArray`		`recvVecNB, SOCKET`
`RandomAccessNotSupported, IO`		`RealArray2`		`recvVecNB', SOCKET`
`range, POSIX_ERROR`		`RealArraySlice`		`Reg, WINDOWS`
`RD, PRIM_IO`		`realCeil, REAL`		region
`read, WINDOWS.Key`		`realFloor, REAL`			`ARRAY2`
`readArr, POSIX_IO`		`realfmt, STRING_CVT`			`MONO_ARRAY2`
`readDir, OS_FILE_SYS`		`realMod, REAL`		rem
`readdir, POSIX_FILE_SYS`		`realPath, OS_FILE_SYS`			`INTEGER`
reader		`realRound, REAL`			`REAL`
	`PRIM_IO`	`realTrunc, REAL`		`remove, OS_FILE_SYS`
	`STREAM_IO`	`RealVector`		rename
	`STRING_CVT`	`RealVectorSlice`			`OS_FILE_SYS`
`readLink, OS_FILE_SYS`		reap			`POSIX_FILE_SYS`
`readlink, POSIX_FILE_SYS`			`UNIX`	`rev, LIST`
`readVec, POSIX_IO`			`WINDOWS`	`revAppend, LIST`
`REAL`		`recvArr, SOCKET`		`rewindDir, OS_FILE_SYS`
`Real`		`recvArr', SOCKET`		`rewinddir, POSIX_FILE_SYS`
real		`recvArrFrom, SOCKET`		`rmDir, OS_FILE_SYS`
	`MATH`	`recvArrFrom', SOCKET`		`rmdir, POSIX_FILE_SYS`
	`PACK_REAL`	`recvArrFromNB, SOCKET`		`rofs, POSIX_ERROR`
	`REAL`	`recvArrFromNB', SOCKET`		`round, REAL`
`real_order, IEEE_REAL`		`recvArrNB, SOCKET`		`rounding_mode, IEEE_REAL`
`real_timer, TIMER`		`recvArrNB', SOCKET`		row
`Real{N}`		`recvVec, SOCKET`			`ARRAY2`
`Real{N}Array`		`recvVec', SOCKET`			`MONO_ARRAY2`
`Real{N}Array2`		`recvVecFrom, SOCKET`		`RowMajor, ARRAY2`
`Real{N}ArraySlice`		`recvVecFrom', SOCKET`
`Real{N}Vector`		`recvVecFromNB, SOCKET`

S

`S, POSIX_FILE_SYS`		`signBit, REAL`		`stdOut, TEXT_IO`
`sadrain, POSIX_TTY.TC`		`simpleExecute, WINDOWS`		`stdout, POSIX_FILE_SYS`
`saflush, POSIX_TTY.TC`		`sin, MATH`		stop
`sameAddr, SOCKET`		`singleStep, WINDOWS.Status`			`POSIX_SIGNAL`
`sameDesc, SOCKET`		`sinh, MATH`			`POSIX_TTY.V`
sameSign		`Size, GENERAL`		`stopDialog, WINDOWS.DDE`
	`INTEGER`	size		`str, STRING`
	`REAL`		`POSIX_FILE_SYS.ST`	`stream, SOCKET`
`sanow, POSIX_TTY.TC`			`STRING`	`stream, SOCKET.SOCK`
`Sat, DATE`			`SUBSTRING`	`STREAM_IO`
scan		`skipWS, STRING_CVT`		stream_sock
	`BOOL`	sleep			`INET_SOCK`
	`CHAR`		`OS_PROCESS`		`UNIX_SOCK`
	`DATE`		`POSIX_PROCESS`	StreamIO
	`IEEE_REAL`	slice			`IMPERATIVE_IO`
	`INTEGER`		`ARRAY_SLICE`		`ImperativeIO`
	`NET_HOST_DB`		`MONO_ARRAY_SLICE`		`TEXT_IO`
	`REAL`		`MONO_VECTOR_SLICE`	`StreamIO`
	`STRING`		`VECTOR_SLICE`	`streamsOf, UNIX`
	`TIME`	slice		`STRING`
	`WORD`		`ARRAY_SLICE`	String
`scanStream, TEXT_IO`			`MONO_ARRAY_SLICE`		`<top level>`
`scanString, STRING_CVT`			`MONO_VECTOR_SLICE`		`TEXT`
`SCI, STRING_CVT`			`SUBSTRING`	string
`second, DATE`			`VECTOR_SLICE`		`CHAR`
`SEEK_CUR, POSIX_IO`		`SOCK, SOCKET`			`STRING`
`SEEK_END, POSIX_IO`		sock			`SUBSTRING`
`SEEK_SET, POSIX_IO`			`INET_SOCK`	`string, SUBSTRING`
`segv, POSIX_SIGNAL`			`SOCKET`	`STRING_CVT`
`select, SOCKET`			`UNIX_SOCK`	`StringCvt`
`sendArr, SOCKET`		sock_addr		`stringToBytes, BYTE`
`sendArr', SOCKET`			`INET_SOCK`	`Strm, UNIX_SOCK`
`sendArrNB, SOCKET`			`SOCKET`	sub
`sendArrNB', SOCKET`			`UNIX_SOCK`		`ARRAY`
`sendArrTo, SOCKET`		`sock_desc, SOCKET`			`ARRAY2`
`sendArrTo', SOCKET`		`sock_type, SOCKET.SOCK`			`ARRAY_SLICE`
`sendArrToNB, SOCKET`		`sockDesc, SOCKET`			`MONO_ARRAY`
`sendArrToNB', SOCKET`		`SOCKET`			`MONO_ARRAY2`
`sendbreak, POSIX_TTY.TC`		`Socket`			`MONO_ARRAY_SLICE`
`sendVec, SOCKET`		socket			`MONO_VECTOR`
`sendVec', SOCKET`			`GENERIC_SOCK`		`MONO_VECTOR_SLICE`
`sendVecNB, SOCKET`			`INET_SOCK.TCP`		`POSIX_TTY.V`
`sendVecNB', SOCKET`			`INET_SOCK.UDP`		`STRING`
`sendVecTo, SOCKET`			`OS_IO.Kind`		`SUBSTRING`
`sendVecTo', SOCKET`			`UNIX_SOCK.DGrm`		`VECTOR`
`sendVecToNB, SOCKET`			`UNIX_SOCK.Strm`		`VECTOR_SLICE`
`sendVecToNB', SOCKET`		socket'		subArr
`Sep, DATE`			`GENERIC_SOCK`		`PACK_REAL`
`set_action, POSIX_TTY.TC`			`INET_SOCK.TCP`		`PACK_WORD`
`setattr, POSIX_TTY.TC`			`INET_SOCK.UDP`	`subArrX, PACK_WORD`
`setBROADCAST, SOCKET.Ctl`		socketPair		`SUBNORMAL, IEEE_REAL`
`setBufferMode, STREAM_IO`			`GENERIC_SOCK`	`Subscript, GENERAL`
`setDEBUG, SOCKET.Ctl`			`UNIX_SOCK.DGrm`	subslice
`setDONTROUTE, SOCKET.Ctl`			`UNIX_SOCK.Strm`		`ARRAY_SLICE`
`setfd, POSIX_IO`		`socketPair', GENERIC_SOCK`			`MONO_ARRAY_SLICE`
`setfl, POSIX_IO`		`SOME, OPTION`			`MONO_VECTOR_SLICE`
`setgid, POSIX_PROC_ENV`		someElem			`VECTOR_SLICE`
`setInstream, IMPERATIVE_IO`			`PrimIO`	`SUBSTRING`
`setispeed, POSIX_TTY.CF`			`StreamIO`	Substring
`setKEEPALIVE, SOCKET.Ctl`		`Span, GENERAL`			`<top level>`
`setLINGER, SOCKET.Ctl`		`span, SUBSTRING`			`TEXT`
`setlk, POSIX_IO`		`speed, POSIX_TTY`		`substring, SUBSTRING`
`setlkw, POSIX_IO`		`speedToWord, POSIX_TTY`		substring
`setNODELAY, INET_SOCK.TCP`		`spipe, POSIX_ERROR`			`STRING`
`setOOBINLINE, SOCKET.Ctl`		`split, REAL`			`SUBSTRING`
`setospeed, POSIX_TTY.CF`		`splitAt, SUBSTRING`		subVec
`setOutstream, IMPERATIVE_IO`		`splitBaseExt, OS_PATH`			`PACK_REAL`
`setpgid, POSIX_PROC_ENV`		`splitDirFile, OS_PATH`			`PACK_WORD`
`setpgrp, POSIX_TTY.TC`		splitl		`subVecX, PACK_WORD`
setPosOut			`STRING_CVT`	`succ, CHAR`
	`IMPERATIVE_IO`		`SUBSTRING`	`success, OS_PROCESS`
	`STREAM_IO`	`splitr, SUBSTRING`		`Sun, DATE`
`setRCVBUF, SOCKET.Ctl`		`sqrt, MATH`		`susp, POSIX_TTY.V`
`setREUSEADDR, SOCKET.Ctl`		`srch, POSIX_ERROR`		symlink
`setRoundingMode, IEEE_REAL`		`ST, POSIX_FILE_SYS`			`OS_IO.Kind`
`setsid, POSIX_PROC_ENV`		`stackOverflow, WINDOWS.Status`			`POSIX_FILE_SYS`
`setSNDBUF, SOCKET.Ctl`		start		sync
`setTime, OS_FILE_SYS`			`POSIX_IO.FLock`		`POSIX_FILE_SYS.O`
`setuid, POSIX_PROC_ENV`			`POSIX_TTY.V`		`POSIX_IO.O`
`setValue, WINDOWS.Key`		`startCPUTimer, TIMER`		`sysconf, POSIX_PROC_ENV`
`setValueEx, WINDOWS.Reg`		`startDialog, WINDOWS.DDE`		`SysDB, POSIX`
`shell, POSIX_SYS_DB.Passwd`		`startRealTimer, TIMER`		`SysErr, OS`
`shutdown, SOCKET`		`stat, POSIX_FILE_SYS.ST`		syserror
`shutdown_mode, SOCKET`		`stat, POSIX_FILE_SYS`			`OS`
sign		`Status, WINDOWS`			`POSIX_ERROR`
	`INTEGER`	status		syserror
	`REAL`		`OS_PROCESS`		`OS`
`Signal, POSIX`			`WINDOWS.Status`		`POSIX_ERROR`
signal		`stdErr, TEXT_IO`		`system, OS_PROCESS`
	`POSIX_PROCESS`	`stderr, POSIX_FILE_SYS`		`SysWord`
	`POSIX_SIGNAL`	`stdIn, TEXT_IO`		`SZ, WINDOWS.Reg`
	`UNIX`	`stdin, POSIX_FILE_SYS`

T

tabulate		`Timer`		`tostop, POSIX_TTY.L`
	`ARRAY`	`times, POSIX_PROC_ENV`		toString
	`ARRAY2`	`tl, LIST`			`BOOL`
	`LIST`	`tmpName, OS_FILE_SYS`			`CHAR`
	`MONO_ARRAY`	`TO_NEAREST, IEEE_REAL`			`DATE`
	`MONO_ARRAY2`	`TO_NEGINF, IEEE_REAL`			`IEEE_REAL`
	`MONO_VECTOR`	`TO_POSINF, IEEE_REAL`			`INTEGER`
	`VECTOR`	`TO_ZERO, IEEE_REAL`			`NET_HOST_DB`
`take, LIST`		toAddr			`OS_PATH`
takel			`INET_SOCK`		`REAL`
	`STRING_CVT`		`UNIX_SOCK`		`SOCKET.AF`
	`SUBSTRING`	`toBytes, PACK_REAL`			`SOCKET.SOCK`
`taker, SUBSTRING`		toCString			`STRING`
`tan, MATH`			`CHAR`		`TIME`
`tanh, MATH`			`STRING`		`WORD`
`TC, POSIX_TTY`		`toDecimal, REAL`		`totalCPUTimer, TIMER`
`TCP, INET_SOCK`		toInt		`totalRealTimer, TIMER`
`term, POSIX_SIGNAL`			`INTEGER`	`toTime, DATE`
`terminate, OS_PROCESS`			`REAL`	`toUnixPath, OS_PATH`
`termios, POSIX_TTY`			`WORD`	`toUpper, CHAR`
`termios, POSIX_TTY`		`toIntX, WORD`		toWord
`TEXT`		tokens			`BIT_FLAGS`
`Text`			`STRING`		`POSIX_ERROR`
`TEXT_IO`			`SUBSTRING`		`POSIX_SIGNAL`
`TEXT_STREAM_IO`		toLarge		translate
textInstreamOf			`INTEGER`		`STRING`
	`UNIX`		`REAL`		`SUBSTRING`
	`WINDOWS`		`WORD`	traversal
`TextIO`		toLargeInt			`ARRAY2`
textOutstreamOf			`REAL`		`MONO_ARRAY2`
	`UNIX`		`WORD`	`triml, SUBSTRING`
	`WINDOWS`	`toLargeIntX, WORD`		`trimr, SUBSTRING`
`TextPrimIO`		`toLargeWord, WORD`		`true, BOOL`
`Thu, DATE`		`toLargeWordX, WORD`		trunc
`TIME`		`toLargeX, WORD`			`POSIX_FILE_SYS.O`
`Time`		`toLower, CHAR`			`REAL`
`Time, TIME`		`toManExp, REAL`		`tstp, POSIX_SIGNAL`
`time, TIME`		`toMicroseconds, TIME`		`ttin, POSIX_SIGNAL`
time		`toMilliseconds, TIME`		`ttou, POSIX_SIGNAL`
	`POSIX_PROC_ENV`	`toNanoseconds, TIME`		`TTY, POSIX`
	`POSIX_TTY.V`	`toobig, POSIX_ERROR`		`tty, OS_IO.Kind`
`timeout, WINDOWS.Status`		`toReal, TIME`		`ttyname, POSIX_PROC_ENV`
`TIMER`		`toSeconds, TIME`		`Tue, DATE`

U

`UDP, INET_SOCK`		`unix, UNIX_SOCK`		`userAPC, WINDOWS.Status`
uid		`UNIX_SOCK`		`users, WINDOWS.Reg`
	`POSIX_FILE_SYS`	`unixAF, UNIX_SOCK`		`usr1, POSIX_SIGNAL`
	`POSIX_PROC_ENV`	`UnixSock`		`usr2, POSIX_SIGNAL`
	`POSIX_SYS_DB`	`unlink, POSIX_FILE_SYS`		`utime, POSIX_FILE_SYS`
uid		`UNORDERED, IEEE_REAL`
	`POSIX_FILE_SYS.ST`	`Unordered, IEEE_REAL`
	`POSIX_SYS_DB.Passwd`	`unordered, REAL`
`uidToWord, POSIX_PROC_ENV`		`unpackString, BYTE`
`umask, POSIX_FILE_SYS`		`unpackStringVec, BYTE`
`uname, POSIX_PROC_ENV`		`untraced, POSIX_PROCESS.W`
`UnequalLengths, LIST_PAIR`		`unzip, LIST_PAIR`
`unit, GENERAL`		update
`UNIX`			`ARRAY`
`Unix`			`ARRAY2`
			`ARRAY_SLICE`
			`MONO_ARRAY`
			`MONO_ARRAY2`
			`MONO_ARRAY_SLICE`
			`MONO_VECTOR`
			`PACK_REAL`
			`PACK_WORD`
			`POSIX_TTY.V`
			`VECTOR`

V

`V, POSIX_TTY`		vector
`validVolume, OS_PATH`			`ARRAY`
`valOf, OPTION`			`ARRAY_SLICE`
`value, WINDOWS.Reg`			`MONO_ARRAY`
`VECTOR`			`MONO_ARRAY_SLICE`
Vector			`MONO_VECTOR_SLICE`
	`<top level>`		`VECTOR_SLICE`
	`ImperativeIO`	`VECTOR_SLICE`
	`PrimIO`	vector_slice
	`StreamIO`		`MONO_ARRAY_SLICE`
vector			`PRIM_IO`
	`ARRAY`	VectorSlice
	`IMPERATIVE_IO`		`<top level>`
	`MONO_ARRAY`		`PrimIO`
	`MONO_ARRAY2`
	`MONO_ARRAY_SLICE`
	`MONO_VECTOR`
	`MONO_VECTOR_SLICE`
	`PRIM_IO`
	`STREAM_IO`
	`VECTOR`

W

`W, POSIX_PROCESS`		`whence, POSIX_IO.FLock`	`Word{N}Array2`
`W_ANY_CHILD, POSIX_PROCESS`		`WideChar`	`Word{N}ArraySlice`
`W_CHILD, POSIX_PROCESS`		`WideCharArray`	`Word{N}Vector`
W_EXITED		`WideCharArray2`	`Word{N}VectorSlice`
	`POSIX_PROCESS`	`WideCharArraySlice`	`WordArray`
	`UNIX`	`WideCharVector`	`WordArray2`
W_EXITSTATUS		`WideCharVectorSlice`	`WordArraySlice`
	`POSIX_PROCESS`	`WideString`	`wordSize, WORD`
	`UNIX`	`WideSubstring`	`wordToDev, POSIX_FILE_SYS`
`W_GROUP, POSIX_PROCESS`		`WideText`	`wordToFD, POSIX_FILE_SYS`
`W_SAME_GROUP, POSIX_PROCESS`		`WideTextIO`	`wordToGid, POSIX_PROC_ENV`
W_SIGNALED		`WideTextPrimIO`	`wordToIno, POSIX_FILE_SYS`
	`POSIX_PROCESS`	`WINDOWS`	`wordToPid, POSIX_PROCESS`
	`UNIX`	`Windows`	`wordToSpeed, POSIX_TTY`
W_STOPPED		`WORD`	`wordToUid, POSIX_PROC_ENV`
	`POSIX_PROCESS`	`Word`	`WordVector`
	`UNIX`	`word, WORD`	`WordVectorSlice`
`wait, POSIX_PROCESS`		`Word8`	`WR, PRIM_IO`
`waitpid, POSIX_PROCESS`		`Word8Array`	`write, WINDOWS.Key`
`waitpid_arg, POSIX_PROCESS`		`Word8Array2`	`writeArr, POSIX_IO`
`waitpid_nh, POSIX_PROCESS`		`Word8ArraySlice`	writer
`Wed, DATE`		`Word8Vector`		`PRIM_IO`
`weekDay, DATE`		`Word8VectorSlice`		`STREAM_IO`
`weekday, DATE`		`Word{N}`	`writeVec, POSIX_IO`
`whence, POSIX_IO`		`Word{N}Array`

X

`xdev, POSIX_ERROR`
xorb
	`INT_INF`
	`WORD`

Y

year, DATE

yearDay, DATE

Z

`ZERO, IEEE_REAL`		`zip, LIST_PAIR`
`zeroTime, TIME`		`zipEq, LIST_PAIR`

[ Top | Parent | Contents | Index | Root ]

This document may be distributed freely over the internet as long as the copyright notice and license terms below are prominently displayed within every machine-readable copy.

Copyright © 2003 AT&T and Lucent Technologies. All rights reserved.
Permission is granted for internet users to make one paper copy for their own personal use. Further hardcopy reproduction is strictly prohibited. Permission to distribute the HTML document electronically on any medium other than the internet must be requested from the copyright holders by contacting the editors. Printed versions of the SML Basis Manual are available from Cambridge University Press. To order, please visit www.cup.org (North America) or www.cup.cam.ac.uk (outside North America).