(index ("current-exception-handler" 0) ("exceptions" 145) ("exception?" 237) ("exn?" 372) ("exception-of?" 445) ("exn-of?" 633) ("make-exception" 720) ("make-exn" 1055) ("location" 1152) ("message" 1270) ("arguments" 1385) ("raise" 1506) ("with-exn-handler" 1659) ("condition-case" 1925) ("handle-exceptions" 2091) ("guard" 2240) ("assert*" 2574) ("argument-exception" 2825) ("argument-exn" 2989) ("result-exception" 3094) ("result-exn" 3253) ("named-lambda" 3352) ("<<" 3497) (">>" 3712) ("true?" 3924) ("false?" 3997))
(def (sig (parameter "(current-exception-handler [new-handler])" (id current-exception-handler))) (p "chicken's handler parameter reexported."))
(def (sig (procedure "(exceptions [sym])" (id exceptions))) (p "documentation procedure."))
(def (sig (procedure "(exception? xpr)" (id exception?))) (p "type predicate. Note, that each exception is a condition of kind exn."))
(def (sig (procedure "(exn? xpr)" (id exn?))) (p "alias to exception?"))
(def (sig (procedure "(exception-of? kind-key)" (id exception-of?))) (p "returns a unary predicate, which checks, if its argument expression is an exception of kind kind-key, a symbol."))
(def (sig (procedure "(exn-of? kind-key)" (id exn-of?))) (p "alias to exception-of?"))
(def (sig (procedure "(make-exception msg . kind-keys)" (id make-exception))) (p "Returns a procedure of at least one argument, a symbol describing the location of its call, and an optional other argument, a list of arguments, which creates an exception of kinds kind-keys, message msg, as well as the given location and arguments."))
(def (sig (procedure "(make-exn msg . kind-keys)" (id make-exn))) (p "alias to make-exception"))
(def (sig (procedure "(location exn)" (id location))) (p "returns the location property of its exception argument."))
(def (sig (procedure "(message exn)" (id message))) (p "returns the message property of its exception argument."))
(def (sig (procedure "(arguments exn)" (id arguments))) (p "returns the arguments property of its exception argument."))
(def (sig (procedure "(raise exn)" (id raise))) (p "raises its argument, i.e. calls (current-exception-handler) with exn. In essence chicken's abort."))
(def (sig (procedure "(with-exn-handler handler thunk)" (id with-exn-handler))) (p "A save version of chicken's low-level with-exception-handler. Sets the current-exception-handler to handler for the dynamic extent of its call and executes thunk in this context."))
(def (sig (syntax "(condition-case xpr ([var] (kind ...) body) . other-clauses)))" (id condition-case))) (p "Chicken's highest level exception-handler reexported."))
(def (sig (syntax "(handle-exceptions exn handle-xpr xpr . xprs)" (id handle-exceptions))) (p "Chicken's high level exception handler reexported."))
(def (sig (syntax "(guard (exn cond-clause . cond-clauses) xpr . xprs)" (id guard))) (p "The high level exception handler of R6RS and R7RS. Sets the current-exception-handler to an exception-handler created from exn und the supplied cond-clauses for the dynamic extent of its call and executes the body xpr . xprs in this context."))
(def (sig (syntax "(assert* loc xpr . xprs)" (id assert*))) (p "checks the expressions xpr . xprs in sequence and raises an exception for the first failing expression with location property loc and arguments property the failing expression quoted."))
(def (sig (procedure "(argument-exception loc arg ...)" (id argument-exception))) (p "raised when a precondition is violated. Can be catched with (exn argument)"))
(def (sig (procedure "(argument-exn loc arg ...)" (id argument-exn))) (p "alias to argument-exception"))
(def (sig (procedure "(result-exception loc arg ...)" (id result-exception))) (p "raised when a postcondition is violated. Can be catched with (exn result)"))
(def (sig (procedure "(result-exn loc arg ...)" (id result-exn))) (p "alias to result-exception"))
(def (sig (syntax "(named-lambda name args xpr . xprs)" (id named-lambda))) (p "can replace anonymous procedures and can be used recursively."))
(def (sig (procedure "(<< x loc .. x? ...)" (id <<))) (p "precondition test: passes x unchanged only if all predicates x? return #t on it, raises an argument-exception at location loc, if given, or '<< otherwise"))
(def (sig (procedure "(>> x loc .. x? ...)" (id >>))) (p "postcondition test: passes x unchanged only if all predicates x? return #t on it raises a result-exception at location loc, if given, or '>> otherwise"))
(def (sig (procedure "(true? xpr)" (id true?))) (p "returns always #t"))
(def (sig (procedure "(false? xpr)" (id false?))) (p "returns always #f"))
