xenial (7) afnix-reference.7.gz
NAME
vol-2 - afnix reference manual
RESERVED KEYWORDS
Reserved keyword are, with symbols and literals, the basic constituents of the writing system. With
couple of exception, reserved keywords are in fact special forms. During the execution, a special
assert
The assert special form check for equality between two operands. Both objects must be of the same type.
If the equality test fails, the special form print a message and abort the execution. By default, the
assertion checking is turned off. The interpreter option -f assert enables the assertion checking. When
the interpreter is compiled in debug mode, the assertion checking is turned on by default.
Syntax
assert "form 1" "form 2"
Example
assert true (== 1 1) assert 3 (+ 2 1)
block
The block special form defines a new nameset for sequential execution of regular form or implicit form.
When the block form is evaluated, the block nameset is linked to its parent nameset. When all forms have
been executed, the block nameset is destroyed and the result of the last evaluation in the block is
considered to be the result of the block evaluation.
Syntax
block "regular form" block "block form"
Example
trans a 1 block {
assert a 1
trans a (+ 1 1)
assert a 2
assert ..:a 1 } assert 1 a
class
The class special form creates a new class object. Without argument, an instance of that class is created
without data members.
Syntax
class
Example
const Color (class) trans Color:preset (red green blue) {
const this:red red
const this:green green
const this:blue blue } const red (Color 255 0 0) const green (Color 0 255 0) const
blue (Color 0 0 255)
const
The const special form binds a symbol with an object and marks it as a constant symbol. When used with
three or four argument, a gamma expression is automatically created. const can also be used to bind class
or instance members.
Syntax
const symbol "object" const symbol "argument" "body" const symbol "argument" "closed variables"
"body"
Example
const number 123 const max (x y) (if (> x y) x y)
delay
The delay special form delays the evaluation of the form argument by creating a Promise object. The
promise evaluate to itself until a call to force the evaluation has been made. When the promise has been
forced, the evaluation result is stored. Further call to force will produce the same result. Without
argument, the delayed evaluation is nil. With one argument, a Promise object is created directly. With
several argument, a cons cell is created with the first argument left unevaluated and the other
evaluated. This permit to delay a form while evaluatin the calling arguments.
Syntax
delay "form"
Example
trans y 3 const l ((lambda (x) (+ x y)) 1) assert 4 (force l) trans y 0 assert 4 (force l)
trans y 1 trans d (delay (lambda (x) (+ x 1)) y) assert 2 (force d)
do
The do special form is used to build loop with forward condition. The loop construct accepts either 2 or
3 arguments. With 2 argument, the first argument is the loop body and the second argument is the loop
condition which must evaluates to a boolean object. With 3 arguments, the first argument is the initial
condition that is executed only once.
Syntax
do "body" "condition" do "initial" "body" "condition"
Example
const number-of-digits (s) {
const len (s:length)
trans index 0
trans count 0
do {
trans c (s:get index)
if (c:digit-p) (count:++)
} (< (index:++) len)
eval count }
enum
The enum special form creates an enumeration from a list of literal. The result object is an Enum object
that holds the enumerated items. An item evaluation results with an Item object that is bound to the
enumeration object.
Syntax
enum "literal" ...
Example
const e (enum E1 E2 E3)
errorln
The errorln special form prints on the interpreter error stream a set of arguments. Each arguments have
to be a literal which are converted to a string. When all arguments have been printed a new line
character is printed. The error special form behaves like errorln excepts that a new line character is
not printed at the end of the arguments.
Syntax
errorln errorln "nil" errorln "literal list"
Example
errorln errorln "hello millennium" ' ' 2000
eval
The eval special form simply evaluates the object argument. The form is useful when returning an argument
from a lambda or gamma expression using an implicit form.
Syntax
eval "object"
Example
const ret (x) (eval x) eval (protect (+ 1 2))
for
The for special form provides a facility to iterate on iterable objects. The Cons, List and Vector
objects are typical iterable objects. For each iterable objects, a symbol is set after each iteration.
Each object symbol value can be used for further computation. The iteration stops when one of the objects
iterator is at the end position.
Syntax
for "symbol list" "iterable object list" "body"
Example
# compute the scalar product of two vectors const scalar-product (u v) {
trans result 0
for (x y) (u v) (result:+= (* x y))
eval result }
force
The force special form forces the evaluation of its argument. If the argument evaluates to a promise
object, the promise evaluation is forced. If the argument is not a promise, force keyword behaves like
eval. When a promise has been forced, further call to force will not change the evaluation result.
Syntax
force "object"
Example
trans y 3 const l ((lambda (x) (+ x y)) 1) assert 4 (force l) trans y 0 assert 4 (force l)
if
The if special form executes a form based on the evaluation of a boolean expression. In its first
representation, if executes a form if the condition is evaluated to true. An alternate form can be
specified and is executed if the boolean expression evaluates to false. It is an error to use a
conditional form which does not evaluate to a boolean object.
Syntax
if "condition" "true form" if "condition" "true form" "else form"
Example
const max (x y) (if (> x y) x y)
lambda
The lambda special form creates a new closure object with eventually a set of arguments and a set of
closed variables. In its first form, the closure is declared with a set of arguments or nil to indicate
no argument. In its second form, the closure is declared with a set of arguments and a set of closed
variables. The closed variables are evaluated at the construction of the closure and become part of the
closure object. When the closure is called, a new nameset is created and linked with the parent nameset.
The set of calling arguments are bounded in that nameset with the formal argument list to become the
actual arguments. The set of closed variables is linked at runtime to the closure nameset. A lambda or
gamma expression can have its argument declared as const argument.
Syntax
lambda "nil" "body" lambda "argument list" "body" lambda "argument list" "closed variables list"
"body"
Example
const no-args (lambda nil (+ 1 1)) const add (lambda ((const x) (const y)) (+ x y)) const
closed (lambda (x) (y) (+ x y))
launch
The launch special form creates a new thread by executing the form argument in a normal thread. The
created thread is added in the normal thread list by creating a clone of the interpreter and starting
immediately the execution of the form with the cloned interpreter. The command returns the thread object
in the calling thread. When the thread terminates, the thread object holds the result of the last
executed form. The main thread is suspended until all normal threads have completed their execution.
Syntax
launch "form" launch "thread" "form"
Example
launch (println "hello world")
loop
The loop special form executes a loop based on an initial condition, an exit condition and a step form.
The initial condition is only executed one time. The exit condition is tested at each loop iteration. The
loop special form creates its own nameset since the initial condition generally binds symbol locally for
the loop.
Syntax
loop "init form" "exit form" "step" "form"
Example
loop (trans i 0) (< i 10) (i:++) (println i)
nameset
The nameset special form creates a new nameset. With no argument, a new nameset is created and no parent
is binded to this nameset. With one argument, the argument must evaluate to a nameset and that nameset is
used as the parent one. If a nameset has to be created with the global nameset as the parent, the symbol
... can be used to reference the top level nameset. The symbol . references the current nameset. The
symbol .. references the parent nameset of the current nameset.
Syntax
nameset nameset "parent nameset"
Example
const local-nameset-not-bound (nameset) const local-nameset-bounded (nameset ...) const
...:global-nameset (nameset)
println
The println special form prints on the interpreter output stream a set of arguments. Each arguments have
to be a literal which is converted to a string. When all arguments have been printed a new line character
is printed. The print special form behaves like println excepts that a new line character is not printed
at the end of the arguments.
Syntax
println println "nil" println "literal list"
Example
println println "hello millennium" ' ' 2000
protect
The protect special form take a single argument and returns it without evaluation. Protect is mainly use
to get a symbol or form object.
Syntax
protect "object"
Example
const cons (protect (+ 1 2))
return
The return special form causes the current expression to stop its evaluation and returns the argument or
nil. The return keyword is primarily used in lambda or gamma expressions. If used in a top level block,
the block execution is stopped and the control is transferred to the top level.
Syntax
return "object"
Example
return (+ 1 2)
sync
The sync special form is a form synchronizer. Within a multi-threaded environment, the engine guarantees
that only one thread will execute the form. The other threads are suspended until the form has been
completed.
Syntax
sync "form"
Example
const print-message (code mesg) (
sync {
errorln "error : " code
errorln "message: " mesg
} )
switch
The switch special form is a form selector. The first argument is the object to switch. The second
argument is a list of forms with an object matcher and an execution form. The else special form can be
used as default matcher.
Syntax
switch "selector" "list of conditions"
Example
const get-primary-color (color value) (
switch color (
("red" (return (value:substr 0 2))
("green" (return (value:substr 2 4))
("blue" (return (value:substr 4 6))
)
)
throw
The throw special form throws an exception. Without argument, an exception of type user-exception is
thrown. With one argument, the exception id is set. With two arguments, the exception id and exception
reason are set. With three arguments, the exception id, exception reason and exception object are set. An
exception object represented by the symbol what can also be thrown. This is the method used to re-throw
an exception.
Syntax
throw throw what throw "id" throw "id" "reason" throw "id" "reason" "object"
Example
throw throw "type-error" throw "type-error" "invalid argument"
trans
The trans special form creates or sets a symbol with an object. trans searches in the current nameset
only. If a symbol is found, it is set with the object. If the symbol is not found, it is created in the
current nameset. The trans keyword can also be used with qualified names. With 3 or 4 arguments, trans
creates automatically a lambda expression.
Syntax
trans symbol "object" trans symbol "argument" "body" trans symbol "argument" "closed variables"
"body"
Example
trans a 1 trans fact (n) (if (< n 1) 1 (* n (fact (- n 1))))
try
The try special form catch an exception in the current execution nameset. The first argument is a form to
execute. The optional second argument is the exception handler to be called in case of exception. If
there is no exception handler, all exceptions are caught. The result of execution is either the result of
the form execution, or the exception object in case of exception, or nil if the exception is a native
one. If there is an exception handler, the handler is executed with a new nameset and the special symbol
what is bound to the exception. If the exception is nil, the symbol what is undefined.
Syntax
try "form" try "form" " exception handler"
Example
try (+ 1 2) try (throw) try (throw "hello") try (throw "hello" "world") try (throw "hello" "world"
"folks")
unref
The unref special form unreference a symbol.
Syntax
unref symbol
Example
const number 123 unref number
while
The while special form is used to build loop with backward condition. The loop construct accepts either 2
or 3 arguments. With 2 argument, the first argument is the loop condition and the second argument is the
loop body that must evaluate to a boolean. With 3 arguments, the first argument is the initial condition
that is executed only once.
Syntax
while "condition" "body" while "initial" "condition" "body"
Example
const gcd (u v) {
while (!= v 0) {
trans r (u:mod v)
u:= v
v:= r
}
eval u }
RESERVED OBJECTS
This chapter is a reference of the reserved objects with their respective builtin methods. The reserved
objects are those objects defined in the global interpreter nameset and bind as reserved names. All
literal have a string representation. The to-string method is always available for these reserved
objects. A literal object has a default constructor. Generally, it can also be constructed by a same type
object or by a string object.
Literal
The Literal object is a base object for all literal object. The sole purpose of a literal object is to
provide to methods named to-string and to-literal that return a string representation of the literal
object.
Predicate
literal-p
Inheritance
Serial
Methods
to-string -> String (none)
The to-string method returns a string representation of the literal. The string is expected to
represent at best the literal.
to-literal -> String (none)
The to-literal method returns a string representation of the literal. The string differs from the
to-string method in the sense that the string is a literal representation. For example the literal
representation of a string is the quoted string.
Nameable
The Nameable object is a base object that support name definition. The sole purpose of a literal object
is to provide to method named get-name that returns the object name.
Predicate
nameable-p
Inheritance
Object
Methods
get-name -> String (none)
The get-name method returns the associated object name. The object name defined here is a name
that the class wishes to associate with the object. For example, the InputFile is a nameable class
and the name is the file name.
Item
The Item reserved object is an enumeration item. The item is bound to an enumeration object. An item
object is created during the evaluation of an enumeration object. An enumeration item cannot be
constructed directly.
Predicate
item-p
Inheritance
Literal
Operators
== -> Boolean (Boolean)
The == operator returns true if the calling object is equal to the boolean argument.
!= -> Boolean (Boolean)
The == operator returns true if the calling object is not equal to the boolean argument.
Methods
get-enum -> Enum (none)
The get-enum method returns the enumeration object bound to the item. The item must be a dynamic
item or an exception is thrown.
Boolean
The Boolean reserved object implements the behavior of a native boolean type. Two builtin symbols, namely
true and false are used to represent the value of a boolean instance. The Boolean type is primarily used
for test expression.
Predicate
boolean-p
Inheritance
Literal
Constructors
Boolean (none)
The Boolean constructor create a boolean object those default value is false.
Boolean (Boolean)
The Boolean constructor create a boolean object with the boolean object argument.
Boolean (String)
The Boolean constructor create a boolean object with the string object argument. The string "true"
denotes the true value while the string "false" denotes the false value.
Operators
== -> Boolean (Boolean)
The == operator returns true if the calling object is equal to the boolean argument.
!= -> Boolean (Boolean)
The == operator returns true if the calling object is not equal to the boolean argument.
Number
The Number reserved objectis a base class for all number objects. The number base object is used by the
Integer, Real and Relatif objects. The class provides essentially the methods needed to format a number.
Predicate
number-p
Inheritance
Literal
Methods
format -> String (none|Integer)
The format method format the calling number instance with a certain number of digits after the
decimal point. In the first form without argument, the default formating representation is
performed with a null precision. In the second format, a number is represented with a certain
precision given by the calling argument.
to-hexa -> String (none)
The to-hexa method returns a signed hexadecimal representation of a number. This method works well
with Integer and Relatif objects.
to-hexa-string -> String (none)
The to-hexa-string method returns a hexadecimal representation of a number without a prefix. The
number is always considered positive. This method works well with Integer and Relatif objects.
Integer
The Integer reserved object implements the behavior of a native 64 bits signed integer type. Standard
decimal notation is used to construct integer object from a literal. The integer object can also be
constructed from a string. Standard operators are provided for this class. The Integer object is a
literal object derived from the Number object.
Predicate
integer-p
Inheritance
Number
Constructors
Integer (none)
The Integer constructor create an integer object those default value is 0.
Integer (Real)
The Integer constructor create an integer object with the real object argument those value is
truncated to an integer value.
Integer (Integer)
The Integer constructor create an integer object with the integer object argument.
Integer (Character)
The Integer constructor create an integer object with the character object argument. The character
encoding value is used as the integer value.
Operators
== -> Boolean (Integer|Real)
The == operator returns true if the calling object is equal to the integer or real argument.
!= -> Boolean (Integer|Real)
The != operator returns true if the calling object is not equal to the integer or real argument.
+ -> Integer (Integer|Real)
The + operator returns the sum of the calling integer with an integer or a real object.
- -> Integer (Integer|Real)
The - operator returns the subtraction of the calling integer with an integer or a real object.
* -> Integer (Integer|Real)
The * operator returns the multiplication of the calling integer with an integer or a real object.
/ -> Integer (Integer|Real)
The / operator returns the division of the calling integer with an integer or a real object.
< -> Boolean (Integer|Real)
The < operator returns true if the calling integer is less than the integer or real object.
<= -> Boolean (Integer|Real)
The <= operator returns true if the calling integer is less equal than the integer or real object.
> -> Boolean (Integer|Real)
The > operator returns true if the calling integer is greater than the integer or real object.
>= -> Boolean (Integer|Real)
The >= operator returns true if the calling integer is greater equal than the integer or real
object.
++ -> Integer (Integer|Real)
The ++ operator increments the calling integer by 1.
-- -> Integer (Integer|Real)
The -- operator decrements the calling integer by 1.
+= -> Integer (Integer|Real)
The += operator add and assign the calling integer with an integer or real argument object.
-= -> Integer (Integer|Real)
The -= operator subtracts and assign the calling integer with an integer or real argument object.
*= -> Integer (Integer|Real)
The *= operator multiply and assign the calling integer with an integer or real argument object.
/= -> Integer (Integer|Real)
The /= operator divide and assign the calling integer with an integer or real argument object.
Methods
or -> Integer (Integer)
The or method returns the binary or between the integer and the integer argument.
abs -> Integer (none)
The abs method returns the absolute value of the calling integer instance.
not -> Integer (none)
The not method returns the binary negation of the calling integer instance.
shl -> Integer (Integer)
The shl method returns a new integer corresponding to the calling integer instance shifted left by
the integer argument.
shr -> Integer (Integer)
The shr method returns a new integer corresponding to the calling integer instance shifted right
by the integer argument.
and -> Integer (Integer)
The and method returns a new integer corresponding to the binary and between the calling integer
instance and the integer argument.
xor -> Integer (Integer)
The xor method returns a new integer corresponding to the binary xor between the calling integer
instance and the integer argument.
mod -> Integer (Integer)
The mod method returns the modulo between the integer instance and the integer argument. A type-
error exception is raised if the argument is not an argument.
odd-p -> Boolean (none)
The odd-p method returns true if the integer instance is odd, false otherwise.
even-p -> Boolean (none)
The even-p method returns true if the integer instance is even, false otherwise.
zero-p -> Boolean (none)
The zero-p method returns true if the integer instance is null, false otherwise.
Relatif
The Relatif reserved object implements the behavior of an unlimited signed integer type. Standard decimal
notation followed by the 'r' or 'R' character is used to construct relatif object from a literal. The
relatif object can also be constructed from a string. This class is similar to the Integer class. The
Relatif is a literal object derived from the Number object.
Predicate
relatif-p
Inheritance
Number
Constructors
Relatif (none)
The Relatif constructor create a relatif object those default value is 0.
Relatif (Real)
The Relatif constructor create an relatif object with the real object argument those value is
truncated to an integer value.
Relatif (Relatif)
The Relatif constructor create an relatif object with the relatif object argument.
Relatif (Integer)
The Relatif constructor create an relatif object with the integer object argument.
Relatif (Character)
The Relatif constructor create an relatif object with the character object argument. The character
encoding value is used as the relatif value.
Operators
== -> Boolean (Relatif|Integer)
The == operator returns true if the calling object is equal to the relatif or integer argument.
!= -> Boolean (Relatif|Integer)
The == operator returns true if the calling object is not equal to the relatif or integer
argument.
+ -> Relatif (Relatif|Integer)
The + operator returns the sum of the calling relatif with an relatif or a integer object.
- -> Relatif (Relatif|Integer)
The - operator returns the subtraction of the calling relatif with an relatif or a integer object.
* -> Relatif (Relatif|Integer)
The * operator returns the multiplication of the calling relatif with an relatif or a integer
object.
/ -> Relatif (Relatif|Integer)
The / operator returns the division of the calling relatif with an relatif or a integer object.
< -> Boolean (Relatif|Integer)
The < operator returns true if the calling relatif is less than the relatif or integer object.
<= -> Boolean (Relatif|Integer)
The <= operator returns true if the calling relatif is less equal than the relatif or integer
object.
> -> Boolean (Relatif|Integer)
The > operator returns true if the calling relatif is greater than the relatif or integer object.
>= -> Boolean (Relatif|Integer)
The >= operator returns true if the calling relatif is greater equal than the relatif or integer
object.
++ -> Relatif (Relatif|Integer)
The ++ operator increments the calling relatif by 1.
-- -> Relatif (Relatif|Integer)
The -- operator decrements the calling relatif by 1.
+= -> Relatif (Relatif|Integer)
The += operator add and assign the calling relatif with an relatif or integer argument object.
-= -> Relatif (Relatif|Integer)
The -= operator subtracts and assign the calling relatif with an relatif or integer argument
object.
*= -> Relatif (Relatif|Integer)
The *= operator multiply and assign the calling relatif with an relatif or integer argument
object.
/= -> Relatif (Relatif|Integer)
The /= operator divide and assign the calling relatif with an relatif or integer argument object.
Methods
or -> Relatif (Relatif)
The or method returns the binary or between the relatif and the relatif argument.
abs -> Relatif (none)
The abs method returns the absolute value of the calling relatif instance.
not -> Relatif (none)
The not method returns the binary negation of the calling relatif instance.
shl -> Relatif (Integer)
The shl method returns a new relatif corresponding to the calling relatif instance shifted left by
the integer argument.
shr -> Relatif (Integer)
The shr method returns a new relatif corresponding to the calling relatif instance shifted right
by the integer argument.
pow -> Relatif (Integer|Relatif|Integer Integer|Relatif Relatif)
The pow method returns a new relatif corresponding to the power of the calling relatif instance
with the integer or relatif argument. With one argument, the power is computed directly. With two
arguments, a fast modular exponentiation is performed with the second argument as the modulus.
mmi -> Relatif (Integer|Relatif)
The mmi method returns the multiplicative modular inverse of the calling relatif. The argument is
the modulus to use for the inverse calculation.
and -> Relatif (Relatif)
The and method returns a new relatif corresponding to the binary and between the calling relatif
instance and the relatif argument.
xor -> Relatif (Relatif)
The xor method returns a new relatif corresponding to the binary xor between the calling relatif
instance and the relatif argument.
mod -> Relatif (Relatif|Integer)
The mod method returns the modulo between the relatif instance and the relatif or integer
argument. A type-error exception is raised if the argument is invalid.
odd-p -> Boolean (none)
The odd-p method returns true if the relatif instance is odd, false otherwise.
even-p -> Boolean (none)
The even-p method returns true if the relatif instance is even, false otherwise.
zero-p -> Boolean (none)
The zero-p method returns true if the relatif instance is null, false otherwise.
get-msb -> Integer (none)
The get-msb method returns the most significnd bit position for the calling relatif. If the number
is null, 0 is returned. The msb position is thus counted from 1.
Real
The Real reserved object implements the behavior of a double floating point number type. Standard decimal
dot notation or scientific notation is used to construct real object from a literal. The real object can
also be constructed from an integer, a character or a string. The Real object is a literal object derived
from the Number object.
Predicate
real-p
Inheritance
Number
Constructors
Real (none)
The Real constructor create an real object those default value is 0.0.
Real (Real)
The Real constructor create an real object with the real object argument.
Real (Integer)
The Real constructor create an real object with the integer object argument.
Real (Character)
The Real constructor create an real object with the character object argument. The character
encoding value is used as the integer value.
Operators
== -> Boolean (Integer|Real)
The == operator returns true if the calling object is equal to the integer or real argument.
!= -> Boolean (Integer|Real)
The == operator returns true if the calling object is not equal to the integer or real argument.
+ -> Real (Integer|Real)
The + operator returns the sum of the calling real with an integer or a real object.
- -> Real (Integer|Real)
The - operator returns the subtraction of the calling real with an integer or a real object.
* -> Real (Integer|Real)
The * operator returns the multiplication of the calling real with an integer or a real object.
/ -> Real (Integer|Real)
The / operator returns the division of the calling real with an integer or a real object.
< -> Boolean (Integer|Real)
The < operator returns true if the calling real is less than the integer or real object.
<= -> Boolean (Integer|Real)
The <= operator returns true if the calling real is less equal than the integer or real object.
> -> Boolean (Integer|Real)
The > operator returns true if the calling real is greater than the integer or real object.
>= -> Boolean (Integer|Real)
The >= operator returns true if the calling real is greater equal than the integer or real object.
++ -> Real (Integer|Real)
The ++ operator increments the calling real by 1.
-- -> Real (Integer|Real)
The -- operator decrements the calling real by 1.
+= -> Real (Integer|Real)
The += operator add and assign the calling real with an integer or real argument object.
-= -> Real (Integer|Real)
The -= operator subtracts and assign the calling real with an integer or real argument object.
*= -> Real (Integer|Real)
The *= operator multiply and assign the calling real with an integer or real argument object.
/= -> Real (Integer|Real)
The += operator divide and assign the calling real with an integer or real argument object.
Methods
nan-p -> Boolean (none)
The nan-p method returns true if the calling real number instance is not-a-number (nan).
ceiling -> Real (none)
The ceiling method returns the ceiling of the calling real number instance.
floor -> Real (none)
The floor method returns the floor of the calling real number instance.
abs -> Real (none)
The abs method returns the absolute value of the calling real number instance.
pow -> Real (Real|Integer)
The pow method returns the power of the calling real with the argument. The exponent argument can
be either an integer or a real number.
sqrt -> Real (none)
The sqrt method returns the square root of the calling real number instance.
ln -> Real (none)
The ln method returns the natural logarithm of the calling real number instance.
exp -> Real (none)
The exp method returns the exponential of the calling real number instance.
sin -> Real (none)
The sin method returns the sine of the calling floating point instance. The angle is expressed in
radian.
cos -> Real (none)
The cos method returns the cosine of the calling floating point instance. The angle is expressed
in radian.
tan -> Real (none)
The tan method returns the tangent of the calling floating point instance. The angle is expressed
in radian.
asin -> Real (none)
The asin method returns the arc sine of the calling floating point instance. The result is in
radian.
acos -> Real (none)
The acos method returns the arc cosine of the calling floating point instance. The result is in
radian.
atan -> Real (none)
The atan method returns the arc tangent of the calling floating point instance. The result is in
radian.
sinh -> Real (none)
The sinh method returns the hyperbolic sine of the calling real number instance.
cosh -> Real (none)
The cosh method returns the hyperbolic cosine of the calling real number instance.
tanh -> Real (none)
The atan method returns the hyperbolic tangent of the calling real number instance.
asinh -> Real (none)
The asinh method returns the hyperbolic arc sine of the calling real number instance.
acosh -> Real (none)
The acosh method returns the hyperbolic arc cosine of the calling real number instance.
atanh -> Real (none)
The atanh method returns the hyperbolic arc tangent of the calling real number instance.
zero-p -> Boolean (none)
The zero-p method returns true if the calling real instance is null, false otherwise.
Character
The Character reserved object implements the behavior of an Unicode character type. A character can be
constructed from a literal quoted notation, with a string or with the U+ hexadecimal notation. The
character class is designed to handle the full range of the Unicode character space by using an internal
32 bit quad representation with 31 bit valid. The Character class conform also with the ISO 10646
character representation.
Predicate
character-p
Inheritance
Literal
Constructors
Character (none)
The Character constructor create a character object those default value is the null character.
Character (String)
The Character constructor create a character object with the string object argument.
Character (Integer)
The Character constructor create a character object with the integer object argument.
Character (Character)
The Character constructor create a character object with the character object argument.
Operators
== -> Boolean (Character)
The == operator returns true if the calling object is equal to the character argument.
!= -> Boolean (Character)
The != operator returns true if the calling object is not equal to the character argument.
< -> Boolean (Character)
The < operator returns true if the calling character is less than the character object.
<= -> Boolean (Character)
The <= operator returns true if the calling character is less equal than the character object.
> -> Boolean (Character)
The > operator returns true if the calling character is greater than the character object.
>= -> Boolean (Character)
The >= operator returns true if the calling character is greater equal than the character object.
++ -> Character (Character)
The ++ operator increments the calling character by the next one in lexicographic order.
-- -> Character (Character)
The -- operator decrements the calling character by the previous one in lexicographic order.
+= -> Character (Integer)
The += operator add the integer argument to the calling character.
-= -> Character (Integer)
The -= operator subtracts the integer argument to the calling character.
Methods
letter-p -> Boolean (none)
The letter-p predicate returns true if the character is a letter character, false otherwise.
digit-p -> Boolean (none)
The digit-p predicate returns true if the character is a digit character, false otherwise.
alpha-p -> Boolean (none)
The alpha-p predicate returns true if the character is an alphanumeric character, false otherwise.
blank-p -> Boolean (none)
The blank-p predicate returns true if the character is a blank or tab character, false otherwise.
eol-p -> Boolean (none)
The eol-p predicate returns true if the character is an end-of-line character, false otherwise.
eos-p -> Boolean (none)
The eos-p predicate returns true if the character is an end-of-stream character, false otherwise.
nil-p -> Boolean (none)
The nil-p predicate returns true if the character is the nil character, false otherwise.
to-integer -> Integer (none)
The to-integer method returns an integer representation of the characters.
Byte
The Byte reserved object implements the behavior of an 8 bit character type. A byte can be constructed
from a integer or from another byte. The Byte class is similar to the Character class but is not a
literal object because it does not have a literal representation. Most of the time, a byte object is
created by another object like a stream, when using the read method for example.
Predicate
byte-p
Inheritance
Serial
Constructors
Byte (none)
The Byte constructor create a byte object those default value is the null byte.
Byte (Integer)
The Byte constructor create a byte object with the integer object argument. The integer value must
be in the range of 0x00 to 0xFF.
Byte (Byte)
The Byte constructor create a byte object with the byte object argument.
Operators
== -> Boolean (Byte)
The == operator returns true if the calling object is equal to the byte argument.
!= -> Boolean (Byte)
The != operator returns true if the calling object is not equal to the byte argument.
< -> Boolean (Byte)
The < operator returns true if the calling byte is less than the byte object.
<= -> Boolean (Byte)
The <= operator returns true if the calling byte is less equal than the byte object.
> -> Boolean (Byte)
The > operator returns true if the calling byte is greater than the byte object.
>= -> Boolean (Byte)
The >= operator returns true if the calling byte is greater equal than the byte object.
++ -> Byte (Byte)
The ++ operator increments the calling byte by one.
-- -> Byte (Byte)
The -- operator decrements the calling byte by one.
+= -> Byte (Integer)
The += operator adds the integer argument to the calling byte.
-= -> Byte (Integer)
The -= operator subtracts the integer argument to the calling byte.
Methods
eos-p -> Boolean (none)
The eos-p predicate returns true if the character is an end-of-stream character, false otherwise.
nil-p -> Boolean (none)
The nil-p predicate returns true if the byte is the nil byte, false otherwise.
to-integer -> Integer (none)
The to-integer method returns an integer representation of the byte.
to-char -> Character (none)
The to-char method returns a character representing the byte.
String
The String reserved object implements the behavior of an internal character array. The double quote
notation is the literal notation for a string. A string can also be constructed from the standard
objects. Strings can be compared, transformed or extracted with the help of the methods listed below.
Internally, the string is represented as an array of Unicode characters.
Predicate
string-p
Inheritance
Literal
Constructors
String (none)
The String constructor create a string object those default value is the null string.
String (Literal)
The String constructor create a string object with the literal object argument.
Operators
== -> Boolean (String)
The == operator returns true if the calling object is equal to the string argument.
!= -> Boolean (String)
The != operator returns true if the calling object is not equal to the string argument.
< -> Boolean (String)
The < operator returns true if the calling string is less than the string argument.
<= -> Boolean (String)
The <= operator returns true if the calling string is less equal than the string argument.
> -> Boolean (String)
The > operator returns true if the calling string is greater than the string argument.
>= -> Boolean (String)
The >= operator returns true if the calling string is greater equal than the string argument.
+ -> String (String)
The + operator returns the sum of the calling string with an string object.
+= -> String (String)
The += operator add and assign the calling string with the string argument.
Methods
length -> Integer (none)
The length method returns the length of the string.
first -> Character (none)
The first method returns the first character in the string.
last -> Character (none)
The last method returns the last character in the string.
strip-left -> String (none|String)
The strip-left method removes the leading blanks and tabs and returns a new string. With a string
argument, each character in the string is taken as a character separator that should be stripped.
strip-right -> String (none|String)
The strip-right method removes the trailing blanks and tabs and returns a new string.With a string
argument, each character in the string is taken as a character separator that should be stripped.
strip -> String (none|String)
The strip method removes the leading, trailing blanks and tabs and returns a new string. With a
string argument, each character in the string is taken as a character separator that should be
stripped.
split -> Vector (none|String)
The split method split the string into one or more string according to break sequence. If no
argument is passed to the call, the break sequence is assumed to be a blank, tab and eol
characters.
extract -> Vector (Character)
The extract method extracts one or more string which are enclosed by a control character passed as
an argument. The method returns a vector of strings.
to-upper -> String (none)
The to-upper converts all string characters to upper case and returns a new string.
to-lower -> String (none)
The to-lower method converts all string characters to lower case and returns a new string.
get -> Character (Integer)
The get method returns a the string character at the position given by the argument. If the index
is invalid, an exception is raised.
sub-left -> String (Integer)
The sub-left method returns the left sub string of the calling string up-to the argument index. If
the index is out of range, the string is returned.
sub-right -> String (Integer)
The sub-right method returns the right sub string of the calling string starting at the argument
index. If the index is out of range, the string is returned.
fill-left -> String (Character Integer)
The fill-left method returns a string filled on the left with the character argument. The second
argument is the desired length of the resulting string. If the calling is too long, the string is
returned.
fill-right -> String (Character Integer)
The fill-left method returns a string filled on the right with the character argument. The second
argument is the desired length of the resulting string. If the calling is too long, the string is
returned.
substr -> String (Integer Integer)
The substr method returns a string starting at the first argument index and ending at the second
argument index. If the indexes are out of range, an exception is raised.
strcic -> Boolean (String)
The strcic method compare the calling string with the argument string in a case insensitive way.
Regex
The Regex object is a special object which is automatically instantiated by the interpreter when using
the delimiter character [ and ]. The regex syntax involves the use of standard characters, meta
characters and control characters. Additionally, a string can be use to specify a series of characters.
In its first form, the [ and ] characters are used as syntax delimiters. The lexical analyzer
automatically recognizes this token as a regex and built the equivalent Regex object. The second form is
the explicit construction of the Regex object. Note also that the [ and ] characters are also used as
regex block delimiters. Any character, except the one used as operators can be used in a regex. The $
character is used as a meta-character -- or control character -- to represent a particular set of
characters. For example, [hello world] is a regex which match only the "hello world" string. The [$d+]
regex matches one or more digits. The following control characters are builtin in the regex engine.
Character Description
$a matches any letter or digit
$b matches any blank characters
$c matches any combining characters
$d matches any digit
$e matches eol, cr and eos
$l matches any lower case letter
$n matches eol or cr
$s matches any letter
$u matches any upper case letter
$v matches any valid constituent
$w matches any word constituent
$x matches any hexadecimal characters
The uppercase version is the complement of the corresponding lowercase character set. A character which
follows a $ character and that is not a meta character is treated as a normal character. For example $[
is the [ character. A quoted string can be used to define character matching which could otherwise be
interpreted as control characters or operator. A quoted string also interprets standard escaped sequences
but not meta characters.
Character Description
$A any character except letter or digit
$B any character except blank characters
$C any character except combining characters
$D any character except digit
$E any character except eol, cr and eos
$L any character except lower case letter
$N any character except eol or cr
$S any character except letter
$U any character except upper case letter
$V any character except constituent
$W any character except word constituent
$X any character except hex characters
A character set is defined with the < and > characters. Any enclosed character defines a character set.
Note that meta characters are also interpreted inside a character set. For example, <$d+-> represents any
digit or a plus or minus. If the first character is the ^ character in the character set, the character
set is complemented with regards to its definition. The following unary operators can be used with single
character, control characters and sub-expressions.
Operator Description
* match 0 or more times
+ match 1 or more times
? match 0 or 1 time
| alternation
Alternation is an operator which work with a secondary expression. Care should be taken when writing the
right sub-expression. For example the following regex [$d|hello] is equivalent to [[$d|h]ello]. In other
word, the minimal first sub-expression is used when compiling the regex.
Predicate
regex-p
Inheritance
Literal
Constructors
Regex (none)
The Regex constructor create a regex object those default value is the null regex.
Regex (String)
The Regex constructor create a regex object with the string object argument. The string argument
is the regex specification.
Operators
== -> Boolean (String)
The == operator returns true if the argument is matched by the regex.
!= -> Boolean (String)
The != operator returns true if the argument is not matched by the regex.
< -> Boolean (String)
The < operator returns true if the argument is partially matched by the regex.
Methods
length -> Integer (none)
The length method returns the length of the group vector when a regex match has been successful.
get -> String (Integer)
The get method returns by index the group sub-string when a regex match has been successful.
match -> String (String)
The match method returns the first matching string of the argument string.
replace -> String (String String)
The replace method returns a string constructed by replacing all matching sub-string -- from the
first argument -- with the second argument string.
CONTAINER OBJECTS
This chapter is a reference of the reserved container objects with their respective builtin methods. Some
of these container objects are iterable objects. When an object is iterable, an iterator constructor
constructor is provided. The iterable-p predicate returns true if the container is an iterable object.
The get-iterator method can be used to construct an object iterator. For a given iterator, the predicates
end-p and valid-p can be used to check for the end or a valid iterator position. The next method move the
iterator to its next position. The prev method move the iterator -- if possible -- to its previous
position. The get-object method returns the object at the current iterator position.
Cons
A Cons instance or simply a cons cell is a simple element used to build linked list. The cons cell holds
an object and a pointer to the next cons cell. The cons cell object is called car and the next cons cell
is called the cdr. Historically, car means Current Address Register and cdr means Current Data Register.
This notation is still present here for the sake of tradition.
Predicate
cons-p
Inheritance
SerialIterable
Constructors
Cons (none)
The Cons constructor create a default cons cell with the car and cdr set to nil.
Cons (Objects...)
The Cons constructor create a list of cons cells with the object arguments. Each argument object
is assigned to the car of the cons cell while the cdr is used to link the cell together.
Methods
get-car -> Object (none)
The get-car method returns the car of the calling cons cell.
get-cdr -> Cons (none)
The get-cdr method returns the cdr of the calling cons cell.
get-cadr -> Object (none)
The get-cadr method returns the car of the cdr of the calling cons cell or nil if the cdr is nil.
get-caddr -> Object (none)
The get-caddr method returns the car of the cdr of the cdr of the calling cons cell or nil if the
cdr is nil.
get-cadddr -> Object (none)
The get-cadddr method returns the car of the cdr of the cdr of the cdr of the calling cons cell or
nil if the cdr is nil.
length -> Integer (none)
The length method returns the length of the cons cell. The minimum length returned is always 1.
nil-p -> Boolean (none)
The nil-p predicate returns true if the car of the calling cons cell is nil, false otherwise.
block-p -> Boolean (none)
The block-p predicate returns true if the cons cell is of type block, false otherwise.
get-iterator -> Iterator (none)
The get-iterator returns a forward iterator for this cons cell. No backward methods are supported
for this object.
set-car -> Object (Object)
The set-car set the car of the calling cons cell. The object argument is returned by the method.
set-cdr -> Cons (Cons)
The set-cdr set the cdr of the calling cons cell. The cons cell argument is returned by the
method.
add -> Object (Object)
The add method appends an object at the end of the cons cell chain by creating a new cons cell and
linking it with the last cdr. The object argument is returned by this method.
get -> Object (Integer)
The get method returns the car of the cons cell chain at a certain position specified by the
integer index argument.
Enum
The Enum builtin object is an enumeration object. The enumeration is constructed with the reserved
keyword enum and a list of literals or by string name with a constructor.
Predicate
enum-p
Inheritance
Object
Constructors
Enum (none)
The Enum constructor create an empty enumeration.
Enum (String...)
The Enum constructor create an enumeration from a list of string arguments.
Methods
reset -> none (none)
The reset method resets the enumeration and makes it empty.
length -> Integer (none)
The length method returns the number of items in the enumeration.
exists-p -> Boolean (String)
The exists-p predicate returns true if the name argument exists as an item. The name argument must
be a lexical name or an exception is thrown.
add -> none (String)
The add method adds a new item to the enumeration by name. This method returns nil.
get -> String (Integer)
The get method returns an item string representation by index. The integer argument is the item
index.
List
The List builtin object provides the facility of a double-link list. The List object is another example
of iterable object. The List object provides support for forward and backward iteration.
Predicate
list-p
Inheritance
Iterable
Constructors
List (none)
The List constructor create an empty list.
List (Object...)
The List constructor create a list from a list of object arguments.
Methods
length -> Integer (none)
The length method returns the length of the list. The minimum length is 0 for an empty list.
get-iterator -> Iterator (none)
The get-iterator returns a forward/backward iterator for this list.
add -> Object (Object)
The add method appends an object at the end of the list. The object argument is returned by this
method.
insert -> Object (Object)
The insert method inserts an object at the beginning of the list. The object argument is returned
by this method.
get -> Object (Integer)
The get method returns the object in the list at a certain position specified by the integer index
argument.
Strvec
The Strvec builtin object provides the facility of an index array of strings. The Strvec object is
serializable object that stores strings. The strings can be added with an optional preference for a
unique string value. The class is similar to the general purpose Vector class.
Predicate
strvec-p
Inheritance
Serial
Constructors
Strvec (none)
The Strvec constructor create an empty string vector.
Strvec (Integer|Boolean)
The Strvec constructor create a string vector with a predefined size or with a uniq flag. In the
first form, the preferred vector size is given as an argument. In the second form, the string
unicity flag is given as an argument.
Strvec (Integer Boolean)
The Strvec constructor create a string vector with a predefined size and a uniq flag. The first
argument is the preferred vector size. The second argument is the string unicity flag.
Methods
reset -> none (none)
The reset method resets the string vector. When the method is complete, the string vector is
empty.
length -> Integer (none)
The length method returns the length of the string vector. The minimum length is 0 for an empty
vector.
min-length -> Integer (none)
The min-length method returns the minimum string length of the string vector.
max-length -> Integer (none)
The max-length method returns the maximum string length of the string vector.
empty-p -> Boolean (none)
The empty-p predicate returns true if the vector is empty.
active-p -> Boolean (none)
The active-p predicate returns true if the vector is not empty. This predicate is the negation of
the empty-p predicate.
get -> String (Integer)
The get method returns the string in the vector at a certain position specified by the integer
index argument.
set -> none (Integer String)
The set method set a vector position with a string. The first argument is the vector index. The
second argument is the string to set.
first -> String (none)
The first method returns the first string in the vector.
last -> String (none)
The last method returns the last string in the vector.
pop -> Object (none)
The pop method removes the first element in the string vector and returns it.
pop-last -> String (none)
The pop-last method removes the last element in the string vector and returns it.
find -> Integer (String)
The find method try to find a string in the vector. If the string is found, the vector index is
returned else the -1 value is returned.
lookup -> Integer (String)
The lookup method try to find a string in the vector. If the string is found, the vector index is
returned else an exception is raised.
add -> none (String)
The add method adds an object at the end of the vector. If the uniq flag is active, the string
argument is not added if it already exists.
exists-p -> Boolean (String)
The exists-p method returns true if the string argument exists in the vector.
remove -> none (Integer|String)
The remove method removes a string from the vector by index or value. In the first form, the
vector index is used as the place to remove. In the second form, the string argument is used as a
key for removal. This method repacks the vector when the string has been removed.
set-unique -> none (Boolean)
The set-unique method set the string vector unique flag. When the unique flag is set, there is
only no string duplicate in the vector.
get-unique -> Boolean
The get-unique method returns the string vector unique flag value.
concat -> String (none | Character)
The concat method concatenates the string vector elements with a character separator. In the first
form, with a separator character, the resulting string is the concatenation of the string vector
elements. In the second form, the resulting string is the concatenation of the vector elements
with a character separator. If the character separator is nil then no separator is placed.
Vector
The Vector builtin object provides the facility of an index array of objects. The Vector object is
another example of iterable object. The Vector object provides support for forward and backward
iteration.
Predicate
vector-p
Inheritance
SerialIterable
Constructors
Vector (none)
The Vector constructor create an empty vector.
Vector (Object...)
The Vector constructor create a vector from a list of object arguments.
Methods
reset -> none (none)
The reset method reset the vector. When the method is complete, the vector is empty.
length -> Integer (none)
The length method returns the length of the vector. The minimum length is 0 for an empty vector.
empty-p -> Boolean (none)
The empty-p predicate returns true if the vector is empty.
get -> Object (Integer)
The get method returns the object in the vector at a certain position specified by the integer
index argument.
set -> Object (Integer Object)
The set method set a vector position with an object. The first argument is the vector index. The
second argument is the object to set. The method returns the object to set.
first -> Object (none)
The first method returns the first element in the vector.
last -> Object (none)
The last method returns the last element in the vector.
pop -> Object (none)
The pop method removes the first element in the vector and returns it.
pop-last -> Object (none)
The pop-last method removes the last element in the vector and returns it.
find -> Integer (Object)
The find method try to find an object in the vector. If the object is found, the vector index is
returned as an Integer object, else nilp is returned.
add -> Object (Object|Integer Object)
The add method appends an object at the end of the vector or at a certain index. In the first
form, the object argument is added at the end of the vector. In the second form, the object
argument is inserted in the vector at the specified index. In both cases, the object argument is
returned by this method.
exists-p -> Boolean (Object)
The exists-p method returns true if the object argument exists in the vector. This method is
useful to make sure that only one occurrence of an object is added to a vector.
clean -> none (Integer)
The clean method removes an object from the vector by index and repack the vector.
remove -> none (Object)
The remove method removes an object from the vector and repack the vector. If duplicate exists in
the file, only one is removed.
get-iterator -> Iterator (none)
The get-iterator returns a forward/backward iterator for this vector.
HashTable
The HashTable builtin object is a container object which maps an object with a name. The hash table is
dynamic and get resized automatically when needed. The lookup method throw an exception if the name is
not found. The get method returns nilp if the object is not found. The table can be configured to operate
in a case insensitive way. If the case flag is changed, the table is automatically reset.
Predicate
hashtable-p
Inheritance
Object
Constructors
HashTable (none)
The HashTable constructor create an empty table.
HashTable (Boolean)
The HashTable constructor create a table by case insensitive flag.
HashTable (Integer)
The HashTable constructor create a table with a specific size.
HashTable (Integer Boolean)
The HashTable constructor create a table by size and case insensitive flag.
Methods
reset -> none (none)
The reset method resets the table so that it becomes empty.
add -> none (String Object)
The add method adds a new object in the table by key. The first argument is the key used to
associate the object in the table. The second argument is the object to add.
length -> Object (none)
The length returns the number of objects in the table.
empty-p -> Boolean (none)
The empty-p predicate returns true if the table is empty.
set-case-flag -> none (Boolean)
The set-case-flag method sets the case insensitive flag. The table is automatically reset when is
method is called.
get-case-flag -> Boolean (none)
The get-case-flag method returns the case insensitive flag.
get -> Object (String)
The get method returns the object associated with a key. If the key is not found, nil is returned.
lookup -> Object (String)
The lookup method returns the object associated with a key. If the key is not found, an exception
is raised.
get-key -> String (Integer)
The get-key method returns the key associated with an entry in the table by index. If the index is
out of range, an exception is raised.
get-object -> Object (Integer)
The get-object method returns the object associated with an entry in the table by index. If the
index is out of range, an exception is raised.
Set
The Set builtin object provides the facility of a uniform set of objects. The Set object is another
example of iterable object. The Set object provides support for forward and backward iteration.
Predicate
set-p
Inheritance
SerialIterable
Constructors
Set (none)
The Set constructor create an empty set.
Set (Object...)
The Set constructor create a set from a list of object arguments.
Methods
reset -> none (none)
The reset method reset the set. When the method is complete, the set is empty.
length -> Integer (none)
The length method returns the number of elements in the set. The minimum length is 0 for an empty
set.
add -> Object (Object)
The add method appends an object in the set. If the object already exists in the set, it is not
added twice. This is the main difference between a set and a vector. The object argument is
returned by this method.
get -> Object (Integer)
The get method return object by index.
empty-p -> Boolean (Object)
The empty-p predicate returns true if the set is empty.
exists-p -> Boolean (Object)
The exists predicate returns true if the object argument exists in the set.
merge -> none (Set)
The merge method merges the set argument into the calling set. If an element already exists in the
set, it is not added.
remix -> none (Integer)
The remix method mixes the set by randomly swapping all the elements. This method is useful when
the set has been filled with a certain order by the access must be done randomly.
remove -> Boolean (Object)
The remove method removes the object argument from the set. if the object is removed, the method
returns true. If the object is not in the set, the method returns false.
get-random-subset -> Set (Integer)
The get-random-subset method returns a subset those cardinal is at least the size argument with a
set of randomly chosen elements. The result set might have a cardinal less than the requested size
if the calling set cardinal is less than the requested size.
get-iterator -> Iterator (none)
The get-iterator returns an iterator for this set. The iterator supports forward and backward
iteration.
Queue
The Queue builtin object is a container used to queue and dequeue objects. The order of entry in the
queue defines the order of exit from the queue. The queue is constructed either empty or with a set of
objects.
Predicate
queue-p
Inheritance
Object
Constructors
Queue (none)
The Queue constructor create an empty queue.
Queue (Object...)
The Queue constructor create a queue with a list of object arguments
Methods
enqueue -> Object (Object)
The enqueue adds an object in the queue and returns the queued object.
dequeue -> Object (none)
The dequeue dequeue an object in the order it was queued.
length -> Object (none)
The length returns the number of queued objects.
empty-p -> Boolean (none)
The empty-p method returns true if the queue is empty.
flush -> none (none)
The flush method flushes the queue so that it is empty.
Heap
The Heap builtin object is an object based heap class that organizes object with respect to a key. The
heap is organized as a binary tree those root element is either the object with the highest or the lowest
key. A flag controls whether the heap is operating in ascending or descending mode. By default, the heap
operates in ascending mode, which means that the root node is the lowest one. The heap is self-resizable.
The object insertion is also controlled by a minimum and maximum key. if the key is below the minimum key
or above the maximum key, the object is not inserted.
Predicate
heap-p
Inheritance
Object
Constructors
Heap (none)
The Heap constructor create an empty heap. By default the heap operates in ascending mode.
Heap (Integer)
The Heap constructor create a heap with a specific size. By default the heap operates in ascending
mode.
Heap (Boolean)
The Heap constructor create a heap with a specific mode. If the mode is true, the heap operates in
ascending order. If the mode is false, the heap operates in descending order. In ascending order,
the first object is the object with the lowest key.
Heap (Integer Boolean)
The Heap constructor create a heap with a specific size and mode. The first argument is the heap
size. The second argument is the heap mode. If the mode is true, the heap operates in ascending
order. If the mode is false, the heap operates in descending order. In ascending order, the first
object is the object with the lowest key.
Methods
add -> none (Integer Object)
The add method adds a new object in the heap by key. The first argument is the key used to set the
object position in the heap. The second argument is the object to add.
pop -> Object (none)
The pop pops the first available in the heap. If the heap is empty, an exception is raised.
length -> Object (none)
The length returns the number of objects in the heap.
empty-p -> Boolean (none)
The empty-p method returns true if the heap is empty.
reset -> none (none)
The reset method reset the heap so that it becomes empty.
get-key -> Integer (Integer)
The get-key method returns the key associated with an entry in the heap by index. If the index is
out of range, an exception is raised.
get-object -> Object (Integer)
The get-object method returns the object associated with an entry in the heap by index. If the
index is out of range, an exception is raised.
get-mode -> Boolean (none)
The get-mode method returns the heap operating mode. If the mode is true, the heap operates in
ascending order. If the mode is false, the heap operates in descending order. In ascending order,
the first object is the object with the lowest key.
min-key-p -> Boolean (none)
The min-key-p predicate returns true if a minimum key has been set. The get-min-key method can be
used to retrieve the minimum key value.
max-key-p -> Boolean (none)
The max-key-p predicate returns true if a maximum key has been set. The get-max-key method can be
used to retrieve the maximum key value.
reset-min-key -> none (none)
The reset-min-key method resets the minimum key flag and value.
reset-max-key -> none (none)
The reset-max-key method resets the maximum key flag and value.
set-min-key -> none (Integer)
The set-min-key method sets the minimum key value.
get-min-key -> Integer (none)
The get-min-key method returns the minimum key value.
set-max-key -> none (Integer)
The set-max-key method sets the maximum key value.
get-max-key -> Integer (none)
The get-max-key method returns the maximum key value.
resize -> none (none)
The resize method resize the heap with a new size. if the size is lower than the number of
elements, the procedure does nothing.
Bitset
The Bitset builtin object is a container for multi bit storage. The size of the bitset is determined at
construction. With the use of an index, a particular bit can be set, cleared and tested.
Predicate
bitset-p
Inheritance
Object
Constructors
Bitset (none)
The BitSet constructor create an empty bitset.
Bitset (Integer)
The Bitset constructor create a bitset those size is given by the integer argument.
Bitset (String)
The Bitset constructor create a bitset by parsing the string argument. The string can be either in
the normal binary form with or without the 0b prefix or in hexadecimal form with the 0x prefix.
Bitset (Buffer Boolean)
The Bitset constructor create a bitset from a buffer content. Each byte in the buffer is to be
placed in the bitset. The boolean argument is the ascending flag. When true the buffer bytes are
used in ascending index order, thus making the fist byte in the buffer to be used as the first
right byte in the bitset. When false, the buffer bytes are used in descending index order, thus
making the last byte in the buffer to be used as the first byte in the bitset.
Methods
reset -> none (none)
The reset method reset the bitset and force the initial size to 0.
marked-p -> Boolean (Integer)
The marked-p predicate returns true if the bit is set at the index argument.
clear -> none (Integer)
The clear method clears a bit by the index argument.
mark -> none (Integer)
The mark method marks a bit by the index argument.
mark -> none (Integer Boolean)
The mark method set the bit value by the index argument with the boolean second argument.
add -> none (Integer Boolean)
The add method add a bit in the bitset at the given position. The first argument is the bit
position and the second argument is the bit value. The add method is the only method that resize a
bitset.
set -> none (Integer|String)
The set method set a bitset with an integer value. In the first form with an integer argument, the
bitset is completely reset to a 64 bits bitset and the value set as an unsigned integer. In the
second form with a string argument, the bitset is reset and the string argument is parsed as a
binary string with or without binary prefix or as a hexadecimal string.
clamp -> none (Boolean)
The clamp method clamp a bitset by boolean value. The bitset size is determined by finding the
upper bit index that match the boolean argument.
length -> Integer (none)
The length method returns the length of the bitset in bits.
to-byte -> Integer (Byte)
The to-byte method maps a portion of the bitset to a byte at a specific position. The integer
argument is the bit position that is mapped to the byte lsb.
subset -> Integer (Bitset)
The subset method returns a sub bitset by size.
subset -> Integer Integer (Bitset)
The subset method returns a sub bitset by size and position. The first integer argument is the sub
bitset size. The second argument is the bitset position where the sub bitset is extracted.
Buffer
The Buffer builtin object is a byte buffer that is widely used with i/o operations. The buffer can be
constructed with or without literal arguments. The standard methods to add or push-back byte or
characters are available. One attractive method is the write method which can write a complete buffer to
an output stream specified as an argument. By default, the buffer operates in resize mode. If the buffer
is configured to operate in non-resize mode, an exception is raised when trying to add a character when
the buffer is full.
Predicate
buffer-p
Inheritance
Object
Constructors
Buffer (none)
The Buffer constructor create an empty buffer. The buffer is configured to operate in resize mode.
Buffer (Literal...)
The Buffer constructor create a buffer with a list of literal object arguments. Each literal
argument is used to produce a byte representation which is added into the buffer.
Methods
add -> Integer (Byte|Literal|Buffer)
The add method adds a byte, a literal object or a buffer to the calling buffer. The object
argument is automatically converted to a sequence of bytes. For a buffer, the entire content is
copied into the buffer. The method returns the number of bytes added into the buffer.
get -> Byte (none)
The get method returns the next available byte in the buffer but do not remove it.
read -> Byte (none)
The read method returns the next available character and remove it from the buffer.
reset -> none (none)
The reset method reset the entire buffer and destroy its contents.
length -> Integer (none)
The length method returns the length of the buffer.
full-p -> Boolean (none)
The full-p predicate return true if the buffer is full. If the buffer is re-sizeable, the method
always return false.
empty-p -> Boolean (none)
The empty-p predicate return true if the buffer is empty.
resize-p -> Boolean (none)
The resize-p predicate return true if the buffer is re-sizeable.
to-string -> String (none)
The to-string method returns a string representation of the buffer.
format -> String (none)
The format method returns an octet string representation of the buffer.
pushback -> Integer (Byte|Literal|Buffer)
The pushback method push back a byte, a literal object or a buffer in the calling buffer. The
object argument is automatically converted to a sequence of bytes. For a buffer, the entire
content is copied into the buffer. The method returns the number of byte pushbacked.
get-host-word -> Integer (none)
The get-host-word method reads a word from the buffer and convert it to an integer. The word is
assumed to be in network byte order and is converted into the host byte order before becoming an
integer.
get-host-quad -> Integer (none)
The get-host-quad method reads a quad from the buffer and convert it to an integer. The quad is
assumed to be in network byte order and is converted into the host byte order before becoming an
integer.
get-host-octa -> Integer (none)
The get-host-octa method reads an octa from the buffer and convert it to an integer. The octa is
assumed to be in network byte order and is converted into the host byte order before becoming an
integer.
set-resize -> none (Boolean)
The set-resize method set the resize flag for a particular buffer. This method can be used at any
time.
shl -> none (Integer)
The shl method shift left the buffer by a certain number of characters. The integer argument is
the number of characters to shift.
BlockBuffer
The BlockBuffer builtin object is a special buffer class designed to hold bytes in a bound or unbound
way. In the bound mode, the buffer size is know and the buffer cannot be resized. In the unbound mode,
the buffer size is unknown and the buffer can be resized as needed. The block buffer is designed to be
loaded by various means, including data, buffer or stream. Additionaly, the block buffer can be used to
write into another buffer or a stream by block. By default the read and write block size is the system
block size and the default mode is the bound mode, which can be changed by setting the buffer resize
flag.
Predicate
block-buffer-p
Inheritance
Buffer
Constructors
BlockBuffer (none)
The BlockBuffer constructor create a non-resizable empty block buffer.
BlockBuffer (Integer)
The BlockBuffer constructor create a non-resizable block buffer. The integer argument is the block
buffer size.
Methods
read-count -> Integer (none)
The read-count method returns the number of characters read by the buffer. The read counter is
increased during any read operation that might decrease the buffer length.
write-count -> Byte (none)
The write-count method returns the number of characters writen into the buffer.
copy -> Integer (String|Buffer|InputStream|OutputStream)
The copy method copies an object into or from the block buffer. Inthe first form, a string, a
buffer or an input stream is isued to fill the buffer. If the buffer is resizable, the whole
contents of the objects are copied into the block buffer. If the buffer is not resizable, the copy
operation stops when the buffer is full. The copy method consumes characters with a buffer or an
input stream object. With an output stream object, the block buffer characters are consumed while
beeing written to the output stream. The total number of characters copied is returned by this
method. When using a multiple types object that implements both the input and output stream model,
the priority is given to the input stream type.
copy-input-stream -> Integer (InputStream)
The copy-input-stream method copies an input stream into the block buffer. This method is similar
to the copy method except that it operates only with an input stream. Such method is usefull when
using object that implements multiple stream types.
copy-output-stream -> Integer (OutputStream)
The copy-output-stream method copies an output stream into the block buffer. This method is
similar to the copy method except that it operates only with an output stream. Such method is
usefull when using object that implements multiple stream types.
Property
The Property builtin object is container for a name/value pair. Generally, the property object is used
within a property list. An optional information field can be inserted into the property.
Predicate
property-p
Inheritance
Serial
Constructors
Property (none)
The Property constructor create an empty property.
Property (String)
The Property constructor create a property by name. The first argument is the property name.
Property (String Literal)
The Property constructor create a property by name and value. The first argument is the property
name. The second argument is the property value.
Property (String String Literal)
The Property constructor create a property by name, info and value. The first argument is the
property name. The second argument is the property info. The third argument is the property value.
Methods
set -> none (String Literal)
The set method sets the property name and value. The first argument is the property name. The
second argument is the property value, which is a literal converted to its string representation.
set-name -> none (String)
The set-name method sets the property name.
get-name -> String (none)
The get-name method returns the property name.
set-info -> none (String)
The set-info method sets the property information.
get-info -> String (none)
The get-info method returns the property information.
set-value -> none (Literal)
The set-value method sets the property value. The literal argument is converted to its string
representation.
get-value -> String (none)
The get-value method returns the property string value.
get-boolean-value -> Boolean (none)
The get-boolean-value method returns the property boolean value.
get-integer-value -> Integer (none)
The get-integer-value method returns the property integer value.
get-real-value -> Real (none)
The get-real-value method returns the property real value.
Plist
The Plist builtin object is a base container class used to manage property objects in an ordered way. The
property list operates by maintaining a vector of property object along with a hash table that permits to
find the object quickly.
Predicate
plist-p
Inheritance
SerialIterableNameable
Constructors
Plist (none)
The Plist constructor create an empty property list.
Plist (Boolean)
The Plist constructor create a property list with a case flag.
Plist (String)
The Plist constructor create a property list by name.
Plist (String String)
The Plist constructor create a property list by name and info.
Methods
set-name -> none (String)
The set-name method sets the property list name.
set-info -> none (String)
The set-info method sets the property list info.
get-info -> String (none)
The get-info method returns the property list info.
add -> none (Property | String Literal | String String Literal)
The add method add a property by object or name and value in the property list. In its first form
the object is a property object. In the second form, the first argument is the property name and
the second argument is the property value. In the the third form the first argument is the
property name, the second argument is the property info and the this argument is the property
value. if the property already exists an exception is raised.
set -> none (Property | String Literal | String String Literal)
The set method add or sets the property by object or name and value in the property list. In the
first form, the argument is the property itself. In the second form, the first argument is the
property name and the second argument is the property value. In the third form, the property is
set by name, info and value. If the property already exists, the property value is changed.
get -> Property (Integer)
The get method returns a property by index.
reset -> none (none)
The reset method resets the property lists
empty-p -> Boolean (none)
The emptyp- predicate returns true if the property list is empty.
length -> Integer (none)
The length method returns the number of properties in the property list.
exists-p -> Boolean (String)
The exists-p method returns true if a property exists. The string argument is the property name.
find -> Property (String)
The find method finds a property by name. The string argument is the property name. If the
property does not exists, nil is returned.
lookup -> Property (String)
The lookup method finds a property by name. The string argument is the property name. If the
property does not exists, an exception is raised.
get-value -> String (String)
The get-value method returns the property value. The string argument is the property name. If the
property does not exist, an exception is raised.
to-print-table -> PrintTable (none | Boolean | Boolean Boolean)
The to-print-table method converts the property list into a print table. The print table can be
formated with the property info and value. In the first form, the print table is formated without
the info field in normal value. In the second form, the boolean flag controls whther or not the
info field is added in the table. In the third form, the second boolean value controls whther or
not the real property value are converted in scientific notation.
SPECIAL OBJECTS
This chapter is a reference of the reserved special objects with their respective built-in methods.
Special objects are those objects which interact with the interpreter.
Object
The base object Object provides several methods which are common to all objects.
Methods
repr -> String (none)
The repr method returns the object name in the form of a string. The result string is called the
representation string.
rdlock -> none (none)
The rdlock method try to acquire the object in read-lock mode. If the object is currently locked
in write mode by another thread, the calling thread is suspended until the lock is released.
wrlock -> none (none)
The wrlock method try to acquire the object in write-lock mode. If the object is currently locked
by another thread, the calling thread is suspended until the lock is released.
unlock -> none (none)
The unlock method try to unlock an object. An object will be unlocked if and only if the calling
thread is the one who acquired the lock.
clone -> Object (none)
The clone method returns a clone of the calling object. If the object cannot be cloned, an
exception is raised.
Interp
The Interp is the interpreter object which is automatically bounded for each executable program. There is
no constructor for this object. The current interpreter is bounded to the interp reserved symbol.
Predicate
interp-p
Inheritance
Runnable
Constants
argv
The argv data member holds the interpreter argument vector. The vector is initialized when the
interpreter is created. Each argument is stored as a string object.
os-name
The os-name data member holds the operating system name. The data member evaluates as a string.
os-type
The os-type data member holds the operating system type. The data member evaluates as a string.
version
The version data member holds the full engine version. The data member evaluates as a string.
program-name
The program-name data member holds the interpreter program name. The data member evaluates as a
string.
major-version
The major-version data member holds the interpreter major revision number. The data member
evaluates as an integer.
minor-version
The minor-version data member holds the interpreter minor revision number. The data member
evaluates as an integer.
patch-version
The patch-version data member holds the interpreter patch revision number. The data member
evaluates as an integer.
afnix-uri
The afnix-uri data member holds the official uri. The data member evaluates as a string.
machine-size
The machine-size data member holds the interpreter machine size expressed in bits. Most of the
time, the machine size is either 32 or 64 bits. If something else is returned, it certainly
reflects an exotic platform.
loader
The loader data member holds the interpreter library loader. Under normal circumstances, the
library loader should not be used and the standard interp:library form should be used.
resolver
The resolver data member holds the interpreter resolver. The resolver can be used to add
dynamically a librarian or a directory to the interpreter module resolver.
Methods
load -> Boolean (String)
The load method opens a file those name is the method argument and executes each form in the file
by doing a read-eval loop. When all forms have been executed, the file is closed and the method
returns true. In case of exception, the file is closed and the method returns false.
library -> Library (String)
The library method opens a shared library and a returns a shared library object.
launch -> Thread (form|thread form)
The launch method executes the form argument in a normal thread. The normal thread is created by
cloning the current interpreter. In the first form, a thread object is created by the method and
return when the thread as been launched. In the second form, a thread is started by binding a form
to the thread object.
daemon -> Boolean (none)
The dameon method put the running interpreter in dameon mode. A new detached processed is spawned
with the interpreter attached to it. The boolean result indicates whether or not the operation was
successful.
set-epsilon -> none (Real)
The set-epsilon method sets the interpreter epsilon which corresponds to the real precision. The
real precision is used by the ?= operator to compare real values.
get-epsilon -> Real (none)
The get-real precision method returns the interpreter epsilon which correspond to the real
precision. The real-precision is used by the ?= operator to compare real values.
dup -> Interp (none|Terminal)
The dup method returns a clone of the current interpreter by binding the terminal steam argument.
Without argument, a new terminal object is automatically created and bound to the newly created
interpreter.
loop -> Boolean (none)
The loop method executes the interpreter main loop by reading the interpreter input stream. The
loop is finished when the end-of-stream is reached with the input stream. The method returns a
boolean flag to indicate whether or not the loop was successful.
set-primary-prompt -> none (String)
The set-primary-prompt method sets the interpreter terminal primary prompt which is used during
the interpreter main loop.
set-secondary-prompt -> none (String)
The set-secondary-prompt method sets the interpreter terminal secondary prompt which is used
during the interpreter main loop.
get-primary-prompt -> String (none)
The get-primary-prompt method returns the interpreter terminal primary prompt.
get-secondary-prompt -> String (none)
The get-secondary-prompt method returns the interpreter terminal secondary prompt.
read-line -> String (none|Boolean)
The read-line method reads a line from the interpreter terminal. If no terminal is bound to the
interpreter, the empty string is returned. In the first form, a line is read after printing the
primary prompt. In the second form, a boolean flag controls the prompt disply, which can be
primary or secondary.
read-passphrase -> String (none|String)
The read-passphrase method reads a pass-phrase from the interpreter terminal. If no terminal is
bound to the interpreter, the empty string is returned. With a string argument, the string is
displayed as a prompt, before reading the passphrase.
Thread
The Thread object is a special object which acts as a thread descriptor. Such object is created with the
launch reserved keyword.
Predicate
thread-p
Inheritance
Object
Constructors
Thread (none)
The Thread constructor create a default thread object without any form bound to it. The object can
be later used with the launch command.
Methods
end-p -> none (none)
The end-p predicate returns true if the thread argument has finished. This predicate indicates
that the thread result is a valid one.
wait -> none (none)
The wait method suspends the calling thread until the thread argument as completed. The wait
method is the primary mechanism to detect a thread completion.
result -> Object (none)
The result method returns the thread result. If the thread is not completed, the nil value is
returned. However, this method should not be used to check if a thread has completed and the wait
method must be used because a thread result might be nil.
Condvar
The condition variable Condvar object is a special object which provides a mean of synchronization
between one and several threads. The condition is said to be false unless it has been marked. When a
condition is marked, all threads waiting for that condition to become true are notified and one thread is
activated with that condition.
Predicate
condvar-p
Inheritance
Object
Constructors
Condvar (none)
The Condvar constructor creates a default condition variable.
Methods
lock -> none (none)
The lock method locks the condition variable mutex. If the mutex is already locked, the calling
thread is suspended until the lock is released. When the method returns, the resumed thread owns
the condition variable lock. It is the thread responsibility to reset the condition variable and
unlock it.
mark -> none (none)
The mark method marks the condition variable and notify all pending threads of such change. The
mark method is the basic notification mechanism.
wait -> none (none)
The wait method waits for a condition variable to be marked. When such condition occurs, the
suspended thread is run. When the method returns, the resumed thread owns the condition variable
lock. It is the thread responsibility to reset the condition variable and unlock it.
reset -> none (none)
The reset method acquires the condition variable mutex, reset the mark, and unlock it. If the lock
has been taken, the calling thread is suspended.
unlock -> none (none)
The unlock method unlock the condition variable mutex. This method should be used after a call to
lock or wait.
wait-unlock -> none (none)
The wait-unlock method wait until a condition variable is marked. When such condition occurs, the
suspended thread is run. Before the method returns, the condition variable is reset and the mutex
unlocked. With two threads to synchronize, this is the preferred method compared to wait.
Lexical
The Lexical object is a special object built by the reader. A lexical name is also a literal object.
Although the best way to create a lexical name is with a form, the lexical object can also be constructed
with a string name. A lexical name can be mapped to a symbol by using the map method.
Predicate
lexical-p
Inheritance
Literal
Constructors
Lexical (none)
The Lexical constructor create an empty lexical object which evaluates to nil.
Lexical (String)
The Lexical constructor create a lexical object using the string argument as the lexical name.
Methods
map -> Object (none)
The map method returns the object that is mapped by the lexical name. Most of the time, a symbol
object is returned since it is the kind of object stored in a nameset. Eventually the mapping
might returns an argument object if used inside a closure.
Qualified
The Qualified object is a special object built by the reader. A qualified object is similar to a lexical
object. It is also a literal object. Like a lexical name, a qualified name can be created with a form or
by direct construction with a name. Like a lexical name, the map method can be used to retrieve the
symbol associated with that name.
Predicate
qualified-p
Inheritance
Literal
Constructors
Qualified (none)
The Qualifed constructor create an empty qualified name object which evaluates to nil.
Qualified (String)
The Qualified constructor create a qualified name object using the string argument as the
qualified name. The name is parse for qualified name syntax adherence.
Methods
map -> Object (none)
The map method returns the object that is mapped by the qualified name. Most of the time, a symbol
object is returned since it is the kind of object stored in a nameset. Eventually the mapping
might returns an argument object if used inside a closure.
Symbol
The Symbol object is a special object used by nameset to map a name with an object. Generally a symbol is
obtained by mapping a lexical or qualified name. As an object, the symbol holds a name, an object and a
constant flag. The symbol name cannot be changed since it might introduce inconsistencies in the
containing nameset. On the other hand, the constant flag and the object can be changed. A symbol is a
literal object. A symbol that is not bounded to a nameset can be constructed dynamically. Such symbol is
said to be not interned.
Predicate
symbol-p
Inheritance
Literal
Constructors
Symbol (String)
The Symbol constructor create a symbol by name. The associated object is marked as nil.
Symbol (String Object)
The Symbol constructor create a symbol by name and bind the object argument to the symbol.
Methods
get-const -> Boolean (none)
The get-const method returns the symbol const flag. If the flag is true, the symbol object cannot
be changed unless that flags is reset with the set-const method.
set-const -> none (Boolean)
The set-const method set the symbol const flag. This method is useful to mark a symbol as const or
to make a const symbol mutable.
get-object -> Object (none)
The get-object method returns the symbol object.
set-object -> none (Object)
The set-object method set the symbol object. The object can be obtained by evaluating the symbol.
Closure
The Closure object is a special object that represents a lambda or gamma expression. A closure is
represented by a set of arguments, a set of closed variables and a form to execute. A boolean flag
determines the type of closure. The closure predicate lambda-p returns true if the closure is a lambda
expression. Closed variables can be defines and evaluated with the use of the qualified name mechanism.
Closure mutation is achieved with the add-argument and set-form method. An empty closure can be defined
at construction as well.
Predicate
closure-p
Inheritance
Object
Constructors
Closure (none)
The Closure constructor create a default closure. When the closure is created, a local set of
arguments and closed variables is generated. Note that such local set is dynamic. There is no
restriction to reconfigure a particular lambda at run-time. The difference between a lambda and a
gamma expression resides in the nameset binding when the closure is called. With a lambda, the
closure nameset parent is the calling nameset. With a gamma expression, the parent nameset is
always the top-level interpreter nameset. Note also, that the symbol self is automatically bounded
for this closure.
Closure (Boolean)
The Closure constructor create a closure which acts as lambda expression if the boolean argument
is true. If the boolean argument is false, the closure will behave like a gamma expression.
Methods
gamma-p -> Boolean (none)
The gamma-p predicate returns true if the closure is a gamma expression. The predicate returns
true for a lambda expression.
lambda-p -> Boolean (none)
The lambda-p predicate returns true if the closure is a lambda expression. The predicate returns
false for a gamma expression.
get-form -> Object (none)
The get-form method returns the closure form object.
set-form -> none (Object)
The set-form method sets the closure form object.
add-argument -> none (String|Lexical|form)
The add-argument method adds an argument to the closure. The argument object can be either a
string, a lexical object of a simple form that defines a constant lexical name.
Librarian
The Librarian object is a special object that read or write a librarian. Without argument, a librarian is
created for writing purpose. With one file name argument, the librarian is created for reading.
Predicate
librarian-p
Inheritance
Nameable
Constructors
Librarian (none)
The Librarian constructor creates a librarian for writing. Initially, the librarian is empty and
files must be added with the add method.
Librarian (String)
The Librarian constructor creates a librarian for reading using the name as the librarian file
name.
Methods
add -> none (String)
The add method adds a file into the librarian. The librarian must have been opened in write mode.
write -> none (String)
The write method writes a librarian to a file those name is the argument.
length -> Integer (none)
The length method returns the number of file in the librarian. This method work, no matter how the
librarian has been opened.
exists-p -> Boolean (String)
The exists-p predicate returns true if the file argument exists in the librarian.
extract -> InputMapped (String)
The extract method returns an input stream mapped to the file name argument.
Resolver
The Resolver object is a special object that gives the ability to open a file based on a file path
resolver. The resolver maintains a list of valid path and returns an input stream for a file on demand.
Predicate
resolver-p
Inheritance
Object
Constructors
Resolver (none)
The Resolver constructor creates a default resolver. Once created, the add method can be used to
add path to the resolver.
Methods
add -> none (String)
The add method adds a path into the resolver. The path can points either to a directory or a
librarian.
lookup -> InputStream (String)
The lookup method resolves the file name argument and returns an input stream for that file.
to-string -> String (String)
The to-string method resolves the file name argument and returns a string respresentation for that
file.
valid-p -> Boolean (String)
The valid-p predicate returns true if the file name argument can be resolved. If the file name can
be resolved, the lookup method can be called to get an input stream.
PrintTable
The PrintTable class is a formatting class for tables. The table is constructed with the number of
columns -- default to 1 -- and eventually the number of rows. Once the table is created, element are
added to the table with the add method. Specific table element can be set with the set method. The class
provide a format method those default is to print the table on the interpreter standard output. With an
output stream argument or a buffer, the table is formatted to these objects. The table formatting
includes an optional column width, a filling character and a filling direction flag. By default, the
column width is 0. This means that the column width is computed as the maximum length of all column
elements. If the column width is set with the set-column-size method, the string element might be
truncated to the left or right -- depending on the filling flag -- to fit the column width. Each table
element can also be associated with a tag. The tag-p method can be used to test for the presence of a
tag, while the set-tag and get-tag methods can be used to set or get the tag by row and column
coordinates.
Predicate
print-table-p
Inheritance
Object
Constructors
PrintTable (none)
The PrintTable constructor creates a default table with one column.
PrintTable (Integer)
The PrintTable constructor creates a table with a pre-defined number of columns specified in the
constructor argument.
PrintTable (Integer Integer)
The PrintTable constructor creates a table with a pre-defined number of columns and rows specified
in the constructor arguments.
Methods
head-p -> Boolean (none)
The head-p predicate returns true if the table header is defined.
add-head -> none ([String+])
The add-head method add to the table header the string arguments. The number of arguments must be
equal to the number of columns.
get-head -> String (Integer)
The get-head method returns a table header element by column index. The integer argument is the
header row index.
set-head -> none (Integer String)
The set-head method sets a table header element by column index. The first argument is the header
column index and the second is the header string value to set.
add -> Integer (none|[Literal...])
The add method serves several purposes. Without argument, a new row is added and the row index is
returned. The row index can be later used with the set method to set a particular table element.
With one or several literal arguments, those length must match the number of columns, a new row is
created and those arguments added to the table. The row number is also returned.
get -> String (Integer Integer)
The get method returns a particular table element by row and column. The first argument is the
table row index and the second is the table column index.
set -> none (Integer Integer Literal)
The set method sets a particular table element by row and column. The first argument is the table
row index and the second is the table column index. The last argument is a literal object that is
converted to a string prior its insertion.
tag-p -> Boolean (Integer Integer)
The tag-p predicate returns true if a tag is present at a particular table element. The first
argument is the table row index and the second is the table column index.
set-tag -> none (Integer Integer String)
The set-tag method sets a particular table tag by row and column. The first argument is the table
row index and the second is the table column index. The last argument is the tag value.
get-tag -> String (Integer Integer)
The get-tag method returns a particular table tag by row and column. The first argument is the
table row index and the second is the table column index.
dump -> none|String (none|Integer|OutputStream|Buffer)
The dump method dumps the table to an output stream or a buffer. Without argument, the default
interpreter output stream is used. With an integer argument, the specified row is used and a
string is returned. With a buffer or an output stream, the whole table is written and nothing is
returned.
format -> none|String (none|Integer|OutputStream|Buffer)
The format method writes the formatted table to an output stream or a buffer. Without argument,
the default interpreter output stream is used. With an integer argument, the specified row is used
and a string is returned. With a buffer or an output stream, the whole table is written and
nothing is returned.
get-rows -> Integer (none)
The get-rows method returns the number of rows in the table.
add-columns -> Integer (none)
The add-columns method adds 1 or more columns at the end of the table.
get-columns -> Integer (none)
The get-columns method returns the number of columns in the table.
set-column-size -> none (Integer Integer)
The set-column-size method sets the desired width for a particular column. The first argument is
the column index and the second argument is the column width.If 0 is given, the column width is
computed as the maximum of the column elements.
get-column-size -> Integer (Integer)
The get-column-size method returns the desired width for a particular column.
set-column-fill -> none (Integer Character)
The set-column-fill method sets the filling character for a particular column. The first argument
is the column index and the second argument is a character to use when filling a particular column
element. The default filling character is the blank character.
get-column-fill -> Character (Integer)
The get-column-fill method returns the filling character for a particular column.
set-column-direction -> none (Integer Boolean)
The set-column-direction method sets the direction flag for a particular column. The first
argument is the column index and the second argument is a boolean. A false value indicates a
filling by the left while a true value indicates a filling by the right. The column filling
character is used for this operation.
get-column-direction -> Boolean (Integer)
The get-column-direction method returns the direction flag for a particular column.
Logger
The Looger class is a message logger that stores messages in a buffer with a level. The default level is
the level 0. A negative level generally indicates a warning or an error message but this is just a
convention which is not enforced by the class. A high level generally indicates a less important message.
The messages are stored in a circular buffer. When the logger is full, a new message replace the oldest
one. By default, the logger is initialized with a 256 messages capacity that can be resized.
Predicate
logger-p
Inheritance
Object
Constructors
Logger (none)
The Logger constructor creates a default logger.
Logger (Integer)
The Logger constructor creates a logger with a specific size specified as the constructor
argument.
Logger (String)
The Logger constructor creates a logger with an information argument. The information string is
later used to format the logged messages.
Logger (Integer String)
The Logger constructor creates a logger with a specific size and an information argument. The
first argument is the logger size. The second argument is the information string. The information
string is later used to format the logged messages.
Methods
add -> none (String|String Integer)
The add method adds a message in the logger. With one argument, the method take a single string
message. with two arguments, the first arguments is the message and the second argument is the
message level.
reset -> none (none)
The reset method reset the logger class by removing all messages.
length -> Integer (none)
The length method returns the number of messages stored in the logger object.
resize -> none (Integer)
The resize method resize the logger class by increasing the size of the message buffer. The old
messages are kept during the resizing operation.
set-info -> none (String)
The set-info method sets the logger information string. The information string is used by the
derived classes when a message is printed.
get-info -> String (none)
The get-info method returns the logger information string. The information string is used by the
derived classes when a message is printed.
set-default-level -> none (Integer)
The set-default-level method sets the default level use for storing message. This parameter is
used with the add method in conjunction with the message argument. When the message level is
specified, the default message level is ignored.
get-default-level -> Integer (none)
The get-default-level method returns the default message level used by the logger. The default
message level is used by the add method when the message level is not specified directly.
get-message -> String (Integer)
The get-message method returns a logger message by index. The integer argument is the message
index.
get-full-message -> String (Integer)
The get-full-message method returns a fully formatted logger message by index. The integer
argument is the message index. The message includes the time and contents.
get-message-time -> Integer (Integer)
The get-message-time method returns the logger message time by index. The integer argument is the
message index.
get-message-level -> Integer (Integer)
The get-message-level method returns the logger message level by index. The integer argument is
the message index.
set-output-stream -> none (OutputStream|String)
The set-output-stream method set the logger output stream. The output stream can be either an
output stream or an output file name.
Counter
The Counter class is a mechanism designed to count integer both upward or downward. The counter is
initialized with a start and end value. With a single value, the start value is set to 0 and the counter
direction determined by the end value. The counter object is also a literal object, meaning that it can
be directly printed. The object is also designed to be used directly in a loop.
Predicate
counter-p
Inheritance
Literal
Constructors
Counter (none)
The Counter constructor creates a default counter. Since, both start and end values are
initialized to 0, this object will never count.
Counter (Integer)
The Counter constructor creates an upward counter. If the argument value, the initial counter
value is the argument value and the counter will counter from the value to 0. If the argument
value is positive, the final counter value is the argument value and the counter will count from 0
to this value.
Counter (Integer Integer)
The Counter constructor creates a counter with an initial and final values. Depending on the
initial and final value the counter might be an upward or a downward counter.
Methods
reset -> none (none)
The reset method reset the counter to its start value.
step-p -> Boolean (none)
The step-p predicate checks if the counter can be moved by one position. If the test is
successful, the counter is moved upward or downward. the method returns the result of the test.
valid-p -> Boolean (none)
The valid-p predicate returns true if the counter can be moved by one position.
Lexer
The Lexer class is the lexical analyzer for the writing system. The lexical analyzer consumes characters
from an input stream and produces tokens. From a token, it is possible to derive an object in the form of
a constant object which can be evaluated to a literal or to another object in the presence of a lexical
or qualified object. The lexical analyzer is integrated inside the form reader. As an object it is
possible to use it when it becomes necesary to parse strings.
Predicate
lexer-p
Inheritance
Object
Methods
get-token -> Token (none)
The get-token method returns the next available token.
get-object -> Object (none)
The get-object method returns the next available object.
get-line-number -> Integer (none)
The get-line-number method returns the token line number which is the current line number under
processing.
Former
The Former class is an abstract class used to derive form reader. The class defines only a method parse
which returns a form. The method getlnum returns the form line number.
Predicate
former-p
Inheritance
Object
Methods
parse -> Form (none)
The parse method returns the next available form.
get-line-number -> Integer (none)
The get-line-number method returns the form line number which is the current line number under
processing.
Reader
The Reader class is the general purpose form reader which supports the writing system syntax. The reader
is primarily used to parse file or be run interactively. The reader consumes tokens until a complete form
can be built. The form does not have any particular meaning and must be post processed by the
application.
Predicate
reader-p
Inheritance
FormerNameable
Constructors
Reader (none)
The Reader constructor creates a default reader.
Reader (String|InputStream)
The Reader constructor creates a reader by string or input stream. In the first form, a string is
mapped into a string stream which is used by the reader to parse form. In the second form, an
input stream is bound to the reader to parse forms.
Loader
The Loader class is a library loader. The loader keep a list of loaded libraries. This class is bound to
the interpreter and cannot be constructed. Use the interp:loader to access the interpreter loader. for
safety reason, it is not possible to add a libray to the loader. The interpreter method interp:library is
the prefered method to access the loader.
Predicate
loader-p
Inheritance
Object
Methods
length -> Integer (none)
The length method returns the number of loaded libraries.
get -> Library (Integer)
The get method returns a library object by index.
exists-p -> Boolean (String)
The exists-p predicate returns true if a library is already loaded in the interpreter.