Documentation of LispMe for PalmOS, from Fred Bayer Informatics (fred@lispme.de).
Converted to Doc format by lehalle@earthling.net using MakeDoc7 (from patb@corel.ca)
--> #f <----------------
Category: Constant
Format: #f
Description: #f is the only boolean value false
R4RS Compliance: Full
--> #n <----------------
Category: Constant
Format: #n
Description: #n
R4RS Compliance: LispMe extension
--> #t <----------------
Category: Constant
Format: #t
Description: #t is the canonical boolean value true
R4RS Compliance: Full
--> () <----------------
Category: Constant
Format: '()
Description: '() or (quote ())
R4RS Compliance: Full
--> * <----------------
Category: Primitive procedure
Format: (* numi ...)
Description: *
R4RS Compliance: Full
--> *gstate* <----------------
Category: Variable
Format: *gstate*
Description: *gstate*
R4RS Compliance: LispMe extension
--> + <----------------
Category: Primitive procedure
Format: (+ numi ...)
Description: +
R4RS Compliance: Full
--> - <----------------
Category: Primitive procedure
Format: (- num1 [num2])
Description: When given one number, -
R4RS Compliance: Full
--> / <----------------
Category: Primitive procedure
Format: (/ num1 [num2])
Description: When given one number, /
R4RS Compliance: Full
--> < <----------------
Category: Primitive procedures
Format: (< comp1 comp2)
Description: their relation, either #t or #f
R4RS Compliance: chars and strings, too, and thus subsume the R4
--> = <----------------
Category: Library procedure
Format: (= num1 num2)
Description: = returns #t
R4RS Compliance: Full
--> abs <----------------
Category: Library procedure
Format: (abs num)
Description: abs computes the absolute value of num
R4RS Compliance: Full
--> acos <----------------
Category: Primitive procedure (MathLib required)
Format: (acos z)
Description: acos computes the arc cosine of z
R4RS Compliance: Full
--> acosh <----------------
Category: Primitive procedure (MathLib required)
Format: (acosh z)
Description: acosh
R4RS Compliance: LispMe extension
--> and <----------------
Category: Special form
Format: (and expr1 ...)
Description: and evaluates the expri
R4RS Compliance: Full
--> angle <----------------
Category: Primitive procedure (MathLib required)
Format: (angle z)
Description: angle
R4RS Compliance: Full
--> append <----------------
Category: Primitive procedure
Format: (append listi ...)
Description: append
R4RS Compliance: Full
--> apply <----------------
Category: Primitive procedure
Format: (apply procedure arglist)
Description: apply calls procedure
R4RS Compliance: Full
--> asin <----------------
Category: Primitive procedure (MathLib required)
Format: (asin z)
Description: asin computes the arc sine of z
R4RS Compliance: Full
--> asinh <----------------
Category: Primitive procedure (MathLib required)
Format: (asinh z)
Description: asinh
R4RS Compliance: LispMe extension
--> assoc, <----------------
Category: Library procedures
Format: (assoc obj alist)
Description: alist
R4RS Compliance: Full
--> atan <----------------
Category: Primitive procedure (MathLib required)
Format: (atan z)
Description: atan
R4RS Compliance: Full
--> atanh <----------------
Category: Primitive procedure (MathLib required)
Format: (atanh z)
Description: atanh
R4RS Compliance: LispMe extension
--> begin <----------------
Category: Special form
Format: (begin expr1 expr2 ...)
Description: begin evaluates each expri
R4RS Compliance: Full
--> bit-and <----------------
Category: Primitive procedure
Format: (bit-and ni ...)
Description: bit-and
R4RS Compliance: LispMe extension
--> bit-not <----------------
Category: Primitive procedure
Format: (bit-not n)
Description: bit-not
R4RS Compliance: LispMe extension
--> bit-or <----------------
Category: Primitive procedure
Format: (bit-or ni ...)
Description: bit-or
R4RS Compliance: LispMe extension
--> bit-shift <----------------
Category: Primitive procedure
Format: (bit-shift n k)
Description: bit-shift shifts n
R4RS Compliance: LispMe extension
--> bit-xor <----------------
Category: Primitive procedure
Format: (bit-xor ni ...)
Description: bit-xor
R4RS Compliance: LispMe extension
--> bitmap <----------------
Category: Primitive procedure
Format: (bitmap bmap)
Description: bitmap
R4RS Compliance: LispMe extension
--> boolean? <----------------
Category: Primitive procedure
Format: (boolean? obj)
Description: boolean? returns #t
R4RS Compliance: Full
--> c...r <----------------
Category: Primitive procedures
Format: (c...r pair)
Description: c...r applies a sequence of car
R4RS Compliance: Supports upto 13 nested applications instead of 4
--> call/cc <----------------
Category: Primitive procedure
Format: (call/cc procedure)
Description: call/cc calls procedure
R4RS Compliance: The verbose name call-with-current-continuation
--> car <----------------
Category: Primitive procedure
Format: (car pair)
Description: car returns the car component of pair
R4RS Compliance: Full
--> case <----------------
Category: Special form
Format: (case expr (guard expr1 expr2 ...) ...)
Description: case first evaluates expr
R4RS Compliance: Full
--> cdr <----------------
Category: Primitive procedure
Format: (cdr pair)
Description: cdr returns the cdr component of pair
R4RS Compliance: Full
--> ceiling <----------------
Category: Primitive procedure (MathLib required)
Format: (ceiling num)
Description: ceiling converts num
R4RS Compliance: Full
--> char2integer <----------------
Category: Primitive procedure
Format: (char->integer char)
Description: char->integer
R4RS Compliance: Full
--> char? <----------------
Category: Primitive procedure
Format: (char? obj)
Description: char? returns #t
R4RS Compliance: Full
--> complex? <----------------
Category: Primitive procedure
Format: (complex? obj)
Description: complex? returns #t
R4RS Compliance: Full
--> cond <----------------
Category: Special form
Format: (cond (guard expr1 expr2 ...) ...)
Description: cond evaluates each guard
R4RS Compliance: Expression sequence in each clause must not be empty
--> cons <----------------
Category: Primitive procedure
Format: (cons obj1 obj2)
Description: cons
R4RS Compliance: Full
--> continuation? <----------------
Category: Primitive procedure
Format: (continuation? obj)
Description: continuation? returns #t
R4RS Compliance: Full
--> cos <----------------
Category: Primitive procedure (MathLib required)
Format: (cos z)
Description: cos computes the cosine of the number z
R4RS Compliance: Full
--> cosh <----------------
Category: Primitive procedure (MathLib required)
Format: (cosh z)
Description: cosh
R4RS Compliance: LispMe extension
--> ctl-enter <----------------
Category: UI event
Format: (ctl-enter id)
Description: ctl-enter
--> ctl-get-val <----------------
Category: Primitive procedure
Format: (ctl-get-val id)
Description: ctl-get-val
R4RS Compliance: LispMe extension
--> ctl-repeat <----------------
Category: UI event
Format: (ctl-repeat id)
Description: ctl-repeat
--> ctl-select <----------------
Category: UI event
Format: (ctl-select id state)
Description: ctl-selected
--> ctl-set-val <----------------
Category: Primitive procedure
Format: (ctl-set-val id obj)
Description: ctl-set-val
R4RS Compliance: LispMe extension
--> date-time <----------------
Category: Primitive procedure
Format: (date-time)
Description: date-time
R4RS Compliance: LispMe extension
--> define <----------------
Category: Special form
Format: (define var expr)
Description: define
R4RS Compliance: See here
--> delay <----------------
Category: Special form
Format: (delay expr)
Description: delay packages expr
R4RS Compliance: Full
--> delete-file <----------------
Category: Primitive procedure
Format: (delete-file string)
Description: delete-file
R4RS Compliance: LispMe extension
--> delete-record <----------------
Category: Library procedure
Format: (delete-record dbname recnum)
Description: delete-record
R4RS Compliance: LispMe extension.
--> dir <----------------
Category: Primitive procedure
Format: (dir [category])
Description: dir
R4RS Compliance: LispMe extension
--> disasm <----------------
Category: Primitive procedure
Format: (disasm closure)
Description: disasm
R4RS Compliance: LispMe extension
--> display <----------------
Category: Primitive procedure
Format: (display obj [outport])
Description: display
R4RS Compliance: Full
--> do <----------------
Category: Special form (library)
Format: (do ((var init step) ...) (test expr
Description: do
R4RS Compliance: Full
--> draw <----------------
Category: Primitive procedure
Format: (draw x y)
Description: draw
R4RS Compliance: LispMe extension
--> eof-object? <----------------
Category: Primitive procedure
Format: (eof-object? obj)
Description: eof-object? returns #t
R4RS Compliance: Full
--> eq? <----------------
Category: Primitive procedure
Format: (eq? obj1 obj2)
Description: eq? returns #t
R4RS Compliance: Full
--> equal? <----------------
Category: Library procedure
Format: (equal? obj1 obj2)
Description: equal? returns #t
R4RS Compliance: Full
--> eqv? <----------------
Category: Primitive procedure
Format: (eqv? obj1 obj2)
Description: eq? returns #t
R4RS Compliance: Full
--> error <----------------
Category: Primitive procedure
Format: (error obj)
Description: error
R4RS Compliance: LispMe extension
--> eval <----------------
Category: Primitive procedure
Format: (eval expression)
Description: eval evaluates expression
R4RS Compliance: R5RS is not supported.
--> even? <----------------
Category: Library procedure
Format: (even? int)
Description: even? returns #t, if int
R4RS Compliance: Full
--> event <----------------
Category: Primitive procedure
Format: (event wait)
Description: event
R4RS Compliance: LispMe extension
--> exact? <----------------
Category: Library procedure
Format: (exact? num)
Description: exact? always returns #f
R4RS Compliance: Exactness property not supported
--> exp <----------------
Category: Primitive procedure (MathLib required)
Format: (exp z)
Description: exp returns the natural antilogarithm ex
R4RS Compliance: Full
--> expt <----------------
Category: Library procedure (MathLib required)
Format: (expt z1 z2)
Description: expt
R4RS Compliance: Full
--> fld-changed <----------------
Category: UI event
Format: (fld-changed id)
Description: fld-changed
--> fld-copy <----------------
Category: Primitive procedure
Format: (fld-copy id)
Description: fld-copy
R4RS Compliance: LispMe extension
--> fld-cut <----------------
Category: Primitive procedure
Format: (fld-cut id)
Description: fld-cut
R4RS Compliance: LispMe extension
--> fld-enter <----------------
Category: UI event
Format: (fld-enter id)
Description: fld-enter
--> fld-get-scroll <----------------
Category: Primitive procedure
Format: (fld-get-scroll id)
Description: fld-get-scroll
R4RS Compliance: LispMe extension
--> fld-get-text <----------------
Category: Primitive procedure
Format: (fld-get-text id)
Description: fld-get-text
R4RS Compliance: LispMe extension
--> fld-paste <----------------
Category: Primitive procedure
Format: (fld-paste id)
Description: fld-paste
R4RS Compliance: LispMe extension
--> fld-scroll <----------------
Category: Primitive procedure
Format: (fld-scroll id n)
Description: fld-scroll
R4RS Compliance: LispMe extension
--> fld-set-text <----------------
Category: Primitive procedure
Format: (fld-set-text id obj)
Description: fld-set-text prints obj
R4RS Compliance: LispMe extension
--> fld-undo <----------------
Category: Primitive procedure
Format: (fld-undo id)
Description: fld-undo
R4RS Compliance: LispMe extension
--> floor <----------------
Category: Primitive procedure (MathLib required)
Format: (floor num)
Description: floor converts num
R4RS Compliance: Full
--> for-each <----------------
Category: Library procedure
Format: (for-each proc list)
Description: for-each applies proc
R4RS Compliance: Supports only one list
--> force <----------------
Category: Primitive procedure
Format: (force prom)
Description: force
R4RS Compliance: Full
--> frm-close <----------------
Category: UI event
Format: (frm-close id)
Description: frm-close
--> frm-get-focus <----------------
Category: Primitive procedure
Format: (frm-get-focus)
Description: frm-get-focus
R4RS Compliance: LispMe extension
--> frm-goto <----------------
Category: Primitive procedure
Format: (frm-goto id handler)
Description: frm-goto
R4RS Compliance: LispMe extension
--> frm-open <----------------
Category: UI event
Format: (frm-open id)
Description: frm-open
--> frm-popup <----------------
Category: Primitive procedure
Format: (frm-show id handler)
Description: frm-popup
R4RS Compliance: LispMe extension
--> frm-return <----------------
Category: Primitive procedure
Format: (frm-return obj)
Description: frm-return
R4RS Compliance: LispMe extension
--> frm-set-focus <----------------
Category: Primitive procedure
Format: (frm-set-focus id)
Description: frm-set-focus
R4RS Compliance: LispMe extension
--> frm-show <----------------
Category: Primitive procedure
Format: (frm-show id obj)
Description: frm-show
R4RS Compliance: LispMe extension
--> gc <----------------
Category: Primitive procedure
Format: (gc)
Description: gc
R4RS Compliance: LispMe extension
--> gensym <----------------
Category: Primitive procedure
Format: (gensym)
Description: gensym
R4RS Compliance: LispMe extension
--> hb-addrecord <----------------
Category: Primitive procedure
Format: (hb-addrecord dbname)
Description: hb-addrecord
R4RS Compliance: LispMe extension
--> hb-dir <----------------
Category: Primitive procedure
Format: (hb-dir)
Description: hb-dir
R4RS Compliance: LispMe extension
--> hb-info <----------------
Category: Primitive procedure
Format: (hb-info dbname)
Description: hb-info
R4RS Compliance: LispMe extension
--> hb-getfield <----------------
Category: Primitive procedure
Format: (hb-getfield dbname recnum fldnum)
Description: hb-getfield
R4RS Compliance: LispMe extension
--> hb-getlinks <----------------
Category: Primitive procedure
Format: (hb-getlinks dbname recnum fldnum)
Description: hb-getlinks
R4RS Compliance: LispMe extension
--> hb-setfield <----------------
Category: Primitive procedure
Format: (hb-setfield dbname recnum fldnum obj)
Description: obj
R4RS Compliance: LispMe extension
--> if <----------------
Category: Special form
Format: (if test consequent [alternative])
Description: if evaluates test
R4RS Compliance: Full
--> imag-part <----------------
Category: Primitive procedure
Format: (imag-part z)
Description: imag-part
R4RS Compliance: Full
--> index->rgb <----------------
Category: Primitive procedure)
Format: (index->rgb col)
Description: index->rgb
R4RS Compliance: LispMe extension
--> inexact? <----------------
Category: Library procedure
Format: (inexact? num)
Description: inexact? always returns #t
R4RS Compliance: Exactness property not supported
--> input <----------------
Category: Library procedure
Format: (input prompt)
Description: input
R4RS Compliance: read
--> input-port? <----------------
Category: Primitive procedure
Format: (input-port? obj)
Description: input-port? returns #t
R4RS Compliance: Full
--> input-string <----------------
Category: Library procedure
Format: (input-string prompt)
Description: input-string
R4RS Compliance: read-string
--> integer <----------------
Category: Primitive procedure
Format: (integer num)
Description: integer
R4RS Compliance: LispMe extension
--> integer2char <----------------
Category: Primitive procedure
Format: (integer->char int)
Description: integer->char
R4RS Compliance: Full
--> integer? <----------------
Category: Primitive procedure
Format: (integer? obj)
Description: integer? returns #t
R4RS Compliance: Full
--> it <----------------
Category: Variable
Format: it
Description: it
R4RS Compliance: LispMe extension
--> key-down <----------------
Category: UI event
Format: (key-down char)
Description: key-down
--> lambda <----------------
Category: Special form
Format: (lambda formals expr1 expr2 ...)
Description: lambda
R4RS Compliance: Full
--> launch <----------------
Category: Primitive procedure
Format: (launch [creator])
Description: launch
R4RS Compliance: LispMe extension.
--> length <----------------
Category: Library procedure
Format: (length list)
Description: length
R4RS Compliance: Full
--> let <----------------
Category: Special form
Format: (let ((var form) ...) expr1 expr2 ...)
Description: let
R4RS Compliance: Full
--> let* <----------------
Category: Special form (library)
Format: (let* ((var form) ...) expr1
Description: let*
R4RS Compliance: Full
--> letrec <----------------
Category: Special form
Format: (letrec ((var form) ...) expr1 expr2 ...)
Description: letrec
R4RS Compliance: Full
--> list <----------------
Category: Primitive procedure
Format: (list obj1 ...)
Description: list
R4RS Compliance: Full
--> list2string <----------------
Category: Primitive procedure
Format: (list->string charlist)
Description: list->string
R4RS Compliance: Full
--> list2vector <----------------
Category: Primitive procedure
Format: (list->vector list)
Description: list->vector
R4RS Compliance: Full
--> list-ref <----------------
Category: Library procedure
Format: (list-ref list index)
Description: list-ref returns the index
R4RS Compliance: Full
--> log <----------------
Category: Primitive procedure (MathLib required)
Format: (log z)
Description: log
R4RS Compliance: Full
--> log10 <----------------
Category: Library procedure (MathLib required)
Format: (log10 z)
Description: log10
R4RS Compliance: LispMe extension
--> lst-enter <----------------
Category: UI event
Format: (lst-enter id sel)
Description: lst-enter
--> lst-get-sel <----------------
Category: Primitive procedure
Format: (lst-get-sel id)
Description: lst-get-sel
R4RS Compliance: LispMe extension
--> lst-get-text <----------------
Category: Primitive procedure
Format: (lst-get-text id item)
Description: lst-get-text
R4RS Compliance: LispMe extension
--> lst-select <----------------
Category: UI event
Format: (lst-select id sel)
Description: lst-select
--> lst-set-list <----------------
Category: Primitive procedure
Format: (lst-set-list id list)
Description: lst-set-list prints each item in list
R4RS Compliance: LispMe extension
--> lst-set-sel <----------------
Category: Primitive procedure
Format: (lst-set-sel id sel)
Description: lst-set-sel
R4RS Compliance: LispMe extension
--> macro <----------------
Category: Special form
Format: (macro (var arg) expr1 expr2 ...)
Description: macro
R4RS Compliance: LispMe extension, but according to several other macro systems
--> macro? <----------------
Category: Primitive procedure
Format: (macro? obj)
Description: macro? returns #t
R4RS Compliance: Full
--> magnitude <----------------
Category: Primitive procedure (MathLib required)
Format: (magnitude z)
Description: magnitude
R4RS Compliance: Full
--> make-polar <----------------
Category: Primitive procedure (MathLib required)
Format: (make-polar mag ang)
Description: make-polar
R4RS Compliance: Full
--> make-rectangular <----------------
Category: Primitive procedure (MathLib required)
Format: (make-rectangular re im)
Description: make-rectangular
R4RS Compliance: Full
--> make-string <----------------
Category: Primitive procedure
Format: (make-string len char)
Description: make-string
R4RS Compliance: Fill char is required
--> make-vector <----------------
Category: Primitive procedure
Format: (make-vector len fill)
Description: make-vector
R4RS Compliance: Fill value is required
--> map <----------------
Category: Library procedure
Format: (map proc list)
Description: map
R4RS Compliance: Supports only one list
--> max <----------------
Category: Library procedure
Format: (max comp1 comp2 ...)
Description: max
R4RS Compliance: characters, too.
--> member, <----------------
Category: Library procedures
Format: (member obj list)
Description: list
R4RS Compliance: Full
--> menu <----------------
Category: UI event
Format: (menu id)
Description: menu
--> message <----------------
Category: Primitive procedure
Format: (message obj)
Description: message
R4RS Compliance: LispMe extension
--> min <----------------
Category: Library procedure
Format: (min comp1 comp2 ...)
Description: min
R4RS Compliance: characters, too.
--> modulo <----------------
Category: Library procedure
Format: (modulo int1 int2)
Description: modulo
R4RS Compliance: Full
--> negative? <----------------
Category: Library procedure
Format: (negative? num)
Description: negative? returns #t, if num
R4RS Compliance: Full
--> newline <----------------
Category: Library procedure
Format: (newline [outport])
Description: newline
R4RS Compliance: Full
--> none? <----------------
Category: Primitive procedure
Format: (none? obj)
Description: none? returns #t
R4RS Compliance: LispMe extension
--> not <----------------
Category: Primitive procedure
Format: (not obj)
Description: not returns #t if obj
R4RS Compliance: Full
--> null? <----------------
Category: Primitive procedure
Format: (null? obj)
Description: null? returns #t
R4RS Compliance: Full
--> number? <----------------
Category: Primitive procedure
Format: (number? obj)
Description: number? returns #t
R4RS Compliance: Full
--> object2string <----------------
Category: Primitive procedure
Format: (object->string obj)
Description: object->string
R4RS Compliance: LispMe extension. object->string
--> odd? <----------------
Category: Library procedure
Format: (odd? int)
Description: odd? returns #t, if int
R4RS Compliance: Full
--> open-append-file <----------------
Category: Primitive procedure
Format: (open-append-file string)
Description: open-append-file
R4RS Compliance: LispMe extension
--> open-input-file <----------------
Category: Primitive procedure
Format: (open-input-file string)
Description: open-input-file
R4RS Compliance: Full
--> open-output-file <----------------
Category: Primitive procedure
Format: (open-output-file string)
Description: open-output-file
R4RS Compliance: Full
--> or <----------------
Category: Special form
Format: (or expr1 ...)
Description: or evaluates the expri
R4RS Compliance: Full
--> output-port? <----------------
Category: Primitive procedure
Format: (output-port? obj)
Description: output-port? returns #t
R4RS Compliance: Full
--> own-gui <----------------
Category: Primitive procedure
Format: (own-gui switch)
Description: When switch is true
R4RS Compliance: LispMe extension
--> pair? <----------------
Category: Primitive procedure
Format: (pair? obj)
Description: pair? returns #t
R4RS Compliance: Full
--> peek-char <----------------
Category: Primitive procedure
Format: (peek-char inport)
Description: peek-char
R4RS Compliance: The port parameter is not optional.
--> pen-down <----------------
Category: UI event
Format: (pen-down x y)
Description: pen-down
--> pen-move <----------------
Category: UI event
Format: (pen-move x y)
Description: pen-move
--> pen-up <----------------
Category: UI event
Format: (pen-up x y)
Description: pen-up
--> pop-select <----------------
Category: UI event
Format: (pop-select pid lid newsel oldsel)
Description: pop-select
--> port? <----------------
Category: Library procedure
Format: (port? obj)
Description: port? returns #t
R4RS Compliance: Full
--> positive? <----------------
Category: Library procedure
Format: (positive? num)
Description: positive? returns #t, if num
R4RS Compliance: Full
--> procedure? <----------------
Category: Primitive procedure
Format: (procedure? obj)
Description: procedure? returns #t
R4RS Compliance: Full
--> promise? <----------------
Category: Primitive procedure
Format: (promise? obj)
Description: promise? returns #t
R4RS Compliance: Full
--> quasiquote <----------------
Category: Special form
Format: (quasiquote template)
Description: quasiquote returns template
R4RS Compliance: Full
--> quote <----------------
Category: Special form
Format: (quote obj)
Description: quote returns obj
R4RS Compliance: Full
--> quotient <----------------
Category: Primitive procedure
Format: (quotient int1 int2)
Description: quotient
R4RS Compliance: Full
--> random <----------------
Category: Primitive procedure
Format: (random int)
Description: random
R4RS Compliance: LispMe extension
--> read <----------------
Category: Primitive procedure
Format: (read inport)
Description: read reads an object from the input port inport
R4RS Compliance: input
--> read-char <----------------
Category: Primitive procedure
Format: (read-char inport)
Description: read-char
R4RS Compliance: The port parameter is not optional.
--> read-line <----------------
Category: Primitive procedure
Format: (read-line inport)
Description: read-line
R4RS Compliance: input-string
--> read-record <----------------
Category: Primitive procedure
Format: (read-record dbname recnum)
Description: read-record
R4RS Compliance: LispMe extension.
--> read-resource <----------------
Category: Primitive procedure
Format: (read-resource restype resid)
Description: read-resource
R4RS Compliance: LispMe extension.
--> real-part <----------------
Category: Primitive procedure
Format: (real-part z)
Description: real-part
R4RS Compliance: Full
--> real? <----------------
Category: Primitive procedure
Format: (real? obj)
Description: real? returns #t
R4RS Compliance: Full
--> rect <----------------
Category: Primitive procedure
Format: (rect x y radius)
Description: rect
R4RS Compliance: LispMe extension
--> remainder <----------------
Category: Primitive procedure
Format: (remainder int1 int2)
Description: remainder
R4RS Compliance: Full
--> reverse <----------------
Category: Library procedure
Format: (reverse list)
Description: reverse
R4RS Compliance: Full
--> rgb->index <----------------
Category: Primitive procedure
Format: (rgb->index r g b)
Description: rgb->index
R4RS Compliance: LispMe extension
--> round <----------------
Category: Primitive procedure (MathLib required)
Format: (round num)
Description: round converts num
R4RS Compliance: Full
--> scl-enter <----------------
Category: UI event
Format: (scl-enter id)
Description: scl-enter
--> scl-exit <----------------
Category: UI event
Format: (scl-exit id new)
Description: scl-exit
--> scl-get-val <----------------
Category: Primitive procedure
Format: (scl-get-val id)
Description: scl-get-val
R4RS Compliance: LispMe extension
--> scl-repeat <----------------
Category: UI event
Format: (scl-repeat id new old)
Description: scl-repeat
--> scl-set-val <----------------
Category: Primitive procedure
Format: (scl-set-val id vals)
Description: scl-set-val
R4RS Compliance: LispMe extension
--> set! <----------------
Category: Special form
Format: (set! var expr)
Description: set! evaluates expr
R4RS Compliance: Full
--> set-car! <----------------
Category: Primitive procedure
Format: (set-car! pair obj)
Description: set-car!
R4RS Compliance: Full
--> set-cdr! <----------------
Category: Primitive procedure
Format: (set-cdr! pair obj)
Description: set-cdr!
R4RS Compliance: Full
--> set-palette <----------------
Category: Primitive procedure
Format: (set-palette index r g b)
Description: set-palette
R4RS Compliance: LispMe extension
--> set-resdb <----------------
Category: Primitive procedure
Format: (set-resdb str)
Description: set-resdb
R4RS Compliance: LispMe extension
--> sin <----------------
Category: Primitive procedure (MathLib required)
Format: (sin z)
Description: sin computes the sine of the number z
R4RS Compliance: Full
--> sinh <----------------
Category: Primitive procedure (MathLib required)
Format: (sinh z)
Description: sinh
R4RS Compliance: LispMe extension
--> sound <----------------
Category: Primitive procedure
Format: (sound freq time)
Description: sound plays a sound of frequency freq
R4RS Compliance: LispMe extension
--> sqrt <----------------
Category: Primitive procedure (MathLib required)
Format: (sqrt z)
Description: sqrt
R4RS Compliance: Full
--> string2list <----------------
Category: Primitive procedure
Format: (string->list string)
Description: string->list
R4RS Compliance: Full
--> string2object <----------------
Category: Primitive procedure
Format: (string->object string)
Description: string->object
R4RS Compliance: LispMe extension. string->object
--> string-append <----------------
Category: Primitive procedure
Format: (string-append stringi ...)
Description: string-append
R4RS Compliance: Full
--> string-length <----------------
Category: Primitive procedure
Format: (string-length string)
Description: string-length
R4RS Compliance: Full
--> string-ref <----------------
Category: Primitive procedure
Format: (string-ref string index)
Description: string-ref returns the index
R4RS Compliance: Full
--> string-set! <----------------
Category: Primitive procedure
Format: (string-set! string index char)
Description: string-set! replaces the index
R4RS Compliance: Full
--> string=? <----------------
Category: Primitive procedure
Format: (string=? string1 string2)
Description: string=? returns #t
R4RS Compliance: Full
--> string? <----------------
Category: Primitive procedure
Format: (string? obj)
Description: string? returns #t
R4RS Compliance: Full
--> substring <----------------
Category: Primitive procedure
Format: (substring string start end)
Description: substring
R4RS Compliance: It's no error, when the second index end
--> symbol? <----------------
Category: Primitive procedure
Format: (symbol? obj)
Description: symbol? returns #t
R4RS Compliance: Full
--> tan <----------------
Category: Primitive procedure (MathLib required)
Format: (tan z)
Description: tan computes the tangent of the number z
R4RS Compliance: Full
--> tanh <----------------
Category: Primitive procedure (MathLib required)
Format: (tanh z)
Description: tanh
R4RS Compliance: LispMe extension
--> text <----------------
Category: Primitive procedure
Format: (text obj)
Description: text formats obj
R4RS Compliance: LispMe extension
--> truncate <----------------
Category: Primitive procedure (MathLib required)
Format: (truncate num)
Description: truncate converts num
R4RS Compliance: Full
--> unquote <----------------
Category: Special form
Format: (unquote exp)
Description: unquote evaluates exp
R4RS Compliance: Full
--> unquote-splicing <----------------
Category: Special form
Format: (unquote-splicing exp)
Description: unquote-splicing evaluates exp
R4RS Compliance: Full
--> vector <----------------
Category: Primitive procedure
Format: (vector obj1 ...)
Description: vector
R4RS Compliance: Full
--> vector2list <----------------
Category: Primitive procedure
Format: (vector->list vec)
Description: vector->list
R4RS Compliance: Full
--> vector-length <----------------
Category: Primitive procedure
Format: (vector-length vec)
Description: vector-length
R4RS Compliance: Full
--> vector-ref <----------------
Category: Primitive procedure
Format: (vector-ref vec index)
Description: vector-ref returns the index
R4RS Compliance: Full
--> vector-set! <----------------
Category: Primitive procedure
Format: (vector-set! vec index obj)
Description: vector-set! replaces the index
R4RS Compliance: Full
--> vector? <----------------
Category: Primitive procedure
Format: (vector? obj)
Description: vector? returns #t
R4RS Compliance: Full
--> wait <----------------
Category: Primitive procedure
Format: (wait time)
Description: waits waits for time
R4RS Compliance: LispMe extension
--> wait-pen <----------------
Category: Library procedure
Format: (wait-pen)
Description: wait-pen
R4RS Compliance: LispMe extension
--> write <----------------
Category: Primitive procedure
Format: (write obj [outport])
Description: write
R4RS Compliance: optional port parameter not supported
--> write-record <----------------
Category: Primitive procedure
Format: (write-record dbname recnum obj)
Description: write-record
R4RS Compliance: LispMe extension.
--> zero? <----------------
Category: Library procedure
Format: (zero? num)
Description: zero? returns #t, if num
R4RS Compliance: Full
