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

 

#!
.bat
.zo
3m
A Customer-Manager Component
A Dictionary
A Parameteric (Simple) Stack
A Queue
aborts
Abstract Contracts using #:exists and #:∃
accessor
Adding Collections
Adding Contracts to Signatures
Adding Contracts to Units
Additional Examples
Alternation
An Extended Example
And More
any and any/c
apply 函数
Argument and Result Dependencies
arms
assertions
Assignment and Redefinition
attached
available
backreference
Backreferences
Backtracking
backtracking
Basic Assertions
benchmarking
blocking
bracketed character class
Breaking an Iteration
Buffered Asynchronous Channels
Building New Contracts
Building Your Own Synchronization Patterns
Bytes, Characters, and Encodings
call-by-reference
CGC
Channels
character class
Characters and Character Classes
Checking Properties of Data Structures
Checking State Changes
Class Contracts
Classes and Objects
cloister
Cloisters
closures
Clustering
Clusters
code inspectors
collection
Command-Line Tools
Command-Line Tools and Your Editor of Choice
Compilation and Configuration: raco
Compile and Run-Time Phases
Compile-Time Instantiation
components
composable continuations
concurrency
Concurrency and Synchronization
conservative garbage collector
constructor
constructor guard
continuation
Continuations
Contract boundaries and define/contract
contract combinator
Contract Messages with “???”
Contract Struct Properties
Contract Violations
Contracts
Contracts and Boundaries
Contracts and eq?
Contracts for case-lambda
Contracts for Units
Contracts on Functions in General
Contracts on Higher-order Functions
Contracts on Structures
Contracts: A Thorough Example
Controlling the Scope of External Names
Copying and Update
Creating and Installing Namespaces
Creating Languages
Creating Stand-Alone Executables
CS
current continuation
current namespace
Datatypes and Serialization
Declaration versus Instantiation
Default Ports
default prompt tag
define-syntax and syntax-rules
define-syntax-rule
Defining new #lang Languages
Defining Recursive Contracts
delimited continuations
Designating a #lang Language
destructing bind
Dialects of Racket and Scheme
disarm
Dissecting a contract error message
Distributed Places
domain
dye pack
Emacs
eval
exception
Exceptions
Exceptions and Control
Exists Contracts and Predicates
expands
Experimenting with Contracts and Modules
Experimenting with Nested Contract Boundaries
Exports: provide
Extended Example: Call-by-Reference Functions
External Class Contracts
Final, Augment, and Inner
First-Class Units
Fixed but Statically Unknown Arities
fixnum
Fixnum and Flonum Optimizations
flat named contracts
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-Call Optimizations
functional update
futures
General Macro Transformers
General Phase Levels
generational garbage collector
Gotchas
Graphics and GUIs
greedy
Guarantees for a Specific Value
Guarantees for All Values
I/O Patterns
identifier macro
Identifier Macros
identifier syntax object
Implicit Form Bindings
Imports: require
incremental garbage-collection
index pairs
Inherit and Super in Traits
Initialization Arguments
Input and Output
Installing a Language
instantiated
instantiates
instantiation
Interactive evaluation
Interactive Mode
Interfaces
Internal and External Names
Internal Class Contracts
invoked
Invoking Units
Iteration Performance
Iterations and Comprehensions
JIT
just-in-time
Keyword Arguments
Lazy Visits via Available Modules
letrec Performance
Lexical Scope
Library Collections
link
Linking Units
Lisp/Scheme 经验者注意
Load Mode
Local Scopes
Lookahead
Lookbehind
Looking Ahead and Behind
macro
macro pattern variables
macro transformer
Macro Transformer Procedures
macro-generating macro
Macro-Generating Macros
Macros
Main and Test Submodules
main submodule
major collections
Major Modes
Manipulating Namespaces
Matching Regexp Patterns
Matching Sequences
Memory Management
meta-compile phase level
metacharacters
metasequences
Methods
minor collections
Minor Modes
mixin
Mixing Patterns and Expressions: syntax-case
Mixing set! and contract-out
Mixins
Mixins and Interfaces
Module Basics
Module Instantiations and Visits
module language
Module Languages
Module Mode
module path
Module Paths
Module Syntax
Module-Handling Configuration
Modules
Modules and Macros
Modules and Performance
More Libraries
More Rackets
More Structure Type Options
multi-line mode
Multiple Result Values
Multiple-Valued Sequences
Mutation and Performance
mutator
namespace
Namespaces
Namespaces and Modules
non-capturing
Non-capturing Clusters
non-greedy
opaque
Opaque versus Transparent Structure Types
Optional Arguments
Optional Keyword Arguments
Organizing Modules
package
Packages and Collections
Packages specific to Evil Mode
Parallelism
parallelism
Parallelism with Futures
Parallelism with Places
Parameterized Mixins
PATH
Pattern Matching
pattern variables
pattern-based macro
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 class
POSIX character classes
predicate
prefab
Prefab Structure Types
Programmer-Defined Datatypes
prompt
prompt tag
Prompts and Aborts
property
protected
Protected Exports
protected method
Quantifiers
quantifiers
R5RS
R6RS
Racket 指南
Racket 精要
racket/exists
range
Reachability and Garbage Collection
Reader Extensions
Reading and Writing Racket Data
readtable
Readtables
Reducing Garbage Collection Pauses
Reflection and Dynamic Evaluation
regexp
Regular Expression Performance
Regular Expressions
REPL
Rest Arguments
Rolling Your Own Contracts
run-time configuration
Running and Creating Executables
Running racket and gracket
S-expression
Scripting Evaluation and Using load
Scripts
Semaphores
Sequence Constructors
serialization
set! Transformers
Sharing Data and Code Across Namespaces
Shell completion
signatures
Signatures and Units
Simple Contracts on Functions
Simple Structure Types: struct
Some Frequently Used Character Classes
Source Locations
Source-Handling Configuration
speed
Standards
Structure Comparisons
Structure Subtypes
structure type descriptor
Structure Type Generativity
Styles of ->
subcluster
Sublime Text
submatch
submodule
Submodules
subpattern
Synchronizable Events and sync
synchronized
Syntax Objects
syntax objects
Syntax Taints
tainted
Tainting Modes
Taints and Code Inspectors
Teaching
template
template phase level
text string
The #lang Shorthand
The Bytecode and Just-in-Time (JIT) Compilers
The mixin Form
The module Form
The trait Form
The Web Server
Thread Mailboxes
Threads
threads
Traits
Traits as Sets of Mixins
transformer
transformer binding
transparent
Unchecked, Unsafe Operations
unit versus module
Units
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
Vim
visit
Visiting Modules
void 与 undefined
Weak Boxes and Testing
Whole-module Signatures and Units
Windows Batch Files
With all the Bells and Whistles
with-syntax and generate-temporaries
Writing Regexp Patterns
与 Racket 进行交互
从零开始构造列表迭代
作用在前:begin
作用在后:begin0
关于代码缩进的提示
关键字
关键字
关键字参数
内建数据类型
内部定义
再谈函数调用
准引述:quasiquote
函数简写
函数调用(过程应用)
函数调用(过程应用)
函数(过程):lambda
列表
列表与 Racket 语法
列表,迭代与递归
创建可执行文件
剩余参数
动态绑定:parameterize
匿名函数与 lambda
参数量敏感的函数:case-lambda
参量
可变序对
向量
向量
命名的 let
声明关键字参数
声明剩余参数
声明可选参数
复数
多值与 define-values
多值绑定:let-valueslet*-valuesletrec-values
多重赋值:set!-values
字符
字符
字符串
字符串(Unicode)
字节
字节与字节串
字节串
定义
定义与交互
定义区
定义:define
实数
quote 简写为 '
尾递归
尾部
局部绑定
局部绑定与 defineletlet*
展开器
布尔值
平行绑定:let
序列
序对
序对、列表和 Racket 语法
序对与列表
引述:quote'
按条件作用:whenunless
散列表
散列表
数值
数值
整数
有理数
条件分支
条件分支与 ifandorcond
柯里化函数简写
标识符
标识符与绑定
欢迎来到 Racket
求值顺序与参数量
quote引述序对和符号
盒子
盒子
符号
符号
简单分支:if
简单分派:case
简单的值
简单的定义与表达式
组合测试:andor
表达式与定义
记法
读取器
赋值使用准则
赋值:set!
递归与迭代
递归绑定:letrec
遮蔽
链式测试:cond
隐式 begin
顺序绑定:let*
预定义的列表循环