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