7370926968854cbeff6fa402fbd6a67425e8a3b2
[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
30   ;;(use-modules (ice-9 syncase))
31   (define sc-expand identity)
32   (define syntax-object->datum syntax->datum)
33   (define datum->syntax-object datum->syntax)
34   )
35  (mes
36   (mes-use-module (mes psyntax))
37   (mes-use-module (mes test))))
38
39 (pass-if "first dummy" #t)
40 (pass-if-not "second dummy" #f)
41
42 (when (not guile?)
43  (pass-if "andmap"
44    (seq? (andmap (lambda (x) (> x 0)) '(3 2 1)) #t))
45
46  (pass-if "andmap 2"
47    (seq? (andmap (lambda (x) (> x 0)) '(3 2 1 0)) #f))
48
49  (pass-if "putprop" (putprop 'foo '*sc-expander 'bar))
50
51  (pass-if "getprop"
52    (seq? (getprop 'foo '*sc-expander) 'bar))
53  )
54
55 (pass-if "syntax-case"
56   (sequal? (let* ((sexp '(syntax-case '((1 2) (3 4)) ()
57                            (((x ...) ...) (syntax (x ... ...)))))
58                   (expanded (sc-expand sexp)))
59              (primitive-eval expanded))
60            '(1 2 3 4)))
61
62 (pass-if "sc-expand"
63   (sequal? (let ()
64              (syntax-case '((1 2) (3 4)) ()
65                (((x ...) ...) (syntax (x ... ...)))))
66            '(1 2 3 4)))
67
68 (pass-if "syntax-object->datum"
69   (sequal? (syntax-object->datum (syntax (set! a b)))
70            '(set! a b)))
71
72 (pass-if "syntax-case swap!"
73   (sequal? (syntax-object->datum
74             (let ((exp '(set! a b)))
75               (syntax-case exp ()
76                 ((swap! a b)
77                  (syntax
78                   (let ((temp a))
79                     (set! a b)
80                     (set! b temp)))))))
81            '(let ((temp a)) (set! a b) (set! b temp))))
82
83 (when (not guile?)
84   (pass-if "syntax-case manual swap!"
85     (sequal?
86      (let* ((sc (sc-expand '(syntax-case exp () ((swap! a b) (syntax (let ((temp a)) (set! a b) (set! b temp)))))))
87             (exp '(swap foo bar))
88             (foo "foo")
89             (bar "bar")
90             (s (eval sc (current-module)))
91             (d (syntax-object->datum s)))
92        (eval d (current-module))
93        (list foo bar))
94      '("bar" "foo"))))
95
96 (pass-if "define-syntax swap! [syntax-case]"
97   (sequal?
98    (let ()
99      (define-syntax swap!
100        (lambda (exp)
101          (syntax-case exp ()
102            ((swap! a b)
103             (syntax
104              ((lambda (temp)
105                 (set! a b)
106                 (set! b temp)) a))))))
107      (let ((foo "foo")
108            (bar "bar"))
109        (swap! foo bar)
110        (list foo bar)))
111    (list "bar" "foo")))
112
113 (pass-if "define-syntax swap! [syntax-case+let]"
114   (sequal?
115    (let ()
116      (define-syntax swap!
117        (lambda (exp)
118          (syntax-case exp ()
119            ((swap! a b)
120             (syntax
121              (let ((temp a))
122                (set! a b)
123                (set! b temp)))))))
124      (let ((foo "foo")
125            (bar "bar"))
126        (swap! foo bar)
127        (list foo bar)))
128    (list "bar" "foo")))
129
130 (pass-if "define-syntax sr:when [syntax-rules]"
131   (sequal?
132    (let ()
133      (define-syntax sr:when
134        (syntax-rules ()
135          ((sc:when condition exp ...)
136           (if condition
137               (begin exp ...)))))
138      (let ()
139        (sr:when #t "if not now, then?")))
140    "if not now, then?"))
141
142 (pass-if "define-syntax-rule"
143   (sequal?
144    (let ()
145      (define-syntax-rule (sre:when c e ...)
146        (if c (begin e ...)))
147      (let ()
148        (sre:when #t "if not now, then?")))
149    "if not now, then?"))
150
151 (pass-if-equal "syntax-rules plus"
152     (+ 1 2 3)
153   (let ()
154     (define-syntax plus
155       (syntax-rules ()
156         ((plus x ...) (+ x ...))))
157     (plus 1 2 3)))
158
159 (when guile?
160   (pass-if-equal "macro with quasisyntax"
161       '("foo" "foo")
162     (let ()
163       (define-syntax string-let
164         (lambda (stx)
165           (syntax-case stx ()
166             ((_ id body ...)
167              #`(let ((id #,(symbol->string (syntax->datum #'id))))
168                  body ...)))))
169       (string-let foo (list foo foo)))))
170
171   ;; (pass-if-equal "custom ellipsis within normal ellipsis"
172   ;;     '((((a x) (a y) (a …))
173   ;;        ((b x) (b y) (b …))
174   ;;        ((c x) (c y) (c …)))
175   ;;       (((a x) (b x) (c x))
176   ;;        ((a y) (b y) (c y))
177   ;;        ((a …) (b …) (c …))))
178   ;;   (let ()
179   ;;     (define-syntax foo
180   ;;       (syntax-rules ()
181   ;;         ((_ y ...)
182   ;;          (syntax-rules … ()
183   ;;            ((_ x …)
184   ;;             '((((x y) ...) …)
185   ;;               (((x y) …) ...)))))))
186   ;;     (define-syntax bar (foo x y …))
187   ;;     (bar a b c)))
188
189 (let ()
190  (define-syntax define-quotation-macros
191    (lambda (x)
192      (syntax-case x ()
193        ((_ (macro-name head-symbol) ...)
194         #'(begin (define-syntax macro-name
195                    (lambda (x)
196                      (with-ellipsis :::
197                                     (syntax-case x ()
198                                       ((_ x :::)
199                                        #'(quote (head-symbol x :::)))))))
200                  ...)))))
201  (define-quotation-macros (quote-a a) (quote-b b) (quote-c c))
202
203  (pass-if-equal "with-ellipsis"
204      '(a 1 2 3)
205      (quote-a 1 2 3)))
206
207 (result 'report)