# 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
(src)

- (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
(src)

- (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