Racket 레퍼런스 색인

Racket 레퍼런스 색인 (Index)

Racket 레퍼런스 문서 전체에서 등장하는 식별자, 구문 키워드, 심볼, 주제를 알파벳순으로 모은 색인이에요. 각 항목은 원문 그대로의 이름과 해당 문서로 가는 링크를 담고 있어요.

출처: Racket Reference

본문

색인 (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


A

  • abort
  • abort-current-continuation
  • abort/cc
  • abs
  • absent
  • absolute-path?
  • abstract
  • accessor
  • acos
  • add-between
  • add1
  • Additional Byte String Functions
  • Additional Control Operators
  • Additional Custom-Output Support
  • Additional Exception Functions
  • Additional Hash Table Functions
  • Additional Higher-Order Functions
  • Additional Keyword Functions
  • Additional List Functions and Synonyms
  • Additional Logging Functions
  • Additional Matching Forms
  • Additional Operating System Functions
  • Additional Promise Kinds
  • Additional provide Forms
  • Additional require Forms
  • Additional Sequence Constructors and Functions
  • Additional Sequence Operations
  • Additional String Functions
  • Additional Structure Utilities
  • Additional Symbol Functions
  • Additional Syntactic Constraints
  • Additional Vector Functions
  • alarm-evt
  • all-defined-out
  • all-from-out
  • always-evt
  • and
  • and
  • and/c
  • andmap
  • angle
  • any
  • any/c
  • app
  • append
  • append*
  • append-map
  • applicable structure
  • apply
  • argmax
  • argmin
  • Arithmetic
  • arithmetic-shift
  • arity-at-least (struct)
  • arity-at-least-value
  • arity-at-least?
  • arity-includes?
  • arity=?
  • asin
  • assert-unreachable
  • assf
  • assignment transformers
  • Assignment: set! and set!-values
  • assoc
  • association list
  • assq
  • assv
  • assw
  • async-channel-get
  • async-channel-put
  • async-channel-put-evt
  • async-channel-try-get
  • async-channel/c
  • async-channel?
  • asynchronous channel
  • atan
  • atexit
  • Attaching Contracts to Values
  • augment
  • augment*
  • augment-final
  • augment-final*
  • augmenting
  • augride
  • augride*
  • authentic
  • automatic fields
  • available

B

  • banner
  • base environment
  • base phase
  • Basic Pretty-Print Options
  • BC
  • BC Compilation Modes
  • begin
  • begin-encourage-inline
  • begin-for-syntax
  • begin0
  • between/c
  • binding
  • binding space
  • binds
  • Bitwise Operations
  • bitwise-and
  • bitwise-bit-field
  • bitwise-bit-set?
  • bitwise-first-bit-set
  • bitwise-ior
  • bitwise-not
  • bitwise-xor
  • black-box
  • Black-Box Procedure
  • Blame Objects
  • blame objects
  • blame-add-context
  • blame-add-missing-party
  • blame-context
  • blame-contract
  • blame-missing-party?
  • blame-negative
  • blame-original?
  • blame-positive
  • blame-replace-negative
  • blame-replaced-negative?
  • blame-source
  • blame-swap
  • blame-swapped?
  • blame-update
  • blame-value
  • blame?
  • block
  • block-device-type-bits
  • blocking
  • Blocks: block
  • Boolean Aliases
  • boolean=?
  • boolean?
  • Booleans
  • booleans
  • bound
  • bound-identifier=?
  • box
  • box
  • box
  • box-cas!
  • box-immutable
  • box-immutable/c
  • box/c
  • box?
  • Boxes
  • break
  • break-enabled
  • break-evaluator
  • break-parameterization?
  • break-thread
  • Breaks
  • Buffered Asynchronous Channels
  • build-chaperone-contract-property
  • build-collapsible-contract-property
  • build-compound-type-name
  • build-contract-property
  • build-flat-contract-property
  • build-list
  • build-path
  • build-path/convention-type
  • build-string
  • build-vector
  • Building New Contract Combinators
  • Built-in Exception Types
  • bulk bindings
  • Byte and String Input
  • Byte and String Output
  • byte converter
  • byte string
  • Byte String Comparisons
  • Byte String Constructors, Selectors, and Mutators
  • byte strings, parsing
  • byte strings, immutable
  • byte strings, concatenate
  • Byte Strings
  • byte-pregexp
  • byte-pregexp?
  • byte-ready?
  • byte-regexp
  • byte-regexp?
  • byte?
  • bytes
  • bytes
  • Bytes to Bytes Encoding Conversion
  • Bytes to/from Characters, Decoding and Encoding
  • bytes->immutable-bytes
  • bytes->list
  • bytes->path
  • bytes->path-element
  • bytes->string/latin-1
  • bytes->string/locale
  • bytes->string/utf-8
  • bytes-append
  • bytes-append*
  • bytes-close-converter
  • bytes-convert
  • bytes-convert-end
  • bytes-converter?
  • bytes-copy
  • bytes-copy!
  • bytes-environment-variable-name?
  • bytes-fill!
  • bytes-join
  • bytes-length
  • bytes-no-nuls?
  • bytes-open-converter
  • bytes-ref
  • bytes-set!
  • bytes-utf-8-index
  • bytes-utf-8-length
  • bytes-utf-8-ref
  • bytes<?
  • bytes=?
  • bytes>?
  • bytes?

C

  • caaaar
  • caaadr
  • caaar
  • caadar
  • caaddr
  • caadr
  • caar
  • cadaar
  • cadadr
  • cadar
  • caddar
  • cadddr
  • caddr
  • cadr
  • call-by-value
  • call-in-continuation
  • call-in-nested-thread
  • call-in-sandbox-context
  • call-with-atomic-output-file
  • call-with-break-parameterization
  • call-with-composable-continuation
  • call-with-continuation-barrier
  • call-with-continuation-prompt
  • call-with-current-continuation
  • call-with-custodian-shutdown
  • call-with-deep-time-limit
  • call-with-default-reading-parameterization
  • call-with-escape-continuation
  • call-with-exception-handler
  • call-with-file-lock/timeout
  • call-with-immediate-continuation-mark
  • call-with-input-bytes
  • call-with-input-file
  • call-with-input-file*
  • call-with-input-string
  • call-with-killing-threads
  • call-with-limits
  • call-with-output-bytes
  • call-with-output-file
  • call-with-output-file*
  • call-with-output-string
  • call-with-parameterization
  • call-with-semaphore
  • call-with-semaphore/enable-break
  • call-with-trusted-sandbox-configuration
  • call-with-values
  • call/cc
  • call/comp
  • call/ec
  • call/prompt
  • car
  • cartesian-product
  • case
  • case->
  • case->m
  • case-insensitive
  • case-lambda
  • case-sensitivity
  • case-λ
  • case/eq
  • case/equal
  • case/equal-always
  • case/eqv
  • catch
  • cdaaar
  • cdaadr
  • cdaar
  • cdadar
  • cdaddr
  • cdadr
  • cdar
  • cddaar
  • cddadr
  • cddar
  • cdddar
  • cddddr
  • cdddr
  • cddr
  • cdr
  • ceiling
  • CGC
  • Chaining Reader Language
  • channel
  • channel-get
  • channel-put
  • channel-put-evt
  • channel-put-evt?
  • channel-try-get
  • channel/c
  • channel?
  • Channels
  • chaperone
  • Chaperone Constructors
  • chaperone contract property
  • Chaperone contracts
  • chaperone-async-channel
  • chaperone-box
  • chaperone-channel
  • chaperone-continuation-mark-key
  • chaperone-contract-property?
  • chaperone-contract?
  • chaperone-evt
  • chaperone-generics
  • chaperone-hash
  • chaperone-hash-set
  • chaperone-mutable-treelist
  • chaperone-of?
  • chaperone-procedure
  • chaperone-procedure*
  • chaperone-prompt-tag
  • chaperone-struct
  • chaperone-struct-type
  • chaperone-struct-unsafe-undefined
  • chaperone-treelist
  • chaperone-vector
  • chaperone-vector*
  • chaperone?
  • char->integer
  • char-alphabetic?
  • char-blank?
  • char-ci<=?
  • char-ci<?
  • char-ci=?
  • char-ci>=?
  • char-ci>?
  • char-downcase
  • char-extended-pictographic?
  • char-foldcase
  • char-general-category
  • char-grapheme-break-property
  • char-grapheme-step
  • char-graphic?
  • char-in
  • char-iso-control?
  • char-lower-case?
  • char-numeric?
  • char-punctuation?
  • char-ready?
  • char-symbolic?
  • char-title-case?
  • char-titlecase
  • char-upcase
  • char-upper-case?
  • char-utf-8-length
  • char-whitespace?
  • char<=?
  • char<?
  • char=?
  • char>=?
  • char>?
  • char?
  • Character Comparisons
  • Character Conversions
  • Character Grapheme-Cluster Streaming
  • character-device-type-bits
  • Characters
  • Characters
  • Characters and Scalar Values
  • check-duplicate-identifier
  • check-duplicates
  • check-not-unsafe-undefined
  • check-not-unsafe-undefined/assign
  • checked-procedure-check-and-extract
  • checked-struct-info?
  • chmod
  • choice-evt
  • class
  • class
  • class*
  • class->interface
  • class-field-accessor
  • class-field-mutator
  • class-info
  • class-seal
  • class-unseal
  • class/c
  • class/derived
  • class?
  • Classes and Objects
  • Classifications
  • cleanse
  • cleanse-path
  • close-input-port
  • close-output-port
  • Code Inspectors
  • code inspectors
  • code point
  • coerce-chaperone-contract
  • coerce-chaperone-contracts
  • coerce-contract
  • coerce-contract/f
  • coerce-contracts
  • coerce-flat-contract
  • coerce-flat-contracts
  • collapsible contract property
  • Collapsible Contracts
  • Collapsible contracts
  • collapsible-contract-continuation-mark-key
  • collapsible-contract-property?
  • collapsible-contract?
  • collapsible-count-property (struct)
  • collapsible-count-property-count
  • collapsible-count-property-prev
  • collapsible-count-property?
  • collapsible-guard
  • collapsible-ho/c (struct)
  • collapsible-ho/c-latest-blame
  • collapsible-ho/c-latest-ctc
  • collapsible-ho/c-missing-party
  • collapsible-ho/c?
  • collapsible-leaf/c (struct)
  • collapsible-leaf/c-blame-list
  • collapsible-leaf/c-contract-list
  • collapsible-leaf/c-missing-party-list
  • collapsible-leaf/c-proj-list
  • collapsible-leaf/c?
  • collapsible-property (struct)
  • collapsible-property-c-c
  • collapsible-property-neg-party
  • collapsible-property-ref
  • collapsible-property?
  • collapsible-wrapper-property (struct)
  • collapsible-wrapper-property-checking-wrapper
  • collapsible-wrapper-property?
  • collect-garbage
  • Collection Links
  • Collection links files
  • Collection Paths and Parameters
  • Collection Search Configuration
  • collection-file-path
  • collection-path
  • collections
  • column locations
  • column numbers
  • combinations
  • combine-in
  • combine-out
  • combine-output
  • Combining Hash Codes
  • Command Line
  • command-line
  • Command-Line Parsing
  • committed
  • Compilation
  • compilation handler
  • Compilation Modes
  • compile
  • compile-allow-set!-undefined
  • compile-context-preservation-enabled
  • compile-enforce-module-constants
  • compile-linklet
  • compile-syntax
  • compile-target-machine?
  • compiled
  • Compiled Modules and References
  • compiled-expression-add-target-machine
  • compiled-expression-recompile
  • compiled-expression-summarize-target-machine
  • compiled-expression?
  • compiled-load handler
  • compiled-module-expression?
  • complete
  • complete-path?
  • completion value
  • Complex Numbers
  • complex numbers
  • complex/c
  • complex?
  • composable continuation
  • compose
  • compose1
  • compound-unit
  • compound-unit/infer
  • Concurrency and Parallelism
  • cond
  • Conditionals: if, cond, and, and or
  • Configuration options
  • configure-expand
  • configure-runtime
  • Configuring Default Handling
  • conjoin
  • conjugate
  • cons
  • cons
  • cons/c
  • cons/dc
  • cons?
  • const
  • const*
  • Constructing Graphs: shared
  • constructor
  • context
  • continuation
  • continuation barrier
  • continuation frames
  • Continuation Frames and Marks
  • Continuation Marks
  • continuation marks
  • Continuation Marks: with-continuation-mark
  • continuation-mark-key/c
  • continuation-mark-key?
  • continuation-mark-set->context
  • continuation-mark-set->iterator
  • continuation-mark-set->list
  • continuation-mark-set->list*
  • continuation-mark-set-first
  • continuation-mark-set?
  • continuation-marks
  • continuation-prompt-available?
  • continuation-prompt-tag?
  • continuation?
  • Continuations
  • contract
  • Contract combinators
  • contract property
  • Contract Utilities
  • contract-continuation-mark-key
  • contract-custom-write-property-proc
  • contract-equivalent?
  • contract-exercise
  • contract-first-order
  • contract-first-order-okay-to-give-up?
  • contract-first-order-passes?
  • contract-first-order-try-less-hard
  • contract-in
  • contract-late-neg-projection
  • contract-name
  • contract-out
  • contract-pos/neg-doubling
  • contract-proc
  • contract-projection
  • contract-property?
  • contract-random-generate
  • contract-random-generate-env?
  • contract-random-generate-fail
  • contract-random-generate-fail?
  • contract-random-generate-get-current-environment
  • contract-random-generate-stash
  • contract-random-generate/choose
  • contract-stronger?
  • contract-struct
  • contract-val-first-projection
  • contract?
  • contracted
  • Contracted Dictionaries
  • Contracts
  • Contracts
  • Contracts and Impersonators on Asynchronous Channels
  • Contracts as structs
  • control
  • Control Flow
  • control-at
  • control0
  • control0-at
  • Controlling and Inspecting Compilation
  • convert-relative-module-path
  • convert-stream
  • Converting Values to Strings
  • copy-directory/files
  • copy-file
  • copy-port
  • Copying and Updating Structures
  • Copying Streams
  • core form
  • coroutine thread
  • correlated objects
  • correlated->datum
  • correlated-column
  • correlated-e
  • correlated-line
  • correlated-position
  • correlated-property
  • correlated-property-symbol-keys
  • correlated-source
  • correlated-span
  • correlated?
  • cos
  • cosh
  • count
  • count property
  • Counting Positions, Lines, and Columns
  • Creating and Touching Futures
  • Creating and Using Asynchronous Channels
  • Creating Classes
  • Creating formatted identifiers
  • Creating Interfaces
  • Creating Loggers
  • Creating Objects
  • Creating Ports
  • Creating Structure Types
  • Creating Threads
  • Creating Units
  • cross-phase persistent
  • Cross-Phase Persistent Module Declarations
  • Cross-Phase Persistent Modules
  • crypto-random-bytes
  • Cryptographic Hashing
  • CS
  • CS Compilation Modes
  • cupto
  • current custodian
  • current logger
  • current namespace
  • current plumber
  • current-blame-format
  • current-break-parameterization
  • current-code-inspector
  • current-command-line-arguments
  • current-command-line-arguments
  • current-compile
  • current-compile-realm
  • current-compile-target-machine
  • current-compiled-file-roots
  • current-continuation-marks
  • current-contract-region
  • current-custodian
  • current-date
  • current-directory
  • current-directory-for-user
  • current-drive
  • current-environment-variables
  • current-error-message-adjuster
  • current-error-port
  • current-eval
  • current-evt-pseudo-random-generator
  • current-force-delete-permissions
  • current-future
  • current-gc-milliseconds
  • current-get-interaction-evt
  • current-get-interaction-input-port
  • current-inexact-milliseconds
  • current-inexact-monotonic-milliseconds
  • current-input-port
  • current-inspector
  • current-interaction-info
  • current-library-collection-links
  • current-library-collection-paths
  • current-load
  • current-load-extension
  • current-load-relative-directory
  • current-load/use-compiled
  • current-locale
  • current-logger
  • current-memory-use
  • current-milliseconds
  • current-module-declare-name
  • current-module-declare-source
  • current-module-name-resolver
  • current-module-path-for-load
  • current-namespace
  • current-output-port
  • current-parameterization
  • current-plumber
  • current-prefix-in
  • current-prefix-out
  • current-preserved-thread-cell-values
  • current-print
  • current-process-milliseconds
  • current-prompt-read
  • current-pseudo-random-generator
  • current-read-interaction
  • current-reader-guard
  • current-readtable
  • current-recorded-disappeared-uses
  • current-require-module-path
  • current-seconds
  • current-security-guard
  • current-subprocess-custodian-mode
  • current-subprocess-keep-file-descriptors
  • current-syntax-context
  • current-thread
  • current-thread-group
  • current-thread-initial-stack-size
  • current-trace-notify
  • current-trace-print-args
  • current-trace-print-results
  • current-write-relative-directory
  • curry
  • curryr
  • custodian
  • custodian box
  • custodian-box-value
  • custodian-box?
  • custodian-limit-memory
  • custodian-managed-list
  • custodian-memory-accounting-available?
  • custodian-require-memory
  • custodian-shut-down?
  • custodian-shutdown-all
  • custodian?
  • Custodians
  • Custodians
  • Custom Hash Sets
  • Custom Hash Tables
  • Custom Ports
  • custom ports
  • custom-print-quotable-accessor
  • custom-print-quotable?
  • custom-write-accessor
  • custom-write?
  • Customized Unreachable Reporting
  • Customizing Evaluators

D

  • Data-structure Contracts
  • Datatypes
  • date (struct)
  • Date Utilities
  • date* (struct)
  • date*->seconds
  • date*-nanosecond
  • date*-time-zone-name
  • date*?
  • date->julian/scaliger
  • date->julian/scalinger
  • date->seconds
  • date->string
  • date-day
  • date-display-format
  • date-dst?
  • date-hour
  • date-minute
  • date-month
  • date-second
  • date-time-zone-offset
  • date-week-day
  • date-year
  • date-year-day
  • date?
  • datum
  • datum->correlated
  • datum->syntax
  • datum-intern-literal
  • Debugging
  • declared
  • Declaring Paths Needed at Run Time
  • decompile-linklet
  • Deep time
  • default binding space
  • default method
  • default-continuation-prompt-tag
  • default-global-port-print-handler
  • default-language-readers
  • define
  • define-compound-unit
  • define-compound-unit/infer
  • define-contract-struct
  • define-custom-hash-types
  • define-custom-set-types
  • define-deprecated-alias
  • define-for-syntax
  • define-generics
  • define-inline
  • define-local-member-name
  • define-logger
  • define-match-expander
  • define-member-name
  • define-module-boundary-contract
  • define-namespace-anchor
  • define-opt/c
  • define-provide-syntax
  • define-rename-transformer-parameter
  • define-require-syntax
  • define-runtime-module-path
  • define-runtime-module-path-index
  • define-runtime-path
  • define-runtime-path-list
  • define-runtime-paths
  • define-sequence-syntax
  • define-serializable-class
  • define-serializable-class*
  • define-serializable-struct
  • define-serializable-struct/versions
  • define-signature
  • define-signature-form
  • define-splicing-for-clause-syntax
  • define-struct
  • define-struct/contract
  • define-struct/derived
  • define-syntax
  • define-syntax-parameter
  • define-syntax-rule
  • define-syntaxes
  • define-unit
  • define-unit-binding
  • define-unit-from-context
  • define-unit/contract
  • define-unit/new-import-export
  • define-unit/s
  • define-values
  • define-values-for-export
  • define-values-for-syntax
  • define-values/invoke-unit
  • define-values/invoke-unit/infer
  • define/augment
  • define/augment-final
  • define/augride
  • define/contract
  • define/final-prop
  • define/generic
  • define/match
  • define/overment
  • define/override
  • define/override-final
  • define/private
  • define/public
  • define/public-final
  • define/pubment
  • define/subexpression-pos-prop
  • define/with-syntax
  • Defining Structure Types: struct
  • Definitions: define, define-syntax, ...
  • degrees->radians
  • delay
  • delay/idle
  • delay/name
  • delay/strict
  • delay/sync
  • delay/thread
  • Delayed Evaluation
  • delete-directory
  • delete-directory/files
  • delete-file
  • delimited continuation
  • delimiters
  • Delimiters and Dispatch
  • denominator
  • deprecated
  • deprecated alias transformer
  • Deprecated Alias Transformers
  • Deprecated Aliases
  • deprecated-alias
  • deprecated-alias-target
  • deprecated-alias?
  • Deprecation
  • depth marker
  • derivation requirement
  • derived class
  • Derived Dictionary Methods
  • Deriving New Iteration Forms
  • deserialize
  • deserialize-module-guard
  • Detecting Filesystem Changes
  • dict->list
  • dict-can-functional-set?
  • dict-can-remove-keys?
  • dict-clear
  • dict-clear!
  • dict-copy
  • dict-count
  • dict-empty?
  • dict-for-each
  • dict-has-key?
  • dict-implements/c
  • dict-implements?
  • dict-iter-contract
  • dict-iterate-first
  • dict-iterate-key
  • dict-iterate-next
  • dict-iterate-value
  • dict-key-contract
  • dict-keys
  • dict-map
  • dict-map/copy
  • dict-mutable?
  • dict-ref
  • dict-ref!
  • dict-remove
  • dict-remove!
  • dict-set
  • dict-set!
  • dict-set*
  • dict-set*!
  • dict-update
  • dict-update!
  • dict-value-contract
  • dict-values
  • dict?
  • Dictionaries
  • dictionary
  • Dictionary Predicates and Contracts
  • Dictionary Sequences
  • Directories
  • directory-exists?
  • directory-list
  • directory-type-bits
  • discarded
  • disjoin
  • Dispatch: case
  • display
  • display-lines
  • display-lines-to-file
  • display-to-file
  • displayln
  • division by inexact zero
  • do
  • Do Loops
  • double-flonum?
  • drop
  • drop-common-prefix
  • drop-right
  • dropf
  • dropf-right
  • dump-memory-stats
  • dup-input-port
  • dup-output-port
  • dynamic extension
  • dynamic extent
  • Dynamic Module Access
  • dynamic->*
  • dynamic-enter!
  • dynamic-get-field
  • dynamic-instantiate
  • dynamic-object/c
  • dynamic-place
  • dynamic-place*
  • dynamic-require
  • dynamic-require-for-syntax
  • dynamic-rerequire
  • dynamic-send
  • dynamic-set-field!
  • dynamic-wind

E

  • effects
  • eighth
  • eleventh
  • else
  • empty
  • empty-sequence
  • empty-stream
  • empty-treelist
  • empty?
  • Encodings and Locales
  • engine
  • engine
  • engine-kill
  • engine-result
  • engine-run
  • engine?
  • Engines
  • enter!
  • Entering Modules
  • Environment and Runtime Information
  • environment variable set
  • Environment Variables
  • environment-variables-copy
  • environment-variables-names
  • environment-variables-ref
  • environment-variables-set!
  • environment-variables?
  • eof
  • eof-evt
  • eof-object?
  • ephemeron
  • ephemeron-value
  • ephemeron?
  • Ephemerons
  • eprintf
  • eq-hash-code
  • eq?
  • equal-always-hash-code
  • equal-always-hash-code/recur
  • equal-always-secondary-hash-code
  • equal-always?
  • equal-always?/recur
  • equal-hash-code
  • equal-hash-code/recur
  • equal-secondary-hash-code
  • equal<%>
  • equal?
  • equal?/recur
  • Equality
  • Equality and Hashing
  • eqv-hash-code
  • eqv?
  • error
  • error display handler
  • error escape handler
  • error message convention
  • Error Message Conventions
  • Error reporting
  • error syntax conversion handler
  • error syntax name handler
  • error syntax source-location handler
  • error value conversion handler
  • error-contract->adjusted-string
  • error-display-handler
  • error-escape-handler
  • error-message->adjusted-string
  • error-message-adjuster-key
  • error-module-path->string-handler
  • error-print-context-length
  • error-print-source-location
  • error-print-width
  • error-syntax->name-handler
  • error-syntax->srcloc-handler
  • error-syntax->string-handler
  • error-value->string-handler
  • escape continuation
  • eval
  • eval-jit-enabled
  • eval-linklet
  • eval-syntax
  • Evaluation and Compilation
  • evaluation handler
  • Evaluation Model
  • evaluation order
  • evaluator-alive?
  • even?
  • Events
  • evt/c
  • evt?
  • exact number
  • exact->inexact
  • exact-ceiling
  • exact-floor
  • exact-integer?
  • exact-nonnegative-integer?
  • exact-positive-integer?
  • exact-round
  • exact-truncate
  • exact?
  • except
  • except-in
  • except-out
  • exception handler
  • Exceptions
  • Exceptions
  • Exceptions
  • executable-yield-handler
  • exit
  • exit handler
  • Exit Status
  • exit-handler
  • Exiting
  • exn (struct)
  • exn->string
  • exn-classify-errno
  • exn-continuation-marks
  • exn-message
  • exn:break (struct)
  • exn:break-continuation
  • exn:break:hang-up (struct)
  • exn:break:hang-up?
  • exn:break:terminate (struct)
  • exn:break:terminate?
  • exn:break?
  • exn:fail (struct)
  • exn:fail:contract (struct)
  • exn:fail:contract:arity (struct)
  • exn:fail:contract:arity?
  • exn:fail:contract:blame (struct)
  • exn:fail:contract:blame-object
  • exn:fail:contract:blame?
  • exn:fail:contract:continuation (struct)
  • exn:fail:contract:continuation?
  • exn:fail:contract:divide-by-zero (struct)
  • exn:fail:contract:divide-by-zero?
  • exn:fail:contract:non-fixnum-result (struct)
  • exn:fail:contract:non-fixnum-result?
  • exn:fail:contract:variable (struct)
  • exn:fail:contract:variable-id
  • exn:fail:contract:variable?
  • exn:fail:contract?
  • exn:fail:filesystem (struct)
  • exn:fail:filesystem:errno (struct)
  • exn:fail:filesystem:errno-errno
  • exn:fail:filesystem:errno?
  • exn:fail:filesystem:exists (struct)
  • exn:fail:filesystem:exists?
  • exn:fail:filesystem:missing-module (struct)
  • exn:fail:filesystem:missing-module-path
  • exn:fail:filesystem:missing-module?
  • exn:fail:filesystem:version (struct)
  • exn:fail:filesystem:version?
  • exn:fail:filesystem?
  • exn:fail:network (struct)
  • exn:fail:network:errno (struct)
  • exn:fail:network:errno-errno
  • exn:fail:network:errno?
  • exn:fail:network?
  • exn:fail:object (struct)
  • exn:fail:object?
  • exn:fail:out-of-memory (struct)
  • exn:fail:out-of-memory?
  • exn:fail:read (struct)
  • exn:fail:read-srclocs
  • exn:fail:read:eof (struct)
  • exn:fail:read:eof?
  • exn:fail:read:non-char (struct)
  • exn:fail:read:non-char?
  • exn:fail:read?
  • exn:fail:resource-resource
  • exn:fail:resource?
  • exn:fail:sandbox-terminated-reason
  • exn:fail:sandbox-terminated?
  • exn:fail:support (struct)
  • exn:fail:support?
  • exn:fail:syntax (struct)
  • exn:fail:syntax-exprs
  • exn:fail:syntax:missing-module (struct)
  • exn:fail:syntax:missing-module-path
  • exn:fail:syntax:missing-module?
  • exn:fail:syntax:unbound (struct)
  • exn:fail:syntax:unbound?
  • exn:fail:syntax?
  • exn:fail:unsupported (struct)
  • exn:fail:unsupported?
  • exn:fail:user (struct)
  • exn:fail:user?
  • exn:fail?
  • exn:misc:match?
  • exn:missing-module-accessor
  • exn:missing-module?
  • exn:srclocs-accessor
  • exn:srclocs?
  • exn?
  • exp
  • expand
  • expand
  • expand-export
  • expand-import
  • expand-once
  • expand-syntax
  • expand-syntax-once
  • expand-syntax-to-top-form
  • expand-to-top-form
  • expand-user-path
  • Expanding Top-Level Forms
  • Expansion
  • Expansion (Parsing)
  • Expansion Context
  • Expansion Steps
  • explode-path
  • export (struct)
  • export
  • export-local-id
  • export-mode
  • export-orig-stx
  • export-out-id
  • export-out-sym
  • export-protect?
  • export?
  • expression context
  • Expression Wrapper: #%expression
  • expt
  • extend
  • Extending match
  • Extending the Syntax of Signatures
  • extends
  • extension-load handler
  • externalizable<%>
  • externally lifted
  • extfl*
  • extfl+
  • extfl-
  • extfl->exact
  • extfl->exact-integer
  • extfl->floating-point-bytes
  • extfl->fx
  • extfl->inexact
  • extfl/
  • extfl<
  • extfl<=
  • extfl=
  • extfl>
  • extfl>=
  • extflabs
  • extflacos
  • extflasin
  • extflatan
  • extflceiling
  • extflcos
  • extflexp
  • extflexpt
  • extflfloor
  • extfllog
  • extflmax
  • extflmin
  • extflonum
  • Extflonum Arithmetic
  • Extflonum Byte Strings
  • Extflonum Constants
  • Extflonum Vectors
  • extflonum-available?
  • extflonum?
  • Extflonums
  • extflround
  • extflsin
  • extflsqrt
  • extfltan
  • extfltruncate
  • extflvector
  • extflvector
  • extflvector-copy
  • extflvector-length
  • extflvector-ref
  • extflvector-set!
  • extflvector?
  • Extra Constants and Functions
  • extract-struct-info

F

  • failure procedure
  • failure-cont
  • failure-result/c
  • fallback method
  • false
  • false/c
  • false?
  • fasl->s-exp
  • Fast-Load Serialization
  • fcontrol
  • field
  • Field and Method Access
  • field-bound?
  • field-names
  • Fields
  • Fields
  • fifo-type-bits
  • fifteenth
  • fifth
  • file
  • File Inclusion
  • file modification date and time
  • File Ports
  • file->bytes
  • file->bytes-lines
  • file->lines
  • file->list
  • file->string
  • file->value
  • file-exists?
  • file-name-from-path
  • file-or-directory-identity
  • file-or-directory-modify-seconds
  • file-or-directory-permissions
  • file-or-directory-stat
  • file-or-directory-type
  • file-position
  • file-position*
  • file-size
  • file-stream port
  • file-stream-buffer-mode
  • file-stream-port?
  • file-truncate
  • file-type-bits
  • filename-extension
  • Files
  • Filesystem
  • filesystem change event
  • filesystem-change-evt
  • filesystem-change-evt-cancel
  • filesystem-change-evt-ready?
  • filesystem-change-evt?
  • filesystem-root-list
  • filter
  • filter-map
  • filter-not
  • filter-read-input-port
  • filtered-in
  • filtered-out
  • finalizers
  • find-compiled-file-roots
  • find-executable-path
  • find-files
  • find-library-collection-links
  • find-library-collection-paths
  • find-relative-path
  • find-seconds
  • find-system-path
  • findf
  • first
  • first-or/c
  • fixnum
  • Fixnum Arithmetic
  • Fixnum Range
  • Fixnum Vectors
  • fixnum-for-every-system?
  • fixnum?
  • Fixnums
  • fl*
  • fl+
  • fl-
  • fl->exact-integer
  • fl->fx
  • fl/
  • fl<
  • fl<=
  • fl=
  • fl>
  • fl>=
  • flabs
  • flacos
  • flasin
  • flat contract property
  • Flat contracts
  • flat-contract
  • flat-contract-predicate
  • flat-contract-property?
  • flat-contract-with-explanation
  • flat-contract?
  • flat-murec-contract
  • flat-named-contract
  • flat-rec-contract
  • flatan
  • flatten
  • flbit-field
  • flceiling
  • flcos
  • flexp
  • flexpt
  • flfloor
  • flimag-part
  • fllog
  • flmax
  • flmin
  • floating-point-bytes->extfl
  • floating-point-bytes->real
  • Flonum Arithmetic
  • Flonum Vectors
  • flonum?
  • Flonums
  • flonums
  • floor
  • flrandom
  • flreal-part
  • flround
  • flsin
  • flsingle
  • flsqrt
  • fltan
  • fltruncate
  • flush callbacks
  • flush handle
  • flush-output
  • flvector
  • flvector
  • flvector-copy
  • flvector-length
  • flvector-ref
  • flvector-set!
  • flvector?
  • fold-files
  • foldl
  • foldr
  • for
  • for*
  • for*/and
  • for*/async
  • for*/extflvector
  • for*/first
  • for*/flvector
  • for*/fold
  • for*/fold/derived
  • for*/foldr
  • for*/foldr/derived
  • for*/fxvector
  • for*/hash
  • for*/hashalw
  • for*/hasheq
  • for*/hasheqv
  • for*/last
  • for*/list
  • for*/list/concurrent
  • for*/lists
  • for*/mutable-set
  • for*/mutable-setalw
  • for*/mutable-seteq
  • for*/mutable-seteqv
  • for*/mutable-treelist
  • for*/or
  • for*/product
  • for*/set
  • for*/setalw
  • for*/seteq
  • for*/seteqv
  • for*/stream
  • for*/sum
  • for*/treelist
  • for*/vector
  • for*/weak-set
  • for*/weak-setalw
  • for*/weak-seteq
  • for*/weak-seteqv
  • for-clause-syntax-protect
  • for-each
  • for-label
  • for-meta
  • for-space
  • for-syntax
  • for-template
  • for/and
  • for/async
  • for/extflvector
  • for/first
  • for/flvector
  • for/fold
  • for/fold/derived
  • for/foldr
  • for/foldr/derived
  • for/fxvector
  • for/hash
  • for/hashalw
  • for/hasheq
  • for/hasheqv
  • for/last
  • for/list
  • for/list/concurrent
  • for/lists
  • for/mutable-set
  • for/mutable-setalw
  • for/mutable-seteq
  • for/mutable-seteqv
  • for/mutable-treelist
  • for/or
  • for/product
  • for/set
  • for/setalw
  • for/seteq
  • for/seteqv
  • for/stream
  • for/sum
  • for/treelist
  • for/vector
  • for/weak-set
  • for/weak-setalw
  • for/weak-seteq
  • for/weak-seteqv
  • force
  • form
  • format
  • format-id
  • format-symbol
  • fourteenth
  • fourth
  • fprintf
  • free-identifier=?
  • free-label-identifier=?
  • free-template-identifier=?
  • free-transformer-identifier=?
  • fsemaphore-count
  • fsemaphore-post
  • fsemaphore-try-wait?
  • fsemaphore-wait
  • fsemaphore?
  • Fully Expanded Programs
  • fully-expanded
  • function contract
  • Function Contracts
  • future
  • future
  • Future Performance Logging
  • future semaphore
  • Future Semaphores
  • future?
  • Futures
  • futures-enabled?
  • fx*
  • fx*/wraparound
  • fx+
  • fx+/wraparound
  • fx-
  • fx-/wraparound
  • fx->extfl
  • fx->fl
  • fx<
  • fx<=
  • fx=
  • fx>
  • fx>=
  • fxabs
  • fxand
  • fxior
  • fxlshift
  • fxlshift/wraparound
  • fxmax
  • fxmin
  • fxmodulo
  • fxnot
  • fxpopcount
  • fxpopcount16
  • fxpopcount32
  • fxquotient
  • fxremainder
  • fxrshift
  • fxrshift/logical
  • fxvector
  • fxvector
  • fxvector-copy
  • fxvector-length
  • fxvector-ref
  • fxvector-set!
  • fxvector?
  • fxxor

G

  • Garbage Collection
  • Garbage Collection
  • garbage collection
  • gc-info
  • gcd
  • gen:custom-write
  • gen:dict
  • gen:equal+hash
  • gen:equal-mode+hash
  • gen:set
  • gen:stream
  • generate-member-key
  • generate-temporaries
  • generate-temporary
  • Generating A Unit from Context
  • generator
  • generator
  • generator-state
  • generator?
  • Generators
  • generic
  • generic
  • Generic Dictionary Interface
  • generic instance
  • generic interface
  • Generic Interfaces
  • generic method
  • Generic Numerics
  • Generic Set Interface
  • generic-instance/c
  • generic-set?
  • generic?
  • Generics
  • gensym
  • get-error-output
  • get-field
  • get-impersonator-prop:collapsible
  • get-output
  • get-output-bytes
  • get-output-string
  • get-preference
  • get-uncovered-expressions
  • get-user-custodian
  • get/build-collapsible-late-neg-projection
  • get/build-late-neg-projection
  • get/build-val-first-projection
  • getenv
  • gethostname
  • getpid
  • global port print handler
  • global-port-print-handler
  • gracket
  • GRacket.app
  • GRacket.exe
  • greatest common divisor
  • group-by
  • group-execute-bit
  • group-permission-bits
  • group-read-bit
  • group-write-bit
  • guard-evt
  • Guarded Evaluation: when and unless
  • gui?

H

  • handle-evt
  • handle-evt?
  • Handling Exceptions
  • has-blame?
  • has-contract?
  • has-impersonator-prop:collapsible?
  • hash
  • hash
  • hash
  • hash code
  • hash placeholders
  • hash set
  • Hash Sets
  • hash table
  • Hash Tables
  • hash*
  • hash->linklet-bundle
  • hash->linklet-directory
  • hash->list
  • hash-clear
  • hash-clear!
  • hash-code-combine
  • hash-code-combine*
  • hash-code-combine-unordered
  • hash-code-combine-unordered*
  • hash-copy
  • hash-copy-clear
  • hash-count
  • hash-empty?
  • hash-ephemeron?
  • hash-eq?
  • hash-equal-always?
  • hash-equal?
  • hash-eqv?
  • hash-filter
  • hash-filter-keys
  • hash-filter-values
  • hash-for-each
  • hash-has-key?
  • hash-intersect
  • hash-iterate-first
  • hash-iterate-key
  • hash-iterate-key+value
  • hash-iterate-next
  • hash-iterate-pair
  • hash-iterate-value
  • hash-keys
  • hash-keys-subset?
  • hash-map
  • hash-map/copy
  • hash-placeholder?
  • hash-ref
  • hash-ref!
  • hash-ref-key
  • hash-remove
  • hash-remove!
  • hash-set
  • hash-set!
  • hash-set*
  • hash-set*!
  • hash-strong?
  • hash-table
  • hash-union
  • hash-union!
  • hash-update
  • hash-update!
  • hash-values
  • hash-weak?
  • hash/c
  • hash/dc
  • hash?
  • hashalw
  • hasheq
  • hasheqv
  • help
  • here strings
  • heredoc
  • HOME
  • HOMEDRIVE
  • HOMEPATH
  • Honest Custom Equality

I

  • identifier
  • identifier-binding
  • identifier-binding-portal-syntax
  • identifier-binding-symbol
  • identifier-distinct-binding
  • identifier-label-binding
  • identifier-prune-lexical-context
  • identifier-prune-to-source-module
  • identifier-remove-from-definition-context
  • identifier-template-binding
  • identifier-transformer-binding
  • identifier?
  • Identifiers, Binding, and Scopes
  • identity
  • IEEE floating-point numbers
  • if
  • if/c
  • imag-part
  • Immutable Cyclic Data
  • Immutable Treelists
  • immutable-box?
  • immutable-bytes?
  • immutable-hash?
  • immutable-string?
  • immutable-vector?
  • immutable?
  • impersonate-async-channel
  • impersonate-box
  • impersonate-channel
  • impersonate-continuation-mark-key
  • impersonate-generics
  • impersonate-hash
  • impersonate-hash-set
  • impersonate-mutable-treelist
  • impersonate-procedure
  • impersonate-procedure*
  • impersonate-prompt-tag
  • impersonate-struct
  • impersonate-vector
  • impersonate-vector*
  • impersonator
  • Impersonator Constructors
  • Impersonator contracts
  • Impersonator Properties
  • impersonator properties
  • impersonator property accessor
  • impersonator property descriptor
  • impersonator property predicate
  • impersonator-contract?
  • impersonator-ephemeron
  • impersonator-of?
  • impersonator-prop:application-mark
  • impersonator-prop:blame
  • impersonator-prop:collapsible
  • impersonator-prop:contracted
  • impersonator-property-accessor-procedure?
  • impersonator-property-predicate-procedure?
  • impersonator-property?
  • impersonator?
  • Impersonators and Chaperones
  • implementation?
  • implementation?/c
  • Implementations
  • implemented generic method
  • Implementing Equality for Custom Types
  • implements
  • implicit-made-explicit properties
  • implies
  • import
  • import (struct)
  • import-local-id
  • import-mode
  • import-orig-mode
  • import-orig-stx
  • import-req-mode
  • import-source (struct)
  • import-source-mod-path-stx
  • import-source-mode
  • import-source?
  • import-src-mod-path
  • import-src-sym
  • import?
  • Importing and Exporting: require and provide
  • Importing Modules Lazily: lazy-require
  • in-bytes
  • in-bytes-lines
  • in-combinations
  • in-cycle
  • in-dict
  • in-dict-keys
  • in-dict-pairs
  • in-dict-values
  • in-directory
  • in-ephemeron-hash
  • in-ephemeron-hash-keys
  • in-ephemeron-hash-pairs
  • in-ephemeron-hash-values
  • in-extflvector
  • in-flvector
  • in-fxvector
  • in-generator
  • in-hash
  • in-hash-keys
  • in-hash-pairs
  • in-hash-values
  • in-immutable-hash
  • in-immutable-hash-keys
  • in-immutable-hash-pairs
  • in-immutable-hash-values
  • in-immutable-set
  • in-inclusive-range
  • in-indexed
  • in-input-port-bytes
  • in-input-port-chars
  • in-lines
  • in-list
  • in-mlist
  • in-mutable-hash
  • in-mutable-hash-keys
  • in-mutable-hash-pairs
  • in-mutable-hash-values
  • in-mutable-set
  • in-mutable-treelist
  • in-naturals
  • in-parallel
  • in-parallel-values
  • in-permutations
  • in-port
  • in-powerset
  • in-producer
  • in-range
  • in-rearrangements
  • in-sequences
  • in-set
  • in-slice
  • in-stream
  • in-string
  • in-syntax
  • in-treelist
  • in-value
  • in-values*-sequence
  • in-values-sequence
  • in-vector
  • in-weak-hash
  • in-weak-hash-keys
  • in-weak-hash-pairs
  • in-weak-hash-values
  • in-weak-set
  • include
  • include-at/relative-to
  • include-at/relative-to/reader
  • include/reader
  • inclusive-range
  • index-of
  • index-where
  • indexes-of
  • indexes-where
  • inexact number
  • inexact->exact
  • inexact-real?
  • inexact?
  • Inferred Linking
  • Inferred Value Names
  • infinite-generator
  • infinite?
  • infinity
  • infix
  • Information on Expanded Modules
  • inherit
  • inherit-field
  • inherit/inner
  • inherit/super
  • inheritance
  • Inherited and Superclass Methods
  • init
  • Init Libraries
  • init-depend
  • init-field
  • init-rest
  • Initialization
  • Initialization Variables
  • initiate
  • initiate-sequence
  • inner
  • inode
  • inode
  • inode
  • Input and Output
  • input port
  • input ports, pattern matching
  • input-port-append
  • input-port?
  • inside-edge scope
  • inspect
  • Inspecting Compiler Passes
  • inspector
  • inspector-superior?
  • inspector?
  • instance-data
  • instance-describe-variable!
  • instance-name
  • instance-set-variable-value!
  • instance-unset-variable!
  • instance-variable-names
  • instance-variable-value
  • instance?
  • instanceof/c
  • instantiate
  • instantiate-linklet
  • instantiates
  • instantiation
  • integer->char
  • integer->integer-bytes
  • integer-bytes->integer
  • integer-in
  • integer-length
  • integer-sqrt
  • integer-sqrt/remainder
  • integer?
  • integers
  • Interacting with Evaluators
  • Interaction Configuration
  • interaction event handler
  • interaction port handler
  • Interaction Wrapper: #%top-interaction
  • Interactive Help
  • Interactive Module Loading
  • interface
  • interface
  • interface*
  • interface->method-names
  • interface-extension?
  • interface?
  • Internal and External Names
  • Internal Definitions
  • internal-definition context
  • Internal-Definition Limiting: #%stratified-body
  • internal-definition-context-add-scopes
  • internal-definition-context-apply
  • internal-definition-context-binding-identifiers
  • internal-definition-context-introduce
  • internal-definition-context-seal
  • internal-definition-context-splice-binding-identifier
  • internal-definition-context?
  • interned
  • interned scope
  • Introducing Bindings
  • invariant-assertion
  • invoke-unit
  • invoke-unit/infer
  • invoked
  • Invoking Units
  • IP_MULTICAST_LOOP
  • IP_MULTICAST_TTL
  • IP_TTL
  • is-a?
  • is-a?/c
  • Iteration and Comprehension Forms
  • Iteration Expansion
  • iteration pattern variable
  • Iterations and Comprehensions: for, for/list, ...
  • iterator

J

  • JIT
  • julian/scaliger->string
  • julian/scalinger->string

K

  • Kernel Forms and Functions
  • keyword
  • keyword->immutable-string
  • keyword->string
  • keyword-apply
  • keyword-apply/dict
  • Keyword-Argument Conversion Introspection
  • keyword<?
  • keyword?
  • Keywords
  • Keywords and Arity
  • kill-evaluator
  • kill-thread

L

  • label phase level
  • lambda
  • LANG
  • Language Expand Configuration
  • Language Model
  • Language Run-Time Configuration
  • last
  • last-pair
  • late neg projection
  • lazy
  • Lazy Data-structure Contracts
  • lazy-require
  • lazy-require-syntax
  • LC_ALL
  • LC_TYPE
  • lcm
  • least common multiple
  • Legacy Contracts
  • legacy-match-expander?
  • length
  • let
  • let*
  • let*-values
  • let-syntax
  • let-syntaxes
  • let-values
  • let/cc
  • let/ec
  • letrec
  • letrec-syntax
  • letrec-syntaxes
  • letrec-syntaxes+values
  • letrec-values
  • lexical information
  • lexical scoping
  • lib
  • liberal expansion
  • liberal-define-context?
  • Libraries and Collections
  • library
  • Library Extensions
  • line locations
  • line numbers
  • Line-Output Hook
  • link
  • link-exists?
  • linked
  • Linking Units and Creating Compound Units
  • linklet
  • linklet bundle
  • linklet directory
  • linklet instance
  • linklet-add-target-machine-info
  • linklet-body-reserved-symbol?
  • linklet-bundle->hash
  • linklet-bundle?
  • linklet-directory->hash
  • linklet-directory?
  • linklet-export-variables
  • linklet-import-variables
  • linklet-summarize-target-machine-info
  • linklet?
  • Linklets and the Core Compiler
  • list
  • list
  • list
  • List Filtering
  • List Iteration
  • List Operations
  • List Searching
  • list*
  • list*
  • list*of
  • list->bytes
  • list->mutable-set
  • list->mutable-setalw
  • list->mutable-seteq
  • list->mutable-seteqv
  • list->mutable-treelist
  • list->set
  • list->setalw
  • list->seteq
  • list->seteqv
  • list->string
  • list->treelist
  • list->vector
  • list->weak-set
  • list->weak-setalw
  • list->weak-seteq
  • list->weak-seteqv
  • list-contract?
  • list-no-order
  • list-prefix?
  • list-ref
  • list-rest
  • list-set
  • list-tail
  • list-update
  • list/c
  • list?
  • listen-port-number?
  • listof
  • Literals: quote and #%datum
  • load
  • load handler
  • load-extension
  • load-on-demand-enabled
  • load-relative
  • load-relative-extension
  • load/cd
  • load/use-compiled
  • Loading and Reloading Modules
  • local
  • Local Binding Context
  • local binding context
  • Local Binding with Splicing Body
  • Local Binding: let, let*, letrec, ...
  • local bindings
  • Local Definitions: local
  • local variable
  • local-expand
  • local-expand/capture-lifts
  • local-require
  • local-transformer-expand
  • local-transformer-expand/capture-lifts
  • locale
  • Locale-Specific String Operations
  • locale-string-encoding
  • Locating Paths
  • location
  • Locations: #%variable-reference
  • log
  • log receiver
  • log-all-levels
  • log-debug
  • log-error
  • log-fatal
  • log-info
  • log-level-evt
  • log-level/c
  • log-level?
  • log-max-level
  • log-message
  • log-receiver?
  • log-warning
  • logger
  • logger-name
  • logger?
  • Logging
  • Logging Events
  • logical operators
  • LOGNAME
  • Low-level Contract Boundaries

M

  • Machine Memory Order
  • macro
  • Macro-Introduced Bindings
  • macro-introduction scope
  • Macros
  • magnitude
  • make-arity-at-least
  • make-async-channel
  • make-base-empty-namespace
  • make-base-namespace
  • make-bytes
  • make-channel
  • make-chaperone-contract
  • make-constructor-style-printer
  • make-continuation-mark-key
  • make-continuation-prompt-tag
  • make-contract
  • make-custodian
  • make-custodian-box
  • make-custom-hash
  • make-custom-hash-types
  • make-custom-set-types
  • make-date
  • make-date*
  • make-derived-parameter
  • make-deserialize-info
  • make-directory
  • make-directory*
  • make-do-sequence
  • make-empty-namespace
  • make-environment-variables
  • make-ephemeron
  • make-ephemeron-hash
  • make-ephemeron-hashalw
  • make-ephemeron-hasheq
  • make-ephemeron-hasheqv
  • make-evaluator
  • make-exn
  • make-exn:break
  • make-exn:break:hang-up
  • make-exn:break:terminate
  • make-exn:fail
  • make-exn:fail:contract
  • make-exn:fail:contract:arity
  • make-exn:fail:contract:blame
  • make-exn:fail:contract:continuation
  • make-exn:fail:contract:divide-by-zero
  • make-exn:fail:contract:non-fixnum-result
  • make-exn:fail:contract:variable
  • make-exn:fail:filesystem
  • make-exn:fail:filesystem:errno
  • make-exn:fail:filesystem:exists
  • make-exn:fail:filesystem:missing-module
  • make-exn:fail:filesystem:version
  • make-exn:fail:network
  • make-exn:fail:network:errno
  • make-exn:fail:object
  • make-exn:fail:out-of-memory
  • make-exn:fail:read
  • make-exn:fail:read:eof
  • make-exn:fail:read:non-char
  • make-exn:fail:syntax
  • make-exn:fail:syntax:missing-module
  • make-exn:fail:syntax:unbound
  • make-exn:fail:unsupported
  • make-exn:fail:user
  • make-export
  • make-extflvector
  • make-file-or-directory-link
  • make-flat-contract
  • make-flrectangular
  • make-flvector
  • make-fsemaphore
  • make-fxvector
  • make-generic
  • make-generic-struct-type-property
  • make-handle-get-preference-locked
  • make-hash
  • make-hash-placeholder
  • make-hashalw
  • make-hashalw-placeholder
  • make-hasheq
  • make-hasheq-placeholder
  • make-hasheqv
  • make-hasheqv-placeholder
  • make-immutable-custom-hash
  • make-immutable-hash
  • make-immutable-hashalw
  • make-immutable-hasheq
  • make-immutable-hasheqv
  • make-impersonator-property
  • make-import
  • make-import-source
  • make-input-port
  • make-input-port/read-to-peek
  • make-inspector
  • make-instance
  • make-interned-syntax-introducer
  • make-keyword-procedure
  • make-known-char-range-list
  • make-limited-input-port
  • make-list
  • make-lock-file-name
  • make-log-receiver
  • make-logger
  • make-mixin-contract
  • make-module-evaluator
  • make-mutable-treelist
  • make-none/c
  • make-object
  • make-output-port
  • make-parallel-thread-pool
  • make-parameter
  • make-parameter-rename-transformer
  • make-parent-directory*
  • make-phantom-bytes
  • make-pipe
  • make-pipe-with-specials
  • make-placeholder
  • make-plumber
  • make-polar
  • make-portal-syntax
  • make-prefab-struct
  • make-proj-contract
  • make-provide-pre-transformer
  • make-provide-transformer
  • make-pseudo-random-generator
  • make-reader-graph
  • make-readtable
  • make-rectangular
  • make-rename-transformer
  • make-require-transformer
  • make-resolved-module-path
  • make-security-guard
  • make-semaphore
  • make-serialize-info
  • make-set!-transformer
  • make-shared-bytes
  • make-shared-extflvector
  • make-shared-flvector
  • make-shared-fxvector
  • make-sibling-inspector
  • make-special-comment
  • make-srcloc
  • make-string
  • make-struct-field-accessor
  • make-struct-field-mutator
  • make-struct-info
  • make-struct-type
  • make-struct-type-property
  • make-struct-type-property/generic
  • make-syntax-delta-introducer
  • make-syntax-introducer
  • make-temporary-directory
  • make-temporary-directory*
  • make-temporary-file
  • make-temporary-file*
  • make-tentative-pretty-print-output-port
  • make-thread-cell
  • make-thread-group
  • make-treelist
  • make-vector
  • make-weak-box
  • make-weak-custom-hash
  • make-weak-hash
  • make-weak-hashalw
  • make-weak-hasheq
  • make-weak-hasheqv
  • make-will-executor
  • Managing Ports
  • Manipulating Paths
  • map
  • match
  • match expander
  • match*
  • match*/derived
  • match-define
  • match-define-values
  • match-equality-test
  • match-expander?
  • match-lambda
  • match-lambda*
  • match-lambda**
  • match-let
  • match-let*
  • match-let*-values
  • match-let-values
  • match-letrec
  • match-letrec-values
  • match-λ
  • match-λ*
  • match-λ**
  • match/derived
  • match/values
  • matching-identifiers-in
  • matching-identifiers-out
  • max
  • mcar
  • mcdr
  • mcons
  • mcons
  • member
  • member-name-key
  • member-name-key-hash-code
  • member-name-key=?
  • member-name-key?
  • memf
  • Memory Management
  • memory-order-acquire
  • memory-order-release
  • memq
  • memv
  • memw
  • merge
  • merge-input
  • metavariables
  • Method Definitions
  • method-in-interface?
  • Methods
  • Methods
  • min
  • Miscellaneous
  • Miscellaneous utilities
  • mixin
  • mixin
  • mixin-contract
  • Mixins
  • module
  • module binding
  • Module Cache
  • module context
  • Module Expansion, Phases, and Visits
  • module name resolver
  • Module Names and Loading
  • module path
  • module path index
  • module path resolver
  • Module Redeclarations
  • module registry
  • module*
  • module+
  • module->exports
  • module->imports
  • module->indirect-exports
  • module->language-info
  • module->namespace
  • module->realm
  • module-begin context
  • module-cache-clear!
  • module-compiled-cross-phase-persistent?
  • module-compiled-exports
  • module-compiled-imports
  • module-compiled-indirect-exports
  • module-compiled-language-info
  • module-compiled-name
  • module-compiled-realm
  • module-compiled-submodules
  • module-declared?
  • module-level variable
  • module-path-index-join
  • module-path-index-resolve
  • module-path-index-split
  • module-path-index-submodule
  • module-path-index?
  • module-path?
  • module-predefined?
  • module-provide-protected?
  • modules, re-define
  • modules, imports
  • modules, exports
  • modules
  • Modules and Module-Level Variables
  • Modules: module, module*, ...
  • modulo
  • More File and Directory Utilities
  • More List Grouping
  • More List Iteration
  • More Path Utilities
  • More Port Constructors, Procedures, and Events
  • most-negative-fixnum
  • most-positive-fixnum
  • mpair?
  • multi-in
  • Multiple Return Values
  • Multiple Values
  • multiple values
  • Mutability Predicates
  • mutable list
  • mutable pair
  • Mutable Pair Constructors and Selectors
  • Mutable Pairs and Lists
  • mutable treelist
  • Mutable Treelists
  • mutable-box?
  • mutable-bytes?
  • mutable-hash?
  • mutable-set
  • mutable-setalw
  • mutable-seteq
  • mutable-seteqv
  • mutable-string?
  • mutable-treelist
  • mutable-treelist->list
  • mutable-treelist->vector
  • mutable-treelist-add!
  • mutable-treelist-append!
  • mutable-treelist-cons!
  • mutable-treelist-copy
  • mutable-treelist-delete!
  • mutable-treelist-drop!
  • mutable-treelist-drop-right!
  • mutable-treelist-empty?
  • mutable-treelist-find
  • mutable-treelist-first
  • mutable-treelist-for-each
  • mutable-treelist-insert!
  • mutable-treelist-last
  • mutable-treelist-length
  • mutable-treelist-map!
  • mutable-treelist-member?
  • mutable-treelist-prepend!
  • mutable-treelist-ref
  • mutable-treelist-reverse!
  • mutable-treelist-set!
  • mutable-treelist-snapshot
  • mutable-treelist-sort!
  • mutable-treelist-sublist!
  • mutable-treelist-take!
  • mutable-treelist-take-right!
  • mutable-treelist/c
  • mutable-treelist?
  • mutable-vector?
  • mutator

N

  • nack-guard-evt
  • named let
  • namespace
  • namespace-anchor->empty-namespace
  • namespace-anchor->namespace
  • namespace-anchor?
  • namespace-attach-module
  • namespace-attach-module-declaration
  • namespace-base-phase
  • namespace-call-with-registry-lock
  • namespace-mapped-symbols
  • namespace-module-identifier
  • namespace-module-registry
  • namespace-require
  • namespace-require/constant
  • namespace-require/copy
  • namespace-require/expansion-time
  • namespace-set-variable-value!
  • namespace-symbol->identifier
  • namespace-syntax-introduce
  • namespace-undefine-variable!
  • namespace-unprotect-module
  • namespace-variable-value
  • namespace?
  • Namespaces
  • Namespaces
  • nan?
  • nand
  • natural-number/c
  • natural?
  • negate
  • negative-integer?
  • negative?
  • Nested Contract Boundaries
  • Networking
  • never-evt
  • new
  • new-prompt
  • new-∀/c
  • new-∃/c
  • newline
  • ninth
  • non-empty-listof
  • non-empty-string?
  • non-linear pattern
  • Non-linear Patterns and Ellipses
  • none/c
  • nonnegative-integer?
  • nonpositive-integer?
  • nor
  • normal-case-path
  • normalize-arity
  • normalize-path
  • normalized-arity?
  • not
  • not
  • not-a-number
  • not/c
  • Notation for Documentation
  • Notation for Function Documentation
  • Notation for Module Documentation
  • Notation for Other Documentation
  • Notation for Parameter Documentation
  • Notation for Structure Type Documentation
  • Notation for Syntactic Form Documentation
  • null
  • null?
  • Number Comparison
  • Number Types
  • Number–String Conversions
  • number->string
  • number?
  • numbers, parsing
  • numbers, machine representations
  • numbers, little-endian
  • numbers, floating-point
  • numbers, converting
  • numbers, big-endian
  • Numbers
  • numbers
  • numerator

O

  • Opening a null output port
  • Opening a null input port
  • Object and Class Contracts
  • Object Equality and Hashing
  • Object Identity and Comparisons
  • Object Printing
  • Object Serialization
  • object%
  • Object, Class, and Interface Utilities
  • object->vector
  • object-contract
  • object-info
  • object-interface
  • object-method-arity-includes?
  • object-name
  • object-or-false=?
  • object/c
  • object=-hash-code
  • object=?
  • object?
  • objects
  • Objects and Imperative Update
  • Obligation Information in Check Syntax
  • odd?
  • one-of/c
  • only
  • only-in
  • only-meta-in
  • only-space-in
  • open
  • open-input-bytes
  • open-input-file
  • open-input-nowhere
  • open-input-output-file
  • open-input-string
  • open-output-bytes
  • open-output-file
  • open-output-nowhere
  • open-output-string
  • Operating System
  • opt/c
  • or
  • or
  • or/c
  • order-of-magnitude
  • ormap
  • Other Randomness Utilities
  • other-execute-bit
  • other-permission-bits
  • other-read-bit
  • other-write-bit
  • output port
  • output-port?
  • outside-edge scope
  • overment
  • overment*
  • override
  • override*
  • override-final
  • override-final*
  • overriding

P

  • packages
  • pair
  • Pair Accessor Shorthands
  • Pair Constructors and Selectors
  • pair?
  • Pairs and Lists
  • parallel thread
  • parallel thread pool
  • Parallel Thread Pools
  • parallel-thread-pool-close
  • parallel-thread-pool?
  • parameter procedure
  • parameter-procedure=?
  • parameter/c
  • parameter?
  • parameterization
  • parameterization?
  • parameterize
  • parameterize*
  • parameterize-break
  • Parameters
  • Parameters
  • Parameters
  • Parametric Contracts
  • parametric->/c
  • parent internal-definition context
  • parse
  • parse-command-line
  • parsed
  • Partial Expansion
  • partial expansion
  • partition
  • Passing Keyword Arguments in Dictionaries
  • patched
  • PATH
  • path
  • path element
  • path or string
  • path->bytes
  • path->complete-path
  • path->directory-path
  • path->string
  • path-add-extension
  • path-add-suffix
  • path-convention-type
  • path-element->bytes
  • path-element->string
  • path-element?
  • path-for-some-system?
  • path-get-extension
  • path-has-extension?
  • path-list-string->path-list
  • path-only
  • path-replace-extension
  • path-replace-suffix
  • path-string?
  • path-up
  • path<?
  • path?
  • pathlist-closure
  • Paths
  • Pattern Matching
  • pattern matching
  • pattern variable
  • Pattern variables
  • Pattern-Based Syntax Matching
  • peek-byte
  • peek-byte-or-special
  • peek-bytes
  • peek-bytes!
  • peek-bytes!-evt
  • peek-bytes-avail!
  • peek-bytes-avail!*
  • peek-bytes-avail!-evt
  • peek-bytes-avail!/enable-break
  • peek-bytes-evt
  • peek-char
  • peek-char-or-special
  • peek-string
  • peek-string!
  • peek-string!-evt
  • peek-string-evt
  • peeked
  • peeking-input-port
  • Per-Symbol Special Printing
  • Performance Hints: begin-encourage-inline
  • permutations
  • phantom byte string
  • Phantom Byte Strings
  • phantom-bytes?
  • Phase and Space Utilities
  • phase level
  • phase+space
  • phase+space+
  • phase+space-phase
  • phase+space-shift+
  • phase+space-shift?
  • phase+space-space
  • phase+space?
  • phase?
  • Phases
  • phases
  • pi
  • pi.f
  • pi.t
  • pipe
  • pipe-content-length
  • pipe-port?
  • Pipes
  • place
  • place
  • place channels
  • place descriptor
  • place locations
  • place*
  • place-break
  • place-channel
  • place-channel-get
  • place-channel-put
  • place-channel-put/get
  • place-channel?
  • place-dead-evt
  • place-enabled?
  • place-kill
  • place-location?
  • place-message-allowed?
  • place-wait
  • place/context
  • place?
  • placeholder-get
  • placeholder-set!
  • placeholder?
  • placeholders
  • Places
  • Places Logging
  • planet
  • PLT_COMPILE_ANY
  • PLT_COMPILED_FILE_CHECK
  • PLT_CS_COMPILE_LIMIT
  • PLT_CS_DEBUG
  • PLT_CS_INTERP
  • PLT_CS_JIT
  • PLT_CS_MACH
  • PLT_DELAY_FROM_ZO
  • PLT_EXPANDER_TIMES
  • PLT_INCREMENTAL_GC
  • PLT_LINKLET_SHOW
  • PLT_LINKLET_SHOW_ASSEMBLY
  • PLT_LINKLET_SHOW_CP0
  • PLT_LINKLET_SHOW_GENSYM
  • PLT_LINKLET_SHOW_JIT_DEMAND
  • PLT_LINKLET_SHOW_KNOWN
  • PLT_LINKLET_SHOW_LAMBDA
  • PLT_LINKLET_SHOW_PASSES
  • PLT_LINKLET_SHOW_POST_INTERP
  • PLT_LINKLET_SHOW_POST_LAMBDA
  • PLT_LINKLET_SHOW_PRE_JIT
  • PLT_LINKLET_TIMES
  • PLT_VALIDATE_COMPILE
  • PLT_VALIDATE_LOAD
  • PLT_ZO_PATH
  • PLTADDONDIR
  • PLTCOLLECTS
  • PLTCOMPILEDROOTS
  • PLTCONFIGDIR
  • PLTDISABLEGC
  • PLTNOMZJIT
  • PLTSTDERR
  • PLTSTDOUT
  • PLTSYSLOG
  • PLTUSERHOME
  • plumber
  • plumber-add-flush!
  • plumber-flush-all
  • plumber-flush-handle-remove!
  • plumber-flush-handle?
  • plumber?
  • Plumbers
  • poll
  • poll-guard-evt
  • Port Buffers and Positions
  • port display handler
  • Port Events
  • port positions
  • port print handler
  • port read handler
  • Port String and List Conversions
  • port write handler
  • port->bytes
  • port->bytes-lines
  • port->lines
  • port->list
  • port->string
  • port-closed-evt
  • port-closed?
  • port-commit-peeked
  • port-count-lines!
  • port-count-lines-enabled
  • port-counts-lines?
  • port-display-handler
  • port-file-identity
  • port-file-stat
  • port-file-unlock
  • port-next-location
  • port-number?
  • port-print-handler
  • port-progress-evt
  • port-provides-progress-evts?
  • port-read-handler
  • port-try-file-lock?
  • port-waiting-peer?
  • port-write-handler
  • port-writes-atomic?
  • port-writes-special?
  • port?
  • portal syntax
  • Portal Syntax Bindings
  • portal-syntax-content
  • portal-syntax?
  • ports, flushing
  • Ports
  • Ports
  • position
  • positive-integer?
  • positive?
  • Powers and Roots
  • powerset
  • pre-expand-export
  • predicate
  • predicate/c
  • prefab
  • prefab-key->struct-type
  • prefab-key?
  • prefab-struct-key
  • prefab-struct-type-key+field-count
  • preferences-lock-file-mode
  • prefix
  • prefix-in
  • prefix-out
  • pregexp
  • pregexp
  • pregexp-quote
  • pregexp?
  • preserved
  • preserved
  • Pretty Printing
  • pretty-display
  • pretty-format
  • pretty-print
  • pretty-print-.-symbol-without-bars
  • pretty-print-abbreviate-read-macros
  • pretty-print-columns
  • pretty-print-current-style-table
  • pretty-print-depth
  • pretty-print-exact-as-decimal
  • pretty-print-extend-style-table
  • pretty-print-handler
  • pretty-print-newline
  • pretty-print-post-print-hook
  • pretty-print-pre-print-hook
  • pretty-print-print-hook
  • pretty-print-print-line
  • pretty-print-remap-stylable
  • pretty-print-show-inexactness
  • pretty-print-size-hook
  • pretty-print-style-table?
  • pretty-printing
  • pretty-write
  • Primitive Dictionary Methods
  • primitive procedure
  • primitive-closure?
  • primitive-result-arity
  • primitive?
  • print
  • print handler
  • print-as-expression
  • print-boolean-long-form
  • print-box
  • print-graph
  • print-hash-table
  • print-mpair-curly-braces
  • print-pair-curly-braces
  • print-reader-abbreviations
  • print-struct
  • print-syntax-width
  • print-unreadable
  • print-value-columns
  • print-vector-length
  • printable/c
  • printable<%>
  • Printer Extension
  • printf
  • Printing Booleans
  • Printing Boxes
  • Printing Characters
  • Printing Compiled Code
  • Printing Extflonums
  • Printing Hash Tables
  • Printing Keywords
  • Printing Numbers
  • Printing Pairs and Lists
  • Printing Paths
  • Printing Regular Expressions
  • Printing Strings
  • Printing Structures
  • Printing Symbols
  • Printing Unreadable Values
  • Printing Vectors
  • println
  • private
  • private*
  • Procedure Applications and #%app
  • Procedure Applications and Local Variables
  • Procedure Expressions: lambda and case-lambda
  • procedure->method
  • procedure-arity
  • procedure-arity-includes/c
  • procedure-arity-includes?
  • procedure-arity-mask
  • procedure-arity?
  • procedure-closure-contents-eq?
  • procedure-extract-target
  • procedure-impersonator*?
  • procedure-keywords
  • procedure-realm
  • procedure-reduce-arity
  • procedure-reduce-arity-mask
  • procedure-reduce-keyword-arity
  • procedure-reduce-keyword-arity-mask
  • procedure-rename
  • procedure-result-arity
  • procedure-specialize
  • procedure-struct-type?
  • procedure?
  • Procedures
  • process
  • process*
  • process*/ports
  • process/ports
  • Processes
  • processor-count
  • processor-count
  • progress-evt?
  • promise
  • promise-forced?
  • promise-running?
  • promise/c
  • promise/name?
  • promise?
  • prompt
  • prompt
  • prompt read handler
  • prompt tag
  • prompt-at
  • prompt-tag/c
  • prompt0
  • prompt0-at
  • Prompts, Delimited Continuations, and Barriers
  • prop:arity-string
  • prop:authentic
  • prop:blame
  • prop:chaperone-contract
  • prop:chaperone-unsafe-undefined
  • prop:checked-procedure
  • prop:collapsible-contract
  • prop:contract
  • prop:contracted
  • prop:custom-print-quotable
  • prop:custom-write
  • prop:dict
  • prop:dict/contract
  • prop:equal+hash
  • prop:evt
  • prop:exn:missing-module
  • prop:exn:srclocs
  • prop:expansion-contexts
  • prop:flat-contract
  • prop:impersonator-of
  • prop:input-port
  • prop:legacy-match-expander
  • prop:liberal-define-context
  • prop:match-expander
  • prop:object-name
  • prop:output-port
  • prop:place-location
  • prop:procedure
  • prop:provide-pre-transformer
  • prop:provide-transformer
  • prop:rename-transformer
  • prop:require-transformer
  • prop:sealed
  • prop:sequence
  • prop:serializable
  • prop:set!-transformer
  • prop:stream
  • prop:struct-auto-info
  • prop:struct-field-info
  • prop:struct-info
  • proper-subset?
  • property accessor
  • property predicate
  • property/c
  • protect-out
  • protected
  • provide
  • provide Macros
  • provide pre-transformer
  • provide transformer
  • provide Transformers
  • provide-pre-transformer?
  • provide-signature-elements
  • provide-transformer?
  • provide/contract
  • proxy design pattern
  • pseudo-random-generator->vector
  • pseudo-random-generator-vector?
  • pseudo-random-generator?
  • public
  • public*
  • public-final
  • public-final*
  • pubment
  • pubment*
  • put-input
  • put-preferences
  • putenv
  • PWD

Q

  • quasiquote
  • quasiquote
  • Quasiquoting: quasiquote, unquote, and unquote-splicing
  • quasisyntax
  • quasisyntax/loc
  • quotable
  • quote
  • quote-syntax
  • quote-syntax/prune
  • quotient
  • quotient/remainder
  • quoting depth

R

  • racket
  • racket
  • Racket.exe
  • racket/async-channel
  • racket/base
  • racket/block
  • racket/bool
  • racket/bytes
  • racket/case
  • racket/class
  • racket/cmdline
  • racket/contract
  • racket/contract/base
  • racket/contract/base
  • racket/contract/collapsible
  • racket/contract/combinator
  • racket/contract/parametric
  • racket/contract/region
  • racket/contract:contract
  • racket/contract:contract-on-boundary
  • racket/contract:internal-contract
  • racket/contract:negative-position
  • racket/contract:positive-position
  • racket/control
  • racket/date
  • racket/deprecation
  • racket/deprecation/transformer
  • racket/dict
  • racket/engine
  • racket/enter
  • racket/exn
  • racket/extflonum
  • racket/fasl
  • racket/file
  • racket/fixnum
  • racket/flonum
  • racket/for-clause
  • racket/format
  • racket/function
  • racket/future
  • racket/generator
  • racket/generic
  • racket/hash
  • racket/hash-code
  • racket/help
  • racket/include
  • racket/init
  • racket/interaction-info
  • racket/interactive
  • racket/kernel
  • racket/kernel/init
  • racket/keyword
  • racket/keyword-transform
  • racket/language-info
  • racket/lazy-require
  • racket/linklet
  • racket/list
  • racket/list/grouping
  • racket/list/iteration
  • racket/load
  • racket/local
  • racket/logging
  • racket/match
  • racket/math
  • racket/mutability
  • racket/mutable-treelist
  • racket/os
  • racket/path
  • racket/performance-hint
  • racket/phase+space
  • racket/place
  • racket/place/dynamic
  • racket/port
  • racket/pretty
  • racket/promise
  • racket/provide
  • racket/provide-syntax
  • racket/provide-transform
  • racket/random
  • racket/repl
  • racket/require
  • racket/require-syntax
  • racket/require-transform
  • racket/rerequire
  • racket/runtime-config
  • racket/runtime-path
  • racket/sandbox
  • racket/sequence
  • racket/serialize
  • racket/serialize-structs
  • racket/set
  • racket/shared
  • racket/signature
  • racket/splicing
  • racket/stream
  • racket/string
  • racket/struct
  • racket/struct-info
  • racket/stxparam
  • racket/stxparam-exptime
  • racket/surrogate
  • racket/symbol
  • racket/syntax
  • racket/syntax-srcloc
  • racket/system
  • racket/tcp
  • racket/trace
  • racket/trait
  • racket/treelist
  • racket/udp
  • racket/undefined
  • racket/unit
  • racket/unit-exptime
  • racket/unreachable
  • racket/unsafe/ops
  • racket/unsafe/struct-type-property
  • racket/unsafe/undefined
  • racket/vector
  • radians->degrees
  • raise
  • raise-argument-error
  • raise-argument-error*
  • raise-arguments-error
  • raise-arguments-error*
  • raise-arity-error
  • raise-arity-error*
  • raise-arity-mask-error
  • raise-arity-mask-error*
  • raise-blame-error
  • raise-contract-error
  • raise-mismatch-error
  • raise-range-error
  • raise-range-error*
  • raise-result-arity-error
  • raise-result-arity-error*
  • raise-result-error
  • raise-result-error*
  • raise-support-error
  • raise-syntax-error
  • raise-type-error
  • raise-user-error
  • Raising Exceptions
  • random
  • Random generation
  • Random Numbers
  • random-ref
  • random-sample
  • random-seed
  • range
  • rational numbers
  • rational?
  • rationalize
  • reachable
  • read
  • read
  • read interaction handler
  • read-accept-bar-quote
  • read-accept-box
  • read-accept-compiled
  • read-accept-dot
  • read-accept-graph
  • read-accept-infix-dot
  • read-accept-lang
  • read-accept-quasiquote
  • read-accept-reader
  • read-byte
  • read-byte-or-special
  • read-bytes
  • read-bytes!
  • read-bytes!-evt
  • read-bytes-avail!
  • read-bytes-avail!*
  • read-bytes-avail!-evt
  • read-bytes-avail!/enable-break
  • read-bytes-evt
  • read-bytes-line
  • read-bytes-line-evt
  • read-case-sensitive
  • read-cdot
  • read-char
  • read-char-or-special
  • read-curly-brace-as-paren
  • read-curly-brace-with-tag
  • read-decimal-as-inexact
  • read-eval-print-loop
  • read-installation-configuration-table
  • read-language
  • read-line
  • read-line-evt
  • read-on-demand-source
  • read-single-flonum
  • read-square-bracket-as-paren
  • read-square-bracket-with-tag
  • read-string
  • read-string!
  • read-string!-evt
  • read-string-evt
  • read-syntax
  • read-syntax-accept-graph
  • read-syntax/recursive
  • read/recursive
  • reader
  • Reader Extension
  • reader extension procedures
  • reader language
  • reader macro
  • Reader-Extension Procedures
  • Reading
  • Reading Booleans
  • Reading Boxes
  • Reading Characters
  • Reading Comments
  • Reading Extflonums
  • Reading Graph Structure
  • Reading Hash Tables
  • Reading Keywords
  • Reading Numbers
  • Reading Pairs and Lists
  • Reading Quotes
  • Reading Regular Expressions
  • Reading Strings
  • Reading Structures
  • Reading Symbols
  • Reading Vectors
  • Reading via an Extension
  • Reading with C-style Infix-Dot Notation
  • readtable
  • readtable-mapping
  • readtable?
  • Readtables
  • ready for synchronization
  • real numbers
  • real->decimal-string
  • real->double-flonum
  • real->extfl
  • real->floating-point-bytes
  • real->single-flonum
  • real-in
  • real-part
  • real?
  • realm
  • Realms and Error Message Adjusters
  • rearrangements
  • Receiving Logged Events
  • recompile-linklet
  • recontract-out
  • record-disappeared-uses
  • Recording disappeared uses
  • recursive-contract
  • RED
  • redex
  • redirect-generics
  • reencode-input-port
  • reencode-output-port
  • reference
  • Reflecting on Primitives
  • Reflection and Security
  • regexp
  • regexp
  • Regexp Constructors
  • Regexp Matching
  • Regexp Splitting
  • Regexp Substitution
  • Regexp Syntax
  • regexp value
  • regexp-capture-group-count
  • regexp-match
  • regexp-match*
  • regexp-match-evt
  • regexp-match-exact?
  • regexp-match-peek
  • regexp-match-peek-immediate
  • regexp-match-peek-positions
  • regexp-match-peek-positions*
  • regexp-match-peek-positions-immediate
  • regexp-match-peek-positions-immediate/end
  • regexp-match-peek-positions/end
  • regexp-match-positions
  • regexp-match-positions*
  • regexp-match-positions/end
  • regexp-match/end
  • regexp-match?
  • regexp-max-lookbehind
  • regexp-quote
  • regexp-replace
  • regexp-replace*
  • regexp-replace-quote
  • regexp-replaces
  • regexp-split
  • regexp-try-match
  • regexp?
  • regexps
  • Regular Expressions
  • Regular expressions
  • regular-file-type-bits
  • REL
  • relative-in
  • relative-path?
  • relocate-input-port
  • relocate-output-port
  • remainder
  • remf
  • remf*
  • remove
  • remove*
  • remove-duplicates
  • remq
  • remq*
  • remv
  • remv*
  • remw
  • remw*
  • rename
  • rename transformer
  • rename-contract
  • rename-file-or-directory
  • rename-in
  • rename-inner
  • rename-out
  • rename-super
  • rename-transformer-target
  • rename-transformer?
  • REPL
  • replace-evt
  • require
  • require Macros
  • require transformer
  • require Transformers
  • require-transformer?
  • reroot-path
  • reset
  • reset-at
  • reset0
  • reset0-at
  • resolve-path
  • resolved
  • resolved module path
  • resolved-module-path-name
  • resolved-module-path?
  • Resolving Module Names
  • rest
  • reverse
  • root namespace
  • round
  • Running Racket
  • Running Racket or GRacket
  • running-foldl
  • running-foldr
  • runtime-paths
  • runtime-require

S

  • s-exp
  • s-exp->fasl
  • S-Expression Reader Language
  • sandbox-coverage-enabled
  • sandbox-error-output
  • sandbox-eval-handlers
  • sandbox-eval-limits
  • sandbox-exit-handler
  • sandbox-gui-available
  • sandbox-init-hook
  • sandbox-input
  • sandbox-make-code-inspector
  • sandbox-make-environment-variables
  • sandbox-make-inspector
  • sandbox-make-logger
  • sandbox-make-namespace
  • sandbox-make-plumber
  • sandbox-memory-limit
  • sandbox-namespace-specs
  • sandbox-network-guard
  • sandbox-output
  • sandbox-override-collection-paths
  • sandbox-path-permissions
  • sandbox-propagate-breaks
  • sandbox-propagate-exceptions
  • sandbox-reader
  • sandbox-run-submodules
  • sandbox-security-guard
  • Sandboxed Evaluation
  • scalar value
  • scope
  • scope set
  • sealed
  • second
  • seconds->date
  • Security Considerations
  • security guard
  • Security Guards
  • security-guard?
  • select
  • self
  • semaphore
  • semaphore-peek-evt
  • semaphore-peek-evt?
  • semaphore-post
  • semaphore-try-wait?
  • semaphore-wait
  • semaphore-wait/enable-break
  • semaphore?
  • Semaphores
  • send
  • send*
  • send+
  • send-generic
  • send/apply
  • send/keyword-apply
  • separate compilation guarantee
  • sequence
  • Sequence Conversion
  • Sequence Predicate and Constructors
  • sequence->generator
  • sequence->list
  • sequence->repeated-generator
  • sequence->stream
  • sequence->treelist
  • sequence-add-between
  • sequence-andmap
  • sequence-append
  • sequence-count
  • sequence-filter
  • sequence-fold
  • sequence-for-each
  • sequence-generate
  • sequence-generate*
  • sequence-length
  • sequence-map
  • sequence-ormap
  • sequence-ref
  • sequence-tail
  • sequence/c
  • sequence?
  • Sequences
  • Sequences and Streams
  • Sequencing: begin, begin0, and begin-for-syntax
  • serializable
  • serializable-struct
  • serializable-struct/versions
  • serializable?
  • Serialization
  • Serialization Structures
  • serialize
  • serialized=?
  • Serializing Syntax
  • set
  • set
  • set
  • Set Methods
  • Set Predicates and Contracts
  • set!
  • set!-transformer-procedure
  • set!-transformer?
  • set!-values
  • set->list
  • set->stream
  • set-add
  • set-add!
  • set-box!
  • set-box*!
  • set-clear
  • set-clear!
  • set-copy
  • set-copy-clear
  • set-count
  • set-empty?
  • set-eq?
  • set-equal-always?
  • set-equal?
  • set-eqv?
  • set-eval-handler
  • set-eval-limits
  • set-field!
  • set-first
  • set-for-each
  • set-group-id-bit
  • set-implements/c
  • set-implements?
  • set-intersect
  • set-intersect!
  • set-map
  • set-mcar!
  • set-mcdr!
  • set-member?
  • set-mutable?
  • set-phantom-bytes!
  • set-port-next-location!
  • set-remove
  • set-remove!
  • set-rest
  • set-subset?
  • set-subtract
  • set-subtract!
  • set-symmetric-difference
  • set-symmetric-difference!
  • set-union
  • set-union!
  • set-user-id-bit
  • set-weak?
  • set/c
  • set=?
  • set?
  • setalw
  • seteq
  • seteqv
  • Sets
  • seventh
  • sgn
  • sha1-bytes
  • sha224-bytes
  • sha256-bytes
  • shadowing
  • shadows
  • Shallow time
  • shared
  • shared memory space
  • shared-bytes
  • shared-extflvector
  • shared-flvector
  • shared-fxvector
  • shell-execute
  • ShellExecute
  • shift
  • shift-at
  • shift0
  • shift0-at
  • shrink-path-wrt
  • shuffle
  • SIGHUP
  • SIGINT
  • signature
  • signature-members
  • SIGTERM
  • Simple Subprocesses
  • simple-form-path
  • simplify-path
  • sin
  • single-flonum-available?
  • single-flonum?
  • single-flonums
  • Single-Signature Modules
  • Single-Unit Modules
  • sinh
  • sixth
  • skip-projection-wrapper?
  • sleep
  • slice-by
  • socket-type-bits
  • some-system-path->string
  • sort
  • source location
  • space?
  • spawn
  • special
  • Special Comments
  • special-comment-value
  • special-comment?
  • special-filter-input-port
  • spliced
  • splicing-let
  • splicing-let-syntax
  • splicing-let-syntaxes
  • splicing-let-values
  • splicing-letrec
  • splicing-letrec-syntax
  • splicing-letrec-syntaxes
  • splicing-letrec-syntaxes+values
  • splicing-letrec-values
  • splicing-local
  • splicing-parameterize
  • splicing-syntax-parameterize
  • split-at
  • split-at-right
  • split-common-prefix
  • split-path
  • splitf-at
  • splitf-at-right
  • splitter
  • sqr
  • sqrt
  • square root
  • srcloc (struct)
  • srcloc->string
  • srcloc-column
  • srcloc-line
  • srcloc-position
  • srcloc-source
  • srcloc-span
  • srcloc?
  • stack dump
  • stack trace
  • stencil vector
  • Stencil Vectors
  • stencil-vector
  • stencil-vector-length
  • stencil-vector-mask
  • stencil-vector-mask-width
  • stencil-vector-ref
  • stencil-vector-set!
  • stencil-vector-update
  • stencil-vector?
  • sticky-bit
  • stop-after
  • stop-before
  • stream
  • stream
  • stream*
  • stream->list
  • stream-add-between
  • stream-andmap
  • stream-append
  • stream-cons
  • stream-count
  • stream-empty?
  • stream-filter
  • stream-first
  • stream-fold
  • stream-for-each
  • stream-force
  • stream-lazy
  • stream-length
  • stream-map
  • stream-ormap
  • stream-ref
  • stream-rest
  • stream-tail
  • stream-take
  • stream/c
  • stream?
  • Streams
  • string
  • string
  • String Comparisons
  • String Constructors, Selectors, and Mutators
  • String Conversions
  • String Grapheme Clusters
  • string port
  • String Ports
  • string->bytes/latin-1
  • string->bytes/locale
  • string->bytes/utf-8
  • string->immutable-string
  • string->keyword
  • string->list
  • string->number
  • string->path
  • string->path-element
  • string->some-system-path
  • string->symbol
  • string->uninterned-symbol
  • string->unreadable-symbol
  • string-append
  • string-append*
  • string-append-immutable
  • string-ci<=?
  • string-ci<?
  • string-ci=?
  • string-ci>=?
  • string-ci>?
  • string-contains?
  • string-copy
  • string-copy!
  • string-downcase
  • string-environment-variable-name?
  • string-fill!
  • string-find
  • string-foldcase
  • string-grapheme-count
  • string-grapheme-span
  • string-join
  • string-len/c
  • string-length
  • string-locale-ci<?
  • string-locale-ci=?
  • string-locale-ci>?
  • string-locale-downcase
  • string-locale-upcase
  • string-locale<?
  • string-locale=?
  • string-locale>?
  • string-no-nuls?
  • string-normalize-nfc
  • string-normalize-nfd
  • string-normalize-nfkc
  • string-normalize-nfkd
  • string-normalize-spaces
  • string-port?
  • string-prefix?
  • string-ref
  • string-replace
  • string-set!
  • string-split
  • string-suffix?
  • string-titlecase
  • string-trim
  • string-upcase
  • string-utf-8-length
  • string<=?
  • string<?
  • string=?
  • string>=?
  • string>?
  • string?
  • strings, uppercase
  • strings, upper-case
  • strings, pattern matching
  • strings, parsing
  • strings, lowercase
  • strings, lower-case
  • strings, immutable
  • strings, concatenate
  • Strings
  • struct
  • struct
  • struct*
  • struct->list
  • struct->vector
  • struct-accessor-procedure?
  • struct-auto-info-lists
  • struct-auto-info?
  • struct-constructor-procedure?
  • struct-copy
  • struct-field-index
  • struct-field-info-list
  • struct-field-info?
  • struct-guard/c
  • struct-info
  • struct-info?
  • struct-mutator-procedure?
  • struct-out
  • struct-predicate-procedure?
  • struct-type-authentic?
  • struct-type-info
  • struct-type-make-constructor
  • struct-type-make-predicate
  • struct-type-property-accessor-procedure?
  • struct-type-property-predicate-procedure?
  • struct-type-property/c
  • struct-type-property?
  • struct-type-sealed?
  • struct-type?
  • struct/c
  • struct/contract
  • struct/ctc
  • struct/dc
  • struct/derived
  • struct:arity-at-least
  • struct:collapsible-count-property
  • struct:collapsible-ho/c
  • struct:collapsible-leaf/c
  • struct:collapsible-property
  • struct:collapsible-wrapper-property
  • struct:date
  • struct:date*
  • struct:exn
  • struct:exn:break
  • struct:exn:break:hang-up
  • struct:exn:break:terminate
  • struct:exn:fail
  • struct:exn:fail:contract
  • struct:exn:fail:contract:arity
  • struct:exn:fail:contract:blame
  • struct:exn:fail:contract:continuation
  • struct:exn:fail:contract:divide-by-zero
  • struct:exn:fail:contract:non-fixnum-result
  • struct:exn:fail:contract:variable
  • struct:exn:fail:filesystem
  • struct:exn:fail:filesystem:errno
  • struct:exn:fail:filesystem:exists
  • struct:exn:fail:filesystem:missing-module
  • struct:exn:fail:filesystem:version
  • struct:exn:fail:network
  • struct:exn:fail:network:errno
  • struct:exn:fail:object
  • struct:exn:fail:out-of-memory
  • struct:exn:fail:read
  • struct:exn:fail:read:eof
  • struct:exn:fail:read:non-char
  • struct:exn:fail:support
  • struct:exn:fail:syntax
  • struct:exn:fail:syntax:missing-module
  • struct:exn:fail:syntax:unbound
  • struct:exn:fail:unsupported
  • struct:exn:fail:user
  • struct:export
  • struct:import
  • struct:import-source
  • struct:srcloc
  • struct:struct-info
  • struct?
  • Structural Matching
  • structure
  • Structure Inspectors
  • structure subtype
  • structure type
  • structure type descriptor
  • Structure Type Properties
  • structure type property
  • Structure Type Property Contracts
  • structure type property descriptor
  • Structure Type Transformer Binding
  • Structure Utilities
  • structures, equality
  • Structures
  • Structures as Ports
  • Sub-expression Evaluation and Continuations
  • sub1
  • subbytes
  • subclass?
  • subclass?/c
  • submod
  • submodule
  • Submodules
  • subprocess
  • subprocess
  • subprocess-group-enabled
  • subprocess-kill
  • subprocess-pid
  • subprocess-status
  • subprocess-wait
  • subprocess?
  • subset?
  • substring
  • subtract-in
  • suggest/c
  • super
  • super-instantiate
  • super-make-object
  • super-new
  • superclass
  • supported generic method
  • surrogate
  • Surrogates
  • Suspending, Resuming, and Killing Threads
  • symbol
  • symbol->immutable-string
  • symbol->string
  • symbol-interned?
  • symbol-unreadable?
  • symbol<?
  • symbol=?
  • symbol?
  • symbolic-link-type-bits
  • symbols, unique
  • symbols, generating
  • Symbols
  • symbols
  • sync
  • sync/enable-break
  • sync/timeout
  • sync/timeout/enable-break
  • synchronizable event
  • Synchronization
  • synchronization result
  • Synchronizing Thread State
  • syntactic form
  • Syntactic Forms
  • Syntactic Support for Using Places
  • syntax
  • syntax binding set
  • Syntax Model
  • syntax object
  • Syntax Object Bindings
  • Syntax Object Content
  • Syntax Object Properties
  • Syntax Object Source Locations
  • Syntax Objects
  • syntax pair
  • syntax parameter
  • Syntax Parameter Inspection
  • Syntax Parameters
  • syntax property
  • Syntax Quoting: quote-syntax
  • Syntax Taints
  • syntax transformer
  • Syntax Transformers
  • Syntax Utilities
  • syntax->datum
  • syntax->list
  • syntax-arm
  • syntax-binding-set
  • syntax-binding-set->syntax
  • syntax-binding-set-extend
  • syntax-binding-set?
  • syntax-bound-interned-scope-symbols
  • syntax-bound-phases
  • syntax-bound-symbols
  • syntax-case
  • syntax-case*
  • syntax-column
  • syntax-debug-info
  • syntax-deserialize
  • syntax-disarm
  • syntax-e
  • syntax-id-rules
  • syntax-line
  • syntax-local-apply-transformer
  • syntax-local-bind-syntaxes
  • syntax-local-certifier
  • syntax-local-compiling-module?
  • syntax-local-context
  • syntax-local-eval
  • syntax-local-expand-expression
  • syntax-local-get-shadower
  • syntax-local-identifier-as-binding
  • syntax-local-introduce
  • syntax-local-lift-context
  • syntax-local-lift-expression
  • syntax-local-lift-module
  • syntax-local-lift-module-end-declaration
  • syntax-local-lift-provide
  • syntax-local-lift-require
  • syntax-local-lift-require-top-level-form
  • syntax-local-lift-values-expression
  • syntax-local-make-definition-context
  • syntax-local-make-definition-context-introducer
  • syntax-local-make-delta-introducer
  • syntax-local-match-introduce
  • syntax-local-module-defined-identifiers
  • syntax-local-module-exports
  • syntax-local-module-interned-scope-symbols
  • syntax-local-module-required-identifiers
  • syntax-local-name
  • syntax-local-phase-level
  • syntax-local-provide-certifier
  • syntax-local-provide-introduce
  • syntax-local-require-certifier
  • syntax-local-require-introduce
  • syntax-local-splicing-for-clause-introduce
  • syntax-local-submodules
  • syntax-local-transforming-module-provides?
  • syntax-local-value
  • syntax-local-value/immediate
  • syntax-local-value/record
  • syntax-original?
  • syntax-parameter-value
  • syntax-parameterize
  • syntax-pattern-variable?
  • syntax-position
  • syntax-procedure-alias-property
  • syntax-procedure-converted-arguments-property
  • syntax-property
  • syntax-property-preserved?
  • syntax-property-remove
  • syntax-property-symbol-keys
  • syntax-protect
  • syntax-rearm
  • syntax-recertify
  • syntax-rules
  • syntax-serialize
  • syntax-shift-phase-level
  • syntax-source
  • syntax-source-module
  • syntax-span
  • syntax-srcloc
  • syntax-taint
  • syntax-tainted?
  • syntax-track-origin
  • syntax-transforming-module-expression?
  • syntax-transforming-with-lifts?
  • syntax-transforming?
  • syntax/c
  • syntax/loc
  • syntax?
  • system
  • system*
  • system*/exit-code
  • system-big-endian?
  • system-idle-evt
  • system-language+country
  • system-library-subpath
  • system-path-convention-type
  • system-type
  • system/exit-code

T

  • tag
  • Tail Position
  • tail position
  • tainted
  • take
  • take-common-prefix
  • take-right
  • takef
  • takef-right
  • tan
  • tanh
  • TCP
  • TCP listener
  • TCP port
  • tcp-abandon-port
  • tcp-accept
  • tcp-accept-evt
  • tcp-accept-ready?
  • tcp-accept/enable-break
  • tcp-addresses
  • tcp-close
  • tcp-connect
  • tcp-connect/enable-break
  • tcp-listen
  • tcp-listener?
  • tcp-port?
  • TCP_NODELAY
  • TEMP
  • template environment
  • tentative-pretty-print-port-cancel
  • tentative-pretty-print-port-transfer
  • tenth
  • terminal-file-position
  • terminal-port?
  • the epoch
  • The Printer
  • The Racket Reference
  • The racket/load Language
  • The racket/repl Library
  • The Reader
  • The Separate Compilation Guarantee
  • the-unsupplied-arg
  • third
  • thirteenth
  • this
  • this%
  • thread
  • Thread Cells
  • thread cells
  • thread descriptor
  • thread group
  • Thread Groups
  • Thread Mailboxes
  • thread-cell-ref
  • thread-cell-set!
  • thread-cell-values?
  • thread-cell?
  • thread-dead-evt
  • thread-dead?
  • thread-group?
  • Thread-Local Storage
  • thread-receive
  • thread-receive-evt
  • thread-resume
  • thread-resume-evt
  • thread-rewind-receive
  • thread-running?
  • thread-send
  • thread-suspend
  • thread-suspend-evt
  • thread-try-receive
  • thread-wait
  • thread/suspend-to-kill
  • thread?
  • threads, run state
  • threads, breaking
  • threads, breaking
  • Threads
  • Threads
  • threads
  • thunk
  • thunk*
  • Time
  • time
  • time-apply
  • TMP
  • TMPDIR
  • top-level binding
  • top-level context
  • top-level variable
  • Top-Level Variables
  • touch
  • trace
  • trace-call
  • trace-define
  • trace-define-syntax
  • trace-lambda
  • trace-let
  • Tracing
  • trait
  • trait
  • trait->mixin
  • trait-alias
  • trait-exclude
  • trait-exclude-field
  • trait-rename
  • trait-rename-field
  • trait-sum
  • trait?
  • Traits
  • transformer
  • Transformer Bindings
  • transformer environment
  • Transformer Helpers
  • transplant-input-port
  • transplant-output-port
  • treelist
  • treelist
  • treelist->list
  • treelist->vector
  • treelist-add
  • treelist-append
  • treelist-append*
  • treelist-chaperone-state
  • treelist-cons
  • treelist-copy
  • treelist-delete
  • treelist-drop
  • treelist-drop-right
  • treelist-empty?
  • treelist-filter
  • treelist-find
  • treelist-first
  • treelist-flatten
  • treelist-for-each
  • treelist-index-of
  • treelist-insert
  • treelist-last
  • treelist-length
  • treelist-map
  • treelist-member?
  • treelist-ref
  • treelist-rest
  • treelist-reverse
  • treelist-set
  • treelist-sort
  • treelist-sublist
  • treelist-take
  • treelist-take-right
  • treelist/c
  • treelist?
  • Treelists
  • Trigonometric Functions
  • true
  • truncate
  • twelfth

U

  • UDP
  • UDP socket
  • udp-addresses
  • udp-bind!
  • udp-bound?
  • udp-close
  • udp-connect!
  • udp-connected?
  • udp-multicast-interface
  • udp-multicast-join-group!
  • udp-multicast-leave-group!
  • udp-multicast-loopback?
  • udp-multicast-set-interface!
  • udp-multicast-set-loopback!
  • udp-multicast-set-ttl!
  • udp-multicast-ttl
  • udp-open-socket
  • udp-receive!
  • udp-receive!*
  • udp-receive!-evt
  • udp-receive!/enable-break
  • udp-receive-ready-evt
  • udp-send
  • udp-send*
  • udp-send-evt
  • udp-send-ready-evt
  • udp-send-to
  • udp-send-to*
  • udp-send-to-evt
  • udp-send-to/enable-break
  • udp-send/enable-break
  • udp-set-receive-buffer-size!
  • udp-set-ttl!
  • udp-ttl
  • udp?
  • unbound
  • unbox
  • unbox*
  • uncaught-exception handler
  • uncaught-exception-handler
  • unconstrained-domain->
  • Undefined
  • undefined
  • uninterned
  • unit
  • unit contract
  • Unit Contracts
  • Unit Utilities
  • unit-from-context
  • unit-static-init-dependencies
  • unit-static-signatures
  • unit/c
  • unit/new-import-export
  • unit/s
  • unit?
  • Units
  • Units
  • Unix and Mac OS Paths
  • Unix Path Representation
  • unless
  • unquote
  • unquote-splicing
  • unquoted-printing string
  • unquoted-printing-string
  • unquoted-printing-string-value
  • unquoted-printing-string?
  • Unreachable Expressions
  • unreadable symbol
  • unsafe
  • Unsafe Access to Core Compiler Forms
  • Unsafe Assertions
  • Unsafe Character Operations
  • Unsafe Compound-Data Operations
  • Unsafe Extflonum Operations
  • Unsafe Impersonators and Chaperones
  • unsafe mode
  • Unsafe Numeric Operations
  • Unsafe Operations
  • Unsafe Structure Type Properties
  • Unsafe Undefined
  • unsafe-assert-unreachable
  • unsafe-box*-cas!
  • unsafe-bytes->immutable-bytes!
  • unsafe-bytes-copy!
  • unsafe-bytes-length
  • unsafe-bytes-ref
  • unsafe-bytes-set!
  • unsafe-car
  • unsafe-cdr
  • unsafe-chaperone-procedure
  • unsafe-chaperone-vector
  • unsafe-char->integer
  • unsafe-char<=?
  • unsafe-char<?
  • unsafe-char=?
  • unsafe-char>=?
  • unsafe-char>?
  • unsafe-cons-list
  • unsafe-ephemeron-hash-iterate-first
  • unsafe-ephemeron-hash-iterate-key
  • unsafe-ephemeron-hash-iterate-key+value
  • unsafe-ephemeron-hash-iterate-next
  • unsafe-ephemeron-hash-iterate-pair
  • unsafe-ephemeron-hash-iterate-value
  • unsafe-extfl*
  • unsafe-extfl+
  • unsafe-extfl-
  • unsafe-extfl->fx
  • unsafe-extfl/
  • unsafe-extfl<
  • unsafe-extfl<=
  • unsafe-extfl=
  • unsafe-extfl>
  • unsafe-extfl>=
  • unsafe-extflabs
  • unsafe-extflacos
  • unsafe-extflasin
  • unsafe-extflatan
  • unsafe-extflceiling
  • unsafe-extflcos
  • unsafe-extflexp
  • unsafe-extflexpt
  • unsafe-extflfloor
  • unsafe-extfllog
  • unsafe-extflmax
  • unsafe-extflmin
  • unsafe-extflround
  • unsafe-extflsin
  • unsafe-extflsqrt
  • unsafe-extfltan
  • unsafe-extfltruncate
  • unsafe-extflvector-length
  • unsafe-extflvector-ref
  • unsafe-extflvector-set!
  • unsafe-f64vector-ref
  • unsafe-f64vector-set!
  • unsafe-fl*
  • unsafe-fl+
  • unsafe-fl-
  • unsafe-fl->fx
  • unsafe-fl/
  • unsafe-fl<
  • unsafe-fl<=
  • unsafe-fl=
  • unsafe-fl>
  • unsafe-fl>=
  • unsafe-flabs
  • unsafe-flacos
  • unsafe-flasin
  • unsafe-flatan
  • unsafe-flbit-field
  • unsafe-flceiling
  • unsafe-flcos
  • unsafe-flexp
  • unsafe-flexpt
  • unsafe-flfloor
  • unsafe-flimag-part
  • unsafe-fllog
  • unsafe-flmax
  • unsafe-flmin
  • unsafe-flrandom
  • unsafe-flreal-part
  • unsafe-flround
  • unsafe-flsin
  • unsafe-flsingle
  • unsafe-flsqrt
  • unsafe-fltan
  • unsafe-fltruncate
  • unsafe-flvector-length
  • unsafe-flvector-ref
  • unsafe-flvector-set!
  • unsafe-fx*
  • unsafe-fx*/wraparound
  • unsafe-fx+
  • unsafe-fx+/wraparound
  • unsafe-fx-
  • unsafe-fx-/wraparound
  • unsafe-fx->extfl
  • unsafe-fx->fl
  • unsafe-fx<
  • unsafe-fx<=
  • unsafe-fx=
  • unsafe-fx>
  • unsafe-fx>=
  • unsafe-fxabs
  • unsafe-fxand
  • unsafe-fxior
  • unsafe-fxlshift
  • unsafe-fxlshift/wraparound
  • unsafe-fxmax
  • unsafe-fxmin
  • unsafe-fxmodulo
  • unsafe-fxnot
  • unsafe-fxpopcount
  • unsafe-fxpopcount16
  • unsafe-fxpopcount32
  • unsafe-fxquotient
  • unsafe-fxremainder
  • unsafe-fxrshift
  • unsafe-fxrshift/logical
  • unsafe-fxvector-length
  • unsafe-fxvector-ref
  • unsafe-fxvector-set!
  • unsafe-fxxor
  • unsafe-immutable-hash-iterate-first
  • unsafe-immutable-hash-iterate-key
  • unsafe-immutable-hash-iterate-key+value
  • unsafe-immutable-hash-iterate-next
  • unsafe-immutable-hash-iterate-pair
  • unsafe-immutable-hash-iterate-value
  • unsafe-impersonate-procedure
  • unsafe-impersonate-vector
  • unsafe-list-ref
  • unsafe-list-tail
  • unsafe-make-flrectangular
  • unsafe-make-srcloc
  • unsafe-make-struct-type-property/guard-calls-no-arguments
  • unsafe-mcar
  • unsafe-mcdr
  • unsafe-mutable-hash-iterate-first
  • unsafe-mutable-hash-iterate-key
  • unsafe-mutable-hash-iterate-key+value
  • unsafe-mutable-hash-iterate-next
  • unsafe-mutable-hash-iterate-pair
  • unsafe-mutable-hash-iterate-value
  • unsafe-s16vector-ref
  • unsafe-s16vector-set!
  • unsafe-set-box!
  • unsafe-set-box*!
  • unsafe-set-immutable-car!
  • unsafe-set-immutable-cdr!
  • unsafe-set-mcar!
  • unsafe-set-mcdr!
  • unsafe-stencil-vector
  • unsafe-stencil-vector-length
  • unsafe-stencil-vector-mask
  • unsafe-stencil-vector-ref
  • unsafe-stencil-vector-set!
  • unsafe-stencil-vector-update
  • unsafe-string->immutable-string!
  • unsafe-string-length
  • unsafe-string-ref
  • unsafe-string-set!
  • unsafe-struct*-cas!
  • unsafe-struct*-ref
  • unsafe-struct*-set!
  • unsafe-struct*-type
  • unsafe-struct-ref
  • unsafe-struct-set!
  • unsafe-u16vector-ref
  • unsafe-u16vector-set!
  • unsafe-unbox
  • unsafe-unbox*
  • unsafe-undefined
  • unsafe-vector*->immutable-vector!
  • unsafe-vector*-append
  • unsafe-vector*-cas!
  • unsafe-vector*-copy
  • unsafe-vector*-length
  • unsafe-vector*-ref
  • unsafe-vector*-set!
  • unsafe-vector*-set/copy
  • unsafe-vector-append
  • unsafe-vector-copy
  • unsafe-vector-length
  • unsafe-vector-ref
  • unsafe-vector-set!
  • unsafe-vector-set/copy
  • unsafe-weak-hash-iterate-first
  • unsafe-weak-hash-iterate-key
  • unsafe-weak-hash-iterate-key+value
  • unsafe-weak-hash-iterate-next
  • unsafe-weak-hash-iterate-pair
  • unsafe-weak-hash-iterate-value
  • unsupplied-arg?
  • unsyntax
  • unsyntax-splicing
  • untrace
  • use-collection-link-paths
  • use-compiled-file-check
  • use-compiled-file-paths
  • use-site scope
  • use-user-specific-search-paths
  • USER
  • user’s home directory
  • user-execute-bit
  • user-permission-bits
  • user-read-bit
  • user-read-bit
  • user-write-bit
  • USERPROFILE
  • Using Places
  • UTF-8-permissive
  • Utilities for Building New Combinators

V

  • valid hash index
  • value
  • Value Output Hook
  • value-blame
  • value-contract
  • values
  • variable
  • variable reference
  • Variable References and #%top
  • variable-reference->empty-namespace
  • variable-reference->instance
  • variable-reference->module-base-phase
  • variable-reference->module-declaration-inspector
  • variable-reference->module-path-index
  • variable-reference->module-source
  • variable-reference->namespace
  • variable-reference->phase
  • variable-reference->resolved-module-path
  • variable-reference-constant?
  • variable-reference-from-unsafe?
  • variable-reference?
  • Variables and Locations
  • Variants of case
  • vector
  • vector
  • vector
  • vector*-append
  • vector*-copy
  • vector*-extend
  • vector*-length
  • vector*-ref
  • vector*-set!
  • vector*-set/copy
  • vector->immutable-vector
  • vector->list
  • vector->mutable-treelist
  • vector->pseudo-random-generator
  • vector->pseudo-random-generator!
  • vector->treelist
  • vector->values
  • vector-append
  • vector-argmax
  • vector-argmin
  • vector-cas!
  • vector-copy
  • vector-copy!
  • vector-count
  • vector-drop
  • vector-drop-right
  • vector-empty?
  • vector-extend
  • vector-fill!
  • vector-filter
  • vector-filter-not
  • vector-immutable
  • vector-immutable/c
  • vector-immutableof
  • vector-length
  • vector-map
  • vector-map!
  • vector-member
  • vector-memq
  • vector-memv
  • vector-ref
  • vector-set!
  • vector-set*!
  • vector-set-performance-stats!
  • vector-set/copy
  • vector-sort
  • vector-sort!
  • vector-split-at
  • vector-split-at-right
  • vector-take
  • vector-take-right
  • vector/c
  • vector?
  • vectorof
  • Vectors
  • version
  • visits
  • Void
  • void
  • void?

W

  • weak box
  • Weak Boxes
  • weak references
  • weak-box-value
  • weak-box?
  • weak-set
  • weak-setalw
  • weak-seteq
  • weak-seteqv
  • when
  • will
  • will executor
  • will-execute
  • will-executor?
  • will-register
  • will-try-execute
  • Wills and Executors
  • windows
  • Windows Path Representation
  • Windows Paths
  • with-assert-unreachable
  • with-collapsible-contract-continuation-mark
  • with-continuation-mark
  • with-contract
  • with-contract-continuation-mark
  • with-deep-time-limit
  • with-disappeared-uses
  • with-handlers
  • with-handlers*
  • with-input-from-bytes
  • with-input-from-file
  • with-input-from-string
  • with-intercepted-logging
  • with-limits
  • with-logging-to-port
  • with-method
  • with-output-to-bytes
  • with-output-to-file
  • with-output-to-string
  • with-syntax
  • with-syntax*
  • would-be-future
  • wrap-evt
  • writable<%>
  • write
  • write-byte
  • write-bytes
  • write-bytes-avail
  • write-bytes-avail*
  • write-bytes-avail-evt
  • write-bytes-avail/enable-break
  • write-char
  • write-special
  • write-special-avail*
  • write-special-evt
  • write-string
  • write-to-file
  • writeln
  • Writing
  • wrong-syntax

X

  • XDG_CACHE_HOME
  • XDG_CONFIG_HOME
  • XDG_DATA_HOME
  • xor

Y

  • yield

Z

  • zero?

  • "
  • "longdouble.dll"
  • #!
  • #!
  • #!/
  • #"
  • #%
  • #%app
  • '#%braces
  • '#%brackets
  • #%datum
  • #%declare
  • '#%dot
  • #%expression
  • #%foreign-inline
  • '#%kernel
  • #%module-begin
  • #%plain-app
  • #%plain-lambda
  • #%plain-module-begin
  • #%printing-module-begin
  • #%provide
  • #%require
  • #%stratified-body
  • #%top
  • #%top-interaction
  • #%variable-reference
  • #&
  • #'
  • #(
  • #,
  • #,@
  • #0#
  • #0=
  • #:
  • #:cross-phase-persistent
  • #:empty-namespace
  • #:flatten-requires
  • #:realm
  • #:require=define
  • #:unlimited-compile
  • #:unsafe
  • #;
  • #<<
  • #[
  • #\
  • #\backspace
  • #\linefeed
  • #\newline
  • #\nul
  • #\null
  • #\page
  • #\return
  • #\rubout
  • #\space
  • #\tab
  • #\vtab
  • #
    `
  • #b
  • #ci
  • #cs
  • #d
  • #e
  • #F
  • #f
  • #false
  • #fl
  • #fx
  • #hash
  • #hashalw
  • #hasheq
  • #hasheqv
  • #i
  • #lang
  • #o
  • #px
  • #reader
  • #rx
  • #s(
  • #s[
  • #s{
  • #T
  • #t
  • #true
  • #x
  • #{
  • #|
  • #~
  • %
  • '
  • (
  • )
  • *
  • *list/c
  • +
  • +inf.0
  • +inf.f
  • +inf.t
  • +nan.0
  • +nan.f
  • +nan.t
  • +rv
  • ,
  • ,@
  • -
  • \--
  • \--addon
  • \--addon
  • \--back
  • \--binary
  • \--collects
  • \--compile-any
  • \--compiled
  • \--config
  • \--cross
  • \--cross
  • \--eval
  • \--exe
  • \--help
  • \--lib
  • \--load
  • \--main
  • \--make
  • \--make
  • \--name
  • \--no-compiled
  • \--no-compiled
  • \--no-delay
  • \--no-init-file
  • \--no-jit
  • \--no-lib
  • \--no-user-path
  • \--no-yield
  • \--repl
  • \--require
  • \--require-script
  • \--script
  • \--search
  • \--stdout
  • \--syslog
  • \--text-repl
  • \--version
  • \--warn
  • \--wm-class
  • ->
  • ->*
  • ->*m
  • ->d
  • ->dm
  • ->extfl
  • ->fl
  • ->i
  • ->m
  • -A
  • -A
  • -b
  • -background
  • -bg
  • -C
  • -C
  • -c
  • -c
  • -d
  • -display
  • -E
  • -e
  • -f
  • -fg
  • -fn
  • -font
  • -foreground
  • -G
  • -geometry
  • -h
  • -I
  • -i
  • -iconic
  • -inf.0
  • -inf.f
  • -inf.t
  • -J
  • -j
  • -K
  • -k
  • -L
  • -l
  • -M
  • -m
  • -N
  • -n
  • -name
  • -nan.0
  • -nan.f
  • -nan.t
  • -O
  • -p
  • -psn_
  • -q
  • -R
  • -r
  • -reverse
  • -rv
  • -S
  • -selectionTimeout
  • -singleInstance
  • -synchronous
  • -t
  • -title
  • -U
  • -u
  • -V
  • -v
  • -W
  • -X
  • -xnllanguage
  • -xrm
  • -Y
  • -y
  • -y
  • -Z
  • -z
  • .
  • ...
  • ".racketrc"
  • /
  • '3m
  • 3m
  • :do-in
  • ;
  • <
  • </c
  • <=
  • <=/c
  • =
  • =/c
  • ==
  • =>
  • >
  • >/c
  • >=
  • >=/c
  • ?
  • [
  • \
  • \"
  • \'
  • \‹digit8›{1,3}
  • \‹newline›
  • \\\
  • \a
  • \b
  • \e
  • \f
  • \n
  • \r
  • \t
  • \u‹digit16›{1,4}
  • \U‹digit16›{1,8}
  • \u‹digit16›{4,4}\u‹digit16›{4,4}
  • \v
  • \x‹digit16›{1,2}
  • _
  • _
  • ``
    `
  • 'aborts
  • 'access-time-nanoseconds
  • 'access-time-seconds
  • 'addon-dir
  • 'any
  • 'any-one
  • 'append
  • 'arch
  • "AUX"
  • 'binary
  • 'block
  • 'block-count
  • 'block-size
  • 'body-as-unsafe
  • 'body-as-unsafe
  • 'cache-dir
  • 'can-update
  • 'cc
  • 'certify-mode
  • 'cf
  • 'cgc
  • 'change-time-nanoseconds
  • 'change-time-seconds
  • 'chez-scheme
  • 'client
  • 'cn
  • 'co
  • 'collects-dir
  • "COM1"
  • "COM2"
  • "COM3"
  • "COM4"
  • "COM5"
  • "COM6"
  • "COM7"
  • "COM8"
  • "COM9"
  • 'compiler-hint:cross-module-inline
  • 'complete
  • 'complete
  • "CON"
  • 'config-dir
  • 'configure-runtime
  • 'continues
  • 'continues
  • 'Control
  • 'CR
  • 'creation-time-nanoseconds
  • 'creation-time-seconds
  • 'cross
  • 'cs
  • 'cs
  • 'definition-intended-as-local
  • 'delete
  • 'desk-dir
  • 'device-id
  • 'device-id-for-special-file
  • 'disappeared-binding
  • 'disappeared-use
  • 'dispatch-macro
  • 'dll
  • 'doc-dir
  • 'enclosing-module-name
  • 'error
  • 'error
  • 'exact
  • 'exec-file
  • 'execute
  • 'execute
  • 'exists
  • 'Extend
  • 'file-level
  • 'for:no-implicit-optimization
  • 'force
  • 'framework
  • 'fs-change
  • 'gc
  • 'group-id
  • 'hardlink-count
  • 'home-dir
  • 'host-addon-dir
  • 'host-collects-dir
  • 'host-config-dir
  • 'import-or-export-prefix-ranges
  • 'import-or-export-prefix-ranges
  • 'infer
  • 'inferred-name
  • 'init-dir
  • 'init-file
  • 'inode
  • 'L
  • 'lexical
  • 'LF
  • 'line
  • 'linefeed
  • 'link
  • 'll
  • 'lm
  • 'lo
  • 'low-latency
  • "LPT1"
  • "LPT2"
  • "LPT3"
  • "LPT4"
  • "LPT5"
  • "LPT6"
  • "LPT7"
  • "LPT8"
  • "LPT9"
  • 'lt
  • 'lu
  • 'LV
  • 'LVT
  • 'machine
  • 'macosx
  • 'mc
  • 'me
  • 'method-arity-error
  • 'method-arity-error
  • 'mn
  • 'mode
  • 'modify-time-nanoseconds
  • 'modify-time-seconds
  • 'module-body-context
  • 'module-body-context-simple?
  • 'module-body-inside-context
  • 'module-language
  • 'module-language
  • 'must-truncate
  • 'nd
  • 'nl
  • 'no
  • 'nominal-id
  • 'non-terminating-macro
  • 'non-terminating-macro
  • 'none
  • 'not-free-identifier=?
  • 'not-provide-all-defined
  • "NUL"
  • 'orig-dir
  • 'origin
  • 'origin-form-srcloc
  • 'os
  • 'os*
  • 'Other
  • 'paren-shape
  • 'pc
  • 'pd
  • 'pe
  • 'pf
  • 'pi
  • 'platform
  • 'po
  • 'pref-dir
  • 'pref-file
  • 'Prepend
  • "PRN"
  • 'protected
  • 'provide/contract-original-contract
  • 'ps
  • 'racket
  • "racketrc.rktl"
  • "racketrc.rktl"
  • 'read
  • 'read
  • 'Regional_Indicator
  • 'relative
  • 'replace
  • 'return
  • 'return-linefeed
  • 'run-file
  • 'running
  • 'same
  • 'sc
  • 'scalable
  • 'server
  • 'shared
  • 'size
  • 'sk
  • 'sm
  • 'so
  • 'so-find
  • 'so-mode
  • 'so-suffix
  • 'SpacingMark
  • 'static
  • 'supported
  • 'SW_HIDE
  • 'sw_hide
  • 'SW_MAXIMIZE
  • 'sw_maximize
  • 'SW_MINIMIZE
  • 'sw_minimize
  • 'SW_RESTORE
  • 'sw_restore
  • 'SW_SHOW
  • 'sw_show
  • 'SW_SHOWDEFAULT
  • 'sw_showdefault
  • 'SW_SHOWMAXIMIZED
  • 'sw_showmaximized
  • 'SW_SHOWMINIMIZED
  • 'sw_showminimized
  • 'SW_SHOWMINNOACTIVE
  • 'sw_showminnoactive
  • 'SW_SHOWNA
  • 'sw_showna
  • 'SW_SHOWNOACTIVATE
  • 'sw_shownoactivate
  • 'SW_SHOWNORMAL
  • 'sw_shownormal
  • 'sys-dir
  • 'T
  • 'taint-mode
  • 'target-machine
  • 'temp-dir
  • 'terminating-macro
  • 'text
  • 'truncate
  • 'truncate/replace
  • 'undefined-error-name
  • 'unix
  • 'unix
  • 'up
  • 'update
  • 'user-id
  • 'V
  • 'vm
  • 'windows
  • 'windows
  • 'word
  • 'write
  • 'write
  • 'zl
  • 'zp
  • 'zs
  • 'ZWJ
  • {
  • |
  • }
  • ~.a
  • ~.s
  • ~.v
  • ~?
  • ~@
  • ~a
  • ~e
  • ~r
  • ~s
  • ~v
  • λ

더 알아보기