source: project/wiki/man/4/Non-standard macros and special forms @ 25875

Last change on this file since 25875 was 25875, checked in by felix winkelmann, 9 years ago

merged some manual changes from master into wiki

File size: 21.1 KB
Line 
1[[tags: manual]]
2
3[[toc:]]
4
5== Non-standard macros and special forms
6
7=== Making extra libraries and extensions available
8
9==== require-library
10
11<macro>(require-library ID ...)</macro>
12
13This form does all the necessary steps to make the libraries or extensions given
14in {{ID ...}} available. It loads syntactic extensions, if needed and generates
15code for loading/linking with core library modules or separately installed
16extensions.
17
18During interpretation/evaluation {{require-library}} performs one of the
19following:
20
21* If {{ID}} names a built-in feature {{chicken srfi-0 srfi-2 srfi-6 srfi-8 srfi-9 srfi-10 srfi-17 srfi-23 srfi-30 srfi-39 srfi-55}}, then nothing is done.
22* If {{ID}} names one of the syntactic extensions {{chicken-syntax chicken-ffi-syntax}}, then this extension will be loaded.
23* If {{ID}} names one of the core library units shipped with CHICKEN, then a {{(load-library 'ID)}} will be performed.
24* If {{ID}} names an installed extension with the {{syntax}} or {{require-at-runtime}} attribute, then the extensions is loaded at compile-time, probably doing a run-time {{(require ...)}} for any run-time requirements.
25* Otherwise, {{(require-library ID)}} is equivalent to {{(require 'ID)}}.
26
27During compilation, one of the following happens instead:
28
29* If {{ID}} names a built-in feature {{chicken srfi-0 srfi-2 srfi-6 srfi-8 srfi-9 srfi-10 srfi-17 srfi-23 srfi-30 srfi-39 srfi-55}}, then nothing is done.
30* If {{ID}} names one of the syntactic extensions {{chicken-syntax chicken-ffi-syntax}}, then this extension will be loaded at compile-time, making the syntactic extensions available in compiled code.
31* If {{ID}} names one of the core library units shipped with CHICKEN, or if the option {{-uses ID}} has been passed to the compiler, then a {{(declare (uses ID))}} is generated.
32* If {{ID}} names an installed extension with the {{syntax}} or {{require-at-runtime}} attribute, then the extension is loaded at compile-time, and code is emitted to {{(require ...)}} any needed run-time requirements.
33* Otherwise {{(require-library ID)}} is equivalent to {{(require 'ID)}}.
34
35To make long matters short - just use {{require-library}} and it will normally figure everything out for dynamically
36loadable extensions and core library units.
37
38{{ID}} should be a pure extension name and should not contain any path prefixes (for example {{dir/lib...}}) is illegal).
39
40{{ID}} may also be a list that designates an extension-specifier. Currently the following extension specifiers are
41defined:
42
43* {{(srfi NUMBER ...)}} is required for SRFI-55 compatibility and is fully implemented
44* {{(version ID NUMBER)}} is equivalent to {{ID}}, but checks at compile-time whether the extension named {{ID}} is installed and whether its version is equal or higher than {{NUMBER}}. {{NUMBER}} may be a string or a number, the comparison is done lexicographically (using {{string>=?}}).
45
46See also: {{set-extension-specifier!}}
47
48==== require-extension
49
50<macro>(require-extension ID ...)</macro>
51
52This is equivalent to {{(require-library ID ...)}} but performs an implicit
53{{import}}, if necessary. Since version 4.4.0, {{ID}} may also be an import specification
54(using {{rename}}, {{only}}, {{except}} or {{prefix}}).
55
56This implementation of {{require-extension}} is compliant with [[http://srfi.schemers.org/srfi-55/srfi-55.html|SRFI-55]]
57(see the [[http://srfi.schemers.org/srfi-55/srfi-55.html|SRFI-55]] document for more information).
58
59==== use
60
61<macro>(use ID ...)</macro>
62
63{{use}} is just a shorter alias for {{require-extension}}.
64
65
66=== Binding forms for optional arguments
67
68==== optional
69
70<macro>(optional ARGS DEFAULT)</macro>
71
72Use this form for procedures that take a single optional argument. If
73{{ARGS}} is the empty list {{DEFAULT}} is evaluated and
74returned, otherwise the first element of the list {{ARGS}}. It is
75an error if {{ARGS}} contains more than one value.
76
77<enscript highlight=scheme>
78(define (incr x . i) (+ x (optional i 1)))
79(incr 10)                                   ==> 11
80(incr 12 5)                                 ==> 17
81</enscript>
82==== case-lambda
83
84<macro>(case-lambda (LAMBDA-LIST1 EXP1 ...) ...)</macro>
85
86Expands into a lambda that invokes the body following the first
87matching lambda-list.
88
89<enscript highlight=scheme>
90(define plus
91  (case-lambda
92    (() 0)
93    ((x) x)
94    ((x y) (+ x y))
95    ((x y z) (+ (+ x y) z))
96    (args (apply + args))))
97
98(plus)                      ==> 0
99(plus 1)                    ==> 1
100(plus 1 2 3)                ==> 6
101</enscript>
102
103For more information see the documentation for
104[[http://srfi.schemers.org/srfi-16/srfi-16.html|SRFI-16]]
105
106==== let-optionals
107
108<macro> (let-optionals ARGS ((VAR1 DEFAULT1) ...) BODY ...)</macro>
109
110Binding constructs for optional procedure arguments. {{ARGS}} should
111be a rest-parameter taken from a lambda-list. {{let-optionals}}
112binds {{VAR1 ...}} to available arguments in parallel, or
113to {{DEFAULT1 ...}} if not enough arguments were provided.
114{{let-optionals*}} binds {{VAR1 ...}} sequentially, so every
115variable sees the previous ones. it is an error if any excess
116arguments are provided.
117
118<enscript highlight=scheme>
119(let-optionals '(one two) ((a 1) (b 2) (c 3))
120  (list a b c) )                               ==> (one two 3)
121</enscript>
122
123==== let-optionals*
124
125<macro> (let-optionals* ARGS ((VAR1 DEFAULT1) ... [RESTVAR]) BODY ...)</macro>
126
127Binding constructs for optional procedure arguments. {{ARGS}} should
128be a rest-parameter taken from a lambda-list. {{let-optionals}}
129binds {{VAR1 ...}} to available arguments in parallel, or
130to {{DEFAULT1 ...}} if not enough arguments were provided.
131{{let-optionals*}} binds {{VAR1 ...}} sequentially, so every
132variable sees the previous ones. If a single variable {{RESTVAR}}
133is given, then it is bound to any remaining arguments, otherwise it is
134an error if any excess arguments are provided.
135
136<enscript highlight=scheme>
137(let-optionals* '(one two) ((a 1) (b 2) (c a))
138  (list a b c) )                               ==> (one two one)
139</enscript>
140
141
142=== Other binding forms
143
144==== and-let*
145
146<macro>(and-let* (BINDING ...) EXP1 EXP2 ...)</macro>
147
148SRFI-2. Bind sequentially and execute body. {{BINDING}} can
149be a list of a variable and an expression, a list with a single
150expression, or a single variable. If the value of an expression
151bound to a variable is {{#f}}, the {{and-let*}} form
152evaluates to {{#f}} (and the subsequent bindings and the body
153are not executed).  Otherwise the next binding is performed. If
154all bindings/expressions evaluate to a true result, the body is
155executed normally and the result of the last expression is the
156result of the {{and-let*}} form. See also the documentation for
157[[http://srfi.schemers.org/srfi-2/srfi-2.html|SRFI-2]].
158
159==== rec
160
161<macro>(rec NAME EXPRESSION)</macro><br>
162<macro>(rec (NAME VARIABLE ...) BODY ...)</macro>
163
164Allows simple definition of recursive definitions. {{(rec NAME EXPRESSION)}} is
165equivalent to {{(letrec ((NAME EXPRESSION)) NAME)}} and {{(rec (NAME VARIABLE ...) BODY ...)}}
166is the same as {{(letrec ((NAME (lambda (VARIABLE ...) BODY ...))) NAME)}}.
167
168==== cut
169
170<macro>(cut SLOT ...)</macro><br>
171<macro>(cute SLOT ...)</macro>
172
173[[http://srfi.schemers.org/srfi-26/srfi-26.html|Syntactic sugar for specializing parameters]].
174
175==== define-values
176
177<macro>(define-values (NAME ...) EXP)</macro>
178
179Defines several variables at once, with the result values of expression
180{{EXP}}.
181
182==== fluid-let
183
184<macro>(fluid-let ((VAR1 X1) ...) BODY ...)</macro>
185
186Binds the variables {{VAR1 ...}} dynamically to the values {{X1 ...}}
187during execution of {{BODY ...}}.
188This implements [[http://srfi.schemers.org/srfi-15/srfi-15.html|SRFI-15]].
189
190==== let-values
191
192<macro>(let-values (((NAME ...) EXP) ...) BODY ...)</macro>
193
194Binds multiple variables to the result values of {{EXP ...}}.
195All variables are bound simultaneously.
196This implements [[http://srfi.schemers.org/srfi-11/srfi-11.html|SRFI-11]].
197
198==== let*-values
199
200<macro>(let*-values (((NAME ...) EXP) ...) BODY ...)</macro>
201
202Binds multiple variables to the result values of {{EXP ...}}.
203The variables are bound sequentially.
204This is also part of [[http://srfi.schemers.org/srfi-11/srfi-11.html|SRFI-11]].
205
206<enscript highlight=scheme>
207(let*-values (((a b) (values 2 3))
208              ((p) (+ a b)) )
209  p)                               ==> 5
210</enscript>
211
212==== letrec-values
213
214<macro>(letrec-values (((NAME ...) EXP) ...) BODY ...)</macro>
215
216Binds the result values of {{EXP ...}} to multiple variables at once.
217All variables are mutually recursive.
218
219<enscript highlight=scheme>
220(letrec-values (((odd even)
221                   (values
222                     (lambda (n) (if (zero? n) #f (even (sub1 n))))
223                     (lambda (n) (if (zero? n) #t (odd (sub1 n)))) ) ) )
224  (odd 17) )                           ==> #t
225</enscript>
226
227==== parameterize
228
229<macro>(parameterize ((PARAMETER1 X1) ...) BODY ...)</macro>
230
231Binds the parameters {{PARAMETER1 ...}} dynamically to the values
232{{X1 ...}} during execution of {{BODY ...}}.  (see also:
233{{make-parameter}} in [[Parameters]]). Note that {{PARAMETER}} may be any
234expression that evaluates to a parameter procedure.
235
236==== receive
237
238<macro>(receive (NAME ...) VALUEEXP BODY ...)</macro><br>
239<macro>(receive (NAME1 ... NAMEn . NAMEn+1) VALUEEXP BODY ...)</macro><br>
240<macro>(receive VALUEEXP)</macro>
241
242[[http://srfi.schemers.org/srfi-8/srfi-8.html|SRFI-8]].
243Syntactic sugar for {{call-with-values}}. Binds variables
244to the result values of {{VALUEEXP}} and evaluates {{BODY ...}}.
245
246{{(receive VALUEEXP)}} is equivalent to {{(receive _ VALUEEXP _)}}.
247
248==== set!-values
249
250<macro>(set!-values (NAME ...) EXP)</macro>
251
252Assigns the result values of expression {{EXP}} to multiple
253variables.
254
255=== Substitution forms and macros
256
257==== define-constant
258
259<macro>(define-constant NAME CONST)</macro>
260
261Define a variable with a constant value, evaluated at compile-time.
262Any reference to such a constant should appear textually '''after'''
263its definition. This construct is equivalent to {{define}} when
264evaluated or interpreted.  Constant definitions should only appear at
265toplevel. Note that constants are local to the current compilation
266unit and are not available outside of the source file in which they
267are defined. Names of constants still exist in the Scheme namespace
268and can be lexically shadowed.  If the value is mutable, then the
269compiler is careful to preserve its identity.  {{CONST}} may be any
270constant expression, and may also refer to constants defined via
271{{define-constant}} previously, but it must be possible to
272evaluate the expression at compile-time.
273
274==== define-inline
275
276<macro>(define-inline (NAME VAR ...) BODY ...)</macro><br>
277<macro>(define-inline (NAME VAR1 ... VARn . VARn+1) BODY ...)</macro><br>
278<macro>(define-inline NAME EXP)</macro>
279
280Defines an inline procedure. Any occurrence of {{NAME}} will be
281replaced by {{EXP}} or {{(lambda (VAR ... [. VAR]) BODY ...)}}.
282This is similar to a macro, but variable-names and -scope will
283be correctly handled.  Inline substitutions take place '''after'''
284macro-expansion.  {{EXP}} should be a lambda-expression. Any
285reference to {{NAME}} should appear textually '''after'''
286its definition. Note that inline procedures are local to the current
287compilation unit and are not available outside of the source file in
288which they are defined. Names of inline procedures still exist in the
289Scheme namespace and can be lexically shadowed.  This construct is
290equivalent to {{define}} when evaluated or interpreted. Inline
291definitions should only appear at toplevel.
292
293==== define-for-syntax
294
295<macro>(define-for-syntax (NAME VAR ...) EXP1 ...)</macro><br>
296<macro>(define-for-syntax (NAME VAR1 ... VARn . VARn+1) EXP1 ...)</macro><br>
297<macro>(define-for-syntax NAME [VALUE])</macro>
298
299Defines the toplevel variable {{NAME}} at macro-expansion time. This can
300be helpful when you want to define support procedures for use in macro-transformers,
301for example.
302
303Note that {{define-for-syntax}} definitions within a module are implicitly
304added to that module's import library. Refer to the documentation on
305[[/man/4/Modules#import-libraries|import libraries]] for more information.
306
307==== define-compiler-syntax
308
309<macro>(define-compiler-syntax NAME)</macro><br>
310<macro>(define-compiler-syntax NAME TRANSFORMER)</macro><br>
311<macro>(define-compiler-syntax (NAME VAR ...) BODY ...)</macro>
312
313Defines what is usually called a ''compiler macro'' in Lisp: {{NAME}} should be the
314name of a globally or locally bound procedure. Any direct call to this procedure
315will be transformed before compilation, which allows arbitrary rewritings
316of function calls.
317
318{{TRANSFORMER}} can be a {{syntax-rules}} expression or an explicit-renaming transformer
319procedure. Returning the original form in an explicit-renaming macro or simply
320"falling trough" all patterns in a {{syntax-rules}} form will keep the original
321expression and compile it normally.
322
323In the interpreter this form does nothing and returns an unspecified value.
324
325Compiler-syntax is always local to the current compilation unit and can not be
326exported. Compiler-syntax defined inside a module is not visible outside of that
327module.
328
329{{define-compiler-syntax}} should only be used at top-level. Local compiler-syntax
330can be defined with {{let-compiler-syntax}}.
331
332<enscript highlight=scheme>
333(define-compiler-syntax +
334  (syntax-rules ()
335    ((_) 1)
336    ((_ x 0) x) ) )
337</enscript>
338
339If no transformer is given, then {{(define-compiler-syntax NAME)}} removes
340any compiler-syntax definitions for {{NAME}}.
341
342
343==== let-compiler-syntax
344
345<macro>(let-compiler-syntax ((NAME [TRANSFORMER]) ...) BODY ...)</macro>
346
347Allows definition local compiler macros, which are only applicable inside {{BODY ...}}.
348By not providing a {{TRANSFORMER}} expression, compiler-syntax for specific identifiers
349can be temporarily disabled.
350
351
352=== Conditional forms
353
354==== select
355
356<macro>(select EXP ((KEY ...) EXP1 ...) ... [(else EXPn ...)])</macro>
357
358This is similar to {{case}}, but the keys are evaluated.
359
360==== unless
361
362<macro>(unless TEST EXP1 EXP2 ...)</macro>
363
364Equivalent to:
365
366<enscript highlight=scheme>
367(if (not TEST) (begin EXP1 EXP2 ...))
368</enscript>
369
370==== when
371
372<macro>(when TEST EXP1 EXP2 ...)</macro>
373
374Equivalent to:
375
376<enscript highlight=scheme>
377(if TEST (begin EXP1 EXP2 ...))
378</enscript>
379
380
381=== Record structures
382
383==== define-record
384
385<macro>(define-record NAME SLOTNAME ...)</macro>
386
387Defines a record type. Call {{make-NAME}} to create an instance
388of the structure (with one initialization-argument for each slot).
389{{(NAME? STRUCT)}} tests any object for being an instance of this
390structure.  Slots are accessed via {{(NAME-SLOTNAME STRUCT)}}
391and updated using {{(NAME-SLOTNAME-set!}} {{STRUCT}} {{VALUE)}}.
392
393<enscript highlight=scheme>
394(define-record point x y)
395(define p1 (make-point 123 456))
396(point? p1)                      ==> #t
397(point-x p1)                     ==> 123
398(point-y-set! p1 99)
399(point-y p1)                     ==> 99
400</enscript>
401
402{{SLOTNAME}} may alternatively also be of the form
403
404  (setter SLOTNAME)
405
406In this case the slot can be read with {{(NAME-SLOTNAME STRUCT)}}
407and written with {{(set! (NAME-SLOTNAME STRUCT) VALUE)}} (the slot-accessor
408has an associated SRFI-17 "setter" procedure).
409
410==== define-record-type
411
412<macro>(define-record-type NAME (CONSTRUCTOR TAG ...) PREDICATE (FIELD ACCESSOR [MODIFIER]) ...)</macro>
413
414SRFI-9 record types. For more information see the documentation for
415[[http://srfi.schemers.org/srfi-9/srfi-9.html|SRFI-9]].
416
417As an extension the {{MODIFIER}} may have the form {{(setter PROCEDURE)}},
418which will define a SRFI-17 setter-procedure for the given {{PROCEDURE}}
419that sets the field value. Usually {{PROCEDURE}} has the same name
420is {{ACCESSOR}} (but it doesn't have to).
421
422
423==== define-record-printer
424
425<macro>(define-record-printer (NAME RECORDVAR PORTVAR) BODY ...)</macro><br>
426<macro>(define-record-printer NAME PROCEDURE)</macro>
427
428Defines a printing method for record of the type {{NAME}} by
429associating a procedure with the record type. When a record of this
430type is written using {{display, write}} or {{print}}, then
431the procedure is called with two arguments: the record to be printed
432and an output-port.
433
434<enscript highlight=scheme>
435(define-record-type foo (make-foo x y z) foo?
436  (x foo-x)
437  (y foo-y)
438  (z foo-z))
439(define f (make-foo 1 2 3))
440(define-record-printer (foo x out)
441  (fprintf out "#,(foo ~S ~S ~S)"
442           (foo-x x) (foo-y x) (foo-z x)) )
443(define-reader-ctor 'foo make-foo)
444(define s (with-output-to-string
445              (lambda () (write f))))
446s                                   ==> "#,(foo 1 2 3)"
447(equal? f (with-input-from-string
448              s read)))             ==> #t
449</enscript>
450
451=== Other forms
452
453==== assert
454
455<macro>(assert EXP [STRING ARG ...])</macro>
456
457Signals an error if {{EXP}} evaluates to false. An optional message
458{{STRING}} and arguments {{ARG ...}} may be supplied to give a
459more informative error-message.  If compiled in ''unsafe'' mode (either
460by specifying the {{-unsafe}} compiler option or by declaring
461{{(unsafe)}}), then this expression expands to an unspecified value.
462The result is the value of {{EXP}}.
463
464
465==== begin-for-syntax
466
467<macro>(begin-for-syntax EXP ...)</macro>
468
469Equivalent to {{(begin EXP ...)}}, but performs the evaluation of
470the expression during macro-expansion time.
471
472
473==== cond-expand
474
475<macro>(cond-expand FEATURE-CLAUSE ...)</macro>
476
477Expands by selecting feature clauses. This form is allowed to appear in non-toplevel expressions.
478
479Predefined feature-identifiers are "situation" specific:
480
481; compile : {{chicken}}, {{compiling}}, {{library}}, {{eval}}, {{extras}}, {{utils}}, {{regex}}, {{srfi-0}}, {{srfi-1}}, {{srfi-2}}, {{srfi-4}}, {{srfi-6}}, {{srfi-8}}, {{srfi-9}}, {{srfi-10}}, {{srfi-11}}, {{srfi-12}}, {{srfi-15}}, {{srfi-16}}, {{srfi-17}}, {{srfi-23}}, {{srfi-26}}, {{srfi-28}}, {{srfi-30}}, {{srfi-31}}, {{srfi-39}}, {{srfi-55}}, {{srfi-61}}, {{srfi-62}}, {{srfi-69}}
482
483; load : {{chicken}}, {{extras}}, {{srfi-0}}, {{srfi-2}}, {{srfi-6}}, {{srfi-8}}, {{srfi-9}}, {{srfi-10}}, {{srfi-12}}, {{srfi-17}}, {{srfi-23}}, {{srfi-28}}, {{srfi-30}}, {{srfi-39}}, {{srfi-55}}, {{srfi-61}}, {{srfi-62}}, {{srfi-69}}. {{library}} is implicit.
484
485; eval : {{csi}}, {{chicken}}, {{extras}}, {{srfi-0}}, {{srfi-2}}, {{srfi-6}}, {{srfi-8}}, {{srfi-9}}, {{srfi-10}}, {{srfi-11}}, {{srfi-12}}, {{srfi-15}}, {{srfi-16}}, {{srfi-17}}, {{srfi-23}}, {{srfi-26}}, {{srfi-28}}, {{srfi-30}}, {{srfi-31}}, {{srfi-39}}, {{srfi-55}}, {{srfi-61}}, {{srfi-62}}, {{srfi-69}}. {{library}} is implicit.
486
487The following feature-identifier classes are available in all situations:
488{{(machine-byte-order)}}, {{(machine-type)}}, {{(software-type)}},
489{{(software-version)}}, where the actual feature-identifier is platform
490dependent.
491
492In addition the following feature-identifiers may exist: {{cross-chicken}},
493{{dload}}, {{manyargs}}, {{ptables}}.
494
495For further information, see the documentation for
496[[http://srfi.schemers.org/srfi-0/srfi-0.html|SRFI-0]].
497
498==== ensure
499
500<macro>(ensure PREDICATE EXP [ARGUMENTS ...])</macro>
501
502Evaluates the expression {{EXP}} and applies the one-argument
503procedure {{PREDICATE}} to the result. If the predicate returns
504{{#f}} an error is signaled, otherwise the result of {{EXP}}
505is returned.  If compiled in ''unsafe'' mode (either by specifying
506the {{-unsafe}} compiler option or by declaring {{(unsafe)}}),
507then this expression expands to an unspecified value.  If specified,
508the optional {{ARGUMENTS}} are used as arguments to the invocation
509of the error-signalling code, as in {{(error ARGUMENTS ...)}}. If
510no {{ARGUMENTS}} are given, a generic error message is displayed
511with the offending value and {{PREDICATE}} expression.
512
513==== eval-when
514
515<macro>(eval-when (SITUATION ...) EXP ...)</macro>
516
517Controls evaluation/compilation of subforms. {{SITUATION}} should
518be one of the symbols {{eval}}, {{compile}} or {{load}}.
519When encountered in the evaluator, and the situation specifier
520{{eval}} is not given, then this form is not evaluated and an
521unspecified value is returned.  When encountered while compiling code,
522and the situation specifier {{compile}} is given, then this form is
523evaluated at compile-time.  When encountered while compiling code, and the
524situation specifier {{load}} is not given, then this form is ignored
525and an expression resulting into an unspecified value is compiled instead.
526
527The following table should make this clearer:
528
529<table>
530<tr><th></th><th>In compiled code</th><th>In interpreted code</th></tr>
531<tr><td>{{eval}}</td><td>ignore</td><td>evaluate</td></tr>
532<tr><td>{{compile}}</td><td>evaluate at compile time</td><td>ignore</td></tr>
533<tr><td>{{load}}</td><td>compile as normal</td><td>ignore</td></tr>
534</table>
535
536==== include
537
538<macro>(include STRING)</macro>
539
540Include toplevel-expressions from the given source file in the currently
541compiled/interpreted program.  If the included file has the extension
542{{.scm}}, then it may be omitted.  The file is searched in the
543current directory and, if not found, in all directories specified in the
544{{-include-path}} option.
545
546==== nth-value
547
548<macro>(nth-value N EXP)</macro>
549
550Returns the {{N}}th value (counting from zero) of the values returned
551by expression {{EXP}}.
552
553==== time
554
555<macro>(time EXP1 ...)</macro>
556
557Performs a major garbage collection, evaluates {{EXP1 ...}} and prints
558elapsed CPU time and some values about GC use, like time spent in major
559GCs, number of minor and major GCs. The output is sent to the port
560that is the current value of {{(current-error-port)}}. Nested invocations
561of this form will give incorrect results for all output but the innermost.
562
563---
564Previous: [[Non-standard read syntax]]
565
566Next: [[Macros]]
Note: See TracBrowser for help on using the repository browser.