%:function = %(elem[]?) {block?}
&:function = &(`args*) {block}
string:module = <module:string>
  __name__:string = string
  upper:function = upper(str:string):map
  lower:function = lower(str:string):map
  left:function = left(str:string, len?:number):map
  right:function = right(str:string, len?:number):map
  len:function = len(str:string):map
  capitalize:function = capitalize(str:string):map
  strip:function = strip(str:string):map:[both,left,right]
  align:function = align(str:string, len:number, padding:string => " "):map:[center,left,right]
  mid:function = mid(str:string, start:number => 0, len?:number):map
  find:function = find(str:string, sub:string, start:number => 0):map:[rev,icase]
  replace:function = replace(str:string, sub:string, replace:string, maxreplace?:number):map:[icase]
  split:function = split(str:string, sep?:string, maxnumber?:number):map:[icase] {block?}
  eachline:function = eachline(str:string, nlines?:number):map:[chop] {block?}
  join:function = join(strs[]:string, sep:string => "")
nil:nil = nil
raise:function = raise(error:error, msg:string => "error", value?)
true:boolean = true
false:boolean = false
if:function = if (`cond) {block}
elsif:function = elsif (`cond) {block}
else:function = else() {block}
repeat:function = repeat (n?:number) {block}
while:function = while (`cond) {block}
for:function = for (`expr+) {block}
cross:function = cross (`expr+) {block}
except:function = except(errors*:error) {block}
__name__:string = __main__
list:function = list(iter+:iterator)
xlist:function = xlist(iter+:iterator)
set:function = set(iter+:iterator):[and,or,xor]
xset:function = xset(iter+:iterator):[and,or,xor]
root:environment = <environment:root>
extern:function = extern(`syms+)
local:function = local(`syms+)
help:function = help(func:function):map:void
path:module = <module:path>
  __name__:string = path
  stat:function = stat(pathname:string):map
  dir:function = dir(pathname?:string, pattern*:string):map:flat:[stat,icase,file,dir] {block?}
  split:function = split(pathname:string):map
  join:function = join(paths+:string):map:[http]
  basename:function = basename(pathname:string):map
  dirname:function = dirname(pathname:string):map
  sep_file:string = \
  exists:function = exists(pathname:string):map
  walk:function = walk(pathname?:string, maxdepth?:number, pattern*:string):map:flat:[stat,icase,file,dir] {block?}
  glob:function = glob(pattern:string):map:flat:[stat,icase,file,dir] {block?}
  match:function = match(pattern:string, name:string):map:[icase]
  absname:function = absname(name:string):map:[http]
  splitext:function = splitext(pathname:string):map
format:function = format(format:string, values*):map
color:function = color(elem?, green:number => 0, blue:number => 0, alpha:number => 255):map
palette:function = palette(type:symbol)
open:function = open(name:string, mode:string => "r", encoding:string => "utf-8"):map {block?}
min:function = min(values+):map
dir:function = dir(obj?)
module:function = module() {block}
class:function = class(superclass?:function):[static] {block?}
object:function = object()
binary:function = binary(buff*)
matrix:function = matrix(nrows:number, ncols:number, value?)
dict:function = dict(elem[]?) {block?}
iterator:function = iterator(value+)
semaphore:function = semaphore()
struct:function = struct(`args+):[loose] {block?}
image:function = image(args+):map
audio:function = audio(format:symbol, len:number, channels:number => 1)
codec:function = codec(encoding:string, process_eol:boolean => 0)
istype:function = istype(value, type:expr):map
tonumber:function = tonumber(value):map:[nil,zero,raise,strict]
tostring:function = tostring(value):map
default:function = default() {block}
print:function = print(value*):map:void
println:function = println(value*):map:void
pack:function = pack(format:string, value*):map
printf:function = printf(format:string, values*):map:void
max:function = max(values+):map
readlines:function = readlines(stream?:stream):[chop] {block?}
isbinary:function = isbinary(value)
isstring:function = isstring(value)
issymbol:function = issymbol(value)
eval:function = eval(expr:expr):map
fill:function = fill(n:number, value?) {block?}
None:error = <error:None>
SyntaxError:error = <error:SyntaxError>
ArithmeticError:error = <error:ArithmeticError>
TypeError:error = <error:TypeError>
ZeroDivisionError:error = <error:ZeroDivisionError>
ValueError:error = <error:ValueError>
SystemError:error = <error:SystemError>
IOError:error = <error:IOError>
IndexError:error = <error:IndexError>
KeyError:error = <error:KeyError>
ImportError:error = <error:ImportError>
AttributeError:error = <error:AttributeError>
StopIteration:error = <error:StopIteration>
RuntimeError:error = <error:RuntimeError>
NameError:error = <error:NameError>
NotImplementedError:error = <error:NotImplementedError>
IteratorError:error = <error:IteratorError>
CodecError:error = <error:CodecError>
CommandError:error = <error:CommandError>
MemoryError:error = <error:MemoryError>
FormatError:error = <error:FormatError>
ResourceError:error = <error:ResourceError>
__pos__:function = __pos__(n):map
__neg__:function = __neg__(n):map
__invert__:function = __invert__(n):map
__not__:function = __not__(flag:boolean):map
__add__:function = __add__(n, m):map
__sub__:function = __sub__(n, m):map
__mul__:function = __mul__(n, m):map
__div__:function = __div__(n, m):map
mod:function = mod(n, m):map
__pow__:function = __pow__(n, m):map
__eq__:function = __eq__(n, m):map
__ne__:function = __ne__(n, m):map
__gt__:function = __gt__(n, m):map
__lt__:function = __lt__(n, m):map
__ge__:function = __ge__(n, m):map
__le__:function = __le__(n, m):map
__cmp__:function = __cmp__(n, m):map
in:function = in(n, m)
__or__:function = __or__(n, m):map
__and__:function = __and__(n, m):map
__xor__:function = __xor__(n, m):map
__shl__:function = __shl__(n, m):map
__shr__:function = __shr__(n, m):map
__oror__:function = __oror__(`n, `m):map
__andand__:function = __andand__(`n, `m):map
__seq__:function = __seq__(n, m):map
__seqinf__:function = __seqinf__(n):map
@rem:nil = nil
try:function = try() {block}
finally:function = finally() {block}
switch:function = switch() {block}
case:function = case(`cond) {block}
dim:function = dim(n+:number) {block?}
zip:function = zip(values+) {block?}
choose:function = choose(index:number, values+):map
chooseif:function = chooseif(flag:boolean, value1, value2):map
import:function = import(`module, `alias?):[overwrite] {block?}
parsestream:function = parsestream(stream:stream):map
parse:function = parse(code:string):map
locals:function = locals(module?:module)
outers:function = outers()
tosymbol:function = tosymbol(str:string):map
int:function = int(value):map
ord:function = ord(str:string):map
chr:function = chr(num:number):map
hex:function = hex(num:number, digits?:number):map:[upper]
isdefined:function = isdefined(`symbol)
typename:function = typename(`value)
undef:function = undef(`value+):[raise]
isboolean:function = isboolean(value)
isnumber:function = isnumber(value)
iscomplex:function = iscomplex(value)
isfunction:function = isfunction(value)
islist:function = islist(value)
ismatrix:function = ismatrix(value)
isdict:function = isdict(value)
isdatetime:function = isdatetime(value)
istimedelta:function = istimedelta(value)
isiterator:function = isiterator(value)
isexpr:function = isexpr(value)
isenvironment:function = isenvironment(value)
iserror:function = iserror(value)
isuri:function = isuri(value)
issemaphore:function = issemaphore(value)
ismodule:function = ismodule(value)
isclass:function = isclass(value)
isinstance:function = isinstance(value, type:expr):map
classref:function = classref(type:expr):map
range:function = range(num:number, num_end?:number, step?:number):map {block?}
interval:function = interval(a:number, b:number, samples:number):map:[open,open_l,open_r] {block?}
rand:function = rand(range?:number)
rands:function = rands(num?:number, range?:number) {block?}
@:function = @(func?:function) {block?}
lambda:function = lambda(`args*) {block}
@@:function = @@() {block}
copy:function = copy(src:stream, dst:stream):map:void
sys:module = <module:sys>
  ps1:string = >>> 
  ps2:string = ... 
  __name__:string = sys
  echo:function = echo(flag:boolean)
  exit:function = exit(status?:number)
  listcodec:function = listcodec()
codecs:module = <module:codecs>
  __name__:string = codecs
  basic:module = <module:basic>
    __name__:string = basic
  iso8859:module = <module:iso8859>
    __name__:string = iso8859
  japanese:module = <module:japanese>
    __name__:string = japanese
fs:module = <module:fs>
  __name__:string = fs
  rename:function = rename(src:string, dst:string):map:void
  remove:function = remove(pathname:string):map:void
  mkdir:function = mkdir(pathname:string):map:void
  chdir:function = chdir(pathname:string):void
  getcwd:function = getcwd()
os:module = <module:os>
  stdin:stream = <stream:R:cp932:dosmode:stdin>
  stdout:stream = <stream:W:cp932:dosmode:stdout>
  stderr:stream = <stream:W:cp932:dosmode:stderr>
  __name__:string = os
  exec:function = exec(pathname:string, args*:string):map
  getenv:function = getenv(name:string):map
  putenv:function = putenv(name:string, value:string):void
time:module = <module:time>
  __name__:string = time
  datetime:function = datetime(year:number => 0, month:number => 1, day:number => 1, hour:number => 0, min:number => 0, sec:number => 0, usec:number => 0, minsoff?:number):map
  parse:function = parse(str:string):map
  time:function = time(hour:number => 0, minute:number => 0, sec:number => 0, usec:number => 0):map
  Sunday:number = 0
  Monday:number = 1
  Tuesday:number = 2
  Wednesday:number = 3
  Thursday:number = 4
  Friday:number = 5
  Saturday:number = 6
  sleep:function = sleep(secs:number)
  clock:function = clock()
  monthdays:function = monthdays(year:number, month:number):map
  weekday:function = weekday(year:number, month:number, day:number):map
  now:function = now():[utc]
  today:function = today():[utc]
  delta:function = delta(days:number => 0, secs:number => 0, usecs:number => 0, msecs:number => 0, mins:number => 0, hours:number => 0, weeks:number => 0):map
  isleap:function = isleap(year:number):map
math:module = <module:math>
  e:number = 2.71828
  pi:number = 3.14159
  __name__:string = math
  real:function = real(num):map
  imag:function = imag(num):map
  arg:function = arg(num):map
  norm:function = norm(num):map
  conj:function = conj(num):map
  acos:function = acos(num):map
  asin:function = asin(num):map
  atan:function = atan(num):map
  atan2:function = atan2(num1, num2):map
  ceil:function = ceil(num):map
  cos:function = cos(num):map
  cosh:function = cosh(num):map
  exp:function = exp(num):map
  abs:function = abs(num):map
  floor:function = floor(num):map
  log:function = log(num):map
  log10:function = log10(num):map
  sin:function = sin(num):map
  sinh:function = sinh(num):map
  sqrt:function = sqrt(num):map
  tan:function = tan(num):map
  tanh:function = tanh(num):map
  least_square:function = least_square(x:iterator, y:iterator, n:number => 1, var:symbol => x)
  bezier:function = bezier(nums[]+:number)
  diff:function = diff(expr:expr, var:symbol):map
  optimize:function = optimize(expr:expr):map
  fft:function = fft(seq[])
  dot_product:function = dot_product(a[], b[])
  cross_product:function = cross_product(a[], b[])
  covariance:function = covariance(a:iterator, b:iterator)
  integral:function = integral()
