Thank you for your comment

Beau­tiful Racket / explainers

Identifiers

An iden­ti­fier is a name that appears in a program. The meaning of the name is deter­mined by the iden­ti­fier’s binding, which is an asso­ci­a­tion between an iden­ti­fier and some other item—e.g., a specific value, a func­tion, a macro, or another iden­ti­fier.

An iden­ti­fier with a binding is also known as a vari­able:

(define prometheus "I am bound, ergo I am a variable")
prometheus
1
2
(define prometheus "I am bound, ergo I am a variable")
prometheus
copy to clipboard
"I am bound, ergo I am a variable"
1
"I am bound, ergo I am a variable"
copy to clipboard

An iden­ti­fier without a binding is called an unbound iden­ti­fier. A Racket program cannot run unless every iden­ti­fier has a binding, so this is a phrase commonly seen in error messages:

atlas
1
atlas
copy to clipboard
atlas: unbound identifier in module in: atlas
1
atlas: unbound identifier in module in: atlas
copy to clipboard

Naming require­ments & conven­tions

An iden­ti­fier can be written with any Unicode char­ac­ters, except white­space and the following reserved char­ac­ters:

( ) [ ] { } " , ' ` ; # | \
1
( ) [ ] { } " , ' ` ; # | \
copy to clipboard

Numbers can’t be used as iden­ti­fiers either:

(define 42a "value") ; ok, though possibly confusing
(define 42 "value") ; not ok: bad-syntax error
1
2
(define 42a "value") ; ok, though possibly confusing
(define 42 "value")  ; not ok: bad-syntax error
copy to clipboard

By conven­tion, iden­ti­fiers are typi­cally written in lower­case, with hyphens between words:

lowercased
lowercased-with-hyphens
1
2
lowercased
lowercased-with-hyphens
copy to clipboard

Naming styles common in other languages are not syntac­ti­cally wrong in Racket, but they’re also not idiomatic:

Capitalized ; no
lowercased_with_underscores ; no
Title-Cased ; no
CamelCased ; hell no
1
2
3
4
Capitalized ; no
lowercased_with_underscores ; no
Title-Cased ; no
CamelCased ; hell no
copy to clipboard

Certain classes of func­tions have recom­mended naming conven­tions. See func­tions.

Making bind­ings

Iden­ti­fier bind­ings can be created three ways:

  1. With an explicit binding form like define, let, or lambda. These bind­ings will over­ride (aka shadow) existing bind­ings outside the form:

    (define x 42)
    x ; 42

    (define y 100)
    (let ([y 42])
      (+ x y)) ; 84 (not 142)

    (define z 1000)
    (define f (lambda ([z 42]) (+ x y z)))
    (f) ; 184 (not 1142)
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    (define x 42)
x ; 42

(define y 100)
(let ([y 42])
  (+ x y)) ; 84 (not 142)

(define z 1000)
(define f (lambda ([z 42]) (+ x y z)))
(f) ; 184 (not 1142)
    copy to clipboard

  2. By importing bind­ings from another module with a form like require. Bind­ings within the module will shadow imported bind­ings:

    (module mod1 br
      (define foo "zim")
      (provide foo))
    (require (submod "." mod1))

    foo ; "zim"

    (module mod2 br
      (define bar "zam")
      (provide bar))
    (require (submod "." mod2))

    (define bar "bang")
    bar ; "bang" (not "zam")
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
    (module mod1 br
  (define foo "zim")
  (provide foo))
(require (submod "." mod1))

foo ; "zim"

(module mod2 br
  (define bar "zam")
  (provide bar))
(require (submod "." mod2))

(define bar "bang")
bar ; "bang" (not "zam")
    copy to clipboard

    But an error will arise if two imported modules provide bind­ings for the same iden­ti­fier:

    (module mod1 br
      (define foo "zim")
      (provide foo))
    (require (submod "." mod1))

    (module mod2 br
      (define foo "zam")
      (provide foo))
    (require (submod "." mod2))
    ;; error: identifier `foo` imported twice
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    (module mod1 br
  (define foo "zim")
  (provide foo))
(require (submod "." mod1))

(module mod2 br
  (define foo "zam")
  (provide foo))
(require (submod "." mod2))
;; error: identifier `foo` imported twice
    copy to clipboard

  3. By making new bind­ings with a macro. Macros can attach bind­ings to existing iden­ti­fiers, or create a new iden­ti­fier and its binding.

    (define-macro (define-as-42 ID)
      #'(define ID 42))
    (define-as-42 foo)
    foo ; 42

    (define-macro (define-bar-as-42)
      (with-pattern ([BAR-ID (datum->syntax caller-stx 'bar)])
        #'(define BAR-ID 42)))
    (define-bar-as-42)
    bar ; 42
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    (define-macro (define-as-42 ID)
  #'(define ID 42))
(define-as-42 foo)
foo ; 42

(define-macro (define-bar-as-42)
  (with-pattern ([BAR-ID (datum->syntax caller-stx 'bar)])
    #'(define BAR-ID 42)))
(define-bar-as-42)
bar ; 42
    copy to clipboard

Scope

Every iden­ti­fier binding has a scope that deter­mines where in the program the binding is visible. Outside that scope, the binding won’t work. The scope of a binding depends on how & where the iden­ti­fier is intro­duced. The three most common options:

  1. Expres­sion scope: a binding created within another expres­sion is only visible within that expres­sion (and it can be shad­owed within that expres­sion):

    (define (get-bar)
      (define bar 42)
      (let ([bar 92])
        bar))

    (get-bar) ; 92
    bar ; error: unbound identifier
    1
2
3
4
5
6
7
    (define (get-bar)
  (define bar 42)
  (let ([bar 92])
    bar))

(get-bar) ; 92
bar ; error: unbound identifier
    copy to clipboard

  2. Module scope: a binding created at the top level of a module with define, or imported with require, is visible throughout the module (though it can be shad­owed else­where).  + True, a module is itself an expres­sion. But module scope is not a special case of expres­sion scope, because bind­ings can only cross module bound­aries when explic­itly requested (for instance, with require).

    (define top 40)

    (define (f1)
      (let ()
        (let ()
          (let ()
            top))))
    (f1) ; 40

    (define (f2)
      (let ([top 41])
        (let ([top 42])
          (let ([top 43])
            top))))
    (f2) ; 43
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
    (define top 40)

(define (f1)
  (let ()
    (let ()
      (let ()
        top))))
(f1) ; 40

(define (f2)
  (let ([top 41])
    (let ([top 42])
      (let ([top 43])
        top))))
(f2) ; 43
    copy to clipboard

  3. Macro scope: if a macro creates an iden­ti­fier and its binding (i.e., a vari­able) it’s only visible to other code created by the same macro. Caution: this is a trap for the unwary. In the example below, even though the macro emits (define foo 42)—which sure looks like it will create a vari­able foo that has module scope—it doesn’t. That vari­able is not visible to code outside the macro:

    (define-macro (make-macro-scoped-foo)
      #'(begin
          (define foo 42)
          (* foo 2)))

    (make-macro-scoped-foo) ; 84
    foo ; unbound identifier (!)
    1
2
3
4
5
6
7
    (define-macro (make-macro-scoped-foo)
  #'(begin
      (define foo 42)
      (* foo 2)))

(make-macro-scoped-foo) ; 84
foo ; unbound identifier (!)
    copy to clipboard

    But if a macro adds a binding to an existing iden­ti­fier—for instance, one passed as an argu­ment to the macro—that binding does not have macro scope. Instead, it adopts the scope of the iden­ti­fier:

    (define-macro (bind-existing-identifier ID)
      #'(begin
          (define ID 42)
          (* ID 2)))

    (bind-existing-identifier foo) ; 84
    foo ; 42 (and `foo` has module scope)

    (let ()
      (bind-existing-identifier bar)
      bar) ; 42 (and `bar` has expression scope)
    bar ; unbound identifier
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    (define-macro (bind-existing-identifier ID)
  #'(begin
      (define ID 42)
      (* ID 2)))

(bind-existing-identifier foo) ; 84
foo ; 42 (and `foo` has module scope)

(let ()
  (bind-existing-identifier bar)
  bar) ; 42 (and `bar` has expression scope)
bar ; unbound identifier
    copy to clipboard

    For more about this behavior—which is a feature, not a bug—see hygiene.

Further

← prev next →