► |  | The Racket Reference

1 | Language Model
2 | Syntactic Forms
3 | Datatypes
4 | Structures
5 | Classes and Objects
6 | Units
7 | Contracts
8 | Pattern Matching
9 | Control Flow
10 | Concurrency and Parallelism
11 | Macros
12 | Input and Output
13 | Reflection and Security
14 | Operating System
15 | Memory Management
16 | Unsafe Operations
17 | Running Racket
| Bibliography
| Index

▼ | 2 | Syntactic Forms

2.1 | Modules: module, module*, ...
2.2 | Importing and Exporting: require and provide
2.3 | Literals: quote and #%datum
2.4 | Expression Wrapper: #%expression
2.5 | Variable References and #%top
2.6 | Locations: #%variable-reference
2.7 | Procedure Applications and #%app
2.8 | Procedure Expressions: lambda and case-lambda
2.9 | Local Binding: let, let*, letrec, ...
2.10 | Local Definitions: local
2.11 | Constructing Graphs: shared
2.12 | Conditionals: if, cond, and, and or
2.13 | Dispatch: case
2.14 | Definitions: define, define-syntax, ...
2.15 | Sequencing: begin, begin0, and begin-for-syntax
2.16 | Guarded Evaluation: when and unless
2.17 | Assignment: set! and set!-values
2.18 | Iterations and Comprehensions: for, for/ list, ...
2.19 | Continuation Marks: with-continuation-mark
2.20 | Quasiquoting: quasiquote, unquote, and unquote-splicing
2.21 | Syntax Quoting: quote-syntax
2.22 | Interaction Wrapper: #%top-interaction
2.23 | Blocks: block
2.24 | Internal-Definition Limiting: #%stratified-body
2.25 | Performance Hints: begin-encourage-inline
2.26 | Importing Modules Lazily: lazy-require

On this page:

lazy-require

top ← prev up next →

#### 2.26`` Importing Modules Lazily: lazy-require

(require racket/lazy-require)

The bindings documented in this section are provided by the racket/lazy-require library, not racket/base or racket.

> > syntax

> > (lazy-require [module-path (fun-import ...)] ...)

> fun-import |  | = |  | fun-id
> |  | | |  | (orig-fun-id fun-id)

Defines each fun-id as a function that, when called, dynamically requires the export named orig-fun-id from the module specified by module-path and calls it with the same arguments. If orig-fun-id is not given, it defaults to fun-id.

If the enclosing relative phase level is not 0, then module-path is also placed in a submodule (with a use of define-runtime-module-path-index at phase level 0 within the submodule). Introduced submodules have the names lazy-require-n-m, where n is a phase-level number and m is a number.

When the use of a lazily-required function triggers module loading, register-external-module declares a potential compilation dependency (in case the function is used in the process of compiling a module).

Examples:

> > (lazy-require
> [racket/list (partition)])

> > (partition even? '(1 2 3 4 5))

> '(2 4)
> '(1 3 5)

> > (module hello racket/base
> (provide hello)
> (printf "starting hello server\n")
> (define (hello) (printf "hello!\n")))

> > (lazy-require
> ['hello ([hello greet])])

> > (greet)

> starting hello server
> hello!

top ← prev up next →