tests: Move (ice-9 syncase) into cond-expand.
[mes.git] / tests / psyntax.test
1 #! /bin/sh
2 # -*-scheme-*-
3 echo ' ()' | cat $(dirname $0)/../module/mes/base-0.mes $0 /dev/stdin | $(dirname $0)/../scripts/mes $MES_FLAGS "$@"
4 #paredit:||
5 exit $?
6 !#
7
8 ;;; -*-scheme-*-
9
10 ;;; Mes --- Maxwell Equations of Software
11 ;;; Copyright © 2016 Jan Nieuwenhuizen <janneke@gnu.org>
12 ;;;
13 ;;; This file is part of Mes.
14 ;;;
15 ;;; Mes is free software; you can redistribute it and/or modify it
16 ;;; under the terms of the GNU General Public License as published by
17 ;;; the Free Software Foundation; either version 3 of the License, or (at
18 ;;; your option) any later version.
19 ;;;
20 ;;; Mes is distributed in the hope that it will be useful, but
21 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
22 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23 ;;; GNU General Public License for more details.
24 ;;;
25 ;;; You should have received a copy of the GNU General Public License
26 ;;; along with Mes.  If not, see <http://www.gnu.org/licenses/>.
27
28 (cond-expand
29  (guile-2
30   (define sc-expand identity)
31   (define syntax-object->datum syntax->datum)
32   (define datum->syntax-object datum->syntax))
33  (guile
34   (use-modules (ice-9 syncase))
35   (define sc-expand identity))
36  (mes
37   (mes-use-module (mes psyntax))
38   (mes-use-module (mes test))))
39
40 (pass-if "first dummy" #t)
41 (pass-if-not "second dummy" #f)
42
43 (when (not guile?)
44  (pass-if "andmap"
45    (seq? (andmap (lambda (x) (> x 0)) '(3 2 1)) #t))
46
47  (pass-if "andmap 2"
48    (seq? (andmap (lambda (x) (> x 0)) '(3 2 1 0)) #f))
49
50  (pass-if "putprop" (putprop 'foo '*sc-expander 'bar))
51
52  (pass-if "getprop"
53    (seq? (getprop 'foo '*sc-expander) 'bar))
54  )
55
56 (pass-if "syntax-case"
57   (sequal? (let* ((sexp '(syntax-case '((1 2) (3 4)) ()
58                            (((x ...) ...) (syntax (x ... ...)))))
59                   (expanded (sc-expand sexp)))
60              (primitive-eval expanded))
61            '(1 2 3 4)))
62
63 (pass-if "sc-expand"
64   (sequal? (let ()
65              (syntax-case '((1 2) (3 4)) ()
66                (((x ...) ...) (syntax (x ... ...)))))
67            '(1 2 3 4)))
68
69 (pass-if "syntax-object->datum"
70   (sequal? (syntax-object->datum (syntax (set! a b)))
71            '(set! a b)))
72
73 (pass-if "syntax-case swap!"
74   (sequal? (syntax-object->datum
75             (let ((exp '(set! a b)))
76               (syntax-case exp ()
77                 ((swap! a b)
78                  (syntax
79                   (let ((temp a))
80                     (set! a b)
81                     (set! b temp)))))))
82            '(let ((temp a)) (set! a b) (set! b temp))))
83
84 (when (not guile?)
85   (pass-if "syntax-case manual swap!"
86     (sequal?
87      (let* ((sc (sc-expand '(syntax-case exp () ((swap! a b) (syntax (let ((temp a)) (set! a b) (set! b temp)))))))
88             (exp '(swap foo bar))
89             (foo "foo")
90             (bar "bar")
91             (s (eval sc (current-module)))
92             (d (syntax-object->datum s)))
93        (eval d (current-module))
94        (list foo bar))
95      '("bar" "foo"))))
96
97 (pass-if "define-syntax swap! [syntax-case]"
98   (sequal?
99    (let ()
100      (define-syntax swap!
101        (lambda (exp)
102          (syntax-case exp ()
103            ((swap! a b)
104             (syntax
105              ((lambda (temp)
106                 (set! a b)
107                 (set! b temp)) a))))))
108      (let ((foo "foo")
109            (bar "bar"))
110        (swap! foo bar)
111        (list foo bar)))
112    (list "bar" "foo")))
113
114 (pass-if "define-syntax swap! [syntax-case+let]"
115   (sequal?
116    (let ()
117      (define-syntax swap!
118        (lambda (exp)
119          (syntax-case exp ()
120            ((swap! a b)
121             (syntax
122              (let ((temp a))
123                (set! a b)
124                (set! b temp)))))))
125      (let ((foo "foo")
126            (bar "bar"))
127        (swap! foo bar)
128        (list foo bar)))
129    (list "bar" "foo")))
130
131 (pass-if "define-syntax sr:when [syntax-rules]"
132   (sequal?
133    (let ()
134      (define-syntax sr:when
135        (syntax-rules ()
136          ((sc:when condition exp ...)
137           (if condition
138               (begin exp ...)))))
139      (let ()
140        (sr:when #t "if not now, then?")))
141    "if not now, then?"))
142
143 (pass-if "define-syntax-rule"
144   (sequal?
145    (let ()
146      (define-syntax-rule (sre:when c e ...)
147        (if c (begin e ...)))
148      (let ()
149        (sre:when #t "if not now, then?")))
150    "if not now, then?"))
151
152 (pass-if-equal "syntax-rules plus"
153     (+ 1 2 3)
154   (let ()
155     (define-syntax plus
156       (syntax-rules ()
157         ((plus x ...) (+ x ...))))
158     (plus 1 2 3)))
159
160 (when guile?
161   (pass-if-equal "macro with quasisyntax"
162       '("foo" "foo")
163     (let ()
164       (define-syntax string-let
165         (lambda (stx)
166           (syntax-case stx ()
167             ((_ id body ...)
168              #`(let ((id #,(symbol->string (syntax->datum #'id))))
169                  body ...)))))
170       (string-let foo (list foo foo)))))
171
172   ;; (pass-if-equal "custom ellipsis within normal ellipsis"
173   ;;     '((((a x) (a y) (a …))
174   ;;        ((b x) (b y) (b …))
175   ;;        ((c x) (c y) (c …)))
176   ;;       (((a x) (b x) (c x))
177   ;;        ((a y) (b y) (c y))
178   ;;        ((a …) (b …) (c …))))
179   ;;   (let ()
180   ;;     (define-syntax foo
181   ;;       (syntax-rules ()
182   ;;         ((_ y ...)
183   ;;          (syntax-rules … ()
184   ;;            ((_ x …)
185   ;;             '((((x y) ...) …)
186   ;;               (((x y) …) ...)))))))
187   ;;     (define-syntax bar (foo x y …))
188   ;;     (bar a b c)))
189
190 (let ()
191  (define-syntax define-quotation-macros
192    (lambda (x)
193      (syntax-case x ()
194        ((_ (macro-name head-symbol) ...)
195         #'(begin (define-syntax macro-name
196                    (lambda (x)
197                      (with-ellipsis :::
198                                     (syntax-case x ()
199                                       ((_ x :::)
200                                        #'(quote (head-symbol x :::)))))))
201                  ...)))))
202  (define-quotation-macros (quote-a a) (quote-b b) (quote-c c))
203
204  (pass-if-equal "with-ellipsis"
205      '(a 1 2 3)
206      (quote-a 1 2 3)))
207
208 (result 'report)