s7

s7 is a Scheme implementation intended as an extension language for other applications, primarily Snd, Radium, and Common Music. It exists as just two files, s7.c and s7.h, that want only to disappear into someone else's source tree. There are no libraries, no run-time init files, and no configuration scripts. It can be built as a stand-alone interpreter (see below). s7test.scm is a regression test for s7. A tarball is available: s7 tarball.

s7 is the default extension language of Snd and sndlib (snd), Rick Taube's Common Music (commonmusic at sourceforge), and Kjetil Matheussen's Radium music editor. There are X, Motif, Gtk, and openGL bindings in libxm in the Snd tarball, or at ftp://ccrma-ftp.stanford.edu/pub/Lisp/libxm.tar.gz. If you're running s7 in a context that has getenv, file-exists?, and system, you can use s7-slib-init.scm to gain easy access to slib. This init file is named "s7.init" in the slib distribution.

Although it is a descendant of tinyScheme, s7 is closest as a Scheme dialect to Guile 1.8. I believe it is compatible with r5rs and r7rs: you can just ignore all the additions discussed in this file. It has continuations, ratios, complex numbers, macros, keywords, hash-tables, multiprecision arithmetic, generalized set!, unicode, and so on. It does not have syntax-rules or any of its friends, and it does not think there is any such thing as an inexact integer.

This file assumes you know about Scheme and all its problems, and want a quick tour of where s7 is different. (Well, it was quick once upon a time). The main difference: if it's in s7, it's a first-class citizen of s7, and that includes macros, environments, and syntactic forms.

> I originally used a small font for scholia, but now I have to squint to read that tiny text, so less-than-vital commentaries are shown in the normal font, but indented and on a sort of brownish background.

- arbitrary precision arithmetic
- math functions
- define*, named let*
- define-macro
- procedure-setter
- generalized set!
- multidimensional vectors
- hash tables
- environments
- multiple-values
- call-with-exit
- format
- hooks
- procedure info
- eval
- IO and other OS functions
- errors
- autoload
- define-constant, symbol-access
- marvels and curiousities:
  - *load-path*, *features*, *#readers*,
  - make-list, char-position, keywords
  - symbol-table, help, gc, morally-equal?
  - define-expansion, *s7*, r5rs, r7rs,
  - profiling, circular lists, legolambda, etc...
- FFI examples
  - read-eval-print loop (and emacs)
  - define a function with arguments and a returned value, and define a variable
  - call a Scheme function from C, and get/set Scheme variable values in C
  - C++ and Juce
  - load sndlib using the Xen functions and macros
  - add a new Scheme type and a procedure with a setter
  - redirect display output to a C procedure
  - extend a built-in operator ("+" in this case)
  - C-side define* (s7_define_function_star)
  - C-side define-macro (s7_define_macro)
  - define a generic function in C
  - signal handling (C-C to break out of an infinite loop)
  - direct multidimensional vector element access
  - notification in C that a Scheme variable has been set!
  - Load C defined stuff into a separate namespace
  - Error handling in C
  - Hooks in C and Scheme
  - Load a C module dynamically
  - gmp and friends
  - glistener.c
  - gdb
- s7 examples
  - cload.scm
    - libc
    - libgsl
    - libgdbm
  - repl.scm
  - lint.scm

#### multiprecision arithmetic

All numeric types, integers, ratios, reals, and complex numbers are supported. The basic integer and real types are defined in s7.h, defaulting to long long int and double. A ratio consists of two integers, a complex number two reals. pi is predefined, as are most-positive-fixnum and most-negative-fixnum. s7 can be built with multiprecision support for all types, using the gmp, mpfr, and mpc libraries (set WITH_GMP to 1 in s7.c). If multiprecision arithmetic is enabled, the following functions are included: bignum, and bignum?, and the variable (*s7* 'bignum-precision). (*s7* 'bignum-precision) defaults to 128; it sets the number of bits each float takes. pi automatically reflects the current (*s7* 'bignum-precision):

    > pi
    3.141592653589793238462643383279502884195E0
    > (*s7* 'bignum-precision)
    128
    > (set! (*s7* 'bignum-precision) 256)
    256
    > pi
    3.141592653589793238462643383279502884197169399375105820974944592307816406286198E0

bignum? returns #t if its argument is a big number of some type; I use "bignum" for any big number, not just integers. To create a big number, either include enough digits to overflow the default types, or use the bignum function. Its argument is a string representing the desired number:

    > (bignum "123456789123456789")
    123456789123456789
    > (bignum "1.123123123123123123123123123")
    1.12312312312312312312312312300000000009E0

> In the non-gmp case, if s7 is built using doubles (s7_double in s7.h), the float "epsilon" is around (expt 2 -53), or about 1e-16. In the gmp case, it is around (expt 2 (- (*s7* 'bignum-precision))). So in the default case (precision = 128), using gmp:

>     > (= 1.0 (+ 1.0 (expt 2.0 -128)))
>     #t
>     > (= 1.0 (+ 1.0 (expt 2.0 -127)))
>     #f

> and in the non-gmp case:

>     > (= 1.0 (+ 1.0 (expt 2 -53)))
>     #t
>     > (= 1.0 (+ 1.0 (expt 2 -52)))
>     #f

> In the gmp case, integers and ratios are limited only by the size of memory, but reals are limited by (*s7* 'bignum-precision). This means, for example, that

>     > (floor 1e56) ; (*s7* 'bignum-precision) is 128
>     99999999999999999999999999999999999999927942405962072064
>     > (set! (*s7* 'bignum-precision) 256)
>     256
>     > (floor 1e56)
>     100000000000000000000000000000000000000000000000000000000

> The non-gmp case is similar, but it's easy to find the edge cases:

>     > (floor (+ 0.9999999995 (expt 2.0 23)))
>     8388609

#### math functions

s7 includes:

- sinh, cosh, tanh, asinh, acosh, atanh
- logior, logxor, logand, lognot, logbit?, ash, integer-length, integer-decode-float
- random
- nan?, infinite?

The random function can take any numeric argument, including 0. The following constants are predefined: pi, most-positive-fixnum, most-negative-fixnum. Other math-related differences between s7 and r5rs:

- rational? and exact mean integer or ratio (i.e. not floating point), inexact means not exact.
- floor, ceiling, truncate, and round return (exact) integer results.
- "#" does not stand for an unknown digit.
- the "@" complex number notation is not supported ("@" is an exponent marker in s7).
- "+i" is not considered a number; include the real part.
- modulo, remainder, and quotient take integer, ratio, or real arguments.
- lcm and gcd can take integer or ratio arguments.
- log takes an optional second argument, the base.
- '.' and an exponent can occur in a number in any base.
- rationalize returns a ratio!
- case is significant in numbers, as elsewhere: #b0 is 0, but #B0 is an error.

    > (exact? 1.0)
    #f
    > (rational? 1.5)
    #f
    > (floor 1.4)
    1
    > (remainder 2.4 1)
    0.4
    > (modulo 1.4 1.0)
    0.4
    > (lcm 3/4 1/6)
    3/2
    > (log 8 2)
    3
    > (number->string 0.5 2)
    "0.1"
    > (string->number "0.1" 2)
    0.5
    > (rationalize 1.5)
    3/2
    > (complex 1/2 0)
    1/2
    > (logbit? 6 1) ; argument order, (logbit? int index), follows gmp, not CL
    #t

See cload and libgsl.scm for easy access to GSL, and similarly libm.scm for the C math library.

> The exponent itself is always in base 10; this follows gmp usage. Scheme normally uses "@" for its useless polar notation, but that means `(string->number "1e1" 16)` is ambiguous — is the "e" a digit or an exponent marker? In s7, "@" is an exponent marker.

>     > (string->number "1e9" 2)  ; (expt 2 9)
>     512.0
>     > (string->number "1e1" 12) ; "e" is not a digit in base 12
>     #f
>     > (string->number "1e1" 16) ; (+ (* 1 16 16) (* 14 16) 1)
>     481
>     > (string->number "1.2e1" 3); (* 3 (+ 1 2/3))
>     5.0

> Should s7 predefine the numbers +inf.0, -inf.0, and nan.0? It doesn't currently, but you can get them via log or 1/0 (see below). But what is `(/ 1.0 0.0)`? s7 gives a "division by zero" error here, and also in `(/ 1 0)`. Guile returns +inf.0 in the first case, which seems reasonable, but a "numerical overflow" error in the second. Slightly weirder is `(expt 0.0 0+i)`. Currently s7 returns 0.0, Guile returns +nan.0+nan.0i, Clisp and sbcl throw an error. Everybody agrees that `(expt 0 0)` is 1, and Guile thinks that `(expt 0.0 0.0)` is 1.0. But `(expt 0 0.0)` and `(expt 0.0 0)` return different results in Guile (1 and 1.0), both are 0.0 in s7, the first is an error in Clisp, but the second returns 1, and so on — what a mess! This mess was made a lot worse than it needs to be when the IEEE decreed that 0.0 equals -0.0, so we can't tell them apart, but that they produce different results in nearly every use!

>     scheme@(guile-user)> (= -0.0 0.0)
>     #t
>     scheme@(guile-user)> (negative? -0.0)
>     #f
>     scheme@(guile-user)> (= (/ 1.0 0.0) (/ 1.0 -0.0))
>     #f
>     scheme@(guile-user)>  (< (/ 1.0 -0.0) -1e100 1e100 (/ 1.0 0.0))
>     #t

> How can they be equal? In s7, the sign of -0.0 is ignored, and they really are equal. One other oddity: two floats can satisfy eq? and yet not be eqv?: `(eq? nan.0 nan.0)` might be #t (it is unspecified), but `(eqv? nan.0 nan.0)` is #f. The same problem afflicts memq and assq.

> The random function takes a range and an optional state, and returns a number between zero and the range, of the same type as the range. It is perfectly reasonable to use a range of 0, in which case random returns 0. random-state creates a new random state from a seed. If no state is passed, random uses some default state initialized from the current time. random-state? returns #t if passed a random state object.

>     > (random 0)
>     0
>     > (random 1.0)
>     0.86331198514245
>     > (random 3/4)
>     654/1129
>     > (random 1+i)
>     0.86300308872748+0.83601002730848i
>     > (random -1.0)
>     -0.037691127513267
>     > (define r0 (random-state 1234))
>     r0
>     > (random 100 r0)
>     94
>     > (random 100 r0)
>     19
>     > (define r1 (random-state 1234))
>     r1
>     > (random 100 r1)
>     94
>     > (random 100 r1)
>     19

> copy the random-state to save a spot in a random number sequence, or save the random-state as a list via random-state->list, then to restart from that point, apply random-state to that list.

> I can't find the right tone for this section; this is the 400-th revision; I wish I were a better writer!

> In some Schemes, "rational" means "could possibly be expressed equally well as a ratio: floats are approximations". In s7 it's: "is actually expressed (at the scheme level) as a ratio (or an integer of course)"; otherwise "rational?" is the same as "real?":

>     (not-s7)> (rational? (sqrt 2))
>     #t

> That 1.0 is represented at the IEEE-float level as a sort of ratio does not mean it has to be a scheme ratio; the two notions are independent.

> But that confusion is trivial compared to the completely nutty "inexact integer". As I understand it, "inexact" originally meant "floating point", and "exact" meant integer or ratio of integers. But words have a life of their own. 0.0 somehow became an "inexact" integer (although it can be represented exactly in floating point). +inf.0 must be an integer — its fractional part is explicitly zero! But +nan.0... And then there's:

>     (not-s7)> (integer? 9007199254740993.1)
>     #t

> When does this matter? I often need to index into a vector, but the index is a float (a "real" in Scheme-speak: its fractional part can be non-zero). In one Scheme:

>     (not-s7)> (vector-ref #(0) (floor 0.1))
>     ERROR: Wrong type (expecting exact integer): 0.0   ; [why?  "it's probably a programmer mistake"!]

> Not to worry, I'll use inexact->exact:

>     (not-s7)> (inexact->exact 0.1)
>     3602879701896397/36028797018963968                  ; [why? "floats are ratios"!]

> So I end up using the verbose `(floor (inexact->exact ...))` everywhere, and even then I have no guarantee that I'll get a legal vector index. I have never seen any use made of the exact/inexact distinction — just wild flailing to try get around it. I think the whole idea is confused and useless, and leads to verbose and buggy code. If we discard it, we can maintain backwards compatibility via:

>     (define exact? rational?)
>     (define (inexact? x) (not (rational? x)))
>     (define inexact->exact rationalize) ; or floor
>     (define (exact->inexact x) (* x 1.0))

> #i and #e are also useless because you can have any number after, for example, #b:

>     > #b1.1
>     1.5
>     > #b1e2
>     4.0
>     > #o17.5+i
>     15.625+1i

> Speaking of #b and friends, what should `(string->number "#xffff" 2)` return?

> more examples

>     (define (log-n-of n . ints)     ; return the bits on in exactly n of ints
>       (let ((len (length ints)))
>         (cond ((= len 0) (if (= n 0) -1 0))
>     	  ((= n 0)   (lognot (apply logior ints)))
>     	  ((= n len) (apply logand ints))
>     	  ((> n len) 0)
>     	  (#t
>     	   (do ((1s 0)
>     		(prev ints)
>     		(i 0 (+ i 1)))
>     	       ((= i len) 1s)
>     	     (let ((cur (ints i)))
>     	       (if (= i 0)
>     		   (set! 1s (logior 1s (logand cur (apply log-n-of (- n 1) (cdr ints)))))
>     		   (let ((mid (cdr prev)))
>     		     (set! (cdr prev) (if (= i (- len 1)) () (cdr mid)))
>     		     (set! 1s (logior 1s (logand cur (apply log-n-of (- n 1) ints))))
>     		     (set! (cdr prev) mid)
>     		     (set! prev mid)))))))))

#### define*, lambda*

define* and lambda* are extensions of define and lambda that make it easier to deal with optional, keyword, and rest arguments. The syntax is very simple: every argument to define* has a default value and is automatically available as a keyword argument. The default value is either #f if unspecified, or given in a list whose first member is the argument name. The last argument can be preceded by :rest or a dot to indicate that all other trailing arguments should be packaged as a list under that argument's name. A trailing or rest argument's default value is ().

    (define* (hi a (b 32) (c "hi")) (list a b c))

Here the argument "a" defaults to #f, "b" to 32, etc. When the function is called, the argument names are set from the values passed the function, then any unset arguments are bound to their default values, evaluated in left-to-right order. As the current argument list is scanned, any name that occurs as a keyword, :arg for example where the parameter name is arg, sets that argument's new value. Otherwise, as values occur, they are plugged into the actual argument list based on their position, counting a keyword/value pair as one argument. This is called an optional-key list in CLM. So, taking the function above as an example:

    > (hi 1)
    (1 32 "hi")
    > (hi :b 2 :a 3)
    (3 2 "hi")
    > (hi 3 2 1)
    (3 2 1)

See s7test.scm for many examples. (s7's define* is very close to srfi-89's define*).

> The combination of optional and keyword arguments is viewed with disfavor in the Lisp community, but the problem is in CL's implementation of the idea, not the idea itself. I've used the s7 style since around 1976, and have never found it confusing. The mistake in CL is to require the optional arguments if a keyword argument occurs, and to consider them as distinct from the keyword arguments. So everyone forgets and puts a keyword where CL expects a required-optional argument. CL then does something ridiculous, and the programmer stomps around shouting about keywords, but the fault lies with CL. If s7's way is considered too loose, one way to tighten it might be to insist that once a keyword is used, only keyword argument pairs can follow.

> A natural companion of lambda* is named let*. In named let, the implicit function's arguments have initial values, but thereafter, each call requires the full set of arguments. Why not treat the initial values as default values?

>     > (let* func ((i 1) (j 2))
>         (+ i j (if (> i 0) (func (- i 1)) 0)))
>     5
>     > (letrec ((func (lambda* ((i 1) (j 2))
>                        (+ i j (if (> i 0) (func (- i 1)) 0)))))
>         (func))
>     5

> This is consistent with the lambda* arguments because their defaults are already set in left-to-right order, and as each parameter is set to its default value, the binding is added to the default value expression environment (just as if it were a let*). The let* name itself (the implicit function) is not defined until after the bindings have been evaluated (as in named let).

> In CL, keyword default values are handled in the same way:

>     > (defun foo (&key (a 0) (b (+ a 4)) (c (+ a 7))) (list a b c))
>     FOO
>     > (foo :b 2 :a 60)
>     (60 2 67)

> In s7, we'd use:

>     (define* (foo (a 0) (b (+ a 4)) (c (+ a 7))) (list a b c))

> To try to catch what I believe are usually mistakes, I added two error checks. One is triggered if you set the same parameter twice in the same call, and the other if an unknown keyword is encountered in the key position. These problems arise in a case such as

>     (define* (f (a 1) (b 2)) (list a b))

> You could do any of the following by accident:

>     (f 1 :a 2)  ; what is a?
>     (f :b 1 2)  ; what is b?
>     (f :c 3)    ; did you really want a to be :c and b to be 3?

> In the last case, to pass a keyword deliberately, either include the argument keyword: `(f :a :c)`, or make the default value a keyword: `(define* (f (a :c) ...))`. To turn off this error check, add :allow-other-keys at the end of the parameter list.

> rest arg nits

> s7's lambda* arglist handling is not the same as CL's lambda-list. First, you can have more than one :rest parameter:

>     > ((lambda* (:rest a :rest b) (map + a b)) 1 2 3 4 5)
>     '(3 5 7 9)

> and second, the rest parameter, if any, takes up an argument slot just like any other argument:

>     > ((lambda* ((b 3) :rest x (c 1)) (list b c x)) 32)
>     (32 1 ())
>     > ((lambda* ((b 3) :rest x (c 1)) (list b c x)) 1 2 3 4 5)
>     (1 3 (2 3 4 5))

> CL would agree with the first case if we used &key for 'c', but would give an error in the second. Of course, the major difference is that s7 keyword arguments don't insist that the key be present. The :rest argument is needed in cases like these because we can't use an expression such as:

>     > ((lambda* ((a 3) . b c) (list a b c)) 1 2 3 4 5)
>     error: stray dot?
>     > ((lambda* (a . (b 1)) b) 1 2) ; the reader turns the arglist into (a b 1)
>     error: lambda* parameter '1 is a constant

> Yet another nit: the :rest argument is not considered a keyword argument, so

>     > (define* (f :rest a) a)
>     f
>     > (f :a 1)
>     (:a 1)

#### macros

define-macro, define-macro*, macroexpand, gensym, gensym?, and macro? implement the standard old-time macros.

    > (define-macro (and-let* vars . body)
        `(let () (and ,@(map (lambda (v) `(define ,@v)) vars) (begin ,@body))))

    > (define-macro (trace f)
        `(define ,f
           (apply lambda 'args
             `((format () "(~A ~{~A~^ ~}) -> " ',',f args)
               (let ((val (apply ,,f args)))
                 (format () "~A~%" val)
                 val)))))
    trace
    > (trace abs)
    abs
    > (abs -1.5)
    (abs -1.5) -> 1.5
    1.5

macroexpand can help debug a macro. I always forget that it wants an expression:

    > (define-macro (add-1 arg) `(+ 1 ,arg))
    add-1
    > (macroexpand (add-1 32))
    (+ 1 32)

gensym returns a symbol that is guaranteed to be unused. It takes an optional string argument giving the new symbol name's prefix. gensym? returns #t if its argument is a symbol created by gensym.

    (define-macro (pop! sym)
      (let ((v (gensym)))
        `(let ((,v (car ,sym)))
           (set! ,sym (cdr ,sym))
           ,v)))

As in define*, the starred forms give optional and keyword arguments:

    > (define-macro* (add-2 a (b 2)) `(+ ,a ,b))
    add-2
    > (add-2 1 3)
    4
    > (add-2 1)
    3
    > (add-2 :b 3 :a 1)
    4

A bacro is a macro that expands its body and evaluates the result in the calling environment.

    (define setf
      (let ((args (gensym))
            (name (gensym)))
         (apply define-bacro `((,name . ,args)
    			   (unless (null? ,args)
    			     (apply set! (car ,args) (cadr ,args) ())
    			     (apply setf (cddr ,args)))))))

The setf argument is a gensym (created when setf is defined) so that its name does not shadow any existing variable. Bacros expand in the calling environment, and a normal argument name might shadow something in that environment while the bacro is being expanded. Similarly, if you introduce bindings in the bacro expansion code, you need to keep track of which environment you want things to happen in. Use with-let and gensym liberally. stuff.scm has bacro-shaker which can find inadvertent name collisions, but it is flighty and easily confused. See s7test.scm for many examples of macros including such perennial favorites as loop, dotimes, do*, enum, pushnew, and defstruct. The calling environment itself is (outlet (curlet)) from within a bacro, so

    (define-bacro (holler)
      `(format *stderr* "(~S~{ ~S ~S~^~})~%"
    	   (let ((f __func__))
    	     (if (pair? f) (car f) f))
    	   (map (lambda (slot)
    		  (values (symbol->keyword (car slot)) (cdr slot)))
    		(reverse (map values ,(outlet (curlet)))))))

    (define (f1 a b)
      (holler)
      (+ a b))

    (f1 2 3) ; prints out "(f1 :a 2 :b 3)" and returns 5

> Since a bacro (normally) sheds its define-time environment:

>     (define call-bac
>       (let ((x 2))
>         (define-bacro (m a) `(+ ,a ,x))))

>     > (call-bac 1)
>     error: x: unbound variable

> A macro here returns 3. But don't be hasty! The bacro can get its define-time environment (its closure) via funclet, so in fact, define-macro is a special case of define-bacro! We can define macros that work in all four ways: the expansion can happen in either the definition or calling environment, as can the evaluation of that expansion. In a bacro, both happen in the calling environment if we take no other action, and in a normal macro (define-macro), the expansion happens in the definition environment, and the evaluation in the calling environment. Here's a brief example of all four:

>     (let ((x 1) (y 2))
>       (define-bacro (bac1 a)
>          `(+ ,x y ,a))        ; expand and eval in calling env
>       (let ((x 32) (y 64))
>         (bac1 3)))            ; (with-let (inlet 'x 32 'y 64) (+ 32 y 3))
>     -> 99                     ;  with-let and inlet refer to environments

>     (let ((x 1) (y 2))        ; this is like define-macro
>       (define-bacro (bac2 a)
>         (with-let (sublet (funclet bac2) :a a)
>           `(+ ,x y ,a)))      ; expand in definition env, eval in calling env
>       (let ((x 32) (y 64))
>         (bac2 3)))            ; (with-let (inlet 'x 32 'y 64) (+ 1 y 3))
>     -> 68

>     (let ((x 1) (y 2))
>       (define-bacro (bac3 a)
>         (let ((e (with-let (sublet (funclet bac3) :a a)
>     	       `(+ ,x y ,a))))
>           `(with-let ,(sublet (funclet bac3) :a a)
>     	 ,e)))           ; expand and eval in definition env
>       (let ((x 32) (y 64))
>         (bac3 3)))           ; (with-let (inlet 'x 1 'y 2) (+ 1 y 3))
>     -> 6

>     (let ((x 1) (y 2))
>       (define-bacro (bac4 a)
>         (let ((e `(+ ,x y ,a)))
>           `(with-let ,(sublet (funclet bac4) :a a)
>     	 ,e)))           ; expand in calling env, eval in definition env
>       (let ((x 32) (y 64))
>         (bac4 3)))           ; (with-let (inlet 'x 1 'y 2) (+ 32 y 3))
>     -> 37

> As the setf example shows, a macro is a first-class citizen of s7. You can pass it as a function argument, apply it to a list, return it from a function, call it recursively, and assign it to a variable. You can even set its procedure-setter!

>     > (define-macro (hi a) `(+ ,a 1))
>     hi
>     > (apply hi '(4))
>     5
>     > (define (fmac mac) (apply mac '(4)))
>     fmac
>     > (fmac hi)
>     5
>     > (define (fmac mac) (mac 4))
>     fmac
>     > (fmac hi)
>     5
>     > (define (make-mac)
>         (define-macro (hi a) `(+ ,a 1)))
>     make-mac
>     > (let ((x (make-mac)))
>         (x 2))
>     3
>     > (define-macro (ref v i) `(vector-ref ,v ,i))
>     ref
>     > (define-macro (set v i x) `(vector-set! ,v ,i ,x))
>     set
>     > (set! (procedure-setter ref) set)
>     set
>     > (let ((v (vector 1 2 3))) (set! (ref v 0) 32) v)
>     #(32 2 3)

> To expand all the macros in a piece of code:

>     (define-macro (fully-macroexpand form)
>       (list 'quote
>         (let expand ((form form))
>           (cond ((not (pair? form)) form)
>                 ((and (symbol? (car form))
>                       (macro? (symbol->value (car form))))
>                  (expand (apply macroexpand (list form))))
>                 ((and (eq? (car form) 'set!)  ; look for (set! (mac ...) ...) and use mac's procedure-setter
>                       (pair? (cdr form))
>                       (pair? (cadr form))
>                       (macro? (symbol->value (caadr form))))
>                  (expand
>                   (apply (eval
>                      (procedure-source (procedure-setter (symbol->value (caadr form)))))
>                     (append (cdadr form) (cddr form)))))
>                 (else (cons (expand (car form)) (expand (cdr form))))))))

> This does not always handle bacros correctly because their expansion can depend on the run-time state.

> backquote details

> Backquote (quasiquote) in s7 is almost trivial. Constants are unchanged, symbols are quoted, ",arg" becomes "arg", and ",@arg" becomes "(apply values arg)" — hooray for real multiple values! It's almost as easy to write the actual macro body as the backquoted version of it.

>     > (define-macro (hi a) `(+ 1 ,a))
>     hi
>     > (procedure-source hi)
>     (lambda (a) ({list} '+ 1 a))

>     > (define-macro (hi a) `(+ 1 ,@a))
>     hi
>     > (procedure-source hi)
>     (lambda (a) ({list} '+ 1 ({apply_values} a)))

> {list} is a special version of list to avoid name collisions and handle a few tricky details (similarly for {apply_values}). There is no unquote-splicing macro in s7; ",@(...)" becomes "(unquote ({apply_values} ...))" at read-time. There shouldn't be any unquote either. In Scheme the reader turns ,x into (unquote x), so:

>     > (let (,'a) unquote)
>     a
>     > (let (, (lambda (x) (+ x 1))) ,,,,'3)
>     7

> comma becomes a sort of symbol macro! I think I'll remove unquote; ,x and ,@x will still work as expected, but there will not be any "unquote" or "unquote-splicing" in the resultant source code. Just to make life difficult:

>     > (let (' 1) quote)
>     1

> but that translation is so ingrained in lisp that I'm reluctant to change it. The two unquote names, on the other hand, seem unnecessary.

> s7 macros are not hygienic. For example,

>     > (define-macro (mac b)
>         `(let ((a 12))
>            (+ a ,b)))
>     mac
>     > (let ((a 1) (+ *)) (mac a))
>     144

> This returns 144 because '+' has turned into '*', and 'a' is the internal 'a', not the argument 'a'. We get `(* 12 12)` where we might have expected `(+ 12 1)`. Starting with the '+' problem, as long as the redefinition of '+' is local (that is, it happens after the macro definition), we can unquote the +:

>     > (define-macro (mac b)
>         `(let ((a 12))
>            (,+ a ,b))) ; ,+ picks up the definition-time +
>     mac
>     > (let ((a 1) (+ *)) (mac a))
>     24                 ; (+ a a) where a is 12

> But the unquote trick won't work if we have previously loaded some file that redefined '+' at the top-level (so at macro definition time, + is *, but we want the built-in +). Although this example is silly, the problem is real in Scheme because Scheme has no reserved words and only one name space.

>     > (define + *)
>     +
>     > (define (add a b) (+ a b))
>     add
>     > (add 2 3)
>     6
>     > (define (divide a b) (/ a b))
>     divide
>     > (divide 2 3)
>     2/3
>     > (set! / -) ; a bad idea — this turns off s7's optimizer
>     -
>     > (divide 2 3)
>     -1

> Obviously macros are not the problem here. Since we might be loading code written by others, it's sometimes hard to tell what names that code depends on or redefines. We need a way to get the pristine (start-up, built-in) value of '+'. One long-winded way in s7 uses unlet:

>     > (define + *)
>     +
>     > (define (add a b) (with-let (unlet) (+ a b)))
>     add
>     > (add 2 3)
>     5

> But this is hard to read, and it's not inconceivable that we might want all three values of a symbol, the start-up value, the definition-time value, and the current value. The latter can be accessed with the bare symbol, the definition-time value with unquote (','), and the start-up value with either unlet or #_<name>. That is, #_+ is a reader macro for `(with-let (unlet) +)`.

>     > (define-macro (mac b)
>         `(#_let ((a 12))
>            (#_+ a ,b))) ; #_+ and #_let are start-up values
>     mac
>     > (let ((a 1) (+ *)) (mac a))
>     24                 ; (+ a a) where a is 12 and + is the start-up +

>     ;;; make + generic (there's a similar C-based example below)
>     > (define (+ . args)
>         (if (null? args) 0
>             (apply (if (number? (car args)) #_+ #_string-append) args)))
>     +
>     > (+ 1 2)
>     3
>     > (+ "hi" "ho")
>     "hiho"

> #_<name> could be implemented via *#readers*:

>     (set! *#readers*
>       (cons (cons #\_ (lambda (str)
>     		    (with-let (unlet)
>                           (string->symbol (substring str 1)))))
>     	*#readers*))

> So, now we have only the variable capture problem ('a' has been captured in the preceding examples). This is the only thing that the gigantic "hygienic macro" systems actually deal with: a microscopic problem that you'd think, from the hype, was up there with malaria and the national debt. gensym is the standard approach:

>     > (define-macro (mac b)
>         (let ((var (gensym)))
>           `(#_let ((,var 12))
>              (#_+ ,var ,b))))
>     mac
>     > (let ((a 1) (+ *)) (mac a))
>     13

>     ;; or use lambda:
>     > (define-macro (mac b)
>       `((lambda (b) (let ((a 12)) (#_+ a b))) ,b))
>     mac
>     > (let ((a 1) (+ *)) (mac a))
>     13

> But in s7, the simplest approach uses environments. You have complete control over the environment at any point:

>     (define-macro (mac b)
>       `(with-let (inlet 'b ,b)
>          (let ((a 12))
>            (+ a b))))

>     > (let ((a 1) (+ *)) (mac a))
>     13

>     (define-macro (mac1 . b)         ; originally `(let ((a 12)) (+ a ,@b ,@b))
>       `(with-let (inlet 'e (curlet)) ; this 'e will not collide with the calling env
>          (let ((a 12))               ;   nor will 'a (so no gensyms are needed etc)
>            (+ a (with-let e ,@b) (with-let e ,@b)))))

>     > (let ((a 1) (e 2)) (mac1 (display a) (+ a e)))
>     18  ; (and it displays "11")

>     (define-macro (mac2 x)           ; this will use mac2's definition environment for its body
>       `(with-let (sublet (funclet mac2) :x ,x)
>          (let ((a 12))
>            (+ a b x))))              ; a is always 12, b is whatever b happens to be in mac2's env

>     > (define b 10)                  ; this is mac2's b
>     10
>     > (let ((+ *) (a 1) (b 15)) (mac2 (+ a b)))
>     37                               ; mac2 uses its own a (12), b (10), and + (+)
>                                      ;   but (+ a b) is 15 because at that point + is *: (* 1 15)

> Hygienic macros are trivial! So s7 does not have syntax-rules because it is not needed. s7's lint.scm will warn you about any such problematic macro expansion, so I'd say just write macros as simply as possible, then let lint tell you that it's time to do the with-let shuffle. When that happens, wrap the macro body in a with-let that captures the current environment, and at each use of a macro argument wrap it in a with-let that re-establishes that environment.

>     (define-macro (swap a b) ; assume a and b are symbols
>       `(with-let (inlet 'e (curlet) 'tmp ,a)
>          (set! (e ',a) (e ',b))
>          (set! (e ',b) tmp)))

>     > (let ((b 1) (tmp 2)) (swap b tmp) (list b tmp))
>     (2 1)

>     (define-macro (swap a b) ; here a and b can be any settable expressions
>       `(set! ,b (with-let (inlet 'e (curlet) 'tmp ,a)
>     	      (with-let e (set! ,a ,b))
>     	      tmp)))

>     > (let ((v (vector 1 2))) (swap (v 0) (v 1)) v)
>     #(2 1)
>     > (let ((tmp (cons 1 2))) (swap (car tmp) (cdr tmp)) tmp)
>     (2 . 1)

>     (set! (procedure-setter swap) (define-macro (set-swap a b c) `(set! ,b ,c)))

>     > (let ((a 1) (b 2) (c 3) (d 4)) (swap a (swap b (swap c d))) (list a b c d))
>     (2 3 4 1)

>     ;;; but this is simpler:
>     (define-macro (rotate! . args)
>       `(set! ,(args (- (length args) 1))
>              (with-let (inlet 'e (curlet) 'tmp ,(car args))
>     	   (with-let e
>     	     ,@(map (lambda (a b) `(set! ,a ,b)) args (cdr args)))
>     	   tmp)))

>     > (let ((a 1) (b 2) (c 3)) (rotate! a b c) (list a b c))
>     (2 3 1)

> If you want the macro's expanded result to be evaluated in its definition environment:

>     (let ((a 3))
>       (define-macro (mac b)
>         `(with-let (inlet 'b ,b (funclet mac))
>            (+ a b)))       ; definition-time "a", call-time "b"
>       (define-macro (mac-1 b)
>         `(+ a ,b))         ; call-time "a" and "b"
>       (let ((a 32))
>         (list (mac 1)
>     	  (mac-1 1))))

> Here is Peter Seibel's wonderful once-only macro:

>     (define-macro (once-only names . body)
>       (let ((gensyms (map (lambda (n) (gensym)) names)))
>         `(let (,@(map (lambda (g) (list g '(gensym))) gensyms))
>            `(let (,,@(map (lambda (g n) (list list g n)) gensyms names))
>               ,(let (,@(map list names gensyms))
>                  ,@body)))))

> From the land of sparkling bacros:

>     (define once-only
>       (let ((names (gensym))
>     	(body (gensym)))
>         (apply define-bacro `((,(gensym) ,names . ,body)
>           `(let (,@(map (lambda (name) `(,name ,(eval name))) ,names))
>     	 ,@,body)))))

> Sadly, with-let is simpler.

#### procedure-setter

    (procedure-setter proc)
    (dilambda proc setter)

Each function (or macro!) can have an associated setter, much like defsetf in CL. As a convenience, there's also a way to associate the two functions under one name: dilambda. The setter is called when the procedure is the target of set! Its last argument is the value passed to set!:

    > (procedure-setter cadr)
    #f
    > (set! (procedure-setter cadr)
            (lambda (lst val)
              (set! (car (cdr lst)) val)))
    #<lambda (lst val)>
    > (procedure-source (procedure-setter cadr))
    (lambda (lst val) (set! (car (cdr lst)) val))
    > (let ((lst (list 1 2 3)))
        (set! (cadr lst) 4)
        lst)
    (1 4 3)

In some cases, the setter needs to be a macro:

    > (set! (procedure-setter logbit?)
              (define-macro (m var index on) ; here we want to set "var", so we need a macro
    	    `(if ,on
    	         (set! ,var (logior ,var (ash 1 ,index)))
    	         (set! ,var (logand ,var (lognot (ash 1 ,index)))))))
    m
    > (define (mingle a b)
        (let ((r 0))
          (do ((i 0 (+ i 1)))
              ((= i 31) r)
            (set! (logbit? r (* 2 i)) (logbit? a i))
            (set! (logbit? r (+ (* 2 i) 1)) (logbit? b i)))))
    mingle
    > (mingle 6 3) ; the INTERCAL mingle operator?
    30

> Here is a pretty example of dilambda:

>     (define-macro (c?r path)
>       ;; "path" is a list and "X" marks the spot in it that we are trying to access
>       ;; (a (b ((c X)))) — anything after the X is ignored, other symbols are just placeholders
>       ;; c?r returns a dilambda that gets/sets X

>       (define (X-marks-the-spot accessor tree)
>         (if (pair? tree)
>     	(or (X-marks-the-spot (cons 'car accessor) (car tree))
>     	    (X-marks-the-spot (cons 'cdr accessor) (cdr tree)))
>     	(and (eq? tree 'X) accessor)))

>       (let ((body 'lst))
>         (for-each
>          (lambda (f)
>            (set! body (list f body)))
>          (reverse (X-marks-the-spot () path)))

>         `(dilambda
>           (lambda (lst)
>     	,body)
>           (lambda (lst val)
>     	(set! ,body val)))))

>     > ((c?r (a b (X))) '(1 2 (3 4) 5))
>     3
>     > (let ((lst (list 1 2 (list 3 4) 5)))
>        (set! ((c?r (a b (X))) lst) 32)
>        lst)
>     (1 2 (32 4) 5)
>     > (procedure-source (c?r (a b (X))))
>     (lambda (lst) (car (car (cdr (cdr lst)))))
>     > ((c?r (a b . X)) '(1 2 (3 4) 5))
>     ((3 4) 5)
>     > (let ((lst (list 1 2 (list 3 4) 5)))
>        (set! ((c?r (a b . X)) lst) '(32))
>        lst)
>     (1 2 32)
>     > (procedure-source (c?r (a b . X)))
>     (lambda (lst) (cdr (cdr lst)))
>     > ((c?r (((((a (b (c (d (e X)))))))))) '(((((1 (2 (3 (4 (5 6))))))))))
>     6
>     > (let ((lst '(((((1 (2 (3 (4 (5 6)))))))))))
>         (set! ((c?r (((((a (b (c (d (e X)))))))))) lst) 32)
>         lst)
>     (((((1 (2 (3 (4 (5 32)))))))))
>     > (procedure-source (c?r (((((a (b (c (d (e X)))))))))))
>     (lambda (lst) (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr (car (car (car (car lst)))))))))))))))

> Speaking of INTERCAL, COME-FROM:

>     (define-macro (define-with-goto-and-come-from name-and-args . body)
>       (let ((labels ())
>     	(gotos ())
>     	(come-froms ()))

>         (let collect-jumps ((tree body))
>           (when (pair? tree)
>     	(when (pair? (car tree))
>     	  (case (caar tree)
>     	    ((label)     (set! labels (cons tree labels)))
>     	    ((goto)      (set! gotos (cons tree gotos)))
>     	    ((come-from) (set! come-froms (cons tree come-froms)))
>     	    (else (collect-jumps (car tree)))))
>     	(collect-jumps (cdr tree))))

>         (for-each
>          (lambda (goto)
>            (let* ((name (cadr (cadar goto)))
>     	      (label (member name labels (lambda (a b) (eq? a (cadr (cadar b)))))))
>     	 (if label
>     	     (set-cdr! goto (car label))
>     	     (error 'bad-goto "can't find label: ~S" name))))
>          gotos)

>         (for-each
>          (lambda (from)
>            (let* ((name (cadr (cadar from)))
>     	      (label (member name labels (lambda (a b) (eq? a (cadr (cadar b)))))))
>     	 (if label
>     	     (set-cdr! (car label) from)
>     	     (error 'bad-come-from "can't find label: ~S" name))))
>          come-froms)

>         `(define ,name-and-args
>            (let ((label (lambda (name) #f))
>     	     (goto (lambda (name) #f))
>     	     (come-from (lambda (name) #f)))
>     	 ,@body))))

#### applicable objects, generalized set!, generic functions

A procedure with a setter can be viewed as one generalization of set!. Another treats objects as having predefined get and set functions. In s7 lists, strings, vectors, hash-tables, environments, and any cooperating C or Scheme-defined objects are both applicable and settable. newLisp calls this implicit indexing, Kawa has it, Gauche implements it via object-apply, Guile via procedure-with-setter; CL's funcallable instance might be the same idea.

In `(vector-ref #(1 2) 0)`, for example, vector-ref is just a type declaration. But in Scheme, type declarations are unnecessary, so we get exactly the same result from `(#(1 2) 0)`. Similarly, `(lst 1)` is the same as `(list-ref lst 1)`, and `(set! (lst 1) 2)` is the same as `(list-set! lst 1 2)`. I like this syntax: the less noise, the better!

> Well, maybe applicable strings look weird: `("hi" 1)` is #\i, but worse, so is `(cond (1 => "hi"))`! Even though a string, list, or vector is "applicable", it is not currently considered to be a procedure, so `(procedure? "hi")` is #f. map and for-each, however, accept anything that apply can handle, so `(map #(0 1) '(1 0))` is '(1 0). (On the first call to map in this case, you get the result of `(#(0 1) 1)` and so on). string->list, vector->list, and let->list are `(map values object)`. Their inverses are (and always have been) equally trivial.

> The applicable object syntax makes it easy to write generic functions. For example, s7test.scm has implementations of Common Lisp's sequence functions. length, copy, reverse, fill!, iterate, map and for-each are generic in this sense (map always returns a list).

>     > (map (lambda (a b) (- a b)) (list 1 2) (vector 3 4))
>     (5 -3 9)
>     > (length "hi")
>     2

> Here's a generic FFT:

>     (define* (cfft! data n (dir 1)) ; (complex data)
>       (if (not n) (set! n (length data)))
>       (do ((i 0 (+ i 1))
>            (j 0))
>           ((= i n))
>         (if (> j i)
>     	(let ((temp (data j)))
>     	  (set! (data j) (data i))
>     	  (set! (data i) temp)))
>         (do ((m (/ n 2)))
>             ((or (< m 2)
>                  (< j m))
>              (set! j (+ j m)))
>          (set! j (- j m))
>          (set! m (/ m 2))))
>       (do ((ipow (floor (log n 2)))
>            (prev 1)
>            (lg 0 (+ lg 1))
>            (mmax 2 (* mmax 2))
>            (pow (/ n 2) (/ pow 2))
>            (theta (complex 0.0 (* pi dir)) (* theta 0.5)))
>           ((= lg ipow))
>         (let ((wpc (exp theta))
>               (wc 1.0))
>           (do ((ii 0 (+ ii 1)))
>     	  ((= ii prev))
>     	(do ((jj 0 (+ jj 1))
>     	     (i ii (+ i mmax))
>     	     (j (+ ii prev) (+ j mmax)))
>     	    ((>= jj pow))
>     	  (let ((tc (* wc (data j))))
>     	    (set! (data j) (- (data i) tc))
>     	    (set! (data i) (+ (data i) tc))))
>     	(set! wc (* wc wpc)))
>           (set! prev mmax)))
>       data)

>     > (cfft! (list 0.0 1+i 0.0 0.0))
>     (1+1i -1+1i -1-1i 1-1i)
>     > (cfft! (vector 0.0 1+i 0.0 0.0))
>     #(1+1i -1+1i -1-1i 1-1i)

> And a generic function that copies one sequence's elements into another sequence:

>     (define (copy-into source dest) ; this is equivalent to (copy source dest)
>       (do ((i 0 (+ i 1)))
>           ((= i (min (length source) (length dest)))
>            dest)
>         (set! (dest i) (source i))))

> but that is already built-in as the two-argument version of the copy function.

> There is one place where list-set! and friends are not the same as set!: the former evaluate their first argument, but set! does not (with a quibble; see below):

>     > (let ((str "hi")) (string-set! (let () str) 1 #\a) str)
>     "ha"
>     > (let ((str "hi")) (set! (let () str) 1 #\a) str)
>     ;((let () str) 1 #\a): too many arguments to set!
>     > (let ((str "hi")) (set! ((let () str) 1) #\a) str)
>     "ha"
>     > (let ((str "hi")) (set! (str 1) #\a) str)
>     "ha"

> set! looks at its first argument to decide what to set. If it's a symbol, no problem. If it's a list, set! looks at its car to see if it is some object that has a setter. If the car is itself a list, set! evaluates the internal expression, and tries again. So the second case above is the only one that won't work. And of course:

>     > (let ((x (list 1 2)))
>         (set! ((((lambda () (list x))) 0) 0) 3)
>         x)
>     (3 2)

> By my count, around 20 of the Scheme built-in functions are already generic in the sense that they accept arguments of many types (leaving aside the numeric and type checking functions, take for example equal?, display, member, assoc, apply, eval, quasiquote, and values). s7 extends that list with map, for-each, reverse, and length, and adds a few others such as copy, fill!, sort!, object->string, object->let, and append. newLisp takes a more radical approach than s7: it extends operators such as '>' to compare strings and lists, as well as numbers. In map and for-each, however, you can mix the argument types, so I'm not as attracted to making '>' generic; you can't, for example, `(> "hi" 32.1)`, or even `(> 1 0+i)`.

The somewhat non-standard generic sequence functions in s7 are:

    (sort! sequence less?)
    (reverse! sequence) and (reverse sequence)
    (fill! sequence value (start 0) end)
    (copy obj) and (copy source destination (start 0) end)
    (object->string obj)
    (object->let obj)
    (length obj)
    (append . sequences)
    (map func . sequences) and (for-each func . sequences)
    (morally-equal? obj1 obj2)

reverse! is an in-place version of reverse. That is, it modifies the sequence passed to it in the process of reversing its contents. If the sequence is a list, remember to use set!: `(set! p (reverse! p))`. This is somewhat inconsistent with other cases, but historically, lisp programmers have treated the in-place reverse as the fast version, so s7 follows suit.

Leaving aside the weird list case, append returns a sequence of the same type as its first argument.

    > (append #(1 2) '(3 4))
    #(1 2 3 4)
    > (append (float-vector) '(1 2) (byte-vector 3 4))
    (float-vector 1.0 2.0 3.0 4.0)

sort! sorts a sequence using the function passed as its second argument:

    > (sort! (list 3 4 8 2 0 1 5 9 7 6) <)
    (0 1 2 3 4 5 6 7 8 9)

Underlying some of these functions are generic iterators, also built-into s7:

    (make-iterator sequence)
    (iterator? obj)
    (iterate iterator)
    (iterator-sequence iterator)
    (iterator-at-end? iterator)

make-iterator takes a sequence argument and returns an iterator object that traverses that sequence as it is called. The iterator itself can be treated as a function of no arguments, or (for code clarity) it can be the argument to iterate, which does the same thing. That is `(iter)` is the same as `(iterate iter)`. The sequence that an iterator is traversing is iterator-sequence.

If the sequence is a hash-table or let, the iterator normally returns a cons of the key and value. There are many cases where this overhead is objectionable, so make-iterator takes a third optional argument, the cons to use (changing its car and cdr directly on each call).

When an iterator reaches the end of its sequence, it returns #<eof>. It used to return nil; I can't decide whether this change is an improvement. If an iterator over a list notices that its list is circular, it returns #<eof>. map and for-each use iterators, so if you pass a circular list to either, it will stop eventually. (An arcane consequence for method writers: specialize make-iterator, not map or for-each).

    (define (find-if f sequence)
      (let ((iter (make-iterator sequence)))
        (do ((x (iter) (iter)))
    	((or (eof-object? x) (f x))
    	 (and (not (eof-object? x)) x)))))

But of course a sequence might contain #<eof>! So to be really safe, use iterator-at-end? instead of eof-object?.

The argument to make-iterator can also be a function or macro. There should be a variable named 'iterator with a non-#f value in the closure's environment:

    (define (make-circular-iterator obj)
      (let ((iter (make-iterator obj)))
        (make-iterator
         (let ((iterator? #t))
           (lambda ()
             (let ((result (iter)))
    	   (if (eof-object? result)
    	       ((set! iter (make-iterator obj)))
    	       result)))))))

The 'iterator? variable is similar to the 'documentation variable used by procedure-documentation. It gives make-iterator some hope of catching inadvertent bogus function arguments that would otherwise cause an infinite loop.

#### multidimensional vectors

s7 supports vectors with any number of dimensions. It is here, in particular, that generalized set! shines. make-vector's second argument can be a list of dimensions, rather than an integer as in the one dimensional case:

    (make-vector (list 2 3 4))
    (make-vector '(2 3) 1.0)
    (vector-dimensions (make-vector '(2 3 4))) -> (2 3 4)

The second example includes the optional initial element. `(vect i ...)` or `(vector-ref vect i ...)` return the given element, and `(set! (vect i ...) value)` and `(vector-set! vect i ... value)` set it. vector-length (or just length) returns the total number of elements. vector-dimensions returns a list of the dimensions.

    > (define v (make-vector '(2 3) 1.0))
    #2D((1.0 1.0 1.0) (1.0 1.0 1.0))
    > (set! (v 0 1) 2.0)
    #2D((1.0 2.0 1.0) (1.0 1.0 1.0))
    > (v 0 1)
    2.0
    > (vector-length v)
    6

This function initializes each element of a multidimensional vector:

    (define (make-array dims . inits)
      (make-shared-vector (apply vector (flatten inits)) dims))

    > (make-array '(3 3) '(1 1 1) '(2 2 2) '(3 3 3))
    #2D((1 1 1) (2 2 2) (3 3 3))

make-int-vector and make-float-vector produce homogeneous vectors holding s7_ints or s7_doubles. These are mostly useful in conjunction with C code. These homogeneous vector functions are currently built-in:

    (float-vector? obj)
    (float-vector . args)
    (make-float-vector len (init 0.0))
    (float-vector-ref obj . indices)
    (float-vector-set! obj indices[...] value)

    (int-vector? obj)
    (int-vector . args)
    (make-int-vector len (init 0))
    (int-vector-ref obj . indices)
    (int-vector-set! obj indices[...] value)

And also, for completeness:

    (byte-vector? obj)
    (byte-vector . args)
    (make-byte-vector len (init 0))
    (string->byte-vector str)

but these are really just strings in disguise.

To access a vector's elements with different dimensions than the original had, use `(make-shared-vector original-vector new-dimensions (offset 0))`:

    > (let ((v1 #2d((1 2 3) (4 5 6))))
        (let ((v2 (make-shared-vector v1 '(6)))) ; flatten the original
          v2))
    #(1 2 3 4 5 6)
    > (let ((v1 #(1 2 3 4 5 6)))
        (let ((v2 (make-shared-vector v1 '(3 2))))
          v2))
    #2D((1 2) (3 4) (5 6))

> matrix multiplication:

>     (define (matrix-multiply A B)
>       ;; assume square matrices and so on for simplicity
>       (let ((size (car (vector-dimensions A))))
>         (do ((C (make-vector (list size size) 0))
>              (i 0 (+ i 1)))
>     	((= i size) C)
>           (do ((j 0 (+ j 1)))
>     	  ((= j size))
>     	(do ((sum 0)
>                  (k 0 (+ k 1)))
>     	    ((= k size)
>                  (set! (C i j) sum))
>     	  (set! sum (+ sum (* (A i k) (B k j)))))))))

> Conway's game of Life:

>     (define* (life (width 40) (height 40))
>       (let ((state0 (make-vector (list width height) 0))
>     	(state1 (make-vector (list width height) 0)))

>         ;; initialize with some random pattern
>         (do ((x 0 (+ x 1)))
>     	((= x width))
>           (do ((y 0 (+ y 1)))
>     	  ((= y height))
>     	(set! (state0 x y) (if (< (random 100) 15) 1 0))))

>         (do () ()
>           ;; show current state (using terminal escape sequences, borrowed from the Rosetta C code)
>           (format *stderr* "~C[H" #\escape)           ; ESC H = tab set
>           (do ((y 0 (+ y 1)))
>     	  ((= y height))
>     	(do ((x 0 (+ x 1)))
>     	    ((= x width))
>     	  (format *stderr*
>                       (if (zero? (state0 x y))
>     	              "  "                        ; ESC 07m below = inverse
>     	              (values "~C[07m  ~C[m" #\escape #\escape))))
>     	(format *stderr* "~C[E" #\escape))        ; ESC E = next line

>           ;; get the next state
>           (do ((x 1 (+ x 1)))
>     	  ((= x (- width 1)))
>     	(do ((y 1 (+ y 1)))
>     	    ((= y (- height 1)))
>     	  (let ((n (+ (state0 (- x 1) (- y 1))
>     		      (state0    x    (- y 1))
>     		      (state0 (+ x 1) (- y 1))
>     		      (state0 (- x 1)    y)
>     		      (state0 (+ x 1)    y)
>     		      (state0 (- x 1) (+ y 1))
>     		      (state0    x    (+ y 1))
>     		      (state0 (+ x 1) (+ y 1)))))
>     	    (set! (state1 x y)
>     		  (if (or (= n 3)
>     			  (and (= n 2)
>     			       (not (zero? (state0 x y)))))
>     		      1 0)))))
>           (do ((x 0 (+ x 1)))
>     	  ((= x width))
>     	(do ((y 0 (+ y 1)))
>     	    ((= y height))
>     	  (set! (state0 x y) (state1 x y)))))))

> Multidimensional vector constant syntax is modelled after CL: #nd(...) or #nD(...) signals that the lists specify the elements of an 'n' dimensional vector: `#2D((1 2 3) (4 5 6))`

>     > (vector-ref #2D((1 2 3) (4 5 6)) 1 2)
>     6
>     > (matrix-multiply #2d((-1 0) (0 -1)) #2d((2 0) (-2 2)))
>     #2D((-2 0) (2 -2))

> If any dimension has 0 length, you get an n-dimensional empty vector. It is not equal to a 1-dimensional empty vector.

>     > (make-vector '(10 0 3))
>     #3D()
>     > (equal? #() #3D())
>     #f

> To save on costly parentheses, and make it easier to write generic multidimensional sequence functions, you can use this same syntax with lists.

>     > (let ((L '((1 2 3) (4 5 6))))
>         (L 1 0))              ; same as (list-ref (list-ref L 1) 0) or ((L 1) 0)
>     4
>     > (let ((L '(((1 2 3) (4 5 6)) ((7 8 9) (10 11 12)))))
>         (set! (L 1 0 2) 32)   ; same as (list-set! (list-ref (list-ref L 1) 0) 2 32) which is unreadable!
>         L)
>     (((1 2 3) (4 5 6)) ((7 8 32) (10 11 12)))

> Or with vectors of vectors, of course:

>     > (let ((V #(#(1 2 3) #(4 5 6))))
>         (V 1 2))              ; same as (vector-ref (vector-ref V 1) 2) or ((V 1) 2)
>     6
>     > (let ((V #2d((1 2 3) (4 5 6))))
>         (V 0))
>     #(1 2 3)

> There's one difference between a vector-of-vectors and a multidimensional vector: in the latter case, you can't clobber one of the inner vectors.

>     > (let ((V #(#(1 2 3) #(4 5 6)))) (set! (V 1) 32) V)
>     #(#(1 2 3) 32)
>     > (let ((V #2d((1 2 3) (4 5 6)))) (set! (V 1) 32) V)
>     ;not enough args for vector-set!: (#2D((1 2 3) (4 5 6)) 1 32)

> Using lists to display the inner vectors may not be optimal, especially when the elements are also lists:

>     #2D(((0) (0) ((0))) ((0) 0 ((0))))

> The "#()" notation is no better (the elements can be vectors), and I'm not a fan of "[]" parentheses. Perhaps we could use different colors? Or different size parentheses?

>     #2D(((0) (0) ((0))) ((0) 0 ((0))))
>     #2D(((0) (0) ((0))) ((0) 0 ((0))))

> A similar problem afflicts homogeneous vectors. We need some reasonable way to express such a vector even when it has more than one dimension. My first thought was `#(...)#`, but that makes `(let ((b1 0)) (#(1 2)#b1))` ambiguous.

> I'm not sure how to handle vector->list and list->vector in the multidimensional case. Currently, vector->list flattens the vector, and list->vector always returns a one dimensional vector, so the two are not inverses.

>     > (vector->list #2d((1 2) (3 4)))
>     (1 2 3 4)             ; should this be '((1 2) (3 4)) or '(#(1 2) #(3 4))?
>     > (list->vector '(#(1 2) #(3 4))) ; what about '((1 2) (3 4))?
>     #(#(1 2) #(3 4))

> This also affects format and sort!:

>     > (format #f "~{~A~^ ~}" #2d((1 2) (3 4)))
>     "1 2 3 4"
>     > (sort! #2d((1 4) (3 2)) >)
>     #2D((4 3) (2 1))

> Perhaps make-shared-vector can help:

>     >(make-shared-vector (list->vector '(1 2 3 4)) '(2 2))
>     #2D((1 2) (3 4))

> Another question: should we accept the multi-index syntax in a case such as `(#("abc" "def") 0 2)`? My first thought was that the indices should all refer to the same type of object, so s7 would complain in a mixed case like that. If we can nest any applicable objects and apply the whole thing to an arbitrary list of indices, ambiguities arise:

>     ((lambda (x) x) "hi" 0)
>     ((lambda (x) (lambda (y) (+ x y))) 1 2)

> I think these should complain that the function got too many arguments, but from the implicit indexing point of view, they could be interpreted as:

>     (string-ref ((lambda (x) x) "hi") 0) ; i.e. (((lambda (x) x) "hi") 0)
>     (((lambda (x) (lambda (y) (+ x y))) 1) 2)

> Add optional and rest arguments, and you can't tell who is supposed to take which arguments. Currently, you can mix types with implicit indices, but a function grabs all remaining indices. Trickier than I expected!

#### hash-tables

- (make-hash-table (size 8) eq-func)
- (hash-table ...)
- (hash-table* ...)
- (hash-table? obj)
- (hash-table-ref ht key)
- (hash-table-set! ht key value)
- (hash-table-entries ht)

Each hash-table keeps track of the keys it contains, optimizing the search wherever possible. Any s7 object can be the key or the key's value. If you pass a table size that is not a power of 2, make-hash-table rounds it up to the next power of 2. The table grows as needed. length returns the current size. If a key is not in the table, hash-table-ref returns #f. To remove a key, set its value to #f; to remove all keys, `(fill! table #f)`.

    > (let ((ht (make-hash-table)))
        (set! (ht "hi") 123)
        (ht "hi"))
    123

hash-table (the function) parallels the functions vector, list, and string. Its arguments are conses containing key/value pairs. The result is a new hash-table with those values preinstalled: `(hash-table '("hi" . 32) '("ho" . 1))`. After much use, I now think it is more convenient here, as in inlet, to use hash-table*; its arguments are simply the keys and values, without the consing: `(hash-table* 'a 1 'b 2)`. Implicit indexing gives multilevel hashes:

    > (let ((h (hash-table* 'a (hash-table* 'b 2 'c 3)))) (h 'a 'b))
    2
    > (let ((h (hash-table* 'a (hash-table* 'b 2 'c 3)))) (set! (h 'a 'b) 4) (h 'a 'b))
    4

> Since hash-tables accept the same applicable-object syntax that vectors use, we can treat a hash-table as, for example, a sparse array:

>     > (define make-sparse-array make-hash-table)
>     make-sparse-array
>     > (let ((arr (make-sparse-array)))
>        (set! (arr 1032) "1032")
>        (set! (arr -23) "-23")
>        (list (arr 1032) (arr -23)))
>     ("1032" "-23")

> map and for-each accept hash-table arguments. On each iteration, the map or for-each function is passed an entry, `'(key . value)`, in whatever order the entries are encountered in the table.

>     (define (hash-table->alist table)
>       (map values table))

>     (define (merge-hash-tables . tables) ; probably faster: (define merge-hash-tables append)
>       (apply hash-table (apply map values hash-tables)))

> reverse of a hash-table returns a new table with the keys and values reversed. fill! sets all the values. Two hash-tables are equal if they have the same keys with the same values. This is independent of the table sizes, or the order in which the key/value pairs were added.

> The third argument to make-hash-table (eq-func) is slightly complicated. If it is omitted, s7 chooses the hashing equality and mapping functions based on the keys in the hash-table. There are times when you know in advance what equality function you want. If it's one of the built-in s7 equality functions, eq?, eqv?, equal?, morally-equal?, =, string=?, string-ci=?, char=?, or char-ci=?, you can pass that function as the third argument. In any other case, you need to give s7 both the equality function and the mapping function. The latter takes any object and returns the hash-table location for it (an integer). The problem here is that for the arbitrary equality function to work, objects that are equal according to that function have to be mapped to the same hash-table location. There's no way for s7 to intuit what this mapping should be except in the built-in cases. So to specify some arbitrary function, the third argument is a cons: '(equality-checker mapper).

> Here's a brief example. In CLM, we have c-objects of type mus-generator (from s7's point of view), and we want to hash them using equal? (which will call the generator-specific equality function). But s7 doesn't realize that the mus-generator type covers 40 or 50 internal types, so as the mapper we pass mus-type: `(make-hash-table 64 (cons equal? mus-type))`.

> If the hash key is a float (a non-rational number), hash-table-ref uses morally-equal?. Otherwise, for example, you could use NaN as a key, but then never be able to access it!

>     (define-macro (define-memoized name&arg . body)
>       (let ((arg (cadr name&arg))
>     	(memo (gensym "memo")))
>         `(define ,(car name&arg)
>            (let ((,memo (make-hash-table)))
>     	 (lambda (,arg)
>     	   (or (,memo ,arg)                             ; check for saved value
>     	       (set! (,memo ,arg) (begin ,@body)))))))) ; set! returns the new value

>     > (define (fib n)
>       (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2)))))
>     fib
>     > (define-memoized
>        (memo-fib n)
>          (if (< n 2) n (+ (memo-fib (- n 1)) (memo-fib (- n 2)))))
>     memo-fib
>     > (time (fib 34))         ; un-memoized time
>     1.168                        ;   0.70 on ccrma's i7-3930 machines
>     > (time (memo-fib 34))    ; memoized time
>     3.200e-05
>     > (outlet (funclet memo-fib))
>     (inlet '{memo}-18 (hash-table
>         '(0 . 0) '(1 . 1) '(2 . 1) '(3 . 2) '(4 . 3) '(5 . 5)
>         '(6 . 8) '(7 . 13) '(8 . 21) '(9 . 34) '(10 . 55) '(11 . 89)
>         '(12 . 144) '(13 . 233) '(14 . 377) '(15 . 610) '(16 . 987)
>         '(17 . 1597) '(18 . 2584) '(19 . 4181) '(20 . 6765) '(21 . 10946)
>         '(22 . 17711) '(23 . 28657) '(24 . 46368) '(25 . 75025) '(26 . 121393)
>         '(27 . 196418) '(28 . 317811) '(29 . 514229) '(30 . 832040) '(31 . 1346269)
>         '(32 . 2178309) '(33 . 3524578) '(34 . 5702887)))

#### environments

An environment holds symbols and their values. The global environment, for example, holds all the variables that are defined at the top level. Environments are first class (and applicable) objects in s7.

    (rootlet)               the top-level (global) environment
    (curlet)                the current (innermost) environment
    (funclet proc)          the environment at the time when proc was defined
    (owlet)                 the environment at the point of the last error
    (unlet)                 the current environment, but all built-in functions have their original values

    (let-ref env sym)       get value of sym in env, same as (env sym)
    (let-set! env sym val)

    (inlet . bindings)       make a new environment with the given bindings
    (sublet env . bindings)  same as inlet, but the new environment is local to env
    (varlet env . bindings)  add new bindings directly to env
    (cutlet env . fields)    remove bindings from env

    (let? obj)               #t if obj is an environment
    (with-let env . body)    evaluate body in the environment env
    (outlet env)             the environment that encloses the environment env (settable)
    (let->list env)          return the environment bindings as a list of (symbol . value) cons's

    (openlet env)            mark env as open (see below)
    (openlet? env)           #t is env is open
    (coverlet env)           mark env as closed (undo an earlier openlet)

    (object->let obj)        return an environment containing information about obj
    (let-temporarily vars . body)

>     > (inlet 'a 1 'b 2)
>     (inlet 'a 1 'b 2)
>     > (let ((a 1) (b 2)) (curlet))
>     (inlet 'a 1 'b 2)
>     > (let ((x (inlet :a 1 :b 2))) (x 'a))
>     1
>     > (with-let (inlet 'a 1 'b 2) (+ a b))
>     3
>     > (let ((x (inlet :a 1 :b 2))) (set! (x 'a) 4) x)
>     (inlet 'a 4 'b 2)
>     > (let ((x (inlet))) (varlet x 'a 1) x)
>     (inlet 'a 1)
>     > (let ((a 1)) (let ((b 2)) (outlet (curlet))))
>     (inlet 'a 1)
>     > (let ((e (inlet 'a (inlet 'b 1 'c 2)))) (e 'a 'b)) ; in C terms, e->a->b
>     1
>     > (let ((e (inlet 'a (inlet 'b 1 'c 2)))) (set! (e 'a 'b) 3) (e 'a 'b))
>     3

As the names suggest, in s7 an environment is viewed as a disembodied let. Environments are equal if they contain the same symbols with the same values leaving aside shadowing, and taking into account the environment chain up to the rootlet. That is, two environments are equal if any local variable of either has the same value in both.

with-let evaluates its body in the given environment, so `(with-let e . body)` is equivalent to `(eval `(begin ,@body) e)`, but probably faster. Similarly, `(let bindings . body)` is equivalent to `(eval `(begin ,@body) (apply inlet (flatten bindings)))`, ignoring the outer (enclosing) environment (the default outer environment of inlet is rootlet). Or better,

    (define-macro (with-environs e . body)
      `(apply let (map (lambda (a) (list (car a) (cdr a))) ,e) '(,@body)))

Or turning it around,

    (define-macro (Let vars . body)
      `(with-let (sublet (curlet)
    	       ,@(map (lambda (var)
    			(values (symbol->keyword (car var)) (cadr var)))
    		      vars))
         ,@body))

    (Let ((c 4))
      (Let ((a 2)
            (b (+ c 2)))
      (+ a b c)))

let-temporarily (now built-into s7) is somewhat similar to fluid-let in other Schemes. Its syntax looks like let, but it first saves the current value, then sets the variable to the new value (via set!), calls the body, and finally restores the original value. It can handle anything settable:

    (let-temporarily (((*s7* 'print-length) 8)) (display x))

This sets s7's print-length variable to 8 while displaying x, then puts it back to its original value.

sublet adds bindings (symbols with associated values) to an environment. It does not change the environment passed to it, but just prepends the new bindings, shadowing any old ones, as if you had called "let". To add the bindings directly to the environment, use varlet. Both of these functions accept nil as the 'env' argument as shorthand for `(rootlet)`. Both also accept other environments as well as individual bindings, adding all the argument's bindings to the new environment. inlet is very similar, but normally omits the environment argument. The arguments to sublet and inlet can be passed as symbol/value pairs, as a cons, or using keywords as if in define*. inlet can also be used to copy an environment without accidentally invoking that environment's copy method.

Here's an example: we want to define two functions that share a local variable:

    (varlet (curlet)            ; import f1 and f2 into the current environment
      (let ((x 1))              ; x is our local variable
        (define (f1 a) (+ a x))
        (define (f2 b) (* b x))
        (inlet 'f1 f1 'f2 f2))) ; export f1 and f2

One way to add reader and writer functions to an individual environment slot is:

    (define e (inlet
                'x (let ((local-x 3)) ; x's initial value
    		 (dilambda
    		   (lambda () local-x)
    		   (lambda (val) (set! local-x (max 0 (min val 100))))))))
    > ((e 'x))
    3
    > (set! ((e 'x)) 123)
    100

> I originally used a bunch of foolishly pompous names for the environment functions. Two are still available for backwards compatibility:

>     rootlet      global-environment
>     curlet       current-environment

It is possible in Scheme to redefine built-in functions such as car. To ensure that some code sees the original built-in function definitions, wrap it in `(with-let (unlet) ...)`:

    > (let ((caar 123))
        (+ caar (with-let (unlet)
                  (caar '((2) 3)))))
    125

with-let and unlet are constants, so you can use them in any context without worrying about whether they've been redefined. As mentioned in the macro section, #_<name> is a built-in reader macro for `(with-let (unlet) <name>)`, so for example, #_+ is the built-in + function, no matter what. `(unlet)` cleans up the current environment whenever it's called, so you can use it to revert the REPL. (The environment of built-in functions that unlet accesses is not accessible from scheme code, so there's no way that those values can be clobbered).

> I think these functions can implement the notions of libraries, separate namespaces, or modules. Here's one way: first the library writer just writes his library. The normal user simply loads it. The abnormal user worries about everything, so first he loads the library in a local let to make sure no bindings escape to pollute his code, and then he uses unlet to make sure that none of his bindings pollute the library code:

>     (let ()
>       (with-let (unlet)
>         (load "any-library.scm" (curlet))
>         ;; by default load puts stuff in the global environment
>         ...))

> Now Abnormal User can do what he wants with the library entities. Say he wants to use "lognor" under the name "bitwise-not-or", and all the other functions are of no interest:

>     (varlet (curlet)
>       'bitwise-not-or (with-let (unlet)
>                         (load "any-library.scm" (curlet))
>                         lognor)) ; lognor is presumably defined in "any-library.scm"

> Say he wants to make sure the library is cleanly loaded, but all its top-level bindings are imported into the current environment:

>     (varlet (curlet)
>       (with-let (unlet)
>         (let ()
>           (load "any-library.scm" (curlet))
>           (curlet)))) ; these are the bindings introduced by loading the library

> To do the same thing, but prepend "library:" to each name:

>     (apply varlet (curlet)
>       (with-let (unlet)
>         (let ()
>           (load "any-library.scm" (curlet))
>           (map (lambda (binding)
>     	     (cons (symbol "library:" (symbol->string (car binding)))
>     		   (cdr binding)))
>     	    (curlet)))))

> That's all there is to it! Here is the same idea as a macro:

>     (define-macro (let! init end . body)
>       ;; syntax mimics 'do: (let! (vars&values) ((exported-names) result) body)
>       ;;   (let! ((a 1)) ((hiho)) (define (hiho x) (+ a x)))
>       `(let ,init
>          ,@body
>          (varlet (outlet (curlet))
>            ,@(map (lambda (export)
>     		`(cons ',export ,export))
>     	      (car end)))
>          ,@(cdr end)))

> Well, almost, darn it. If the loaded library file sets (via set!) a global value such as abs, we need to put it back to its original form:

>     (define (safe-load file)
>       (let ((e (with-let (unlet)         ; save the environment before loading
>     	     (let->list (curlet)))))
>         (load file (curlet))
>         (let ((new-e (with-let (unlet)   ; get the environment after loading
>     		   (let->list (curlet)))))
>           (for-each                       ; see if any built-in functions were stepped on
>            (lambda (sym)
>     	 (unless (assoc (car sym) e)
>     	   (format () "~S clobbered ~A~%" file (car sym))
>     	   (apply set! (car sym) (list (cdr sym)))))
>            new-e))))

>     ;; say libtest.scm has the line (set! abs odd?)

>     > (safe-load "libtest.scm")
>     "libtest.scm" clobbered abs
>     > (abs -2)
>     2

openlet marks its argument, either an environment, a closure, or a c-object as open. I need better terminology here! An open object is one that the built-in s7 functions handle specially. If they encounter one in their argument list, they look in the object for their own name, and call that function if it exists. A bare-bones example:

    > (abs (openlet (inlet 'abs (lambda (x) 47))))
    47
    > (define* (f1 (a 1)) (if (real? a) (abs a) ((a 'f1) a)))
    f1
    > (f1 :a (openlet (inlet 'f1 (lambda (e) 47))))
    47

In CLOS, we'd declare a class and a method, and call make-instance, and then discover that it wouldn't work anyway. Here we have, in effect, an anonymous instance of an anonymous class. I think this is called a "prototype system"; javascript is apparently similar. A slightly more complex example:

    (let* ((e1 (openlet
    	   (inlet
    	    'x 3
    	    '* (lambda args
    		 (apply * (if (number? (car args))
    		     	      (values (car args) ((cadr args) 'x) (cddr args))
    		              (values ((car args) 'x) (cdr args))))))))
           (e2 (copy e1)))
      (set! (e2 'x) 4)
      (* 2 e1 e2)) ; (* 2 3 4) => 24

Perhaps these names would be better: openlet -> with-methods, coverlet -> without-methods, and openlet? -> methods?.

object->let returns an environment (more of a dictionary really) that contains details about its argument. It is intended as a debugging aid, underlying a debugger's "inspect" for example.

    > (let ((iter (make-iterator "1234")))
        (iter)
        (iter)
        (object->let iter))
    (inlet 'value #<iterator: string> 'type iterator? 'at-end #f 'sequence "1234" 'length 4 'position 2)

A c-object (in the sense of s7_new_type), can add its own info to this namespace via an object->let method in its local environment. snd-marks.c has a simple example using a class-wide environment (g_mark_methods), holding as the value of its 'object->let field the function s7_mark_to_let. The latter uses s7_varlet to add information to the namespace created by `(object->let mark)`.

> define-class

> Here is yet another object system. Each class and each instance is an environment. A class might be thought of as a template for instances, but there's actually no difference between them. To make an instance of a class, copy it. To inherit from another class, concatenate the environments. To access (get or set) a field or a method, use the implicit indexing syntax with the field or method name. To evaluate a form in the context of an instance (CL's with-slots), use with-let. To run through all the fields, use map or for-each.

>     (define-macro* (define-class class-name inherited-classes (slots ()) (methods ()))
>       `(let ((outer-env (outlet (curlet)))
>     	 (new-methods ())
>     	 (new-slots ()))

>          (for-each
>           (lambda (class)
>     	;; each class is a set of nested environments, the innermost (first in the list)
>     	;;   holds the local slots which are copied each time an instance is created,
>     	;;   the next holds the class slots (global to all instances, not copied);
>     	;;   these hold the class name and other such info.  The remaining environments
>     	;;   hold the methods, with the localmost method first.  So in this loop, we
>     	;;   are gathering the local slots and all the methods of the inherited
>     	;;   classes, and will splice them together below as a new class.

>     	(set! new-slots (append (let->list class) new-slots))
>     	(do ((e (outlet (outlet class)) (outlet e)))
>     	    ((or (not (let? e))
>     		 (eq? e (rootlet))))
>     	  (set! new-methods (append (let->list e) new-methods))))
>           ,inherited-classes)

>          (let ((remove-duplicates
>     	    (lambda (lst)         ; if multiple local slots with same name, take the localmost
>     	      (letrec ((rem-dup
>     			(lambda (lst nlst)
>     			  (cond ((null? lst) nlst)
>     				((assq (caar lst) nlst) (rem-dup (cdr lst) nlst))
>     				(else (rem-dup (cdr lst) (cons (car lst) nlst)))))))
>     		(reverse (rem-dup lst ()))))))
>            (set! new-slots
>     	     (remove-duplicates
>     	      (append (map (lambda (slot)
>     			     (if (pair? slot)
>     				 (cons (car slot) (cadr slot))
>     				 (cons slot #f)))
>     			   ,slots)                    ; the incoming new slots, #f is the default value
>     		      new-slots))))                   ; the inherited slots

>          (set! new-methods
>     	   (append (map (lambda (method)
>     			  (if (pair? method)
>     			      (cons (car method) (cadr method))
>     			      (cons method #f)))
>     			,methods)                     ; the incoming new methods

>     		   ;; add an object->string method for this class (this is already a generic function).
>     		   (list (cons 'object->string
>     			       (lambda* (obj (use-write #t))
>     				 (if (eq? use-write :readable)    ; write readably
>     				     (format #f "(make-~A~{ :~A ~W~^~})"
>     					     ',class-name
>     					     (map (lambda (slot)
>     						    (values (car slot) (cdr slot)))
>     						  obj))
>     				     (format #f "#<~A: ~{~A~^ ~}>"
>     					     ',class-name
>     					     (map (lambda (slot)
>     						    (list (car slot) (cdr slot)))
>     						  obj))))))
>     		   (reverse! new-methods)))                      ; the inherited methods, shadowed automatically

>          (let ((new-class (openlet
>                            (apply sublet                             ; the local slots
>     			      (sublet                            ; the global slots
>     				  (apply inlet                   ; the methods
>     					 (reverse new-methods))
>     				'class-name ',class-name         ; class-name slot
>     				'inherited ,inherited-classes
>     				'inheritors ())                  ; classes that inherit from this class
>     			      new-slots))))

>            (varlet outer-env
>     	 ',class-name new-class                                  ; define the class as class-name in the calling environment

>     	 ;; define class-name? type check
>     	 (string->symbol (string-append (symbol->string ',class-name) "?"))
>     	 (lambda (obj)
>     	   (and (let? obj)
>     		(eq? (obj 'class-name) ',class-name))))

>            (varlet outer-env
>     	 ;; define the make-instance function for this class.
>     	 ;;   Each slot is a keyword argument to the make function.
>     	 (string->symbol (string-append "make-" (symbol->string ',class-name)))
>     	 (apply lambda* (map (lambda (slot)
>     			       (if (pair? slot)
>     				   (list (car slot) (cdr slot))
>     				   (list slot #f)))
>     			     new-slots)
>     		`((let ((new-obj (copy ,,class-name)))
>     		    ,@(map (lambda (slot)
>     			     `(set! (new-obj ',(car slot)) ,(car slot)))
>     			   new-slots)
>     		    new-obj))))

>            ;; save inheritance info for this class for subsequent define-method
>            (letrec ((add-inheritor (lambda (class)
>     				 (for-each add-inheritor (class 'inherited))
>     				 (if (not (memq new-class (class 'inheritors)))
>     				     (set! (class 'inheritors) (cons new-class (class 'inheritors)))))))
>     	 (for-each add-inheritor ,inherited-classes))

>            ',class-name)))

>     (define-macro (define-generic name)    ; (define (genfun any) ((any 'genfun) any))
>       `(define ,name
>          (lambda args
>            (let ((gf ((car args) ',name))) ; get local definition
>     	 (if (not (eq? gf ,name))      ; avoid infinite recursion
>                  (apply gf args)
>     	     (error "attempt to call generic function wrapper recursively"))))))

>     (define-macro (define-slot-accessor name slot)
>       `(define ,name (dilambda
>     		  (lambda (obj) (obj ',slot))
>     		  (lambda (obj val) (set! (obj ',slot) val)))))

>     (define-macro (define-method name-and-args . body)
>       `(let* ((outer-env (outlet (curlet)))
>     	  (method-name (car ',name-and-args))
>     	  (method-args (cdr ',name-and-args))
>     	  (object (caar method-args))
>     	  (class (symbol->value (cadar method-args)))
>     	  (old-method (class method-name))
>     	  (method (apply lambda* method-args ',body)))

>          ;; define the method as a normal-looking function
>          ;;   s7test.scm has define-method-with-next-method that implements call-next-method here
>          ;;   it also has make-instance
>          (varlet outer-env
>            method-name (apply lambda* method-args
>     			  `(((,object ',method-name)
>     			     ,@(map (lambda (arg)
>     				      (if (pair? arg) (car arg) arg))
>     				    method-args)))))

>          ;; add the method to the class
>          (varlet (outlet (outlet class)) method-name method)

>          ;; if there are inheritors, add it to them as well, but not if they have a shadowing version
>          (for-each
>           (lambda (inheritor)
>     	(if (not (eq? (inheritor method-name) #<undefined>)) ; defined? goes to the global env
>     	    (if (eq? (inheritor method-name) old-method)
>     		(set! (inheritor method-name) method))
>     	    (varlet (outlet (outlet inheritor)) method-name method)))
>           (class 'inheritors))

>          method-name))

>     (define (all-methods obj method)
>       ;; for arbitrary method combinations: this returns a list of all the methods of a given name
>       ;;   in obj's class and the classes it inherits from (see example below)
>       (let* ((base-method (obj method))
>     	 (methods (if (procedure? base-method) (list base-method) ())))
>         (for-each
>          (lambda (ancestor)
>            (let ((next-method (ancestor method)))
>     	 (if (and (procedure? next-method)
>     		  (not (memq next-method methods)))
>     	     (set! methods (cons next-method methods)))))
>          (obj 'inherited))
>         (reverse methods)))

>     > (define-class class-1 ()
>            '((a 1) (b 2))
>            (list (list 'add (lambda (obj)
>                               (with-let obj
>                                 (+ a b))))))
>     class-1
>     > (define v (make-class-1 :a 32))
>     v
>     > (v 'a)                         ; to set the 'a slot, (set! (v 'a) 0)
>     32
>     > (object->string v)             ; built-in functions are all generic
>     "#<class-1: (a 32) (b 2)>"       ;   so this uses the method defined in the class definition
>     > ((v 'add) v)
>     34
>     > (define-generic add)
>     add
>     > (add v)                        ; syntactic sugar for ((v 'add) v)
>     34
>     > (define-slot-accessor slot-a a) ; more sugar!
>     slot-a
>     > (slot-a v)                     ; same as (v 'a), set via (set! (slot-a v) 123)
>     32
>     > (map car v)                    ; map and for-each work with environments
>     (a b)                               ;   map cdr would return '(32 2) in this case
>     > (define-class class-2 (list class-1)
>            '((c 3))
>            (list (list 'multiply (lambda (obj)
>                                    (with-let obj
>                                      (* a b c))))))
>     class-2
>     > (define v2 (make-class-2 :a 32))
>     v2
>     > v2                            ; will use object->string
>     "#<class-2: (c 3) (a 32) (b 2)>"
>     > ((v2 'multiply) v2)
>     192
>     > (add v2)                      ; inherited from class-1
>     34
>     > (define-method (subtract (obj class-1)) (with-let obj (- a b)))
>     subtract
>     > (subtract v2)  ; class-2 inherits from class-1 so it knows about subtract
>     30
>     > (define v1 (make-class-1))
>     v1
>     > (varlet v1      ; change the add method just in this instance
>            'add (lambda (obj)
>                   (with-let obj
>                     (+ 1 a (* 2 b)))))
>     #<class-1: (a 1) (b 2) (add #<lambda (obj)>)>
>     > (add v1)
>     6
>     > (add v)                       ; other class-1 instances are not affected
>     34
>     > (define-class class-3 (list class-2) ()
>         (list (list 'multiply (lambda (obj num)
>     			    (* num
>     			       ((class-2 'multiply) obj) ; method combination
>     			       (add obj))))))
>     class-3
>     > ((class-3 'multiply) class-3 10)
>     180                               ; (* 10 (* 1 2 3) (+ 1 2))
>     > (define v3 (make-class-3))
>     v3
>     > (all-methods v3 'multiply)
>     (#<lambda (obj num)> #<lambda (obj)>)
>     > (for-each (lambda (p) (format () "~A~%" (procedure-source p))) (all-methods v3 'multiply))
>     (lambda (obj num) (* num ((class-2 'multiply) obj) (add obj)))
>     (lambda (obj) (with-let obj (* a b c)))

> with-let (used briefly above) provides an even more striking simplification of syntax than implicit indexing or multidimensional vectors, and it is faster as well! See Snd's generators.scm for many examples.

> more examples

> Implicit indexing of a local environment does not search the global environment. Since unlet extends the current environment chain, it is considered a local environment:

>     > ((rootlet) 'abs)
>     abs
>     > (let () ((curlet) 'abs))
>     #<undefined>
>     > ((unlet) 'abs)
>     #<undefined>

>     (define-macro (value->symbol expr)
>       `(let ((val ,expr)
>     	 (e1 (curlet)))
>          (call-with-exit
>           (lambda (return)
>     	(do ((e e1 (outlet e))) ()
>     	  (for-each
>     	   (lambda (slot)
>     	     (if (equal? val (cdr slot))
>     		 (return (car slot))))
>     	   e)
>     	  (if (eq? e (rootlet))
>     	      (return #f)))))))

>     > (let ((a 1) (b "hi"))
>         (value->symbol "hi"))
>     b

> openlet alerts the rest of s7 that the environment has methods.

>     (begin
>       (define fvector? #f)
>       (define make-fvector #f)
>       (let ((type (gensym))
>     	(->float (lambda (x)
>     		   (if (real? x)
>     		       (* x 1.0)
>     		       (error 'wrong-type-arg "fvector new value is not a real: ~A" x)))))
>         (set! make-fvector
>     	  (lambda* (len (init 0.0))
>     	    (openlet
>     	     (inlet :v (make-vector len (->float init))
>     	            :type type
>     	   	    :length (lambda (f) len)
>     		    :object->string (lambda (f . args) "#<fvector>")
>     		    :let-set! (lambda (fv i val) (#_vector-set! (fv 'v) i (->float val)))
>     		    :let-ref (lambda (fv i) (#_vector-ref (fv 'v) i))))))
>         (set! fvector? (lambda (p)
>     		     (and (let? p)
>     			  (eq? (p 'type) type))))))

>     > (define fv (make-fvector 32))
>     fv
>     > fv
>     #<fvector>
>     > (length fv)
>     32
>     > (set! (fv 0) 123)
>     123.0
>     > (fv 0)
>     123.0

> I can't resist adding at least some of a quaternion implementation (finally "number?" is not the same as "complex?"!):

>     (define-class quaternion ()
>       '((r 0) (i 0) (j 0) (k 0))
>       (list (list 'number? (lambda (obj) #t))
>     	(list 'complex? (lambda (obj) #f))
>     	(list 'real? (lambda (obj) #f))
>     	(list 'integer? (lambda (obj) #f))
>     	(list 'rational? (lambda (obj) #f))

>     	(list '+ (lambda orig-args
>     		   (let add ((r ()) (i ()) (j ()) (k ()) (args orig-args))
>     		     (if (null? args)
>     			 (make-quaternion
>                                (apply + r) (apply + i) (apply + j) (apply + k))
>     			 (let ((n (car args)))
>     			   (cond
>     			    ((real? n)
>     			     (add (cons n r) i j k (cdr args)))
>     			    ((complex? n)
>     			     (add (cons (real-part n) r) (cons (imag-part n) i) j k (cdr args)))
>     			    ((quaternion? n)
>     			       (add (cons (n 'r) r) (cons (n 'i) i)
>                                         (cons (n 'j) j) (cons (n 'k) k)
>                                         (cdr args)))
>                                 ((not (openlet? n))   ; maybe we'll add octonions later!
>                                  (error 'wrong-type-arg "+ argument ~A is not a number" n))
>                                 ((eq? n (car orig-args))
>                                  (error 'missing-method "+ can't handle these arguments: ~A" args))
>                                 (else
>     			      (apply (n '+)
>                                          (make-quaternion
>                                            (apply + r) (apply + i) (apply + j) (apply + k))
>                                          (cdr args)))))))))))

>     > (let ((q1 (make-quaternion 1.0 1.0 0.0 0.0)))
>         (+ 1 q1 2.5+i))
>     #<quaternion: (r 4.5) (i 2.0) (j 0.0) (k 0.0)>

> If an s7 function ignores the type of an argument, as in cons or vector for example, then that argument won't be treated as having any methods.

> Since outlet is settable, there are two ways an environment can become circular. One is to include the current environment as the value of one of its variables. The other is: `(let () (set! (outlet (curlet)) (curlet)))`.

> If you want to hide an environment's fields from any part of s7 that does not know the field names in advance,

>     (openlet  ; make it appear to be empty to the rest of s7
>       (inlet 'object->string  (lambda args "#<let>")
>              'map             (lambda args ())
>              'for-each        (lambda args #<unspecified>)
>       	 'let->list       (lambda args ())
>              'length          (lambda args 0)
>     	 'copy            (lambda args (inlet))
>      	 'open #t
>     	 'coverlet        (lambda (e) (set! (e 'open) #f) e)
>     	 'openlet         (lambda (e) (set! (e 'open) #t) e)
>     	 'openlet?        (lambda (e) (e 'open))
>              ;; your secret data here
>              ))

> (There are still at least two ways to tell that something is fishy).

#### multiple-values

In s7, multiple values are spliced directly into the caller's argument list.

    > (+ (values 1 2 3) 4)
    10
    > (string-ref ((lambda () (values "abcd" 2))))
    #\c
    > ((lambda (a b) (+ a b)) ((lambda () (values 1 2))))
    3
    > (+ (call/cc (lambda (ret) (ret 1 2 3))) 4) ; call/cc has an implicit "values"
    10
    > ((lambda* ((a 1) (b 2)) (list a b)) (values :a 3))
    (3 2)

    (define-macro (call-with-values producer consumer)
      `(,consumer (,producer)))

    (define-macro (multiple-value-bind vars expr . body)
      `((lambda ,vars ,@body) ,expr))

    (define-macro (define-values vars expression)
      `(if (not (null? ',vars))
           (varlet (curlet) ((lambda ,vars (curlet)) ,expression))))

    (define (curry function . args)
      (if (null? args)
          function
          (lambda more-args
            (if (null? more-args)
                (apply function args)
                (function (apply values args) (apply values more-args))))))

> multiple-values are useful in a several situations. For example, `(if test (+ a b c) (+ a b d e))` can be written `(+ a b (if test c (values d e)))`. There are a few special uses of multiple-values. First, you can use the values function to return any number of values, including 0, from map's function application:

>     > (map (lambda (x) (if (odd? x) (values x (* x 20)) (values))) (list 1 2 3))
>     (1 20 3 60)
>     > (map values (list 1 2 3) (list 4 5 6))
>     (1 4 2 5 3 6)

>     (define (remove-if func lst)
>       (map (lambda (x) (if (func x) (values) x)) lst))

>     (define (pick-mappings func lst)
>       (map (lambda (x) (or (func x) (values))) lst))

>     (define (shuffle . args)
>       (apply map values args))

>     > (shuffle '(1 2 3) #(4 5 6) '(7 8 9))
>     (1 4 7 2 5 8 3 6 9)

>     (define (concatenate . args)
>       (apply append (map (lambda (arg) (map values arg)) args)))

> Second, a macro can return multiple values; these are evaluated and spliced, exactly like a normal macro, so you can use `(values '(define a 1) '(define b 2))` to splice multiple definitions at the macro invocation point. If an expansion returns (values), nothing is spliced in. This is mostly useful in reader-cond and the #; reader.

>     > (define-expansion (comment str) (values))
>     comment
>     > (+ 1 (comment "one") 2 (comment "two"))
>     3

> At the top-level (in the REPL), since there's nothing to splice into, you simply get your values back:

>     > (values 1 (list 1 2) (+ 3 4 5))
>     (values 1 (1 2) 12)

> But this printout is just trying to be informative. There is no multiple-values object in s7. You can't `(set! x (values 1 2))`, for example. The values function tells s7 that its arguments should be handled in a special way, and the multiple-value indication goes away as soon as the arguments are spliced into some caller's arguments.

> Internally, s7 uses `(apply values ...)` to implement unquote splicing (",@") in quasiquote.

> Since set! does not evaluate its first argument, and there is no setter for "values", `(set! (values x) ...)` is not the same as `(set! x ...)`. `(string-set! (values string) ...)` works because string-set! does evaluate its first argument. `((values + 1 2) (values 3 4) 5)` is 15, as anyone would expect.

> more on values

> In some Schemes, values behaves like CL's prog1:

>     (not s7)> (let ((x 1)) (cond ((values #f (set! x 2) #t) 3) (#t x)))
>     2
>     (not s7)> (if (values #f #t) 1 2)
>     2

> But in s7 we're trying to implement real multiple values (else why have them at all?). There are many ways we could interpret `(cond ((values ...))...)` and `(cond ((values...) => func))`, but surely equivalent uses of "cond" and "if" should give the same result. Currently in s7, where a test is in progress, only `(values #f)` is the same as #f.

>     > (if (values #f #f) 1 2)            ; (values #f #f) is not #f
>     1
>     > (cond ((values #f #f) 1) (#t 2))
>     1
>     ;;; but if we interpreted this as splicing in the values, we get an inconsistency:
>     > (cond (#f #f 1) (#t 2))
>     2
>     > (if (values #f) 1 2)
>     2
>     > (cond ((values #f) 1) (#t 2))
>     2
>     > (if (values) 1 2)
>     1
>     > (cond ((values) 1) (#t 2))
>     1
>     ;;; this is consistent with (cond (1) (#t 2))

> So "if" and "cond" agree, but it requires that in one case the "values" behavior is slightly weird. `(or (values #f #f))` is #f, but that isn't inconsistent because "or" is not testing anything. We might choose to say that `(if (values #f #f)...)` is an error, but that would be hasty — our troubles have only begun. First, "cond" can omit the expressions that follow the test, unlike "if":

>     > (cond (3))
>     3

> and even trickier, "cond" can pass the test value to a function:

>     > (cond (3 => +))
>     3

> The various standards agree that in the "=>" case, the "fed to" function receives one argument, so

>     (not s7)> (cond ((values 1 2) => +))
>     1

> If we were following the "splice immediately" model, this would be `(cond (1 2 => +))` which is an error in some Schemes. So something has to give. My druthers is to make "values" work as consistently as possible, and hope that the one odd corner will not trip anyone. From that point of view, the "one arg" standard looks like a wasted opportunity. s7 handles it this way:

>     > (+ 1 (cond ((values 2 3))) 4)   ; trailing values are not ignored
>     10
>     > (cond ((values 1 2 3) => +))
>     6

> Of course, it is unproblematic that the expression can itself involve multiple values:

>     > (+ (cond (#t (values 1 2))))
>     3

> Now, what have I missed?

#### call-with-exit, with-baffle and continuation?

call-with-exit is call/cc without the ability to jump back into the original context, similar to "return" in C. This is cleaner than call/cc, and much faster.

    (define-macro (block . body)
      ;; borrowed loosely from CL — predefine "return" as an escape
      `(call-with-exit (lambda (return) ,@body)))

    (define-macro (while test . body)      ; while loop with predefined break and continue
      `(call-with-exit
        (lambda (break)
          (let continue ()
    	(if (let () ,test)
    	    (begin
    	      (let () ,@body)
    	      (continue))
    	    (break))))))

    (define-macro (switch selector . clauses) ; C-style case (branches fall through unless break called)
      `(call-with-exit
        (lambda (break)
          (case ,selector
    	,@(do ((clause clauses (cdr clause))
    	       (new-clauses ()))
    	      ((null? clause) (reverse new-clauses))
    	    (set! new-clauses (cons `(,(caar clause)
    				      ,@(cdar clause)
    				      ,@(map (lambda (nc)
    					       (apply values (cdr nc))) ; doubly spliced!
    					     (if (pair? clause) (cdr clause) ())))
    				    new-clauses)))))))

    (define (and-for-each func . args)
      ;; apply func to the first member of each arg, stopping if it returns #f
      (call-with-exit
       (lambda (quit)
         (apply for-each (lambda arglist
    		       (if (not (apply func arglist))
    			   (quit #<unspecified>)))
    	    args))))

    (define (find-if f . args)  ; generic position-if is very similar
      (call-with-exit
       (lambda (return)
         (apply for-each (lambda main-args
    		       (if (apply f main-args)
    			   (apply return main-args)))
    	    args))))

    > (find-if even? #(1 3 5 2))
    2
    > (* (find-if > #(1 3 5 2) '(2 2 2 3)))
    6

The call-with-exit function's argument (the "continuation") is only valid within the call-with-exit function. In call/cc, you can save it, then call it later to jump back, but if you try that with call-with-exit (from outside the call-with-exit function's body), you'll get an error. This is similar to trying to read from a closed input port.

The other side, so to speak, of call-with-exit, is with-baffle. Both limit the scope of a continuation. Sometimes we need a normal call/cc, but want to make sure it is active only within a given block of code. Normally, if a continuation gets away, there's no telling when it might wreak havoc on us. Scheme code with call/cc becomes unpredictable, undebuggable, and completely unmaintainable. with-baffle blocks all that — no continuation can jump into its body:

    (let ((what's-for-breakfast ())
          (bad-dog 'fido))        ; bad-dog wonders what's for breakfast?
      (with-baffle                ; the syntax is (with-baffle . body)
       (set! what's-for-breakfast
    	 (call/cc
    	  (lambda (biscuit?)
    	    (set! bad-dog biscuit?) ; bad-dog smells a biscuit!
    	    'biscuit!))))
      (if (eq? what's-for-breakfast 'biscuit!)
          (bad-dog 'biscuit!))     ; now, outside the baffled block, bad-dog wants that biscuit!
      what's-for-breakfast)        ;   but s7 says "No!": baffled! ("continuation can't jump into with-baffle")

continuation? returns #t if its argument is a continuation, as opposed to a normal procedure. I don't know why Scheme hasn't had this function from the very beginning, but it's needed if you want to write a continuable error handler. Here is a sketch of the situation:

    (let ()
      (catch #t
    	 (lambda ()
    	   (let ((res (call/cc
                            (lambda (ok)
    			  (error 'cerror "an error" ok)))))
    	     (display res) (newline)))
    	 (lambda args
    	   (if (and (eq? (car args) 'cerror)
    		    (continuation? (cadadr args)))
    	       (begin
    		 (display "continuing...")
    		 ((cadadr args) 2)))
    	   (display "oops"))))

    continuing...2

In a more general case, the error handler is separate from the catch body, and needs a way to distinguish a real continuation from a simple procedure.

    (define (continuable-error . args)
      (call/cc
       (lambda (continue)
         (apply error args))))

    (define (continue-from-error)
      (if (continuation? ((owlet) 'continue)) ; might be #<undefined> or a function as in the while macro
          (((owlet) 'continue))
          'bummer))

#### format, object->string

object->string returns the string representation of its argument. Its optional second argument can be #f (use display), #t (the default, use write), or :readable. In the latter case, object->string tries to produce a string that can be evaluated via eval-string to return an object equal to the original.

    > (object->string "hiho")
    "\"hiho\""
    > (format #f "~S" "hiho")
    "\"hiho\""

s7's format function is very close to that in srfi-48.

    > (format #f "~A ~D ~F" 'hi 123 3.14)
    "hi 123 3.140000"

The format directives (tilde chars) are:

    ~%        insert newline
    ~&        insert newline if preceding char was not newline
    ~~        insert tilde
    ~\n       (tilde followed by newline): trim white space
    ~{        begin iteration (take arguments from a list, string, vector, or any other applicable object)
    ~}        end iteration
    ~^ ~|     jump out of iteration
    ~*        ignore the current argument
    ~C        print character (numeric argument = how many times to print it)
    ~P        insert 's' if current argument is not 1 or 1.0 (use ~@P for "ies" or "y")
    ~A        object->string as in display
    ~S        object->string as in write
    ~B        number->string in base 2
    ~O        number->string in base 8
    ~D        number->string in base 10
    ~X        number->string in base 16
    ~E        float to string, (format #f "~E" 100.1) -> "1.001000e+02", (%e in C)
    ~F        float to string, (format #f "~F" 100.1) -> "100.100000",   (%f in C)
    ~G        float to string, (format #f "~G" 100.1) -> "100.1",        (%g in C)
    ~T        insert spaces (padding)
    ~N        get numeric argument from argument list (similar to ~V in CL)
    ~W        object->string with :readable (write readably; s7 is the intended reader)

The eight directives before ~W take the usual numeric arguments to specify field width and precision. These can also be ~N or ~n in which case the numeric argument is read from the list of arguments:

    (format #f "~ND" 20 1234) ; => (format "~20D" 1234)
    "                1234"

`(format #f ...)` simply returns the formatted string; `(format #t ...)` also sends the string to the current-output-port. `(format () ...)` sends the output to the current-output-port without returning the string (this mimics the other IO routines such as display and newline). Other built-in port choices are *stdout* and *stderr*.

> Floats can occur in any base, so:

>     > #xf.c
>     15.75

> This also affects format. In most Schemes, `(format #f "~X" 1.25)` is an error. In CL, it is equivalent to using ~A which is perverse. But

>     > (number->string 1.25 16)
>     "1.4"

> and there's no obvious way to get the same effect from format unless we accept floats in the "~X" case. So in s7,

>     > (format #f "~X" 21)
>     "15"
>     > (format #f "~X" 1.25)
>     "1.4"
>     > (format #f "~X" 1.25+i)
>     "1.4+1.0i"
>     > (format #f "~X" 21/4)
>     "15/4"

> That is, the output choice matches the argument. A case that came up in the Guile mailing lists is: `(format #f "~F" 1/3)`. s7 currently returns "1/3", but Clisp returns "0.33333334".

> The curly bracket directive applies to anything you can map over, not just lists:

>     > (format #f "~{~C~^ ~}" "hiho")
>     "h i h o"
>     > (format #f "~{~{~C~^ ~}~^...~}" (list "hiho" "test"))
>     "h i h o...t e s t"
>     > (with-input-from-string (format #f "(~{~C~^ ~})" (format #f "~B" 1367)) read) ; integer->list
>     (1 0 1 0 1 0 1 0 1 1 1)

> Since any sequence can be passed to ~{~}, we need a way to truncate output and represent the rest of the sequence with "...", but ~^ only stops at the end of the sequence. ~| is like ~^ but it also stops after it handles (*s7* 'print-length) elements and prints "...". So, `(format #f "~{~A~| ~}" #(0 1 2 3 4))` returns "0 1 2 ..." if (*s7* 'print-length) is 3.

> I added object->string to s7 before deciding to include format. format excites a vague disquiet — why do we need this ancient unlispy thing? We can almost replace it with:

>     (define (objects->string . objects)
>       (apply string-append (map (lambda (obj) (object->string obj #f)) objects)))

> But how to handle lists (~{...~} in format), or columnized output (~T)? I wonder whether formatted string output still matters outside a REPL. Even in that context, a modern GUI leaves formatting decisions to a text or table widget.

>     (define-macro (string->objects str . objs)
>       `(with-input-from-string ,str
>          (lambda ()
>            ,@(map (lambda (obj)
>     		`(set! ,obj (eval (read))))
>     	      objs))))

#### hooks

    (make-hook . fields)           ; make a new hook
    (hook-functions hook)          ; the hook's list of 'body' functions

A hook is a function created by make-hook, and called (normally from C) when something interesting happens. In GUI toolkits hooks are called callback-lists, in CL conditions, in other contexts watchpoints or signals. s7 itself has several hooks: *error-hook*, *read-error-hook*, *unbound-variable-hook*, *missing-close-paren-hook*, and *load-hook*. make-hook is:

    (define (make-hook . args)
      (let ((body ()))
        (apply lambda* args
          '(let ((result #<unspecified>))
             (let ((e (curlet)))
    	   (for-each (lambda (f) (f e)) body)
               result))
           ())))

So the result of calling make-hook is a function (the lambda* that is applied to args above) that contains a list of functions, 'body. Each function in that list takes one argument, the hook. Each time the hook itself is called, each of the body functions is called, and the value of 'result is returned. That variable, and each of the hook's arguments are accessible to the hook's internal functions by going through the environment passed to the internal functions. This is a bit circuitous; here's a sketch:

    > (define h (make-hook '(a 32) 'b))     ; h is a function: (lambda* ((a 32) b) ...)
    h
    > (set! (hook-functions h)              ; this sets ((funclet h) 'body)
               (list (lambda (hook) 	; each hook internal function takes one argument, the environment
                       (set! (hook 'result) ; this is the "result" variable above
                             (format #f "a: ~S, b: ~S" (hook 'a) (hook 'b))))))
    (#<lambda (hook)>)
    > (h 1 2)                               ; this calls the hook's internal functions (just one in this case)
    "a: 1, b: 2"                            ; we set "result" to this string, so it is returned as the hook application result
    > (h)
    "a: 32, b: #f"

In C, to make a hook:

    hook = s7_eval_c_string("(make-hook '(a 32) 'b)");
    s7_gc_protect(s7, hook);

And call it:

    result = s7_call(s7, hook, s7_list(s7, 2, s7_make_integer(s7, 1), s7_make_integer(s7, 2)));

    (define-macro (hook . body)  ; return a new hook with "body" as its body, setting "result"
      `(let ((h (make-hook)))
         (set! (hook-functions h) (list (lambda (h) (set! (h 'result) (begin ,@body)))))
         h))

#### procedure info

    (procedure-source proc)
    (procedure-documentation proc)
    (procedure-signature proc)
    (procedure-setter proc)
    (funclet proc)

    (arity obj)
    (aritable? obj num-args)

procedure-setter returns or sets the set function associated with a procedure (set-car! with car, for example). funclet returns a procedure's environment. procedure-source returns the procedure source (a list).

    (define (procedure-arglist f) (cadr (procedure-source f)))

procedure-documentation returns the documentation string associated with a procedure. This used to be the initial string in the function's body (as in CL), but now it is the value of the 'documentation variable, if any, in the procedure's local environment. That is, `(define (f a) "doc string" a)` is now `(define f (let ((documentation "doc string")) (lambda (a) a)))`. This change gets the string out of the body (where it can slow down evaluation of the function to no purpose), and makes it possible to extend the function information arbitrarily.

arity takes any object and returns either #f if it is not applicable, or a cons containing the minimum and maximum number of arguments acceptable. If the maximum reported is a really big number, that means any number of arguments is ok. aritable? takes two arguments, an object and an integer, and returns #t if the object can be applied to that many arguments.

    > (define add-2 (let ((documentation "add-2 adds its 2 args")) (lambda* (a (b 32)) (+ a b))))
    add-2
    > (procedure-documentation add-2)
    "add-2 adds its 2 args"
    > (procedure-source add-2)
    (lambda* (a (b 32)) (+ a b))
    > (arity add-2)
    (0 . 2)

procedure-signature is a list describing the argument types and returned value type of the function. The first entry in the list is the return type, and the rest are argument types. #t means any type is possible, and 'values means the function returns multiple values.

    > (procedure-signature round)
    (integer? real?) ; round takes a real argument, returns an integer
    > (procedure-signature vector-ref)
    (#t vector? . #1=(integer? . #1#)) ; trailing args are all integers (indices)

If an entry is a list, any of the listed types can occur:

    > (procedure-signature char-position)
    ((boolean? integer?) (char? string?) string? integer?)

which says that the first argument to char-position can be a string or a character, and the return type can be either boolean or an integer. If the function is defined in scheme, its signature is the value of the 'signature variable in its closure:

    > (define f1 (let ((documentation "helpful info")
                       (signature '(boolean? real?)))
                    (lambda (x)
                      (positive? x))))
    f1
    > (procedure-documentation f1)
    "helpful info"
    > (procedure-signature f1)
    (boolean? real?)

We could do the same thing using methods:

    > (define f1 (let ((procedure-documentation (lambda (f) "helpful info"))
                        (procedure-signature (lambda (f) '(boolean? real?))))
                    (openlet
                      (lambda (x)
                        (positive? x)))))
    > (procedure-documentation f1)
    "helpful info"
    > (procedure-signature f1)
    (boolean? real?)

openlet alerts s7 that f1 has methods.

> examples

> procedure-source returns the actual function source. If you call the function, the optimizer changes the source to suit itself, so if you want to walk over the function body or change it in some way, make a clean copy of the procedure-source first (using, for example, copy-tree in stuff.scm).

>     (define-bacro (procedure-annotate proc) ; use "bacro" so we can annotate local functions
>       (let ((orig (procedure-source proc))) ; this assumes we haven't called "proc" yet

>         (define (proc-walk source)
>           (cond ((not (pair? source))
>     	     source)

>     	    ((not (memq (car source) '(let let*))) ; if let or let*, show local variables
>     	     (cons (proc-walk (car source))
>     		   (proc-walk (cdr source))))

>     	    ((symbol? (cadr source))               ; named let?
>     	     (append               ; (let name vars . body) -> (let name vars print-vars . body)
>     	       (list (car source)
>     		     (cadr source)
>     		     (caddr source)
>     		     `(format () "    (let ~A (~{~A~^ ~}) ...)~%" ,(cadr source) (curlet)))
>     	       (cdddr source)))

>                 (else                  ; (let(*) vars . body) -> (let vars print-vars . body)
>     	      (append
>     	        (list (car source)
>     		      (cadr source)
>     		      `(format () "    (~A (~{~A~^ ~}) ...)~%" ,(car source) (curlet)))
>     	        (cddr source)))))

>         (let* ((new-body (proc-walk orig))
>     	   (result (gensym))
>     	   (new-source
>     	    `(lambda ,(cadr orig)
>     	       (let ((,result #<undefined>))
>     		 (dynamic-wind
>     		     (lambda ()       ; upon entry, show procedure name and args
>     		       (format () "(~A~{ ~A~})~%"
>                                    ',proc
>     			       (outlet (outlet (curlet)))))
>     		     (lambda ()
>     		       (set! ,result (,new-body ,@(cadr orig))))
>     		     (lambda ()       ; at exit, show result
>     		       (if (eq? ,result #<undefined>)
>     			   (format () "  ~A returns early~%" ',proc)
>     			   (format () "  ~A returns ~A~%" ',proc ,result))))))))

>           `(define ,proc ,new-source))))

>     > (define (hi a) (let ((b 12)) (+ b a)))
>     hi
>     > (procedure-annotate hi)
>     #<lambda (a)>
>     > (let ((x 32)) (+ 1 (hi x)))
>     45
>     ;; printing:
>     (hi (a . 32))
>         (let ((b . 12)) ...)
>       hi returns 44

> But maybe something less invasive is better. Here's a version of let that prints its bindings (this is borrowed from "nuntius" at reddit lisp):

>     (define-macro (print-let bindings . body)
>       (let ((temp-symbol (gensym)))
>         `(let ,(map (lambda (var/val)
>     		  `(,(car var/val)
>     		    (let ((,temp-symbol ,(cadr var/val)))
>     		      (format () ";~S: ~S -> ~S~%"
>     			      ',(car var/val)
>     			      ',(cadr var/val)
>     			      ,temp-symbol)
>     		      ,temp-symbol)))
>     		bindings)
>            ,@body)))

>     ;; or simpler:

>     (define-macro (print-let bindings . body)
>       `(let ,bindings
>          (format () "~{;~A~%~}" (curlet))
>          ,@body))

> A minor footnote: there are cases in s7 where aritable? can't tell whether a given number of arguments can be applied to an object. For example, `((list 1 (list 2 3)) 0 1)` is an error, but `((list 1 (list 2 3)) 1 1)` is 3. So `(aritable? (list 1 (list 2 3)) 2)` depdends on what actual arguments you pass. In these cases, aritable? returns `#f`.

>     (define (for-each-subset func args)
>       ;; form each subset of args, apply func to the subsets that fit its arity
>       (let subset ((source args)
>                    (dest ())
>                    (len 0))
>         (if (null? source)
>             (if (aritable? func len)   ; does this subset fit?
>                 (apply func dest))
>             (begin
>               (subset (cdr source) (cons (car source) dest) (+ len 1))
>               (subset (cdr source) dest len)))))

#### eval

eval evaluates its argument, a list representing a piece of code. It takes an optional second argument, the environment in which the evaluation should take place. eval-string is similar, but its argument is a string.

    > (eval '(+ 1 2))
    3
    > (eval-string "(+ 1 2)")
    3

Leaving aside a few special cases, eval-string could be defined:

    (define-macro* (eval-string x e)
      `(eval (with-input-from-string ,x read) (or ,e (curlet))))

> eval's environment argument is handy when implementing break and trace:

>     (define *breaklet* #f)
>     (define *step-hook* (make-hook 'code 'e))

>     (define-macro* (trace/break code . break-points)
>       (define (caller tree)
>         (if (pair? tree)
>     	(cons
>     	 (if (pair? (car tree))
>     	     (if (and (symbol? (caar tree))
>     		      (procedure? (symbol->value (caar tree))))
>     		 (if (member (car tree) break-points)
>     		     `(__break__ ,(caller (car tree)))
>     		     `(__call__ ,(caller (car tree))))
>     		 (caller (car tree)))
>     	     (car tree))
>     	 (caller (cdr tree)))
>     	tree))
>       `(call-with-exit (lambda (__top__) ,(caller code))))

>     (define (go . args)
>       (and (let? *breaklet*)
>            (apply (*breaklet* 'go) args)))

>     (define (clear-break)
>       (set! *breaklet* #f))

>     (define-macro (__call__ code)
>       `(*step-hook* ',code (curlet)))

>     (define-macro (__break__ code)
>       `(begin
>          (call/cc
>           (lambda (go)
>     	(set! *breaklet* (curlet))
>     	(__top__ (format #f "break at: ~A~%" ',code))))
>          ,code))

>     (set! (hook-functions *step-hook*)
>           (list (lambda (hook)
>     	      (set! (hook 'result) (eval (hook 'code) (hook 'e))))))

>     (set! ((funclet *step-hook*) 'end)
>           (list (lambda (hook)
>     	      (define (uncaller tree)
>     		(if (pair? tree)
>     		    (cons
>     		     (if (and (pair? (car tree))
>     			      (memq (caar tree) '(__call__ __break__)))
>     			 (uncaller (cadar tree))
>     			 (uncaller (car tree)))
>     		     (uncaller (cdr tree)))
>     		    tree))
>     	      (format (current-output-port) ": ~A -> ~A~40T~A~%"
>     		      (uncaller (hook 'code))
>     		      (hook 'result)
>     		      (if (and (not (eq? (hook 'e) (rootlet)))
>     			       (not (defined? '__top__ (hook 'e))))
>     			  (map values (hook 'e))
>     			  "")))))

>     ;;; (trace/break (let ((a (+ 3 1)) (b 2)) (if (> (* 2 a) b) 2 3)))
>     ;;; (trace/break (let ((a (+ 3 1)) (b 2)) (if (> (* 2 a) b) 2 3)) (* 2 a))

#### IO and other OS functions

Besides files, ports can also represent strings and functions. The string port functions are:

    (with-output-to-string thunk)         ; open a string port as current-output-port, call thunk, return string
    (with-input-from-string string thunk) ; open string as current-input-port, call thunk
    (call-with-output-string proc)        ; open a string port, apply proc to it, return string
    (call-with-input-string string proc)  ; open string as current-input-port, apply proc to it
    (open-output-string)                  ; open a string output port
    (get-output-string port clear)        ; return output accumulated in the string output port
    (open-input-string string)            ; open a string input port reading string

    > (let ((result #f)
            (p (open-output-string)))
        (format p "this ~A ~C test ~D" "is" #\a 3)
        (set! result (get-output-string p))
        (close-output-port p)
        result)
    "this is a test 3"

In get-output-string, if the optional 'clear' argument is #t, the port is cleared (the default in r7rs I think). Other functions:

- read-byte and write-byte: binary IO.
- read-line: line-at-a-time reads, optional third argument #t to include the newline.
- current-error-port, set-current-error-port

The variable (*s7* 'print-length) sets the upper limit on how many elements of a sequence are printed by object->string and format. The end-of-file object is #<eof>. When running s7 behind a GUI, you often want input to come from and output to go to arbitrary widgets. The function ports provide a way to redirect IO in C. See below for an example.

> The default IO ports are *stdin*, *stdout*, and *stderr*. *stderr* is useful if you want to make sure output is flushed out immediately. The default output port is *stdout* which buffers output until a newline is seen. In most REPLs, the input port is set up by the REPL, so you need to use *stdin* if you want to read from the terminal instead:

>     > (read-char)
>     #<eof>
>     > (read-char *stdin*)
>     a          ; here s7 waited for me to type "a" in the terminal
>     #\a        ; this is the REPL reporting what read-char returned

> An environment can be treated as an IO port, providing what Guile calls a "soft port":

>     (define (call-with-input-vector v proc)
>       (let ((i -1))
>         (proc (openlet (inlet 'read (lambda (p) (v (set! i (+ i 1)))))))))

> Here the IO port is an open environment that redefines the "read" function so that it returns the next element of a vector. See stuff.scm for call-with-output-vector. The "proc" argument above can also be a macro, giving you a kludgey way to get around the dumb "lambda". Here are more useful examples:

>     (openlet          ; a soft port for format that sends its output to *stderr* and returns the string
>       (inlet 'format (lambda (port str . args)
>      	           (display (apply format #f str args) *stderr*))))

>     (define (open-output-log name)
>       ;; return a soft output port that does not hold its output file open
>       (define (logit name str)
>         (let ((p (open-output-file name "a")))
>           (display str p)
>           (close-output-port p)))
>       (openlet
>        (inlet :name name
>     	  :format (lambda (p str . args) (logit (p 'name) (apply format #f str args)))
>     	  :write (lambda (obj p)         (logit (p 'name) (object->string obj #t)))
>     	  :display (lambda (obj p)       (logit (p 'name) (object->string obj #f)))
>     	  :write-string (lambda (str p)  (logit (p 'name) str))
>     	  :write-char (lambda (ch p)     (logit (p 'name) (string ch)))
>     	  :newline (lambda (p)           (logit (p 'name) (string #\newline)))
>     	  :close-output-port (lambda (p) #f)
>     	  :flush-output-port (lambda (p) #f))))

> binary-io.scm in the Snd package has functions that read and write integers and floats in both endian choices in a variety of sizes.

If the compile time switch WITH_SYSTEM_EXTRAS is 1, several additional OS-related and file-related functions are built-in. This is work in progress; currently this switch adds:

    (directory? str)         ; return #t if str is the name of a directory
    (file-exists? str)       ; return #t if str names an existing file
    (delete-file str)        ; try to delete the file, return 0 is successful, else -1
    (getenv var)             ; return the value of an environment variable: (getenv "HOME")
    (directory->list dir)    ; return contents of directory as a list of strings (if HAVE_DIRENT_H)
    (system command)         ; execute command

But maybe this is not needed; see cload.scm below for a more direct approach.

#### error handling

    (error tag . info)           ; signal an error of type tag with addition information
    (catch tag body err)         ; if error of type tag signalled in body (a thunk), call err with tag and info
    (throw tag . info)           ; jump to corresponding catch

s7's error handling mimics that of Guile. An error is signalled via the error function, and can be trapped and dealt with via catch.

    > (catch 'wrong-number-of-args
        (lambda ()     ; code protected by the catch
          (abs 1 2))
        (lambda args   ; the error handler
          (apply format #t (cadr args))))
    "abs: too many arguments: (1 2)"
    > (catch 'division-by-zero
        (lambda () (/ 1.0 0.0))
        (lambda args (string->number "inf.0")))
    inf.0

    (define-macro (catch-all . body)
      `(catch #t (lambda () ,@body) (lambda args args)))

catch has 3 arguments: a tag indicating what error to catch (#t = anything), the code, a thunk, that the catch is protecting, and the function to call if a matching error occurs during the evaluation of the thunk. The error handler takes a rest argument which will hold whatever the error function chooses to pass it. The error function itself takes at least 2 arguments, the error type, a symbol, and the error message. There may also be other arguments describing the error. The default action, in the absence of any catch, is to treat the message as a format control string, apply format to it and the other arguments, and send that info to the current-error-port.

> Normally when reading a file, we have to check for #<eof>, but we can let s7 do that:

>     (define (copy-file infile outfile)
>       (call-with-input-file infile
>         (lambda (in)
>           (call-with-output-file outfile
>     	(lambda (out)
>     	  (catch 'wrong-type-arg   ; s7 raises this error if write-char gets #<eof>
>     	    (lambda ()
>     	      (do () ()            ; read/write until #<eof>
>     		(write-char (read-char in) out)))
>     	    (lambda err
>     	      outfile)))))))

> catch is not limited to error handling:

>     (define (map-with-exit func . args)
>       ;; map, but if early exit taken, return the accumulated partial result
>       ;;   func takes escape thunk, then args
>       (let* ((result ())
>     	 (escape-tag (gensym))
>     	 (escape (lambda () (throw escape-tag))))
>         (catch escape-tag
>           (lambda ()
>     	(let ((len (apply max (map length args))))
>     	  (do ((ctr 0 (+ ctr 1)))
>     	      ((= ctr len) (reverse result))      ; return the full result if no throw
>     	    (let ((val (apply func escape (map (lambda (x) (x ctr)) args))))
>     	      (set! result (cons val result))))))
>           (lambda args
>     	(reverse result))))) ; if we catch escape-tag, return the partial result

>     (define (truncate-if func lst)
>       (map-with-exit (lambda (escape x) (if (func x) (escape) x)) lst))

>     > (truncate-if even? #(1 3 5 -1 4 6 7 8))
>     (1 3 5 -1)

> But this is less useful than map (it can't map over a hash-table for example), and is mostly reimplementing built-in code. Perhaps s7 should have an extension of map (and more usefully, for-each) that is patterned after dynamic-wind: `(dynamic-for-each init-func main-func end-func . args)` where init-func is called with one argument, the length of the shortest sequence argument (for-each and map know this in advance); main-func takes n arguments where n matches the number of sequences passed; and end-func is called even if a jump out of main-func occurs (like dynamic-wind in this regard). In the dynamic-map case, the end-func takes one argument, the current, possibly partial, result list. dynamic-for-each then could easily (but maybe not efficiently) implement generic functions such as ->list, ->vector, and ->string (converting any sequence into a sequence of some other type). map-with-exit would be

>     (define (map-with-exit func . args)
>       (let ((result ()))
>         (call-with-exit
>           (lambda (quit)
>             (apply dynamic-map #f ; no init-func in this case
>                    (lambda main-args
>                      (apply func quit main-args))
>                    (lambda (res)
>                      (set! result res))
>                    args)))
>         result))

> With all the lambda boilerplate, nested catches are hard to read:

>     (catch #t
>       (lambda ()
>         (catch 'division-by-zero
>           (lambda ()
>     	(catch 'wrong-type-arg
>     	  (lambda ()
>     	    (abs -1))
>     	  (lambda args (format () "got a bad arg~%") -1)))
>           (lambda args 0)))
>       (lambda args 123))

> Perhaps we need a macro:

>     (define-macro (catch-case clauses . body)
>       (let ((base `(lambda () ,@body)))
>         (for-each (lambda (clause)
>     	        (let ((tag (car clause)))
>     	          (set! base `(lambda ()
>     			        (catch ',(or (eq? tag 'else) tag)
>     			          ,base
>     			          ,@(cdr clause))))))
>     	      clauses)
>         (caddr base)))

>     ;;; the code above becomes:
>     (catch-case ((wrong-type-arg   (lambda args (format () "got a bad arg~%") -1))
>     	     (division-by-zero (lambda args 0))
>     	     (else             (lambda args 123)))
>       (abs -1))

> This is similar to r7rs scheme's "guard", but I don't want a pointless thunk for the body of the catch. Along the same lines:

>     (define (catch-if test func err)
>       (catch #t
>         func
>         (lambda args
>           (apply (if (test (car args)) err throw) args)))) ; if not caught, re-raise the error via throw

>     (define (catch-member lst func err)
>       (catch-if (lambda (tag) (member tag lst)) func err))

>     (define-macro (catch* clauses . error)
>       ;; try each clause until one evaluates without error, else error:
>       ;;    (macroexpand (catch* ((+ 1 2) (- 3 4)) 'error))
>       ;;    (catch #t (lambda () (+ 1 2)) (lambda args (catch #t (lambda () (- 3 4)) (lambda args 'error))))
>       (define (builder lst)
>         (if (null? lst)
>     	(apply values error)
>     	`(catch #t (lambda () ,(car lst)) (lambda args ,(builder (cdr lst))))))
>       (builder clauses))

When an error is encountered, and when s7 is interrupted via begin_hook, (owlet) returns an environment that contains additional info about that error:

- error-type: the error type or tag, e.g. 'division-by-zero
- error-data: the message or information passed by the error function
- error-code: the code that s7 thinks triggered the error
- error-line: the line number of that code
- error-file: the file name of that code
- error-history: previous evaluations leading to the error (a circular list)

The error-history field depends on the compiler flag WITH_HISTORY. See ow! in stuff.scm for one way to display this data. The *s7* field 'history-size sets the size of the buffer.

> To find a variable's value at the point of the error: `((owlet) var)`. To list all the local bindings from the error outward:

>     (do ((e (outlet (owlet)) (outlet e)))
>         ((eq? e (rootlet)))
>       (format () "~{~A ~}~%" e))

> To see the current s7 stack, `(stacktrace)`. You'll probably want to use this in conjunction with *error-hook*. To evaluate the error handler in the environment of the error:

>     (let ((x 1))
>       (catch #t
>     	 (lambda ()
>     	   (let ((y 2))
>     	     (error 'oops)))
>     	 (lambda args
>     	   (with-let (sublet (owlet) :args args)    ; add the error handler args
>     	     (list args x y)))))    ; we have access to 'y'

> To limit the maximum size of the stack, set (*s7* 'max-stack-size).

The hook *error-hook* provides a way to specialize error reporting. Its arguments are named 'type and 'data.

    (set! (hook-functions *error-hook*)
          (list (lambda (hook)
                  (apply format *stderr* (hook 'data))
                  (newline *stderr*))))

*read-error-hook* provides two hooks into the reader. A major problem when reading code written for other Schemes is that each Scheme provides a plethora of idiosyncratic #-names (even special character names), and \ escapes in string constants. *read-error-hook* provides a way to handle these weird cases. If a #-name is encountered that s7 can't deal with, *read-error-hook* is called with two arguments, #t and the string representing the constant. If you set (hook 'result), that result is returned to the reader. Otherwise a 'read-error is raised and you drop into the error handler. Similarly, if some bizaare \ use occurs, *read-error-hook* is called with two arguments, #f and the offending character. If you return a character, it is passed to the reader; otherwise you get an error. lint.scm has an example.

There is a break macro defined in Snd (snd-xen.c) which allows you to stop at some point, then evaluate arbitrary expressions in that context.

The s7-built-in catch tags are 'wrong-type-arg, 'syntax-error, 'read-error, 'out-of-memory, 'wrong-number-of-args, 'format-error, 'out-of-range, 'division-by-zero, 'io-error, and 'bignum-error.

#### autoload

If s7 encounters an unbound variable, it first looks to see if it has any autoload information about it. This info can be declared via autoload, a function of two arguments, the symbol that triggers the autoload, and either a filename or a function. If a filename, s7 loads that file; if a function, it is called with one argument, the current (calling) environment.

    (autoload 'channel-distance "dsp.scm")
    ;; now if we subsequently call channel-distance but forget to load "dsp.scm" first,
    ;;   s7 loads "dsp.scm" itself, and uses its definition of channel-distance.
    ;;   The C-side equivalent is s7_autoload.

    ;; here is the cload.scm case, loading j0 from the math library if it is called:
    (autoload 'j0
    	  (lambda (e)
    	    (unless (provided? 'cload.scm)
    	      (load "cload.scm"))
    	    (c-define '(double j0 (double)) "" "math.h")
    	    (varlet e 'j0 j0)))

The entity (hash-table or environment probably) that holds the autoload info is named *autoload*. If after checking autoload, the symbol is still unbound, s7 calls *unbound-variable-hook*. The offending symbol is named 'variable in the hook environment. If after running *unbound-variable-hook*, the symbol is still unbound, s7 calls the error handler.

The autoloader knows about s7 environments used as libraries, so, for example, you can `(autoload 'j0 "libm.scm")`, then use j0 in scheme code. The first time s7 encounters j0, j0 is undefined, so s7 loads libm.scm. That load returns the C math library as the environment *libm*. s7 then automatically looks for j0 in *libm*, and defines it for you. So the result is the same as if you had defined j0 yourself in C code. You can use the r7rs library mechanism here, or with-let, or whatever you want! (In Snd, libc, libm, libdl, and libgdbm are automatically tied into s7 via autoload, so if you call, for example, frexp, libm.scm is loaded, and frexp is exported from the *libm* environment, then the evaluator soldiers on, as if frexp had always been defined in s7). You can also import all of (say) gsl into the current environment via `(varlet (curlet) *libgsl*)`.

#### define-constant, constant?, symbol-access

define-constant defines a constant and constant? returns #t if its argument is a constant. A constant in s7 is really constant: it can't be set or rebound.

    > (define-constant var 32)
    var
    > (set! var 1)
    ;set!: can't alter immutable object: var
    > (let ((var 1)) var)
    ;can't bind or set an immutable object: var, line 1

This has the possibly surprising side effect that previous uses of the constant name become constants:

    (define (func a) (let ((cvar (+ a 1))) cvar))
    (define-constant cvar 23)
    (func 1)
    ;can't bind or set an immutable object: cvar

So, obviously, choose unique names for your constants, or don't use define-constant. A function can also be a constant. In some cases, the optimizer can take advantage of this information to speed up function calls.

Constants are very similar to things such as keywords (no set, always return itself as its value), variable trace (informative function upon set or keeping a history of past values), typed variables (restricting a variable's values or doing automatic conversions upon set), and notification upon set (either in Scheme or in C; I wanted this many years ago in Snd). The notification function is especially useful if you have a Scheme variable and want to reflect any change in its value immediately in C (see below). In s7, symbol-access sets this function.

Each environment is a set of symbols and their associated values. symbol-access places a function (or macro) between a symbol and its value in a given environment. The accessor function takes two arguments, the symbol and the new value, and returns the value that is actually set. For example, the function can ensure that a variable is always an integer:

    (define e      ; save environment for use below
      (let ((x 3)  ; will always be an integer
    	(y 3)  ; will always keep its initial value
    	(z 3)) ; will report set!

        (set! (symbol-access 'x) (lambda (s v) (if (integer? v) v x)))
        (set! (symbol-access 'y) (lambda (s v) y))
        (set! (symbol-access 'z) (lambda (s v) (format *stderr* "z ~A -> ~A~%" z v) v))

        (set! x 3.3) ; x does not change because 3.3 is not an integer
        (set! y 3.3) ; y does not change
        (set! z 3.3) ; prints "z 3 -> 3.3"
        (curlet)))

    > e
    (inlet 'x 3 'y 3 'z 3.3)
    >(begin (set! (e 'x) 123) (set! (e 'y) #()) (set! (e 'z) #f))
    ;; prints "z 3.3 -> #f"
    > e
    (inlet 'x 123 'y 3 'z #f)
    > (define-macro (reflective-let vars . body)
        `(let ,vars
           ,@(map (lambda (vr)
    	        `(set! (symbol-access ',(car vr))
    		       (lambda (s v)
    		         (format *stderr* "~S -> ~S~%" s v)
    		         v)))
    	      vars)
           ,@body))
    reflective-let
    > (reflective-let ((a 1)) (set! a 2))
    2     ; prints "a -> 2"
    >(let ((a 0))
         (set! (symbol-access 'a)
          (let ((history (make-vector 3 0))
    	    (position 0))
    	(lambda (s v)
    	  (set! (history position) v)
    	  (set! position (+ position 1))
    	  (if (= position 3) (set! position 0))
    	  v)))
         (set! a 1)
         (set! a 2)
         ((funclet (symbol-access 'a)) 'history))
    #(1 2 0)

Or implement reactive programming:

    (let ((a 1)
          (b 2)
          (c 3))
      (set! (symbol-access 'b) (lambda (s v) (set! a (+ v c)) v))
      (set! (symbol-access 'c) (lambda (s v) (set! a (+ b v)) v))
      (set! a (+ b c)) ; a will be updated if b or c is set
      (set! b 4)
      (set! c 5)
      a)               ; a is 9 = (+ 4 5)

reactive-let

stuff.scm has reactive-set!, reactive-vector, reactive-let, reactive-let*, and reactive-lambda*:

    > (let ((-a- 1)
            (b 2))
        (reactive-set! -a- (* b 2))
        (set! b 3)
        -a-)
    6
    > (let ((a 1))
        (let ((v (reactive-vector a (+ a 1) 2)))
          (set! a 4)
          v))
    #(4 5 2)
    > (let ((a 1))
        (reactive-let ((-b- (+ a 1))) ; if 'a changes, '-b- does too
        (set! a 3)                  ;   so '-b- is now 4
        -b-))
    4
    > (let ((a 1))
        (reactive-lambda* (s v)
          (format *stderr* "~S -> ~S~%" s v))
        (set! a 3))
    "a -> 3"

In the reactive-let example, the macro notices that '-b- depends on 'a, so it sets up a symbol-access on 'a so that `(set! a 3)` triggers `(set! -b- (+ a 1))`. I'm using -name- to distinguish the variables that can change value at any time; in the Lisp community, +name+ is often used to mark a constant, so this seems like a natural convention.

Here's the standard example of following the mouse (assuming you're using Snd and glistener):

    (let ((*mouse-x* 0) (*mouse-y* 0)
          (x 0) (y 0))

      (reactive-set! x (let ((val (round *mouse-x*)))
    		     (format *stderr* "mouse: ~A ~A~%" x y)
    		     val))
      (reactive-set! y (round *mouse-y*))

      (g_signal_connect (G_OBJECT (listener-text-widget *listener*)) "motion_notify_event"
    		    (lambda (w e d)
    		      (let ((mxy (cdr (gdk_event_get_coords (GDK_EVENT e)))))
    			(set! *mouse-x* (car mxy))
    			(set! *mouse-y* (cadr mxy))))))

reactive-lambda* is aimed at library consistency. Say we have the following library that wants A to always be half B:

    (define (make-library)
      (let ((A 1.0)
    	(B 2.0))
        (reactive-lambda* (s v)
          (case s
    	((A) (set! B (* 2 v)))
    	((B) (set! A (/ v 2)))))
        (define (f1 x)
          (+ A (* B x)))
        (curlet)))

    (with-let (make-library)
      (format *stderr* "(f1 3): ~A~%" (f1 3))
      (set! A 3.0)
      (format *stderr* "A: ~A, B: ~A, (f1 3): ~A~%" A B (f1 3))
      (set! B 4.0)
      (format *stderr* "A: ~A, B: ~A, (f1 3): ~A~%" A B (f1 3)))

reactive-lambda* sets up accessors on the library's top-level variables that call the lambda body if one of the variables is set.

None of these macros does the right thing yet; I'm sort of following my nose.

#### marvels and curiousities

*load-path* is a list of directories to search when loading a file. *load-hook* is a hook whose functions are called just before a file is loaded. The hook function argument, named 'name, is the filename. While loading, the port-filename and port-line-number of the current-input-port can tell you where you are in the file. This data is available after loading via pair-line-number and pair-filename. port-line-number is settable (for fancy *#readers*).

    (set! (hook-functions *load-hook*)
           (list (lambda (hook)
                   (format () "loading ~S...~%" (hook 'name)))))

    (set! (hook-functions *load-hook*)
          (cons (lambda (hook)
                  (format *stderr* "~A~%"
                    (system (string-append "./snd lint.scm -e '(begin (lint \"" (hook 'name) "\") (exit))'") #t)))
                (hook-functions *load-hook*)))

Here's a *load-hook* function that adds the loaded file's directory to the *load-path* variable so that subsequent loads don't need to specify the directory:

    (set! (hook-functions *load-hook*)
      (list (lambda (hook)
              (let ((pos -1)
                    (filename (hook 'name)))
                (do ((len (length filename))
                     (i 0 (+ i 1)))
    	        ((= i len))
    	      (if (char=? (filename i) #\/)
    	          (set! pos i)))
                (if (positive? pos)
    	        (let ((directory-name (substring filename 0 pos)))
    	          (if (not (member directory-name *load-path*))
    		      (set! *load-path* (cons directory-name *load-path*)))))))))

As in Common Lisp, *features* is a list describing what is currently loaded into s7. You can check it with the provided? function, or add something to it with provide. In my version of Snd, at startup *features* is:

    > *features*
    (snd-16.7 snd15 snd audio snd-s7 snd-gtk gsl alsa gtk2 xg clm6 clm sndlib linux
     dlopen complex-numbers system-extras ratio s7-3.26 s7)
    > (provided? 'gsl)
    #t

The other side of `provide` is require. `(require . things)` finds each thing (via autoload), and if that thing has not already been loaded, loads the associated file. `(require integrate-envelope)` loads "env.scm", for example; in this case it is equivalent to simply using integrate-envelope, but if placed at the start of a file, it documents that you're using that function. In the more normal use, `(require snd-ws.scm)` looks for the file that has `(provide 'snd-ws.scm)` and if it hasn't already been loaded, loads it ("ws.scm" in this case). To add your own files to this mechanism, add the provided symbol via autoload. Since load can take an environment argument, *features* and its friends follow block structure. So, for example, (let () (require stuff.scm) ...) loads "stuff.scm" into the local environment, not globally.

*features* is an odd variable: it is spread out across the chain of environments, and can hold features in an intermediate environment that aren't in subsequent (nested) values. One simple way this can happen is to load a file in a let, but cause the load to happen at the top level. The provided entities get added to the top-level *features* value, not the current let's value, but they are actually accessible locally. So *features* is a merge of all its currently accessible values, vaguely like call-next-method in CLOS. We can mimic this behavior:

    (let ((x '(a)))
      (let ((x '(b)))
        (define (transparent-memq sym var e)
          (let ((val (symbol->value var e)))
    	(or (and (pair? val)
    		 (memq sym val))
    	    (and (not (eq? e (rootlet)))
    		 (transparent-memq sym var (outlet e))))))
        (let ((ce (curlet)))
          (list (transparent-memq 'a 'x ce)
    	    (transparent-memq 'b 'x ce)
    	    (transparent-memq 'c 'x ce)))))

    '((a) (b) #f)

Multi-line and in-line comments can be enclosed in #| and |#. `(+ #| add |# 1 2)`.

Leaving aside this case and the booleans, #f and #t, you can specify your own handlers for tokens that start with "#". *#readers* is a list of pairs: `(char . func)`. "char" refers to the first character after the sharp sign (#). "func" is a function of one argument, the string that follows the #-sign up to the next delimiter. "func" is called when #<char> is encountered. If it returns something other than #f, the #-expression is replaced with that value. Scheme has several predefined #-readers for cases such as #b1, #\a, #i123, and so on, but you can override these if you like. If the string passed in is not the complete #-expression, the function can use read-char or read to get the rest. Say we'd like #t<number> to interpret the number in base 12:

    (set! *#readers* (cons (cons #\t (lambda (str) (string->number (substring str 1) 12))) *#readers*))

    > #tb
    11
    > #t11.3
    13.25

Or have #c(real imag) be read as a complex number:

    (set! *#readers* (cons (cons #\c (lambda (str) (apply complex (read)))) *#readers*))

    > #c(1 2)
    1+2i

Here's a reader macro for read-time evaluation:

    (set! *#readers*
      (cons (cons #\. (lambda (str)
    		    (and (string=? str ".") (eval (read)))))
    	*#readers*))

    > '(1 2 #.(* 3 4) 5)
    (1 2 12 5)

And a reader that implements #[...]# for literal hash-tables:

    > (set! *#readers*
        (list (cons #\[ (lambda (str)
    		      (let ((h (make-hash-table)))
    		        (do ((c (read) (read)))
    		            ((eq? c ']#) h) ; ]# is a symbol from the reader's point of view
    		          (set! (h (car c)) (cdr c))))))))
    ((#\[ . #<lambda (str)>))
    > #[(a . 1) (b . #[(c . 3)]#)]#
    (hash-table '(b . (hash-table '(c . 3))) '(a . 1))

To return no value from a reader, use `(values)`.

    > (set! *#readers* (cons (cons #\; (lambda (str) (if (string=? str ";") (read)) (values))) *#readers*))
    ((#\; . #<lambda (str)>))
    > (+ 1 #;(* 2 3) 4)
    5

Here is CL's #+ reader:

    (define (sharp-plus str)
      ;; str here is "+", we assume either a symbol or an expression involving symbols follows
      (let ((e (if (string=? str "+")
    		(read)                                ; must be #+(...)
    		(string->symbol (substring str 1))))  ; #+feature
    	(expr (read)))  ; this is the expression following #+
        (if (symbol? e)
            (if (provided? e)
    	    expr
    	    (values))
    	(if (not (pair? e))
    	    (error "strange #+ chooser: ~S~%" e)
    	    (begin      ; evaluate the #+(...) expression as in cond-expand
    	      (define (traverse tree)
    		(if (pair? tree)
    		    (cons (traverse (car tree))
    			  (if (null? (cdr tree)) () (traverse (cdr tree))))
    		    (if (memq tree '(and or not)) tree
    			(and (symbol? tree) (provided? tree)))))
    	      (if (eval (traverse e))
    		  expr
    		  (values)))))))

See also the #n= reader below.

(make-list length (initial-element #f)) returns a list of 'length' elements defaulting to 'initial-element'.

    (char-position char-or-string searched-string (start 0))
    (string-position substring searched-string (start 0))

char-position and string-position search a string for the occurrence of a character, any of a set of characters, or a string. They return either #f if none is found, or the position within the searched string of the first occurrence. The optional third argument sets where the search starts in the second argument.

If char-position's first argument is a string, it is treated as a set of characters, and char-position looks for the first occurrence of any member of that set. Currently, the strings involved are assumed to be C strings (don't expect embedded nulls to work right in this context).

    (call-with-input-file "s7.c" ; report any lines with "static " but no following open paren
      (lambda (file)
        (let loop ((line (read-line file #t)))
          (or (eof-object? line)
    	  (let ((pos (string-position "static " line)))
    	    (if (and pos
    		     (not (char-position #\( (substring line pos))))
     	        (if (> (length line) 80)
    		    (begin (display (substring line 0 80)) (newline))
    		    (display line))))
    	    (loop (read-line file #t)))))))

Keywords exist mainly for define*'s benefit. The keyword functions are: keyword?, make-keyword, symbol->keyword, and keyword->symbol. A keyword is a symbol that starts or ends with a colon. The colon is considered to be a part of the symbol name. A keyword is a constant that evaluates to itself.

    (symbol-table)
    (symbol->value sym (env (curlet)))
    (symbol->dynamic-value sym)
    (defined? sym (env (curlet)) ignore-global-env)

`defined?` returns #t if the symbol is defined in the environment:

    (define-macro (defvar name value)
      `(unless (defined? ',name)
         (define ,name ,value)))

If ignore-global-env is #t, the search is confined to the given environment. `symbol->value` returns the value (lexically) bound to the symbol, whereas `symbol->dynamic-value` returns the value dynamically bound to it. A variable can access both of its values:

    > (let ((x 32))
      (define (gx) ; return both bindings of 'x
        (list x (symbol->value 'x) (symbol->dynamic-value 'x)))
      (let ((x 100))
        (let ((x 12))
          (values (gx))))) ; this 'values' looks dumb, it is dumb, but see my unconvincing explanantion below.
                           ;   briefly: "dynamic binding" in s7 is not "lexically apparent dynamic binding"
    (32 32 12)

`symbol-table` returns a vector containing the symbols currently in the symbol-table. Here we scan the symbol table looking for any function that doesn't have documentation:

    (for-each
       (lambda (sym)
         (if (defined? sym)
             (let ((val (symbol->value sym)))
               (if (and (procedure? val)
                        (string=? "" (procedure-documentation val)))
                   (format *stderr* "~S " sym)))))
      (symbol-table))

Here's a better example, an automatic software tester.

    (for-each
      (lambda (sym)
        (if (defined? sym)
    	(let ((val (symbol->value sym)))
              (if (procedure? val)
    	      (let ((max-args (cdr (arity val))))
    	        (if (or (> max-args 4)
    	   	        (memq sym '(exit abort)))
    		    (format () ";skip ~S for now~%" sym)
    		    (begin
    		      (format () ";whack on ~S...~%" sym)
                          (let ((constants (list #f #t pi () 1 1.5 3/2 1.5+i)))
                            (let autotest ((args ()) (args-left max-args))
                              (catch #t (lambda () (apply func args)) (lambda any #f))
                              (if (> args-left 0)
     	                      (for-each
    	                        (lambda (c)
    	                          (autotest (cons c args) (- args-left 1)))
    	                        constants)))))))))))
      (symbol-table))

more on dynamic values

Why the useless 'values' in our dynamic binding example? The short answer: tail calls. The long winded one goes something like this. symbol->dynamic-value searches the stack to find the latest binding of its argument. But because we want to support tail calls, "let" does not push anything on the stack. If we call a function as the last thing that happens in that let's body, and it tries (internally) to access a dynamic binding, the let that launched the function no longer exists; it might already be garbage collected, and it certainly isn't on the stack. Take our earlier example without the 'values':

    (let ((x 32))
      (define (gx)
        (symbol->dynamic-value 'x))
      (let ((x 100))
        (gx)))

This returns 32 because the `(x 100)` binding no longer exists anywhere when the gx body is evaluated. So, in s7, the "dynamic binding" of x is the last binding of x that is accessible to s7. This may not be the last binding that we can see in the code text, but I don't see that as an inconsistency. It's not lexical after all. Leaving aside this special case, so to speak, dynamic binding does what you'd expect, even in the context of call/cc. See s7test.scm for the MIT-Scheme test of that interaction.

There is another way to get the call-time value:

    (define-macro (elambda args . body)
      `(define-macro (,(gensym) ,@args)
        `((lambda* ,(append ',args `((*env* (curlet))))
            ,'(begin ,@body))
          ,,@args)))

    (define efunc (elambda (x) (+ (*env* 'y) x))) ; add x to the run-time value of y
    (let ((y 3)) (efunc 1)) ; returns 4

elambda does not suffer from the symbol->dynamic-value defects mentioned above, but it's probably slower. We have to wrap the function in a macro because lambda*'s argument default values are evaluated in the definition environment, but we want the run-time environment.

    (define-macro* (rlambda args . body) ; lambda* but eval arg defaults in run-time env
      (let ((arg-names (map (lambda (arg) (if (pair? arg) (car arg) arg)) args))
    	(arg-defaults (map (lambda (arg) (if (pair? arg) `(,(car arg) (eval ,(cadr arg))) arg)) args)))
        `(define-bacro* (,(gensym) ,@arg-defaults)
          `((lambda ,',arg-names ,'(begin ,@body)) ,,@arg-names))))

    (let ()
      (define rx (rlambda ((a x))
                   (if (> a 0)
                       (let ((x (- x 1))) ;:)
                         (rx))
                       0)))
      (let ((x 3))
        (rx)))

Now putting that idea with the procedure-annotation macro given earlier, and the __func__ business (to get the caller's name), and taking care to handle default arguments correctly, we make a macro that returns an anonymous macro that returns an anonymous function that — where was I?

    (define-macro (Display definition) ; (Display (define (f1 x) (+ x 1))) -> an annotated version of f1
      (let ((func (caadr definition))
    	(args (cdadr definition)))
        (let ((arg-names (map (lambda (a) (if (symbol? a) a (car a))) args))
    	  (body (proc-walk `(begin ,@(cddr definition))))) ; from procedure-annotation above
          `(define ,func
    	  (define-macro* (,(gensym) ,@args)
    	    (let ((e (gensym))
    		  (result (gensym)))
    	      `((lambda* ,(append ',arg-names `((,e (curlet)))) ; the calling environment
    		  (let ((,result '?))
    		    (dynamic-wind
    			(lambda ()    ; display the caller, if any, as well as the incoming arguments
    			  (format *stderr* "(~A~{~^ ~A~})" ',',func
    				  (map (lambda (slot)
    					 (if (gensym? (car slot)) (values) slot))
    				       (outlet (outlet (curlet)))))
    			  (let ((caller (eval '__func__ ,e)))
    			    (if (not (eq? caller #<undefined>))
    				(format *stderr* " ;called from ~S" caller))
    			    (newline *stderr*)))
    			(lambda ()   ; evaluate the original function's body with annotations
    			  (set! ,result ,',body))
    			(lambda ()   ; display the result (it is returned by the set! above)
    			  (format *stderr* "    -> ~S~%" ,result)))))
    		,,@arg-names)))))))

stuff.scm has a more mature version of this macro.

help tries to find information about its argument.

    > (help 'caadar)
    "(caadar lst) returns (car (car (cdr (car lst)))): (caadar '((1 (2 3)))) -> 2"

gc calls the garbage collector. `(gc #f)` turns off the GC, and `(gc #t)` turns it on.

    (morally-equal? x y)

Say we want to check that two different computations came to the same result, and that result might involve circular structures. Will equal? be our friend?

    > (equal? 2 2.0)
    #f
    > (let ((x +nan.0)) (equal? x x))
    #f
    > (equal? .1 1/10)
    #f
    > (= .1 1/10)
    #f
    > (= 0.0 0+1e-300i)
    #f

No! We need an equality check that ignores epsilonic differences in real and complex numbers, and knows that NaNs are equal for all practical purposes. Leaving aside numbers, closed ports are not equal, yet nothing can be done with them. #() is not equal to #2d(). And two closures are never equal, even if their arguments, environments, and bodies are equal. Since there might be circles, it is not easy to write a replacement for equal? in Scheme. So, in s7, if one thing is basically the same as some other thing, they satisfy the function morally-equal?.

    > (morally-equal? 2 2.0)        ; would "equal!?" be a better name?
    #t
    > (morally-equal? 1/0 1/0)      ; NaN
    #t
    > (morally-equal? .1 1/10)
    #t                              ; floating-point epsilon here is 1.0e-15 or thereabouts
    > (morally-equal? 0.0 1e-300)
    #t
    > (morally-equal? 0.0 1e-14)
    #f                              ; its not always #t!
    > (morally-equal? (lambda () #f) (lambda () #f))
    #t

The *s7* field morally-equal-float-epsilon sets the floating-point fudge factor. I can't decide how bignums should interact with morally-equal?. Currently, if a bignum is involved, either here or in a hash-table, s7 uses equal?. Finally, if either argument is an environment with a 'morally-equal? method, that method is invoked.

define-expansion defines a macro that expands at read-time. It has the same syntax as define-macro, and (in normal use) the same result, but it is much faster because it expands only once. (See define-with-macros in s7test.scm for a way to expand macros in a function body at definition time). Since the reader knows almost nothing about the code it is reading, you need to make sure the expansion is defined at the top level and that its name is unique! The reader does know about global variables, so:

    (define *debugging* #t)

    (define-expansion (assert assertion)
      (if *debugging*          ; or maybe better, (eq? (symbol->value '*debugging*) #t)
          `(unless ,assertion
    	 (format *stderr* "~A: ~A failed~%" __func__ ',assertion))
          (values)))

Now the assertion code is only present in the function body (or wherever) if *debugging* is #t; otherwise assert expands into nothing. Another very handy use is to embed a source file line number into a message; see for example lint-format in lint.scm. Leaving aside read-time expansion and splicing, the real difference between define-macro and define-expansion is that the expansion's result is not evaluated. I'm no historian, but I believe that means that define-expansion creates a (gasp!) f*xpr. In fact:

    (define-macro (define-f*xpr name-and-args . body)
      `(define ,(car name-and-args)
         (apply define-expansion
           (append (list (append (list (gensym)) ',(cdr name-and-args))) ',body))))

    > (define-f*xpr (mac a) `(+ ,a 1))
    mac
    > (mac (* 2 3))
    (+ (* 2 3) 1)

You can do something similar with a normal macro, or make the indirection explicit:

    > (define-macro (fx x) `'(+ 1 ,x)) ; quote result to avoid evaluation
    fx
    > (let ((a 3)) (fx a))
    (+ 1 a)
    > (define-expansion (ex x) `(+ 1 ,x))
    ex
    > (let ((x ex) (a 3)) (x a))       ; avoid read-time splicing
    (+ 1 a)
    > (let ((a 3)) (ex a))             ; spliced in at read-time
    4

As this example shows, the reader knows nothing about the program context, so if it does not see a list whose first element is a expansion name, it does not do anything special. In the `(x a)` case above, the expansion happens when the code is evaluated, and the expansion result is simply returned, unevaluated.

You can also use macroexpand to cancel the evaluation of a macro's expansion:

    (define-macro (rmac . args)
      (if (null? args)
          ()
          (if (null? (cdr args))
    	  `(display ',(car args))
    	  (list 'begin
                    `(display ',(car args))
    		(apply macroexpand (list (cons 'rmac (cdr args))))))))

    > (macroexpand (rmac a b c))
    (begin (display 'a) (begin (display 'b) (display 'c)))
    > (begin (rmac a b c d) (newline))
    abcd

The main built-in expansion is reader-cond. The syntax is based on cond: the car of each clause is evaluated (in the read-time context), and if it is not false, the remainder of that clause is spliced into the code as if you had typed it from the start.

    > '(1 2 (reader-cond ((> 1 0) 3) (else 4)) 5 6)
    (1 2 3 5 6)
    > ((reader-cond ((> 1 0) list 1 2) (else cons)) 5 6)
    (1 2 5 6)

If you build s7 with the flag -DWITH_PROFILE=1, s7 accumulates profiling data in the (*s7* 'profile-info) hash-table. The line number reported sometimes points to the end of the form. Also, do loops and other iterations are sometimes highly optimized, so only the outer form is counted. profile.scm shows one way to sort and display this data. To clear the counts, `(fill! (*s7* 'profile-info) #f)`.

*s7* is an environment that gives access to some of s7's internal state:

    print-length                  number of elements of a sequence to print
    max-string-length             max size arg to make-string and read-string
    max-list-length               max size arg to make-list
    max-vector-length             max size arg to make-vector and make-hash-table
    max-vector-dimensions         make-vector dimensions limit
    default-hash-table-length     default size for make-hash-table (8, tables resize as needed)
    initial-string-port-length    128, initial size of a string port's buffer
    history-size                  eval history buffer size if s7 built WITH_HISTORY=1
    profile-info                  profiling data if s7 built WITH_PROFILE=1

    default-rationalize-error     1e-12 (settable)
    morally-equal-float-epsilon   1e-15 (settable)
    hash-table-float-epsilon      1e-12 (settable, but currently limited to less than 1e-3).
    bignum-precision              bits for bignum floats (128)
    float-format-precision        digits to print for floats (16)
    default-random-state          the default arg for random (settable)

    cpu-time                      run time so far
    file-names                    currently loaded files (a list)

    safety                        0
    undefined-identifier-warnings #f

    catches                       a list of the currently active catch tags
    exits                         a list of active call-with-exit exit functions
    c-types                       a list of c-object type names (from s7_new_type, etc)
    input-ports, output-ports, strings, gensyms, vectors, hash-tables, continuations

    stack-top                     current stack location
    stack-size                    current stack size
    max-stack-size                max stack size (settable)
    stack                         the current stack entries
    stacktrace-defaults           stacktrace formatting info for error handler

    symbol-table                  a vector
    symbol-table-locked?          #f (if #t, no new symbols can be added to the symbol table)
    rootlet-size                  the number of globals

    heap-size                     total cells currently available
    free-heap-size                the number of currently unused cells
    gc-freed                      number of cells freed by the last GC pass
    gc-protected-objects          vector of the objects permanently protected from the GC
    gc-stats                      #f (#t turns on printout of the GC activity)
    memory-usage                  a description of current memory allocations

Use the standard environment syntax to access these fields: `(*s7* 'stack-top)`. stuff.scm has the function *s7*->list that returns most of these fields in a list.

Set (*s7* 'safety) to 2 or higher to turn off optimization.

stacktrace-defaults is a list of four integers and a boolean that tell the error handler how to format stacktrace information. The four integers are: how many frames to display, how many columns are devoted to code display, how many columns are available for a line of data, and where to place comments. The boolean sets whether the entire output should be displayed as a comment. The defaults are '(3 45 80 45 #t).

    (c-object? obj)
    (c-pointer? obj)
    (c-pointer int)

You can wrap up raw C pointers and pass them around in s7 code. The function c-pointer returns a wrapped pointer, and c-pointer? returns #t if passed one. `(define NULL (c-pointer 0))`. c-object? returns the object's type tag if passed such an object (otherwise #f of course). This tag is also the position of the object's type in the (*s7* 'c-types) list. (*s7* 'c-types) returns a list of the types created by s7_new_type_x and friends.

> Some other differences from r5rs:

> - no force or delay (see below).
> - no syntax-rules or any of its friends.
> - no scheme-report-environment, null-environment, or interaction-environment (use curlet).
> - no transcript-on or transcript-off.
> - begin returns the value of the last form; it can contain both definitions and other statements.
> - #<unspecified>, #<eof>, and #<undefined> are first-class objects.
> - for-each and map accept different length arguments; the operation stops when any argument reaches its end.
> - for-each and map accept any applicable object as the first argument, and any sequence or iterator as a trailing argument.
> - letrec*, but without conviction.
> - set! and *-set! return the new value (modulo symbol-access), not #<unspecified>.
> - define and its friends return the new value.
> - port-closed?
> - list? means "pair or null", proper-list? is r5rs list?, float? means "real and not rational", sequence? = length.
> - the default IO ports are named *stdin*, *stdout*, and *stderr*.
> - #f as an output port means nothing is output (#f is /dev/null, I guess).
> - member and assoc accept an optional third argument, the comparison function (equal? is the default).
> - case accepts => much like cond (the function argument is the selector).
> - if WITH_SYSTEM_EXTRAS is 1, the following are built-in: directory?, file-exists?, delete-file, system, directory->list, getenv.
> - s7 is case sensitive.
> - when and unless (for r7rs), returning the value of the last form.
> - the "d", "f", "s", and "l" exponent markers are not supported by default (use "e", "E", or "@").
> - quasiquoted vector constants are not supported (use the normal list expansions wrapped in list->vector).

> In s7 if a built-in function like gcd is referred to in a function body, the optimizer is free to replace it with #_function. That is, `(gcd ...)` can be changed to `(#_gcd ...)` at s7's whim, if gcd has its original value at the time the optimizer sees the expression using it. A subsequent `(set! gcd +)` does not affect this optimized call. I think I could wave my hands and mumble about "aggressive lexical scope" or something, but actually the choice here is that speed trumps that ol' hobgoblin consistency. If you want to change gcd to +, do it before loading code that calls gcd. I think most Schemes handle macros this way: the macro call is replaced by its expansion using its current definition, and a later redefinition does not affect earlier uses.

> Here are some changes I'd make to s7 if I didn't care about compatibility with other Schemes:

> - remove the exact/inexact distinction including #i and #e
> - remove call-with-values and its friends
> - remove char-ready?
> - change eof-object? to eof? or just omit it (you can use eq? #<eof>)
> - change make-rectangular to complex, and remove make-polar.
> - remove unquote (the name, not the functionality).
> - remove cond-expand.
> - remove *-ci functions
> - remove #d

> (most of these are removed if you set the compiler flag WITH_PURE_S7), and perhaps:

> - remove even? and odd?, gcd and lcm.
> - remove string-length and vector-length.
> - remove list-ref|set!, string-ref|set!, vector-ref|set!, hash-table-ref|set!, set-car!|cdr!, and set-current-output|input|error-port.
> - change file-exists? to file? (or omit it and assume the use of libc.scm — why reinvent the wheel?).
> - remove all the conversion and copy functions like vector->list and vector-copy (use copy or map).
> - add typeq? and perhaps make null? generic (see stuff.scm).
> - change string->symbol to symbol (what to do with symbol->string in that case?)
> - change with-output-to-* and with-input-from-* to omit the pointless lambda.
> - remove the with-* IO functions (e.g. with-input-from-string), keeping the call-with-* versions (call-with-input-string).
> - remove assq, assv, memq, and memv (these are pointless now that assoc and member can be passed eq? and eqv?).

> There are several less-than-ideal names. Perhaps s7 should use *pi*, *most-negative-fixnum*, *most-positive-fixnum* (*fixmost*?) so that all the built-in variables and constants have the same kind of name (or +pi+ to show it is a constant?). Perhaps object->string should be ->string. get-output-string should be current-output-string. write-char behaves like display, not write. provided? should be feature? or *features* should be *provisions*.

> The name "cond-expand" is bad — we're not expanding anything, and the macro's point is to make it easy to operate with the *features* list; perhaps "cond-provided"? Not only is cond-expand poorly named, but the whole idea is clumsy. Take libgsl.scm; different versions of the GSL library have different functions. We need to know when we're building the FFI what GSL version we're dealing with. It would be nuts to start pushing and checking dozens of library version symbols when all we actually want is `(> version 23.19)`. (We are also politely trying to ignore the ridiculous little language built into cond-expand; are we not running Scheme?). In place of cond-expand, s7 uses reader-cond, so the read-time decision involves normal evaluation.

> Then there's the case case: a case clause without a result appears to be an error in r7rs. But the notation used to indicate that is the same as that used for begin. So if we allow `(begin)`, we should allow case clauses to have no explicit result. Currently in s7, the case case is an error and `(begin)` returns nil, which strikes me as, *horrors*, inconsistent. But in cond, the "implicit progn" (in CL terminology) includes the test expression, so a clause without a result returns the test result (if true of course). In the case case, a similar approach might return the selector value. So should `(case x ((0 1)))` be an error, or equivalent to `(case x ((0 1) (begin)))` as in CL, or (my favorite) `(case x ((0 1) => values))`. If the latter, an empty else statement would also return the selector since it would be the same as `(else => values)`.

> Better ideas are always welcome!

> Here are the built-in s7 variables:

> - *features* ; a list of symbols
> - *libraries* ; a list of (filename . let) pairs
> - *load-path* ; a list of directories
> - *cload-directory* ; directory for cload output
> - *autoload* ; autoload info
> - *#readers* ; a list of (char . handler) pairs

> And the built-in constants:

> - pi
> - *stdin* *stdout* *stderr*
> - *s7*
> - nan.0 -nan.0 inf.0 -inf.0 (what crappy names! nan.0 is an inexact integer that is not a number?)
> - most-positive-fixnum most-negative-fixnum
> - *unbound-variable-hook* *missing-close-paren-hook* *load-hook* *error-hook* *read-error-hook*

> __func__ is the name (or name and location) of the function currently being called, as in C.

> Currently WITH_PURE_S7:

> - places 'pure-s7 in *features*
> - omits char-ready, char-ci*, string-ci*
> - omits string-copy, string-fill!, vector-fill!, vector-append
> - omits list->string, list->vector, string->list, vector->list, let->list
> - omits string-length and vector-length
> - omits cond-expand, multiple-values-bind|set!, call-with-values, defmacro(*)
> - omits unquote (the name)
> - omits d/f/s/l exponents
> - omits make-polar and make-rectangular (use complex)
> - omits integer-length, exact?, inexact?, exact->inexact, inexact->exact, #i and #e
> - omits set-current-output-port and set-current-input-port
> quotes

> Schemes vary in their treatment of (). s7 considers it a constant that evaluates to itself, so you don't need to quote it. `(eq? () '())` is #t. This is consistent with, for example, `(eq? #f '#f)` which is also #t. The standard says "the empty list is a special object of its own type", so surely either choice is acceptable in that regard. One place where the quote matters is in a case statement; the selector is evaluated but the key is not:

>     > (case '() ((()) 2) (else 1))
>     2
>     > (case '() (('()) 2) (else 1)) ; (eqv? '() ''()) is #f
>     1
>     ;;; which parallels #f (or a number such as 2 etc):
>     > (case '#f ((#f) 2) (else 1))
>     2
>     > (case '#f (('#f) 2) (else 1)) ; (eqv? '#f ''#f) is #f
>     1

> Similarly, vector constants do not have to be quoted. A list constant is quoted to keep it from being evaluated, but #(1 2 3) is as unproblematic as "123" or 123.

> These examples bring up another odd corner of scheme: else. In `(cond (else 1))` the 'else is evaluated (like any cond test), so its value might be #f; in `(case 0 (else 1))` it is not evaluated (like any case key), so it's just a symbol. Since symbol accessors are local in s7, someone can `(let ((else #f)) (cond (else 1)))` even if we protect the rootlet 'else. Of course, in scheme this kind of trouble is pervasive, so rather than make 'else a constant I think the best path is to use unlet: `(let ((else #f)) (cond (#_else 1)))`. This is 1 (not ()) because the initial value of 'else can't be changed.

> mutable constants

> How should s7 treat this: `(string-set! "hiho" 1 #\z)`, or `(vector-set! #(1 2 3) 1 32)`, or `(list-set! '(1 2 3) 1 32)`? Originally, in s7, the first two were errors, and the third was allowed, which doesn't make much sense. Guile and Common Lisp accept all three, but that leads to weird cases where we can reach into a function's body:

>     > (let ((x (lambda () '(1 2 3)))) (list-set! (x) 1 32) (x))
>     (1 32 3) ; s7, Guile
>     > (flet ((x () '(1 2 3))) (setf (nth 1 (x)) 32) (x))
>     (1 32 3) ; Clisp
>     > (let ((x (lambda () (list 1 2 3)))) (list-set! (x) 1 32) (x))
>     (1 2 3)

> But it's possible to reach into a function's closure, even when the closed-over thing is a constant:

>     > (flet ((x () '(1 2 3))) (setf (nth 1 (x)) 32) (x))
>     (1 32 3)
>     > (let ((xx (let ((x '(1 2 3))) (lambda () x)))) (list-set! (xx) 1 32) (xx))
>     (1 32 3)
>     > (let ((xx (let ((x (list 1 2 3))) (lambda () x)))) (list-set! (xx) 1 32) (xx))
>     (1 32 3)

> And it's possible to reach into a constant list via list-set! (or set-car! of course):

>     > (let* ((x '(1 2)) (y (list x)) (z (car y))) (list-set! z 1 32) (list x y z))
>     ((1 32) ((1 32)) (1 32))

> It would be a programmer's nightmare to have to keep track of which piece of a list is constant, and an implementor's nightmare to copy every list. set! in all its forms is used for its side-effects, so why should we try to put a fence around them? If we flush "immutable constant" because it is a ham-fisted, whack-it-with-a-shovel approach, the only real problem I can see is symbol->string. In CL, this is explicitly an error:

>     > (setf (elt (symbol-name 'xyz) 1) #\X)
>     *** - Attempt to modify a read-only string: "XYZ"

> And in Guile:

>     > (string-set! (symbol->string 'symbol->string) 1 #\X)
>     ERROR: string is read-only: "symbol->string"

> So both have a notion of immutable strings. I wonder what other Scheme programmers (not implementors!) want in this situation. Currently, there are no immutable list, string, or vector constants, and symbol->string returns a copy of the string. copy can protect some values. Or combine object->string and string->symbol:

>     > (let ((x (lambda () (copy "hiho")))) (string-set! (x) 1 #\x) (x))
>     "hiho"
>     > (let ((x (string->symbol "hiho"))) (string-set! (symbol->string x) 1 #\x) (symbol->string x))
>     "hiho"
>     > (define (immutable obj) (string->symbol (object->string obj :readable)))
>     immutable
>     > (define (symbol->object sym) (eval-string (symbol->string sym)))
>     symbol->object
>     > (symbol->object (immutable (list 1 2 3)))
>     (1 2 3)

> s7 normally tries to optimize garbage collection by removing some list constants from the heap. If you later set a member of it to something that needs GC protection, nobody in the heap points to it, so it is GC'd. Here is an example:

>     (define (bad-idea)
>       (let* ((lst '(1 2 3))
>              (result (list-ref lst 1)))
>        (list-set! lst 1 (* 2.0 16.6))
>        (gc)
>        result))

> Put this is a file, load it into the interpreter, then call `(bad-idea)` a few times. You can turn off the optimization in question by setting the variable `(*s7* 'safety)` to 1. `(*s7* 'safety)` defaults to 0.

> A similar problem arises when you want to walk a function's source or reuse a piece of code directly. When the function is evaluated, the optimizer changes the program source to speed up subsequent evaluation. This annotation process means that nothing in that source is what it appears to be, so a tree walker will be confused, and if you copy that source and try to insert it into some other program source, the existing annotations will not fit the new context. In both cases, you can get a clean version of the code by copying it with :readable as the second argument to copy. There is an example in lint.scm, and in the snd file tools/tgen.scm.

> circular lists

> s7 handles circular lists and vectors and dotted lists with its customary aplomb. You can pass them to memq, or print them, for example; you can even evaluate them. The print syntax is borrowed from CL:

>     > (let ((lst (list 1 2 3)))
>         (set! (cdr (cdr (cdr lst))) lst)
>         lst)
>     #1=(1 2 3 . #1#)
>     > (let* ((x (cons 1 2))
>              (y (cons 3 x)))
>         (list x y))
>     (#1=(1 . 2) (3 . #1#))

> But should this syntax be readable as well? I'm inclined to say no because then it is part of the language, and it doesn't look like the rest of the language. (I think it's kind of ugly). Perhaps we could implement it via *#readers*:

>     (define circular-list-reader
>       (let ((known-vals #f)
>     	(top-n -1))
>         (lambda (str)

>           (define (replace-syms lst)
>     	;; walk through the new list, replacing our special keywords
>             ;;   with the associated locations

>     	(define (replace-sym tree getter)
>     	  (if (keyword? (getter tree))
>     	      (let ((n (string->number (symbol->string (keyword->symbol (getter tree))))))
>     		(if (integer? n)
>     		    (let ((lst (assoc n known-vals)))
>     		      (if lst
>     			  (set! (getter tree) (cdr lst))
>     			  (format *stderr* "#~D# is not defined~%" n)))))))

>     	(let walk-tree ((tree (cdr lst)))
>     	  (if (pair? tree)
>     	      (begin
>     		(if (pair? (car tree)) (walk-tree (car tree)) (replace-sym tree car))
>     		(if (pair? (cdr tree)) (walk-tree (cdr tree)) (replace-sym tree cdr))))
>     	  tree))

>           ;; str is whatever followed the #, first char is a digit
>           (let* ((len (length str))
>     	     (last-char (str (- len 1))))
>     	(and (memv last-char '(#\= #\#))             ; is it #n= or #n#?
>     	    (let ((n (string->number (substring str 0 (- len 1)))))
>     	      (and (integer? n)
>     		  (begin
>     		    (if (not known-vals)            ; save n so we know when we're done
>     			(begin
>     			  (set! known-vals ())
>     			  (set! top-n n)))

>     		    (if (char=? last-char #\=)      ; #n=
>     			(and (eqv? (peek-char) #\() ; eqv? since peek-char can return #<eof>
>     			    (let ((cur-val (assoc n known-vals)))
>     			      ;; associate the number and the list it points to
>     			      ;;    if cur-val, perhaps complain? (#n# redefined)
>     			      (let ((lst (catch #t
>     					   read
>     					   (lambda args             ; a read error
>     					     (set! known-vals #f)   ;   so clear our state
>     					     (apply throw args))))) ;   and pass the error on up
>     				(if cur-val
>                                         (set! (cdr cur-val) lst)
>     				    (set! known-vals
>     					  (cons (set! cur-val (cons n lst)) known-vals))))

>     			      (if (= n top-n)            ; replace our special keywords
>     				  (let ((result (replace-syms cur-val)))
>     				    (set! known-vals #f) ; '#1=(#+gsl #1#) -> '(:1)!
>     				    result)
>     				  (cdr cur-val))))
>     			                         ; #n=<not a list>?
>     			;; else it's #n# — set a marker for now since we may not
>     			;;   have its associated value yet.  We use a symbol name that
>                             ;;   string->number accepts.
>     			(symbol->keyword
>                               (symbol (number->string n) (string #\null) " "))))))
>     		                                 ; #n<not an integer>?
>     	    )))))                                ; #n<something else>?

>     (do ((i 0 (+ i 1)))
>         ((= i 10))
>       ;; load up all the #n cases
>       (set! *#readers*
>         (cons (cons (integer->char (+ i (char->integer #\0))) circular-list-reader)
>               *#readers*)))

>     > '#1=(1 2 . #1#)
>     #1=(1 2 . #1#)
>     > '#1=(1 #2=(2 . #2#) . #1#)
>     #2=(1 #1=(2 . #1#) . #2#)

> And of course, we can treat these as labels:

>     (let ((ctr 0)) #1=(begin (format () "~D " ctr) (set! ctr (+ ctr 1)) (if (< ctr 4) #1# (newline))))

> which prints "0 1 2 3" and a newline.

> Length returns +inf.0 if passed a circular list, and returns a negative number if passed a dotted list. In the dotted case, the absolute value of the length is the list length not counting the final cdr. `(define (circular? lst) (infinite? (length lst)))`.

> cyclic-sequences returns a list of the cyclic sequences in its argument, or nil. `(define (cyclic? obj) (pair? (cyclic-sequences obj)))`.

> Here's an amusing use of circular lists:

>     (define (for-each-permutation func vals)
>       ;; apply func to every permutation of vals:
>       ;;   (for-each-permutation (lambda args (format () "~{~A~^ ~}~%" args)) '(1 2 3))
>       (define (pinner cur nvals len)
>         (if (= len 1)
>             (apply func (car nvals) cur)
>             (do ((i 0 (+ i 1)))                       ; I suppose a named let would be more Schemish
>                 ((= i len))
>               (let ((start nvals))
>                 (set! nvals (cdr nvals))
>                 (let ((cur1 (cons (car nvals) cur)))  ; add (car nvals) to our arg list
>                   (set! (cdr start) (cdr nvals))      ; splice out that element and
>                   (pinner cur1 (cdr start) (- len 1)) ;   pass a smaller circle on down, "wheels within wheels"
>                   (set! (cdr start) nvals))))))       ; restore original circle
>       (let ((len (length vals)))
>         (set-cdr! (list-tail vals (- len 1)) vals)    ; make vals into a circle
>         (pinner () vals len)
>         (set-cdr! (list-tail vals (- len 1)) ())))    ; restore its original shape

> unprintable symbols

> s7 and Snd use "*" in a variable name, *features* for example, to indicate that the variable is predefined. It may occur unprotected in a macro, for example. The "*" doesn't mean that the variable is special in the CL sense of dynamic scope, but some clear marker is needed for a global variable so that the programmer doesn't accidentally step on it.

> Although a variable name's first character is more restricted, currently only #\null, #\newline, #\tab, #\space, #\), #\(, #\", and #\; can't occur within the name. I did not originally include double-quote in this set, so wild stuff like `(let ((nam""e 1)) nam""e)` would work, but that means that `'(1 ."hi")` is parsed as a 1 and the symbol `."hi"`, and `(string-set! x"hi")` is an error. The first character should not be #\#, #\', #\`, #\,, #\:, or any of those mentioned above, and some characters can't occur by themselves. For example, "." is not a legal variable name, but ".." is. These weird symbols have to be printed sometimes:

>     > (list 1 (string->symbol (string #\; #\" #\\)) 2)
>     (1 ;"\ 2)
>     > (list 1 (string->symbol (string #\.)) 2)
>     (1 . 2)

> which is a mess. Guile prints the first as `(1 #{\;\"\\}# 2)`. In CL and some Schemes:

>     [1]> (list 1 (intern (coerce (list #\; #\" #\\) 'string)) 2) ; thanks to Rob Warnock
>     (1 |;"\\| 2)
>     [2]> (equalp 'A '|A|) ; in CL case matters here
>     T

> This is clean, and has the weight of tradition behind it, but I think I'll use "symbol" instead:

>     > (list 1 (string->symbol (string #\; #\" #\\)) 2)
>     (1 (symbol ";\"\\") 2)

> This output is readable, and does not eat up perfectly good characters like vertical bar, but it means we can't easily use variable names like "| e t c |". We could allow a name to contain any characters if it starts and ends with "|", but then one vertical bar is trouble. (The symbol function actually accepts any number of string arguments which it concatenates to form the new symbol name).

> These symbols are not just an optimization of string comparison:

>     > (define-macro (hi a)
>       (let ((funny-name (string->symbol ";")))
>         `(let ((,funny-name ,a)) (+ 1 ,funny-name))))
>     hi
>     > (hi 2)
>     3
>     > (macroexpand (hi 2))
>     (let ((; 2)) (+ 1 ;))    ; for a good time, try (string #\")

>     > (define-macro (hi a)
>       (let ((funny-name (string->symbol "| e t c |")))
>         `(let ((,funny-name ,a)) (+ 1 ,funny-name))))
>     hi
>     > (hi 2)
>     3
>     > (macroexpand (hi 2))
>     (let ((| e t c | 2)) (+ 1 | e t c |))
>     > (let ((funny-name (string->symbol "| e t c |"))) ; now use it as a keyword arg to a function
>         (apply define* `((func (,funny-name 32)) (+ ,funny-name 1)))
>         ;; (procedure-source func) is (lambda* ((| e t c | 32)) (+ | e t c | 1))
>         (apply func (list (symbol->keyword funny-name) 2)))
>     3

> I hope that makes you as happy as it makes me!

> The built-in syntactic forms, such as "begin", are almost first-class citizens.

>     > (let ((progn begin))
>         (progn
>           (define x 1)
>           (set! x 3)
>           (+ x 4)))
>     7
>     > (let ((function lambda))
>         ((function (a b) (list a b)) 3 4))
>     (3 4)
>     > (apply begin '((define x 3) (+ x 2)))
>     5
>     > ((lambda (n) (apply n '(((x 1)) (+ x 2)))) let)
>     3

>     (define-macro (symbol-set! var val) ; like CL's set
>       `(apply set! ,var ',val ()))      ; trailing nil is just to make apply happy — apply*?

>     (define-macro (progv vars vals . body)
>      `(apply (apply lambda ,vars ',body) ,vals))

>     > (let ((s '(one two)) (v '(1 2))) (progv s v (+ one two)))
>     3

> We can snap together program fragments ("look Ma, no macros!"):

>     (let* ((x 3)
>            (arg '(x))
>            (body `((+ ,x x 1))))
>       ((apply lambda arg body) 12)) ; "legolambda"?

>     (define (engulph form)
>       (let ((body `(let ((L ()))
>     		 (do ((i 0 (+ i 1)))
>     		     ((= i 10) (reverse L))
>     		   (set! L (cons ,form L))))))
>         (define function (apply lambda () (list (copy body :readable))))
>         (function)))

>     (let ()
>       (define (hi a) (+ a x))
>       ((apply let '((x 32)) (list (procedure-source hi))) 12)) ; one function, many closures?

>     (let ((ctr -1))  ; (enum zero one two) but without using a macro
>       (apply begin
>         (map (lambda (symbol)
>                (set! ctr (+ ctr 1))
>                (list 'define symbol ctr)) ; e.g. '(define zero 0)
>              '(zero one two)))
>       (+ zero one two))

> But there's a prettier way to implement enum ("transparent-for-each"):

>     > (define-macro (enum . args)
>         `(for-each define ',args (iota (length ',args))))
>     enum
>     > (enum a b c)
>     #<unspecified>
>     > b
>     1

> `(apply define ...)` is similar to CL's set.

>     > ((apply define-macro '((m a) `(+ 1 ,a))) 3)
>     4
>     > ((apply define '((hi a) (+ a 1))) 3)
>     4

> This gives us a way to make anonymous macros, just as lambda returns an anonymous function:

>     > (define-macro (mu args . body)
>       `(apply define-macro '((,(gensym) ,@args) ,@body)))
>     mu
>     > ((mu (a) `(+ 1 ,a)) 3)
>     4
>     > (define-macro (glambda args) ; returns an anonymous macro that will return a function given a body
>         `(define-macro (,(gensym) . body)
>              `(lambda ,',args ,@body)))
>     glambda
>     > (let ((gf (glambda (a b))))  ; gf is now ready for any body that involves arguments 'a and 'b
>         ((gf (+ a b)) 1 2))        ; apply (lambda (a b) (+ a b)) to '(1 2)
>     3

> catch, dynamic-wind, and many of the other functions that take function arguments in standard Scheme, accept macros in s7.

> Apply let is very similar to eval:

>     > (apply let '((a 2) (b 3)) '((+ a b)))
>     5
>     > (eval '(+ a b) (inlet 'a 2 'b 3))
>     5
>     > ((apply lambda '(a b) '((+ a b))) 2 3)
>     5
>     > (apply let '((a 2) (b 3)) '((list + a b))) ; a -> 2, b -> 3
>     (+ 2 3)

> The redundant-looking double lists are for apply's benefit. We could use a trailing null instead (mimicking apply* in some ancient lisps):

>     > (apply let '((a 2) (b 3)) '(list + a b) ())
>     (+ 2 3)

> Currently, you can't set! a built-in syntactic keyword to some new value: `(set! if 3)`. I hope this kind of thing is not actually very useful, but let me know if you need it. The issue is purely one of speed.

> Speaking of speed... It is widely believed that a Scheme with first class everything can't hope to compete with any "real" Scheme. Humph I say. Take this little example (which is not so misleading that I feel guilty about it):

>     (define (do-loop n)
>       (do ((i 0 (+ i 1)))
>           ((= i n))
>         (if (zero? (modulo i 1000))
>     	(display ".")))
>       (newline))

>     (for-each
>      (lambda (n) (do-loop n))
>      (list 1000 1000000 10000000))

> In s7, that takes 0.24 seconds on my home machine. In tinyScheme, from whence we sprang, it takes 85 seconds. In the chicken interpreter, 5.3 seconds, and after compilation (using -O2) of the chicken compiler output, 0.75 seconds. So, s7 is comparable to chicken in speed, even though chicken is compiling to C. I think Guile 2.0.9 takes about 1 second. The equivalent in CL: clisp interpreted 9.3 seconds, compiled 0.85 seconds; sbcl 0.21 seconds.

> In s7, there is only one kind of begin statement, and it can contain both definitions and expressions. These are evaluated in the order in which they occur, and in the environment at the point of the evaluation. I think of it as being a little REPL. begin does not introduce a new frame in the current environment, so defines happen in the enclosing environment.

> The r7rs compatibility code is in r7rs.scm. I used to include it here, but as r7rs grew, this section got too large. In general, all the conversion routines in r7rs are handled in s7 via generic functions, records are classes, byte-vectors are strings, and so on.

> threads

> s7 originally had multithreading support, but I removed it in August, 2011. It turned out to be less useful than I hoped, mainly because s7 threads shared the heap and therefore had to coordinate all cell allocations. It was faster and simpler to use multiple processes each running a separate s7 interpreter, rather than one s7 running multiple s7 threads. In CLM, there was also contention for access to the output stream. In GUI-related situations, threads were not useful mainly because the GUI toolkits are not thread safe. Last but not least, the effort to make the non-threaded s7 faster messed up parts of the threaded version. Rather than waste a lot of time fixing this, I chose to flush multithreading. Here's a very simple example of using an s7 interpreter per thread:

>     #include <stdlib.h>
>     #include <stdio.h>
>     #include <string.h>
>     #include <pthread.h>
>     #include "s7.h"

>     typedef struct {
>       s7_scheme *sc;
>       s7_pointer func;
>       pthread_t *thread;
>     } thred;

>     static void *run_thread(void *obj)
>     {
>       thred *f = (thred *)obj;
>       return((void *)s7_call(f->sc, f->func, s7_nil(f->sc)));
>     }

>     static thred *make_thread(s7_function func)
>     {
>       thred *f;
>       f = (thred *)malloc(sizeof(thred));
>       f->sc = s7_init();
>       f->func = s7_make_function(f->sc, "a-test", func, 0, 0, false, "a test");
>       f->thread = (pthread_t *)malloc(sizeof(pthread_t));
>       pthread_create(f->thread, NULL, run_thread, (void *)f);
>       return(f);
>     }

>     static s7_pointer a_test(s7_scheme *sc, s7_pointer args)
>     {
>       fprintf(stderr, "I am %p\n", sc);
>       /* do something time-consuming... */
>       return(args);
>     }

>     int main(int argc, char **argv)
>     {
>       thred *f1, *f2;
>       f1 = make_thread(a_test);
>       f2 = make_thread(a_test);

>       pthread_join(*(f1->thread), NULL);
>       pthread_join(*(f2->thread), NULL);
>     }

>     /* build s7 with -DWITH_THREADS, then
>      * gcc -o repl repl.c s7.o -g3 -Wl,-export-dynamic -lpthread -lm -I. -ldl
>      */

> Unfortunately, there's no way yet to free all the resources s7_init allocates (the heap, stack, etc).

> "Life", a poem.

>     (+(*(+))(*)(+(+)(+)(*)))
>     (((((lambda () (lambda () (lambda () (lambda () 1))))))))
>     (+ (((lambda () values)) 1 2 3))
>     (map apply (list map) (list map) (list (list *)) '((((1 2)) ((3 4 5)))))
>     (do ((do do do)) (do do do))
>     (*(*)(*) (+)(+) 1)

FFI examples

s7 exists only to serve as an extension of some other application, so it is primarily a foreign function interface. s7.h has lots of comments about the individual functions. Here I'll collect some complete examples. s7.c depends on the following compile-time flags:

    SIZEOF_VOID_P                  8 (default) or 4.
    WITH_GMP                       1 if you want multiprecision arithmetic (requires gmp, mpfr, and mpc, default is 0)
    HAVE_COMPLEX_NUMBERS           1 if your compiler supports complex numbers
    HAVE_COMPLEX_TRIG              1 if your math library has complex versions of the trig functions
    DISABLE_DEPRECATED             1 if you want to make sure you're not using any deprecated s7 stuff (default is 0)

    WITH_IMMUTATBLE_UNQUOTE        1 if you want "unquote" omitted (default is 0)
    WITH_EXTRA_EXPONENT_MARKERS    1 if you want "d", "f", "l", and "s" in addition to "e" as exponent markers (default is 0)
                                       if someone defends these exponent markers, ask him to read 1l11+11l1i
                                       (in 2 million lines of open-source Scheme, there is not one use of these silly things)
    WITH_SYSTEM_EXTRAS             1 if you want some additional OS-related functions built-in (default is 0)
    WITH_MAIN                      1 if you want s7.c to include a main program section that runs a REPL.
    WITH_C_LOADER		       1 if you want to be able to load shared object files with load.

See the comment at the start of s7.c for more information about these switches. s7.h defines the two main number types: s7_int and s7_double. The examples that follow show:

- read-eval-print loop (and emacs)
- define a function with arguments and a returned value, and define a variable
- call a Scheme function from C, and get/set Scheme variable values in C
- C++ and Juce
- load sndlib using the Xen functions and macros
- add a new Scheme type and a procedure with a setter
- redirect display output to a C procedure
- extend a built-in operator ("+" in this case)
- C-side define* (s7_define_function_star)
- C-side define-macro (s7_define_macro)
- define a generic function in C
- signal handling (C-C to break out of an infinite loop)
- direct multidimensional vector element access
- notification in C that a Scheme variable has been set!
- Load C defined stuff into a separate namespace
- Error handling in C
- Hooks in C and Scheme
- Load a C module dynamically
- gmp and friends
- glistener.c
- gdb

#### A simple listener

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include "s7.h"

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];

      s7 = s7_init();                 /* initialize the interpreter */
      while (1)                       /* fire up a read-eval-print loop */
        {
          fprintf(stdout, "\n> ");    /* prompt for input */
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{                         /* evaluate the input and print the result */
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /* make mus-config.h (it can be empty), then
     *
     *   gcc -c s7.c -I.
     *   gcc -o repl repl.c s7.o -lm -I. -ldl
     *
     * run it:
     *
     *    repl
     *    > (+ 1 2)
     *    3
     *    > (define (add1 x) (+ 1 x))
     *    add1
     *    > (add1 2)
     *    3
     *    > (exit)
     *
     * for long-term happiness in linux use:
     *   gcc -o repl repl.c s7.o -Wl,-export-dynamic -lm -I. -ldl
     * freebsd:
     *   gcc -o repl repl.c s7.o -Wl,-export-dynamic -lm -I.
     * osx:
     *   gcc -o repl repl.c s7.o -lm -I.
     * openbsd:
     *   gcc -o repl repl.c s7.o -I. -ftrampolines -Wl,-export-dynamic -lm
     */

Since this reads stdin and writes stdout, it can be run as a Scheme subjob of emacs. One (inconvenient) way to do this is to set the emacs variable scheme-program-name to the name of the exectuable created above ("doc7"), then call the emacs function run-scheme: M-x eval-expression in emacs, followed by (setq scheme-program-name "doc7"), then M-x run-scheme, and you're talking to s7 in emacs. Of course, this connection can be customized indefinitely. See, for example, inf-snd.el in the Snd package.

Here are the not-always-built-in indentations I use in emacs:

    (put 'with-let 'scheme-indent-function 1)
    (put 'with-baffle 'scheme-indent-function 0)
    (put 'with-sound 'scheme-indent-function 1)
    (put 'catch 'scheme-indent-function 1)
    (put 'lambda* 'scheme-indent-function 1)
    (put 'when 'scheme-indent-function 1)
    (put 'let-temporarily 'scheme-indent-function 1)
    (put 'let*-temporarily 'scheme-indent-function 1)
    (put 'call-with-input-string 'scheme-indent-function 1)
    (put 'unless 'scheme-indent-function 1)
    (put 'letrec* 'scheme-indent-function 1)
    (put 'sublet 'scheme-indent-function 1)
    (put 'varlet 'scheme-indent-function 1)

To read stdin while working in a GUI-based program is trickier. In glib/gtk, you can use something like this:

>     static gboolean read_stdin(GIOChannel *source, GIOCondition condition, gpointer data)
>     {
>       /* here read from g_io_channel_unix_get_fd(source) and call s7_eval_string */
>       return(true);
>     }

>     /* ... during initialization ... */

>     GIOChannel *channel;
>     channel = g_io_channel_unix_new(STDIN_FILENO);  /* watch stdin */
>     stdin_id = g_io_add_watch_full(channel,         /* and call read_stdin above if input is noticed */
>     			       G_PRIORITY_DEFAULT,
>     			       (GIOCondition)(G_IO_IN | G_IO_HUP | G_IO_ERR),
>     			       read_stdin, NULL, NULL);
>     g_io_channel_unref(channel);

repl with libtecla

Here's a version that uses libtecla for the line editor:

>     #include <stdlib.h>
>     #include <stdio.h>
>     #include <string.h>
>     #include <libtecla.h>
>     #include "s7.h"

>     int main(int argc, char **argv)
>     {
>       s7_scheme *s7;
>       char *buffer;
>       char response[1024];
>       GetLine *gl;            /* The tecla line editor */

>       gl = new_GetLine(500, 5000);
>       s7 = s7_init();

>       while (1)
>         {
>           buffer = gl_get_line(gl, "> ", NULL, 0);
>           if ((buffer[0] != '\n') ||
>     	  (strlen(buffer) > 1))
>     	{
>     	  sprintf(response, "(write %s)", buffer);
>     	  s7_eval_c_string(s7, response);
>     	  fprintf(stdout, "\n");
>     	}
>         }
>       gl = del_GetLine(gl);
>     }

>     /*
>      *   gcc -c s7.c -I. -O2 -g3
>      *   gcc -o ex1 ex1.c s7.o -lm -I. -ltecla -ldl
>      */

A repl (based on repl.scm) is built into s7. Include the compiler flag -DWITH_MAIN:

    in Linux: gcc s7.c -o repl -DWITH_MAIN -I. -O2 -g -ldl -lm -Wl,-export-dynamic
    in *BSD:  gcc s7.c -o repl -DWITH_MAIN -I. -O2 -g -lm -Wl,-export-dynamic
    in OSX:   gcc s7.c -o repl -DWITH_MAIN -I. -O2 -g -lm

repl in C++

If you prefer C++, here's a C++ version of the listener, extracted from Rick Taube's Common Music package:

>     #include <iostream>
>     #include "s7.h"

>     static s7_pointer main_quit(s7_scheme *sc, s7_pointer args);
>     static bool is_balanced(std::string str);
>     static bool is_not_white(std::string str);

>     int main(int argc, const char* argv[])
>     {
>       s7_scheme* s7 = s7_init();
>       s7_pointer val;
>       std::string str;

>       try
>         {
>           while (std::cin)
>     	{
>     	  std::cout << "\ns7> ";
>     	  str = "";
>     	  while (true)
>     	    {
>     	      std::string lin;
>     	      std::getline(std::cin, lin);
>     	      str = str + lin + "\n";
>     	      if (is_balanced(str))
>     		break;
>     	    }
>     	  if (is_not_white(str))
>     	    {
>     	      val = s7_eval_c_string(s7, str.c_str());
>     	      std::cout << s7_object_to_c_string(s7, val);
>     	    }
>     	}
>         }
>       catch(...)
>         {
>         }
>       std::cout << "Bye!\n";
>       return 0;
>     }

>     static s7_pointer main_quit(s7_scheme *sc, s7_pointer args)
>     {
>       throw 0;
>       return(s7_nil(sc));
>     }

>     static bool is_balanced(std::string str)
>     {
>       int parens = 0;
>       int quotes = 0;
>       unsigned i = 0;
>       while (i < str.size())
>         {
>           if (str[i] == ';')
>     	{
>     	  for (i = i + 1; i < str.size(); i++)
>     	    {
>     	      if (str[i] == '\n')
>     		break;
>     	    }
>     	}
>           else if (str[i] == '"')
>     	{
>     	  if (i == 0 || str[i - 1] != '\\')
>     	    {
>     	      quotes = 1;
>     	      for (i = i + 1; i < str.size(); i++)
>     		{
>     		  if (str[i] == '"' && str[i - 1] != '\\')
>     		    {
>     		      quotes = 0;
>     		      break;
>     		    }
>     		}
>     	      if (quotes)
>     		return false;
>     	    }
>     	}
>           else if (str[i] == '(')
>     	parens++;
>           else if (str[i] == ')')
>     	parens--;
>           i++;
>         }
>       return (parens == 0) && (quotes == 0);
>     }

>     static bool is_not_white(std::string str)
>     {
>       for (unsigned i = 0; (i < str.size() && str[i] != ';'); i++)
>         if (str[i] != ' ' && str[i] != '\n' && str[i] != '\t')
>           return true;
>       return false;
>     }

>     /* g++ -I. -c repl.cpp
>      * g++ -o repl repl.o s7.o -ldl
>      */

Common Lisp has something called "evalhook" that makes it possible to insert your own function into the eval loop. In s7, we have a "begin_hook" which sits at the opening of many begin blocks (implicit or explicit). begin_hook is a (C) function; if it sets its bool argument to true, s7 interrupts the current evaluation. Here is a version of the REPL in which begin_hook watches for C-g to interrupt some long computation:

>     /* terminal-based REPL,
>      *    an expansion of the read-eval-print loop program above.
>      * type C-g to interrupt an evaluation.
>      */
>     #include <stdlib.h>
>     #include <stdio.h>
>     #include <string.h>
>     #include <termios.h>
>     #include <signal.h>

>     #include "s7.h"

>     static struct termios save_buf, buf;

>     static void sigcatch(int n)
>     {
>       /* put things back the way they were */
>       tcsetattr(fileno(stdin), TCSAFLUSH, &save_buf);
>       exit(0);
>     }

>     static char buffer[512];
>     static int type_ahead_point = 0;

>     static void watch_for_c_g(s7_scheme *sc, bool *all_done)
>     {
>       char c;
>       /* watch for C-g without blocking, save other chars as type-ahead */
>       tcsetattr(fileno(stdin), TCSAFLUSH, &buf);
>       if (read(fileno(stdin), &c, 1) == 1)
>         {
>           if (c == 7) /* C-g */
>     	{
>     	  *all_done = true;
>     	  type_ahead_point = 0;
>     	}
>           else buffer[type_ahead_point++] = c;
>         }
>       tcsetattr(fileno(stdin), TCSAFLUSH, &save_buf);
>     }

>     int main(int argc, char **argv)
>     {
>       s7_scheme *s7;
>       bool use_begin_hook;

>       use_begin_hook = (tcgetattr(fileno(stdin), &save_buf) >= 0);
>       if (use_begin_hook)
>         {
>           buf = save_buf;
>           buf.c_lflag &= ~ICANON;
>           buf.c_cc[VMIN] = 0;
>           buf.c_cc[VTIME] = 0;

>           signal(SIGINT, sigcatch);
>           signal(SIGQUIT, sigcatch);
>           signal(SIGTERM, sigcatch);
>         }
>       s7 = s7_init();

>       if (argc == 2)
>         {
>           fprintf(stderr, "load %s\n", argv[1]);
>           s7_load(s7, argv[1]);
>         }
>       else
>         {
>           char response[1024];
>           while (1)
>     	{
>     	  fprintf(stdout, "\n> ");
>     	  fgets((char *)(buffer + type_ahead_point), 512 - type_ahead_point, stdin);
>     	  type_ahead_point = 0;

>     	  if ((buffer[0] != '\n') ||
>     	      (strlen(buffer) > 1))
>     	    {
>     	      sprintf(response, "(write %s)", buffer);

>     	      if (use_begin_hook)
>     		s7_set_begin_hook(s7, watch_for_c_g);
>     	      s7_eval_c_string(s7, response);
>     	      if (use_begin_hook)
>     		s7_set_begin_hook(s7, NULL);
>     	    }
>     	}
>         }
>       if (use_begin_hook)
>         tcsetattr(fileno(stdin), TCSAFLUSH, &save_buf);
>     }

#### Define a function with arguments and a returned value, and a variable

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    static s7_pointer add1(s7_scheme *sc, s7_pointer args)
    {
      /* all added functions have this form, args is a list,
       *    s7_car(args) is the first arg, etc
       */
      if (s7_is_integer(s7_car(args)))
        return(s7_make_integer(sc, 1 + s7_integer(s7_car(args))));
      return(s7_wrong_type_arg_error(sc, "add1", 1, s7_car(args), "an integer"));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];

      s7 = s7_init();

      s7_define_function(s7, "add1", add1, 1, 0, false, "(add1 int) adds 1 to int");
                                          /* add the function "add1" to the interpreter.
                                           *   1, 0, false -> one required arg,
    				       *                  no optional args,
    				       *                  no "rest" arg
    				       */
     s7_define_variable(s7, "my-pi", s7_make_real(s7, 3.14159265));

      while (1)                           /* fire up a "repl" */
        {
          fprintf(stdout, "\n> ");        /* prompt for input */
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response); /* evaluate input and write the result */
    	}
        }
    }

    /*    doc7
     *    > my-pi
     *    3.14159265
     *    > (+ 1 (add1 1))
     *    3
     *    > (exit)
     */

#### Call a Scheme-defined function from C, and get/set Scheme variable values in C

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      s7 = s7_init();

      s7_define_variable(s7, "an-integer", s7_make_integer(s7, 1));
      s7_eval_c_string(s7, "(define (add1 a) (+ a 1))");

      fprintf(stderr, "an-integer: %lld\n",
    	  s7_integer(s7_name_to_value(s7, "an-integer")));

      s7_symbol_set_value(s7, s7_make_symbol(s7, "an-integer"), s7_make_integer(s7, 32));

      fprintf(stderr, "now an-integer: %lld\n",
    	  s7_integer(s7_name_to_value(s7, "an-integer")));

      fprintf(stderr, "(add1 2): %lld\n",
    	  s7_integer(s7_call(s7,
    			     s7_name_to_value(s7, "add1"),
    			     s7_cons(s7, s7_make_integer(s7, 2), s7_nil(s7)))));
    }

    /*
     *    doc7
     *    an-integer: 1
     *    now an-integer: 32
     *    (add1 2): 3
     */

#### C++ and Juce, from Rick Taube

    int main(int argc, const char* argv[])
    {
      initialiseJuce_NonGUI();

      s7_scheme *s7 = s7_init();
      if (!s7)
        {
          std::cout <<  "Can't start S7!\n";
          return -1;
        }

      s7_pointer val;
      std::string str;
      while (true)
        {
          std::cout << "\ns7> ";
          std::getline(std::cin, str);
          val = s7_eval_c_string(s7, str.c_str());
          std::cout << s7_object_to_c_string(s7, val);
        }

      free(s7);
      std::cout << "Bye!\n";
      return 0;
    }

#### Load sndlib into an s7 repl

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <unistd.h>

    /* assume we've configured and built sndlib, so it has created a mus-config.h file.
     * also assume we've built s7 with WITH_SYSTEM_EXTRAS set, so we have file-exists? and delete-file
     */

    #include "mus-config.h"
    #include "s7.h"
    #include "xen.h"
    #include "clm.h"
    #include "clm2xen.h"

    /* we need to redirect clm's mus_error calls to s7_error */

    static void mus_error_to_s7(int type, char *msg)
    {
      s7_error(s7,                               /* s7 is declared in xen.h, defined in xen.c */
    	   s7_make_symbol(s7, "mus-error"),
    	   s7_cons(s7, s7_make_string(s7, msg), s7_nil(s7)));
    }

    int main(int argc, char **argv)
    {
      char buffer[512];
      char response[1024];

      s7 = s7_init();                     /* initialize the interpreter */
      s7_xen_initialize(s7);              /* initialize the xen stuff (hooks and the xen s7 FFI used by sndlib) */
      Init_sndlib();                      /* initialize sndlib with all the functions linked into s7 */

      mus_error_set_handler(mus_error_to_s7); /* catch low-level errors and pass them to s7-error */

      while (1)                           /* fire up a "repl" */
        {
          fprintf(stdout, "\n> ");        /* prompt for input */
          fgets(buffer, 512, stdin);

          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response); /* evaluate input and write the result */
    	}
        }
    }

    /* gcc -o doc7 doc7.c -lm -I. /usr/local/lib/libsndlib.a -lasound -ldl
     *
     *   (load "sndlib-ws.scm")
     *   (with-sound () (outa 10 .1))
     *   (load "v.scm")
     *   (with-sound () (fm-violin 0 .1 440 .1))
     *
     * you might also need -lgsl -lgslcblas -lfftw3
     */

If you built libsndlib.so, it is possible to use it directly in the s7 repl:

    repl          ; this is a bare s7 running repl.scm via -DWITH_MAIN=1
    loading libc_s7.so
    > (load "/home/bil/test/sndlib/libsndlib.so" (inlet 'init_func 's7_init_sndlib))
    #t            ; s7_init_sndlib ties all the sndlib functions and variables into s7
    > (load "sndlib-ws.scm")
    tmpnam
    > (set! *clm-player* (lambda (file) (system (format #f "sndplay ~A" file))))
    > (load "v.scm")
    fm-violin
    > (with-sound (:play #t) (fm-violin 0 1 440 .1))
    "test.snd"

You can use autoload to load libsndlib when needed:

    (define (find-library name)
      (if (or (file-exists? name)
    	  (char=? (name 0) #\/))
          name
          (call-with-exit
           (lambda (return)
    	 (for-each
    	  (lambda (path)
    	    (let ((new-name (string-append path "/" name)))
    	      (if (file-exists? new-name)
    		  (return new-name))))
    	  *load-path*)
    	 (let ((libs (getenv "LD_LIBRARY_PATH")) ; colon separated directory names
    	       (start 0))
    	   (do ((colon (char-position #\: libs) (char-position #\: libs start)))
    	       ((or (not colon)
    		    (let ((new-name (string-append (substring libs start colon) "/" name)))
    		      (and (file-exists? new-name)
    			   (return new-name)))))
    	     (set! start (+ colon 1))))
    	 name))))

    (autoload 'clm
      (lambda (e)
        (load (find-library "libsndlib.so") (inlet '(init_func . s7_init_sndlib)))
        (set! *features* (cons 'clm *features*))
        (with-let (rootlet) (define clm #t))
        (load "sndlib-ws.scm")
        (set! *clm-player* (lambda (file) (system (format #f "sndplay ~A" file))))))

and use the repl's vt100 stuff to (for example) post the current begin time as a note list computes:

    (define (clm-notehook . args)
      ;; assume second arg is begin time (first is instrument name)
      (when (and (pair? args)
    	     (pair? (cdr args))
    	     (number? (cadr args)))
        (with-let (sublet (*repl* 'repl-let) :begin-time (cadr args))
          (let ((coords (cursor-coords))
    	    (col (floor (/ last-col 2))))
    	(let ((str (number->string begin-time)))
    	  (format *stderr* "~C[~D;~DH" #\escape prompt-row col)
    	  (format *stderr* "~C[K~A"  #\escape (if (> (length str) col) (substring str 0 (- col 1)) str)))
    	(format *stderr* "~C[~D;~DH"   #\escape (cdr coords) (car coords))))))

    (set! *clm-notehook* clm-notehook)

#### Add a new Scheme type and a procedure with a setter

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    /* define *listener-prompt* in scheme, add two accessors for C get/set */

    static const char *listener_prompt(s7_scheme *sc)
    {
      return(s7_string(s7_name_to_value(sc, "*listener-prompt*")));
    }

    static void set_listener_prompt(s7_scheme *sc, const char *new_prompt)
    {
      s7_symbol_set_value(sc, s7_make_symbol(sc, "*listener-prompt*"), s7_make_string(sc, new_prompt));
    }

    /* now add a new type, a struct named "dax" with two fields, a real "x" and a list "data" */
    /*   since the data field is an s7 object, we'll need to mark it to protect it from the GC */

    typedef struct {
      s7_double x;
      s7_pointer data;
    } dax;

    static char *print_dax(s7_scheme *sc, void *val)
    {
      char *data_str, *str;
      int data_str_len;
      dax *o = (dax *)val;
      data_str = s7_object_to_c_string(sc, o->data);
      data_str_len = strlen(data_str);
      str = (char *)calloc(data_str_len + 32, sizeof(char));
      snprintf(str, data_str_len + 32, "#<dax %.3f %s>", o->x, data_str);
      free(data_str);
      return(str);
    }

    static void free_dax(void *val)
    {
      if (val) free(val);
    }

    static bool equal_dax(void *val1, void *val2)
    {
      return(val1 == val2);
    }

    static void mark_dax(void *val)
    {
      dax *o = (dax *)val;
      if (o) s7_mark_object(o->data);
    }

    static int dax_type_tag = 0;

    static s7_pointer make_dax(s7_scheme *sc, s7_pointer args)
    {
      dax *o;
      o = (dax *)malloc(sizeof(dax));
      o->x = s7_real(s7_car(args));
      if (s7_cdr(args) != s7_nil(sc))
        o->data = s7_cadr(args);
      else o->data = s7_nil(sc);
      return(s7_make_object(sc, dax_type_tag, (void *)o));
    }

    static s7_pointer is_dax(s7_scheme *sc, s7_pointer args)
    {
      return(s7_make_boolean(sc,
    			 s7_is_object(s7_car(args)) &&
    			 s7_object_type(s7_car(args)) == dax_type_tag));
    }

    static s7_pointer dax_x(s7_scheme *sc, s7_pointer args)
    {
      dax *o;
      o = (dax *)s7_object_value(s7_car(args));
      return(s7_make_real(sc, o->x));
    }

    static s7_pointer set_dax_x(s7_scheme *sc, s7_pointer args)
    {
      dax *o;
      o = (dax *)s7_object_value(s7_car(args));
      o->x = s7_real(s7_cadr(args));
      return(s7_cadr(args));
    }

    static s7_pointer dax_data(s7_scheme *sc, s7_pointer args)
    {
      dax *o;
      o = (dax *)s7_object_value(s7_car(args));
      return(o->data);
    }

    static s7_pointer set_dax_data(s7_scheme *sc, s7_pointer args)
    {
      dax *o;
      o = (dax *)s7_object_value(s7_car(args));
      o->data = s7_cadr(args);
      return(o->data);
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];

      s7 = s7_init();

      s7_define_variable(s7, "*listener-prompt*", s7_make_string(s7, ">"));

      dax_type_tag = s7_new_type("dax", print_dax, free_dax, equal_dax, mark_dax, NULL, NULL);
      s7_define_function(s7, "make-dax", make_dax, 2, 0, false, "(make-dax x data) makes a new dax");
      s7_define_function(s7, "dax?", is_dax, 1, 0, false, "(dax? anything) returns #t if its argument is a dax object");

      s7_define_variable(s7, "dax-x",
                         s7_dilambda(s7, "dax-x", dax_x, 1, 0, set_dax_x, 2, 0, "dax x field"));

      s7_define_variable(s7, "dax-data",
                         s7_dilambda(s7, "dax-data", dax_data, 1, 0, set_dax_data, 2, 0, "dax data field"));

      while (1)
        {
          fprintf(stdout, "\n%s ", listener_prompt(s7));
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response); /* evaluate input and write the result */
    	}
        }
    }

    /*
     *    > *listener-prompt*
     *    ">"
     *    > (set! *listener-prompt* ":")
     *    ":"
     *    : (define obj (make-dax 1.0 (list 1 2 3)))
     *    obj
     *    : obj
     *    #<dax 1.000 (1 2 3)>
     *    : (dax-x obj)
     *    1.0
     *    : (dax-data obj)
     *    (1 2 3)
     *    : (set! (dax-x obj) 123.0)
     *    123.0
     *    : obj
     *    #<dax 123.000 (1 2 3)>
     *    : (dax? obj)
     *    #t
     *    : (exit)
     */

#### Redirect output (and input) to a C procedure

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    static void my_print(s7_scheme *sc, unsigned char c, s7_pointer port)
    {
      fprintf(stderr, "[%c] ", c);
    }

    static s7_pointer my_read(s7_scheme *sc, s7_read_t peek, s7_pointer port)
    {
      return(s7_make_character(sc, fgetc(stdin)));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];

      s7 = s7_init();

      s7_set_current_output_port(s7, s7_open_output_function(s7, my_print));
      s7_define_variable(s7, "io-port", s7_open_input_function(s7, my_read));

      while (1)
        {
          fprintf(stdout, "\n> ");
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /*
     *    > (+ 1 2)
     *    [3]
     *    > (display "hiho")
     *    [h] [i] [h] [o] [#] [<] [u] [n] [s] [p] [e] [c] [i] [f] [i] [e] [d] [>]
     *    > (define (add1 x) (+ 1 x))
     *    [a] [d] [d] [1]
     *    > (add1 123)
     *    [1] [2] [4]
     *    > (read-char io-port)
     *    a                             ; here I typed "a" in the shell
     *    [#] [\] [a]
     */

#### Extend a built-in operator ("+" in this case)

There are several ways to do this. In the first example, we save the original function, and replace it with ours, calling the original whenever possible:

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    static s7_pointer old_add;           /* the original "+" function for non-string cases */
    static s7_pointer old_string_append; /* same, for "string-append" */

    static s7_pointer our_add(s7_scheme *sc, s7_pointer args)
    {
      /* this will replace the built-in "+" operator, extending it to include strings:
       *   (+ "hi" "ho") -> "hiho" and  (+ 3 4) -> 7
       */
      if ((s7_is_pair(args)) &&
          (s7_is_string(s7_car(args))))
        return(s7_apply_function(sc, old_string_append, args));
      return(s7_apply_function(sc, old_add, args));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];
      s7 = s7_init();

      /* get built-in + and string-append */
      old_add = s7_name_to_value(s7, "+");
      old_string_append = s7_name_to_value(s7, "string-append");

      /* redefine "+" */
      s7_define_function(s7, "+", our_add, 0, 0, true, "(+ ...) adds or appends its arguments");

      while (1)
        {
          fprintf(stdout, "\n> ");
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /*    > (+ 1 2)
     *    3
     *    > (+ "hi" "ho")
     *    "hiho"
     */

In the next example, we use the method (inlet) machinery:

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <math.h>

    #include "s7.h"

    static s7_pointer our_abs(s7_scheme *sc, s7_pointer args)
    {
      s7_pointer x;
      x = s7_car(args);
      if (!s7_is_number(x))
        {
          s7_pointer method;
          method = s7_method(sc, x, s7_make_symbol(sc, "abs"));
          if (method == s7_undefined(sc))                       /* no method found, so raise an error */
    	s7_wrong_type_arg_error(sc, "abs", 1, x, "a real");
          return(s7_apply_function(sc, method, args));          /*   else apply the method to the args */
        }
      return(s7_make_real(sc, (s7_double)fabs(s7_number_to_real(sc, x))));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];

      s7 = s7_init();
      s7_define_function(s7, "our-abs", our_abs, 1, 0, false, "abs replacement");

      while (1)
        {
          fprintf(stdout, "\n> ");
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /*    > (our-abs -1)
     *    1.0
     *    > (our-abs (openlet (inlet 'value -3.0 'abs (lambda (x) (abs (x 'value))))))
     *    3.0
     */

#### C-side define* (s7_define_function_star)

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    static s7_pointer plus(s7_scheme *sc, s7_pointer args)
    {
      /* (define* (plus (red 32) blue) (+ (* 2 red) blue)) */
      return(s7_make_integer(sc, 2 * s7_integer(s7_car(args)) + s7_integer(s7_cadr(args))));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];

      s7 = s7_init();
      s7_define_function_star(s7, "plus", plus, "(red 32) blue", "an example of define* from C");

      while (1)
        {
          fprintf(stdout, "\n> ");
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /*
     *    > (plus 2 3)
     *    7
     *    > (plus :blue 3)
     *    67
     *    > (plus :blue 1 :red 4)
     *    9
     *    > (plus 2 :blue 3)
     *    7
     *    > (plus :blue 3 :red 1)
     *    5
     */

#### C-side define-macro (s7_define_macro)

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    static s7_pointer plus(s7_scheme *sc, s7_pointer args)
    {
      /* (define-macro (plus a b) `(+ ,a ,b)) */
      s7_pointer a, b;
      a = s7_car(args);
      b = s7_cadr(args);
      return(s7_list(sc, 3, s7_make_symbol(sc, "+"),  a, b));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];

      s7 = s7_init();
      s7_define_macro(s7, "plus", plus, 2, 0, false, "plus adds its two arguments");

      while (1)
        {
          fprintf(stdout, "\n> ");
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /*
     *    > (plus 2 3)
     *    5
     */

#### define a generic function in C

In scheme, a function becomes generic simply by `(apply ((car args) 'func) args)`. To accomplish the same thing in C, we use s7_method and s7_apply_function:

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    static s7_pointer plus(s7_scheme *sc, s7_pointer args)
    {
      #define plus_help "(plus obj ...) applies obj's plus method to obj and any trailing arguments."
      s7_pointer obj, method;
      obj = s7_car(args);
      method = s7_method(sc, obj, s7_make_symbol(sc, "plus"));
      if (s7_is_procedure(method))
        return(s7_apply_function(sc, method, args));
      return(s7_f(sc));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      s7 = s7_init();
      s7_define_function(s7, "plus", plus, 1, 0, true, plus_help);
      while (1)
        {
          char buffer[512];
          char response[1024];
          fprintf(stdout, "\n> ");
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /* gcc -c s7.c -I.
     * gcc -o ex15 ex15.c s7.o -I. -lm -ldl
     *
     *     > (plus 1 2)
     *     #f
     *     > (define obj (openlet (inlet 'plus (lambda args (apply + 1 (cdr args))))))
     *     obj
     *     > (plus obj 2 3)
     *     6
     */

#### Signal handling and continuations

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <signal.h>

    #include "s7.h"

    static s7_scheme *s7;
    struct sigaction new_act, old_act;

    static void handle_sigint(int ignored)
    {
      fprintf(stderr, "interrupted!\n");
      s7_symbol_set_value(s7, s7_make_symbol(s7, "*interrupt*"), s7_make_continuation(s7)); /* save where we were interrupted */
      sigaction(SIGINT, &new_act, NULL);
      s7_quit(s7);                             /* get out of the eval loop if possible */
    }

    static s7_pointer our_sleep(s7_scheme *sc, s7_pointer args)
    {
      /* slow down our infinite loop for demo purposes */
      sleep(1);
      return(s7_f(sc));
    }

    int main(int argc, char **argv)
    {
      char buffer[512];
      char response[1024];

      s7 = s7_init();
      s7_define_function(s7, "sleep", our_sleep, 0, 0, false, "(sleep) sleeps");
      s7_define_variable(s7, "*interrupt*", s7_f(s7));
      /* Scheme variable *interrupt* holds the continuation at the point of the interrupt */

      sigaction(SIGINT, NULL, &old_act);
      if (old_act.sa_handler != SIG_IGN)
        {
          memset(&new_act, 0, sizeof(new_act));
          new_act.sa_handler = &handle_sigint;
          sigaction(SIGINT, &new_act, NULL);
        }

      while (1)
        {
          fprintf(stderr, "\n> ");
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /*
     *    > (do ((i 0 (+ i 1))) ((= i -1)) (format () "~D " i) (sleep))
     *      ;;; now type C-C to break out of this loop
     *    0 1 2 ^Cinterrupted!
     *      ;;; call the continuation to continue from where we were interrupted
     *    > (*interrupt*)
     *    3 4 5 ^Cinterrupted!
     *    > *interrupt*
     *    #<continuation>
     *    > (+ 1 2)
     *    3
     */

#### Multidimensional vector element access

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <stdarg.h>

    #include "s7.h"

    static s7_pointer multivector_ref(s7_scheme *sc, s7_pointer vector, int indices, ...)
    {
      /* multivector_ref returns an element of a multidimensional vector */
      int ndims;
      ndims = s7_vector_rank(vector);

      if (ndims == indices)
        {
          va_list ap;
          s7_int index = 0;
          va_start(ap, indices);

          if (ndims == 1)
    	{
    	  index = va_arg(ap, s7_int);
    	  va_end(ap);
    	  return(s7_vector_ref(sc, vector, index));
    	}
          else
    	{
    	  int i;
    	  s7_pointer *elements;
    	  s7_int *offsets, *dimensions;

    	  elements = s7_vector_elements(vector);
    	  dimensions = s7_vector_dimensions(vector);
    	  offsets = s7_vector_offsets(vector);

    	  for (i = 0; i < indices; i++)
    	    {
    	      int ind;
    	      ind = va_arg(ap, int);
    	      if ((ind < 0) ||
    		  (ind >= dimensions[i]))
    		{
    		  va_end(ap);
    		  return(s7_out_of_range_error(sc,
                                                   "multivector_ref", i,
                                                   s7_make_integer(sc, ind),
                                                   "index should be between 0 and the dimension size"));
    		}
    	      index += (ind * offsets[i]);
    	    }
    	  va_end(ap);
    	  return(elements[index]);
    	}
        }
      return(s7_wrong_number_of_args_error(sc,
                                           "multivector_ref: wrong number of indices: ~A",
                                           s7_make_integer(sc, indices)));
    }

    int main(int argc, char **argv)
    {
      char buffer[512];
      char response[1024];
      s7_scheme *s7;

      s7 = s7_init();
      s7_eval_c_string(s7, "(define vect (make-vector '(2 3 4) 0))");
      s7_eval_c_string(s7, "(set! (vect 1 1 1) 32)");

      fprintf(stdout, "vect[0,0,0]: %s, vect[1,1,1]: %s\n",
    	  s7_object_to_c_string(s7, multivector_ref(s7, s7_name_to_value(s7, "vect"), 3, 0, 0, 0)),
    	  s7_object_to_c_string(s7, multivector_ref(s7, s7_name_to_value(s7, "vect"), 3, 1, 1, 1)));
    }

    /* vect[0,0,0]: 0, vect[1,1,1]: 32
     */

Much later... I decided to add s7_vector_ref_n and s7_vector_set_n to s7.

#### Notification from Scheme that a given Scheme variable has been set

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    static s7_pointer scheme_set_notification(s7_scheme *sc, s7_pointer args)
    {
      /* this function is called when the Scheme variable is set! */
      fprintf(stderr, "%s set to %s\n",
    	  s7_object_to_c_string(sc, s7_car(args)),
    	  s7_object_to_c_string(sc, s7_cadr(args)));
      return(s7_cadr(args));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      s7 = s7_init();

      s7_define_function(s7, "notify-C", scheme_set_notification, 2, 0, false, "called if notified-var is set!");
      s7_define_variable(s7, "notified-var", s7_make_integer(s7, 0));
      s7_symbol_set_access(s7, s7_make_symbol(s7, "notified-var"), s7_name_to_value(s7, "notify-C"));

      if (argc == 2)
        {
          fprintf(stderr, "load %s\n", argv[1]);
          s7_load(s7, argv[1]);
        }
      else
        {
          char buffer[512];
          char response[1024];
          while (1)
    	{
    	  fprintf(stdout, "\n> ");
    	  fgets(buffer, 512, stdin);

    	  if ((buffer[0] != '\n') ||
    	      (strlen(buffer) > 1))
    	    {
    	      sprintf(response, "(write %s)", buffer);
    	      s7_eval_c_string(s7, response);
    	    }
    	}
        }
    }

    /*    > notified-var
     *    0
     *    > (set! notified-var 32)
     *    notified-var set to 32
     *    32
     */

#### Load C defined stuff into a separate namespace

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    static s7_pointer func1(s7_scheme *sc, s7_pointer args)
    {
      return(s7_make_integer(sc, s7_integer(s7_car(args)) + 1));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      s7_pointer new_env;

      s7 = s7_init();

      /* "func1" and "var1" will be placed in an anonymous environment,
       *   accessible from Scheme via the global variable "lib-exports"
       */

      new_env = s7_inlet(s7, s7_curlet(s7), s7_nil(s7));
      /* make a private environment for func1 and var1 below (this is our "namespace") */
      s7_gc_protect(s7, new_env);

      s7_define(s7, new_env,
    	    s7_make_symbol(s7, "func1"),
    	    s7_make_function(s7, "func1", func1, 1, 0, false, "func1 adds 1 to its argument"));

      s7_define(s7, new_env, s7_make_symbol(s7, "var1"), s7_make_integer(s7, 32));
      /* those two symbols are now defined in the new environment */

      /* add "lib-exports" to the global environment */
      s7_define_variable(s7, "lib-exports", s7_let_to_list(s7, new_env));

      if (argc == 2)
        {
          fprintf(stderr, "load %s\n", argv[1]);
          s7_load(s7, argv[1]);
        }
      else
        {
          char buffer[512];
          char response[1024];
          while (1)
    	{
    	  fprintf(stdout, "\n> ");
    	  fgets(buffer, 512, stdin);

    	  if ((buffer[0] != '\n') ||
    	      (strlen(buffer) > 1))
    	    {
    	      sprintf(response, "(write %s)", buffer);
    	      s7_eval_c_string(s7, response);
    	    }
    	}
        }
    }

    /*     > func1
     *     ;func1: unbound variable, line 1
     *     > lib-exports
     *     ((var1 . 32) (func1 . func1))
     *     ;; so lib-exports has the C-defined names and values
     *     ;; we can use these directly:
     *
     *     > (define lib-env (apply sublet (curlet) lib-exports))
     *     lib-env
     *     > (with-let lib-env (func1 var1))
     *     33
     *
     *     ;; or rename them to prepend "lib:"
     *     > (define lib-env (apply sublet
                                    (curlet)
                                    (map (lambda (binding)
                                           (cons (string->symbol
                                                   (string-append "lib:" (symbol->string (car binding))))
                                                 (cdr binding)))
                                         lib-exports)))
     *     lib-env
     *     > (with-let lib-env (lib:func1 lib:var1))
     *     33
     *
     *     ;;; now for convenience, place "func1" in the global environment under the name "func2"
     *     > (define func2 (cdadr lib-exports))
     *     func2
     *     > (func2 1)
     *     2
     */

#### Handle scheme errors in C

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    static s7_pointer error_handler(s7_scheme *sc, s7_pointer args)
    {
      fprintf(stdout, "error: %s\n", s7_string(s7_car(args)));
      return(s7_f(sc));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];
      bool with_error_hook = false;

      s7 = s7_init();
      s7_define_function(s7, "error-handler", error_handler, 1, 0, false, "our error handler");

      if (with_error_hook)
        s7_eval_c_string(s7, "(set! (hook-functions *error-hook*)                    \n\
                                (list (lambda (hook)                                 \n\
                                        (error-handler                               \n\
                                          (apply format #f (hook 'data)))            \n\
                                        (set! (hook 'result) 'our-error))))");
      while (1)
        {
          fprintf(stdout, "\n> ");
          fgets(buffer, 512, stdin);

          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  s7_pointer old_port, result;
    	  int gc_loc = -1;
    	  const char *errmsg = NULL;

    	  /* trap error messages */
    	  old_port = s7_set_current_error_port(s7, s7_open_output_string(s7));
    	  if (old_port != s7_nil(s7))
    	    gc_loc = s7_gc_protect(s7, old_port);

    	  /* evaluate the input string */
    	  result = s7_eval_c_string(s7, buffer);

    	  /* print out the value wrapped in "{}" so we can tell it from other IO paths */
    	  fprintf(stdout, "{%s}", s7_object_to_c_string(s7, result));

    	  /* look for error messages */
    	  errmsg = s7_get_output_string(s7, s7_current_error_port(s7));

    	  /* if we got something, wrap it in "[]" */
    	  if ((errmsg) && (*errmsg))
    	    fprintf(stdout, "[%s]", errmsg);

    	  s7_close_output_port(s7, s7_current_error_port(s7));
    	  s7_set_current_error_port(s7, old_port);
    	  if (gc_loc != -1)
    	    s7_gc_unprotect_at(s7, gc_loc);
    	}
        }
    }

    /*
     *   gcc -c s7.c -I. -g3
     *   gcc -o ex3 ex3.c s7.o -lm -I. -ldl
     *
     * if with_error_hook is false,
     *
     *   > (+ 1 2)
     *   {3}
     *   > (+ 1 #\c)
     *   {wrong-type-arg}[
     *   ;+ argument 2, #\c, is character but should be a number, line 1
     *   ]
     *
     * so s7 by default prepends ";" to the error message, and appends "\n",
     *   sending that to current-error-port, and the error type ('wrong-type-arg here)
     *   is returned.
     *
     * if with_error_hook is true,
     *
     *   > (+ 1 2)
     *   {3}
     *   > (+ 1 #\c)
     *   error: + argument 2, #\c, is character but should be a number
     *   {our-error}
     *
     * so now the *error-hook* code handles both the error reporting and
     *   the value returned ('our-error in this case).
     */

#### C and Scheme hooks

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    static s7_pointer my_hook_function(s7_scheme *sc, s7_pointer args)
    {
      fprintf(stderr, "a is %s\n", s7_object_to_c_string(sc, s7_symbol_local_value(sc, s7_make_symbol(sc, "a"), s7_car(args))));
      return(s7_car(args));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];
      s7_pointer test_hook;

      s7 = s7_init();

      /* define test_hook in C, test-hook in Scheme, arguments are named a and b */
      test_hook = s7_eval_c_string(s7, "(make-hook 'a 'b)");
      s7_define_constant(s7, "test-hook", test_hook);

      /* add my_hook_function to the test_hook function list */
      s7_hook_set_functions(s7, test_hook,
    			s7_cons(s7,
    				s7_make_function(s7, "my-hook-function", my_hook_function, 1, 0, false, "my hook-function"),
    				s7_hook_functions(s7, test_hook)));
      while (1)
        {
          fprintf(stdout, "\n> ");
          fgets(buffer, 512, stdin);

          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /*
     *    > test-hook
     *    #<lambda (hook)>
     *    > (hook-functions test-hook)
     *    (my-hook-function)
     *    > (test-hook 1 2)
     *    a is 1
     *    #<unspecified>
     */

#### Load a shared library

We can use dlopen to load a shared library, and dlsym to initialize that library in our main program. The tricky part is to conjure up the right compiler and loader flags. First we define a module that defines a new s7 function, add-1 that we'll tie into s7 explicitly, and another function that we'll try to call by waving a wand.

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"

    double a_function(double an_arg);
    double a_function(double an_arg)
    {
      return(an_arg + 1.0);
    }

    static s7_pointer add_1(s7_scheme *sc, s7_pointer args)
    {
      return(s7_make_integer(sc, s7_integer(s7_car(args)) + 1));
    }

    void init_ex(s7_scheme *sc);
    void init_ex(s7_scheme *sc)  /* this needs to be globally accessible (not "static") */
    {
      /* tell s7 about add-1, but leave a_function hidden */
      s7_define_function(sc, "add-1", add_1, 1, 0, false, "(add-1 x) adds 1 to x");
    }

And here is our main program:

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include "s7.h"
    #include <dlfcn.h>

    static void *library = NULL;

    static s7_pointer try(s7_scheme *sc, s7_pointer args)
    {
      /* try tries to call an arbitrary function in the shared library */
      void *func;
      func = dlsym(library, s7_string(s7_car(args)));
      if (func)
        {
          /* we'll assume double f(double) */
          typedef double (*dl_func)(double arg);
          return(s7_make_real(sc, ((dl_func)func)(s7_real(s7_cadr(args)))));
        }
      return(s7_error(sc, s7_make_symbol(sc, "can't find function"),
    		  s7_list(sc, 2, s7_make_string(sc, "loader error: ~S"),
    			         s7_make_string(sc, dlerror()))));
    }

    static s7_pointer cload(s7_scheme *sc, s7_pointer args)
    {
      /* cload loads a shared library */
      #define CLOAD_HELP "(cload so-file-name) loads the module"
      library = dlopen(s7_string(s7_car(args)), RTLD_LAZY);
      if (library)
        {
          /* call our init func to define add-1 in s7 */
          void *init_func;
          init_func = dlsym(library, s7_string(s7_cadr(args)));
          if (init_func)
    	{
    	  typedef void *(*dl_func)(s7_scheme *sc);
    	  ((dl_func)init_func)(sc);  /* call the initialization function (init_ex above) */
    	  return(s7_t(sc));
    	}
        }
      return(s7_error(sc, s7_make_symbol(sc, "load-error"),
    		      s7_list(sc, 2, s7_make_string(sc, "loader error: ~S"),
    			             s7_make_string(sc, dlerror()))));
    }

    int main(int argc, char **argv)
    {
      char buffer[512];
      char response[1024];
      s7_scheme *s7;

      s7 = s7_init();

      s7_define_function(s7, "cload", cload, 2, 0, false, CLOAD_HELP);
      s7_define_function(s7, "try", try, 2, 0, false,
                             "(try name num) tries to call name in the shared library with the argument num.");

      while (1)
        {
          fprintf(stdout, "\n> ");
          fgets(buffer, 512, stdin);

          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /* Put the module in the file ex3a.c and the main program in ex3.c, then
     *
     * in Linux:
     *   gcc -c -fPIC ex3a.c
     *   gcc ex3a.o -shared -o ex3a.so
     *   gcc -c s7.c -I. -fPIC -shared
     *   gcc -o ex3 ex3.c s7.o -lm -ldl -I. -Wl,-export-dynamic
     *   # omit -ldl in freeBSD, openBSD might want -ftrampolines
     *
     * in Mac OSX:
     *   gcc -c ex3a.c
     *   gcc ex3a.o -o ex3a.so -dynamic -bundle -undefined suppress -flat_namespace
     *   gcc -c s7.c -I. -dynamic -bundle -undefined suppress -flat_namespace
     *   gcc -o ex3 ex3.c s7.o -lm -ldl -I.
     *
     * and run it:
     *   ex3
     *   > (cload "/home/bil/snd-16/ex3a.so" "init_ex")
     *   #t
     *   > (add-1 2)
     *   3
     *   > (try "a_function" 2.5)
     *   3.5
     */

All of this is just boring boilerplate, so with a little support from s7, we can write a script to do the entire linkage. The s7 side is an extension to "load" that loads a shared object file if its extension is "so", and runs an initialization function whose name is defined in the load environment (the optional second argument to load). An example of the scheme side is cload.scm, included in the s7 tarball. It defines a function that can be called:

    (c-define '(double j0 (double)) "m" "math.h")

This links the s7 function m:j0 to the math library function j0. See cload.scm for more details.

#### Bignums in C

Bignum support depends on gmp, mpfr, and mpc. In this example, we define "add-1" which adds 1 to any kind of number. The s7_big_* functions return the underlying gmp/mpfr/mpc pointer, so we have to copy that into a new number before adding.

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    #include <gmp.h>
    #include <mpfr.h>
    #include <mpc.h>

    #include "s7.h"

    static s7_pointer big_add_1(s7_scheme *sc, s7_pointer args)
    {
      /* add 1 to either a normal number or a bignum */
      s7_pointer x;
      x = s7_car(args);
      if (s7_is_bignum(x))
        {
          s7_pointer n;
          if (s7_is_integer(x))
    	{
    	  mpz_t *big_n;
    	  n = s7_make_big_integer(sc, s7_big_integer(x)); /* copy x */
    	  big_n = s7_big_integer(n);                      /* get mpz_t pointer of copy */
    	  mpz_add_ui(*big_n, *big_n, 1);                  /* add 1 to that */
    	  return(n);                                      /* return the new bignum */
    	}
          if (s7_is_ratio(x))
    	{
    	  mpq_t *big_q;
    	  mpz_t num, den;
    	  n = s7_make_big_ratio(sc, s7_big_ratio(x));
    	  big_q = s7_big_ratio(n);
    	  mpz_init_set(num, mpq_numref(*big_q));
    	  mpz_init_set(den, mpq_denref(*big_q));
    	  mpz_add(num, num, den);
    	  mpq_set_num(*big_q, num);
    	  mpz_clear(num);
    	  mpz_clear(den);
    	  return(n);
    	}
          if (s7_is_real(x))
    	{
    	  mpfr_t *big_x;
    	  n = s7_make_big_real(sc, s7_big_real(x));
    	  big_x = s7_big_real(n);
    	  mpfr_add_ui(*big_x, *big_x, 1, GMP_RNDN);
    	  return(n);
    	}
          /* x must be big complex */
          {
    	mpc_t *big_z;
    	n = s7_make_big_complex(sc, s7_big_complex(x));
    	big_z = s7_big_complex(n);
    	mpc_add_ui(*big_z, *big_z, 1, MPC_RNDNN);
    	return(n);
          }
        }
      else
        {
          if (s7_is_integer(x))
    	return(s7_make_integer(sc, 1 + s7_integer(x)));
          if (s7_is_rational(x))
    	return(s7_make_ratio(sc, s7_numerator(x) + s7_denominator(x), s7_denominator(x)));
          if (s7_is_real(x))
    	return(s7_make_real(sc, 1.0 + s7_real(x)));
          if (s7_is_complex(x))
    	return(s7_make_complex(sc, 1.0 + s7_real_part(x), s7_imag_part(x)));
        }
      return(s7_wrong_type_arg_error(sc, "add-1", 0, x, "a number"));
    }

    int main(int argc, char **argv)
    {
      s7_scheme *s7;
      char buffer[512];
      char response[1024];

      s7 = s7_init();
      s7_define_function(s7, "add-1", big_add_1, 1, 0, false, "(add-1 num) adds 1 to num");

      while (1)
        {
          fprintf(stdout, "\n> ");
          fgets(buffer, 512, stdin);
          if ((buffer[0] != '\n') ||
    	  (strlen(buffer) > 1))
    	{
    	  sprintf(response, "(write %s)", buffer);
    	  s7_eval_c_string(s7, response);
    	}
        }
    }

    /*
     *   gcc -DWITH_GMP=1 -c s7.c -I. -O2 -g3
     *   gcc -DWITH_GMP=1 -o ex2 ex2.c s7.o -I. -O2 -lm -ldl -lgmp -lmpfr -lmpc
     *
     *   ex2
     *   > (add-1 1)
     *   2
     *   > (add-1 2/3)
     *   5/3
     *   > (add-1 1.4)
     *   2.4
     *   > (add-1 1.5+i)
     *   2.5+1i
     *   > (add-1 (bignum "3"))
     *   4          ; this is the bignum 4
     *   > (add-1 (bignum "3/4"))
     *   7/4
     *   > (add-1 (bignum "1.4"))
     *   2.399999999999999911182158029987476766109E0
     *   > (add-1 (bignum "1.5+i"))
     *   2.500E0+1.000E0i
     */

#### glistener.c

glistener.c is a gtk-based repl. It is not specific to s7: Snd uses it as its Forth and Ruby listener as well as for s7. Here's a short example:

    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    #include <stdbool.h>

    #include <gtk/gtk.h>

    #include "s7.h"
    #include "glistener.h"

    static s7_scheme *s7;

    static gint quit_repl(GtkWidget *w, GdkEvent *event, gpointer context) {exit(0);}

    static void evaluator(glistener *g, const char *text)
    {
      /* this sends "text" to s7 for evaluation, then displays the result */
      int gc_loc;
      s7_pointer old_port, result;
      const char *errmsg = NULL;
      char *msg = NULL;

      old_port = s7_set_current_error_port(s7, s7_open_output_string(s7));
      gc_loc = s7_gc_protect(s7, old_port);

      result = s7_eval_c_string(s7, text);
      errmsg = s7_get_output_string(s7, s7_current_error_port(s7));
      if ((errmsg) && (*errmsg))
        {
          msg = (char *)calloc(strlen(errmsg) + 1, sizeof(char));
          strcpy(msg, errmsg);
        }

      s7_close_output_port(s7, s7_current_error_port(s7));
      s7_set_current_error_port(s7, old_port);
      s7_gc_unprotect_at(s7, gc_loc);

      glistener_append_text(g, "\n");
      if (msg)                      /* some error occurred during evaluation */
        glistener_append_text(g, msg);
      else
        {                           /* evaluation produced an s7 object which we need to display */
          msg = s7_object_to_c_string(s7, result);
          glistener_append_text(g, msg);
        }
      if (msg) free(msg);
      glistener_append_prompt(g);  /* prompt for more input */
    }

    static void listener_init(glistener *g, GtkWidget *w)
    {
      /* this is the glistener initialization function. "w" above is the new text-view widget,
       *   "g" is the new glistener pointer, passed to any function that wants to talk to this
       *   listener.
       */
      unsigned char prompt[4] = {0xce, 0xbb, '>', '\0'}; /* lambda as prompt */
      GtkTextBuffer *buffer;

      buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w));
      glistener_set_font(g, pango_font_description_from_string("Monospace 10"));

      /* our prompt will be a red lambda */
      glistener_set_prompt_tag(g, gtk_text_buffer_create_tag(buffer, "glistener_prompt_tag",
    							 "weight", PANGO_WEIGHT_BOLD,
    							 "foreground", "red",
    							 NULL));
      glistener_set_prompt(g, prompt);
    }

    static const char *helper(glistener *g, const char *text)
    {
      /* this function is called whenever the listener thinks help is needed.
       *   Any string it returns is posted in the listener statusbar.
       */
      s7_pointer sym;
      sym = s7_symbol_table_find_name(s7, text);
      if (sym)
        return(s7_help(s7, sym));
      glistener_clear_status(g);
      return(NULL);
    }

    static void completer(glistener *g, bool (*symbol_func)(const char *symbol_name, void *data), void *data)
    {
      /* this function is called when <tab> is typed after a partial symbol name.
       *   "symbol_func" above should be called on each member of the symbol-table, passing it
       *   the symbol name (as a string) and the data passed as "completer's" third argument.
       *   If symbol_func returns true, it is done, so the loop through the symbol-table can stop.
       */
      s7_for_each_symbol_name(s7, symbol_func, data);
    }

    int main(int argc, char **argv)
    {
      GtkWidget *shell, *frame;
      glistener *g;

      s7 = s7_init();

      gtk_init(&argc, &argv);
      shell = gtk_window_new(GTK_WINDOW_TOPLEVEL);
      g_signal_connect(G_OBJECT(shell), "delete_event", G_CALLBACK(quit_repl), NULL);

      frame = gtk_frame_new(NULL);
      gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
      gtk_widget_show(frame);

      gtk_container_add(GTK_CONTAINER(shell), frame);

      /* make a new listener */
      g = glistener_new(frame, listener_init);
      glistener_set_evaluator(g, evaluator);
      glistener_set_helper(g, helper);
      glistener_set_completer(g, completer);

      gtk_widget_show(shell);
      gdk_window_resize(gtk_widget_get_window(shell), 400, 200);
      gtk_main();
    }

    /* in gtk-2: gcc gcall.c -o gcall s7.o glistener.o `pkg-config --libs gtk+-2.0 --cflags` -lm -ldl
     * in gtk-3: gcc gcall.c -o gcall s7.o glistener.o `pkg-config --libs gtk+-3.0 --cflags` -lm -ldl
     */

    λ> (define λ lambda)
    λ
    λ> ((λ (a b) (+ a b)) 1 2)
    3
    λ>

The five or six functions supplied by the caller (evaluator, helper, completer, checker, colorizer, keyer) all have defaults, so you don't have to supply anything but an evaluator. The default evaluator just prints "?" and prompts for more input. See glistener.h for the full API and an earnest attempt at helpful documentation.

A multi-listener test program is the Snd file tools/gcall.c which is used by tools/gtest.scm for regression testing. One way to name unicode characters is: `(define-constant |lambda| #u8(#xce #xbb))`. This can be embedded in an ordinary s7 string with any string operation: `(string-append |lambda| "ambda")` which returns "λambda". (string-length will still return the number of bytes; to get the number of characters in a case like this, use g_utf8_strlen). So, to set the prompt to be a red lambda and the font to be "Nimbus mono 10" from Scheme, assuming we have the usual Scheme-to-C linkages (see snd-glistener.c):

    (set! (listener-prompt) (byte-vector #xce #xbb (char->integer #\>) (char->integer #\space)))
    (set! (listener-font) "Nimbus mono 10")
    (listener-set-prompt-tag *listener* ; ideally this too would be a setter
      (gtk_text_buffer_create_tag
        (GTK_TEXT_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (listener-text-widget *listener*))))
        "" (list "weight" PANGO_WEIGHT_BOLD "foreground" "red")))

In Snd, all the gtk code is in the *gtk* environment, so we need to use:

    (listener-set-prompt-tag *listener*
      (with-let (sublet *gtk* 'textw (listener-text-widget *listener*)) ; use *gtk*
        (gtk_text_buffer_create_tag
          (GTK_TEXT_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW textw)))
          "" (list "weight" PANGO_WEIGHT_BOLD "foreground" "red"))))

#### gdb

It is possible to make a mistake while writing C code. I switched from Common Lisp to Scheme a long time ago partly because it was so painful to debug FFI troubles in Common Lisp, and I chose Guile at that time partly because I thought gdb would have native support for it. As far as I know it is still impossible to debug CL FFI troubles, 20 years later! And in gdb Python has muscled Guile aside. Anyway, say you have hit a segfault and find yourself staring at a stackful of opaque pointers. Print statements are your friend, of course, and at the gdb command level, the main one in this context is s7_object_to_c_string. Here are some commands (intended for your .gdbinit file) that can speed up the process. They assume the s7_scheme pointer is named "sc". (These are now included in the gdbinit file in the s7 tarball).

    define s7print
    print s7_object_to_c_string(sc, $arg0)
    end
    document s7print
    interpret the argument as an s7 value and display it
    end
    # the current expression is sc->cur_code
    # the current environment is sc->envir
    # the error environment is sc->owlet
    # so for example, to see the current local variables, s7p sc->envir

    define s7eval
    print s7_object_to_c_string(sc, s7_eval_c_string(sc, $arg0))
    end
    document s7eval
    eval the argument (a string)
    end

    define s7stack
    print s7_object_to_c_string(sc, s7_stacktrace(sc))
    end
    document s7stack
    display the current stack
    end

    define s7value
    print s7_object_to_c_string(sc, s7_name_to_value(sc, $arg0))
    end
    document s7value
    print the value of the variable passed by its print name: s7v "*features*"
    end

gdbinit also has s7cell to decode every field of an s7_pointer, and two backtrace decoders: s7bt and s7btfull (heh heh). The bt replacements print the gdb backtrace info, replacing bare pointer numbers with their s7 value, wherever possible:

    #1  0x000000000042104e in find_symbol_unchecked (sc=0x97edf0, symbol=vars) at s7.c:6677
            x = (inlet 'f import-lambda-definition-2)
            __FUNCTION__ = "find_symbol_unchecked"
    #2  0x00000000006e3424 in eval (sc=0x97edf0, first_op=9) at s7.c:63673
            _x_ = import-lambda-definition-2
            _slot_ = 'form import-lambda-definition-2
            _sym_ = env
            _val_ = import-lambda-definition-2
            args = (vars)
            p = (env)
            func = lint-walk
            e = (inlet 'name import-lambda-definition-2 'form import-lambda-definition-2)
            code = (lint-walk name f vars)
            __FUNCTION__ = "eval"

s7 examples

The s7 tarball includes several scheme files including s7test.scm, lint.scm, cload.scm, write.scm, mockery.scm, and stuff.scm. s7test.scm is a regression test for s7, lint.scm is the s7 equivalent of the ancient C program named lint (modern equivalent: cppcheck), write.scm has a pretty printer, mockery.scm has mock data libraries, cload.scm is a wrapper for the FFI stuff described above, and stuff.scm is just some arbitrary stuff. gdbinit has some gdb commands for s7. repl.scm is a repl. profile.scm provides access to profiling data, if it's enabled.

#### cload.scm

cload.scm defines the macro c-define that reduces the overhead involved in (dynamically) linking C entities into s7.

    (c-define c-info (prefix "") (headers ()) (cflags "") (ldflags "") output-name)

For example, `(c-define '(double j0 (double)) "m" "math.h")` links the C math library function j0 into s7 under the name m:j0, passing it a double argument and getting a double result (a real in s7).

prefix is some arbitrary prefix that you want prepended to various names.

headers is a list of headers (as strings) that the c-info relies on, (("math.h") for example).

cflags are any special C compiler flags that are needed ("-I." in particular), and ldflags is the similar case for the loader. output-name is the name of the output C file and associated library. It defaults to "temp-s7-output" followed by a number. In libm.scm, it is set to "libm_s7" to protect it across cload calls. If cload finds an up-to-date output C file and shared library, it simply loads the library, rather than going through all the trouble of writing and compling it.

c-info is a list that describes the C entities that you want to load into s7. It can be either one list describing one entity, or a list of such lists. Each description has the form:

    (return-type entity-name-in-C (argument-type...))

where each entry is a symbol, and C names are used throughout. So, in the j0 example above, `(double j0 (double))` says we want access to j0, it returns a C double, and it takes one argument, also a C double. s7 tries to figure out what the corresponding s7 type is, but in tricky cases, you should tell it by replacing the bare type name with a list: `(C-type underlying-C-type)`. For example, the Snd function set_graph_style takes an (enum) argument of type graph_style_t. This is actually an int, so we use `(graph_style_t int)` as the type:

    (void set_graph_style ((graph_style_t int)))

If the C entity is a constant, then the descriptor list has just two entries, the C-type and the entity name: `(int F_OK)` for example. The entity name can also be a list:

    ((graph_style_t int) (GRAPH_LINES GRAPH_DOTS GRAPH_FILLED GRAPH_DOTS_AND_LINES GRAPH_LOLLIPOPS))

This defines all the names in the list as integers. If the C type has a space ("struct tm*"), use `(symbol "struct tm*")` to construct the corresponding symbol.

The entity is placed in the current s7 environment under the name `(string-append prefix ":" name)` where the ":" is omitted if the prefix is null. So in the j0 example, we get in s7 the function m:j0. c-define returns #t if it thinks the load worked, and #f otherwise.

There are times when the only straightforward approach is to write the desired C code directly. To insert C code on the fly, use (in-C "code..."). Two more such cases that come up all the time: C-function for linkage to functions written directly in s7 style using in-C, and C-macro for macros in the C header file that need to be wrapped in #ifdefs. Here are some examples:

    ;;; various math library functions
    (c-define '((double j0 (double))
                (double j1 (double))
                (double erf (double))
                (double erfc (double))
                (double lgamma (double)))
              "m" "math.h")

    ;;; getenv and setenv
    (c-define '(char* getenv (char*)))
    (c-define '(int setenv (char* char* int)))

    ;;; file-exists? and delete-file
    (define file-exists? (let () ; define F_OK and access only within this let
                           (c-define '((int F_OK) (int access (char* int))) "" "unistd.h")
                           (lambda (arg) (= (access arg F_OK) 0))))

    (define delete-file (let ()
                          (c-define '(int unlink (char*)) "" "unistd.h")
                          (lambda (file) (= (unlink file) 0)))) ; 0=success

    ;;; examples from Snd:
    (c-define '(char* version_info ()) "" "snd.h" "-I.")

    (c-define '(mus_float_t mus_degrees_to_radians (mus_float_t)) "" "snd.h" "-I.")

    (c-define '(snd_info* any_selected_sound ()) "" "snd.h" "-I.")
    (c-define '(void select_channel (snd_info* int)) "" "snd.h" "-I.")

    (c-define '(((graph_style_t int) (GRAPH_LINES GRAPH_DOTS GRAPH_FILLED GRAPH_DOTS_AND_LINES GRAPH_LOLLIPOPS))
                (void set_graph_style ((graph_style_t int))))
              "" "snd.h" "-I.")

    ;;; getcwd, strftime
    (c-define '(char* getcwd (char* size_t)) "" "unistd.h")

    (c-define (list '(void* calloc (size_t size_t))
    	        '(void free (void*))
    	        '(void time (time_t*)) ; ignore returned value
    	        (list (symbol "struct tm*") 'localtime '(time_t*))
                    (list 'size_t 'strftime (list 'char* 'size_t 'char* (symbol "struct tm*"))))
              "" "time.h")

    > (let ((p (calloc 1 8))
            (str (make-string 32)))
        (time p)
        (strftime str 32 "%a %d-%b-%Y %H:%M %Z" (localtime p))
        (free p)
        str)
    "Sat 11-Aug-2012 08:55 PDT\x00      "

    ;;; opendir, read_dir, closedir
    (c-define '((int closedir (DIR*))
    	    (DIR* opendir (char*))
    	    (in-C "static char *read_dir(DIR *p)  \
                       {                              \
                         struct dirent *dirp;          \
                         dirp = readdir(p);            \
                         if (!dirp) return(NULL);      \
                         return(dirp->d_name);         \
                       }")
    	    (char* read_dir (DIR*)))
      "" '("sys/types.h" "dirent.h"))

    (let ((dir (opendir "/home/bil/gtk-snd")))
      (do ((p (read_dir dir) (read_dir dir)))
          ((= (length p) 0))
        (format *stderr* "~A " p))
      (closedir dir))

For the simple cases above, include "-ldl -Wl,-export-dynamic" in the gcc command. So the first FFI example is built (this is in Linux):

    gcc -c s7.c -I.
    gcc -o ex1 ex1.c s7.o -lm -I. -ldl -Wl,-export-dynamic
    ex1
    > (load "cload.scm")
    c-define-1
    > (c-define '(double j0 (double)) "m" "math.h")
    #t
    > (m:j0 0.5)
    0.93846980724081

See also r7rs.scm, libc.scm, libgsl.scm, libm.scm, libdl.scm, and libgdbm.scm. libutf8proc.scm exists, but I have not tested it at all.

    (require libc.scm)

    (define (copy-file in-file out-file)
      (with-let (sublet *libc* :in-file in-file :out-file out-file)

        ;; the rest of the function body exists in the *libc* environment, with the
        ;;   function parameters in-file and out-file imported, so, for example,
        ;;   (open ...) below calls the libc function open.

        (let ((infd (open in-file O_RDONLY 0)))
          (if (= infd -1)
    	  (error 'io-error "can't find ~S~%" in-file)
    	  (let ((outfd (creat out-file #o666)))
    	    (if (= outfd -1)
    		(begin
    		  (close infd)
    		  (error 'io-error "can't open ~S~%" out-file))
    		(let* ((BUF_SIZE 1024)
                           (buf (malloc BUF_SIZE)))
    		  (do ((num (read infd buf BUF_SIZE) (read infd buf BUF_SIZE)))
    		      ((or (<= num 0)
    			   (not (= (write outfd buf num) num)))))
    		  (close outfd)
    		  (close infd)
    		  (free buf)
    		  out-file)))))))

    (define (glob->list pattern)
      (with-let (sublet *libc* :pattern pattern)
        (let ((g (glob.make)))
          (glob pattern 0 g)
          (let ((res (glob.gl_pathv g)))
    	(globfree g)
    	res))))

    ;; now (load "*.scm") is (for-each load (glob->list "*.scm"))

    (require libgsl.scm)

    (define (eigenvalues M)
      (with-let (sublet *libgsl* :M M)
        (let* ((len (sqrt (length M)))
    	   (gm (gsl_matrix_alloc len len))
    	   (m (float-vector->gsl_matrix M gm))
    	   (evl (gsl_vector_complex_alloc len))
    	   (evc (gsl_matrix_complex_alloc len len))
    	   (w (gsl_eigen_nonsymmv_alloc len)))

          (gsl_eigen_nonsymmv m evl evc w)
          (gsl_eigen_nonsymmv_free w)
          (gsl_eigen_nonsymmv_sort evl evc GSL_EIGEN_SORT_ABS_DESC)

          (let ((vals (make-vector len)))
    	(do ((i 0 (+ i 1)))
    	    ((= i len))
    	  (set! (vals i) (gsl_vector_complex_get evl i)))
    	(gsl_matrix_free gm)
    	(gsl_vector_complex_free evl)
    	(gsl_matrix_complex_free evc)
    	vals))))

We can use gdbm (or better yet, mdb), the :readable argument to object->string, and the fallback methods in the environments to create name-spaces (lets) with billions of thread-safe local variables, which can be saved and communicated between s7 runs:

    (require libgdbm.scm)

    (with-let *libgdbm*

      (define *db*
        (openlet
         (inlet :file (gdbm_open "test.gdbm" 1024 GDBM_NEWDB #o664
    		    (lambda (str) (format *stderr* "gdbm error: ~S~%" str)))

    	    :let-ref-fallback (lambda (obj sym)
    				(eval-string (gdbm_fetch (obj 'file) (symbol->string sym))))

    	    :let-set!-fallback (lambda (obj sym val)
    				 (gdbm_store (obj 'file)
    					     (symbol->string sym)
    					     (object->string val :readable)
    					     GDBM_REPLACE)
    				 val)

    	    :make-iterator (lambda (obj)
    			     (let ((key #f)
    				   (length (lambda (obj) (expt 2 20))))
    			       (#_make-iterator
                                    (let ((iterator? #t))
    				  (openlet
    				   (lambda ()
    				     (if key
    				         (set! key (gdbm_nextkey (obj 'file) (cdr key)))
    				         (set! key (gdbm_firstkey (obj 'file))))
    				     (if (pair? key)
    				         (cons (string->symbol (car key))
    					       (eval-string (gdbm_fetch (obj 'file) (car key))))
    				         key))))))))))

      (set! (*db* 'str) "123") ; add a variable named 'str with the value "123"
      (set! (*db* 'int) 432)

      (with-let *db*
        (+ int (length str)))    ; -> 435
      (map values *db*)          ; -> '((str . "123") (int . 432))

      (gdbm_close (*db* 'file)))

#### repl.scm

repl.scm implements a repl using vt100 codes and libc.scm. It includes symbol and filename completion, a history buffer, paren matching, indentation, multi-line edits, and a debugger window. To move around in the history buffer, use M-p, M-n or M-. (C-p and C-n are used to move the cursor in the current expression). You can change the keymap or the prompt; all the repl functions are accessible through the *repl* environment. One field is 'repl-let which gives you access to all the repl's internal variables and functions. Another is 'top-level-let, normally (sublet (rootlet)), which is the environment in which the repl's evaluation takes place. You can reset the repl back to its starting point with: `(set! (*repl* 'top-level-let) (sublet (rootlet)))`. You can save the current repl state via `((*repl* 'save-repl))`, and restore it later via `((*repl* 'restore-repl))`. The repl's saved state is in the file save.repl, or the filename can be passed as an argument to save-repl and restore-repl. The special symbol '** holds the last value.

Meta keys are a problem on the Mac. You can use ESC instead, but that requires super-human capacities. I stared at replacement control keys, and nothing seemed right. If you can think of something, it's easy to define replacements: see repl.scm which has a small table of mappings.

To run the repl, either build s7 with the compiler flag -DWITH_MAIN, or conjure up a wrapper:

    #include "s7.h"

    int main(int argc, char **argv)
    {
      s7_scheme *sc;
      sc = s7_init();
      s7_load(sc, "repl.scm");
      s7_eval_c_string(sc, "((*repl* 'run))");
      return(0);
    }

    /* gcc -o r r.c s7.o -Wl,-export-dynamic -lm -I. -ldl
     */

Besides evaluating s7 expressions, like any repl, you can also type shell commands just as in a shell:

    > pwd
    /home/bil/cl
    > cd ..
    /home/bil
    > date
    Wed 15-Apr-2015 17:32:24 PDT
    > **
    "Wed 15-Apr-2015 17:32:24 PDT
    "

In most cases, these are handled through *unbound-variable-hook*, checked using "command -v", then passed to the underlying shell via the system function. If s7's (as opposed to libc's) system command is accessible, the '** variable holds whatever the command printed.

The prompt is set by the function (*repl* 'prompt). It gets one argument, the current line number, and should set the prompt string and its length.

    (set! (*repl* 'prompt) (lambda (num)
    			 (with-let (*repl* 'repl-let)
    			   (set! prompt-string "scheme> ")
    			   (set! prompt-length (length prompt-string)))))

or, to use the red lambda example mentioned earlier:

    (set! (*repl* 'prompt)
          (lambda (num)
    	(with-let (*repl* 'repl-let)
    	  (set! prompt-string (bold (red (string #\xce #\xbb #\> #\space))))
    	  (set! prompt-length 3)))) ; until we get unicode length calc

The line number provides a quick way to move around in the history buffer. To get a previous line without laboriously typing M-p over and over, simply type the line number (without control or meta bits), then M-.

Here is an example of adding to the keymap:

    (set! ((*repl* 'keymap) (integer->char 17)) ; C-q to quit and return to caller
          (lambda (c)
    	(set! ((*repl* 'repl-let) 'all-done) #t)))

To access the meta keys (in the keymap), use a string: `((*repl* 'keymap) (string #\escape #\p))`; this is Meta-p which normally accesses the history buffer.

You can call the repl from other code, poke around in the current environment (or whatever), then return to the caller:

    (load "repl.scm")

    (define (drop-into-repl e)
      (let ((C-q (integer->char 17)))              ; we'll use the C-q example above to get out
        (let ((old-C-q ((*repl* 'keymap) C-q))
    	  (old-top-level (*repl* 'top-level-let)))
          (dynamic-wind
    	  (lambda ()
    	    (set! (*repl* 'top-level-let) e)
    	    (set! ((*repl* 'keymap) C-q)
    		  (lambda (c)
    		    (set! ((*repl* 'repl-let) 'all-done) #t))))
    	  (lambda ()
    	    ((*repl* 'run)))                   ; run the repl
    	  (lambda ()
    	    (set! (*repl* 'top-level-let) old-top-level)
    	    (set! ((*repl* 'keymap) C-q) old-C-q))))))

    (let ((x 32))
      (format *stderr* "x: ~A~%" x)
      (drop-into-repl (curlet))
      (format *stderr* "now x: ~A~%" x))

Now load that code and:

    x: 32
    > x
    32
    > (set! x 91)
    91
    > x
    91
    > now x: 91  ; here I typed C-q at the prompt

Another possibility:

    (set! (hook-functions *error-hook*)
          (list (lambda (hook)
                  (apply format *stderr* (hook 'data))
                  (newline *stderr*)
    	      (drop-into-repl (owlet)))))

See the end of repl.scm for more examples.

#### lint.scm

lint tries to find errors or infelicities in your scheme code. To try it:

    (load "lint.scm")
    (lint "some-code.scm")

There are several variables at the start of lint.scm to control additional output:

    *report-unused-parameters*
    *report-unused-top-level-functions*
    *report-shadowed-variables*
    *report-undefined-identifiers*
    *report-multiply-defined-top-level-functions*
    *report-nested-if*
    *report-short-branch*
    *report-one-armed-if*
    *report-loaded-files*
    *report-any-!-as-setter*
    *report-doc-strings*
    *report-func-as-arg-arity-mismatch*
    *report-constant-expressions-in-do*
    *report-bad-variable-names*
    *report-built-in-functions-used-as-variables*
    *report-forward-functions*
    *report-sloppy-assoc*
    *report-bloated-arg*
    *report-clobbered-function-return-value*
    *report-boolean-functions-misbehaving*
    *report-repeated-code-fragments*

See lint.scm for more about these switches. You can also extend lint by adding your own code, or adding your functions to lint's tables, or most simply by defining signatures for your functions. snd-lint.scm performs these tasks for Snd. (lint exports its innards via *lint*). lint is not smart about functions defined outside the current file, so *report-undefined-variables* sometimes gets confused. You'll sometimes get a recommendation from lint that is less than helpful; nobody's perfect. If it's actually wrong, and not just wrong-headed, please let me know. Also in lint.scm are html-lint and C-lint. html-lint reads an HTML file looking for Scheme code. If any is found, it runs s7 and then lint over it, reporting troubles. Similarly C-lint reads a C file looking for s7_eval_c_string and running lint over its string.

> After months of intense typing, Insanely declares his labors complete. "Ship it!" says Mr Big, and hands him a million stock options. Meanwhile, in the basement behind an old door with the eldritch sign "eep Ou", in a labyrinth of pounding pipes and fluorescent lights, a forgotten shadow types `(lint "insanely-great.scm")`...