about summary refs log tree commit diff stats
path: root/chicanery.sld
blob: 5c882d3ba2f68f8d1075a1df94c0cfc2bfa94927 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
;;; chicanery --- subtly breaking scheme expectations

(cond-expand
  (r7rs)
  (chicken (import r7rs utf8))
  (guile (install-r7rs!))
  (gambit (include "chicanery#.scm"))
  (else (display "Unsupported R7RS implementation.\n"
                 (current-error-port))))

(define-library (chicanery)
  ;; All the scheme stuff in one place
  (import (except (scheme base)
                  map for-each append))
  (import (rename (scheme base)
                  (map scheme/map)
                  (for-each scheme/for-each)
                  (append scheme/append)))
  (import (scheme case-lambda))
  (import (scheme char))
  (import (scheme complex))
  (import (scheme cxr))
  (import (scheme eval))
  (import (scheme file))
  (import (scheme inexact))
  (import (scheme lazy))
  (import (scheme load))
  (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?
          displayed ->string
          written
          print)

  (include "chicanery.extras.scm"))