path: root/chicanery.sld

;;; 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"))