List of all Scheme Primitive Procedures
Jscheme adopts almost all of the
standard procedures of
R4RS Scheme.
It does not fully implement call/cc.
Also, while JScheme provides string mutators string-set! and
string-fill!, JScheme strings are implemented as Java Strings
which are considered immutable, so use these procedures carefully.
The only R4RS primitives that
are not fully supported are
- (call-with-current-continuation )
ONLY PARTIALLY IMPLEMENTED
- (complex? )
NOT IMPLEMENTED
- (rational? ) UNIMPLEMENTED
- (real? ) UNIMPLEMENTED
A list of all essential R4RS primitives is provided below.
- (exact->inexact n ) -- converts an exact number n to an inexact number
- (inexact->exact x ) -- converts an inexact number x to an exact number
- (* x y ... z) multiplies a sequence of numbers
- (+ x y ... z ) adds a sequence of numbers
- (- x y ) subtracts two numbers
- (/ x y ) divides two numbers
- (< x y ) compares two numbers, returns #t if x is less than y
- (<=x y ) compares two numbers, returns #t if x is less than or equal to y
- (= x y) compares two numbers, returns #t if x is equal to y
- (> x y ) compares two numbers, returns #t if x is greater than y
- (>= x y ) compares two numbers, returns #t if x is greater than or equal to y
- (abs x ) the absolute value of x
- (acos x ) the arc cosine of x
- (append x y) appends two lists x y to get a new list
- (apply f arguments ) applies the function f to the list of arguments
- (asin x) the arc sine of x
- (assoc x alist) alist is a list of pairs (key value), if x is one of those keys, the value is returned.
equal? is used to compare x and key.
- (assq x alist) Same as assoc, but eq? is used to compare x and key.
- (assv x alist) Same as assoc, but eqv? is used to compare x and key.
- (atan x) the arc tangent of x
- (boolean? b ) #t if b is a boolean value: #t or #f
- (caaaar ) (lambda (x) (car (car (car (car x)))))
- (caaadr ) (lambda (x) (car (car (car (cdr x)))))
- (caaar ) (lambda (x) (car (car (car x))))
- (caadar ) (lambda (x) (car (car (cdr (car x)))))
- (caaddr ) (lambda (x) (car (car (cdr (cdr x)))))
- (caadr ) (lambda (x) (car (car (cdr x))))
- (caar ) (lambda (x) (car (car x)))
- (cadaar ) (lambda (x) (car (cdr (car (car x)))))
- (cadadr ) (lambda (x) (car (cdr (car (cdr x)))))
- (cadar ) (lambda (x) (car (cdr (car x))))
- (caddar ) (lambda (x) (car (cdr (cdr (car x)))))
- (cadddr ) (lambda (x) (car (cdr (cdr (cdr x)))))
- (caddr ) (lambda (x) (car (cdr (cdr x))))
- (cadr ) (lambda (x) (car (cdr x)))
- (call-with-current-continuation )
ONLY PARTIALLY IMPLEMENTED
- (call-with-input-file )
- (call-with-output-file )
- (car L ) the first element in the list L
- (cdaaar ) (lambda (x) (cdr (car (car (car x)))))
- (cdaadr ) (lambda (x) (cdr (car (car (cdr x)))))
- (cdaar ) (lambda (x) (cdr (car (car x))))
- (cdadar ) (lambda (x) (cdr (car (cdr (car x)))))
- (cdaddr ) (lambda (x) (cdr (car (cdr (cdr x)))))
- (cdadr ) (lambda (x) (cdr (car (cdr x))))
- (cdar ) (lambda (x) (cdr (car x)))
- (cddaar ) (lambda (x) (cdr (cdr (car (car x)))))
- (cddadr ) (lambda (x) (cdr (cdr (car (cdr x)))))
- (cddar ) (lambda (x) (cdr (cdr (car x))))
- (cdddar ) (lambda (x) (cdr (cdr (cdr (car x)))))
- (cddddr ) (lambda (x) (cdr (cdr (cdr (cdr x)))))
- (cdddr ) (lambda (x) (cdr (cdr (cdr x))))
- (cddr ) (lambda (x) (cdr (cdr x)))
- (cdr L ) the list obtained by removing the first element from the list L
- (ceiling x ) return the smallest integer greater than or equal to x
- (char->integer )
- (char-alphabetic? )
- ((char-ci<=? C1 C2) ) case-insensitive comparison of characters C1,C2
- (char-ci )
- (char-ci=? )
- (char-ci>=? )
- (char-ci>? )
- (char-downcase )
- (char-lower-case? )
- (char-numeric? )
- (char-upcase )
- (char-upper-case? )
- (char-whitespace? )
- ((char<=? C1 C2) ) case-sensitive comparison of characters
- (char )
- (char=? )
- (char>=? )
- (char>? )
- (char? )
- (close-input-port )
- (close-output-port )
- (complex? ) NOT IMPLEMENTED
- (cons x L ) the list obtained by adding x to the beginning of the list L
- (cos x) the cosine of x in radians
- ((current-input-port) )
- ((current-output-port) )
- (display T ) print the term T on the Java console
- ((eof-object? X) ) returns true if X is the end of file object returned by read
- ((eq? A B) ) returns #t when A and B are
both #null or when they are both the same object
- (equal? x y)
returns #t if x and y are both #null or
represent the same numbers, or are ".equals" as Java objects,
or are lists whose corresponding elements are "equal?", or are arrays whose corresponding elements are "equal?".
or are
- ((eqv? A B) )
returns #t if x and y are both #null or
represent the same numbers, or are ".equals" as Java objects.
- ((eval T) ) this evaluates the expression T in
the current toplevel environment. The expression T is an expression formed from symbols and objects
cons'd together.
- (even? x) #t if x is an even number
- ((exact? x) ) #t if x is a byte, short, or int
- (exp x ) the exponential function applied to x
- (expt n e ) raise n to the power e
- (floor x) return the largest integer less than x
- (for-each P L ) apply the procedure P to every element of the list L
- (force )
- (gcd x y ) find the greatest common divisor of x and y
- ((inexact? x) ) #t if x is a float or double
- ((input-port? x) )
- ((integer->char i) ) converts i to 16 bit unicode character
- (interaction-environment)Return the current interaction environment.
- (integer? x ) #t if x is an integer
- (lcm x y) return the least common multiple of x and y
- (length L) return the length of the list L
- (list x y ... z) make a list from the elements x, y, ... z
- ((list->string Cs) ) converts the list Cs of characters to a string
- ((list->vector Os) ) converts the list Os of objects to a vector
- ((list-ref L N ) returns the (N+1)st element of L. So
(list-ref L 0) returns the first element of L.
- (list-tailL N ) returns the list obtained by removing the
first N elements from L
- (list? L) returns #t if L is a list
- (load F) reads and interprets the Scheme expressions in
the file F in the current toplevel environment
- (log x) the natural log function applied to x
- (macroexpand X)
- (make-string )
- (make-vector )
- (map F L) return the list obtained by applying the function F to every element of the list L
- (max a b c ... d) find the largest of the numbers a, b, ..., d
- (member x L) return #t if x is a member of the list L
- (memq )
- (memv )
- (min a b c ... d) find the smallest of the numbers a, b, ..., d
- (modulo n d) return the remainder of n divided by d
- (negative? x) return #t if x is a negative number
- (newline) write a newline on the Java console
- (not b) negates the truth value b
- (null-environment )
- (null? L ) return #t if L is the empty list
- (number->string )
- (number? x ) return #t if x is a number
- (odd? x) return #t if x is an odd number
- (open-input-file )
- (open-output-file )
- (output-port? )
- (pair? L) return #t if L is a pair.
- (peek-char )
- (positive? x) return #t if x is a positive number
- (procedure? p) return #t if p is a procedure
- (quotient x y ) return the integer quotient of x divided by y
- (rational? ) UNIMPLEMENTED
- (read )
- (read-char )
- (real? ) UNIMPLEMENTED
- (remainder x y) return the remainder of x divided by y
- (reverse L) reverse the list L
- (round x) return the nearest integer to the number x
- (scheme-report-environment )
- (set-car! )
- (set-cdr! )
- (sin x) the sine of x
- (sqrt x) the square root of x
- (string )
- (string->list )
- (string->number )
- (string->symbol )
- (string-append a b c ... d) combine the strings a, b, ..., d into a single new string
- (string-ci<=? )
- (string-ci )
- (string-ci=? )
- (string-ci>=? )
- (string-ci>? )
- (string-copy )
- (string-fill! )
- (string-length x) return the number of characters in the string x
- (string-ref )
- (string-set! )
- (string<=? )
- (string )
- (string=? )
- (string>=? )
- (string>? )
- (string? )
- (substring s i j ) return the substring of s that starts at position i and ends right before position j,
where 0 is the first position in the string.
- (symbol->string )
- (symbol? s) return #t if s is a symbol
- (tan x) tangent of x
- (truncate x) remove the fractional part of the decimal x to get an integer
- (vector )
- (vector->list )
- (vector-fill! )
- (vector-length )
- (vector-ref )
- (vector-set! )
- (vector? )
- (write )
- (write-char )
- (zero? z) return #t if z equals 0