SRFI-259 based parameter implementation Peter McGoron 07 Nov 2026 16:14 UTC

This is an implementation of R7RS parameters with a corresponding
parameter? predicate. It uses SRFI 259 for the corresponding parameter
object.

SRFI 259 is a better way to implement parameters, as they don’t require
special procedure arguments like the usual implementation. In
particular, this implementation could be extended to allow for multiple
value parameters, using multiple value boxes. However, for this example
implementation, I kept it simple.

I tested this on bleeding-edge Gauche. It should also work in CHICKEN 6,
but I’d have to compile the file for the test script to work, and I
don’t want to set that up right now.

-- Peter McGoron

;;;; parameterize-with-predicate.sld

(define-library (parameterize-with-predicate)
   (import (scheme base) (scheme case-lambda) (srfi 259))
   (export parameterize make-parameter parameter?)
   (begin
     (define-procedure-tag %make-parameter parameter? %get-parmaeter)
     (define make-parameter
       (case-lambda
         ((init) (make-parameter init values))
         ((init converter)
          (letrec ((data (vector (converter init) converter))
                   (func (%make-parameter
                          data
                          (lambda () (vector-ref data 0)))))
            func))))
     (define-syntax parameterize
       (syntax-rules ()
         ((_ ((parameter value) ...) body ...)
          (parameterize "loop" () ((parameter value) ...) (body ...)))
         ((_ "loop" (acc ...)
                    ((parameter value) rest ...)
                    body)
          (_ "loop" ((parameter value evaled-param box cvrt old-value
new-value) acc ...)
                    (rest ...)
                    body))
         ((_ "loop" ((parameter value evaled-param box cvrt old-value
new-value) ...) () (body ...))
          (let ((evaled-param parameter) ...)
            (unless (parameter? evaled-param)
              (error "Not a parameter" evaled-param)) ...
            (let ((box (%get-parameter evaled-param)) ...)
              (let ((old-value (vector-ref box 0)) ...)
                (let ((cvrt (vector-ref box 1)) ...)
                  (let ((new-value (cvrt value)) ...)
                    (dynamic-wind
                     (lambda ()
                       (vector-set! box 0 new-value) ...)
                     (lambda () body ...)
                     (lambda ()
                       (vector-set! box 0 old-value) ...))))))))))))

;;;; test.scm

(import (scheme base)
         (prefix (parameterize-with-predicate) new:)
         (srfi 64))

(test-begin "parameterize with predicate")

(define p (new:make-parameter 10 (lambda (x) (+ x 10))))
(define f (new:make-parameter "adsf"))

(test-eqv "(p) = 20" 20 (p))
(test-assert "p is parameter?" (new:parameter? p))
(test-assert "f is parameter?" (new:parameter? f))
(new:parameterize ((p 100)
                    (f "qwerty"))
   (test-eqv "(p) = 110" 110 (p))
   (test-equal "(f) = \"qwerty\"" "qwerty" (f)))

(test-end "parameterize with predicate")