Index🔗

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

 

"main.rkt"
#!
.bat
.ps1
3m
A Customer-Manager Component
A Dictionary
A Note to Readers with Lisp/Scheme Experience
A Parameteric (Simple) Stack
A Queue
Abbreviating quote with '
abort
Abstract Contracts using #:exists and #:∃
accessor
Adding Collections
Adding Contracts to Signatures
Adding Contracts to Units
Additional Examples
Alternation
An Aside on Indenting Code
An Extended Example
And More
Anonymous Functions with lambda
any and any/c
Arity-Sensitive Functions: case-lambda
Assignment and Redefinition
Assignment: set!
attach
available
Backreferences
Backtracking
Basic Assertions
BC
benchmarking
blocking
Booleans
box
Boxes
Breaking an Iteration
Buffered Asynchronous Channels
Building New Contracts
Building Your Own Synchronization Patterns
Built-In Datatypes
Bytecode, Machine Code, and Just-in-Time (JIT) Compilers
Bytes and Byte Strings
Bytes, Characters, and Encodings
case-lambda 的契约
CGC
Chaining Tests: cond
Channels
Characters
Characters and Character Classes
Class Contracts
Classes and Objects
Cloisters
Clusters
Code inspector
Code Inspectors for Trusted and Untrusted Code
Combining Tests: and and or
Command-Line Tools
Compilation and Configuration: raco
Compile and Run-Time Phases
Compile-Time Instantiation
complex
concurrency
Concurrency and Synchronization
Conditionals
Conditionals with if, and, or, and cond
constructor
constructor guard
continuation
Continuations
contract combinator
Contract Struct Properties
Contract Violations
Contract 边界与 define/contract
Contracts
Contracts and Boundaries
Contracts for Units
Contracts on Functions in General
Contracts on Structures
Contracts 与 eq?
Contracts: A Thorough Example
Controlling the Scope of External Names
Copying and Update
coroutine thread
Creating and Installing Namespaces
Creating Executables
Creating Languages
Creating Stand-Alone Executables
CS
current namespace
Curried Function Shorthand
Datatypes and Serialization
Declaration versus Instantiation
Declaring a Rest Argument
Declaring Keyword Arguments
Declaring Optional Arguments
Default Ports
define-syntax and syntax-rules
define-syntax-rule
Defining new #lang Languages
Definitions
Definitions and Interactions
Definitions: define
Designating a #lang Language
Dialects of Racket and Scheme
Distributed Places
domain
Dynamic Binding: parameterize
Effects After: begin0
Effects Before: begin
Effects If...: when and unless
Emacs 编辑器
eval
Evaluation Order and Arity
Evil Mode 专用包
Exceptions
Exceptions and Control
Exists Contract 与谓词
Experimenting with Contracts and Modules
Experimenting with Nested Contract Boundaries
Exports: provide
Expressions and Definitions
Extended Example: Call-by-Reference Functions
External Class Contracts
Final, Augment, and Inner
First-Class Units
fixnum
Fixnum and Flonum Optimizations
flat named contract
flonum
for and for*
for/and and for/or
for/first and for/last
for/fold and for*/fold
for/list and for*/list
for/vector and for*/vector
Foreign Pointers
Function Calls (Procedure Applications)
Function Calls, Again
Function Shorthand
Function-Call Optimizations
functional update
Functions (Procedures): lambda
futures
futures visualizer
General Macro Transformers
General Phase Levels
Gotchas
Graphics and GUIs
Guidelines for Using Assignment
hash table
Hash Tables
I/O Patterns
Identifier Macros
identifier syntax object
Identifiers
Identifiers and Binding
Implicit Form Bindings
Imports: require
Inherit and Super in Traits
Initialization Arguments
Input and Output
Installing a Language
instantiated
instantiates
instantiation
integer
Interacting with Racket
Interactive evaluation
Interactive Mode
Interfaces
Internal and External Names
Internal Class Contracts
Internal Definitions
Invoking Units
Iteration Performance
Iterations and Comprehensions
JIT
keyword
Keyword Arguments
Keywords
Lazy Visits via Available Modules
letrec Performance
Lexical Scope
Library Collections
Linking Units
list
List Iteration from Scratch
Lists and Racket Syntax
Lists, Iteration, and Recursion
Load Mode
Local Binding
Local Binding with define, let, and let*
Local Scopes
Lookahead
Lookbehind
Looking Ahead and Behind
macro
macro transformer
Macro Transformer Procedures
Macro-Generating Macros
Macros
Main and Test Submodules
main 子模块
Manipulating Namespaces
Matching Regexp Patterns
Matching Sequences
Memory Management
meta-compile phase level
Methods
mixin
Mixing Patterns and Expressions: syntax-case
Mixins and Interfaces
Module Basics
Module Instantiations and Visits
module language
Module Languages
Module Mode
module path
Module Paths
Module References Within a Collection
Module Syntax
Module-Handling Configuration
Modules
Modules and Macros
Modules and Performance
More Libraries
More Rackets
More Structure Type Options
Multiple Values and define-values
Multiple Values: let-values, let*-values, letrec-values
Multiple Values: set!-values
Multiple-Valued Sequences
mutable pair
Mutation and Performance
mutator
Named let
namespace
Namespaces
Namespaces and Modules
Non-capturing Clusters
Notation
number
Numbers
opaque
Opaque versus Transparent Structure Types
Optional Arguments
Optional 关键字参数
Organizing Modules
Packages and Collections
pair
Pairs and Lists
Pairs, Lists, and Racket Syntax
Parallel Binding: let
Parallel Threads
Parallelism
parallelism
Parallelism with Futures
Parallelism with Places
parameter
Parameterized Mixins
Pattern Matching
Pattern-Based Macros
Performance
Performance in DrRacket
phase
phase level
phase level -1
phase level 2
Phases and Bindings
Phases and Modules
place
place channel
port
POSIX character classes
POSIX 字符类
Predefined List Loops
predicate
prefab
Prefab Structure Types
Programmer-Defined Datatypes
prompt
prompt tag
Prompts and Aborts
property
protected
Protected Exports
protected method
Quantifiers
Quasiquoting: quasiquote and ‘
Quoting Pairs and Symbols with quote
Quoting: quote and ’
R5RS
R6RS
Racket Essentials
Racket Virtual Machine Implementations
range
rational
Reachability and Garbage Collection
Reader Extensions
Reading and Writing Racket Data
readtable
Readtables
real
Recursion versus Iteration
Recursive Binding: letrec
Reducing Garbage Collection Pauses
Reflection and Dynamic Evaluation
regexp
Regular Expression Performance
Regular Expressions
REPL
REPL
rest 参数
run-time configuration
Running and Creating Executables
Running racket and gracket
S-expression
Scribble 支持
Scripting Evaluation and Using load
Scripts
Semaphores
Sequence Constructors
Sequencing
Sequential Binding: let*
set! Transformers
Sharing Data and Code Across Namespaces
Shell completion
Signatures and Units
Simple Branching: if
Simple Contracts on Functions
Simple Definitions and Expressions
Simple Dispatch: case
Simple Structure Types: struct
Simple Values
Some Frequently Used Character Classes
Source Locations
Source-Handling Configuration
speed
Standards
Strings (Unicode)
Structure Comparisons
Structure Subtypes
structure type descriptor
Structure Type Generativity
Styles of ->
Sublime Text 编辑器
Submodules
Symbol
Symbols
Synchronizable Events and sync
synchronized
Syntax Objects
syntax objects
Tail Recursion
Tainted Syntax
Teaching
template phase level
The #lang Shorthand
The apply Function
The mixin Form
The module Form
The Racket Guide
The trait Form
The Web Server
thread
Thread Mailboxes
Threads
Traits as Sets of Mixins
transformer
transformer binding
transparent
Unchecked, Unsafe Operations
Unit
unit versus module
Units (Components)
Unix Scripts
Using #lang reader
Using #lang s-exp
Using #lang s-exp syntax/module-reader
Using define/contract and ->
Using Foreign Libraries
Varieties of Ports
vector
Vectors
Vim 编辑器
visit
Visiting Modules
Visual Studio Code 编辑器
Void and Undefined
Weak Boxes and Testing
Welcome to Racket
Whole-module Signatures and Units
Windows Batch Files
With all the Bells and Whistles
with-syntax and generate-temporaries
Writing Regexp Patterns
主要模式
保守垃圾回收器
修饰区
元字符
元序列
关键字参数
分代垃圾回收器
分组
剖析 contract 错误消息
剩余参数
包
包含 “???” 的 Contract 消息
即时
参数与结果之间的依赖关系
反向引用
可变参数
可组合 continuation
命令行工具与你选择的编辑器
回溯
固定但静态未知的元数
增强的 Racket 支持
增量垃圾回收
多行模式
多返回值
大型回收
子分组
子匹配
子模块
子模式
字符
字符串
字符类
字节
字节串
宏模式变量
定义区
定义递归 Contract
对所有值的保证
对特定值的保证
小型回收
尾部位置
展开器
带污染的
并行线程
并行线程池
序列化
异常
当前 continuation
按引用传递
文本字符串
断言
方括号 字符类
旧版 Vim
有界 continuation
杂项
标识符宏
检查数据结构的属性
检查状态变更
模式变量
模式宏
模板
次要模式
注释
混合使用 set! 与 contract-out
生成宏的宏
签名
索引对
组件
结构化编辑
缩进
自定义 Contract
解构绑定
读取器
调用
贪婪
遮蔽
量词
链接
闭包
隐式 begin
集合
非捕获
非贪婪
高亮
高阶函数上的 Contract
默认 prompt tag