The type of boolean values. As a type conversion, a true value is converted to #t, while a false value is converted to #f. Represented as a primitive Java boolean or kava.lang.Boolean when converted to an object.

The boolean? predicate returns #t if obj is either #t or #f, and returns #f otherwise.

(boolean? #f)   ⇒  #t
(boolean? 0)    ⇒  #f
(boolean? '())  ⇒  #f

The not procedure returns #t if obj is false, and returns #f otherwise.

(not #t)         ⇒  #f
(not 3)          ⇒  #f
(not (list 3))   ⇒  #f
(not #f)         ⇒  #t
(not ’())        ⇒  #f
(not (list))     ⇒  #f
(not ’nil)       ⇒  #f

Returns #t if all the arguments are booleans and all are #t or all are #f.

An if expression is evaluated as follows: first, test-expression is evaluated. If it yields a true value, then consequent is evaluated and its values are returned. Otherwise alternate is evaluated and its values are returned. If test yields #f and no alternate is specified, then the result of the expression is unspecified.

(if (> 3 2) 'yes 'no)          ⇒ yes
(if (> 2 3) 'yes 'no)          ⇒ no
(if (> 3 2)
    (- 3 2)
    (+ 3 2))                   ⇒ 1
(if #f #f)                     ⇒ unspecified

The consequent and alternate expressions are in tail context if the if expression itself is.

cond-clause ::= (test-expression expression^*)
    | (test => expression)

A cond expression is evaluated by evaluating the test-expressions of successive cond-clauses in order until one of them evaluates to a true value. When a test-expression evaluates to a true value, then the remaining expressions in its cond-clause are evaluated in order, and the results of the last expression in the cond-clause are returned as the results of the entire cond expression. If the selected cond-clause contains only the test-expression and no expressions, then the value of the test-expression is returned as the result. If the selected cond-clause uses the => alternate form, then the expression is evaluated. Its value must be a procedure. This procedure should accept one argument; it is called on the value of the test-expression and the values returned by this procedure are returned by the cond expression.

If all test-expressions evaluate to #f, and there is no else clause, then the conditional expression returns unspecified values; if there is an else clause, then its expressions are evaluated, and the values of the last one are returned.

(cond ((> 3 2) 'greater)
      ((< 3 2) 'less))         ⇒ greater

(cond ((> 3 3) 'greater)
      ((< 3 3) 'less)
      (else 'equal))           ⇒ equal

(cond ('(1 2 3) => cadr)
      (else #f))               ⇒ 2

For a cond-clause of one of the following forms:

(test expression^*)
(else expression expression^*)

the last expression is in tail context if the cond form itself is. For a cond clause of the form:

(test => expression)

the (implied) call to the procedure that results from the evaluation of expression is in a tail context if the cond form itself is.

case-key ::= expression
case-clause ::= ((datum^*) expression^+)
    | ((datum^*) => expression)
case-else-clause ::= (else  expression^+)
    | (else => expression)

Each datum is an external representation of some object. Each datum in the entire case expression should be distinct.

A case expression is evaluated as follows.

1. The case-key is evaluated and its result is compared using eqv? against the data represented by the datums of each case-clause in turn, proceeding in order from left to right through the set of clauses.

2. If the result of evaluating case-key is equivalent to a datum of a case-clause, the corresponding expressions are evaluated from left to right and the results of the last expression in the case-clause are returned as the results of the case expression. Otherwise, the comparison process continues.

3. If the result of evaluating key is different from every datum in each set, then if there is an case-else-clause its expressions are evaluated and the results of the last are the results of the case expression; otherwise the result of case expression is unspecified.

If the selected case-clause or case-else-clause uses the => alternate form, then the expression is evaluated. It is an error if its value is not a procedure accepting one argument. This procedure is then called on the value of the key and the values returned by this procedure are returned by the case expression.

(case (* 2 3)
  ((2 3 5 7) 'prime)
  ((1 4 6 8 9) 'composite))    ⇒ composite
(case (car '(c d))
  ((a) 'a)
  ((b) 'b))                    ⇒ unspecified
(case (car '(c d))
  ((a e i o u) 'vowel)
  ((w y) 'semivowel)
  (else => (lambda (x) x)))    ⇒ c

The last expression of a case clause is in tail context if the case expression itself is.

If there are no test-expressions, #t is returned. Otherwise, the test-expression are evaluated from left to right until a test-expression returns #f or the last test-expression is reached. In the former case, the and expression returns #f without evaluating the remaining expressions. In the latter case, the last expression is evaluated and its values are returned.

(and (= 2 2) (> 2 1))          ⇒  #t
(and (= 2 2) (< 2 1))          ⇒  #f
(and 1 2 'c '(f g))            ⇒  (f g)
(and)                          ⇒  #t

The and keyword could be defined in terms of if using syntax-rules as follows:

(define-syntax and
  (syntax-rules ()
    ((and) #t)
    ((and test) test)
    ((and test1 test2 ...)
     (if test1 (and test2 ...) #t))))

The last test-expression is in tail context if the and expression itself is.

If there are no test-expressions, #f is returned. Otherwise, the test-expressions are evaluated from left to right until a test-expression returns a true value val or the last test-expression is reached. In the former case, the or expression returns val without evaluating the remaining expressions. In the latter case, the last expression is evaluated and its values are returned.

(or (= 2 2) (> 2 1))           ⇒ #t
(or (= 2 2) (< 2 1))           ⇒ #t
(or #f #f #f)                  ⇒ #f
(or '(b c) (/ 3 0))            ⇒ (b c)

The or keyword could be defined in terms of if using syntax-rules as follows:

(define-syntax or
  (syntax-rules ()
    ((or) #f)
    ((or test) test)
    ((or test1 test2 ...)
     (let ((x test1))
       (if x x (or test2 ...))))))

The last test-expression is in tail context if the or expression itself is.

If test-expression is true, evaluate each form in order, returning the value of the last one.

If test-expression is false, evaluate each form in order, returning the value of the last one.

Same as define, except that name is not exported.

Defines name to have the given value. The value is readonly, and you cannot assign to it. (This is not fully enforced.)

If define-early-constant is used or the value is a compile-time constant, then the compiler will create a final field with the given name and type, and evaluate value in the module's class initializer (if the definition is static) or constructor (if the definition is non-static), before other definitions and expressions. Othewise, the value is evaluated in the module body where it appears.

If the value is a compile-time constant, then the definition defaults to being static.

If init is specified and name does not have a global variable binding, then init is evaluated, and name bound to the result. Otherwise, the value bound to name does not change. (Note that init is not evaluated if name does have a global variable binding.)

Also, declares to the compiler that name will be looked up in the dynamic environment. This can be useful for shutting up warnings from --warn-undefined-variable.

This is similar to the Common Lisp defvar form. However, the Kawa version is (currently) only allowed at module level.

Declare new local variables with the given name, initial value init, and optional type specification type. The inits are evaluated in the current environment (in left-to-right onder), the variables are bound to fresh locations holding the results, the body is evaluated in the extended environment, and the values of the last expression of body are returned. Each binding of a variable has body as its region. If type is specified, then after the expression init is evaluated, the result coerced to type, and then assigned to the variable. If type is not specified, it defaults to Object.

(let ((x 2) (y 3))
  (* x y)) ⇒ 6

(let ((x 2) (y 3))
  (let ((x 7)
        (z (+ x y)))
    (* z x)))   ⇒ 35

The let* binding construct is similar to let, but the bindings are performed sequentially from left to right, and the region of a variable is that part of the let* expression to the right of the binding. Thus the second binding is done in an environment in which the first binding is visible, and so on. The variables need not be distinct.

(let ((x 2) (y 3))
  (let* ((x 7)
         (z (+ x y)))
    (* z x)))  ⇒ 70

The variables are bound to fresh locations, each variable is assigned in left-to-right order to the result of the corresponding init, the body is evaluated in the resulting environment, and the values of the last expression in body are returned. Despite the left-to-right evaluation and assignment order, each binding of a variable has the entire letrec or letrec* expression as its region, making it possible to define mutually recursive procedures.

In Kawa letrec is defined as the same as letrec*. In standard Scheme the order of evaluation of the inits is undefined, as is the order of assignments. If the order matters, you should use letrec*.

If it is not possible to evaluate each init without assigning or referring to the value of the corresponding variable or the variables that follow it , it is an error.

(letrec ((even?
          (lambda (n)
            (if (zero? n)
                #t
                (odd? (- n 1)))))
         (odd?
          (lambda (n)
            (if (zero? n)
                #f
                (even? (- n 1))))))
  (even? 88))
     ⇒ #t

Creates a new thread that evaluates expression.

(The result extends java.lang.Thread and implements gnu.mapping.Lazy.)

The standard force function has generalized to also work on threads. If waits for the thread's expression to finish executing, and returns the result.

Creates a new Runnable instance from a function. Useful for passing to Java code that expects a Runnable. You can get the result (a value or a thrown exception) using the getResult method.

Synchronize on the given object. (This means getting an exclusive lock on the object, by acquiring its monitor.) Then execute the forms while holding the lock. When the forms finish (normally or abnormally by throwing an exception), the lock is released. Returns the result of the last form. Equivalent to the Java synchronized statement, except that it may return a result.

It is an error if handler does not accept one argument. It is also an error if thunk does not accept zero arguments. The with-exception-handler procedure returns the results of invoking thunk. The handler is installed as the current exception handler in the dynamic environment used for the invocation of thunk.

(call-with-current-continuation
  (lambda (k)
   (with-exception-handler
    (lambda (x)
     (display "condition: ")
     (write x)
     (newline)
     (k 'exception))
    (lambda ()
     (+ 1 (raise ’an-error))))))
       ⇒ exception
       and prints condition: an-error

(with-exception-handler
 (lambda (x)
  (display "something went wrong\n"))
 (lambda ()
  (+ 1 (raise ’an-error))))
    prints something went wrong

After printing, the second example then raises another exception.

Performance note: The thunk is inlined if it is a lambda expression. However, the handler cannot be inlined even if it is a lambda expression, because it could be called by raise-continuable. Using the guard form is usually more efficient.

Raises an exception by invoking the current exception handler on obj. The handler is called with the same dynamic environment as that of the call to raise, except that the current exception handler is the one that was in place when the handler being called was installed. If the handler returns, then obj is re-raised in the same dynamic environment as the handler.

If obj is an instance of java.lang.Throwable, then raise has the same effect as primitive-throw.

Raises an exception by invoking the current exception handler on obj. The handler is called with the same dynamic environment as the call to raise-continuable, except that: (1) the current exception handler is the one that was in place when the handler being called was installed, and (2) if the handler being called returns, then it will again become the current exception handler. If the handler returns, the values it returns become the values returned by the call to raise-continuable.

(with-exception-handler
  (lambda (con)
    (cond
      ((string? con)
       (display con))
      (else
       (display "a warning has been issued")))
    42)
  (lambda ()
    (+ (raise-continuable "should be a number")
       23)))
      prints: should be a number
      ⇒ 65

The body is evaluated with an exception handler that binds the raised object to variable and, within the scope of that binding, evaluates the clauses as if they were the clauses of a cond expression. That implicit cond expression is evaluated with the continuation and dynamic environment of the guard expression. If every cond-clause’s test evaluates to #f and there is no else clause, then raise-continuable is invoked on the raised object within the dynamic environment of the original call to raise or raise-continuable, except that the current exception handler is that of the guard expression.

(guard (condition
         ((assq 'a condition) => cdr)
         ((assq 'b condition)))
  (raise (list (cons 'a 42))))
      ⇒ 42

(guard (condition
         ((assq 'a condition) => cdr)
         ((assq 'b condition)))
  (raise (list (cons 'b 23))))
      ⇒ (b . 23)

Performance note: Using guard is moderately efficient: there is some overhead compared to using native exception handling, but both the body and the handlers in the cond-clause are inlined.

All three arguments must be 0-argument procedures. First calls in-guard, then thunk, then out-guard. The result of the expression is that of thunk. If thunk is exited abnormally (by throwing an exception or invoking a continuation), out-guard is called.

If the continuation of the dynamic-wind is re-entered (which is not yet possible in Kawa), the in-guard is called again.

This function was added in R5RS.

Returns #t if obj is an object raised by the read procedure. (That is if obj is a gnu.text.SyntaxException.)

Returns #t if obj is an object raised by inability to open an input or output port on a file. (This includes java.io.FileNotFoundException as well as certain other exceptions.)