%:function = %(elem[]?):[icase] {block?}
&:function = &(`args*) {block}
@:function = @(func?:function) {block?}
@@:function = @@() {block}
@rem:nil = nil
ArithmeticError:error = <error:ArithmeticError>
AttributeError:error = <error:AttributeError>
CodecError:error = <error:CodecError>
CommandError:error = <error:CommandError>
FormatError:error = <error:FormatError>
IOError:error = <error:IOError>
ImportError:error = <error:ImportError>
IndexError:error = <error:IndexError>
IteratorError:error = <error:IteratorError>
KeyError:error = <error:KeyError>
MemoryError:error = <error:MemoryError>
NameError:error = <error:NameError>
None:error = <error:None>
NotImplementedError:error = <error:NotImplementedError>
ResourceError:error = <error:ResourceError>
RuntimeError:error = <error:RuntimeError>
StopIteration:error = <error:StopIteration>
SyntaxError:error = <error:SyntaxError>
SystemError:error = <error:SystemError>
TypeError:error = <error:TypeError>
ValueError:error = <error:ValueError>
ZeroDivisionError:error = <error:ZeroDivisionError>
__add__:function = __add__(n, m):map
__and__:function = __and__(n, m):map
__andand__:function = __andand__(`n, `m):map
__cmp__:function = __cmp__(n, m):map
__div__:function = __div__(n, m):map
__eq__:function = __eq__(n, m):map
__ge__:function = __ge__(n, m):map
__gt__:function = __gt__(n, m):map
__invert__:function = __invert__(n):map
__le__:function = __le__(n, m):map
__lt__:function = __lt__(n, m):map
__mul__:function = __mul__(n, m):map
__name__:string = __main__
__ne__:function = __ne__(n, m):map
__neg__:function = __neg__(n):map
__not__:function = __not__(flag):map
__or__:function = __or__(n, m):map
__oror__:function = __oror__(`n, `m):map
__pos__:function = __pos__(n):map
__pow__:function = __pow__(n, m):map
__seq__:function = __seq__(n, m):map
__seqinf__:function = __seqinf__(n):map
__shl__:function = __shl__(n, m):map
__shr__:function = __shr__(n, m):map
__sub__:function = __sub__(n, m):map
__xor__:function = __xor__(n, m):map
audio:function = audio(format:symbol, len:number, channels:number => 1) {block?}
base64:module = <module:base64>
  __name__:string = base64
  __source__:string = <integrated>
  __symbol__:symbol = base64
  decode:function = decode(stream:stream:r)
  encode:function = encode(stream:stream:r, linelen:number:nil => 76)
  reader:function = reader(stream:stream:r)
  writer:function = writer(stream:stream:w, linelen:number:nil => 76)
binary:function = binary(buff*) {block?}
case:function = case(`cond) {block}
choose:function = choose(index:number, values+):map
chr:function = chr(num:number):map
class:function = class(superclass?:function) {block?}
classref:function = classref(type:expr):map {block?}
codec:function = codec(encoding:string, process_eol:boolean => false) {block?}
codecs:module = <module:codecs>
  __name__:string = codecs
  __source__:string = <integrated>
  __symbol__:symbol = codecs
  basic:module = <module:basic>
    __name__:string = basic
    __source__:string = <integrated>
    __symbol__:symbol = basic
  iso8859:module = <module:iso8859>
    __name__:string = iso8859
    __source__:string = <integrated>
    __symbol__:symbol = iso8859
  japanese:module = <module:japanese>
    __name__:string = japanese
    __source__:string = <integrated>
    __symbol__:symbol = japanese
color:function = color(args+):map {block?}
cond:function = cond(flag:boolean, value1:nomap, value2?:nomap):map
conds:function = conds(flag:boolean, value1, value2?):map
copy:function = copy(src:stream:r, dst:stream:w, bytesunit:number => 65536):map:void {block?}
cross:function = cross (`expr+) {block}
default:function = default() {block}
dict:function = dict(elem[]?):[icase] {block?}
dim:function = dim(n+:number) {block?}
dir:function = dir(obj?)
else:function = else() {block}
elsif:function = elsif (`cond) {block}
eval:function = eval(expr:expr):map
except:function = except(errors*:error) {block}
extern:function = extern(`syms+)
false:boolean = false
fill:function = fill(n:number, value?) {block?}
finally:function = finally() {block}
for:function = for (`expr+) {block}
format:function = format(format:string, values*):map
fs:module = <module:fs>
  __name__:string = fs
  __source__:string = <integrated>
  __symbol__:symbol = fs
  chdir:function = chdir(pathname:string):void
  chmod:function = chmod(mode, pathname:string):void
  getcwd:function = getcwd()
  mkdir:function = mkdir(pathname:string):map:void:[tree]
  remove:function = remove(pathname:string):map:void
  rename:function = rename(src:string, dst:string):map:void
  rmdir:function = rmdir(pathname:string):map:void:[tree]
function:function = function(`args*) {block}
help:function = help(func:function):map:void
hex:function = hex(num:number, digits?:number):map:[upper]
if:function = if (`cond) {block}
image:function = image(args+):map {block?}
import:function = import(`module, `alias?):[overwrite] {block?}
in:function = in(n, m)
int:function = int(value):map
interval:function = interval(a:number, b:number, samples:number):map:[open,open_l,open_r] {block?}
isbinary:function = isbinary(value)
isboolean:function = isboolean(value)
isclass:function = isclass(value)
iscomplex:function = iscomplex(value)
isdatetime:function = isdatetime(value)
isdefined:function = isdefined(`symbol)
isdict:function = isdict(value)
isenvironment:function = isenvironment(value)
iserror:function = iserror(value)
isexpr:function = isexpr(value)
isfunction:function = isfunction(value)
isinstance:function = isinstance(value, type:expr):map
isiterator:function = isiterator(value)
islist:function = islist(value)
ismatrix:function = ismatrix(value)
ismodule:function = ismodule(value)
isnil:function = isnil(value)
isnumber:function = isnumber(value)
issemaphore:function = issemaphore(value)
isstring:function = isstring(value)
issymbol:function = issymbol(value)
istimedelta:function = istimedelta(value)
istype:function = istype(value, type:expr):map
isuri:function = isuri(value)
iterator:function = iterator(value+) {block?}
list:function = list(value+)
local:function = local(`syms+)
locals:function = locals(module?:module)
math:module = <module:math>
  __name__:string = math
  __source__:string = <integrated>
  __symbol__:symbol = math
  abs:function = abs(num):map
  acos:function = acos(num):map
  arg:function = arg(num):map
  asin:function = asin(num):map
  atan:function = atan(num):map
  atan2:function = atan2(num1, num2):map
  bezier:function = bezier(nums[]+:number)
  ceil:function = ceil(num):map
  conj:function = conj(num):map
  cos:function = cos(num):map
  cosh:function = cosh(num):map
  covariance:function = covariance(a:iterator, b:iterator)
  cross_product:function = cross_product(a[], b[])
  diff:function = diff(expr:expr, var:symbol):map
  dot_product:function = dot_product(a[], b[])
  e:number = 2.71828
  exp:function = exp(num):map
  fft:function = fft(seq[])
  floor:function = floor(num):map
  gcd:function = gcd(a:number, b+:number):map
  imag:function = imag(num):map
  integral:function = integral()
  lcm:function = lcm(a:number, b+:number):map
  least_square:function = least_square(x:iterator, y:iterator, dim:number => 1, var:symbol => x)
  log:function = log(num):map
  log10:function = log10(num):map
  norm:function = norm(num):map
  optimize:function = optimize(expr:expr):map
  pi:number = 3.14159
  real:function = real(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
matrix:function = matrix(nrows:number, ncols:number, value?) {block?}
max:function = max(values+):map
min:function = min(values+):map
mod:function = mod(n, m):map
module:function = module() {block}
nil:nil = nil
object:function = object()
open:function = open(name:string, mode:string => 'r', encoding:string => 'utf-8'):map {block?}
ord:function = ord(str:string):map
os:module = <module:os>
  __name__:string = os
  __source__:string = <integrated>
  __symbol__:symbol = os
  exec:function = exec(pathname:string, args*:string):map:[fork]
  fromnative:function = fromnative(buff:binary):map
  getenv:function = getenv(name:string):map
  putenv:function = putenv(name:string, value:string):void
  redirect:function = redirect(stdin:stream:nil:r, stdout:stream:nil:w, stderr?:stream:w) {block?}
  tonative:function = tonative(str:string):map
outers:function = outers()
palette:function = palette(type) {block?}
path:module = <module:path>
  __name__:string = path
  __source__:string = <integrated>
  __symbol__:symbol = path
  absname:function = absname(name:string):map:[uri]
  bottom:function = bottom(pathname:string):map
  cutbottom:function = cutbottom(pathname:string):map
  dir:function = dir(pathname?:string, pattern*:string):map:flat:[stat,icase,file,dir] {block?}
  dirname:function = dirname(pathname:string):map
  exists:function = exists(pathname:string):map
  filename:function = filename(pathname:string):map
  glob:function = glob(pattern:string):map:flat:[stat,icase,file,dir] {block?}
  join:function = join(paths+:string):map:[uri]
  match:function = match(pattern:string, name:string):map:[icase]
  regulate:function = regulate(name:string):map:[uri]
  split:function = split(pathname:string):map:[bottom]
  splitext:function = splitext(pathname:string):map
  stat:function = stat(pathname:string):map
  walk:function = walk(pathname?:string, maxdepth?:number, pattern*:string):map:flat:[stat,icase,file,dir] {block?}
print:function = print(value*):map:void
printf:function = printf(format:string, values*):map:void
println:function = println(value*):map:void
raise:function = raise(error:error, msg:string => 'error', value?)
rand:function = rand(range?:number) {block?}
rands:function = rands(num?:number, range?:number) {block?}
randseed:function = randseed(seed:number)
range:function = range(num:number, num_end?:number, step?:number):map {block?}
readlines:function = readlines(stream?:stream:r):[chop] {block?}
repeat:function = repeat (n?:number) {block}
root:environment = <environment:root>
scope:function = scope(target?) {block}
semaphore:function = semaphore()
set:function = set(iter+:iterator):[and,or,xor]
struct:function = struct(`args+):[loose] {block?}
super:function = super(obj):map {block?}
switch:function = switch() {block}
sys:module = <module:sys>
  __name__:string = sys
  __source__:string = <integrated>
  __symbol__:symbol = sys
  echo:function = echo(flag:boolean)
  exit:function = exit(status?:number)
  ps1:string = >>> 
  ps2:string = ... 
  version:string = 0.3.1
template:function = template(src:stream:r, dst?:stream:w):map:[lasteol,noindent] {block?}
time:module = <module:time>
  Friday:number = 5
  Monday:number = 1
  Saturday:number = 6
  Sunday:number = 0
  Thursday:number = 4
  Tuesday:number = 2
  Wednesday:number = 3
  __name__:string = time
  __source__:string = <integrated>
  __symbol__:symbol = time
  clock:function = clock()
  datetime:function = datetime(year:number, month:number, day:number, hour:number => 0, min:number => 0, sec:number => 0, usec:number => 0, minsoff?:number):map
  delta:function = delta(days:number => 0, secs:number => 0, usecs:number => 0):map
  isleap:function = isleap(year:number):map
  monthdays:function = monthdays(year:number, month:number):map
  now:function = now():[utc]
  parse:function = parse(str:string):map
  sleep:function = sleep(secs:number)
  time:function = time(hour:number => 0, minute:number => 0, sec:number => 0, usec:number => 0):map
  today:function = today():[utc]
  weekday:function = weekday(year:number, month:number, day:number):map
tonumber:function = tonumber(value):map:[nil,zero,raise,strict]
tostring:function = tostring(value):map
tosymbol:function = tosymbol(str:string):map
true:boolean = true
try:function = try() {block}
typename:function = typename(`value)
undef:function = undef(`value+):[raise]
while:function = while (`cond) {block}
xlist:function = xlist(iter+:iterator)
xset:function = xset(iter+:iterator):[and,or,xor]
zipv:function = zipv(values+) {block?}
