active.clojure.condition — de.active-group/active-clojure 0.35.0

Conditions, protocol for communicating the causes of exceptions.

This provides infrastructure for building condition objects. A condition object provides information about the cause of an exception. Conditions thus form a protocol.

Clojure ex-info objects do not, by themselves, enough to form such a protocol, as they do not allow classifying an exception easily.

This condition system builds on the design of R6RS Scheme.

Condition objects are represented as specially marked ex-info objects.

One notable difference to the R6RS design is that there is no user-facing type for 'simple conditions', nor are they regular records.

&assertion clj/s

Violation of a specific assertion.

&condition clj/s

Root of the condition-type hierarchy.

&error clj/s

Error from environment, not preventable by the program.

&irritants clj/s

Condition with objects providing more information about an exceptional situation.

irritants (objects providing more information): access via active.clojure.condition/condition-irritants

&location clj/s

Location information about an exceptional situation

namespace (namespace of the location): access via active.clojure.condition/location-condition-namespace file (file name of the location): access via active.clojure.condition/location-condition-file line (line number of the loocation): access via active.clojure.condition/location-condition-line

&message clj/s

Human-reaable message.

message (message text): access via active.clojure.condition/condition-message

&serious clj/s

Serious condition that should not be ignored.

&throwable clj/s

Throwable value that's not a condition.

value (Throwable object): access via active.clojure.condition/throwable-value

&violation clj/s

Bug in the program.

&warning clj/s

Non-fatal warning.

&who clj/s

Information about in what entity an exceptional situation occurred.

who (name of the entity): access via active.clojure.condition/condition-who

->condition clj/s

(->condition thing)

Coerce something into a condition object.

This yields thing if it's already a condition, and an [[&exception]] condition if it's not.

assert clj/s macro

(assert x)

(assert x message)

Evaluates expr and throws an exception if it does not evaluate to logical true.

assertion-violation clj/s

(assertion-violation who message & irritants)

Throw an exception that signals that an assertion was violated.

This should be called when an invalid call to a procedure was made, either passing an invalid number of arguments, or passing an argument that it is not specified to handle.

The irritants arguments can be conditions, in which case they're included in the resulting condition, or non-conditions, which are included in an &irritants condition.

On Java, irritants can also include Throwable objects.

assertion-violation? clj/s

(assertion-violation? thing)

Is object a active.clojure.condition/&assertion condition?

combine-conditions clj/s

(combine-conditions & component-conditions)

Make a compound condition from constituents.

nil and false arguments are ignored.

condition clj/s macro

(condition ?base ?message & ?irritants)

condition-accessor clj/s

(condition-accessor type field-name)

Create an an accessor for field-name for conditions of type type.

condition-irritants clj/s≠

(condition-irritants &irritants)

clj

Access the irritants (objects providing more information) field from a active.clojure.condition/&irritants condition.

cljs

Access the irritants (objects providing more information) field from a [[user/&irritants]] condition.

condition-message clj/s≠

(condition-message &message)

clj

Access the message (message text) field from a active.clojure.condition/&message condition.

cljs

Access the message (message text) field from a [[user/&message]] condition.

condition-of-type? clj/s

(condition-of-type? type cond)

Does condition cond have type type?

condition-predicate clj/s

(condition-predicate type)

Make predicate from condition type.

condition-who clj/s≠

(condition-who &who)

clj

Access the who (name of the entity) field from a active.clojure.condition/&who condition.

cljs

Access the who (name of the entity) field from a [[user/&who]] condition.

condition? clj/s

(condition? x)

ConditionComponent cljs

ConditionType cljs

covered-condition-types clj/s

(covered-condition-types)

decode-condition clj/s

(decode-condition con)

Return a keyword describing the type, a symbol or string describing the source of the problem, an error message or nil, and a sequence of other objects describing the problem.

Valid type symbols include: :error, :assertion-violation, :violation, :serious.

define-condition-type clj/s macro

(define-condition-type ?condition-type
                       ?supertype
                       ?constructor
                       ?predicate
                       &
                       ?field-specs)

(define-condition-type <condition-type>
  <supertype>
  <constructor> <predicate>
  [<field> <accessor> ...)

<Condition-type>, <supertype>, <constructor>, and <predicate> must all be identifiers. Each <field> and <accessor> must be identifiers.

The define-condition-type form defines a condition type named <condition-type>. It will have <supertype> has its parent type. The remaining identifiers will be bound as follows:

<Constructor> is bound to a constructor for the type: It accepts one argument for each of the condition type's complete set of fields (including parent types, with the fields of the parent coming before those of the extension in the arguments) and returns a condition object initialized to those arguments.

<Predicate> is bound to a predicate that identifies conditions of type <condition-type> or any of its subtypes.

Each <accessor> is bound to a function that extracts the corresponding field from a condition of type <condition-type>.

:doc properties attached to the metadata of <condition-type> and `the <field>s will yield proper docstrings for the names defined by this form.

delete-first clj/s

(delete-first pred? l)

error clj/s

(error who message & irritants)

Throw an exception that signals that an error has occurred.

This function should be called when an error has occurred, typically caused by something that has gone wrong in the interaction of the program with the external world or the user.

The irritants arguments can be conditions, in which case they're included in the resulting condition, or non-conditions, which are included in an &irritants condition.

Error cljs

error? clj/s

(error? thing)

Is object a active.clojure.condition/&error condition?

guard clj/s macro

(guard ?handling & ?body)

index-of cljs

(index-of coll v)

irritants-condition? clj/s

(irritants-condition? thing)

Is object a active.clojure.condition/&irritants condition?

location-condition-file clj/s≠

(location-condition-file &location)

clj

Access the file (file name of the location) field from a active.clojure.condition/&location condition.

cljs

Access the file (file name of the location) field from a [[user/&location]] condition.

location-condition-line clj/s≠

(location-condition-line &location)

clj

Access the line (line number of the loocation) field from a active.clojure.condition/&location condition.

cljs

Access the line (line number of the loocation) field from a [[user/&location]] condition.

location-condition-namespace clj/s≠

(location-condition-namespace &location)

clj

Access the namespace (namespace of the location) field from a active.clojure.condition/&location condition.

cljs

Access the namespace (namespace of the location) field from a [[user/&location]] condition.

location-condition? clj/s

(location-condition? thing)

Is object a active.clojure.condition/&location condition?

make-assertion-violation clj/s

Construct a active.clojure.condition/&assertion condition.

make-condition clj/s

(make-condition condition-components)

Make a condition from components.

For internal use only.

make-error clj/s

Construct a active.clojure.condition/&error condition.

make-irritants-condition clj/s

Construct a active.clojure.condition/&irritants condition.

make-location-condition clj/s

Construct a active.clojure.condition/&location condition.

make-message-condition clj/s

Construct a active.clojure.condition/&message condition.

make-serious-condition clj/s

Construct a active.clojure.condition/&serious condition.

make-throwable clj/s

Construct a active.clojure.condition/&throwable condition.

make-violation clj/s

Construct a active.clojure.condition/&violation condition.

make-warning clj/s

Construct a active.clojure.condition/&warning condition.

make-who-condition clj/s

Construct a active.clojure.condition/&who condition.

message-condition? clj/s

(message-condition? thing)

Is object a active.clojure.condition/&message condition?

print-condition clj/s≠

clj

(print-condition c w)

cljs

(print-condition c)

print-stack-trace-of clj

(print-stack-trace-of writer exception)

raise clj/s macro

(raise ?base ?message & ?irritants)

serious-condition? clj/s

(serious-condition? thing)

Is object a active.clojure.condition/&serious condition?

stack-trace-who clj

(stack-trace-who st)

Get a suitable argument for &who from an exception object.

throw-condition clj/s macro

(throw-condition ?base ?who ?message ?irritants)

Throw a condition.

For internal use.

Throwable cljs

throwable-value clj/s≠

(throwable-value &throwable)

clj

Access the value (Throwable object) field from a active.clojure.condition/&throwable condition.

cljs

Access the value (Throwable object) field from a [[user/&throwable]] condition.

throwable? clj/s

(throwable? thing)

Is object a active.clojure.condition/&throwable condition?

violation? clj/s

(violation? thing)

Is object a active.clojure.condition/&violation condition?

warning? clj/s

(warning? thing)

Is object a active.clojure.condition/&warning condition?

who-condition? clj/s

(who-condition? thing)

Is object a active.clojure.condition/&who condition?