Provided by: afnix_2.1.1-3_amd64 bug

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.

              log -> Real (none)
              The log 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.

       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.

       Predicate

              hashtable-p

       Inheritance

              Object

       Constructors

              HashTable (none)
              The HashTable constructor create an empty table.

              HashTable (Integer)
              The HashTable constructor create a table with a specific size.

       Methods

              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.

              reset -> none (none)
              The reset method resets the table so that it becomes empty.

              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 (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 (String Literal)
              The  set  method  add or sets the property name and value in the property list. The
              first argument is the property name. The second argument is the property 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.

              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 -> String (none)
              The get-secondary-prompt method returns the interpreter terminal secondary prompt.

       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.

              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.

              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.

       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.