2.19.4 Specification

The dynamic environment is composed of two parts: the local dynamic environment and the global dynamic environment. The global dynamic environment is used to lookup parameter objects that can’t be found in the local dynamic environment. When parameter objects are created, their initial binding is put in the global dynamic environment (by mutation). The local dynamic environment is only extended by the parameterize form.

Parameter objects are created with the make-parameter procedure which takes one or two arguments. The second argument is a one argument conversion procedure. If only one argument is passed to make-parameter the identity function is used as a conversion procedure. The global dynamic environment is updated to associate the parameter object to a new cell. The initial content of the cell is the result of applying the conversion procedure to the first argument of make-parameter.

A parameter object is a procedure which accepts zero or one argument. The cell bound to a particular parameter object in the dynamic environment is accessed by calling the parameter object. When no argument is passed, the content of the cell is returned. When one argument is passed the content of the cell is updated with the result of applying the parameter object’s conversion procedure to the argument.

The parameterize special form, when given a parameter object and a value, binds for the dynamic extent of its body the parameter object to a new cell. The initial content of the cell is the result of applying the parameter object’s conversion procedure to the value. The parameterize special form behaves analogously to let when binding more than one parameter object (that is the order of evaluation is unspecified and the new bindings are only visible in the body of the parameterize special form).

Note that the conversion procedure can be used for guaranteeing the type of the parameter object’s binding and/or to perform some conversion of the value.

Because it is possible to implement the R5RS procedures current-input-port and current-output-port as parameter objects and this offers added functionnality, it is required by this SRFI that they be implemented as parameter objects created with make-parameter.

Function: make-parameter init [converter]

Returns a new parameter object which is bound in the global dynamic environment to a cell containing the value returned by the call (converter init). If the conversion procedure converter is not specified the identity function is used instead.

The parameter object is a procedure which accepts zero or one argument. When it is called with no argument, the content of the cell bound to this parameter object in the current dynamic environment is returned. When it is called with one argument, the content of the cell bound to this parameter object in the current dynamic environment is set to the result of the call (converter arg), where arg is the argument passed to the parameter object, and an unspecified value is returned.

(define radix
  (make-parameter 10))

(define write-shared
  (make-parameter #f
    (lambda (x)
      (if (boolean? x)
          x
        (error "only booleans are accepted by write-shared")))))

(radix)           =>  10
(radix 2)
(radix)           =>  2
(write-shared 0)  gives an error

(define prompt
  (make-parameter 123
    (lambda (x)
      (if (string? x)
          x
        (with-output-to-string (lambda () (write x)))))))

(prompt)       =>  "123"
(prompt ">")
(prompt)       =>  ">"

Syntax: parameterize ((expr1 expr2) ...) body)

The expressions expr1 and expr2 are evaluated in an unspecified order. The value of the expr1 expressions must be parameter objects. For each expr1 expression and in an unspecified order, the local dynamic environment is extended with a binding of the parameter object expr1 to a new cell whose content is the result of the call (converter val), where val is the value of expr2 and converter is the conversion procedure of the parameter object.

The resulting dynamic environment is then used for the evaluation of body (which refers to the R5RS grammar nonterminal of that name). The result(s) of the parameterize form are the result(s) of the body.

With reference to thte example above:

(radix)
=>  2

(parameterize ([radix 16])
  (radix))
=>  16

(radix)
=>  2

(define (f n)
  (number->string n (radix)))

(f 10)
=>  "1010"

(parameterize ([radix 8])
  (f 10))
=>  "12"

(parameterize ([radix 8]
               [prompt (f 10)])
  (prompt))
=>  "1010"