Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://docs.racket-lang.org/reference/let.html below:

3.9 Local Binding: let, let*, letrec, ...

Local Binding in The Racket Guide introduces local binding.

(let ([id val-expr] ...) body ...+)

(let proc-id ([id init-expr] ...) body ...+)

The first form evaluates the

s left-to-right, creates a new

for each

, and places the values into the locations. It then evaluates the

s, in which the

s are bound. The last

expression is in tail position with respect to the

form. The

s must be distinct according to

.

Examples:

> (let ([x 5]) x)

5

'(5 2)

The second form, usually known as named let, evaluates the init-exprs; the resulting values become arguments in an application of a procedure (lambda (id ...) body ...+), where proc-id is bound within the bodys to the procedure itself.

Example:

(let* ([id val-expr] ...) body ...+)

Like

, but evaluates the

s one by one, creating a

for each

as soon as the value is available. The

s are bound in the remaining

s as well as the

s, and the

s need not be distinct; later bindings shadow earlier bindings.

Example:

(letrec ([id val-expr] ...) body ...+)

Like

, including left-to-right evaluation of the

s, but the

for all

s are created first, all

s are bound in all

s as well as the

s, and each

is initialized immediately after the corresponding

is evaluated. The

s must be distinct according to

.

Referencing or assigning to an id before its initialization raises exn:fail:contract:variable. If an id (i.e., the binding instance or id) has an 'undefined-error-name syntax property whose value is a symbol, the symbol is used as the name of the variable for error reporting, instead of the symbolic form of id.

Example:

Changed in version 6.0.1.2 of package base: Changed reference or assignment of an uninitialized id to an error.

Like

, except that each

must produce as many values as corresponding

s, otherwise the

exception is raised. A separate

is created for each

, all of which are bound in the

s.

Example:

Like

, except that each

must produce as many values as corresponding

s. A separate

is created for each

, all of which are bound in the later

s and in the

s.

Example:

Like

, except that each

must produce as many values as corresponding

s. A separate

is created for each

, all of which are bound in all

s and in the

s.

Example:

Creates a transformer binding (see Transformer Bindings) of each id with the value of trans-expr, which is an expression at phase level 1 relative to the surrounding context. (See Identifiers, Binding, and Scopes for information on phase levels.)

The evaluation of each trans-expr is parameterized to set current-namespace to a namespace that shares bindings and variables with the namespace being used to expand the let-syntax form, except that its base phase is one greater.

Each id is bound in the bodys, and not in other trans-exprs.

Like let-syntax, except that each id is also bound within all trans-exprs.

Like let-syntax, but each trans-expr must produce as many values as corresponding ids, each of which is bound to the corresponding value.

Like let-syntax, except that each id is also bound within all trans-exprs.

The letrec-syntaxes+values form is the core form for local compile-time bindings, since forms like letrec-syntax and internal-definition contexts expand to it. In a fully expanded expression (see Fully Expanded Programs), the trans-id bindings are discarded and the form reduces to a combination of letrec-values or let-values.

For variables bound by letrec-syntaxes+values, the location-creation rules differ slightly from letrec-values. The [(val-id ...) val-expr] binding clauses are partitioned into minimal sets of clauses that satisfy the following rule: if a clause has a val-id binding that is referenced (in a full expansion) by the val-expr of an earlier clause, the two clauses and all in between are in the same set. If a set consists of a single clause whose val-expr does not refer to any of the clause’s val-ids, then locations for the val-ids are created after the val-expr is evaluated. Otherwise, locations for all val-ids in a set are created just before the first val-expr in the set is evaluated. For the purposes of forming sets, a (quote-syntax datum #:local) form counts as a reference to all bindings in the letrec-syntaxes+values form

The end result of the location-creation rules is that scoping and evaluation order are the same as for letrec-values, but the compiler has more freedom to optimize away location creation. The rules also correspond to a nesting of let-values and letrec-values, which is how letrec-syntaxes+values for a fully-expanded expression.

See also local, which supports local bindings with define, define-syntax, and more.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4