« Back to the index

SLI Coding Guidelines


  1. Names of SLI operators shall conform to the following rules.

     functionname     - standard name for PS conforming operator
     FunctionName     - names of Mathematica-like operator, or
                        (other-language)-like operator
     :functionname    - name of an undocumented, internal operator which 
                        may disappear from the language anytime. Should
                        only be used in libraries, but not in user
     ::functionname   - name of undocumented, internal operator, which 
                        operates on the execution stack.
  2. Names may have type-specifier (TS) appended

     functionnameTS  The type-specifier is interpreted from left to right. It indicates which parameters are expected on the operand stack. The rightmost type is expected topmost on the stack.
  3. A type-specifier is defined as follows

     non-terminals := {TS, TA}
     terminals     := {tn, _, epsilon}
     TA            :=    tn   |  TA a
     TS            := _ TA TS | epsilon  `tn` may be expanded to one of the following:
     integer     i
     double      d
     number      num  /* integer or double */
     bool        b
     name        n
     literal     l
     procedure   p
     lprocedure  lp
     array       a
     dictionary  di
     string      s
     trie        t
     istream     is
     xistream    xs
     ostream     os
     regex       r
     any         ""  /* the empty string */  Homogeneous arrays are indicated by appending `a` to the above mentioned type specifiers. This may even by used in a recursive fashion, to indicate nested homogeneous arrays. For example, the following homogeneous SLI arrays have those type specifiers:
     array of integers            ia
     array of doubles             da
     array of numbers             numa
     array of dictionaries        dia
     array of arrays of istreams  isaa


pop_    - takes one argument of arbitrary type         
exch__  - takes two arguments of arbitrary type
foo_i_  - takes one integer and one anytype.
foo__i  - takes one anytype and one integer.
foo_d_i - takes one double and one integer.
foo_di  - takes one dictionary
  1. A name with type-specifier is not required to perform typechecking.
  2. Names with type-specifier are called variants.
  3. The object which combines all variants is called root. (The name root is motivated by the fact that this is the part of the operator name which is common to all variants).
  4. The root variant is required to perform type-checking.
  5. The general properties of the operator shall be documented with the root.
  6. All information which is specific to a variant, shall be documented with the variant.
  7. From the documentation of a variant there shall be a reference to its root.
  8. In the documentation of the root, a reference to the variants is not mandatory, but recommended.