Thank you for your comment

Beau­tiful Racket / explainers

Parameters

A para­meter is a special kind of func­tion that approx­i­mates the behavior of a global vari­able. An ordi­nary Racket value can be mutated with set!:

(define x 42)
(set! x 43)
x ; 43
1
2
3
(define x 42)
(set! x 43)
x ; 43
copy to clipboard

But there are some restric­tions. For instance, we can’t mutate vari­ables across a module boundary:

(module mod br
  (provide x)
  (define x 42))

(require 'mod)
x ; 42
(set! x 43) ; error: cannot mutate x
1
2
3
4
5
6
7
(module mod br
  (provide x)
  (define x 42))

(require 'mod)
x ; 42
(set! x 43) ; error: cannot mutate x
copy to clipboard

Para­me­ters remove these restric­tions. A para­meter is created with make-parameter and an initial value. After that, calling the para­meter without an argu­ment retrieves its current value. Passing the para­meter an argu­ment changes its value:

(module mod br
  (provide x)
  (define x (make-parameter 42)))

(require 'mod)
(x) ; 42
(x 43)
(x) ; 43
1
2
3
4
5
6
7
8
(module mod br
  (provide x)
  (define x (make-parameter 42)))

(require 'mod)
(x) ; 42
(x 43)
(x) ; 43
copy to clipboard

Para­me­ters can be mutated within the scope of an expres­sion by wrap­ping it with parameterize, which consists of a let-like list of binding pairs, with each para­meter name on the left, and the value on the right:

(define current-list (make-parameter '(0 1 2 3 4)))
(displayln (car (current-list))) ; 0
(parameterize ([current-list '(a b c d e)])
  (displayln (car (current-list)))) ; a
(displayln (car (current-list))) ; 0
1
2
3
4
5
(define current-list (make-parameter '(0 1 2 3 4)))
(displayln (car (current-list))) ; 0
(parameterize ([current-list '(a b c d e)])
  (displayln (car (current-list)))) ; a
(displayln (car (current-list))) ; 0
copy to clipboard

Here, parameterize changes the value of current-list only for the nested subex­pres­sions. After the parameterize exits, current-list auto­mat­i­cally reverts to its previous value.

As usual in Racket, parameterize recog­nizes rele­vant para­me­ters not just by their name, but by their binding. In the example below, the param and fun modules both define a para­meter called x. But the parameterize refers to the x para­meter bound in param, so the other is unchanged:

(module param br
  (provide x)
  (define x (make-parameter 42)))

(module fun br
  (provide f)
  (define x (make-parameter 42))
  (define (f) (x)))

(require 'param 'fun)

(parameterize ([x 101])
  (println (x)) ; 101
  (println (f))) ; 42
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
(module param br
  (provide x)
  (define x (make-parameter 42)))

(module fun br
  (provide f)
  (define x (make-parameter 42))
  (define (f) (x)))

(require 'param 'fun)

(parameterize ([x 101])
  (println (x)) ; 101
  (println (f))) ; 42
copy to clipboard

If we want this para­me­ter­i­za­tion to work as intended, then the fun submodule has to import the para­meter binding from param as well:

(module param br
  (provide x)
  (define x (make-parameter 42)))

(module fun br
  (provide f)
  (require (submod ".." param))
  (define (f) (x)))

(require 'param 'fun)

(parameterize ([x 101])
  (println (x)) ; 101
  (println (f))) ; 101
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
(module param br
  (provide x)
  (define x (make-parameter 42)))

(module fun br
  (provide f)
  (require (submod ".." param))
  (define (f) (x)))

(require 'param 'fun)

(parameterize ([x 101])
  (println (x)) ; 101
  (println (f))) ; 101
copy to clipboard

Further

Syntax para­me­ters

Syntax para­me­ters are anal­o­gous to ordi­nary para­me­ters. Whereas ordi­nary para­me­ters dynam­i­cally rebind values to iden­ti­fiers at run time, syntax para­me­ters dynam­i­cally rebind macros to iden­ti­fiers at compile time.

A syntax para­meter is intro­duced with define-syntax-parameter and then rebound with syntax-parameterize. The value of a syntax para­meter is, like all macros, a func­tion that takes one syntax object as input and returns another syntax object:

(require racket/stxparam)

(module param br
  (require racket/stxparam)
  (provide x)
  (define-syntax-parameter x (λ (stx) #'42)))

(module fun br
  (provide f)
  (require (submod ".." param))
  (define f x))

(require 'param 'fun)

(syntax-parameterize ([x (λ (stx) #'101)])
  (println x) ; 101
  (println f)) ; 42
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
(require racket/stxparam)

(module param br
  (require racket/stxparam)
  (provide x)
  (define-syntax-parameter x (λ (stx) #'42)))

(module fun br
  (provide f)
  (require (submod ".." param))
  (define f x))

(require 'param 'fun)

(syntax-parameterize ([x (λ (stx) #'101)])
  (println x) ; 101
  (println f)) ; 42
copy to clipboard

Note that x eval­u­ates to 101 (because it’s rebound by syntax-parameterize). But why isn’t f affected? Because syntax-parameterize oper­ates at compile time. When the fun module is imported, the code (define f x) is rewritten as (define f 42) by syntax-para­meter substi­tu­tion. Thus the later syntax-parameterize can’t alter it.

Syntax para­me­ters are useful for intro­ducing iden­ti­fiers within the body of a form. These are some­times known as anaphoric iden­ti­fiers. For instance, below is a macro called begin/return that returns the value passed to the iden­ti­fier called return:

(require racket/stxparam)
(define-syntax-parameter return (λ (stx) #''default))

(define-macro (begin/return . BODY)
  (with-syntax ([CC (generate-temporary)])
    #'(let/cc CC
        (displayln (format "CC = ~a" 'CC))
        (syntax-parameterize ([return
                               (make-rename-transformer #'CC)])
          . BODY))))

(return 2) ; 'default
(begin/return ; CC = [randomish id]
  1
  (return 2)
  3) ; 2
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
(require racket/stxparam)
(define-syntax-parameter return (λ (stx) #''default))

(define-macro (begin/return . BODY)
  (with-syntax ([CC (generate-temporary)])
    #'(let/cc CC
        (displayln (format "CC = ~a" 'CC))
        (syntax-parameterize ([return
                               (make-rename-transformer #'CC)])
          . BODY))))

(return 2) ; 'default
(begin/return ; CC = [randomish id]
  1
  (return 2)
  3) ; 2
copy to clipboard

Under the hood, return is a syntax para­meter. Outside the begin/return, this syntax para­meter expands to its default value. But within begin/return, syntax-parameterize uses make-rename-transformer to make return an alias for CC (which in turn has a randomish iden­ti­fier made by generate-temporary). Thus, even though the name of CC will change on recom­pile, we can still capture this name and bind it to return throughout the syntax repre­sented by BODY.

Syntax para­me­ters vs. unhy­gienic iden­ti­fiers

Syntax para­me­ters overlap with unhy­gienic iden­ti­fiers (see hygiene), but tend to be better behaved. For instance, if we imple­ment return as an unhy­gienic iden­ti­fier, the return only has meaning within begin/return, and produces an unbound-iden­ti­fier error outside:

(define-macro (begin/return . BODY)
  (with-syntax ([CC (generate-temporary)]
                [RETURN (datum->syntax caller-stx 'return)])
    #'(let/cc CC
        (displayln (format "CC = ~a" 'CC))
        (let-syntax ([RETURN (make-rename-transformer #'CC)])
          . BODY))))

(return 2) ; error: unbound identifier
(begin/return ; CC = g1
  1
  (return 2)
  3) ; 2
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
(define-macro (begin/return . BODY)
  (with-syntax ([CC (generate-temporary)]
                [RETURN (datum->syntax caller-stx 'return)])
    #'(let/cc CC
        (displayln (format "CC = ~a" 'CC))
        (let-syntax ([RETURN (make-rename-transformer #'CC)])
          . BODY))))

(return 2) ; error: unbound identifier
(begin/return ; CC = g1
  1
  (return 2)
  3) ; 2
copy to clipboard

In essence, define-syntax-parameter creates a “dummy” binding for return that allows the source to compile, and then syntax-parameterize rebinds it to some­thing useful later on.

One disad­van­tage of syntax para­me­ters is their names and quan­tity must be known in advance. So while they work well for keywordish iden­ti­fiers like return, they wouldn’t work for vari­ables in BASIC, because we can’t know in advance how many vari­ables will exist, or what their names will be.

Further

← prev next →