######## test-declaration.az ########
%(elem[]?) {block?}
&(`args*) {block}
<module:string>

raise(error:error, msg?:string, value?)
true
false
if (`cond) {block}
elsif (`cond) {block}
else() {block}
repeat (n?:number) {block}
while (`cond) {block}
for (`iter+) {block}
cross (`iter+) {block}
break(value?):symbol_func
continue(value?):symbol_func
except(error*:error) {block}
map(func:function, iter:iterator) {block?}
list(iter+:iterator)
xlist(iter+:iterator)
set(iter+:iterator):[and,or,xor]
xset(iter+:iterator):[and,or,xor]
and(iter:iterator)
or(iter:iterator)
module() {block}
class(super_class?:function):[static] {block?}
object()
bytes(buff*)
matrix() {block?}
dict(elem[]?) {block?}
semaphore()
struct(`args+):[loose] {block?}
tonumber(value):map:[nil,zero,raise,strict]
len(iter:iterator)
replace(elem[], value, replace)
format(format:string, values*):map
pack(format:string, value*):map
min(iter:iterator):[index,last_index,indices]
max(iter:iterator):[index,last_index,indices]
filter(criteria, iter:iterator) {block?}
sort(elem[], directive?):[stable]
rank(elem[], directive?):[stable]
reverse(elem[]) {block?}
round(elem[], n?:number) {block?}
print(value*):map:void
println(value*):map:void
printf(format:string, values*):map:void
eval(expr:expr):map
issymbol(value)
<error:None>
<error:SyntaxError>
<error:ArithmeticError>
<error:TypeError>
<error:ZeroDivisionError>
<error:ValueError>
<error:SystemError>
<error:IOError>
<error:IndexError>
<error:KeyError>
<error:ImportError>
<error:AttributeError>
<error:StopIteration>
<error:RuntimeError>
<error:NameError>
<error:NotImplementedError>
<error:IteratorError>
<error:CodecError>
<error:CommandError>
__neg__(value):map
__invert__(value):map
__not__(flag:boolean):map
__add__(valueLeft, valueRight):map
__sub__(valueLeft, valueRight):map
__mul__(valueLeft, valueRight):map
__div__(valueLeft, valueRight):map
mod(valueLeft, valueRight):map
__pow__(valueLeft, valueRight):map
__eq__(valueLeft, valueRight):map
__ne__(valueLeft, valueRight):map
__gt__(valueLeft, valueRight):map
__lt__(valueLeft, valueRight):map
__ge__(valueLeft, valueRight):map
__le__(valueLeft, valueRight):map
__cmp__(valueLeft, valueRight):map
in(valueLeft, valueRight)
__or__(valueLeft, valueRight):map
__and__(valueLeft, valueRight):map
__xor__(valueLeft, valueRight):map
__shl__(valueLeft, valueRight):map
__shr__(valueLeft, valueRight):map
__oror__(`valueLeft, `valueRight):map
__andand__(`valueLeft, `valueRight):map
__seq__(valueLeft, valueRight):map
__seqinf__(value):map

<module:math>
<module:sys>
open(filename:string, mode?:string, encoding?:string):map {block?}
int(value):map
try() {block}
finally() {block}
return(value?):symbol_func
nilto(elem[], replace)
zip(value+)
choosemin(values+):map
choosemax(values+):map
choose(index:number, values+):map
chooseif(flag:boolean, value1, value2):map
sum(iter:iterator)
average(iter:iterator)
mixin(module:module)
import(`module, `name?) {block?}
execfile(filename:string):map
parse(code:string):map
locals()
outers()
tostring(value):map
tosymbol(str:string):map
rand(num?:number)
ord(str:string):map
chr(num:number):map
hex(num:number, digits?:number):map:[upper]
dir(obj?)
isdefined(`symbol)
typename(`value)
undef(`value+)
isboolean(value)
isnumber(value)
iscomplex(value)
isstring(value)
ismodule(value)
isclass(value)
isinstance(value, type:expr):map
range(num:number, num_end?:number, step?:number):map {block?}
interval(a:number, b:number, samples:number):map:[open,open_l,open_r] {block?}
fill(n:number, value?) {block?}
rands(n:number, range?:number) {block?}
@(func?:function) {block?}
lambda(`args*) {block}
@@() {block?}
<module:os>
<module:time>
