1 files changed, 22 insertions, 390 deletions
diff --git a/chicanery.sld b/chicanery.sld
index e6d5697..3a179c1 100644
--- a/chicanery.sld
+++ b/chicanery.sld

@@ -1,391 +1,23 @@
-;;; chicanery --- subtly breaking scheme expectations
 (cond-expand
-  (r7rs)
+  (chicken
-  (chicken (import r7rs utf8))
+   (include "impl/chicken.scm"))
-  (guile (install-r7rs!))
+  (guile
-  (gambit (include "chicanery#.scm"))
+   (install-r7rs!)
-  (else (display "Unsupported R7RS implementation.\n"
+   (include "impl/guile.scm")
-                 (current-error-port))))
+   (include "extras.scm")
+   (export! append for-each map
-(define-library (chicanery)
+            list-append list-for-each list-map
-  ;; All the scheme stuff in one place
+            ref copy
-  (import (rename (scheme base)
+            atom?
-                  (map scheme/map)
+            read-port read-port-chunk-size
-                  (for-each scheme/for-each)
+            defined?
-                  (append scheme/append)))
+            with-output-to-string with-input-from-string
-  (import (scheme case-lambda))
+            displayed ->string written
-  (import (scheme char))
+            print))
-  (import (scheme complex))
+  (gambit
-  (import (scheme cxr))
+   (include "impl/gambit.scm"))
-  (import (scheme eval))
+  (r7rs
-  (import (scheme file))
+   (display "R7RS!\n")
-  (import (scheme inexact))
+   (define-library (chicanery)
-  (import (scheme lazy))
+     (include "impl/r7rs.scm")))
-  (import (scheme load))
+  (else (exit #f)))
-  (import (scheme process-context))
-  (import (scheme read))
-  (import (scheme repl))
-  (import (scheme time))
-  (import (scheme write))
-  (cond-expand
-    ;; Chicken doesn't build utf8 support in by default (at least <=5)
-    (chicken (import (utf8)))
-    ;; Gambit has an extra `namespace' argument to `define-library' forms
-    (gambit (namespace ""))
-    (else))
-  (export *
-          +
-          -
-          /
-          <=
-          <
-          >=
-          =
-          >
-          abs
-          and
-          append
-          apply
-          assoc
-          assq
-          assv
-          begin
-          binary-port?
-          boolean?
-          boolean=?
-          bytevector
-          bytevector-append
-          bytevector-copy
-          bytevector-copy!
-          bytevector-length
-          bytevector-u8-ref
-          bytevector-u8-set!
-          bytevector?
-          car
-          cdr
-          caar
-          cadr
-          cdar
-          cddr
-          call-with-current-continuation
-          call/cc
-          call-with-port
-          call-with-values
-          case
-          ceiling
-          char-ready?
-          char->integer
-          integer->char
-          char=?
-          char<?
-          char>?
-          char<=?
-          char>=?
-          char?
-          close-input-port
-          close-output-port
-          close-port
-          complex?
-          cond
-          cond-expand
-          cons
-          current-input-port
-          current-output-port
-          current-error-port
-          define
-          define-record-type
-          define-syntax
-          define-values
-          denominator
-          numerator
-          do
-          dynamic-wind
-          eof-object
-          eof-object?
-          eq?
-          eqv?
-          equal?
-          error
-          error-object-irritants
-          error-object-message
-          error-object?
-          even?
-          odd?
-          exact
-          inexact
-          exact-integer-sqrt
-          exact-integer?
-          exact?
-          inexact?
-          expt
-          features
-          file-error?
-          floor
-          floor/
-          floor-quotient
-          floor-remainder
-          flush-output-port
-          for-each
-          gcd
-          lcm
-          get-output-bytevector
-          get-output-string
-          guard
-          if
-          import
-          import-for-syntax
-          import-syntax
-          include
-          include-ci
-          input-port-open?
-          output-port-open?
-          input-port?
-          output-port?
-          integer?
-          lambda
-          length
-          let
-          let*
-          letrec
-          letrec*
-          let-values
-          let*-values
-          let-syntax
-          letrec-syntax
-          list
-          list-copy
-          list-ref
-          list-set!
-          list-tail
-          list?
-          list->vector
-          make-bytevector
-          make-list
-          make-parameter
-          make-string
-          make-vector
-          map
-          max
-          min
-          member
-          memq
-          memv
-          modulo
-          negative?
-          positive?
-          newline
-          not
-          null?
-          number->string
-          string->number
-          number?
-          open-input-bytevector
-          open-output-bytevector
-          open-input-string
-          open-output-string
-          or
-          pair?
-          parameterize
-          peek-char
-          peek-u8
-          port?
-          procedure?
-          quasiquote
-          quote
-          quotient
-          remainder
-          raise
-          raise-continuable
-          rational?
-          rationalize
-          read-bytevector
-          read-bytevector!
-          read-char
-          read-error?
-          read-line
-          read-string
-          read-u8
-          real?
-          reverse
-          round
-          set!
-          set-car!
-          set-cdr!
-          square
-          string
-          string->list
-          list->string
-          string->utf8
-          utf8->string
-          string->symbol
-          symbol->string
-          string->vector
-          string-append
-          string-copy
-          string-copy!
-          string-fill!
-          string-for-each
-          string-length
-          string-map
-          string-ref
-          string-set!
-          string=?
-          string<?
-          string>?
-          string<=?
-          string>=?
-          string?
-          substring
-          symbol=?
-          symbol?
-          syntax-error
-          syntax-rules
-          textual-port?
-          truncate
-          truncate/
-          truncate-quotient
-          truncate-remainder
-          u8-ready?
-          unless
-          ;;unquote
-          ;;unquote-splicing
-          values
-          vector
-          vector-append
-          vector-copy
-          vector-copy!
-          vector-fill!
-          vector-for-each
-          vector-length
-          vector-map
-          vector-ref
-          vector-set!
-          vector->list
-          vector->string
-          vector?
-          when
-          with-exception-handler
-          write-bytevector
-          write-char
-          write-string
-          write-u8
-          zero?
-          )
-  (export case-lambda)
-  (export char-alphabetic?
-          char-ci<=?
-          char-ci<?
-          char-ci=?
-          char-ci>=?
-          char-ci>?
-          char-downcase
-          char-foldcase
-          char-lower-case?
-          char-numeric?
-          char-upcase
-          char-upper-case?
-          char-whitespace?
-          digit-value
-          string-ci<=?
-          string-ci<?
-          string-ci=?
-          string-ci>=?
-          string-ci>?
-          string-downcase
-          string-foldcase
-          string-upcase)
-  (export angle
-          imag-part
-          magnitude
-          make-polar
-          make-rectangular
-          real-part)
-  (export caaaar
-          caaadr
-          caaar
-          caadar
-          caaddr
-          caadr
-          cadaar
-          cadadr
-          cadar
-          caddar
-          cadddr
-          caddr
-          cdaaar
-          cdaadr
-          cdaar
-          cdadar
-          cdaddr
-          cdadr
-          cddaar
-          cddadr
-          cddar
-          cdddar
-          cddddr
-          cdddr)
-  (export environment
-          eval)
-  (export call-with-input-file
-          call-with-output-file
-          delete-file
-          file-exists?
-          open-binary-input-file
-          open-binary-output-file
-          open-input-file
-          open-output-file
-          with-input-from-file
-          with-output-to-file)
-  (export acos
-          asin
-          atan
-          cos
-          exp
-          finite?
-          infinite?
-          log
-          nan?
-          sin
-          sqrt
-          tan)
-  (export delay
-          delay-force
-          force
-          make-promise
-          promise?)
-  (export load)
-  (export command-line
-          emergency-exit
-          exit
-          get-environment-variable
-          get-environment-variables)
-  (export read)
-  (export interaction-environment)
-  (export current-jiffy
-          current-second
-          jiffies-per-second)
-  (export display
-          write
-          write-shared
-          write-simple)
-  ;; Extras
-  (export list-map
-          list-for-each
-          list-append
-          ref
-          copy
-          atom?
-          read-port
-          read-port-chunk-size
-          defined?
-          with-output-to-string
-          with-input-from-string
-          displayed ->string
-          written
-          print)
-  (include "chicanery.extras.scm"))

diff --git a/chicanery.sld b/chicanery.sld index e6d5697..3a179c1 100644 --- a/chicanery.sld +++ b/chicanery.sld
@@ -1,391 +1,23 @@
1	;;; chicanery --- subtly breaking scheme expectations
2
3	(cond-expand	1	(cond-expand
4	(r7rs)	2	(chicken
5	(chicken (import r7rs utf8))	3	(include "impl/chicken.scm"))
6	(guile (install-r7rs!))	4	(guile
7	(gambit (include "chicanery#.scm"))	5	(install-r7rs!)
8	(else (display "Unsupported R7RS implementation.\n"	6	(include "impl/guile.scm")
9	(current-error-port))))	7	(include "extras.scm")
10		8	(export! append for-each map
11	(define-library (chicanery)	9	list-append list-for-each list-map
12	;; All the scheme stuff in one place	10	ref copy
13	(import (rename (scheme base)	11	atom?
14	(map scheme/map)	12	read-port read-port-chunk-size
15	(for-each scheme/for-each)	13	defined?
16	(append scheme/append)))	14	with-output-to-string with-input-from-string
17	(import (scheme case-lambda))	15	displayed ->string written
18	(import (scheme char))	16	print))
19	(import (scheme complex))	17	(gambit
20	(import (scheme cxr))	18	(include "impl/gambit.scm"))
21	(import (scheme eval))	19	(r7rs
22	(import (scheme file))	20	(display "R7RS!\n")
23	(import (scheme inexact))	21	(define-library (chicanery)
24	(import (scheme lazy))	22	(include "impl/r7rs.scm")))
25	(import (scheme load))	23	(else (exit #f)))
26	(import (scheme process-context))
27	(import (scheme read))
28	(import (scheme repl))
29	(import (scheme time))
30	(import (scheme write))
31
32	(cond-expand
33	;; Chicken doesn't build utf8 support in by default (at least <=5)
34	(chicken (import (utf8)))
35	;; Gambit has an extra `namespace' argument to `define-library' forms
36	(gambit (namespace ""))
37	(else))
38
39	(export *
40	+
41	-
42	/
43	<=
44	<
45	>=
46	=
47	>
48	abs
49	and
50	append
51	apply
52	assoc
53	assq
54	assv
55	begin
56	binary-port?
57	boolean?
58	boolean=?
59	bytevector
60	bytevector-append
61	bytevector-copy
62	bytevector-copy!
63	bytevector-length
64	bytevector-u8-ref
65	bytevector-u8-set!
66	bytevector?
67	car
68	cdr
69	caar
70	cadr
71	cdar
72	cddr
73	call-with-current-continuation
74	call/cc
75	call-with-port
76	call-with-values
77	case
78	ceiling
79	char-ready?
80	char->integer
81	integer->char
82	char=?
83	char<?
84	char>?
85	char<=?
86	char>=?
87	char?
88	close-input-port
89	close-output-port
90	close-port
91	complex?
92	cond
93	cond-expand
94	cons
95	current-input-port
96	current-output-port
97	current-error-port
98	define
99	define-record-type
100	define-syntax
101	define-values
102	denominator
103	numerator
104	do
105	dynamic-wind
106	eof-object
107	eof-object?
108	eq?
109	eqv?
110	equal?
111	error
112	error-object-irritants
113	error-object-message
114	error-object?
115	even?
116	odd?
117	exact
118	inexact
119	exact-integer-sqrt
120	exact-integer?
121	exact?
122	inexact?
123	expt
124	features
125	file-error?
126	floor
127	floor/
128	floor-quotient
129	floor-remainder
130	flush-output-port
131	for-each
132	gcd
133	lcm
134	get-output-bytevector
135	get-output-string
136	guard
137	if
138	import
139	import-for-syntax
140	import-syntax
141	include
142	include-ci
143	input-port-open?
144	output-port-open?
145	input-port?
146	output-port?
147	integer?
148	lambda
149	length
150	let
151	let*
152	letrec
153	letrec*
154	let-values
155	let*-values
156	let-syntax
157	letrec-syntax
158	list
159	list-copy
160	list-ref
161	list-set!
162	list-tail
163	list?
164	list->vector
165	make-bytevector
166	make-list
167	make-parameter
168	make-string
169	make-vector
170	map
171	max
172	min
173	member
174	memq
175	memv
176	modulo
177	negative?
178	positive?
179	newline
180	not
181	null?
182	number->string
183	string->number
184	number?
185	open-input-bytevector
186	open-output-bytevector
187	open-input-string
188	open-output-string
189	or
190	pair?
191	parameterize
192	peek-char
193	peek-u8
194	port?
195	procedure?
196	quasiquote
197	quote
198	quotient
199	remainder
200	raise
201	raise-continuable
202	rational?
203	rationalize
204	read-bytevector
205	read-bytevector!
206	read-char
207	read-error?
208	read-line
209	read-string
210	read-u8
211	real?
212	reverse
213	round
214	set!
215	set-car!
216	set-cdr!
217	square
218	string
219	string->list
220	list->string
221	string->utf8
222	utf8->string
223	string->symbol
224	symbol->string
225	string->vector
226	string-append
227	string-copy
228	string-copy!
229	string-fill!
230	string-for-each
231	string-length
232	string-map
233	string-ref
234	string-set!
235	string=?
236	string<?
237	string>?
238	string<=?
239	string>=?
240	string?
241	substring
242	symbol=?
243	symbol?
244	syntax-error
245	syntax-rules
246	textual-port?
247	truncate
248	truncate/
249	truncate-quotient
250	truncate-remainder
251	u8-ready?
252	unless
253	;;unquote
254	;;unquote-splicing
255	values
256	vector
257	vector-append
258	vector-copy
259	vector-copy!
260	vector-fill!
261	vector-for-each
262	vector-length
263	vector-map
264	vector-ref
265	vector-set!
266	vector->list
267	vector->string
268	vector?
269	when
270	with-exception-handler
271	write-bytevector
272	write-char
273	write-string
274	write-u8
275	zero?
276	)
277	(export case-lambda)
278	(export char-alphabetic?
279	char-ci<=?
280	char-ci<?
281	char-ci=?
282	char-ci>=?
283	char-ci>?
284	char-downcase
285	char-foldcase
286	char-lower-case?
287	char-numeric?
288	char-upcase
289	char-upper-case?
290	char-whitespace?
291	digit-value
292	string-ci<=?
293	string-ci<?
294	string-ci=?
295	string-ci>=?
296	string-ci>?
297	string-downcase
298	string-foldcase
299	string-upcase)
300	(export angle
301	imag-part
302	magnitude
303	make-polar
304	make-rectangular
305	real-part)
306	(export caaaar
307	caaadr
308	caaar
309	caadar
310	caaddr
311	caadr
312	cadaar
313	cadadr
314	cadar
315	caddar
316	cadddr
317	caddr
318	cdaaar
319	cdaadr
320	cdaar
321	cdadar
322	cdaddr
323	cdadr
324	cddaar
325	cddadr
326	cddar
327	cdddar
328	cddddr
329	cdddr)
330	(export environment
331	eval)
332	(export call-with-input-file
333	call-with-output-file
334	delete-file
335	file-exists?
336	open-binary-input-file
337	open-binary-output-file
338	open-input-file
339	open-output-file
340	with-input-from-file
341	with-output-to-file)
342	(export acos
343	asin
344	atan
345	cos
346	exp
347	finite?
348	infinite?
349	log
350	nan?
351	sin
352	sqrt
353	tan)
354	(export delay
355	delay-force
356	force
357	make-promise
358	promise?)
359	(export load)
360	(export command-line
361	emergency-exit
362	exit
363	get-environment-variable
364	get-environment-variables)
365	(export read)
366	(export interaction-environment)
367	(export current-jiffy
368	current-second
369	jiffies-per-second)
370	(export display
371	write
372	write-shared
373	write-simple)
374
375	;; Extras
376	(export list-map
377	list-for-each
378	list-append
379	ref
380	copy
381	atom?
382	read-port
383	read-port-chunk-size
384	defined?
385	with-output-to-string
386	with-input-from-string
387	displayed ->string
388	written
389	print)
390
391	(include "chicanery.extras.scm"))