Debian Codegraph @

libsrc/util/match.scm

raw
1 ;;
2 ;; util.match - Andrew Wright's pattern matching macro.
3 ;;
4 ;; Ported to Gauche by Shiro Kawai. Public domain.
5 ;; Modified to work with Gauche's object system instead of the original
6 ;; structure model.
7 ;;
8
9 (define-module util.match
10 (export match
11 match-lambda
12 match-lambda*
13 match-let
14 match-let*
15 match-letrec
16 match-let1
17 match-define
18 match:$-ref
19 |setter of match:$-ref|
20 match:every
21 match:error))
22 (select-module util.match)
23
24 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
25 ;; Pattern Matching Syntactic Extensions for Scheme
26 ;;
27 (define match:version "Version 1.18, July 17, 1995")
28 ;;
29 ;; Report bugs to [email protected]. The most recent version of
30 ;; this software can be obtained by anonymous FTP from ftp.nj.nec.com
31 ;; in file pub/wright/match.tar.Z. Be sure to set "type binary" when
32 ;; transferring this file.
33 ;;
34 ;; Written by Andrew K. Wright, 1993 ([email protected]).
35 ;; Adapted from code originally written by Bruce F. Duba, 1991.
36 ;; This package also includes a modified version of Kent Dybvig's
37 ;; define-structure (see Dybvig, R.K., The Scheme Programming Language,
38 ;; Prentice-Hall, NJ, 1987).
39 ;;
40 ;; This software is in the public domain. Feel free to copy,
41 ;; distribute, and modify this software as desired. No warranties
42 ;; nor guarantees of any kind apply. Please return any improvements
43 ;; or bug fixes to [email protected] so that they may be included
44 ;; in future releases.
45 ;;
46 ;; This macro package extends Scheme with several new expression forms.
47 ;; Following is a brief summary of the new forms. See the associated
48 ;; LaTeX documentation for a full description of their functionality.
49 ;;
50 ;; [SK]: check out Gauche texinfo manual for modified spec.
51 ;;
52 ;; match expressions:
53 ;;
54 ;; exp ::= ...
55 ;; | (match exp clause ...)
56 ;; | (match-lambda clause ...)
57 ;; | (match-lambda* clause ...)
58 ;; | (match-let ((pat exp) ...) body)
59 ;; | (match-let* ((pat exp) ...) body)
60 ;; | (match-letrec ((pat exp) ...) body)
61 ;; | (match-define pat exp)
62 ;;
63 ;; clause ::= (pat body) | (pat => exp)
64 ;;
65 ;; patterns: matches:
66 ;;
67 ;; pat ::= identifier anything, and binds identifier
68 ;; | _ anything
69 ;; | () the empty list
70 ;; | #t #t
71 ;; | #f #f
72 ;; | string a string
73 ;; | number a number
74 ;; | character a character
75 ;; | keyword a keyword
76 ;; | 'sexp an s-expression
77 ;; | 'symbol a symbol (special case of s-expr)
78 ;; | (pat_1 ... pat_n) list of n elements
79 ;; | (pat_1 ... pat_n . pat_{n+1}) list of n or more
80 ;; | (pat_1 ... pat_n pat_n+1 ooo) list of n or more, each element
81 ;; of remainder must match pat_n+1
82 ;; | #(pat_1 ... pat_n) vector of n elements
83 ;; | #(pat_1 ... pat_n pat_n+1 ooo) vector of n or more, each element
84 ;; of remainder must match pat_n+1
85 ;; | #&pat box
86 ;; | ($ struct-name pat_1 ... pat_n) a structure
87 ;; | (= field pat) a field of a structure
88 ;; | (and pat_1 ... pat_n) if all of pat_1 thru pat_n match
89 ;; | (or pat_1 ... pat_n) if any of pat_1 thru pat_n match
90 ;; | (not pat_1 ... pat_n) if all pat_1 thru pat_n don't match
91 ;; | (? predicate pat_1 ... pat_n) if predicate true and all of
92 ;; pat_1 thru pat_n match
93 ;; | (set! identifier) anything, and binds setter
94 ;; | (get! identifier) anything, and binds getter
95 ;; | `qp a quasi-pattern
96 ;;
97 ;; ooo ::= ... zero or more
98 ;; | ___ zero or more
99 ;; | ..k k or more
100 ;; | __k k or more
101 ;;
102 ;; quasi-patterns: matches:
103 ;;
104 ;; qp ::= () the empty list
105 ;; | #t #t
106 ;; | #f #f
107 ;; | string a string
108 ;; | number a number
109 ;; | character a character
110 ;; | identifier a symbol
111 ;; | (qp_1 ... qp_n) list of n elements
112 ;; | (qp_1 ... qp_n . qp_{n+1}) list of n or more
113 ;; | (qp_1 ... qp_n qp_n+1 ooo) list of n or more, each element
114 ;; of remainder must match qp_n+1
115 ;; | #(qp_1 ... qp_n) vector of n elements
116 ;; | #(qp_1 ... qp_n qp_n+1 ooo) vector of n or more, each element
117 ;; of remainder must match qp_n+1
118 ;; | #&qp box
119 ;; | ,pat a pattern
120 ;; | ,@pat a pattern
121 ;;
122 ;; The names (quote, quasiquote, unquote, unquote-splicing, ?, _, $,
123 ;; and, or, not, set!, get!, ..., ___) cannot be used as pattern variables.
124 ;;
125 ;;
126 ;; match:error-control controls what code is generated for failed matches.
127 ;; Possible values:
128 ;; 'unspecified - do nothing, ie., evaluate (cond [#f #f])
129 ;; 'fail - call match:error, or die at car or cdr
130 ;; 'error - call match:error with the unmatched value
131 ;; 'match - call match:error with the unmatched value _and_
132 ;; the quoted match expression
133 ;; match:error-control is set by calling match:set-error-control with
134 ;; the new value.
135 ;;
136 ;; match:error is called for a failed match.
137 ;; match:error is set by calling match:set-error with the new value.
138 ;;
139 ;; End of user visible/modifiable stuff.
140 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
141
142 ;;; [SK] NOTE NOTE NOTE
143 ;;; match macro is unhygienic, and it is possible that it has undesired
144 ;;; interference with hygienic maros. I put certain ad-hoc hack in it
145 ;;; to avoid some unexpected behavior. It is still a hack, and ultimately
146 ;;; this should be rewritten in hygienic macro. Here's some points:
147 ;;;
148 ;;; - In patterns, treat symbols and identifiers the same as pattern vars.
149 ;;; - When inserting references to global variables defined in this module,
150 ;;; use identifiers instead of symbols.
151 ;;;
152 ;;; For the latter I needed to use make-identifier which is a private
153 ;;; procedure in gauche.internal. If you're reading this code out of
154 ;;; curiousity, DO NOT USE IT in your code. The identifier stuff may be
155 ;;; changed greatly when I implement proper low-level hygienic stuff.
156 ;;;
157 ;;; The plan is that we revise the code to use er-macro in a couple of
158 ;;; releases (we need to release er-macro support first, for util.match
159 ;;; is used to build HEAD version of source so in this module we can only
160 ;;; depend on the features available in the current release of Gauche.
161 ;;;
162
163 (define (%match-id sym)
164 ((with-module gauche.internal make-identifier) sym (current-module) '()))
165
166 (define match. (%match-id 'match))
167 (define match-let*. (%match-id 'match-let*))
168 (define match:error. (%match-id 'match:error))
169 (define match-lambda*. (%match-id 'match-lambda*))
170 (define match-letrec. (%match-id 'match-letrec))
171 (define match-define. (%match-id 'match-define))
172 (define match:length>=?. (%match-id 'match:length>=?))
173
174 (define lambda. ((with-module gauche.internal make-identifier) 'lambda
175 (find-module 'null) '()))
176
177 (define-inline (match:length>=? n) (cut length>=? <> n))
178
179 ;;; [SK] End of black magic
180
181 (define match:error
182 (lambda (val . args)
183 (errorf "~a: no matching clause for ~a"
184 (string-join (map x->string args) " ")
185 val)))
186
187 (define match:every every) ; alias gauche's every, in case the user of
188 ; util.match isn't inheriting gauche.
189
190 (define match:syntax-err
191 (lambda (obj msg) (error msg obj)))
192
193 (define match:error-control 'error)
194 (define match:set-error-control
195 (lambda (v) (set! match:error-control v)))
196
197 (define match:disjoint-predicates
198 (cons 'null
199 '(pair?
200 identifier?
201 boolean?
202 number?
203 string?
204 char?
205 procedure?
206 vector?)))
207
208 ;; These two methods are used for positional match of objects using $.
209 ;; The default is to take the order of class-slots, which is suffice for
210 ;; most cases. A metaclass can override these if desired.
211 (define-method match:$-ref ((class <class>) fnum obj)
212 (and-let1 slot (list-ref (class-slots class) fnum #f)
213 (slot-ref obj (slot-definition-name slot))))
214 (define-method (setter match:$-ref) ((class <class>) fnum obj val)
215 (and-let1 slot (list-ref (class-slots class) fnum #f)
216 (slot-set! obj (slot-definition-name slot) val)))
217
218 (define (genmatch x clauses match-expr)
219 (let* ((eb-errf (error-maker match-expr))
220 (blist (car eb-errf))
221 (plist (map (lambda (c)
222 (let* ((x (bound (validate-pattern (car c))))
223 (p (car x))
224 (bv (cadr x))
225 (bindings (caddr x))
226 (code (gensym))
227 (fail (and (pair? (cdr c))
228 (pair? (cadr c))
229 (equal? (caadr c) '=>)
230 (pair? (cdadr c))
231 (identifier? (cadadr c))
232 (null? (cddadr c))
233 (pair? (cddr c))
234 (cadadr c)))
235 (bv2 (if fail (cons fail bv) bv))
236 (body (if fail (cddr c) (cdr c))))
237 (set! blist
238 (cons `(,code (,lambda. ,bv2 ,@body))
239 (append bindings blist)))
240 (list p code bv (and fail (gensym)) #f)))
241 clauses))
242 (code (gen x '() plist (cdr eb-errf) (gensym))))
243 (unreachable plist match-expr)
244 `(let ,blist
245 ,code)))
246
247 (define (genletrec pat exp body match-expr)
248 (let* ((eb-errf (error-maker match-expr))
249 (x (bound (validate-pattern pat)))
250 (p (car x))
251 (bv (cadr x))
252 (bindings (caddr x))
253 (code (gensym))
254 (plist (list (list p code bv #f #f)))
255 (x (gensym))
256 (m (gen x '() plist (cdr eb-errf) (gensym)))
257 (gs (map (lambda (_) (gensym)) bv)))
258 (unreachable plist match-expr)
259 `(letrec (,@(map (lambda (v) `(,v #f)) bv)
260 (,x ,exp)
261 (,code (,lambda. ,gs
262 ,@(map (lambda (v g) `(set! ,v ,g)) bv gs)
263 ,@body))
264 ,@bindings
265 ,@(car eb-errf))
266 ,m)))
267
268 (define (gendefine pat exp match-expr)
269 (let* ((eb-errf (error-maker match-expr))
270 (x (bound (validate-pattern pat)))
271 (p (car x))
272 (bv (cadr x))
273 (bindings (caddr x))
274 (code (gensym))
275 (plist (list (list p code bv #f #f)))
276 (x (gensym))
277 (m (gen x '() plist (cdr eb-errf) (gensym)))
278 (gs (map (lambda (_) (gensym)) bv)))
279 (unreachable plist match-expr)
280 `(begin ,@(map (lambda (v) `(define ,v #f)) bv)
281 (let ((,x ,exp)
282 (,code (,lambda. ,gs
283 ,@(map (lambda (v g) `(set! ,v ,g)) bv gs)
284 (cond (#f #f))))
285 ,@bindings
286 ,@(car eb-errf))
287 ,m))))
288
289 (define (symbolize x)
290 (if (identifier? x) (identifier->symbol x) x))
291
292 (define (pattern-var? x)
293 (and-let* ([x (and (identifier? x)
294 (identifier->symbol x))]
295 [ (not (dot-dot-k? x)) ])
296 (not (memq x '(quasiquote quote unquote unquote-splicing
297 ? _ $ struct @ object = and or not set! get! ... ___)))))
298
299 (define (dot-dot-k? s)
300 (and (identifier? s)
301 (if (member s '(... ___))
302 0
303 (and-let* ([s (if (symbol? s) s (unwrap-syntax s))]
304 [m (#/^(?:\.\.|__)(\d+)$/ (symbol->string s))])
305 (string->number (m 1))))))
306
307 (define (error-maker match-expr)
308 (cond
309 ((eq? match:error-control 'unspecified)
310 (cons '() (lambda (x) `(cond (#f #f)))))
311 ((memq match:error-control '(error fail))
312 (cons '() (lambda (x) `(,match:error. ,x))))
313 ((eq? match:error-control 'match)
314 (let ((errf (gensym))
315 (arg (gensym)))
316 (cons `((,errf (,lambda. (,arg)
317 (,match:error. ,arg ',match-expr))))
318 (lambda (x) `(,errf ,x)))))
319 (else (match:syntax-err
320 '(unspecified error fail match)
321 "invalid value for match:error-control, legal values are"))))
322
323 (define (unreachable plist match-expr)
324 (for-each
325 (lambda (x)
326 (if (not (car (cddddr x)))
327 (warn "unreachable pattern ~a in ~a~%" (car x) match-expr)))
328 plist))
329
330 (define (validate-pattern pattern)
331 (define (simple? x)
332 (or (string? x) (boolean? x) (char? x) (number? x) (null? x)
333 ;; This last term is to support both disjoint-keyword and
334 ;; keyword-is-symbol runtime. After we fully migrated to
335 ;; keyword-is-symbol, just remove this term.
336 (and (not (symbol? :x)) (keyword? x))))
337 (define (ordinary p)
338 (let ((cons-ordinary (lambda (x y) (cons (ordinary x) (ordinary y)))))
339 (cond
340 ((simple? p) p)
341 ((equal? p '_) '_)
342 ((pattern-var? p) p)
343 ((pair? p)
344 (case (symbolize (car p))
345 ((quasiquote)
346 (if (and (pair? (cdr p)) (null? (cddr p)))
347 (quasi (cadr p))
348 (cons-ordinary (car p) (cdr p))))
349 ((quote)
350 (if (and (pair? (cdr p)) (null? (cddr p)))
351 p
352 (cons-ordinary (car p) (cdr p))))
353 ((?)
354 (if (and (pair? (cdr p)) (list? (cddr p)))
355 `(? ,(cadr p) ,@(map ordinary (cddr p)))
356 (cons-ordinary (car p) (cdr p))))
357 ((=)
358 (if (and (pair? (cdr p)) (pair? (cddr p)) (null? (cdddr p)))
359 `(= ,(cadr p) ,(ordinary (caddr p)))
360 (cons-ordinary (car p) (cdr p))))
361 ((and)
362 (if (and (list? (cdr p)) (pair? (cdr p)))
363 `(and ,@(map ordinary (cdr p)))
364 (cons-ordinary (car p) (cdr p))))
365 ((or)
366 (if (and (list? (cdr p)) (pair? (cdr p)))
367 `(or ,@(map ordinary (cdr p)))
368 (cons-ordinary (car p) (cdr p))))
369 ((not)
370 (if (and (list? (cdr p)) (pair? (cdr p)))
371 `(not ,@(map ordinary (cdr p)))
372 (cons-ordinary (car p) (cdr p))))
373 (($ struct)
374 (if (and (pair? (cdr p)) (identifier? (cadr p)) (list? (cddr p)))
375 `($ ,(cadr p) ,@(map ordinary (cddr p)))
376 (cons-ordinary (car p) (cdr p))))
377 ((@ object)
378 (if (and (pair? (cdr p)) (identifier? (cadr p)) (list? (cddr p))
379 (every (lambda (p) (and (list? p) (= (length p) 2)))
380 (cddr p)))
381 `(object ,(cadr p) ,@(map (lambda (p)
382 (list (car p) (ordinary (cadr p))))
383 (cddr p)))
384 (cons-ordinary (car p) (cdr p))))
385 ((set!)
386 (if (and (pair? (cdr p)) (pattern-var? (cadr p)) (null? (cddr p)))
387 p
388 (cons-ordinary (car p) (cdr p))))
389 ((get!)
390 (if (and (pair? (cdr p)) (pattern-var? (cadr p)) (null? (cddr p)))
391 p
392 (cons-ordinary (car p) (cdr p))))
393 ((unquote unquote-splicing)
394 (cons-ordinary (car p) (cdr p)))
395 (else
396 (if (and (pair? (cdr p))
397 (dot-dot-k? (cadr p))
398 (null? (cddr p)))
399 `(,(ordinary (car p)) ,(cadr p))
400 (cons-ordinary (car p) (cdr p))))))
401 ((vector? p)
402 (let* ((pl (vector->list p))
403 (rpl (reverse pl)))
404 (list->vector
405 (if (and (not (null? rpl)) (dot-dot-k? (car rpl)))
406 (reverse (cons (car rpl) (map ordinary (cdr rpl))))
407 (map ordinary pl)))))
408 (else (match:syntax-err
409 pattern
410 "syntax error in pattern")))))
411 (define (quasi p)
412 (let ((cons-quasi (lambda (x y) (cons (quasi x) (quasi y)))))
413 (cond
414 ((simple? p) p)
415 ((identifier? p) `',p)
416 ((pair? p)
417 (cond
418 ((eq? (car p) 'unquote)
419 (if (and (pair? (cdr p)) (null? (cddr p)))
420 (ordinary (cadr p))
421 (cons-quasi (car p) (cdr p))))
422 ((and (pair? (car p))
423 (equal? (caar p) 'unquote-splicing)
424 (pair? (cdar p))
425 (null? (cddar p)))
426 (if (null? (cdr p))
427 (ordinary (cadar p))
428 (append (ordlist (cadar p)) (quasi (cdr p)))))
429 ((and (pair? (cdr p))
430 (dot-dot-k? (cadr p))
431 (null? (cddr p)))
432 `(,(quasi (car p)) ,(cadr p)))
433 (else (cons-quasi (car p) (cdr p)))))
434 ((vector? p)
435 (let* ((pl (vector->list p))
436 (rpl (reverse pl)))
437 (list->vector
438 (if (and (not (null? rpl))
439 (dot-dot-k? (car rpl)))
440 (reverse (cons (car rpl) (map quasi (cdr rpl))))
441 (map quasi pl)))))
442 (else
443 (match:syntax-err pattern "syntax error in pattern")))))
444 (define (ordlist p)
445 (cond
446 ((null? p) '())
447 ((pair? p) (cons (ordinary (car p)) (ordlist (cdr p))))
448 (else (match:syntax-err pattern
449 "invalid use of unquote-splicing in pattern"))))
450 (ordinary pattern))
451
452 (define (bound pattern)
453 (define pred-bodies '())
454
455 (define (bound p a k)
456 (cond
457 ((eq? '_ p) (k p a))
458 ((identifier? p)
459 (when (memq p a)
460 (match:syntax-err pattern "duplicate variable in pattern"))
461 (k p (cons p a)))
462 ((and (pair? p) (equal? 'quote (car p)))
463 (k p a))
464 ((and (pair? p) (equal? '? (car p)))
465 (cond
466 ((not (null? (cddr p)))
467 (bound `(and (? ,(cadr p)) ,@(cddr p)) a k))
468 ((or (not (identifier? (cadr p)))
469 (memq (cadr p) a))
470 (let ((g (gensym)))
471 (push! pred-bodies `(,g ,(cadr p)))
472 (k `(? ,g) a)))
473 (else (k p a))))
474 ((and (pair? p) (eq? '= (car p)))
475 (cond
476 ((or (not (identifier? (cadr p)))
477 (memq (cadr p) a))
478 (let ((g (gensym)))
479 (push! pred-bodies `(,g ,(cadr p)))
480 (bound `(= ,g ,(caddr p)) a k)))
481 (else (bound (caddr p) a (lambda (p2 a) (k `(= ,(cadr p) ,p2) a))))))
482 ((and (pair? p) (eq? 'and (car p)))
483 (bound* (cdr p) a (lambda (p a) (k `(and ,@p) a))))
484 ((and (pair? p) (eq? 'or (car p)))
485 (bound (cadr p) a
486 (lambda (first-p first-a)
487 (let or* ((plist (cddr p))
488 (k (lambda (plist) (k `(or ,first-p ,@plist)
489 first-a))))
490 (if (null? plist)
491 (k plist)
492 (bound
493 (car plist)
494 a
495 (lambda (car-p car-a)
496 (if (not (permutation car-a first-a))
497 (match:syntax-err
498 pattern
499 "variables of or-pattern differ in"))
500 (or* (cdr plist)
501 (lambda (cdr-p)
502 (k (cons car-p cdr-p)))))))))))
503 ((and (pair? p) (eq? 'not (car p)))
504 (cond
505 ((not (null? (cddr p)))
506 (bound `(not (or ,@(cdr p))) a k))
507 (else
508 (bound (cadr p)
509 a
510 (lambda (p2 a2)
511 (if (not (permutation a a2))
512 (match:syntax-err p "no variables allowed in"))
513 (k `(not ,p2) a))))))
514 ((and (pair? p)
515 (pair? (cdr p))
516 (dot-dot-k? (cadr p)))
517 (bound (car p)
518 a
519 (lambda (q b)
520 (let ((bvars (find-prefix b a)))
521 (k `(,q ,(cadr p)
522 ,bvars
523 ,(gensym)
524 ,(gensym)
525 ,(map (lambda (_) (gensym)) bvars))
526 b)))))
527 ((and (pair? p) (memq (car p) '($ struct)))
528 (bound* (cddr p)
529 a
530 (lambda (p1 a)
531 (k `($ ,(cadr p) ,@p1) a))))
532 ((and (pair? p) (memq (car p) '(@ object))) ;; Gauche extension
533 (unless (and (pair? (cdr p))
534 (every (lambda (p) (and (list? p) (= (length p) 2)))
535 (cddr p)))
536 (match:syntax-err p "syntax error in pattern"))
537 (bound* (map cadr (cddr p))
538 a
539 (lambda (p1 a)
540 (k `(object ,(cadr p)
541 ,@(map (lambda (p q) (list (car p) q))
542 (cddr p) p1))
543 a))))
544 ((and (pair? p) (eq? 'set! (car p)))
545 (if (memq (cadr p) a)
546 (k p a)
547 (k p (cons (cadr p) a))))
548 ((and (pair? p) (eq? 'get! (car p)))
549 (if (memq (cadr p) a)
550 (k p a)
551 (k p (cons (cadr p) a))))
552 ((pair? p)
553 (bound (car p)
554 a
555 (lambda (car-p a)
556 (bound (cdr p)
557 a
558 (lambda (cdr-p a) (k (cons car-p cdr-p) a))))))
559 ((vector? p)
560 (boundv (vector->list p)
561 a
562 (lambda (pl a) (k (list->vector pl) a))))
563 (else (k p a))))
564
565 (define (boundv plist a k)
566 (let ((g115 (lambda () (k plist a))))
567 (if (pair? plist)
568 (if (and (pair? (cdr plist))
569 (dot-dot-k? (cadr plist))
570 (null? (cddr plist)))
571 (bound plist a k)
572 (if (null? plist)
573 (g115)
574 (bound (car plist)
575 a
576 (lambda (car-p a)
577 (boundv (cdr plist)
578 a
579 (lambda (cdr-p a)
580 (k (cons car-p cdr-p) a)))))))
581 (if (null? plist)
582 (g115)
583 (match:error plist)))))
584
585 (define (bound* plist a k)
586 (if (null? plist)
587 (k plist a)
588 (bound (car plist)
589 a
590 (lambda (car-p a)
591 (bound* (cdr plist)
592 a
593 (lambda (cdr-p a)
594 (k (cons car-p cdr-p) a)))))))
595
596 (define (find-prefix b a)
597 (if (eq? b a)
598 '()
599 (cons (car b) (find-prefix (cdr b) a))))
600
601 (define (permutation p1 p2)
602 (and (= (length p1) (length p2))
603 (every (lambda (x1) (memq x1 p2)) p1)))
604
605 (bound pattern
606 '()
607 (lambda (p a) (list p (reverse a) pred-bodies))))
608
609 (define (gen x sf plist erract eta)
610 (if (null? plist)
611 (erract x)
612 (let* ((v '())
613 (val (lambda (x) (cdr (assq x v))))
614 (fail (lambda (sf)
615 (gen x sf (cdr plist) erract eta)))
616 (success (lambda (sf)
617 (set-car! (cddddr (car plist)) #t)
618 (let* ((code (cadr (car plist)))
619 (bv (caddr (car plist)))
620 (fail-sym (cadddr (car plist))))
621 (if fail-sym
622 (let ((ap `(,code ,fail-sym ,@(map val bv))))
623 `(call-with-current-continuation
624 (,lambda. (,fail-sym)
625 (let ((,fail-sym
626 (,lambda. ()
627 (call-with-values
628 (,lambda. () ,(fail sf))
629 ,fail-sym))))
630 ,ap))))
631 `(,code ,@(map val bv)))))))
632 (let next ((p (caar plist))
633 (e x)
634 (sf sf)
635 (kf fail)
636 (ks success))
637 (cond
638 ((eq? '_ p) (ks sf))
639 ;; The check of (symbol? :x) is to support both disjoint-keyword and
640 ;; keyword-is-symbol runtime. Remove this clause once we fully
641 ;; migrated to keyword-is-symbol.
642 ((and (not (symbol? :x)) (keyword? p))
643 (warn "Unquoted keyword `~s' in match pattern: ~s. \
644 This would likely break in future versions of Gauche. \
645 See the ``Keyword and symbol integration'' section \
646 of the manual for the details.\n" p x)
647 (emit `(equal? ,e ,p) sf kf ks))
648 ((identifier? p) (set! v (cons (cons p e) v))
649 (ks sf))
650 ((null? p) (emit `(null? ,e) sf kf ks))
651 ((equal? p ''()) (emit `(null? ,e) sf kf ks))
652 ((string? p) (emit `(equal? ,e ,p) sf kf ks))
653 ((boolean? p) (emit `(equal? ,e ,p) sf kf ks))
654 ((char? p) (emit `(equal? ,e ,p) sf kf ks))
655 ((number? p) (emit `(equal? ,e ,p) sf kf ks))
656 ((and (pair? p) (equal? 'quote (car p)))
657 (emit `(equal? ,e ,p) sf kf ks))
658 ((and (pair? p) (eq? '? (car p)))
659 (let ((tst `(,(cadr p) ,e)))
660 (emit tst sf kf ks)))
661 ((and (pair? p) (eq? '= (car p)))
662 (if (and (pair? (cadr p))
663 (equal? (caadr p) 'quote))
664 (next (caddr p) `(ref ,(cadr p) ,e) sf kf ks)
665 (next (caddr p) `(,(cadr p) ,e) sf kf ks)))
666 ((and (pair? p) (eq? 'and (car p)))
667 (let loop ((p (cdr p))
668 (sf sf))
669 (if (null? p)
670 (ks sf)
671 (next (car p) e sf kf (lambda (sf) (loop (cdr p) sf))))))
672 ((and (pair? p) (eq? 'or (car p)))
673 (let ((or-v v))
674 (let loop ((p (cdr p))
675 (sf sf))
676 (if (null? p)
677 (kf sf)
678 (begin (set! v or-v)
679 (next (car p) e sf (lambda (sf) (loop (cdr p) sf))
680 ks))))))
681 ((and (pair? p) (eq? 'not (car p)))
682 (next (cadr p) e sf ks kf))
683 ((and (pair? p) (eq? '$ (car p)))
684 (let* ((tag (cadr p))
685 (fields (cdr p))
686 (rlen (length fields))
687 (tst `(is-a? ,e ,tag)))
688 (emit tst sf kf
689 (let rloop ((n 1))
690 (lambda (sf)
691 (if (= n rlen)
692 (ks sf)
693 (next (list-ref fields n)
694 `(match:$-ref ,tag ,(- n 1) ,e)
695 sf kf (rloop (+ 1 n)))))))))
696 ((and (pair? p) (eq? 'object (car p))) ;; Gauche extension
697 (let* ((tag (cadr p))
698 (fields (cddr p))
699 (tst `(is-a? ,e ,tag)))
700 (emit tst sf kf
701 (let rloop ((fields fields))
702 (lambda (sf)
703 (if (null? fields)
704 (ks sf)
705 (next (cadar fields)
706 `(ref ,e ',(caar fields))
707 sf kf (rloop (cdr fields)))))))))
708 ((and (pair? p) (eq? 'set! (car p)))
709 (set! v (cons (cons (cadr p) (get-setter e p)) v))
710 (ks sf))
711 ((and (pair? p) (eq? 'get! (car p)))
712 (set! v (cons (cons (cadr p) (get-getter e p)) v))
713 (ks sf))
714 ((and (pair? p)
715 (pair? (cdr p))
716 (dot-dot-k? (cadr p)))
717 (emit `(list? ,e) sf kf
718 (lambda (sf)
719 (let* ((k (dot-dot-k? (cadr p)))
720 (ks (lambda (sf)
721 (let ((bound (list-ref p 2)))
722 (cond
723 ((eq? (car p) '_) (ks sf))
724 ((null? bound)
725 (let* ((eta (gensym))
726 (ptst (next (car p) eta sf
727 (lambda (sf) #f)
728 (lambda (sf) #t)))
729 (tst (if (and (pair? ptst)
730 (identifier? (car ptst))
731 (pair? (cdr ptst))
732 (eq? eta (cadr ptst))
733 (null? (cddr ptst)))
734 (car ptst)
735 `(,lambda. (,eta) ,ptst))))
736 (assm `(match:every ,tst ,e)
737 (kf sf)
738 (ks sf))))
739 ((and (identifier? (car p))
740 (equal? (list (car p)) bound))
741 (next (car p) e sf kf ks))
742 (else
743 (let* ((gloop (list-ref p 3))
744 (ge (list-ref p 4))
745 (fresh (list-ref p 5))
746 (p1 (next (car p)
747 `(car ,ge)
748 sf
749 kf
750 (lambda (sf)
751 `(,gloop
752 (cdr ,ge)
753 ,@(map (lambda (b f)
754 `(cons ,(val b)
755 ,f))
756 bound
757 fresh))))))
758 (set! v
759 (append
760 (map cons
761 bound
762 (map (lambda (x)
763 `(reverse ,x))
764 fresh))
765 v))
766 `(let ,gloop ((,ge ,e)
767 ,@(map (lambda (x)
768 `(,x '()))
769 fresh))
770 (if (null? ,ge)
771 ,(ks sf)
772 ,p1)))))))))
773 (case k
774 ((0) (ks sf))
775 ((1) (emit `(pair? ,e) sf kf ks))
776 (else (emit `((,match:length>=?. ,k) ,e) sf kf ks)))))))
777 ((pair? p) (emit `(pair? ,e)
778 sf
779 kf
780 (lambda (sf)
781 (next (car p)
782 (add-a e)
783 sf
784 kf
785 (lambda (sf)
786 (next (cdr p) (add-d e) sf kf ks))))))
787 ((and (vector? p)
788 (>= (vector-length p) 6)
789 (dot-dot-k? (vector-ref p (- (vector-length p) 5))))
790 (let* ((vlen (- (vector-length p) 6))
791 (k (dot-dot-k? (vector-ref p (+ vlen 1))))
792 (minlen (+ vlen k))
793 (bound (vector-ref p (+ vlen 2))))
794 (emit `(vector? ,e)
795 sf
796 kf
797 (lambda (sf)
798 (assm `(>= (vector-length ,e) ,minlen)
799 (kf sf)
800 ((let vloop ((n 0))
801 (lambda (sf)
802 (cond
803 ((not (= n vlen))
804 (next (vector-ref p n)
805 `(vector-ref ,e ,n)
806 sf
807 kf
808 (vloop (+ 1 n))))
809 ((eq? (vector-ref p vlen) '_)
810 (ks sf))
811 (else
812 (let* ((gloop (vector-ref p (+ vlen 3)))
813 (ind (vector-ref p (+ vlen 4)))
814 (fresh (vector-ref p (+ vlen 5)))
815 (p1 (next (vector-ref p vlen)
816 `(vector-ref ,e ,ind)
817 sf
818 kf
819 (lambda (sf)
820 `(,gloop
821 (- ,ind 1)
822 ,@(map (lambda (b f)
823 `(cons ,(val b)
824 ,f))
825 bound
826 fresh))))))
827 (set! v
828 (append
829 (map cons bound fresh)
830 v))
831 `(let ,gloop
832 ((,ind (- (vector-length ,e) 1))
833 ,@(map (lambda (x) `(,x '()))
834 fresh))
835 (if (> ,minlen ,ind)
836 ,(ks sf)
837 ,p1)))))))
838 sf))))))
839 ((vector? p)
840 (let ((vlen (vector-length p)))
841 (emit `(vector? ,e)
842 sf
843 kf
844 (lambda (sf)
845 (emit `(equal? (vector-length ,e) ,vlen)
846 sf
847 kf
848 (let vloop ((n 0))
849 (lambda (sf)
850 (if (= n vlen)
851 (ks sf)
852 (next (vector-ref p n)
853 `(vector-ref ,e ,n)
854 sf
855 kf
856 (vloop (+ 1 n)))))))))))
857 (else (display "FATAL ERROR IN PATTERN MATCHER")
858 (newline)
859 (error #f "THIS NEVER HAPPENS")))))))
860
861 (define (emit tst sf kf ks)
862 (cond
863 ((in tst sf) (ks sf))
864 ((in `(not ,tst) sf) (kf sf))
865 (else
866 (let* ((e (cadr tst))
867 (implied (cond
868 ((eq? (car tst) 'equal?)
869 (let ((p (caddr tst)))
870 (cond
871 ((string? p) `((string? ,e)))
872 ((boolean? p) `((boolean? ,e)))
873 ((char? p) `((char? ,e)))
874 ((number? p) `((number? ,e)))
875 ((and (pair? p)
876 (equal? 'quote (car p)))
877 `((symbol? ,e)))
878 (else '()))))
879 ((eq? (car tst) 'null?)
880 `((list? ,e)))
881 (else '())))
882 (not-imp (case (car tst)
883 ((list?) `((not (null? ,e))))
884 (else '())))
885 (s (ks (cons tst (append implied sf))))
886 (k (kf (cons `(not ,tst)
887 (append not-imp sf)))))
888 (assm tst k s)))))
889
890 (define (assm tst f s)
891 (cond
892 ((equal? s f) s)
893 ((and (eq? s #t) (eq? f #f)) tst)
894 ((and (eq? (car tst) 'pair?)
895 (memq match:error-control '(unspecified fail))
896 (memq (car f) '(cond match:error))
897 (guarantees s (cadr tst)))
898 s)
899 (;; (if (and X ...) Y f) => (if (and tst X ...) Y f)
900 ;; (if X Y f) => (if (and tst X) Y f)
901 (and (pair? s)
902 (eq? (car s) 'if)
903 (equal? (cadddr s) f))
904 (if (eq? (car (cadr s)) 'and)
905 `(if (and ,tst ,@(cdr (cadr s)))
906 ,(caddr s)
907 ,f)
908 `(if (and ,tst ,(cadr s))
909 ,(caddr s)
910 ,f)))
911 (;; (call/cc (lambda (X)
912 ;; (let ((Y (lambda () (call-with-values (lambda () f) X))))
913 ;; BODY)))
914 ;; =>
915 ;; (call/cc (lambda (X)
916 ;; (let ((Y (lambda () (call-with-values (lambda () f) X))))
917 ;; (assm tst (Y) BODY))))
918 (and (pair? s)
919 (equal? (car s) 'call-with-current-continuation)
920 (pair? (cdr s))
921 (pair? (cadr s))
922 (equal? (caadr s) lambda.)
923 (pair? (cdadr s))
924 (pair? (cadadr s))
925 (null? (cdr (cadadr s)))
926 (pair? (cddadr s))
927 (pair? (car (cddadr s)))
928 (equal? (caar (cddadr s)) 'let)
929 (pair? (cdar (cddadr s)))
930 (pair? (cadar (cddadr s)))
931 (pair? (caadar (cddadr s)))
932 (pair? (cdr (caadar (cddadr s))))
933 (pair? (cadr (caadar (cddadr s))))
934 (equal? (caadr (caadar (cddadr s))) lambda.)
935 (pair? (cdadr (caadar (cddadr s))))
936 (null? (cadadr (caadar (cddadr s))))
937 (pair? (cddadr (caadar (cddadr s))))
938 (pair? (car (cddadr (caadar (cddadr s)))))
939 (equal? (caar (cddadr (caadar (cddadr s)))) 'call-with-values)
940 (pair? (cdar (cddadr (caadar (cddadr s)))))
941 (pair? (cadar (cddadr (caadar (cddadr s)))))
942 (equal? (caadar (cddadr (caadar (cddadr s)))) lambda.)
943 (pair? (cdadar (cddadr (caadar (cddadr s)))))
944 (null? (car (cdadar (cddadr (caadar (cddadr s))))))
945 (pair? (cdr (cdadar (cddadr (caadar (cddadr s))))))
946 (null? (cddr (cdadar (cddadr (caadar (cddadr s))))))
947 (pair? (cddar (cddadr (caadar (cddadr s)))))
948 (null? (cdddar (cddadr (caadar (cddadr s)))))
949 (null? (cdr (cddadr (caadar (cddadr s)))))
950 (null? (cddr (caadar (cddadr s))))
951 (null? (cdadar (cddadr s)))
952 (pair? (cddar (cddadr s)))
953 (null? (cdddar (cddadr s)))
954 (null? (cdr (cddadr s)))
955 (null? (cddr s))
956 (equal? f (cadr (cdadar (cddadr (caadar (cddadr s)))))))
957 (let ((k (car (cadadr s)))
958 (fail (car (caadar (cddadr s))))
959 (s2 (caddar (cddadr s))))
960 `(call-with-current-continuation
961 (lambda (,k)
962 (let ((,fail (,lambda. () (call-with-values (,lambda. () ,f) ,k))))
963 ,(assm tst `(,fail) s2))))))
964 ((and #f
965 (pair? s)
966 (equal? (car s) 'let)
967 (pair? (cdr s))
968 (pair? (cadr s))
969 (pair? (caadr s))
970 (pair? (cdaadr s))
971 (pair? (car (cdaadr s)))
972 (equal? (caar (cdaadr s)) 'lambda)
973 (pair? (cdar (cdaadr s)))
974 (null? (cadar (cdaadr s)))
975 (pair? (cddar (cdaadr s)))
976 (null? (cdddar (cdaadr s)))
977 (null? (cdr (cdaadr s)))
978 (null? (cdadr s))
979 (pair? (cddr s))
980 (null? (cdddr s))
981 (equal? (caddar (cdaadr s)) f))
982 (let ((fail (caaadr s))
983 (s2 (caddr s)))
984 `(let ((,fail (,lambda. () ,f)))
985 ,(assm tst `(,fail) s2))))
986 (else `(if ,tst ,s ,f))))
987
988 (define (guarantees code x)
989 (let ((a (add-a x)) (d (add-d x)))
990 (let loop ((code code))
991 (cond
992 ((not (pair? code)) #f)
993 ((member (car code) '(cond match:error)) #t)
994 ((or (equal? code a) (equal? code d)) #t)
995 ((eq? (car code) 'if)
996 (or (loop (cadr code))
997 (and (loop (caddr code))
998 (loop (cadddr code)))))
999 ((equal? (car code) 'lambda) #f)
1000 ((and (eq? (car code) 'let)
1001 (identifier? (cadr code)))
1002 #f)
1003 (else (or (loop (car code))
1004 (loop (cdr code))))))))
1005
1006 (define (in e l)
1007 (or (member e l)
1008 (and (eq? (car e) 'list?)
1009 ;; NB: Original Wright's code allows `(pair? ,(cadr e)) here as well,
1010 ;; but they are not the same condition - pair? allows improper list
1011 ;; but list? doesn't. Ref: https://github.com/shirok/Gauche/issues/47
1012 (member `(null? ,(cadr e)) l))
1013 (and (eq? (car e) 'not)
1014 (let* ((srch (cadr e))
1015 (const-class (equal-test? srch)))
1016 (cond
1017 (const-class
1018 (let mem ((l l))
1019 (if (null? l)
1020 #f
1021 (let ((x (car l)))
1022 (or (and (equal? (cadr x) (cadr srch))
1023 (disjoint? x)
1024 (not (equal? const-class (car x))))
1025 (equal? x `(not (,const-class ,(cadr srch))))
1026 (and (equal? (cadr x) (cadr srch))
1027 (equal-test? x)
1028 (not (equal? (caddr srch) (caddr x))))
1029 (mem (cdr l)))))))
1030 ((disjoint? srch)
1031 (let mem ((l l))
1032 (if (null? l)
1033 #f
1034 (let ((x (car l)))
1035 (or (and (equal? (cadr x) (cadr srch))
1036 (disjoint? x)
1037 (not (equal? (car x) (car srch))))
1038 (mem (cdr l)))))))
1039 ((eq? (car srch) 'list?)
1040 (let mem ((l l))
1041 (if (null? l)
1042 #f
1043 (let ((x (car l)))
1044 (or (and (equal? (cadr x) (cadr srch))
1045 (disjoint? x)
1046 (not (memq (car x) '(list? pair? null?))))
1047 (mem (cdr l)))))))
1048 (else #f))))))
1049
1050 (define (equal-test? tst)
1051 (and (equal? (car tst) 'equal?)
1052 (let ((p (caddr tst)))
1053 (cond
1054 ((string? p) 'string?)
1055 ((boolean? p) 'boolean?)
1056 ((char? p) 'char?)
1057 ((number? p) 'number?)
1058 ((and (pair? p)
1059 (pair? (cdr p))
1060 (null? (cddr p))
1061 (equal? 'quote (car p))
1062 (identifier? (cadr p)))
1063 'symbol?)
1064 (else #f)))))
1065
1066 (define (disjoint? tst)
1067 (memq (car tst) match:disjoint-predicates))
1068
1069 (define (add-a a)
1070 (let ((new (and (pair? a) (assq (car a) c---rs))))
1071 (if new (cons (cadr new) (cdr a)) `(car ,a))))
1072
1073 (define (add-d a)
1074 (let ((new (and (pair? a) (assq (car a) c---rs))))
1075 (if new (cons (cddr new) (cdr a)) `(cdr ,a))))
1076
1077 (define c---rs '((car caar . cdar)
1078 (cdr cadr . cddr)
1079 (caar caaar . cdaar)
1080 (cadr caadr . cdadr)
1081 (cdar cadar . cddar)
1082 (cddr caddr . cdddr)
1083 (caaar caaaar . cdaaar)
1084 (caadr caaadr . cdaadr)
1085 (cadar caadar . cdadar)
1086 (caddr caaddr . cdaddr)
1087 (cdaar cadaar . cddaar)
1088 (cdadr cadadr . cddadr)
1089 (cddar caddar . cdddar)
1090 (cdddr cadddr . cddddr)))
1091
1092 (define (get-setter e p)
1093 (unless (pair? e)
1094 (match:syntax-err p "unnested set! pattern"))
1095 `(cute (or (setter ,(car e)) (error "no setter defined to bind " ',p))
1096 ,@(cdr e) <>))
1097
1098 (define (get-getter e p)
1099 (unless (pair? e)
1100 (match:syntax-err p "unnested get! pattern"))
1101 `(cute ,@e))
1102
1103 (define match:expanders
1104 (list genmatch genletrec gendefine pattern-var?))
1105
1106 (define-macro (match . args)
1107 (cond
1108 ((and (list? args)
1109 (<= 1 (length args))
1110 (match:every
1111 (lambda (y) (and (list? y) (<= 2 (length y))))
1112 (cdr args))) (let* ((exp (car args))
1113 (clauses (cdr args))
1114 (e (if (identifier? exp) exp (gensym))))
1115 (if (identifier? exp)
1116 ((car match:expanders)
1117 e
1118 clauses
1119 `(,match. ,@args))
1120 `(let ((,e ,exp))
1121 ,((car match:expanders)
1122 e
1123 clauses
1124 `(,match. ,@args))))))
1125 (else (match:syntax-err `(match ,@args) "syntax error in"))))
1126
1127 (define-macro (match-lambda . args)
1128 (if (and (list? args)
1129 (match:every
1130 (lambda (g126)
1131 (if (and (pair? g126) (list? (cdr g126)))
1132 (pair? (cdr g126))
1133 #f))
1134 args))
1135 ((lambda ()
1136 (let ((e (gensym))) `(,lambda. (,e) (,match. ,e ,@args)))))
1137 ((lambda ()
1138 (match:syntax-err
1139 `(match-lambda ,@args)
1140 "syntax error in")))))
1141
1142 (define-macro (match-lambda* . args)
1143 (if (and (list? args)
1144 (match:every
1145 (lambda (g134)
1146 (if (and (pair? g134) (list? (cdr g134)))
1147 (pair? (cdr g134))
1148 #f))
1149 args))
1150 ((lambda ()
1151 (let ((e (gensym))) `(,lambda. ,e (,match. ,e ,@args)))))
1152 ((lambda ()
1153 (match:syntax-err
1154 `(match-lambda* ,@args)
1155 "syntax error in")))))
1156
1157 (define-macro (match-let . args)
1158 (let ((g158 (lambda (pat exp body)
1159 `(,match. ,exp (,pat ,@body))))
1160 (g154 (lambda (pat exp body)
1161 (let ((g (map (lambda (x) (gensym)) pat))
1162 (vpattern (list->vector pat)))
1163 `(let ,(map list g exp)
1164 (,match. (vector ,@g) (,vpattern ,@body))))))
1165 (g146 (lambda ()
1166 (match:syntax-err `(match-let ,@args) "syntax error in")))
1167 (g145 (lambda (p1 e1 p2 e2 body)
1168 (let ((g1 (gensym)) (g2 (gensym)))
1169 `(let ((,g1 ,e1) (,g2 ,e2))
1170 (,match. (cons ,g1 ,g2) ((,p1 . ,p2) ,@body))))))
1171 (g136 (cadddr match:expanders)))
1172 (if (pair? args)
1173 (if (identifier? (car args))
1174 (if (and (pair? (cdr args)) (list? (cadr args)))
1175 (let g161 ((g162 (cadr args)) (g160 '()) (g159 '()))
1176 (if (null? g162)
1177 (if (and (list? (cddr args)) (pair? (cddr args)))
1178 ((lambda (name pat exp body)
1179 (if (match:every
1180 (cadddr match:expanders)
1181 pat)
1182 `(let ,@args)
1183 `(letrec ((,name (,match-lambda*.
1184 (,pat ,@body))))
1185 (,name ,@exp))))
1186 (car args)
1187 (reverse g159)
1188 (reverse g160)
1189 (cddr args))
1190 (g146))
1191 (if (and (pair? (car g162))
1192 (pair? (cdar g162))
1193 (null? (cddar g162)))
1194 (g161 (cdr g162)
1195 (cons (cadar g162) g160)
1196 (cons (caar g162) g159))
1197 (g146))))
1198 (g146))
1199 (if (list? (car args))
1200 (if (match:every
1201 (lambda (g167)
1202 (if (and (pair? g167)
1203 (g136 (car g167))
1204 (pair? (cdr g167)))
1205 (null? (cddr g167))
1206 #f))
1207 (car args))
1208 (if (and (list? (cdr args)) (pair? (cdr args)))
1209 ((lambda () `(let ,@args)))
1210 (let g149 ((g150 (car args)) (g148 '()) (g147 '()))
1211 (if (null? g150)
1212 (g146)
1213 (if (and (pair? (car g150))
1214 (pair? (cdar g150))
1215 (null? (cddar g150)))
1216 (g149 (cdr g150)
1217 (cons (cadar g150) g148)
1218 (cons (caar g150) g147))
1219 (g146)))))
1220 (if (and (pair? (car args))
1221 (pair? (caar args))
1222 (pair? (cdaar args))
1223 (null? (cddaar args)))
1224 (if (null? (cdar args))
1225 (if (and (list? (cdr args)) (pair? (cdr args)))
1226 (g158 (caaar args)
1227 (cadaar args)
1228 (cdr args))
1229 (let g149 ((g150 (car args))
1230 (g148 '())
1231 (g147 '()))
1232 (if (null? g150)
1233 (g146)
1234 (if (and (pair? (car g150))
1235 (pair? (cdar g150))
1236 (null? (cddar g150)))
1237 (g149 (cdr g150)
1238 (cons (cadar g150) g148)
1239 (cons (caar g150) g147))
1240 (g146)))))
1241 (if (and (pair? (cdar args))
1242 (pair? (cadar args))
1243 (pair? (cdadar args))
1244 (null? (cdr (cdadar args)))
1245 (null? (cddar args)))
1246 (if (and (list? (cdr args))
1247 (pair? (cdr args)))
1248 (g145 (caaar args)
1249 (cadaar args)
1250 (caadar args)
1251 (car (cdadar args))
1252 (cdr args))
1253 (let g149 ((g150 (car args))
1254 (g148 '())
1255 (g147 '()))
1256 (if (null? g150)
1257 (g146)
1258 (if (and (pair? (car g150))
1259 (pair? (cdar g150))
1260 (null? (cddar g150)))
1261 (g149 (cdr g150)
1262 (cons (cadar g150)
1263 g148)
1264 (cons (caar g150)
1265 g147))
1266 (g146)))))
1267 (let g149 ((g150 (car args))
1268 (g148 '())
1269 (g147 '()))
1270 (if (null? g150)
1271 (if (and (list? (cdr args))
1272 (pair? (cdr args)))
1273 (g154 (reverse g147)
1274 (reverse g148)
1275 (cdr args))
1276 (g146))
1277 (if (and (pair? (car g150))
1278 (pair? (cdar g150))
1279 (null? (cddar g150)))
1280 (g149 (cdr g150)
1281 (cons (cadar g150) g148)
1282 (cons (caar g150) g147))
1283 (g146))))))
1284 (let g149 ((g150 (car args)) (g148 '()) (g147 '()))
1285 (if (null? g150)
1286 (if (and (list? (cdr args))
1287 (pair? (cdr args)))
1288 (g154 (reverse g147)
1289 (reverse g148)
1290 (cdr args))
1291 (g146))
1292 (if (and (pair? (car g150))
1293 (pair? (cdar g150))
1294 (null? (cddar g150)))
1295 (g149 (cdr g150)
1296 (cons (cadar g150) g148)
1297 (cons (caar g150) g147))
1298 (g146))))))
1299 (if (pair? (car args))
1300 (if (and (pair? (caar args))
1301 (pair? (cdaar args))
1302 (null? (cddaar args)))
1303 (if (null? (cdar args))
1304 (if (and (list? (cdr args)) (pair? (cdr args)))
1305 (g158 (caaar args)
1306 (cadaar args)
1307 (cdr args))
1308 (let g149 ((g150 (car args))
1309 (g148 '())
1310 (g147 '()))
1311 (if (null? g150)
1312 (g146)
1313 (if (and (pair? (car g150))
1314 (pair? (cdar g150))
1315 (null? (cddar g150)))
1316 (g149 (cdr g150)
1317 (cons (cadar g150) g148)
1318 (cons (caar g150) g147))
1319 (g146)))))
1320 (if (and (pair? (cdar args))
1321 (pair? (cadar args))
1322 (pair? (cdadar args))
1323 (null? (cdr (cdadar args)))
1324 (null? (cddar args)))
1325 (if (and (list? (cdr args))
1326 (pair? (cdr args)))
1327 (g145 (caaar args)
1328 (cadaar args)
1329 (caadar args)
1330 (car (cdadar args))
1331 (cdr args))
1332 (let g149 ((g150 (car args))
1333 (g148 '())
1334 (g147 '()))
1335 (if (null? g150)
1336 (g146)
1337 (if (and (pair? (car g150))
1338 (pair? (cdar g150))
1339 (null? (cddar g150)))
1340 (g149 (cdr g150)
1341 (cons (cadar g150)
1342 g148)
1343 (cons (caar g150)
1344 g147))
1345 (g146)))))
1346 (let g149 ((g150 (car args))
1347 (g148 '())
1348 (g147 '()))
1349 (if (null? g150)
1350 (if (and (list? (cdr args))
1351 (pair? (cdr args)))
1352 (g154 (reverse g147)
1353 (reverse g148)
1354 (cdr args))
1355 (g146))
1356 (if (and (pair? (car g150))
1357 (pair? (cdar g150))
1358 (null? (cddar g150)))
1359 (g149 (cdr g150)
1360 (cons (cadar g150) g148)
1361 (cons (caar g150) g147))
1362 (g146))))))
1363 (let g149 ((g150 (car args)) (g148 '()) (g147 '()))
1364 (if (null? g150)
1365 (if (and (list? (cdr args))
1366 (pair? (cdr args)))
1367 (g154 (reverse g147)
1368 (reverse g148)
1369 (cdr args))
1370 (g146))
1371 (if (and (pair? (car g150))
1372 (pair? (cdar g150))
1373 (null? (cddar g150)))
1374 (g149 (cdr g150)
1375 (cons (cadar g150) g148)
1376 (cons (caar g150) g147))
1377 (g146)))))
1378 (g146))))
1379 (g146))))
1380
1381 (define-macro (match-let1 pat exp . body) ;; Gauche extension
1382 `(,match. ,exp (,pat ,@body)))
1383
1384 (define-macro (match-let* . args)
1385 (let ((g176 (lambda ()
1386 (match:syntax-err `(match-let* ,@args) "syntax error in"))))
1387 (if (pair? args)
1388 (if (null? (car args))
1389 (if (and (list? (cdr args)) (pair? (cdr args)))
1390 ((lambda (body) `(let* ,@args)) (cdr args))
1391 (g176))
1392 (if (and (pair? (car args))
1393 (pair? (caar args))
1394 (pair? (cdaar args))
1395 (null? (cddaar args))
1396 (list? (cdar args))
1397 (list? (cdr args))
1398 (pair? (cdr args)))
1399 ((lambda (pat exp rest body)
1400 (if ((cadddr match:expanders) pat)
1401 `(let ((,pat ,exp)) (,match-let*. ,rest ,@body))
1402 `(,match. ,exp (,pat (,match-let*. ,rest ,@body)))))
1403 (caaar args)
1404 (cadaar args)
1405 (cdar args)
1406 (cdr args))
1407 (g176)))
1408 (g176))))
1409
1410 (define-macro (match-letrec . args)
1411 (let ((g200 (cadddr match:expanders))
1412 (g199 (lambda (p1 e1 p2 e2 body)
1413 `(,match-letrec. (((,p1 . ,p2) (cons ,e1 ,e2))) ,@body)))
1414 (g195 (lambda ()
1415 (match:syntax-err
1416 `(match-letrec ,@args)
1417 "syntax error in")))
1418 (g194 (lambda (pat exp body)
1419 `(,match-letrec.
1420 ((,(list->vector pat) (vector ,@exp)))
1421 ,@body)))
1422 (g186 (lambda (pat exp body)
1423 ((cadr match:expanders)
1424 pat
1425 exp
1426 body
1427 `(,match-letrec. ((,pat ,exp)) ,@body)))))
1428 (if (pair? args)
1429 (if (list? (car args))
1430 (if (match:every
1431 (lambda (g206)
1432 (if (and (pair? g206)
1433 (g200 (car g206))
1434 (pair? (cdr g206)))
1435 (null? (cddr g206))
1436 #f))
1437 (car args))
1438 (if (and (list? (cdr args)) (pair? (cdr args)))
1439 ((lambda () `(letrec ,@args)))
1440 (let g189 ((g190 (car args)) (g188 '()) (g187 '()))
1441 (if (null? g190)
1442 (g195)
1443 (if (and (pair? (car g190))
1444 (pair? (cdar g190))
1445 (null? (cddar g190)))
1446 (g189 (cdr g190)
1447 (cons (cadar g190) g188)
1448 (cons (caar g190) g187))
1449 (g195)))))
1450 (if (and (pair? (car args))
1451 (pair? (caar args))
1452 (pair? (cdaar args))
1453 (null? (cddaar args)))
1454 (if (null? (cdar args))
1455 (if (and (list? (cdr args)) (pair? (cdr args)))
1456 (g186 (caaar args) (cadaar args) (cdr args))
1457 (let g189 ((g190 (car args))
1458 (g188 '())
1459 (g187 '()))
1460 (if (null? g190)
1461 (g195)
1462 (if (and (pair? (car g190))
1463 (pair? (cdar g190))
1464 (null? (cddar g190)))
1465 (g189 (cdr g190)
1466 (cons (cadar g190) g188)
1467 (cons (caar g190) g187))
1468 (g195)))))
1469 (if (and (pair? (cdar args))
1470 (pair? (cadar args))
1471 (pair? (cdadar args))
1472 (null? (cdr (cdadar args)))
1473 (null? (cddar args)))
1474 (if (and (list? (cdr args)) (pair? (cdr args)))
1475 (g199 (caaar args)
1476 (cadaar args)
1477 (caadar args)
1478 (car (cdadar args))
1479 (cdr args))
1480 (let g189 ((g190 (car args))
1481 (g188 '())
1482 (g187 '()))
1483 (if (null? g190)
1484 (g195)
1485 (if (and (pair? (car g190))
1486 (pair? (cdar g190))
1487 (null? (cddar g190)))
1488 (g189 (cdr g190)
1489 (cons (cadar g190) g188)
1490 (cons (caar g190) g187))
1491 (g195)))))
1492 (let g189 ((g190 (car args))
1493 (g188 '())
1494 (g187 '()))
1495 (if (null? g190)
1496 (if (and (list? (cdr args))
1497 (pair? (cdr args)))
1498 (g194 (reverse g187)
1499 (reverse g188)
1500 (cdr args))
1501 (g195))
1502 (if (and (pair? (car g190))
1503 (pair? (cdar g190))
1504 (null? (cddar g190)))
1505 (g189 (cdr g190)
1506 (cons (cadar g190) g188)
1507 (cons (caar g190) g187))
1508 (g195))))))
1509 (let g189 ((g190 (car args)) (g188 '()) (g187 '()))
1510 (if (null? g190)
1511 (if (and (list? (cdr args)) (pair? (cdr args)))
1512 (g194 (reverse g187)
1513 (reverse g188)
1514 (cdr args))
1515 (g195))
1516 (if (and (pair? (car g190))
1517 (pair? (cdar g190))
1518 (null? (cddar g190)))
1519 (g189 (cdr g190)
1520 (cons (cadar g190) g188)
1521 (cons (caar g190) g187))
1522 (g195))))))
1523 (if (pair? (car args))
1524 (if (and (pair? (caar args))
1525 (pair? (cdaar args))
1526 (null? (cddaar args)))
1527 (if (null? (cdar args))
1528 (if (and (list? (cdr args)) (pair? (cdr args)))
1529 (g186 (caaar args) (cadaar args) (cdr args))
1530 (let g189 ((g190 (car args))
1531 (g188 '())
1532 (g187 '()))
1533 (if (null? g190)
1534 (g195)
1535 (if (and (pair? (car g190))
1536 (pair? (cdar g190))
1537 (null? (cddar g190)))
1538 (g189 (cdr g190)
1539 (cons (cadar g190) g188)
1540 (cons (caar g190) g187))
1541 (g195)))))
1542 (if (and (pair? (cdar args))
1543 (pair? (cadar args))
1544 (pair? (cdadar args))
1545 (null? (cdr (cdadar args)))
1546 (null? (cddar args)))
1547 (if (and (list? (cdr args)) (pair? (cdr args)))
1548 (g199 (caaar args)
1549 (cadaar args)
1550 (caadar args)
1551 (car (cdadar args))
1552 (cdr args))
1553 (let g189 ((g190 (car args))
1554 (g188 '())
1555 (g187 '()))
1556 (if (null? g190)
1557 (g195)
1558 (if (and (pair? (car g190))
1559 (pair? (cdar g190))
1560 (null? (cddar g190)))
1561 (g189 (cdr g190)
1562 (cons (cadar g190) g188)
1563 (cons (caar g190) g187))
1564 (g195)))))
1565 (let g189 ((g190 (car args))
1566 (g188 '())
1567 (g187 '()))
1568 (if (null? g190)
1569 (if (and (list? (cdr args))
1570 (pair? (cdr args)))
1571 (g194 (reverse g187)
1572 (reverse g188)
1573 (cdr args))
1574 (g195))
1575 (if (and (pair? (car g190))
1576 (pair? (cdar g190))
1577 (null? (cddar g190)))
1578 (g189 (cdr g190)
1579 (cons (cadar g190) g188)
1580 (cons (caar g190) g187))
1581 (g195))))))
1582 (let g189 ((g190 (car args)) (g188 '()) (g187 '()))
1583 (if (null? g190)
1584 (if (and (list? (cdr args)) (pair? (cdr args)))
1585 (g194 (reverse g187)
1586 (reverse g188)
1587 (cdr args))
1588 (g195))
1589 (if (and (pair? (car g190))
1590 (pair? (cdar g190))
1591 (null? (cddar g190)))
1592 (g189 (cdr g190)
1593 (cons (cadar g190) g188)
1594 (cons (caar g190) g187))
1595 (g195)))))
1596 (g195)))
1597 (g195))))
1598
1599 (define-macro (match-define . args)
1600 (let ((g210 (cadddr match:expanders))
1601 (g209 (lambda ()
1602 (match:syntax-err
1603 `(match-define ,@args)
1604 "syntax error in"))))
1605 (if (pair? args)
1606 (if (g210 (car args))
1607 (if (and (pair? (cdr args)) (null? (cddr args)))
1608 ((lambda () `(begin (define ,@args))))
1609 (g209))
1610 (if (and (pair? (cdr args)) (null? (cddr args)))
1611 ((lambda (pat exp)
1612 ((caddr match:expanders)
1613 pat
1614 exp
1615 `(,match-define. ,@args)))
1616 (car args)
1617 (cadr args))
1618 (g209)))
1619 (g209))))