chicken-bin 4.9.0.1-1 / usr / share / doc / chicken-bin / manual-html / Exceptions.html

This file is indexed.

/usr/share/doc/chicken-bin/manual-html/Exceptions.html is in chicken-bin 4.9.0.1-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
<!doctype html>
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<link rel="stylesheet" href="manual.css" type="text/css" /></head>
<title>Chicken &raquo; Exceptions</title>
<meta name="viewport" content="initial-scale=1" /></html>
<body>
<div id="body">
<div id="main">
<div id="toc">
<h2 class="toc">TOC &raquo;</h2>
<ul class="toc">
<li><a href="#sec:Exceptions">Exceptions</a></li>
<li><a href="#sec:Chicken_implementation">Chicken implementation</a>
<ul>
<li><a href="#sec:System_conditions">System conditions</a></li>
<li><a href="#sec:Notes">Notes</a></li>
<li><a href="#sec:Additional_API">Additional API</a></li></ul></li>
<li><a href="#sec:SRFI-12_specification">SRFI-12 specification</a>
<ul>
<li><a href="#sec:Exception_Handlers">Exception Handlers</a></li>
<li><a href="#sec:Raising_Exceptions">Raising Exceptions</a></li>
<li><a href="#sec:Condition_Objects">Condition Objects</a></li>
<li><a href="#sec:More_Examples">More Examples</a></li></ul></li></ul></div><h2 id="sec:Exceptions"><a href="#sec:Exceptions">Exceptions</a></h2><p>Chicken's exception handling is based on the <a href="http://srfi.schemers.org/srfi-12/srfi-12.html">SRFI-12</a> exception system.  This document contains the core of the SRFI-12 spec as well as Chicken implementation specifics.</p><h2 id="sec:Chicken_implementation"><a href="#sec:Chicken_implementation">Chicken implementation</a></h2><h3 id="sec:System_conditions"><a href="#sec:System_conditions">System conditions</a></h3><p>All error-conditions signaled by the system are of kind <tt>exn</tt>. The following composite conditions are additionally defined:</p><table>

<tr><td> (exn arity) </td><td>

Signaled when a procedure is called with the wrong number of arguments.

</td></tr>
<tr><td> (exn type) </td><td>

Signaled on type-mismatch errors, for example when an argument of the wrong
type is passed to a built-in procedure.

</td></tr>
<tr><td> (exn arithmetic) </td><td>

Signaled on arithmetic errors, like division by zero.

</td></tr>
<tr><td> (exn i/o) </td><td>

Signaled on input/output errors.

</td></tr>
<tr><td> (exn i/o file) </td><td>

Signaled on file-related errors.

</td></tr>
<tr><td> (exn i/o net) </td><td>

Signaled on network errors.

</td></tr>
<tr><td> (exn bounds) </td><td>

Signaled on errors caused by accessing non-existent elements of a collection.

</td></tr>
<tr><td> (exn runtime) </td><td>

Signaled on low-level runtime-system error-situations.

</td></tr>
<tr><td> (exn runtime limit) </td><td>

Signaled when an internal limit is exceeded (like running out of memory).

</td></tr>
<tr><td> (exn match) </td><td>

Signaled on errors raised by failed matches (see the section on <tt>match</tt>).

</td></tr>
<tr><td> (exn syntax) </td><td>

Signaled on syntax errors.

</td></tr>

</table>
<h3 id="sec:Notes"><a href="#sec:Notes">Notes</a></h3><ul><li>All error-exceptions (of the kind <tt>exn</tt>) are non-continuable.</li>
<li>Error-exceptions of the <tt>exn</tt> kind have additional <tt>arguments</tt> and <tt>location</tt> properties that contain the arguments passed to the exception-handler and the name of the procedure where the error occurred (if available).</li>
<li>When the <tt>posix</tt> unit is available and used, then a user-interrupt (<tt>signal/int</tt>) signals an exception of the kind <tt>user-interrupt</tt>.</li>
<li>The procedure <tt>condition-property-accessor</tt> accepts an optional third argument. If the condition does not have a value for the desired property and if the optional argument is given, no error is signaled and the accessor returns the third argument.</li>
<li>On platforms that support the <tt>sigprocmask(3)</tt> POSIX API function, the signals <tt>SIGSEGV</tt>, <tt>SIGFPE</tt>, <tt>SIGBUS</tt> and <tt>SIGILL</tt> will be caught and trigger an exception instead of aborting the process, if possible. If the unwinding and handling of the signal raises one of these signals once again, the process will abort with an error message.</li>
</ul>
<h3 id="sec:Additional_API"><a href="#sec:Additional_API">Additional API</a></h3><dl class="defsig"><dt class="defsig" id="def:condition-case"><span class="sig"><tt>(condition-case EXPRESSION CLAUSE ...)</tt></span> <span class="type">syntax</span></dt>
<dd class="defsig"><p>Evaluates <tt>EXPRESSION</tt> and handles any exceptions that are covered by <tt>CLAUSE ...</tt>, where <tt>CLAUSE</tt> should be of the following form:</p><pre> CLAUSE = ([VARIABLE] (KIND ...) BODY ...)</pre><p>If provided, <tt>VARIABLE</tt> will be bound to the signaled exception object. <tt>BODY ...</tt> is executed when the exception is a property- or composite condition with the kinds given <tt>KIND ...</tt> (unevaluated). If no clause applies, the exception is re-signaled in the same dynamic context as the <tt>condition-case</tt> form.</p>
<pre class="highlight colorize"><span class="paren1">(<span class="default"><i><span class="symbol">define</span></i> <span class="paren2">(<span class="default">check thunk</span>)</span>
  <span class="paren2">(<span class="default">condition-case <span class="paren3">(<span class="default">thunk</span>)</span>
    <span class="paren3">[<span class="default"><span class="paren4">(<span class="default">exn file</span>)</span> <span class="paren4">(<span class="default">print <span class="string">&quot;file error&quot;</span></span>)</span></span>]</span>
    <span class="paren3">[<span class="default"><span class="paren4">(<span class="default">exn</span>)</span> <span class="paren4">(<span class="default">print <span class="string">&quot;other error&quot;</span></span>)</span></span>]</span>
    <span class="paren3">[<span class="default">var <span class="paren4">(<span class="default"></span>)</span> <span class="paren4">(<span class="default">print <span class="string">&quot;something else&quot;</span></span>)</span></span>]</span> </span>)</span> </span>)</span>

<span class="paren1">(<span class="default">check <span class="paren2">(<span class="default"><i><span class="symbol">lambda</span></i> <span class="paren3">(<span class="default"></span>)</span> <span class="paren3">(<span class="default">open-input-file <span class="string">&quot;&quot;</span></span>)</span></span>)</span></span>)</span>   <span class="comment">; -&gt; &quot;file error&quot;
</span><span class="paren1">(<span class="default">check <span class="paren2">(<span class="default"><i><span class="symbol">lambda</span></i> <span class="paren3">(<span class="default"></span>)</span> some-unbound-variable</span>)</span></span>)</span>  <span class="comment">; -&gt; &quot;othererror&quot;
</span><span class="paren1">(<span class="default">check <span class="paren2">(<span class="default"><i><span class="symbol">lambda</span></i> <span class="paren3">(<span class="default"></span>)</span> <span class="paren3">(<span class="default">signal 99</span>)</span></span>)</span></span>)</span>            <span class="comment">; -&gt; &quot;something else&quot;
</span>
<span class="paren1">(<span class="default">condition-case some-unbound-variable
  <span class="paren2">(<span class="default"><span class="paren3">(<span class="default">exn file</span>)</span> <span class="paren3">(<span class="default">print <span class="string">&quot;ignored&quot;</span></span>)</span></span>)</span> </span>)</span>      <span class="comment">; -&gt; signals error</span></pre></dd>
</dl>
<dl class="defsig"><dt class="defsig" id="def:get-condition-property"><span class="sig"><tt>(get-condition-property CONDITION KIND PROPERTY [DEFAULT])</tt></span> <span class="type">procedure</span></dt>
<dd class="defsig"><p>A slightly more convenient condition property accessor, equivalent to</p><pre>((condition-property-accessor KIND PROPERTY [DEFAULT]) CONDITION)</pre></dd>
</dl>
<dl class="defsig"><dt class="defsig" id="def:condition-.3elist"><span class="sig"><tt>(condition-&gt;list CONDITION)</tt></span> <span class="type">procedure</span></dt>
<dd class="defsig"><p>This procedure converts a condition object into a list holding all the conditions that are represented by the <i>CONDITION</i> object.  It is formatted as follows:</p><pre>((KIND1 (PROPERTY1 VALUE1) (PROPERTY2 VALUE2) ...) (KIND2 ... ) ... )</pre><p>There is no guaranteed order within the list.</p><p><tt>condition-&gt;list</tt> was introduced in CHICKEN 4.7.0.</p></dd>
</dl>
<h2 id="sec:SRFI-12_specification"><a href="#sec:SRFI-12_specification">SRFI-12 specification</a></h2><p>A Scheme implementation (&quot;the system&quot;) raises an exception whenever an error is to be signaled or whenever the system determines that evaluation cannot proceed in a manner consistent with the semantics of Scheme. A program may also explicitly raise an exception.</p><p>Whenever the system raises an exception, it invokes the current exception handler with a condition object (encapsulating information about the exception) as its only argument. Any procedure accepting one argument may serve as an exception handler. When a program explicitly raises an exception, it may supply any object to the exception handler.</p><p>An exception is either continuable or non-continuable. When the current exception handler is invoked for a continuable exception, the continuation uses the handler's result(s) in an exception-specific way to continue. When an exception handler is invoked for a non-continuable exception, the continuation raises a non-continuable exception indicating that the exception handler returned.  On CHICKEN, system error exceptions (of kind <tt>exn</tt>) are non-continuable.</p><h3 id="sec:Exception_Handlers"><a href="#sec:Exception_Handlers">Exception Handlers</a></h3><dl class="defsig"><dt class="defsig" id="def:current-exception-handler"><span class="sig"><tt>(current-exception-handler [PROCEDURE])</tt></span> <span class="type">parameter</span></dt>
<dd class="defsig"><p>Sets or returns the current exception handler, a procedure of one argument, the exception object.</p></dd>
</dl>
<dl class="defsig"><dt class="defsig" id="def:with-exception-handler"><span class="sig"><tt>(with-exception-handler handler thunk)</tt></span> <span class="type">procedure</span></dt>
<dd class="defsig"><p>Returns the result(s) of invoking <i>thunk</i>. The <i>handler</i> procedure is installed as the current exception handler in the dynamic context of invoking <i>thunk</i>.</p><p>Example:</p>
<pre class="highlight colorize"><span class="paren1">(<span class="default">call-with-current-continuation
 <span class="paren2">(<span class="default"><i><span class="symbol">lambda</span></i> <span class="paren3">(<span class="default">k</span>)</span>
  <span class="paren3">(<span class="default"><i><span class="symbol">with-exception-handler</span></i> <span class="paren4">(<span class="default"><i><span class="symbol">lambda</span></i> <span class="paren5">(<span class="default">x</span>)</span> <span class="paren5">(<span class="default">k &#x27;<span class="paren6">(<span class="default"></span>)</span></span>)</span></span>)</span>
                          <span class="paren4">(<span class="default"><i><span class="symbol">lambda</span></i> <span class="paren5">(<span class="default"></span>)</span> <span class="paren5">(<span class="default">car &#x27;<span class="paren6">(<span class="default"></span>)</span></span>)</span></span>)</span></span>)</span></span>)</span></span>)</span>
<span class="comment">;=&gt; &#x27;()</span></pre><p>Note that the handler procedure must somehow return non-locally out of the dynamic extent of the <tt>with-exception-handler</tt> form, because returning normally will signal yet another exception and thus result in non-termination.</p></dd>
</dl>
<dl class="defsig"><dt class="defsig" id="def:handle-exceptions"><span class="sig"><tt>(handle-exceptions var handle-expr expr1 expr2 ...)</tt></span> <span class="type">syntax</span></dt>
<dd class="defsig"><p>Evaluates the body expressions <i>expr1</i>, <i>expr2</i>, ... in sequence with an exception handler constructed from <i>var</i> and <i>handle-expr</i>. Assuming no exception is raised, the result(s) of the last body expression is(are) the result(s) of the <tt>handle-exceptions</tt> expression.</p><p>The exception handler created by <tt>handle-exceptions</tt> restores the dynamic context (continuation, exception handler, etc.) of the <tt>handle-exceptions</tt> expression, and then evaluates <i>handle-expr</i> with <i>var</i> bound to the value provided to the handler.</p><p>Examples:</p>
<pre class="highlight colorize"><span class="paren1">(<span class="default">handle-exceptions exn
		   <span class="paren2">(<span class="default">begin
		     <span class="paren3">(<span class="default">display <span class="string">&quot;Went wrong&quot;</span></span>)</span>
		     <span class="paren3">(<span class="default">newline</span>)</span></span>)</span>
 <span class="paren2">(<span class="default">car &#x27;<span class="paren3">(<span class="default"></span>)</span></span>)</span></span>)</span>
<span class="comment">; displays &quot;Went wrong&quot;
</span> 
<span class="paren1">(<span class="default">handle-exceptions exn 
		   <span class="paren2">(<span class="default"><i><span class="symbol">cond</span></i>
		    <span class="paren3">(<span class="default"><span class="paren4">(<span class="default">eq? exn &#x27;one</span>)</span> 1</span>)</span>
		     <span class="paren3">(<span class="default">else <span class="paren4">(<span class="default">abort exn</span>)</span></span>)</span></span>)</span>
  <span class="paren2">(<span class="default">case <span class="paren3">(<span class="default">random 3</span>)</span>
   <span class="paren3">[<span class="default"><span class="paren4">(<span class="default">0</span>)</span> &#x27;zero</span>]</span>
   <span class="paren3">[<span class="default"><span class="paren4">(<span class="default">1</span>)</span> <span class="paren4">(<span class="default">abort &#x27;one</span>)</span></span>]</span>
   <span class="paren3">[<span class="default">else <span class="paren4">(<span class="default">abort <span class="string">&quot;Something else&quot;</span></span>)</span></span>]</span></span>)</span></span>)</span>
<span class="comment">;=&gt; &#x27;zero, 1, or (abort &quot;Something else&quot;)</span></pre></dd>
</dl>
<h3 id="sec:Raising_Exceptions"><a href="#sec:Raising_Exceptions">Raising Exceptions</a></h3><dl class="defsig"><dt class="defsig" id="def:abort"><span class="sig"><tt>(abort obj)</tt></span> <span class="type">procedure</span></dt>
<dd class="defsig"><p>Raises a non-continuable exception represented by <i>obj</i>. The <tt>abort</tt> procedure can be implemented as follows:</p>
<pre class="highlight colorize"><span class="paren1">(<span class="default"><i><span class="symbol">define</span></i> <span class="paren2">(<span class="default">abort obj</span>)</span>
  <span class="paren2">(<span class="default"><span class="paren3">(<span class="default">current-exception-handler</span>)</span> obj</span>)</span>
  <span class="paren2">(<span class="default">abort <span class="paren3">(<span class="default">make-property-condition
	   &#x27;exn
	   &#x27;message
	   <span class="string">&quot;Exception handler returned&quot;</span></span>)</span></span>)</span></span>)</span></pre><p>The <tt>abort</tt> procedure does not ensure that its argument is a condition. If its argument is a condition, <tt>abort</tt> does not ensure that the condition indicates a non-continuable exception.</p></dd>
</dl>
<dl class="defsig"><dt class="defsig" id="def:signal"><span class="sig"><tt>(signal obj)</tt></span> <span class="type">procedure</span></dt>
<dd class="defsig"><p>Raises a continuable exception represented by <i>obj</i>. The <tt>signal</tt> procedure can be implemented as follows:</p>
<pre class="highlight colorize"><span class="paren1">(<span class="default"><i><span class="symbol">define</span></i> <span class="paren2">(<span class="default">signal exn</span>)</span>
 <span class="paren2">(<span class="default"><span class="paren3">(<span class="default">current-exception-handler</span>)</span> exn</span>)</span></span>)</span></pre><p>The <tt>signal</tt> procedure does not ensure that its argument is a condition. If its argument is a condition, <tt>signal</tt> does not ensure that the condition indicates a continuable exception.</p></dd>
</dl>
<h3 id="sec:Condition_Objects"><a href="#sec:Condition_Objects">Condition Objects</a></h3><dl class="defsig"><dt class="defsig" id="def:condition.3f"><span class="sig"><tt>(condition? obj)</tt></span> <span class="type">procedure</span></dt>
<dd class="defsig"><p>Returns #t if <i>obj</i> is a condition, otherwise returns #f. If any of the predicates listed in Section 3.2 of the R5RS is true of <i>obj</i>, then <tt>condition?</tt> is false of <i>obj</i>.</p><p>Rationale: Any Scheme object may be passed to an exception handler. This would cause ambiguity if conditions were not disjoint from all of Scheme's standard types.</p></dd>
</dl>
<dl class="defsig"><dt class="defsig" id="def:make-property-condition"><span class="sig"><tt>(make-property-condition kind-key prop-key value ...)</tt></span> <span class="type">procedure</span></dt>
<dd class="defsig"><p>This procedure accepts any even number of arguments after <i>kind-key</i>, which are regarded as a sequence of alternating <i>prop-key</i> and <i>value</i> objects. Each <i>prop-key</i> is regarded as the name of a property, and each <i>value</i> is regarded as the value associated with the <i>key</i> that precedes it. Returns a <i>kind-key</i> condition that associates the given <i>prop-key</i>s with the given <i>value</i>s.</p></dd>
</dl>
<dl class="defsig"><dt class="defsig" id="def:make-composite-condition"><span class="sig"><tt>(make-composite-condition condition ...)</tt></span> <span class="type">procedure</span></dt>
<dd class="defsig"><p>Returns a newly-allocated condition whose components correspond to the the given <i>condition</i>s. A predicate created by <tt>condition-predicate</tt> returns true for the new condition if and only if it returns true for one or more of its component conditions.</p></dd>
</dl>
<dl class="defsig"><dt class="defsig" id="def:condition-predicate"><span class="sig"><tt>(condition-predicate kind-key)</tt></span> <span class="type">procedure</span></dt>
<dd class="defsig"><p>Returns a predicate that can be called with any object as its argument. Given a condition that was created by <tt>make-property-condition</tt>, the predicate returns #t if and only if <i>kind-key</i> is EQV? to the kind key that was passed to <tt>make-property-condition</tt>. Given a composite condition created with <tt>make-composite-condition</tt>, the predicate returns #t if and only if the predicate returns #t for at least one of its components.</p></dd>
</dl>
<dl class="defsig"><dt class="defsig" id="def:condition-property-accessor"><span class="sig"><tt>(condition-property-accessor kind-key prop-key [default])</tt></span> <span class="type">procedure</span></dt>
<dd class="defsig"><p>Returns a procedure that can be called with any condition that satisfies <tt>(condition-predicate ''kind-key'')</tt>. Given a condition that was created by <tt>make-property-condition</tt> and <i>kind-key</i>, the procedure returns the value that is associated with <i>prop-key</i>. Given a composite condition created with <tt>make-composite-condition</tt>, the procedure returns the value that is associated with <i>prop-key</i> in one of the components that satisfies <tt>(condition-predicate ''kind-key'')</tt>.</p><p>On Chicken, this procedure accepts an optional third argument DEFAULT. If the condition does not have a value for the desired property and if the optional argument is given, no error is signaled and the accessor returns the third argument.</p><p>When the system raises an exception, the condition it passes to the exception handler includes the <tt>'exn</tt> kind with the following properties:</p><dl><dt>message</dt>
<dd>the error message</dd><dt>arguments</dt>
<dd>the arguments passed to the exception handler</dd><dt>location</dt>
<dd>the name of the procedure where the error occurred (if available)</dd></dl>
<p>Thus, if <i>exn</i> is a condition representing a system exception, then</p>
<pre class="highlight colorize"> <span class="paren1">(<span class="default"><span class="paren2">(<span class="default">condition-property-accessor &#x27;exn &#x27;message</span>)</span> exn</span>)</span></pre><p>extracts the error message from <i>exn</i>. Example:</p>
<pre class="highlight colorize"><span class="paren1">(<span class="default">handle-exceptions exn 
		   <span class="paren2">(<span class="default">begin
		     <span class="paren3">(<span class="default">display <span class="string">&quot;Went wrong: &quot;</span></span>)</span>
		     <span class="paren3">(<span class="default">display
		      <span class="paren4">(<span class="default"><span class="paren5">(<span class="default">condition-property-accessor &#x27;exn &#x27;message</span>)</span> exn</span>)</span></span>)</span>
		     <span class="paren3">(<span class="default">newline</span>)</span></span>)</span>
 <span class="paren2">(<span class="default">car &#x27;<span class="paren3">(<span class="default"></span>)</span></span>)</span></span>)</span>
<span class="comment">; displays something like &quot;Went wrong: can&#x27;t take car of nil&quot;</span></pre></dd>
</dl>
<h3 id="sec:More_Examples"><a href="#sec:More_Examples">More Examples</a></h3>
<pre class="highlight colorize"><span class="paren1">(<span class="default"><i><span class="symbol">define</span></i> <span class="paren2">(<span class="default">try-car v</span>)</span>
 <span class="paren2">(<span class="default"><i><span class="symbol">let</span></i> <span class="paren3">(<span class="default"><span class="paren4">(<span class="default">orig <span class="paren5">(<span class="default">current-exception-handler</span>)</span></span>)</span></span>)</span>
   <span class="paren3">(<span class="default"><i><span class="symbol">with-exception-handler</span></i>
    <span class="paren4">(<span class="default"><i><span class="symbol">lambda</span></i> <span class="paren5">(<span class="default">exn</span>)</span>
      <span class="paren5">(<span class="default">orig <span class="paren6">(<span class="default">make-composite-condition
	     <span class="paren1">(<span class="default">make-property-condition
	      &#x27;not-a-pair
	      &#x27;value
	      v</span>)</span>
	     exn</span>)</span></span>)</span></span>)</span>
    <span class="paren4">(<span class="default"><i><span class="symbol">lambda</span></i> <span class="paren5">(<span class="default"></span>)</span> <span class="paren5">(<span class="default">car v</span>)</span></span>)</span></span>)</span></span>)</span></span>)</span>
 
<span class="paren1">(<span class="default">try-car &#x27;<span class="paren2">(<span class="default">1</span>)</span></span>)</span>
<span class="comment">;=&gt; 1
</span>
<span class="paren1">(<span class="default">handle-exceptions exn
		   <span class="paren2">(<span class="default"><i><span class="symbol">if</span></i> <span class="paren3">(<span class="default"><span class="paren4">(<span class="default">condition-predicate &#x27;not-a-pair</span>)</span> exn</span>)</span>
		       <span class="paren3">(<span class="default">begin
			<span class="paren4">(<span class="default">display <span class="string">&quot;Not a pair: &quot;</span></span>)</span>
			<span class="paren4">(<span class="default">display
			 <span class="paren5">(<span class="default"><span class="paren6">(<span class="default">condition-property-accessor &#x27;not-a-pair &#x27;value</span>)</span> exn</span>)</span></span>)</span>
			<span class="paren4">(<span class="default">newline</span>)</span></span>)</span>
		       <span class="paren3">(<span class="default">abort exn</span>)</span></span>)</span>
  <span class="paren2">(<span class="default">try-car 0</span>)</span></span>)</span>
<span class="comment">; displays &quot;Not a pair: 0&quot;
</span>
<span class="paren1">(<span class="default"><i><span class="symbol">let*</span></i> <span class="paren2">(<span class="default"><span class="paren3">(<span class="default">cs-key <span class="paren4">(<span class="default">list &#x27;color-scheme</span>)</span></span>)</span>
       <span class="paren3">(<span class="default">bg-key <span class="paren4">(<span class="default">list &#x27;background</span>)</span></span>)</span>
       <span class="paren3">(<span class="default">color-scheme? <span class="paren4">(<span class="default">condition-predicate cs-key</span>)</span></span>)</span>
       <span class="paren3">(<span class="default">color-scheme-background 
	<span class="paren4">(<span class="default">condition-property-accessor cs-key bg-key</span>)</span></span>)</span>
       <span class="paren3">(<span class="default">condition1 <span class="paren4">(<span class="default">make-property-condition cs-key bg-key &#x27;green</span>)</span></span>)</span>
       <span class="paren3">(<span class="default">condition2 <span class="paren4">(<span class="default">make-property-condition cs-key bg-key &#x27;blue</span>)</span></span>)</span>
       <span class="paren3">(<span class="default">condition3 <span class="paren4">(<span class="default">make-composite-condition condition1 condition2</span>)</span></span>)</span></span>)</span>
  <span class="paren2">(<span class="default">and <span class="paren3">(<span class="default">color-scheme? condition1</span>)</span>
       <span class="paren3">(<span class="default">color-scheme? condition2</span>)</span>
       <span class="paren3">(<span class="default">color-scheme? condition3</span>)</span>
       <span class="paren3">(<span class="default">color-scheme-background condition3</span>)</span></span>)</span></span>)</span>
<span class="comment">; =&gt; &#x27;green or &#x27;blue</span></pre><hr /><p>Previous: <a href="Parameters.html">Parameters</a> Next: <a href="Unit%20library.html">Unit library</a></p></div></div></body>

APT Browse - Built by Thomas Orozco.