|
|
# Identifiers and Binding
|
|
|
|
|
|
The context of an expression determines the meaning of identifiers that
|
|
|
appear in the expression. In particular, starting a module with the
|
|
|
language `racket`, as in
|
|
|
|
|
|
`#lang` `racket`
|
|
|
|
|
|
means that, within the module, the identifiers described in this guide
|
|
|
start with the meaning described here: `cons` refers to the function
|
|
|
that creates a pair, `car` refers to the function that extracts the
|
|
|
first element of a pair, and so on.
|
|
|
|
|
|
> +\[missing\] introduces the syntax of identifiers.
|
|
|
|
|
|
Forms like `define`, `lambda`, and `let` associate a meaning with one or
|
|
|
more identifiers; that is, they _bind_ identifiers. The part of the
|
|
|
program for which the binding applies is the _scope_ of the binding. The
|
|
|
set of bindings in effect for a given expression is the expression’s
|
|
|
_environment_.
|
|
|
|
|
|
For example, in
|
|
|
|
|
|
```racket
|
|
|
#lang racket
|
|
|
|
|
|
(define f
|
|
|
(lambda (x)
|
|
|
(let ([y 5])
|
|
|
(+ x y))))
|
|
|
|
|
|
(f 10)
|
|
|
```
|
|
|
|
|
|
the `define` is a binding of `f`, the `lambda` has a binding for `x`,
|
|
|
and the `let` has a binding for `y`. The scope of the binding for `f` is
|
|
|
the entire module; the scope of the `x` binding is `(let ([y 5]) (+ x
|
|
|
y))`; and the scope of the `y` binding is just `(+ x y)`. The
|
|
|
environment of `(+ x y)` includes bindings for `y`, `x`, and `f`, as
|
|
|
well as everything in `racket`.
|
|
|
|
|
|
A module-level `define` can bind only identifiers that are not already
|
|
|
defined or `require`d into the module. A local `define` or other binding
|
|
|
forms, however, can give a new local binding for an identifier that
|
|
|
already has a binding; such a binding _shadows_ the existing binding.
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
(define f
|
|
|
(lambda (append)
|
|
|
(define cons (append "ugly" "confusing"))
|
|
|
(let ([append 'this-was])
|
|
|
(list append cons))))
|
|
|
|
|
|
> (f list)
|
|
|
'(this-was ("ugly" "confusing"))
|
|
|
```
|
|
|
|
|
|
Similarly, a module-level `define` can shadow a binding from the
|
|
|
module’s language. For example, `(define cons 1)` in a `racket` module
|
|
|
shadows the `cons` that is provided by `racket`. Intentionally shadowing
|
|
|
a language binding is rarely a good idea—especially for widely used
|
|
|
bindings like `cons`—but shadowing relieves a programmer from having to
|
|
|
avoid every obscure binding that is provided by a language.
|
|
|
|
|
|
Even identifiers like `define` and `lambda` get their meanings from
|
|
|
bindings, though they have _transformer_ bindings \(which means that
|
|
|
they indicate syntactic forms\) instead of value bindings. Since
|
|
|
`define` has a transformer binding, the identifier `define` cannot be
|
|
|
used by itself to get a value. However, the normal binding for `define`
|
|
|
can be shadowed.
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
> define
|
|
|
eval:1:0: define: bad syntax
|
|
|
in: define
|
|
|
> (let ([define 5]) define)
|
|
|
5
|
|
|
```
|
|
|
|
|
|
Again, shadowing standard bindings in this way is rarely a good idea,
|
|
|
but the possibility is an inherent part of Racket’s flexibility.
|