Procedure Index

This is an alphabetical list of all the procedures and macros in Guile. It also includes Guile’s Autoconf macros.

When looking for a particular procedure, please look under its Scheme name as well as under its C name. The C name can be constructed from the Scheme names by a simple transformation described in the section See Overview of the Guile API.

Jump to:   #   $   %   &   '   (   *   +   ,   -   .   /   1   <   =   >   @   _   `  
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  
Index Entry  Section

#:accessor: Slot Options
#:allocation: Slot Options
#:class: Slot Options
#:each-subclass: Slot Options
#:getter: Slot Options
#:init-form: Slot Options
#:init-keyword: Slot Options
#:init-thunk: Slot Options
#:init-value: Slot Options
#:instance: Slot Options
#:metaclass: Class Definition
#:name: Class Definition
#:setter: Slot Options
#:slot-ref: Slot Options
#:slot-ref: Slot Options
#:slot-ref: Slot Description Example
#:slot-set!: Slot Options
#:slot-set!: Slot Options
#:slot-set!: Slot Description Example
#:virtual: Slot Options

$allocate-struct: Intrinsic Call Instructions
$car: Intrinsic Call Instructions
$cdr: Intrinsic Call Instructions
$set-car!: Intrinsic Call Instructions
$set-cdr!: Intrinsic Call Instructions
$struct-ref: Intrinsic Call Instructions
$struct-ref/immediate: Intrinsic Call Instructions
$struct-set!: Intrinsic Call Instructions
$struct-set!/immediate: Intrinsic Call Instructions
$struct-vtable: Intrinsic Call Instructions
$variable-ref: Intrinsic Call Instructions
$variable-set!: Intrinsic Call Instructions
$vector-length: Intrinsic Call Instructions
$vector-ref: Intrinsic Call Instructions
$vector-ref/immediate: Intrinsic Call Instructions
$vector-set!: Intrinsic Call Instructions
$vector-set!/immediate: Intrinsic Call Instructions

%: Shift and Reset
%: Shift and Reset
%: Shift and Reset
%char-set-dump: Querying Character Sets
%default-port-conversion-strategy: Encoding
%library-dir: Build Config
%make-void-port: Void Ports
%package-data-dir: Build Config
%read-delimited!: Line/Delimited
%read-line: Line/Delimited
%search-load-path: Load Paths
%site-ccache-dir: Installing Site Packages
%site-ccache-dir: Build Config
%site-dir: Installing Site Packages
%site-dir: Build Config
%string-dump: String Internals

&assertion: rnrs conditions
&condition: rnrs conditions
&error: rnrs conditions
&i/o: R6RS I/O Conditions
&i/o-decoding: R6RS Transcoders
&i/o-encoding: R6RS Transcoders
&i/o-file-already-exists: R6RS I/O Conditions
&i/o-file-does-not-exist: R6RS I/O Conditions
&i/o-file-is-read-only: R6RS I/O Conditions
&i/o-file-protection: R6RS I/O Conditions
&i/o-filename: R6RS I/O Conditions
&i/o-invalid-position: R6RS I/O Conditions
&i/o-port: R6RS I/O Conditions
&i/o-read: R6RS I/O Conditions
&i/o-write: R6RS I/O Conditions
&implementation-restriction: rnrs conditions
&irritants: rnrs conditions
&lexical: rnrs conditions
&message: rnrs conditions
&no-infinities: rnrs arithmetic flonums
&no-nans: rnrs arithmetic flonums
&non-continuable: rnrs conditions
&serious: rnrs conditions
&syntax: rnrs conditions
&undefined: rnrs conditions
&violation: rnrs conditions
&warning: rnrs conditions
&who: rnrs conditions

': Expression Syntax

(oop goops): GOOPS
(scm_t_bits: Non-Immediate Objects

*: Arithmetic
*: rnrs base
*scm_to_latin1_stringn: Conversion to/from C
*scm_to_stringn: Conversion to/from C
*scm_to_utf32_stringn: Conversion to/from C
*scm_to_utf8_stringn: Conversion to/from C

+: Arithmetic
+: rnrs base

,: Expression Syntax
,@: Expression Syntax

-: Arithmetic
-: rnrs base
->char-set: Creating Character Sets

...: Syntax Rules

/: Arithmetic
/: rnrs base

1+: Arithmetic
1+: Arithmetic
1-: Arithmetic
1-: Arithmetic

<: Comparison
<: rnrs base
<=: Comparison
<=: rnrs base
<?: Comparison Instructions

=: Comparison
=: rnrs base
==: Equality
=>: Syntax Rules
=?: Comparison Instructions

>: Comparison
>: rnrs base
>=: Comparison
>=: rnrs base

@: Using Guile Modules
@@: Using Guile Modules

_: Syntax Rules

`: Expression Syntax

abandoned-mutex-exception?: SRFI-18 Exceptions
abort: Shift and Reset
abort: Non-Local Control Flow Instructions
abort-to-prompt: Prompt Primitives
abs: Arithmetic
abs: rnrs base
absolute-file-name?: File System
accept: Network Sockets and Communication
access?: File System
acons: Adding or Setting Alist Entries
acos: Scientific
acos: rnrs base
acosh: Scientific
activate-readline: Readline Functions
adapt-response-version: Responses
add: Intrinsic Call Instructions
add-duration: SRFI-19 Time
add-duration!: SRFI-19 Time
add-ephemeral-stepping-trap!: High-Level Traps
add-ephemeral-trap-at-frame-finish!: High-Level Traps
add-fdes-finalizer!: Ports and File Descriptors
add-hook!: Hook Reference
add-method!: Method Definition Internals
add-method!: Method Definition Internals
add-method!: Method Definition Internals
add-method!: Method Definition Internals
add-method!: Method Definition Internals
add-ref-resolver!: texinfo html
add-to-load-path: Load Paths
add-trace-at-procedure-call!: High-Level Traps
add-trap!: Trap States
add-trap-at-procedure-call!: High-Level Traps
add-trap-at-source-location!: High-Level Traps
add/immediate: Intrinsic Call Instructions
addrinfo:addr: Network Databases
addrinfo:canonname: Network Databases
addrinfo:fam: Network Databases
addrinfo:flags: Network Databases
addrinfo:protocol: Network Databases
addrinfo:socktype: Network Databases
alarm: Signals
alignof: Foreign Structs
alist->hash-table: Hash Table Reference
alist->hash-table: SRFI-69 Creating hash tables
alist->hashq-table: Hash Table Reference
alist->hashv-table: Hash Table Reference
alist->hashx-table: Hash Table Reference
alist->vhash: VHashes
alist-cons: SRFI-1 Association Lists
alist-copy: SRFI-1 Association Lists
alist-delete: SRFI-1 Association Lists
alist-delete!: SRFI-1 Association Lists
all-mapped-elf-images: Bytecode
all-threads: Threads
alloc-frame: Function Prologue Instructions
allocate-words: Memory Access Instructions
allocate-words: Bytecode
allocate-words/immediate: Memory Access Instructions
and: and or
and: rnrs base
and-let*: SRFI-2
and=>: Higher-Order Functions
angle: Complex
angle: rnrs base
any: SRFI-1 Searching
any->c32vector: SRFI-4 Extensions
any->c64vector: SRFI-4 Extensions
any->f32vector: SRFI-4 Extensions
any->f64vector: SRFI-4 Extensions
any->s16vector: SRFI-4 Extensions
any->s32vector: SRFI-4 Extensions
any->s64vector: SRFI-4 Extensions
any->s8vector: SRFI-4 Extensions
any->u16vector: SRFI-4 Extensions
any->u32vector: SRFI-4 Extensions
any->u64vector: SRFI-4 Extensions
any->u8vector: SRFI-4 Extensions
any-bits-set?: SRFI-60
append: Append/Reverse
append: Append/Reverse
append: rnrs base
append: rnrs base
append!: Append/Reverse
append!: Append/Reverse
append-map: SRFI-1 Fold and Map
append-map!: SRFI-1 Fold and Map
append-reverse: SRFI-1 Length Append etc
append-reverse!: SRFI-1 Length Append etc
apply: Fly Evaluation
apply: rnrs base
apply-templates: sxml apply-templates
apropos: Help Commands
apropos-completion-function: Readline Functions
args-fold: SRFI-37
arguments<=?: Function Prologue Instructions
arithmetic-shift: SRFI-60
arity:allow-other-keys?: Compiled Procedures
arity:end: Compiled Procedures
arity:kw: Compiled Procedures
arity:nopt: Compiled Procedures
arity:nreq: Compiled Procedures
arity:rest?: Compiled Procedures
arity:start: Compiled Procedures
array->list: Array Procedures
array-cell-ref: Arrays as arrays of arrays
array-cell-set!: Arrays as arrays of arrays
array-contents: Shared Arrays
array-copy: Array Procedures
array-copy!: Array Procedures
array-copy-in-order!: Array Procedures
array-dimensions: Array Procedures
array-equal?: Array Procedures
array-fill!: Array Procedures
array-for-each: Array Procedures
array-in-bounds?: Array Procedures
array-index-map!: Array Procedures
array-length: Array Procedures
array-map!: Array Procedures
array-map-in-order!: Array Procedures
array-rank: Array Procedures
array-ref: Array Procedures
array-set!: Array Procedures
array-shape: Array Procedures
array-slice: Arrays as arrays of arrays
array-slice-for-each: Arrays as arrays of arrays
array-slice-for-each-in-order: Arrays as arrays of arrays
array-type: Array Procedures
array?: Array Procedures
array?: Comparison Instructions
ash: Bitwise Operations
asin: Scientific
asin: rnrs base
asinh: Scientific
assert: rnrs base
assert-curr-char: sxml ssax input-parse
assert-nargs-ee: Function Prologue Instructions
assert-nargs-ee/locals: Function Prologue Instructions
assert-nargs-ge: Function Prologue Instructions
assert-nargs-le: Function Prologue Instructions
assertion-violation: rnrs base
assertion-violation?: rnrs conditions
assoc: Retrieving Alist Entries
assoc: SRFI-1 Association Lists
assoc: rnrs lists
assoc-ref: Retrieving Alist Entries
assoc-remove!: Removing Alist Entries
assoc-set!: Adding or Setting Alist Entries
assp: rnrs lists
assq: Retrieving Alist Entries
assq: rnrs lists
assq-ref: Retrieving Alist Entries
assq-remove!: Removing Alist Entries
assq-set!: Adding or Setting Alist Entries
assv: Retrieving Alist Entries
assv: rnrs lists
assv-ref: Retrieving Alist Entries
assv-remove!: Removing Alist Entries
assv-set!: Adding or Setting Alist Entries
atan: Scientific
atan: Scientific
atan: rnrs base
atanh: Scientific
atomic-box-compare-and-swap!: Atomics
atomic-box-ref: Atomics
atomic-box-set!: Atomics
atomic-box-swap!: Atomics
atomic-box?: Atomics
atomic-box?: Comparison Instructions
atomic-scm-compare-and-swap!/immediate: Atomic Memory Access Instructions
atomic-scm-ref/immediate: Atomic Memory Access Instructions
atomic-scm-set!/immediate: Atomic Memory Access Instructions
atomic-scm-swap!/immediate: Atomic Memory Access Instructions
attlist->alist: SSAX
attlist-add: SSAX
attlist-fold: SSAX
attlist-null?: SSAX
attlist-remove-top: SSAX

backtrace: Debug Commands
backtrace: Pre-Unwind Debugging
basename: File System
begin: begin
begin: rnrs base
begin-thread: Threads
bignum?: Comparison Instructions
binary-port?: rnrs io ports
bind: Network Sockets and Communication
bind: Network Sockets and Communication
bind: Network Sockets and Communication
bind: Network Sockets and Communication
bind-kwargs: Function Prologue Instructions
bind-optionals: Function Prologue Instructions
bind-rest: Function Prologue Instructions
bind-textdomain-codeset: Gettext Support
binding: Module Commands
binding-index: Frames
binding-name: Frames
binding-ref: Frames
binding-representation: Frames
binding-set!: Frames
binding-slot: Frames
binding:boxed?: Compiled Procedures
binding:end: Compiled Procedures
binding:index: Compiled Procedures
binding:name: Compiled Procedures
binding:start: Compiled Procedures
bindtextdomain: Gettext Support
bit-count: SRFI-60
bit-extract: Bitwise Operations
bit-field: SRFI-60
bit-set?: SRFI-60
bitvector: Bit Vectors
bitvector->list: Bit Vectors
bitvector-bit-clear?: Bit Vectors
bitvector-bit-set?: Bit Vectors
bitvector-clear-all-bits!: Bit Vectors
bitvector-clear-bit!: Bit Vectors
bitvector-clear-bits!: Bit Vectors
bitvector-copy: Bit Vectors
bitvector-count: Bit Vectors
bitvector-count-bits: Bit Vectors
bitvector-flip-all-bits!: Bit Vectors
bitvector-length: Bit Vectors
bitvector-position: Bit Vectors
bitvector-set-all-bits!: Bit Vectors
bitvector-set-bit!: Bit Vectors
bitvector-set-bits!: Bit Vectors
bitvector?: Bit Vectors
bitvector?: Comparison Instructions
bitwise-and: SRFI-60
bitwise-and: rnrs arithmetic bitwise
bitwise-arithmetic-shift: rnrs arithmetic bitwise
bitwise-arithmetic-shift-left: rnrs arithmetic bitwise
bitwise-arithmetic-shift-right: rnrs arithmetic bitwise
bitwise-bit-count: rnrs arithmetic bitwise
bitwise-bit-field: rnrs arithmetic bitwise
bitwise-bit-set?: rnrs arithmetic bitwise
bitwise-copy-bit: rnrs arithmetic bitwise
bitwise-copy-bit-field: rnrs arithmetic bitwise
bitwise-first-bit-set: rnrs arithmetic bitwise
bitwise-if: SRFI-60
bitwise-if: rnrs arithmetic bitwise
bitwise-ior: SRFI-60
bitwise-ior: rnrs arithmetic bitwise
bitwise-length: rnrs arithmetic bitwise
bitwise-merge: SRFI-60
bitwise-not: SRFI-60
bitwise-not: rnrs arithmetic bitwise
bitwise-reverse-bit-field: rnrs arithmetic bitwise
bitwise-rotate-bit-field: rnrs arithmetic bitwise
bitwise-xor: SRFI-60
bitwise-xor: rnrs arithmetic bitwise
boolean?: Booleans
boolean?: rnrs base
booleans->integer: SRFI-60
bound-identifier=?: Syntax Transformer Helpers
bound-identifier=?: rnrs syntax-case
box: SRFI-111
box?: SRFI-111
break: Debug Commands
break: while do
break: SRFI-1 Searching
break!: SRFI-1 Searching
break-at-source: Debug Commands
broadcast-condition-variable: Mutexes and Condition Variables
buffer-mode: R6RS File Ports
buffer-mode?: R6RS File Ports
build-cont: Building CPS
build-cont: Building CPS
build-cont: Building CPS
build-cont: Building CPS
build-cont: Building CPS
build-cont: Building CPS
build-cont: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-exp: Building CPS
build-relative-ref: URIs
build-request: Requests
build-response: Responses
build-term: Building CPS
build-term: Building CPS
build-term: Building CPS
build-term: Building CPS
build-term: Building CPS
build-term: Building CPS
build-term: Building CPS
build-term: Building CPS
build-uri: URIs
build-uri-reference: URIs
builtin-ref: Trampoline Instructions
bytevector: Bytevector Procedures in R7RS
bytevector->pointer: Void Pointers and Byte Access
bytevector->sint-list: Bytevectors and Integer Lists
bytevector->string: Representing Strings as Bytes
bytevector->string: R6RS Transcoders
bytevector->u8-list: Bytevectors and Integer Lists
bytevector->uint-list: Bytevectors and Integer Lists
bytevector-append: Bytevector Procedures in R7RS
bytevector-copy: Bytevector Manipulation
bytevector-copy: Bytevector Procedures in R7RS
bytevector-copy!: Bytevector Manipulation
bytevector-copy!: Bytevector Procedures in R7RS
bytevector-fill!: Bytevector Manipulation
bytevector-ieee-double-native-ref: Bytevectors as Floats
bytevector-ieee-double-native-set!: Bytevectors as Floats
bytevector-ieee-double-ref: Bytevectors as Floats
bytevector-ieee-double-set!: Bytevectors as Floats
bytevector-ieee-single-native-ref: Bytevectors as Floats
bytevector-ieee-single-native-set!: Bytevectors as Floats
bytevector-ieee-single-ref: Bytevectors as Floats
bytevector-ieee-single-set!: Bytevectors as Floats
bytevector-length: Bytevector Manipulation
bytevector-s16-native-ref: Bytevectors as Integers
bytevector-s16-native-set!: Bytevectors as Integers
bytevector-s16-ref: Bytevectors as Integers
bytevector-s16-set!: Bytevectors as Integers
bytevector-s32-native-ref: Bytevectors as Integers
bytevector-s32-native-set!: Bytevectors as Integers
bytevector-s32-ref: Bytevectors as Integers
bytevector-s32-set!: Bytevectors as Integers
bytevector-s64-native-ref: Bytevectors as Integers
bytevector-s64-native-set!: Bytevectors as Integers
bytevector-s64-ref: Bytevectors as Integers
bytevector-s64-set!: Bytevectors as Integers
bytevector-s8-ref: Bytevectors as Integers
bytevector-s8-set!: Bytevectors as Integers
bytevector-sint-ref: Bytevectors as Integers
bytevector-sint-set!: Bytevectors as Integers
bytevector-slice: Bytevector Slices
bytevector-u16-native-ref: Bytevectors as Integers
bytevector-u16-native-set!: Bytevectors as Integers
bytevector-u16-ref: Bytevectors as Integers
bytevector-u16-set!: Bytevectors as Integers
bytevector-u32-native-ref: Bytevectors as Integers
bytevector-u32-native-set!: Bytevectors as Integers
bytevector-u32-ref: Bytevectors as Integers
bytevector-u32-set!: Bytevectors as Integers
bytevector-u64-native-ref: Bytevectors as Integers
bytevector-u64-native-set!: Bytevectors as Integers
bytevector-u64-ref: Bytevectors as Integers
bytevector-u64-set!: Bytevectors as Integers
bytevector-u8-reduce: SRFI-171 Helpers
bytevector-u8-ref: Bytevectors as Integers
bytevector-u8-set!: Bytevectors as Integers
bytevector-u8-transduce: SRFI-171 Applying Transducers
bytevector-u8-transduce: SRFI-171 Applying Transducers
bytevector-uint-ref: Bytevectors as Integers
bytevector-uint-set!: Bytevectors as Integers
bytevector=?: Bytevector Manipulation
bytevector?: Bytevector Manipulation
bytevector?: Comparison Instructions

c32vector: SRFI-4 API
c32vector->list: SRFI-4 API
c32vector-copy: SRFI-4 Extensions
c32vector-copy!: SRFI-4 Extensions
c32vector-length: SRFI-4 API
c32vector-ref: SRFI-4 API
c32vector-set!: SRFI-4 API
c32vector?: SRFI-4 API
c64vector: SRFI-4 API
c64vector->list: SRFI-4 API
c64vector-copy: SRFI-4 Extensions
c64vector-copy!: SRFI-4 Extensions
c64vector-length: SRFI-4 API
c64vector-ref: SRFI-4 API
c64vector-set!: SRFI-4 API
c64vector?: SRFI-4 API
caaaar: Pairs
caaaar: rnrs base
caaadr: Pairs
caaadr: rnrs base
caaar: Pairs
caaar: rnrs base
caadar: Pairs
caadar: rnrs base
caaddr: Pairs
caaddr: rnrs base
caadr: Pairs
caadr: rnrs base
caar: Pairs
caar: rnrs base
cadaar: Pairs
cadaar: rnrs base
cadadr: Pairs
cadadr: rnrs base
cadar: Pairs
cadar: rnrs base
caddar: Pairs
caddar: rnrs base
cadddr: Pairs
cadddr: rnrs base
caddr: Pairs
caddr: rnrs base
cadr: Pairs
cadr: rnrs base
call: Instruction Set
call: Call and Return Instructions
call-f64<-scm: Intrinsic Call Instructions
call-label: Call and Return Instructions
call-s64<-scm: Intrinsic Call Instructions
call-scm-scm: Intrinsic Call Instructions
call-scm-scm-scm: Intrinsic Call Instructions
call-scm-sz-u32: Intrinsic Call Instructions
call-scm-uimm-scm: Intrinsic Call Instructions
call-scm<-s64: Intrinsic Call Instructions
call-scm<-scm: Intrinsic Call Instructions
call-scm<-scm-scm: Intrinsic Call Instructions
call-scm<-scm-u64: Intrinsic Call Instructions
call-scm<-scm-uimm: Intrinsic Call Instructions
call-scm<-thread: Intrinsic Call Instructions
call-scm<-thread-scm: Intrinsic Call Instructions
call-scm<-u64: Intrinsic Call Instructions
call-thread: Intrinsic Call Instructions
call-thread-scm: Intrinsic Call Instructions
call-thread-scm-scm: Intrinsic Call Instructions
call-u64<-scm: Intrinsic Call Instructions
call-with-allocation-limit: Sandboxed Evaluation
call-with-blocked-asyncs: Asyncs
call-with-current-continuation: Continuations
call-with-current-continuation: rnrs base
call-with-error-handling: Standard Error Handling
call-with-escape-continuation: Prompt Primitives
call-with-file-and-dir: texinfo
call-with-input-bytevector: Bytevector Ports
call-with-input-file: File Ports
call-with-input-file: rnrs io simple
call-with-input-string: String Ports
call-with-new-thread: Threads
call-with-output-bytevector: Bytevector Ports
call-with-output-encoded-string: Representing Strings as Bytes
call-with-output-file: File Ports
call-with-output-file: rnrs io simple
call-with-output-string: String Ports
call-with-port: Ports
call-with-port: rnrs io ports
call-with-prompt: Prompt Primitives
call-with-stack-overflow-handler: Stack Overflow
call-with-time-and-allocation-limits: Sandboxed Evaluation
call-with-time-limit: Sandboxed Evaluation
call-with-trace: Tracing Traps
call-with-unblocked-asyncs: Asyncs
call-with-values: Multiple Values
call-with-values: rnrs base
call/cc: Continuations
call/cc: rnrs base
call/ec: Prompt Primitives
cancel-thread: Threads
canonicalize-path: File System
capture-continuation: Non-Local Control Flow Instructions
car: Pairs
car: rnrs base
car+cdr: SRFI-1 Selectors
case: Conditionals
case: rnrs base
case-lambda: Case-lambda
case-lambda: rnrs control
case-lambda*: Case-lambda
catch: Throw and Catch
cd: Processes
cdaaar: Pairs
cdaaar: rnrs base
cdaadr: Pairs
cdaadr: rnrs base
cdaar: Pairs
cdaar: rnrs base
cdadar: Pairs
cdadar: rnrs base
cdaddr: Pairs
cdaddr: rnrs base
cdadr: Pairs
cdadr: rnrs base
cdar: Pairs
cdar: rnrs base
cddaar: Pairs
cddaar: rnrs base
cddadr: Pairs
cddadr: rnrs base
cddar: Pairs
cddar: rnrs base
cdddar: Pairs
cdddar: rnrs base
cddddr: Pairs
cddddr: rnrs base
cdddr: Pairs
cdddr: rnrs base
cddr: Pairs
cddr: rnrs base
cdr: Pairs
cdr: rnrs base
ceiling: Arithmetic
ceiling: rnrs base
ceiling-quotient: Arithmetic
ceiling-remainder: Arithmetic
ceiling/: Arithmetic
center-string: texinfo string-utils
centered-quotient: Arithmetic
centered-remainder: Arithmetic
centered/: Arithmetic
change-class: Changing the Class of an Instance
change-class: Changing the Class of an Instance
char->formal-name: Characters
char->integer: Characters
char->integer: rnrs base
char-alphabetic?: Characters
char-alphabetic?: rnrs unicode
char-ci<=?: Characters
char-ci<=?: rnrs unicode
char-ci<?: Characters
char-ci<?: rnrs unicode
char-ci=?: Characters
char-ci=?: rnrs unicode
char-ci>=?: Characters
char-ci>=?: rnrs unicode
char-ci>?: Characters
char-ci>?: rnrs unicode
char-downcase: Characters
char-downcase: rnrs unicode
char-foldcase: rnrs unicode
char-general-category: Characters
char-general-category: rnrs unicode
char-is-both?: Characters
char-locale-ci<?: Text Collation
char-locale-ci=?: Text Collation
char-locale-ci>?: Text Collation
char-locale-downcase: Character Case Mapping
char-locale-titlecase: Character Case Mapping
char-locale-upcase: Character Case Mapping
char-locale<?: Text Collation
char-locale>?: Text Collation
char-lower-case?: Characters
char-lower-case?: rnrs unicode
char-numeric?: Characters
char-numeric?: rnrs unicode
char-ready?: Venerable Port Interfaces
char-set: Creating Character Sets
char-set->list: Querying Character Sets
char-set->string: Querying Character Sets
char-set-adjoin: Character-Set Algebra
char-set-adjoin!: Character-Set Algebra
char-set-any: Querying Character Sets
char-set-complement: Character-Set Algebra
char-set-complement!: Character-Set Algebra
char-set-contains?: Querying Character Sets
char-set-copy: Creating Character Sets
char-set-count: Querying Character Sets
char-set-cursor: Iterating Over Character Sets
char-set-cursor-next: Iterating Over Character Sets
char-set-delete: Character-Set Algebra
char-set-delete!: Character-Set Algebra
char-set-diff+intersection: Character-Set Algebra
char-set-diff+intersection!: Character-Set Algebra
char-set-difference: Character-Set Algebra
char-set-difference!: Character-Set Algebra
char-set-every: Querying Character Sets
char-set-filter: Creating Character Sets
char-set-filter!: Creating Character Sets
char-set-fold: Iterating Over Character Sets
char-set-for-each: Iterating Over Character Sets
char-set-hash: Character Set Predicates/Comparison
char-set-intersection: Character-Set Algebra
char-set-intersection!: Character-Set Algebra
char-set-map: Iterating Over Character Sets
char-set-ref: Iterating Over Character Sets
char-set-size: Querying Character Sets
char-set-unfold: Iterating Over Character Sets
char-set-unfold!: Iterating Over Character Sets
char-set-union: Character-Set Algebra
char-set-union!: Character-Set Algebra
char-set-xor: Character-Set Algebra
char-set-xor!: Character-Set Algebra
char-set<=: Character Set Predicates/Comparison
char-set=: Character Set Predicates/Comparison
char-set?: Character Set Predicates/Comparison
char-title-case?: rnrs unicode
char-titlecase: Characters
char-titlecase: rnrs unicode
char-upcase: Characters
char-upcase: rnrs unicode
char-upper-case?: Characters
char-upper-case?: rnrs unicode
char-whitespace?: Characters
char-whitespace?: rnrs unicode
char<=?: Characters
char<=?: rnrs base
char<?: Characters
char<?: rnrs base
char=?: Characters
char=?: rnrs base
char>=?: Characters
char>=?: rnrs base
char>?: Characters
char>?: rnrs base
char?: Characters
char?: rnrs base
char?: Comparison Instructions
chdir: Processes
chmod: File System
chown: File System
chownat: File System
chroot: Processes
circular-list: SRFI-1 Constructors
circular-list?: SRFI-1 Predicates
class: Class Definition Protocol
class-direct-methods: Classes
class-direct-slots: Classes
class-direct-subclasses: Classes
class-direct-supers: Classes
class-methods: Classes
class-name: Classes
class-of: Instances
class-of: Intrinsic Call Instructions
class-precedence-list: Classes
class-redefinition: Customizing Class Redefinition
class-redefinition: Customizing Class Redefinition
class-redefinition: Customizing Class Redefinition
class-slot-definition: Slots
class-slot-ref: Accessing Slots
class-slot-set!: Accessing Slots
class-slots: Classes
class-subclasses: Classes
clear-value-history!: Value History
close: Ports and File Descriptors
close-fdes: Ports and File Descriptors
close-input-port: rnrs io simple
close-output-port: rnrs io simple
close-pipe: Pipes
close-port: Ports
close-server: Web Server
closedir: File System
collapse-repeated-chars: texinfo string-utils
command-line: Runtime Environment
command-line: rnrs programs
compile: Compile Commands
compile: Compilation
compile-file: Compile Commands
compile-file: Compilation
compile-peg-pattern: PEG API Reference
compiled-file-name: Compilation
complex?: Complex Numbers
complex?: rnrs base
compnum?: Comparison Instructions
compose: Higher-Order Functions
compose-continuation: Non-Local Control Flow Instructions
compute-std-cpl: Customizing Class Definition
concatenate: SRFI-1 Length Append etc
concatenate!: SRFI-1 Length Append etc
cond: Conditionals
cond: rnrs base
cond-expand: SRFI-0
condition: SRFI-35
condition: rnrs conditions
condition-accessor: rnrs conditions
condition-has-type?: SRFI-35
condition-irritants: rnrs conditions
condition-message: SRFI-35
condition-message: rnrs conditions
condition-predicate: rnrs conditions
condition-ref: SRFI-35
condition-type?: SRFI-35
condition-variable-broadcast!: SRFI-18 Condition variables
condition-variable-name: SRFI-18 Condition variables
condition-variable-signal!: SRFI-18 Condition variables
condition-variable-specific: SRFI-18 Condition variables
condition-variable-specific-set!: SRFI-18 Condition variables
condition-variable?: Mutexes and Condition Variables
condition-variable?: SRFI-18 Condition variables
condition-who: rnrs conditions
condition?: rnrs conditions
connect: Network Sockets and Communication
connect: Network Sockets and Communication
connect: Network Sockets and Communication
connect: Network Sockets and Communication
cons: Pairs
cons: rnrs base
cons*: List Constructors
cons*: rnrs lists
cons*: rnrs lists
cons-source: Source Properties
const: Higher-Order Functions
context-flatten: PEG API Reference
continuation-call: Non-Local Control Flow Instructions
continue: while do
copy-bit: SRFI-60
copy-bit-field: SRFI-60
copy-file: File System
copy-random-state: Random
copy-time: SRFI-19 Time
copy-tree: Copying
cos: Scientific
cos: rnrs base
cosh: Scientific
count: SRFI-1 Length Append etc
coverage-data->lcov: Code Coverage
coverage-data?: Code Coverage
crypt: Encryption
ctermid: Terminals and Ptys
current-date: SRFI-19 Date
current-dynamic-state: Fluids and Dynamic States
current-error-port: Default Ports
current-error-port: rnrs io ports
current-exception-handler: SRFI-18 Exceptions
current-filename: Source Properties
current-http-proxy: Web Client
current-https-proxy: Web Client
current-input-port: Default Ports
current-input-port: rnrs io ports
current-julian-day: SRFI-19 Date
current-load-port: Loading
current-modified-julian-day: SRFI-19 Date
current-module: Module System Reflection
current-module: Intrinsic Call Instructions
current-output-port: Default Ports
current-output-port: rnrs io ports
current-processor-count: Threads
current-read-waiter: Non-Blocking I/O
current-source-location: Source Properties
current-ssax-error-port: SSAX
current-thread: Threads
current-thread: SRFI-18 Threads
current-thread: Atomic Memory Access Instructions
current-time: Time
current-time: SRFI-18 Time
current-time: SRFI-19 Time
current-write-waiter: Non-Blocking I/O
cut: SRFI-26
cute: SRFI-26

date->julian-day: SRFI-19 Time/Date conversions
date->modified-julian-day: SRFI-19 Time/Date conversions
date->string: SRFI-19 Date to string
date->time-monotonic: SRFI-19 Time/Date conversions
date->time-tai: SRFI-19 Time/Date conversions
date->time-utc: SRFI-19 Time/Date conversions
date-day: SRFI-19 Date
date-hour: SRFI-19 Date
date-minute: SRFI-19 Date
date-month: SRFI-19 Date
date-nanosecond: SRFI-19 Date
date-second: SRFI-19 Date
date-week-day: SRFI-19 Date
date-week-number: SRFI-19 Date
date-year: SRFI-19 Date
date-year-day: SRFI-19 Date
date-zone-offset: SRFI-19 Date
date?: SRFI-19 Date
datum->random-state: Random
datum->syntax: Syntax Case
datum->syntax: rnrs syntax-case
debug-disable: Debug Options
debug-enable: Debug Options
debug-options: Debug Options
debug-set!: Debug Options
declare-default-port!: URIs
declare-header!: HTTP
declare-opaque-header!: HTTP
deep-clone: GOOPS Object Miscellany
deep-clone: GOOPS Object Miscellany
default-duplicate-binding-handler: Creating Guile Modules
default-optimization-level: Compilation
default-prompt-tag: Prompt Primitives
default-random-source: SRFI-27 Default Random Source
default-warning-level: Compilation
define: Top Level
define: rnrs base
define: Curried Definitions
define!: Intrinsic Call Instructions
define*: lambda* and define*
define*: Curried Definitions
define*-public: ice-9 optargs
define-accessor: Accessors
define-class: Class Definition
define-class: Class Definition
define-condition-type: SRFI-35
define-condition-type: rnrs conditions
define-enumeration: rnrs enums
define-exception-type: Exception Objects
define-foreign-object-type: Foreign Objects
define-generic: Methods and Generic Functions
define-generic: Methods and Generic Functions
define-immutable-record-type: SRFI-9 Records
define-inlinable: Inlinable Procedures
define-language: Compiler Tower
define-macro: Defmacros
define-method: Methods and Generic Functions
define-method: Methods and Generic Functions
define-module: Creating Guile Modules
define-once: Top Level
define-parsed-entity!: SSAX
define-peg-pattern: PEG API Reference
define-peg-string-patterns: PEG API Reference
define-public: Creating Guile Modules
define-public: Curried Definitions
define-reader-ctor: SRFI-10
define-record-type: SRFI-9 Records
define-record-type: rnrs records syntactic
define-server-impl: Web Server
define-stream: SRFI-41 Stream Library
define-syntax: Defining Macros
define-syntax: rnrs base
define-syntax-parameter: Syntax Parameters
define-syntax-rule: Syntax Rules
define-values: Binding Multiple Values
define-wrapped-pointer-type: Void Pointers and Byte Access
defined?: Binding Reflection
defmacro: Defmacros
defmacro*: ice-9 optargs
defmacro*-public: ice-9 optargs
defvar: Top Level
delay: Delayed Evaluation
delay: SRFI-45
delay: rnrs r5rs
delete: List Modification
delete: SRFI-1 Deleting
delete!: List Modification
delete!: SRFI-1 Deleting
delete-duplicates: SRFI-1 Deleting
delete-duplicates!: SRFI-1 Deleting
delete-file: File System
delete-file-at: File System
delete-trap!: Trap States
delete1!: List Modification
delq: List Modification
delq!: List Modification
delq1!: List Modification
delv: List Modification
delv!: List Modification
delv1!: List Modification
denominator: Reals and Rationals
denominator: rnrs base
deq!: Queues
dereference-pointer: Void Pointers and Byte Access
describe: Help Commands
directory-stream?: File System
dirname: File System
disable-trap!: Trap States
disable-value-history!: Value History
disassemble: Compile Commands
disassemble-file: Compile Commands
display: Scheme Write
display: rnrs io simple
display: rnrs io simple
display: GOOPS Object Miscellany
display-application: Frames
display-backtrace: Stacks
display-error: Handling Errors
div: rnrs base
div: Intrinsic Call Instructions
div-and-mod: rnrs base
div0: rnrs base
div0-and-mod0: rnrs base
do: while do
do: rnrs control
dotted-list?: SRFI-1 Predicates
doubly-weak-hash-table?: Weak hash tables
down: Debug Commands
drain-input: Buffering
drop: SRFI-1 Selectors
drop: Shuffling Instructions
drop-right: SRFI-1 Selectors
drop-right!: SRFI-1 Selectors
drop-while: SRFI-1 Searching
dup: Ports and File Descriptors
dup->fdes: Ports and File Descriptors
dup->inport: Ports and File Descriptors
dup->outport: Ports and File Descriptors
dup->port: Ports and File Descriptors
dup2: Ports and File Descriptors
duplicate-port: Ports and File Descriptors
dynamic-state?: Fluids and Dynamic States
dynamic-state?: Comparison Instructions
dynamic-wind: Dynamic Wind
dynamic-wind: rnrs base

eager: SRFI-45
effective-version: Build Config
eighth: SRFI-1 Selectors
else: Syntax Rules
emit-allocate-words: Bytecode
emit-begin-kw-arity: Bytecode
emit-begin-opt-arity: Bytecode
emit-begin-program: Bytecode
emit-begin-standard-arity: Bytecode
emit-cache-ref: Bytecode
emit-cache-set!: Bytecode
emit-end-arity: Bytecode
emit-end-program: Bytecode
emit-label: Bytecode
emit-load-constant: Bytecode
emit-load-static-procedure: Bytecode
emit-source: Bytecode
enable-primitive-generic!: Extending Primitives
enable-trap!: Trap States
enable-value-history!: Value History
encode-and-join-uri-path: URIs
end-of-char-set?: Iterating Over Character Sets
endgrent: User Information
endhostent: Network Databases
endianness: Bytevector Endianness
endnetent: Network Databases
endprotoent: Network Databases
endpwent: User Information
endservent: Network Databases
enq!: Queues
ensure-accessor: Generic Function Internals
ensure-generic: Generic Function Internals
ensure-metaclass: Class Definition Protocol
ensure-reduced: SRFI-171 Helpers
enum-set->list: rnrs enums
enum-set-complement: rnrs enums
enum-set-constructor: rnrs enums
enum-set-difference: rnrs enums
enum-set-indexer: rnrs enums
enum-set-intersection: rnrs enums
enum-set-member?: rnrs enums
enum-set-projection: rnrs enums
enum-set-subset?: rnrs enums
enum-set-union: rnrs enums
enum-set-universe: rnrs enums
enum-set=?: rnrs enums
environ: Runtime Environment
environment: rnrs eval
eof-object: rnrs io ports
eof-object: rnrs io simple
eof-object?: Binary I/O
eof-object?: rnrs io ports
eof-object?: rnrs io simple
eof-object?: Comparison Instructions
eol-style: R6RS Transcoders
eq-false?: Comparison Instructions
eq-immediate?: Comparison Instructions
eq-nil?: Comparison Instructions
eq-null?: Comparison Instructions
eq-true?: Comparison Instructions
eq?: Equality
eq?: rnrs base
eq?: Comparison Instructions
equal-hash: rnrs hashtables
equal?: Equality
equal?: rnrs base
eqv?: Equality
eqv?: rnrs base
error: Debug Commands
error: Error Reporting
error: rnrs base
error-handling-mode: R6RS Transcoders
error-message: Debug Commands
error?: Exception Objects
error?: SRFI-35
error?: rnrs conditions
escape-special-chars: texinfo string-utils
euclidean-quotient: Arithmetic
euclidean-remainder: Arithmetic
euclidean/: Arithmetic
eval: Fly Evaluation
eval: rnrs eval
eval-in-sandbox: Sandboxed Evaluation
eval-string: Fly Evaluation
eval-when: Eval When
eval-when: Loading
even?: Integer Operations
even?: rnrs base
every: SRFI-1 Searching
exact: rnrs base
exact->inexact: Exactness
exact->inexact: rnrs r5rs
exact-integer-sqrt: Integer Operations
exact-integer-sqrt: rnrs base
exact-integer?: Integers
exact?: Exactness
exact?: rnrs base
exception-accessor: Exception Objects
exception-args: Throw and Catch
exception-irritants: Exception Objects
exception-kind: Throw and Catch
exception-message: Exception Objects
exception-origin: Exception Objects
exception-predicate: Exception Objects
exception-type?: Exception Objects
exception-with-irritants?: Exception Objects
exception-with-message?: Exception Objects
exception-with-origin?: Exception Objects
exception?: Exception Objects
execl: Processes
execle: Processes
execlp: Processes
exists: rnrs lists
exit: Processes
exit: rnrs programs
exp: Scientific
exp: rnrs base
expand: Compile Commands
expand-apply-argument: Shuffling Instructions
expand-tabs: texinfo string-utils
expect: Expect
expect-strings: Expect
export: Creating Guile Modules
export!: Creating Guile Modules
expt: Scientific
expt: rnrs base
external-error?: Exception Objects
extract-condition: SRFI-35

f32-ref: Raw Memory Access Instructions
f32-set!: Raw Memory Access Instructions
f32vector: SRFI-4 API
f32vector->list: SRFI-4 API
f32vector-copy: SRFI-4 Extensions
f32vector-copy!: SRFI-4 Extensions
f32vector-length: SRFI-4 API
f32vector-ref: SRFI-4 API
f32vector-set!: SRFI-4 API
f32vector?: SRFI-4 API
f64-ref: Raw Memory Access Instructions
f64-set!: Raw Memory Access Instructions
f64<?: Comparison Instructions
f64=?: Comparison Instructions
f64vector: SRFI-4 API
f64vector->list: SRFI-4 API
f64vector-copy: SRFI-4 Extensions
f64vector-copy!: SRFI-4 Extensions
f64vector-length: SRFI-4 API
f64vector-ref: SRFI-4 API
f64vector-set!: SRFI-4 API
f64vector?: SRFI-4 API
fadd: Floating-Point Arithmetic Instructions
false-if-exception: Error Reporting
false?: Comparison Instructions
fchmod: File System
fchown: File System
fchownat: File System
fcntl: Ports and File Descriptors
fdes->inport: Ports and File Descriptors
fdes->outport: Ports and File Descriptors
fdes->ports: Ports and File Descriptors
fdiv: Floating-Point Arithmetic Instructions
fdopen: Ports and File Descriptors
feature?: Feature Manipulation
fflush: Buffering
fifth: SRFI-1 Selectors
file-encoding: Character Encoding of Source Files
file-exists?: File System
file-name-separator?: File System
file-options: R6RS File Ports
file-port?: File Ports
file-system-fold: File Tree Walk
file-system-tree: File Tree Walk
filename-completion-function: Readline Functions
fileno: Ports and File Descriptors
fill-string: texinfo string-utils
filter: List Modification
filter: rnrs lists
filter: SXPath
filter!: List Modification
filter-empty-elements: texinfo docbook
filter-map: SRFI-1 Fold and Map
find: SRFI-1 Searching
find: rnrs lists
find-mapped-elf-image: Bytecode
find-string-from-port?: sxml ssax input-parse
find-tail: SRFI-1 Searching
finish: Debug Commands
finite?: Reals and Rationals
finite?: rnrs base
first: SRFI-1 Selectors
first-set-bit: SRFI-60
fixnum->flonum: rnrs arithmetic flonums
fixnum-width: rnrs arithmetic fixnums
fixnum?: rnrs arithmetic fixnums
fixnum?: Comparison Instructions
fl*: rnrs arithmetic flonums
fl+: rnrs arithmetic flonums
fl-: rnrs arithmetic flonums
fl-: rnrs arithmetic flonums
fl/: rnrs arithmetic flonums
fl/: rnrs arithmetic flonums
fl<=?: rnrs arithmetic flonums
fl<?: rnrs arithmetic flonums
fl=?: rnrs arithmetic flonums
fl>=?: rnrs arithmetic flonums
fl>?: rnrs arithmetic flonums
flabs: rnrs arithmetic flonums
flacos: rnrs arithmetic flonums
flasin: rnrs arithmetic flonums
flatan: rnrs arithmetic flonums
flatan: rnrs arithmetic flonums
flceiling: rnrs arithmetic flonums
flcos: rnrs arithmetic flonums
fldenominator: rnrs arithmetic flonums
fldiv: rnrs arithmetic flonums
fldiv-and-mod: rnrs arithmetic flonums
fldiv0: rnrs arithmetic flonums
fldiv0-and-mod0: rnrs arithmetic flonums
fldmod: rnrs arithmetic flonums
fleven?: rnrs arithmetic flonums
flexp: rnrs arithmetic flonums
flexpt: rnrs arithmetic flonums
flfinite?: rnrs arithmetic flonums
flfloor: rnrs arithmetic flonums
flinfinite?: rnrs arithmetic flonums
flinteger?: rnrs arithmetic flonums
fllog: rnrs arithmetic flonums
fllog: rnrs arithmetic flonums
flmax: rnrs arithmetic flonums
flmin: rnrs arithmetic flonums
flmod0: rnrs arithmetic flonums
flnan?: rnrs arithmetic flonums
flnegative?: rnrs arithmetic flonums
flnumerator: rnrs arithmetic flonums
flock: Ports and File Descriptors
flodd?: rnrs arithmetic flonums
flonum?: rnrs arithmetic flonums
flonum?: Comparison Instructions
floor: Arithmetic
floor: rnrs base
floor-quotient: Arithmetic
floor-remainder: Arithmetic
floor/: Arithmetic
flpositive?: rnrs arithmetic flonums
flround: rnrs arithmetic flonums
flsin: rnrs arithmetic flonums
flsqrt: rnrs arithmetic flonums
fltan: rnrs arithmetic flonums
fltruncate: rnrs arithmetic flonums
fluid->parameter: Parameters
fluid-bound?: Fluids and Dynamic States
fluid-ref: Fluids and Dynamic States
fluid-ref: Intrinsic Call Instructions
fluid-ref*: Fluids and Dynamic States
fluid-set!: Fluids and Dynamic States
fluid-set!: Intrinsic Call Instructions
fluid-thread-local?: Thread Local Variables
fluid-unset!: Fluids and Dynamic States
fluid?: Fluids and Dynamic States
fluid?: Comparison Instructions
flush-all-ports: Buffering
flush-output-port: rnrs io ports
flzero?: rnrs arithmetic flonums
fmul: Floating-Point Arithmetic Instructions
fold: SRFI-1 Fold and Map
fold-layout: SXML Tree Fold
fold-left: rnrs lists
fold-matches: Regexp Functions
fold-right: SRFI-1 Fold and Map
fold-right: rnrs lists
fold-values: SXML Tree Fold
foldt: SXML Tree Fold
foldts: Transforming SXML
foldts: SXML Tree Fold
foldts*: SXML Tree Fold
foldts*-values: SXML Tree Fold
for-all: rnrs lists
for-each: List Mapping
for-each: SRFI-1 Fold and Map
for-each: rnrs base
force: Delayed Evaluation
force: SRFI-45
force: rnrs r5rs
force-output: Buffering
foreign-call: Trampoline Instructions
foreign-library-function: Foreign Functions
foreign-library-pointer: Foreign Pointers
foreign-library?: Foreign Libraries
formal-name->char: Characters
format: SRFI-28
format: Formatted Output
fourth: SRFI-1 Selectors
fracnum?: Comparison Instructions
frame: Debug Commands
frame-address: Frames
frame-arguments: Frames
frame-bindings: Frames
frame-dynamic-link: Frames
frame-instruction-pointer: Frames
frame-lookup-binding: Frames
frame-mv-return-address: Frames
frame-previous: Frames
frame-procedure-name: Frames
frame-return-address: Frames
frame-stack-pointer: Frames
frame?: Frames
frame?: Comparison Instructions
free-identifier=?: Syntax Transformer Helpers
free-identifier=?: rnrs syntax-case
fstat: File System
fsub: Floating-Point Arithmetic Instructions
fsync: Ports and File Descriptors
ftell: Random Access
ftruncate: Random Access
ftw: File Tree Walk
future: Futures
future?: Futures
fx*: rnrs arithmetic fixnums
fx*/carry: rnrs arithmetic fixnums
fx+: rnrs arithmetic fixnums
fx+/carry: rnrs arithmetic fixnums
fx-: rnrs arithmetic fixnums
fx-: rnrs arithmetic fixnums
fx-/carry: rnrs arithmetic fixnums
fx<=?: rnrs arithmetic fixnums
fx<?: rnrs arithmetic fixnums
fx=?: rnrs arithmetic fixnums
fx>=?: rnrs arithmetic fixnums
fx>?: rnrs arithmetic fixnums
fxand: rnrs arithmetic fixnums
fxarithmetic-shift: rnrs arithmetic fixnums
fxarithmetic-shift-left: rnrs arithmetic fixnums
fxarithmetic-shift-right: rnrs arithmetic fixnums
fxbit-count: rnrs arithmetic fixnums
fxbit-field: rnrs arithmetic fixnums
fxbit-set?: rnrs arithmetic fixnums
fxcopy-bit: rnrs arithmetic fixnums
fxcopy-bit-field: rnrs arithmetic fixnums
fxdiv: rnrs arithmetic fixnums
fxdiv-and-mod: rnrs arithmetic fixnums
fxdiv0: rnrs arithmetic fixnums
fxdiv0-and-mod0: rnrs arithmetic fixnums
fxeven?: rnrs arithmetic fixnums
fxfirst-bit-set: rnrs arithmetic fixnums
fxif: rnrs arithmetic fixnums
fxior: rnrs arithmetic fixnums
fxlength: rnrs arithmetic fixnums
fxmax: rnrs arithmetic fixnums
fxmin: rnrs arithmetic fixnums
fxmod: rnrs arithmetic fixnums
fxmod0: rnrs arithmetic fixnums
fxnegative?: rnrs arithmetic fixnums
fxnot: rnrs arithmetic fixnums
fxodd?: rnrs arithmetic fixnums
fxpositive?: rnrs arithmetic fixnums
fxreverse-bit-field: rnrs arithmetic fixnums
fxrotate-bit-field: rnrs arithmetic fixnums
fxxor: rnrs arithmetic fixnums
fxzero?: rnrs arithmetic fixnums

gc: System Commands
gc: Garbage Collection Functions
gc-live-object-stats: Garbage Collection Functions
gc-stats: Garbage Collection Functions
gcd: Integer Operations
gcd: rnrs base
gcprof: Statprof
generate-temporaries: Syntax Transformer Helpers
generate-temporaries: rnrs syntax-case
generator-reduce: SRFI-171 Helpers
generator-transduce: SRFI-171 Applying Transducers
generator-transduce: SRFI-171 Applying Transducers
generic-function-methods: Generic Functions
generic-function-name: Generic Functions
gensym: Symbol Primitives
get-bytevector-all: Binary I/O
get-bytevector-all: rnrs io ports
get-bytevector-n: Binary I/O
get-bytevector-n: rnrs io ports
get-bytevector-n!: Binary I/O
get-bytevector-n!: rnrs io ports
get-bytevector-some: Binary I/O
get-bytevector-some: rnrs io ports
get-bytevector-some!: Binary I/O
get-char: Textual I/O
get-char: rnrs io ports
get-datum: rnrs io ports
get-environment-variable: SRFI-98
get-environment-variables: SRFI-98
get-internal-real-time: Time
get-internal-run-time: Time
get-line: Textual I/O
get-line: rnrs io ports
get-output-bytevector: Binary I/O
get-output-string: String Ports
get-string-all: Textual I/O
get-string-all: rnrs io ports
get-string-n: Textual I/O
get-string-n: rnrs io ports
get-string-n!: Textual I/O
get-string-n!: rnrs io ports
get-u8: Binary I/O
get-u8: rnrs io ports
getaddrinfo: Network Databases
getaffinity: Processes
getcwd: Processes
getegid: Processes
getenv: Runtime Environment
geteuid: Processes
getgid: Processes
getgr: User Information
getgrent: User Information
getgrgid: User Information
getgrnam: User Information
getgroups: Processes
gethost: Network Databases
gethostbyaddr: Network Databases
gethostbyname: Network Databases
gethostent: Network Databases
gethostname: System Identification
getitimer: Signals
getlogin: User Information
getnet: Network Databases
getnetbyaddr: Network Databases
getnetbyname: Network Databases
getnetent: Network Databases
getopt-long: getopt-long Reference
getpass: Encryption
getpeername: Network Sockets and Communication
getpgrp: Processes
getpid: Processes
getppid: Processes
getpriority: Processes
getproto: Network Databases
getprotobyname: Network Databases
getprotobynumber: Network Databases
getprotoent: Network Databases
getpw: User Information
getpwent: User Information
getpwnam: User Information
getpwuid: User Information
getserv: Network Databases
getservbyname: Network Databases
getservbyport: Network Databases
getservent: Network Databases
getsid: Processes
getsockname: Network Sockets and Communication
getsockopt: Network Sockets and Communication
getter-with-setter: SRFI-17
gettext: Gettext Support
gettimeofday: Time
getuid: Processes
gmtime: Time
goops-error: GOOPS Error Handling
greatest-fixnum: rnrs arithmetic fixnums
group:gid: User Information
group:mem: User Information
group:name: User Information
group:passwd: User Information
guard: SRFI-34
guard: rnrs exceptions
guild compile: Compilation
guile-extensions-path: Foreign Libraries
guile-system-extensions-path: Foreign Libraries
GUILE_FLAGS: Autoconf Macros
GUILE_PKG: Autoconf Macros
GUILE_PROGS: Autoconf Macros
GUILE_SITE_DIR: Autoconf Macros

handle-interrupts: Instrumentation Instructions
handle-request: Web Server
hash: Hash Table Reference
hash: SRFI-69 Hash table algorithms
hash-by-identity: SRFI-69 Hash table algorithms
hash-clear!: Hash Table Reference
hash-count: Hash Table Reference
hash-create-handle!: Hash Table Reference
hash-fold: Hash Table Reference
hash-for-each: Hash Table Reference
hash-for-each-handle: Hash Table Reference
hash-get-handle: Hash Table Reference
hash-map->list: Hash Table Reference
hash-ref: Hash Table Reference
hash-remove!: Hash Table Reference
hash-set!: Hash Table Reference
hash-table->alist: SRFI-69 Table properties
hash-table-delete!: SRFI-69 Accessing table items
hash-table-equivalence-function: SRFI-69 Hash table algorithms
hash-table-exists?: SRFI-69 Accessing table items
hash-table-fold: SRFI-69 Table properties
hash-table-hash-function: SRFI-69 Hash table algorithms
hash-table-keys: SRFI-69 Table properties
hash-table-ref: SRFI-69 Accessing table items
hash-table-ref/default: SRFI-69 Accessing table items
hash-table-set!: SRFI-69 Accessing table items
hash-table-size: SRFI-69 Table properties
hash-table-update!: SRFI-69 Accessing table items
hash-table-update!/default: SRFI-69 Accessing table items
hash-table-values: SRFI-69 Table properties
hash-table-walk: SRFI-69 Table properties
hash-table?: Hash Table Reference
hash-table?: Comparison Instructions
hashq: Hash Table Reference
hashq-create-handle!: Hash Table Reference
hashq-get-handle: Hash Table Reference
hashq-ref: Hash Table Reference
hashq-remove!: Hash Table Reference
hashq-set!: Hash Table Reference
hashtable-clear!: rnrs hashtables
hashtable-clear!: rnrs hashtables
hashtable-contains?: rnrs hashtables
hashtable-copy: rnrs hashtables
hashtable-copy: rnrs hashtables
hashtable-delete!: rnrs hashtables
hashtable-entries: rnrs hashtables
hashtable-equivalence-function: rnrs hashtables
hashtable-hash-function: rnrs hashtables
hashtable-keys: rnrs hashtables
hashtable-mutable?: rnrs hashtables
hashtable-ref: rnrs hashtables
hashtable-set!: rnrs hashtables
hashtable-size: rnrs hashtables
hashtable-update!: rnrs hashtables
hashtable?: rnrs hashtables
hashv: Hash Table Reference
hashv-create-handle!: Hash Table Reference
hashv-get-handle: Hash Table Reference
hashv-ref: Hash Table Reference
hashv-remove!: Hash Table Reference
hashv-set!: Hash Table Reference
hashx-create-handle!: Hash Table Reference
hashx-get-handle: Hash Table Reference
hashx-ref: Hash Table Reference
hashx-remove!: Hash Table Reference
hashx-set!: Hash Table Reference
header->string: HTTP
header-parser: HTTP
header-validator: HTTP
header-writer: HTTP
heap-number?: Comparison Instructions
heap-numbers-equal?: Comparison Instructions
heap-object?: Comparison Instructions
heap-tag=?: Comparison Instructions
help: Help Commands
hook->list: Hook Reference
hook-empty?: Hook Reference
hook?: Hook Reference
hostent:addr-list: Network Databases
hostent:addrtype: Network Databases
hostent:aliases: Network Databases
hostent:length: Network Databases
hostent:name: Network Databases
http: Web Server
http-delete: Web Client
http-get: Web Client
http-head: Web Client
http-options: Web Client
http-post: Web Client
http-put: Web Client
http-request: Web Client
http-trace: Web Client

i/o-decoding-error?: R6RS Transcoders
i/o-encoding-error-char: R6RS Transcoders
i/o-encoding-error?: R6RS Transcoders
i/o-error-filename: R6RS I/O Conditions
i/o-error-port: R6RS I/O Conditions
i/o-error-position: R6RS I/O Conditions
i/o-error?: R6RS I/O Conditions
i/o-file-already-exists-error?: R6RS I/O Conditions
i/o-file-does-not-exist-error?: R6RS I/O Conditions
i/o-file-is-read-only-error?: R6RS I/O Conditions
i/o-file-protection-error?: R6RS I/O Conditions
i/o-filename-error?: R6RS I/O Conditions
i/o-invalid-position-error?: R6RS I/O Conditions
i/o-port-error?: R6RS I/O Conditions
i/o-read-error?: R6RS I/O Conditions
i/o-write-error?: R6RS I/O Conditions
identifier-syntax: Identifier Macros
identifier-syntax: Identifier Macros
identifier-syntax: rnrs base
identifier?: Syntax Case
identifier?: rnrs syntax-case
identity: Higher-Order Functions
if: Conditionals
if: rnrs base
imag-part: Complex
imag-part: rnrs base
imm-s64<?: Comparison Instructions
imm-u64<?: Comparison Instructions
immediate-tag=?: Comparison Instructions
immutable-vector?: Comparison Instructions
implementation-restriction-violation?: rnrs conditions
import: Module Commands
import: R6RS Libraries
in: Module Commands
in: Module Commands
include: Local Inclusion
include-from-path: Local Inclusion
inet-lnaof: Network Address Conversion
inet-makeaddr: Network Address Conversion
inet-netof: Network Address Conversion
inet-ntop: Network Address Conversion
inet-pton: Network Address Conversion
inexact: rnrs base
inexact->exact: Exactness
inexact->exact: rnrs r5rs
inexact?: Exactness
inexact?: rnrs base
inf: Reals and Rationals
inf?: Reals and Rationals
infinite?: rnrs base
input-port?: Ports
input-port?: rnrs io ports
input-port?: rnrs io simple
inspect: Inspect Commands
install-r6rs!: R6RS Incompatibilities
install-r7rs!: R7RS Incompatibilities
install-suspendable-ports!: Non-Blocking I/O
install-trap-handler!: High-Level Traps
instance?: Instances
instrument-entry: Instrumentation Instructions
instrument-loop: Instrumentation Instructions
instrumented-source-files: Code Coverage
instrumented/executed-lines: Code Coverage
integer->char: Characters
integer->char: rnrs base
integer->list: SRFI-60
integer-expt: Bitwise Operations
integer-length: Bitwise Operations
integer-valued?: rnrs base
integer?: Integers
integer?: rnrs base
interaction-environment: Fly Evaluation
iota: SRFI-1 Constructors
irritants-condition?: rnrs conditions
is-a?: Instances
isatty?: Terminals and Ptys

j: Branch Instructions
je: Branch Instructions
jge: Branch Instructions
jl: Branch Instructions
jne: Branch Instructions
jnge: Branch Instructions
jnl: Branch Instructions
join-thread: Threads
join-timeout-exception?: SRFI-18 Exceptions
jtable: Branch Instructions
julian-day->date: SRFI-19 Time/Date conversions
julian-day->time-monotonic: SRFI-19 Time/Date conversions
julian-day->time-tai: SRFI-19 Time/Date conversions
julian-day->time-utc: SRFI-19 Time/Date conversions

keyword->string: SRFI-88
keyword->symbol: Keyword Procedures
keyword-flatten: PEG API Reference
keyword?: Keyword Procedures
keyword?: SRFI-88
keyword?: Comparison Instructions
kill: Signals
known-header?: HTTP

lalr-parser: LALR(1) Parsing
lambda: Lambda
lambda: rnrs base
lambda*: lambda* and define*
language: Language Commands
last: SRFI-1 Selectors
last-pair: List Selection
latin-1-codec: R6RS Transcoders
lazy: SRFI-45
lchown: File System
lcm: Integer Operations
lcm: rnrs base
least-fixnum: rnrs arithmetic fixnums
left-justify-string: texinfo string-utils
length: List Selection
length: rnrs base
length+: SRFI-1 Length Append etc
let: Local Bindings
let: while do
let: rnrs base
let*: Local Bindings
let*: rnrs base
let*-values: SRFI-11
let*-values: rnrs base
let-escape-continuation: Prompt Primitives
let-keywords: ice-9 optargs
let-keywords*: ice-9 optargs
let-optional: ice-9 optargs
let-optional*: ice-9 optargs
let-syntax: Defining Macros
let-syntax: rnrs base
let-values: SRFI-11
let-values: rnrs base
let/ec: Prompt Primitives
letpar: Parallel Forms
letrec: Local Bindings
letrec: rnrs base
letrec*: Local Bindings
letrec*: rnrs base
letrec-syntax: Defining Macros
letrec-syntax: rnrs base
lexical-error?: Exception Objects
lexical-violation?: rnrs conditions
library: R6RS Libraries
line-execution-counts: Code Coverage
link: File System
link-assembly: Bytecode
list: List Constructors
list: rnrs base
list->array: Array Procedures
list->bitvector: Bit Vectors
list->c32vector: SRFI-4 API
list->c64vector: SRFI-4 API
list->char-set: Creating Character Sets
list->char-set!: Creating Character Sets
list->f32vector: SRFI-4 API
list->f64vector: SRFI-4 API
list->integer: SRFI-60
list->s16vector: SRFI-4 API
list->s32vector: SRFI-4 API
list->s64vector: SRFI-4 API
list->s8vector: SRFI-4 API
list->stream: SRFI-41 Stream Library
list->stream: Streams
list->string: String Constructors
list->string: rnrs base
list->symbol: Symbol Primitives
list->typed-array: Array Procedures
list->u16vector: SRFI-4 API
list->u32vector: SRFI-4 API
list->u64vector: SRFI-4 API
list->u8vector: SRFI-4 API
list->vector: Vector Creation
list->vector: SRFI-43 Conversion
list->vector: rnrs base
list->vlist: VLists
list->weak-vector: Weak vectors
list-cdr-ref: List Selection
list-cdr-set!: List Modification
list-copy: List Constructors
list-copy: SRFI-1 Constructors
list-head: List Selection
list-index: SRFI-1 Searching
list-matches: Regexp Functions
list-reduce: SRFI-171 Helpers
list-ref: List Selection
list-ref: rnrs base
list-set!: List Modification
list-sort: rnrs sorting
list-tabulate: SRFI-1 Constructors
list-tail: List Selection
list-tail: rnrs base
list-transduce: SRFI-171 Applying Transducers
list-transduce: SRFI-171 Applying Transducers
list-traps: Trap States
list=: SRFI-1 Predicates
list?: List Predicates
list?: rnrs base
listen: Network Sockets and Communication
load: Module Commands
load: Loading
load-compiled: Loading
load-extension: Foreign Extensions
load-f64: Constant Instructions
load-foreign-library: Foreign Libraries
load-from-path: Load Paths
load-label: Constant Instructions
load-s64: Constant Instructions
load-thunk-from-file: Bytecode
load-thunk-from-memory: Bytecode
load-u64: Constant Instructions
local-compile: Local Evaluation
local-eval: Local Evaluation
locale-am-string: Accessing Locale Information
locale-currency-symbol: Accessing Locale Information
locale-currency-symbol-precedes-negative?: Accessing Locale Information
locale-currency-symbol-precedes-positive?: Accessing Locale Information
locale-date+time-format: Accessing Locale Information
locale-date-format: Accessing Locale Information
locale-day: Accessing Locale Information
locale-day-short: Accessing Locale Information
locale-decimal-point: Accessing Locale Information
locale-digit-grouping: Accessing Locale Information
locale-encoding: Accessing Locale Information
locale-era: Accessing Locale Information
locale-era-date+time-format: Accessing Locale Information
locale-era-date-format: Accessing Locale Information
locale-era-time-format: Accessing Locale Information
locale-era-year: Accessing Locale Information
locale-monetary-decimal-point: Accessing Locale Information
locale-monetary-fractional-digits: Accessing Locale Information
locale-monetary-grouping: Accessing Locale Information
locale-monetary-negative-sign: Accessing Locale Information
locale-monetary-positive-sign: Accessing Locale Information
locale-monetary-thousands-separator: Accessing Locale Information
locale-month: Accessing Locale Information
locale-month-short: Accessing Locale Information
locale-negative-separated-by-space?: Accessing Locale Information
locale-negative-sign-position: Accessing Locale Information
locale-no-regexp: Accessing Locale Information
locale-pm-string: Accessing Locale Information
locale-positive-separated-by-space?: Accessing Locale Information
locale-positive-sign-position: Accessing Locale Information
locale-string->inexact: Number Input and Output
locale-string->integer: Number Input and Output
locale-thousands-separator: Accessing Locale Information
locale-time+am/pm-format: Accessing Locale Information
locale-time-format: Accessing Locale Information
locale-yes-regexp: Accessing Locale Information
locale?: i18n Introduction
locals: Debug Commands
localtime: Time
lock-mutex: Mutexes and Condition Variables
log: Scientific
log: rnrs base
log10: Scientific
log2-binary-factors: SRFI-60
logand: Bitwise Operations
logand: Intrinsic Call Instructions
logbit?: Bitwise Operations
logcount: Bitwise Operations
logior: Bitwise Operations
logior: Intrinsic Call Instructions
lognot: Bitwise Operations
logsub: Intrinsic Call Instructions
logtest: Bitwise Operations
logxor: Bitwise Operations
logxor: Intrinsic Call Instructions
long-fmov: Shuffling Instructions
long-mov: Shuffling Instructions
lookahead-char: Textual I/O
lookahead-char: rnrs io ports
lookahead-u8: Binary I/O
lookahead-u8: rnrs io ports
lookup: Intrinsic Call Instructions
lookup-language: Compiler Tower
lookup-server-impl: Web Server
lset-adjoin: SRFI-1 Set Operations
lset-diff+intersection: SRFI-1 Set Operations
lset-diff+intersection!: SRFI-1 Set Operations
lset-difference: SRFI-1 Set Operations
lset-difference!: SRFI-1 Set Operations
lset-intersection: SRFI-1 Set Operations
lset-intersection!: SRFI-1 Set Operations
lset-union: SRFI-1 Set Operations
lset-union!: SRFI-1 Set Operations
lset-xor: SRFI-1 Set Operations
lset-xor!: SRFI-1 Set Operations
lset<=: SRFI-1 Set Operations
lset=: SRFI-1 Set Operations
lsh: Intrinsic Call Instructions
lsh/immediate: Intrinsic Call Instructions
lstat: File System
ltdl-library-path: Foreign Libraries

macro-binding: Internal Macros
macro-name: Internal Macros
macro-transformer: Internal Macros
macro-type: Internal Macros
macro?: Internal Macros
magnitude: Complex
magnitude: rnrs base
major-version: Build Config
make: Instance Creation
make: Instance Creation
make: Instance Creation
make: Class Definition Protocol
make-accessor: Generic Function Internals
make-arity: Building CPS
make-array: Array Procedures
make-assertion-violation: rnrs conditions
make-atomic-box: Atomics
make-binding: Compiled Procedures
make-bitvector: Bit Vectors
make-buffered-input-port: Buffered Input
make-bytevector: Bytevector Manipulation
make-c-struct: Foreign Structs
make-c32vector: SRFI-4 API
make-c64vector: SRFI-4 API
make-chunked-input-port: Transfer Codings
make-chunked-output-port: Transfer Codings
make-class: Class Definition Protocol
make-completion-function: Readline Functions
make-compound-condition: SRFI-35
make-condition: SRFI-35
make-condition-type: SRFI-35
make-condition-variable: Mutexes and Condition Variables
make-condition-variable: SRFI-18 Condition variables
make-custom-binary-input-port: Custom Ports
make-custom-binary-input-port: rnrs io ports
make-custom-binary-input/output-port: Custom Ports
make-custom-binary-input/output-port: rnrs io ports
make-custom-binary-output-port: Custom Ports
make-custom-binary-output-port: rnrs io ports
make-date: SRFI-19 Date
make-doubly-weak-hash-table: Weak hash tables
make-empty-attlist: SSAX
make-enumeration: rnrs enums
make-eq-hashtable: rnrs hashtables
make-eq-hashtable: rnrs hashtables
make-eqv-hashtable: rnrs hashtables
make-eqv-hashtable: rnrs hashtables
make-error: Exception Objects
make-error: rnrs conditions
make-exception: Exception Objects
make-exception-from-throw: Throw and Catch
make-exception-type: Exception Objects
make-exception-with-irritants: Exception Objects
make-exception-with-message: Exception Objects
make-exception-with-origin: Exception Objects
make-external-error: Exception Objects
make-f32vector: SRFI-4 API
make-f64vector: SRFI-4 API
make-fluid: Fluids and Dynamic States
make-foreign-object-type: Foreign Objects
make-future: Futures
make-generic: Generic Function Internals
make-guardian: Guardians
make-hash-table: Hash Table Reference
make-hash-table: SRFI-69 Creating hash tables
make-hashtable: rnrs hashtables
make-hashtable: rnrs hashtables
make-hook: Hook Reference
make-i/o-decoding-error: R6RS Transcoders
make-i/o-encoding-error: R6RS Transcoders
make-i/o-error: R6RS I/O Conditions
make-i/o-file-already-exists-error: R6RS I/O Conditions
make-i/o-file-does-not-exist-error: R6RS I/O Conditions
make-i/o-file-is-read-only-error: R6RS I/O Conditions
make-i/o-file-protection-error: R6RS I/O Conditions
make-i/o-invalid-position-error: R6RS I/O Conditions
make-i/o-port-error: R6RS I/O Conditions
make-i/o-read-error: R6RS I/O Conditions
make-i/o-write-error: R6RS I/O Conditions
make-immediate: Constant Instructions
make-implementation-restriction-violation: rnrs conditions
make-instance: Instance Creation
make-instance: Instance Creation
make-io-filename-error: R6RS I/O Conditions
make-irritants-condition: rnrs conditions
make-lexical-error: Exception Objects
make-lexical-violation: rnrs conditions
make-line-buffered-input-port: Buffered Input
make-list: List Constructors
make-locale: i18n Introduction
make-long-immediate: Constant Instructions
make-long-long-immediate: Constant Instructions
make-message-condition: rnrs conditions
make-method: Method Definition Internals
make-mutex: Mutexes and Condition Variables
make-mutex: SRFI-18 Mutexes
make-no-infinities-violation: rnrs arithmetic flonums
make-no-nans-violation: rnrs arithmetic flonums
make-non-continuable-error: Exception Objects
make-non-continuable-violation: rnrs conditions
make-non-immediate: Constant Instructions
make-object-property: Object Properties
make-parameter: Parameters
make-pointer: Foreign Pointers
make-polar: Complex
make-polar: rnrs base
make-procedure-with-setter: Procedures with Setters
make-programming-error: Exception Objects
make-prompt-tag: Prompt Primitives
make-q: Queues
make-random-source: SRFI-27 Random Sources
make-record-constructor-descriptor: rnrs records procedural
make-record-type: Records
make-record-type-descriptor: rnrs records procedural
make-rectangular: Complex
make-rectangular: rnrs base
make-recursive-mutex: Mutexes and Condition Variables
make-regexp: Regexp Functions
make-s16vector: SRFI-4 API
make-s32vector: SRFI-4 API
make-s64vector: SRFI-4 API
make-s8vector: SRFI-4 API
make-sandbox-module: Sandboxed Evaluation
make-serious-condition: rnrs conditions
make-shared-array: Shared Arrays
make-short-immediate: Constant Instructions
make-socket-address: Network Socket Address
make-socket-address: Network Socket Address
make-socket-address: Network Socket Address
make-soft-port: Soft Ports
make-stack: Stack Capture
make-stream: Streams
make-string: String Constructors
make-string: rnrs base
make-struct-layout: Meta-Vtables
make-struct/no-tail: Structure Basics
make-symbol: Symbol Uninterned
make-syntax-error: Exception Objects
make-syntax-transformer: Internal Macros
make-syntax-violation: rnrs conditions
make-tcp-server-socket: REPL Servers
make-text-wrapper: texinfo string-utils
make-thread: Threads
make-thread: SRFI-18 Threads
make-thread-local-fluid: Thread Local Variables
make-time: SRFI-19 Time
make-transcoder: R6RS Transcoders
make-transcoder: R6RS Transcoders
make-transcoder: R6RS Transcoders
make-typed-array: Array Procedures
make-u16vector: SRFI-4 API
make-u32vector: SRFI-4 API
make-u64vector: SRFI-4 API
make-u8vector: SRFI-4 API
make-unbound-fluid: Fluids and Dynamic States
make-undefine-variable-error: Exception Objects
make-undefined-variable: Variables
make-undefined-violation: rnrs conditions
make-unix-domain-server-socket: REPL Servers
make-variable: Variables
make-variable-transformer: Identifier Macros
make-variable-transformer: rnrs syntax-case
make-vector: Vector Creation
make-vector: SRFI-43 Constructors
make-vector: rnrs base
make-vector: rnrs base
make-violation: rnrs conditions
make-vtable: Vtables
make-warning: Exception Objects
make-warning: rnrs conditions
make-weak-key-hash-table: Weak hash tables
make-weak-value-hash-table: Weak hash tables
make-weak-vector: Weak vectors
make-who-condition: rnrs conditions
malloc-stats: Memory Blocks
map: List Mapping
map: SRFI-1 Fold and Map
map!: SRFI-1 Fold and Map
map-in-order: List Mapping
map-union: SXPath
match: Pattern Matching
match-lambda: Pattern Matching
match-lambda*: Pattern Matching
match-let: Pattern Matching
match-let: Pattern Matching
match-let*: Pattern Matching
match-letrec: Pattern Matching
match-pattern: PEG API Reference
match:count: Match Structures
match:end: Match Structures
match:prefix: Match Structures
match:start: Match Structures
match:string: Match Structures
match:substring: Match Structures
match:suffix: Match Structures
max: Arithmetic
max: rnrs base
member: List Searching
member: SRFI-1 Searching
member: rnrs lists
memp: rnrs lists
memq: List Searching
memq: rnrs lists
memv: List Searching
memv: rnrs lists
merge: Sorting
merge!: Sorting
message-condition?: SRFI-35
message-condition?: rnrs conditions
method: Method Definition Internals
method-generic-function: Generic Functions
method-procedure: Generic Functions
method-source: Generic Functions
method-source: Generic Functions
method-specializers: Generic Functions
micro-version: Build Config
min: Arithmetic
min: rnrs base
minor-version: Build Config
mkdir: File System
mkdirat: File System
mkdtemp: File System
mknod: File System
mkstemp: File System
mktime: Time
mod: rnrs base
mod: Intrinsic Call Instructions
mod0: rnrs base
modified-julian-day->date: SRFI-19 Time/Date conversions
modified-julian-day->time-monotonic: SRFI-19 Time/Date conversions
modified-julian-day->time-tai: SRFI-19 Time/Date conversions
modified-julian-day->time-utc: SRFI-19 Time/Date conversions
module: Module Commands
module-add!: Module System Reflection
module-define!: Module System Reflection
module-ref: Module System Reflection
module-set!: Module System Reflection
module-stexi-documentation: texinfo reflection
module-use!: Module System Reflection
module-uses: Module System Reflection
module-variable: Module System Reflection
modulo: Integer Operations
modulo: rnrs r5rs
modulo-expt: Integer Operations
monetary-amount->locale-string: Number Input and Output
monitor: Mutexes and Condition Variables
mov: Shuffling Instructions
move->fdes: Ports and File Descriptors
mul: Intrinsic Call Instructions
mutable-vector?: Comparison Instructions
mutex-level: Mutexes and Condition Variables
mutex-lock!: SRFI-18 Mutexes
mutex-locked?: Mutexes and Condition Variables
mutex-name: SRFI-18 Mutexes
mutex-owner: Mutexes and Condition Variables
mutex-specific: SRFI-18 Mutexes
mutex-specific-set!: SRFI-18 Mutexes
mutex-state: SRFI-18 Mutexes
mutex-unlock!: SRFI-18 Mutexes
mutex?: Mutexes and Condition Variables

n-for-each-par-map: Parallel Forms
n-par-for-each: Parallel Forms
n-par-map: Parallel Forms
nan: Reals and Rationals
nan?: Reals and Rationals
nan?: rnrs base
native-endianness: Bytevector Endianness
native-eol-style: R6RS Transcoders
native-transcoder: R6RS Transcoders
negate: Higher-Order Functions
negative?: Comparison
negative?: rnrs base
netent:addrtype: Network Databases
netent:aliases: Network Databases
netent:name: Network Databases
netent:net: Network Databases
newline: Venerable Port Interfaces
newline: rnrs io simple
newline: rnrs io simple
next: Debug Commands
next-token: sxml ssax input-parse
next-token-of: sxml ssax input-parse
nftw: File Tree Walk
ngettext: Gettext Support
nice: Processes
nil?: Nil
nil?: Comparison Instructions
ninth: SRFI-1 Selectors
nl_langinfo: Accessing Locale Information
no-applicable-method: Handling Invocation Errors
no-applicable-method: Handling Invocation Errors
no-infinities-violation?: rnrs arithmetic flonums
no-method: Handling Invocation Errors
no-method: Handling Invocation Errors
no-nans-violation?: rnrs arithmetic flonums
no-next-method: Handling Invocation Errors
no-next-method: Handling Invocation Errors
node-closure: SXPath
node-eq?: SXPath
node-equal?: SXPath
node-join: SXPath
node-or: SXPath
node-parent: SXPath
node-pos: SXPath
node-reduce: SXPath
node-reverse: SXPath
node-self: SXPath
node-trace: SXPath
node-typeof?: SXPath
nodeset?: SXPath
non-continuable-error?: Exception Objects
non-continuable-violation?: rnrs conditions
not: Booleans
not: rnrs base
not-pair?: SRFI-1 Predicates
null-environment: Environments
null-environment: rnrs r5rs
null-list?: SRFI-1 Predicates
null-pointer?: Foreign Pointers
null?: List Predicates
null?: rnrs base
null?: Comparison Instructions
number->locale-string: Number Input and Output
number->string: Conversion
number->string: rnrs base
number?: Numerical Tower
number?: rnrs base
numerator: Reals and Rationals
numerator: rnrs base

object->string: General Conversion
object-properties: Object Properties
object-property: Object Properties
object-stexi-documentation: texinfo reflection
odd?: Integer Operations
odd?: rnrs base
open: Ports and File Descriptors
open-bytevector-input-port: Bytevector Ports
open-bytevector-input-port: rnrs io ports
open-bytevector-output-port: Bytevector Ports
open-bytevector-output-port: rnrs io ports
open-fdes: Ports and File Descriptors
open-fdes-at: Ports and File Descriptors
open-file: File Ports
open-file-input-port: R6RS File Ports
open-file-input-port: R6RS File Ports
open-file-input-port: R6RS File Ports
open-file-input-port: R6RS File Ports
open-file-output-port: R6RS File Ports
open-file-output-port: R6RS File Ports
open-file-output-port: R6RS File Ports
open-file-output-port: R6RS File Ports
open-input-bytevector: Binary I/O
open-input-file: File Ports
open-input-file: rnrs io simple
open-input-output-pipe: Pipes
open-input-pipe: Pipes
open-input-string: String Ports
open-output-bytevector: Binary I/O
open-output-file: File Ports
open-output-file: rnrs io simple
open-output-pipe: Pipes
open-output-string: String Ports
open-pipe: Pipes
open-pipe*: Pipes
open-server: Web Server
open-socket-for-uri: Web Client
openat: Ports and File Descriptors
opendir: File System
optimize: Compile Commands
option: System Commands
option: SRFI-37
option-names: SRFI-37
option-optional-arg?: SRFI-37
option-processor: SRFI-37
option-ref: option-ref Reference
option-required-arg?: SRFI-37
or: and or
or: rnrs base
output-port?: Ports
output-port?: rnrs io ports
output-port?: rnrs io simple

package-stexi-documentation: texinfo reflection
package-stexi-documentation-for-include: texinfo reflection
package-stexi-extended-menu: texinfo reflection
package-stexi-generic-menu: texinfo reflection
package-stexi-standard-copying: texinfo reflection
package-stexi-standard-menu: texinfo reflection
package-stexi-standard-prologue: texinfo reflection
package-stexi-standard-titlepage: texinfo reflection
pair-fold: SRFI-1 Fold and Map
pair-fold-right: SRFI-1 Fold and Map
pair-for-each: SRFI-1 Fold and Map
pair?: Pairs
pair?: rnrs base
pair?: Comparison Instructions
par-for-each: Parallel Forms
par-map: Parallel Forms
parallel: Parallel Forms
parameterize: Parameters
parse-c-struct: Foreign Structs
parse-header: HTTP
parse-http-method: HTTP
parse-http-version: HTTP
parse-path: Load Paths
parse-path-with-ellipsis: Load Paths
parse-request-uri: HTTP
partition: SRFI-1 Filtering and Partitioning
partition: rnrs lists
partition!: SRFI-1 Filtering and Partitioning
passwd:dir: User Information
passwd:gecos: User Information
passwd:gid: User Information
passwd:name: User Information
passwd:passwd: User Information
passwd:shell: User Information
passwd:uid: User Information
pause: Signals
pclose: Pipes
peek-char: Venerable Port Interfaces
peek-char: rnrs io simple
peek-char: rnrs io simple
peek-next-char: sxml ssax input-parse
peek-u8: Binary I/O
peg-record?: PEG API Reference
peg-string-compile: PEG API Reference
peg:end: PEG API Reference
peg:start: PEG API Reference
peg:string: PEG API Reference
peg:substring: PEG API Reference
peg:tree: PEG API Reference
pipe: Ports and File Descriptors
pipeline: Pipes
PKG_CHECK_MODULES: Autoconf Macros
pointer->bytevector: Void Pointers and Byte Access
pointer->procedure: Foreign Functions
pointer->scm: Foreign Pointers
pointer->string: Void Pointers and Byte Access
pointer-address: Foreign Pointers
pointer-ref/immediate: Memory Access Instructions
pointer-set!/immediate: Memory Access Instructions
pointer?: Foreign Pointers
pointer?: Comparison Instructions
poll-coop-repl-server: Cooperative REPL Servers
pop: Shuffling Instructions
pop-dynamic-state: Intrinsic Call Instructions
pop-fluid: Intrinsic Call Instructions
popen: Pipes
port->fdes: Ports and File Descriptors
port->stream: SRFI-41 Stream Library
port->stream: Streams
port-closed?: Ports
port-column: Textual I/O
port-conversion-strategy: Encoding
port-encoding: Encoding
port-eof?: rnrs io ports
port-filename: File Ports
port-for-each: Ports and File Descriptors
port-has-port-position?: rnrs io ports
port-has-set-port-position!?: rnrs io ports
port-line: Textual I/O
port-mode: File Ports
port-position: rnrs io ports
port-reduce: SRFI-171 Helpers
port-revealed: Ports and File Descriptors
port-transcoder: rnrs io ports
port-transduce: SRFI-171 Applying Transducers
port-transduce: SRFI-171 Applying Transducers
port-transduce: SRFI-171 Applying Transducers
port?: Ports
port?: rnrs io ports
port?: Comparison Instructions
positional-arguments<=?: Function Prologue Instructions
positive?: Comparison
positive?: rnrs base
post-order: Transforming SXML
pre-post-order: Transforming SXML
preserving-reduced: SRFI-171 Helpers
pretty-print: Inspect Commands
pretty-print: Pretty Printing
primitive-eval: Fly Evaluation
primitive-exit: Processes
primitive-fork: Processes
primitive-generic-generic: Extending Primitives
primitive-load: Loading
primitive-load-path: Load Paths
primitive-move->fdes: Ports and File Descriptors
primitive-_exit: Processes
print-options: Scheme Write
print-set!: Scheme Write
procedure: Procedures with Setters
procedure->pointer: More Foreign Functions
procedure-documentation: Procedure Properties
procedure-execution-count: Code Coverage
procedure-name: Procedure Properties
procedure-properties: Procedure Properties
procedure-property: Procedure Properties
procedure-source: Procedure Properties
procedure-with-setter?: Procedures with Setters
procedure?: Procedure Properties
procedure?: rnrs base
profile: Profile Commands
program-arguments: Runtime Environment
program-arguments-alist: Compiled Procedures
program-arities: Compiled Procedures
program-arity: Compiled Procedures
program-bindings: Compiled Procedures
program-code: Compiled Procedures
program-free-variable-ref: Compiled Procedures
program-free-variable-set!: Compiled Procedures
program-lambda-list: Compiled Procedures
program-num-free-variable: Compiled Procedures
program-sources: Compiled Procedures
program?: Compiled Procedures
program?: Comparison Instructions
programming-error?: Exception Objects
promise?: Delayed Evaluation
promise?: SRFI-45
prompt: Non-Local Control Flow Instructions
proper-list?: SRFI-1 Predicates
protoent:aliases: Network Databases
protoent:name: Network Databases
protoent:proto: Network Databases
provide: Feature Manipulation
provided?: Feature Manipulation
PTR2SCM: Non-Immediate Objects
push: Shuffling Instructions
push-dynamic-state: Intrinsic Call Instructions
push-fluid: Intrinsic Call Instructions
put-bytevector: Binary I/O
put-bytevector: rnrs io ports
put-char: Textual I/O
put-char: rnrs io ports
put-datum: rnrs io ports
put-string: Textual I/O
put-string: Textual I/O
put-string: Textual I/O
put-string: rnrs io ports
put-u8: Binary I/O
put-u8: rnrs io ports
putenv: Runtime Environment
pwd: Processes

q-empty-check: Queues
q-empty?: Queues
q-front: Queues
q-length: Queues
q-pop!: Queues
q-push!: Queues
q-rear: Queues
q-remove!: Queues
q?: Queues
quasiquote: Expression Syntax
quasiquote: rnrs base
quasisyntax: rnrs syntax-case
quit: System Commands
quit: Processes
quo: Intrinsic Call Instructions
quote: Expression Syntax
quote: rnrs base
quote-syntax: Syntax Case
quotient: Integer Operations
quotient: rnrs r5rs

raise: Signals
raise: SRFI-18 Exceptions
raise: rnrs exceptions
raise-continuable: rnrs exceptions
raise-exception: Raising and Handling Exceptions
random: Random
random-integer: SRFI-27 Default Random Source
random-real: SRFI-27 Default Random Source
random-source-make-integers: SRFI-27 Random Number Generators
random-source-make-reals: SRFI-27 Random Number Generators
random-source-make-reals: SRFI-27 Random Number Generators
random-source-pseudo-randomize!: SRFI-27 Random Sources
random-source-randomize!: SRFI-27 Random Sources
random-source-state-ref: SRFI-27 Random Sources
random-source-state-set!: SRFI-27 Random Sources
random-source?: SRFI-27 Random Sources
random-state->datum: Random
random-state-from-platform: Random
random:exp: Random
random:hollow-sphere!: Random
random:normal: Random
random:normal-vector!: Random
random:solid-sphere!: Random
random:uniform: Random
rany: SRFI-171 Reducers
rational-valued?: rnrs base
rational?: Reals and Rationals
rational?: rnrs base
rationalize: Reals and Rationals
rationalize: rnrs base
rcons: SRFI-171 Reducers
rcount: SRFI-171 Reducers
re-export: Creating Guile Modules
read: Scheme Read
read: rnrs io simple
read: rnrs io simple
read-bytevector: Binary I/O
read-bytevector!: Binary I/O
read-char: Venerable Port Interfaces
read-char: rnrs io simple
read-char: rnrs io simple
read-client: Web Server
read-delimited: Line/Delimited
read-delimited!: Line/Delimited
read-disable: Scheme Read
read-enable: Scheme Read
read-hash-extend: Reader Extensions
read-header: HTTP
read-headers: HTTP
read-line: Line/Delimited
read-line!: Line/Delimited
read-options: Scheme Read
read-request: Requests
read-request-body: Requests
read-request-line: HTTP
read-response: Responses
read-response-body: Responses
read-response-line: HTTP
read-set!: Scheme Read
read-string: sxml ssax input-parse
read-syntax: Annotated Scheme Read
read-text-line: sxml ssax input-parse
read-u8: Binary I/O
read-with-shared-structure: SRFI-38
read-with-shared-structure: SRFI-38
readdir: File System
readline: Readline Functions
readline-disable: Readline Options
readline-enable: Readline Options
readline-options: Readline Options
readline-port: Readline Functions
readline-set!: Readline Options
readlink: File System
real->flonum: rnrs arithmetic flonums
real-part: Complex
real-part: rnrs base
real-valued?: rnrs base
real?: Reals and Rationals
real?: rnrs base
rec: SRFI-31
receive: Multiple Values
receive: Call and Return Instructions
receive-values: Call and Return Instructions
record-accessor: Records
record-accessor: rnrs records procedural
record-constructor: Records
record-constructor: rnrs records procedural
record-constructor-descriptor: rnrs records syntactic
record-field-mutable?: rnrs records inspection
record-modifier: Records
record-mutator: rnrs records procedural
record-predicate: Records
record-predicate: rnrs records procedural
record-rtd: rnrs records inspection
record-type-descriptor: Records
record-type-descriptor: rnrs records syntactic
record-type-descriptor?: rnrs records procedural
record-type-field-names: rnrs records inspection
record-type-fields: Records
record-type-generative?: rnrs records inspection
record-type-name: Records
record-type-name: rnrs records inspection
record-type-opaque?: rnrs records inspection
record-type-parent: rnrs records inspection
record-type-sealed?: rnrs records inspection
record-type-uid: rnrs records inspection
record?: Records
record?: rnrs records inspection
recv!: Network Sockets and Communication
recvfrom!: Network Sockets and Communication
redirect-port: Ports and File Descriptors
reduce: SRFI-1 Fold and Map
reduce-right: SRFI-1 Fold and Map
reduced: SRFI-171 Helpers
reduced?: SRFI-171 Helpers
regexp-exec: Regexp Functions
regexp-match?: Match Structures
regexp-quote: Backslash Escapes
regexp-substitute: Regexp Functions
regexp-substitute/global: Regexp Functions
regexp?: Regexp Functions
registers: Debug Commands
relative-ref?: URIs
release-port-handle: Ports and File Descriptors
reload: Module Commands
reload-module: Module System Reflection
rem: Intrinsic Call Instructions
remainder: Integer Operations
remainder: rnrs r5rs
remove: SRFI-1 Filtering and Partitioning
remove: rnrs lists
remove!: SRFI-1 Filtering and Partitioning
remove-class-accessors!: Customizing Class Redefinition
remove-fdes-finalizer!: Ports and File Descriptors
remove-hook!: Hook Reference
remp: rnrs lists
remq: rnrs lists
remv: rnrs lists
rename: File System
rename-file: File System
rename-file-at: File System
renameat: File System
repl-default-option-set!: System Commands
replace-range: Transforming SXML
replace-titles: texinfo docbook
request-absolute-uri: Requests
request-accept: Requests
request-accept-charset: Requests
request-accept-encoding: Requests
request-accept-language: Requests
request-allow: Requests
request-authorization: Requests
request-cache-control: Requests
request-connection: Requests
request-content-encoding: Requests
request-content-language: Requests
request-content-length: Requests
request-content-location: Requests
request-content-md5: Requests
request-content-range: Requests
request-content-type: Requests
request-date: Requests
request-expect: Requests
request-expires: Requests
request-from: Requests
request-headers: Requests
request-host: Requests
request-if-match: Requests
request-if-modified-since: Requests
request-if-none-match: Requests
request-if-range: Requests
request-if-unmodified-since: Requests
request-last-modified: Requests
request-max-forwards: Requests
request-meta: Requests
request-method: Requests
request-port: Requests
request-pragma: Requests
request-proxy-authorization: Requests
request-range: Requests
request-referer: Requests
request-te: Requests
request-trailer: Requests
request-transfer-encoding: Requests
request-upgrade: Requests
request-uri: Requests
request-user-agent: Requests
request-version: Requests
request-via: Requests
request-warning: Requests
request?: Requests
require: SLIB
require-extension: SRFI-55
reset: Shift and Reset
reset-frame: Function Prologue Instructions
reset-hook!: Hook Reference
reset-parsed-entity-definitions!: SSAX
resolve-interface: Module System Reflection
resolve-module: Module System Reflection
resolve-module: Intrinsic Call Instructions
response-accept-ranges: Responses
response-age: Responses
response-allow: Responses
response-body-port: Responses
response-cache-control: Responses
response-code: Responses
response-connection: Responses
response-content-encoding: Responses
response-content-language: Responses
response-content-length: Responses
response-content-location: Responses
response-content-md5: Responses
response-content-range: Responses
response-content-type: Responses
response-date: Responses
response-etag: Responses
response-expires: Responses
response-headers: Responses
response-last-modified: Responses
response-location: Responses
response-must-not-include-body?: Responses
response-port: Responses
response-pragma: Responses
response-proxy-authenticate: Responses
response-reason-phrase: Responses
response-retry-after: Responses
response-server: Responses
response-trailer: Responses
response-transfer-encoding: Responses
response-upgrade: Responses
response-vary: Responses
response-version: Responses
response-via: Responses
response-warning: Responses
response-www-authenticate: Responses
response?: Responses
restore-signals: Signals
restricted-vector-sort!: Sorting
return-from-interrupt: Instrumentation Instructions
return-values: Call and Return Instructions
reverse: Append/Reverse
reverse: rnrs base
reverse!: Append/Reverse
reverse-bit-field: SRFI-60
reverse-list->string: String Constructors
reverse-list->vector: SRFI-43 Conversion
reverse-rcons: SRFI-171 Reducers
reverse-vector->list: SRFI-43 Conversion
revery: SRFI-171 Reducers
rewinddir: File System
rewrite-cont: Building CPS
rewrite-exp: Building CPS
rewrite-term: Building CPS
right-justify-string: texinfo string-utils
rmdir: File System
rotate-bit-field: SRFI-60
round: Arithmetic
round: rnrs base
round-ash: Bitwise Operations
round-quotient: Arithmetic
round-remainder: Arithmetic
round/: Arithmetic
rsh: Intrinsic Call Instructions
rsh/immediate: Intrinsic Call Instructions
run-hook: Hook Reference
run-server: REPL Servers
run-server: Web Server

s16-ref: Raw Memory Access Instructions
s16-set!: Raw Memory Access Instructions
s16vector: SRFI-4 API
s16vector->list: SRFI-4 API
s16vector-copy: SRFI-4 Extensions
s16vector-copy!: SRFI-4 Extensions
s16vector-length: SRFI-4 API
s16vector-ref: SRFI-4 API
s16vector-set!: SRFI-4 API
s16vector?: SRFI-4 API
s32-ref: Raw Memory Access Instructions
s32-set!: Raw Memory Access Instructions
s32vector: SRFI-4 API
s32vector->list: SRFI-4 API
s32vector-copy: SRFI-4 Extensions
s32vector-copy!: SRFI-4 Extensions
s32vector-length: SRFI-4 API
s32vector-ref: SRFI-4 API
s32vector-set!: SRFI-4 API
s32vector?: SRFI-4 API
s64->scm: Intrinsic Call Instructions
s64-imm<?: Comparison Instructions
s64-imm=?: Comparison Instructions
s64-ref: Raw Memory Access Instructions
s64-set!: Raw Memory Access Instructions
s64<?: Comparison Instructions
s64vector: SRFI-4 API
s64vector->list: SRFI-4 API
s64vector-copy: SRFI-4 Extensions
s64vector-copy!: SRFI-4 Extensions
s64vector-length: SRFI-4 API
s64vector-ref: SRFI-4 API
s64vector-set!: SRFI-4 API
s64vector?: SRFI-4 API
s8-ref: Raw Memory Access Instructions
s8-set!: Raw Memory Access Instructions
s8vector: SRFI-4 API
s8vector->list: SRFI-4 API
s8vector-copy: SRFI-4 Extensions
s8vector-copy!: SRFI-4 Extensions
s8vector-length: SRFI-4 API
s8vector-ref: SRFI-4 API
s8vector-set!: SRFI-4 API
s8vector?: SRFI-4 API
sanitize-response: Web Server
save-module-excursion: Module System Reflection
scandir: File Tree Walk
scheme-report-environment: Environments
scheme-report-environment: rnrs r5rs
scm->f64: Intrinsic Call Instructions
scm->pointer: Foreign Pointers
scm->s64: Intrinsic Call Instructions
scm->u64: Intrinsic Call Instructions
scm->u64/truncate: Intrinsic Call Instructions
scm-error: Error Reporting
scm-ref: Memory Access Instructions
scm-ref/immediate: Memory Access Instructions
scm-ref/tag: Memory Access Instructions
scm-set!: Memory Access Instructions
scm-set!/immediate: Memory Access Instructions
scm-set!/tag: Memory Access Instructions
SCM2PTR: Non-Immediate Objects
scm_abs: Arithmetic
scm_accept: Network Sockets and Communication
scm_access: File System
scm_acons: Adding or Setting Alist Entries
scm_add_feature: Feature Manipulation
scm_add_hook_x: Hook Reference
scm_alarm: Signals
scm_alignof: Foreign Structs
scm_all_threads: Threads
scm_angle: Complex
scm_any_to_c32vector: SRFI-4 Extensions
scm_any_to_c64vector: SRFI-4 Extensions
scm_any_to_f32vector: SRFI-4 Extensions
scm_any_to_f64vector: SRFI-4 Extensions
scm_any_to_s16vector: SRFI-4 Extensions
scm_any_to_s32vector: SRFI-4 Extensions
scm_any_to_s64vector: SRFI-4 Extensions
scm_any_to_s8vector: SRFI-4 Extensions
scm_any_to_u16vector: SRFI-4 Extensions
scm_any_to_u32vector: SRFI-4 Extensions
scm_any_to_u64vector: SRFI-4 Extensions
scm_any_to_u8vector: SRFI-4 Extensions
scm_append: Append/Reverse
scm_append_x: Append/Reverse
scm_apply: Fly Evaluation
scm_apply_0: Fly Evaluation
scm_apply_1: Fly Evaluation
scm_apply_2: Fly Evaluation
scm_apply_3: Fly Evaluation
SCM_ARG1: Handling Errors
SCM_ARG2: Handling Errors
SCM_ARG3: Handling Errors
SCM_ARG4: Handling Errors
SCM_ARG5: Handling Errors
SCM_ARG6: Handling Errors
SCM_ARG7: Handling Errors
SCM_ARGn: Handling Errors
scm_array_cell_ref: Arrays as arrays of arrays
scm_array_cell_set_x: Arrays as arrays of arrays
scm_array_contents: Shared Arrays
scm_array_copy_x: Array Procedures
scm_array_dimensions: Array Procedures
scm_array_fill_x: Array Procedures
scm_array_for_each: Array Procedures
scm_array_get_handle: Accessing Arrays from C
scm_array_handle_bit_elements: Accessing Arrays from C
scm_array_handle_bit_writable_elements: Accessing Arrays from C
scm_array_handle_c32_elements: Accessing Arrays from C
scm_array_handle_c32_writable_elements: Accessing Arrays from C
scm_array_handle_c64_elements: Accessing Arrays from C
scm_array_handle_c64_writable_elements: Accessing Arrays from C
scm_array_handle_dims: Accessing Arrays from C
scm_array_handle_elements: Accessing Arrays from C
scm_array_handle_f32_elements: Accessing Arrays from C
scm_array_handle_f32_writable_elements: Accessing Arrays from C
scm_array_handle_f64_elements: Accessing Arrays from C
scm_array_handle_f64_writable_elements: Accessing Arrays from C
scm_array_handle_pos: Accessing Arrays from C
scm_array_handle_rank: Accessing Arrays from C
scm_array_handle_ref: Accessing Arrays from C
scm_array_handle_release: Accessing Arrays from C
scm_array_handle_s16_elements: Accessing Arrays from C
scm_array_handle_s16_writable_elements: Accessing Arrays from C
scm_array_handle_s32_elements: Accessing Arrays from C
scm_array_handle_s32_writable_elements: Accessing Arrays from C
scm_array_handle_s64_elements: Accessing Arrays from C
scm_array_handle_s64_writable_elements: Accessing Arrays from C
scm_array_handle_s8_elements: Accessing Arrays from C
scm_array_handle_s8_writable_elements: Accessing Arrays from C
scm_array_handle_set: Accessing Arrays from C
scm_array_handle_u16_elements: Accessing Arrays from C
scm_array_handle_u16_writable_elements: Accessing Arrays from C
scm_array_handle_u32_elements: Accessing Arrays from C
scm_array_handle_u32_writable_elements: Accessing Arrays from C
scm_array_handle_u64_elements: Accessing Arrays from C
scm_array_handle_u64_writable_elements: Accessing Arrays from C
scm_array_handle_u8_elements: Accessing Arrays from C
scm_array_handle_u8_writable_elements: Accessing Arrays from C
scm_array_handle_uniform_elements: Accessing Arrays from C
scm_array_handle_uniform_element_size: Accessing Arrays from C
scm_array_handle_uniform_writable_elements: Accessing Arrays from C
scm_array_handle_writable_elements: Accessing Arrays from C
scm_array_index_map_x: Array Procedures
scm_array_in_bounds_p: Array Procedures
scm_array_length: Array Procedures
scm_array_map_x: Array Procedures
scm_array_p: Array Procedures
scm_array_rank: Array Procedures
scm_array_ref: Array Procedures
scm_array_set_x: Array Procedures
scm_array_slice: Arrays as arrays of arrays
scm_array_slice_for_each: Arrays as arrays of arrays
scm_array_slice_for_each_in_order: Arrays as arrays of arrays
scm_array_to_list: Array Procedures
scm_array_type: Array Procedures
scm_ash: Bitwise Operations
SCM_ASSERT: Handling Errors
scm_assert_foreign_object_type: Foreign Objects
scm_assert_smob_type: Smobs
SCM_ASSERT_TYPE: Handling Errors
scm_assoc: Retrieving Alist Entries
scm_assoc_ref: Retrieving Alist Entries
scm_assoc_remove_x: Removing Alist Entries
scm_assoc_set_x: Adding or Setting Alist Entries
scm_assq: Retrieving Alist Entries
scm_assq_ref: Retrieving Alist Entries
scm_assq_remove_x: Removing Alist Entries
scm_assq_set_x: Adding or Setting Alist Entries
scm_assv: Retrieving Alist Entries
scm_assv_ref: Retrieving Alist Entries
scm_assv_remove_x: Removing Alist Entries
scm_assv_set_x: Adding or Setting Alist Entries
scm_backtrace: Pre-Unwind Debugging
scm_backtrace_with_highlights: Pre-Unwind Debugging
scm_basename: File System
scm_bind: Network Sockets and Communication
scm_bindtextdomain: Gettext Support
scm_bind_textdomain_codeset: Gettext Support
scm_bitvector_bit_is_clear: Bit Vectors
scm_bitvector_bit_is_set: Bit Vectors
scm_bitvector_copy: Bit Vectors
scm_bitvector_elements: Bit Vectors
scm_bitvector_position: Bit Vectors
scm_bitvector_to_list: Bit Vectors
scm_bitvector_writable_elements: Bit Vectors
scm_bit_extract: Bitwise Operations
scm_boolean_p: Booleans
scm_boot_guile: Initialization
scm_broadcast_condition_variable: Mutexes and Condition Variables
SCM_BYTEVECTOR_CONTENTS: Bytevector Manipulation
scm_bytevector_copy: Bytevector Manipulation
scm_bytevector_copy_x: Bytevector Manipulation
scm_bytevector_eq_p: Bytevector Manipulation
scm_bytevector_fill_x: Bytevector Manipulation
scm_bytevector_ieee_double_native_ref: Bytevectors as Floats
scm_bytevector_ieee_double_native_set_x: Bytevectors as Floats
scm_bytevector_ieee_double_ref: Bytevectors as Floats
scm_bytevector_ieee_double_set_x: Bytevectors as Floats
scm_bytevector_ieee_single_native_ref: Bytevectors as Floats
scm_bytevector_ieee_single_native_set_x: Bytevectors as Floats
scm_bytevector_ieee_single_ref: Bytevectors as Floats
scm_bytevector_ieee_single_set_x: Bytevectors as Floats
scm_bytevector_length: Bytevector Manipulation
SCM_BYTEVECTOR_LENGTH: Bytevector Manipulation
scm_bytevector_p: Bytevector Manipulation
scm_bytevector_s16_native_ref: Bytevectors as Integers
scm_bytevector_s16_native_set_x: Bytevectors as Integers
scm_bytevector_s16_ref: Bytevectors as Integers
scm_bytevector_s16_set_x: Bytevectors as Integers
scm_bytevector_s32_native_ref: Bytevectors as Integers
scm_bytevector_s32_native_set_x: Bytevectors as Integers
scm_bytevector_s32_ref: Bytevectors as Integers
scm_bytevector_s32_set_x: Bytevectors as Integers
scm_bytevector_s64_native_ref: Bytevectors as Integers
scm_bytevector_s64_native_set_x: Bytevectors as Integers
scm_bytevector_s64_ref: Bytevectors as Integers
scm_bytevector_s64_set_x: Bytevectors as Integers
scm_bytevector_s8_ref: Bytevectors as Integers
scm_bytevector_s8_set_x: Bytevectors as Integers
scm_bytevector_sint_ref: Bytevectors as Integers
scm_bytevector_sint_set_x: Bytevectors as Integers
scm_bytevector_slice: Bytevector Slices
scm_bytevector_to_pointer: Void Pointers and Byte Access
scm_bytevector_to_sint_list: Bytevectors and Integer Lists
scm_bytevector_to_u8_list: Bytevectors and Integer Lists
scm_bytevector_to_uint_list: Bytevectors and Integer Lists
scm_bytevector_u16_native_ref: Bytevectors as Integers
scm_bytevector_u16_native_set_x: Bytevectors as Integers
scm_bytevector_u16_ref: Bytevectors as Integers
scm_bytevector_u16_set_x: Bytevectors as Integers
scm_bytevector_u32_native_ref: Bytevectors as Integers
scm_bytevector_u32_native_set_x: Bytevectors as Integers
scm_bytevector_u32_ref: Bytevectors as Integers
scm_bytevector_u32_set_x: Bytevectors as Integers
scm_bytevector_u64_native_ref: Bytevectors as Integers
scm_bytevector_u64_native_set_x: Bytevectors as Integers
scm_bytevector_u64_ref: Bytevectors as Integers
scm_bytevector_u64_set_x: Bytevectors as Integers
scm_bytevector_u8_ref: Bytevectors as Integers
scm_bytevector_u8_set_x: Bytevectors as Integers
scm_bytevector_uint_ref: Bytevectors as Integers
scm_bytevector_uint_set_x: Bytevectors as Integers
scm_c32vector: SRFI-4 API
scm_c32vector_elements: SRFI-4 API
scm_c32vector_length: SRFI-4 API
scm_c32vector_p: SRFI-4 API
scm_c32vector_ref: SRFI-4 API
scm_c32vector_set_x: SRFI-4 API
scm_c32vector_to_list: SRFI-4 API
scm_c32vector_writable_elements: SRFI-4 API
scm_c64vector: SRFI-4 API
scm_c64vector_elements: SRFI-4 API
scm_c64vector_length: SRFI-4 API
scm_c64vector_p: SRFI-4 API
scm_c64vector_ref: SRFI-4 API
scm_c64vector_set_x: SRFI-4 API
scm_c64vector_to_list: SRFI-4 API
scm_c64vector_writable_elements: SRFI-4 API
scm_caaaar: Pairs
scm_caaadr: Pairs
scm_caaar: Pairs
scm_caadar: Pairs
scm_caaddr: Pairs
scm_caadr: Pairs
scm_caar: Pairs
scm_cadaar: Pairs
scm_cadadr: Pairs
scm_cadar: Pairs
scm_caddar: Pairs
scm_cadddr: Pairs
scm_caddr: Pairs
scm_cadr: Pairs
scm_call: Fly Evaluation
scm_calloc: Memory Blocks
scm_call_0: Fly Evaluation
scm_call_1: Fly Evaluation
scm_call_2: Fly Evaluation
scm_call_3: Fly Evaluation
scm_call_4: Fly Evaluation
scm_call_5: Fly Evaluation
scm_call_6: Fly Evaluation
scm_call_7: Fly Evaluation
scm_call_8: Fly Evaluation
scm_call_9: Fly Evaluation
scm_call_n: Fly Evaluation
scm_call_with_blocked_asyncs: Asyncs
scm_call_with_input_string: String Ports
scm_call_with_output_string: String Ports
scm_call_with_unblocked_asyncs: Asyncs
scm_cancel_thread: Threads
scm_canonicalize_path: File System
scm_car: Pairs
SCM_CAR: Pairs
scm_catch: Throw and Catch
scm_catch_with_pre_unwind_handler: Throw and Catch
scm_cdaaar: Pairs
scm_cdaadr: Pairs
scm_cdaar: Pairs
scm_cdadar: Pairs
scm_cdaddr: Pairs
scm_cdadr: Pairs
scm_cdar: Pairs
scm_cddaar: Pairs
scm_cddadr: Pairs
scm_cddar: Pairs
scm_cdddar: Pairs
scm_cddddr: Pairs
scm_cdddr: Pairs
scm_cddr: Pairs
scm_cdr: Pairs
SCM_CDR: Pairs
scm_ceiling: Arithmetic
scm_ceiling_divide: Arithmetic
scm_ceiling_quotient: Arithmetic
scm_ceiling_remainder: Arithmetic
scm_cell: Allocating Heap Objects
SCM_CELL_OBJECT: Accessing Heap Object Fields
SCM_CELL_OBJECT_0: Accessing Heap Object Fields
SCM_CELL_OBJECT_1: Accessing Heap Object Fields
SCM_CELL_OBJECT_2: Accessing Heap Object Fields
SCM_CELL_OBJECT_3: Accessing Heap Object Fields
SCM_CELL_TYPE: Heap Object Type Information
SCM_CELL_WORD: Accessing Heap Object Fields
SCM_CELL_WORD_0: Accessing Heap Object Fields
SCM_CELL_WORD_1: Accessing Heap Object Fields
SCM_CELL_WORD_2: Accessing Heap Object Fields
SCM_CELL_WORD_3: Accessing Heap Object Fields
scm_centered_divide: Arithmetic
scm_centered_quotient: Arithmetic
scm_centered_remainder: Arithmetic
scm_char_alphabetic_p: Characters
scm_char_downcase: Characters
scm_char_general_category: Characters
scm_char_is_both_p: Characters
scm_char_locale_ci_eq: Text Collation
scm_char_locale_ci_gt: Text Collation
scm_char_locale_ci_lt: Text Collation
scm_char_locale_downcase: Character Case Mapping
scm_char_locale_gt: Text Collation
scm_char_locale_lt: Text Collation
scm_char_locale_titlecase: Character Case Mapping
scm_char_locale_upcase: Character Case Mapping
scm_char_lower_case_p: Characters
scm_char_numeric_p: Characters
scm_char_p: Characters
scm_char_set: Creating Character Sets
scm_char_set_adjoin: Character-Set Algebra
scm_char_set_adjoin_x: Character-Set Algebra
scm_char_set_any: Querying Character Sets
scm_char_set_complement: Character-Set Algebra
scm_char_set_complement_x: Character-Set Algebra
scm_char_set_contains_p: Querying Character Sets
scm_char_set_copy: Creating Character Sets
scm_char_set_count: Querying Character Sets
scm_char_set_cursor: Iterating Over Character Sets
scm_char_set_cursor_next: Iterating Over Character Sets
scm_char_set_delete: Character-Set Algebra
scm_char_set_delete_x: Character-Set Algebra
scm_char_set_difference: Character-Set Algebra
scm_char_set_difference_x: Character-Set Algebra
scm_char_set_diff_plus_intersection: Character-Set Algebra
scm_char_set_diff_plus_intersection_x: Character-Set Algebra
scm_char_set_eq: Character Set Predicates/Comparison
scm_char_set_every: Querying Character Sets
scm_char_set_filter: Creating Character Sets
scm_char_set_filter_x: Creating Character Sets
scm_char_set_fold: Iterating Over Character Sets
scm_char_set_for_each: Iterating Over Character Sets
scm_char_set_hash: Character Set Predicates/Comparison
scm_char_set_intersection: Character-Set Algebra
scm_char_set_intersection_x: Character-Set Algebra
scm_char_set_leq: Character Set Predicates/Comparison
scm_char_set_map: Iterating Over Character Sets
scm_char_set_p: Character Set Predicates/Comparison
scm_char_set_ref: Iterating Over Character Sets
scm_char_set_size: Querying Character Sets
scm_char_set_to_list: Querying Character Sets
scm_char_set_to_string: Querying Character Sets
scm_char_set_unfold: Iterating Over Character Sets
scm_char_set_unfold_x: Iterating Over Character Sets
scm_char_set_union: Character-Set Algebra
scm_char_set_union_x: Character-Set Algebra
scm_char_set_xor: Character-Set Algebra
scm_char_set_xor_x: Character-Set Algebra
scm_char_titlecase: Characters
scm_char_to_integer: Characters
scm_char_upcase: Characters
scm_char_upper_case_p: Characters
scm_char_whitespace_p: Characters
scm_chdir: Processes
scm_chmod: File System
scm_chown: File System
scm_chownat: File System
scm_chroot: Processes
scm_close: Ports and File Descriptors
scm_closedir: File System
scm_close_fdes: Ports and File Descriptors
scm_close_port: Ports
scm_complex_p: Complex Numbers
scm_condition_variable_p: Mutexes and Condition Variables
scm_connect: Network Sockets and Communication
scm_cons: Pairs
scm_cons_source: Source Properties
scm_copy_file: File System
scm_copy_random_state: Random
scm_copy_tree: Copying
scm_crypt: Encryption
scm_ctermid: Terminals and Ptys
scm_current_dynamic_state: Fluids and Dynamic States
scm_current_error_port: Default Ports
scm_current_input_port: Default Ports
scm_current_load_port: Loading
scm_current_module: Module System Reflection
scm_current_output_port: Default Ports
scm_current_processor_count: Threads
scm_current_thread: Threads
scm_current_time: Time
scm_c_angle: Complex
scm_c_array_rank: Array Procedures
scm_c_bind_keyword_arguments: Keyword Procedures
scm_c_bitvector_clear_all_bits_x: Bit Vectors
scm_c_bitvector_clear_bits_x: Bit Vectors
scm_c_bitvector_clear_bit_x: Bit Vectors
scm_c_bitvector_count: Bit Vectors
scm_c_bitvector_count_bits: Bit Vectors
scm_c_bitvector_flip_all_bits_x: Bit Vectors
scm_c_bitvector_length: Bit Vectors
scm_c_bitvector_set_all_bits_x: Bit Vectors
scm_c_bitvector_set_bits_x: Bit Vectors
scm_c_bitvector_set_bit_x: Bit Vectors
scm_c_bytevector_length: Bytevector Manipulation
scm_c_bytevector_ref: Bytevector Manipulation
scm_c_bytevector_set_x: Bytevector Manipulation
scm_c_call_with_blocked_asyncs: Asyncs
scm_c_call_with_current_module: Accessing Modules from C
scm_c_call_with_unblocked_asyncs: Asyncs
scm_c_catch: Exceptions and C
scm_c_define: Top Level
scm_c_define: Accessing Modules from C
scm_c_define_gsubr: Primitive Procedures
scm_c_define_module: Accessing Modules from C
scm_c_downcase: Characters
scm_c_eval_string: Fly Evaluation
scm_c_export: Accessing Modules from C
scm_c_hook_add: C Hooks
scm_c_hook_init: C Hooks
scm_c_hook_remove: C Hooks
scm_c_hook_run: C Hooks
scm_c_imag_part: Complex
scm_c_locale_stringn_to_number: Conversion
scm_c_lookup: Accessing Modules from C
scm_c_magnitude: Complex
scm_c_make_bitvector: Bit Vectors
scm_c_make_bytevector: Bytevector Manipulation
scm_c_make_gsubr: Primitive Procedures
scm_c_make_polar: Complex
scm_c_make_port: I/O Extensions
scm_c_make_port_with_encoding: I/O Extensions
scm_c_make_rectangular: Complex
scm_c_make_socket_address: Network Socket Address
scm_c_make_string: String Constructors
scm_c_make_struct: Structure Basics
scm_c_make_structv: Structure Basics
scm_c_make_vector: Vector Creation
scm_c_module_define: Accessing Modules from C
scm_c_module_lookup: Accessing Modules from C
scm_c_nvalues: Multiple Values
scm_c_port_for_each: Ports and File Descriptors
scm_c_prepare_to_wait_on_cond: Asyncs
scm_c_prepare_to_wait_on_fd: Asyncs
scm_c_primitive_load: Loading
scm_c_private_lookup: Accessing Modules from C
scm_c_private_ref: Accessing Modules from C
scm_c_private_variable: Accessing Modules from C
scm_c_public_lookup: Accessing Modules from C
scm_c_public_ref: Accessing Modules from C
scm_c_public_variable: Accessing Modules from C
scm_c_put_latin1_chars: Using Ports from C
scm_c_put_utf32_chars: Using Ports from C
scm_c_read: Using Ports from C
scm_c_read_bytes: Using Ports from C
scm_c_real_part: Complex
scm_c_resolve_module: Accessing Modules from C
scm_c_round: Arithmetic
scm_c_run_hook: Hook Reference
scm_c_string_length: String Selection
scm_c_string_ref: String Selection
scm_c_string_set_x: String Modification
scm_c_string_utf8_length: Bytevectors as Strings
scm_c_substring: String Selection
scm_c_substring_copy: String Selection
scm_c_substring_read_only: String Selection
scm_c_substring_shared: String Selection
scm_c_symbol_length: Symbol Primitives
scm_c_titlecase: Characters
scm_c_truncate: Arithmetic
scm_c_upcase: Characters
scm_c_use_module: Accessing Modules from C
scm_c_values: Multiple Values
scm_c_value_ref: Multiple Values
scm_c_vector_length: Vector Accessors
scm_c_vector_ref: Vector Accessors
scm_c_vector_set_x: Vector Accessors
scm_c_wait_finished: Asyncs
scm_c_with_continuation_barrier: Continuation Barriers
scm_c_with_dynamic_state: Fluids and Dynamic States
scm_c_with_fluid: Fluids and Dynamic States
scm_c_with_fluids: Fluids and Dynamic States
scm_c_with_throw_handler: Exceptions and C
scm_c_write: Using Ports from C
scm_c_write_bytes: Using Ports from C
scm_datum_to_random_state: Random
SCM_DEFINE: Snarfing Macros
scm_define: Top Level
scm_define: Accessing Modules from C
scm_defined_p: Binding Reflection
scm_delete: List Modification
scm_delete1_x: List Modification
scm_delete_file: File System
scm_delete_file_at: File System
scm_delete_x: List Modification
scm_delq: List Modification
scm_delq1_x: List Modification
scm_delq_x: List Modification
scm_delv: List Modification
scm_delv1_x: List Modification
scm_delv_x: List Modification
scm_denominator: Reals and Rationals
scm_difference: Arithmetic
scm_directory_stream_p: File System
scm_dirname: File System
scm_display_application: Frames
scm_display_backtrace: Stacks
scm_display_backtrace_with_highlights: Stacks
scm_display_error: Handling Errors
scm_divide: Arithmetic
scm_double_cell: Allocating Heap Objects
scm_doubly_weak_hash_table_p: Weak hash tables
scm_drain_input: Buffering
scm_dup2: Ports and File Descriptors
scm_dup_to_fdes: Ports and File Descriptors
scm_dynamic_state_p: Fluids and Dynamic States
scm_dynamic_wind: Dynamic Wind
scm_dynwind_begin: Dynamic Wind
scm_dynwind_block_asyncs: Asyncs
scm_dynwind_current_dynamic_state: Fluids and Dynamic States
scm_dynwind_current_error_port: Default Ports
scm_dynwind_current_input_port: Default Ports
scm_dynwind_current_output_port: Default Ports
scm_dynwind_end: Dynamic Wind
scm_dynwind_fluid: Fluids and Dynamic States
scm_dynwind_free: Dynamic Wind
scm_dynwind_free: Memory Blocks
scm_dynwind_lock_mutex: Mutexes and Condition Variables
scm_dynwind_rewind_handler: Dynamic Wind
scm_dynwind_rewind_handler_with_scm: Dynamic Wind
scm_dynwind_unblock_asyncs: Asyncs
scm_dynwind_unwind_handler: Dynamic Wind
scm_dynwind_unwind_handler_with_scm: Dynamic Wind
scm_effective_version: Build Config
scm_end_of_char_set_p: Iterating Over Character Sets
scm_environ: Runtime Environment
scm_eof_object_p: Binary I/O
SCM_EOF_VAL: Immediate Objects
SCM_EOL: Immediate Objects
scm_equal_p: Equality
scm_eqv_p: Equality
scm_eq_p: Equality
scm_error: Handling Errors
scm_error_scm: Error Reporting
scm_euclidean_divide: Arithmetic
scm_euclidean_quotient: Arithmetic
scm_euclidean_remainder: Arithmetic
scm_eval: Fly Evaluation
scm_eval_string: Fly Evaluation
scm_eval_string_in_module: Fly Evaluation
scm_even_p: Integer Operations
scm_exact_integer_p: Integers
scm_exact_integer_sqrt: Integer Operations
scm_exact_p: Exactness
scm_exact_to_inexact: Exactness
scm_execl: Processes
scm_execle: Processes
scm_execlp: Processes
scm_f32vector: SRFI-4 API
scm_f32vector_elements: SRFI-4 API
scm_f32vector_length: SRFI-4 API
scm_f32vector_p: SRFI-4 API
scm_f32vector_ref: SRFI-4 API
scm_f32vector_set_x: SRFI-4 API
scm_f32vector_to_list: SRFI-4 API
scm_f32vector_writable_elements: SRFI-4 API
scm_f64vector: SRFI-4 API
scm_f64vector_elements: SRFI-4 API
scm_f64vector_length: SRFI-4 API
scm_f64vector_p: SRFI-4 API
scm_f64vector_ref: SRFI-4 API
scm_f64vector_set_x: SRFI-4 API
scm_f64vector_to_list: SRFI-4 API
scm_f64vector_writable_elements: SRFI-4 API
scm_fcntl: Ports and File Descriptors
scm_fdes_to_ports: Ports and File Descriptors
scm_fdopen: Ports and File Descriptors
scm_fileno: Ports and File Descriptors
scm_file_encoding: Character Encoding of Source Files
scm_file_port_p: File Ports
scm_finite_p: Reals and Rationals
scm_flock: Ports and File Descriptors
scm_floor: Arithmetic
scm_floor_divide: Arithmetic
scm_floor_quotient: Arithmetic
scm_floor_remainder: Arithmetic
scm_fluid_bound_p: Fluids and Dynamic States
scm_fluid_p: Fluids and Dynamic States
scm_fluid_ref: Fluids and Dynamic States
scm_fluid_ref_star: Fluids and Dynamic States
scm_fluid_set_x: Fluids and Dynamic States
scm_fluid_thread_local_p: Thread Local Variables
scm_fluid_unset_x: Fluids and Dynamic States
scm_flush_all_ports: Buffering
scm_force: Delayed Evaluation
scm_force_output: Buffering
scm_foreign_object_ref: Foreign Objects
scm_foreign_object_set_x: Foreign Objects
scm_foreign_object_signed_ref: Foreign Objects
scm_foreign_object_signed_set_x: Foreign Objects
scm_foreign_object_unsigned_ref: Foreign Objects
scm_foreign_object_unsigned_set_x: Foreign Objects
scm_fork: Processes
scm_frame_arguments: Frames
scm_frame_p: Frames
scm_frame_previous: Frames
scm_frame_procedure_name: Frames
scm_from_bool: Booleans
scm_from_char: Integers
scm_from_double: Reals and Rationals
scm_from_int: Integers
scm_from_int16: Integers
scm_from_int32: Integers
scm_from_int64: Integers
scm_from_int8: Integers
scm_from_intmax: Integers
scm_from_intptr_t: Integers
scm_from_latin1_keyword: Keyword Procedures
scm_from_latin1_string: Conversion to/from C
scm_from_latin1_stringn: Conversion to/from C
scm_from_latin1_symbol: Symbol Primitives
scm_from_locale_keyword: Keyword Procedures
scm_from_locale_keywordn: Keyword Procedures
scm_from_locale_string: Conversion to/from C
scm_from_locale_stringn: Conversion to/from C
scm_from_locale_symbol: Symbol Primitives
scm_from_locale_symboln: Symbol Primitives
scm_from_long: Integers
scm_from_long_long: Integers
scm_from_mpz: Integers
scm_from_pointer: Foreign Pointers
scm_from_port_string: Conversion to/from C
scm_from_port_stringn: Conversion to/from C
scm_from_ptrdiff_t: Integers
scm_from_schar: Integers
scm_from_short: Integers
scm_from_signed_integer: Integers
scm_from_size_t: Integers
scm_from_sockaddr: Network Socket Address
scm_from_ssize_t: Integers
scm_from_stringn: Conversion to/from C
scm_from_uchar: Integers
scm_from_uint: Integers
scm_from_uint16: Integers
scm_from_uint32: Integers
scm_from_uint64: Integers
scm_from_uint8: Integers
scm_from_uintmax: Integers
scm_from_uintptr_t: Integers
scm_from_uintptr_t: Integers
scm_from_ulong: Integers
scm_from_ulong_long: Integers
scm_from_unsigned_integer: Integers
scm_from_ushort: Integers
scm_from_utf32_string: Conversion to/from C
scm_from_utf32_stringn: Conversion to/from C
scm_from_utf8_keyword: Keyword Procedures
scm_from_utf8_string: Conversion to/from C
scm_from_utf8_stringn: Conversion to/from C
scm_from_utf8_symbol: Symbol Primitives
scm_fsync: Ports and File Descriptors
scm_ftell: Random Access
scm_gc: Garbage Collection Functions
scm_gcd: Integer Operations
scm_gc_calloc: Memory Blocks
scm_gc_free: Memory Blocks
scm_gc_live_object_stats: Garbage Collection Functions
scm_gc_malloc: Memory Blocks
scm_gc_malloc_pointerless: Memory Blocks
scm_gc_mark: Garbage Collection Functions
scm_gc_protect_object: Garbage Collection Functions
scm_gc_realloc: Memory Blocks
scm_gc_register_allocation: Memory Blocks
scm_gc_stats: Garbage Collection Functions
scm_gc_unprotect_object: Garbage Collection Functions
scm_gensym: Symbol Primitives
scm_geq_p: Comparison
scm_getaddrinfo: Network Databases
scm_getaffinity: Processes
scm_getcwd: Processes
scm_getegid: Processes
scm_getenv: Runtime Environment
scm_geteuid: Processes
scm_getgid: Processes
scm_getgrgid: User Information
scm_getgroups: Processes
scm_gethost: Network Databases
scm_gethostname: System Identification
scm_getitimer: Signals
scm_getlogin: User Information
scm_getnet: Network Databases
scm_getpass: Encryption
scm_getpeername: Network Sockets and Communication
scm_getpgrp: Processes
scm_getpid: Processes
scm_getppid: Processes
scm_getpriority: Processes
scm_getproto: Network Databases
scm_getpwuid: User Information
scm_getserv: Network Databases
scm_getsid: Processes
scm_getsockname: Network Sockets and Communication
scm_getsockopt: Network Sockets and Communication
scm_gettext: Gettext Support
scm_gettimeofday: Time
scm_getuid: Processes
scm_get_bytevector_all: Binary I/O
scm_get_bytevector_n: Binary I/O
scm_get_bytevector_n_x: Binary I/O
scm_get_bytevector_some: Binary I/O
scm_get_bytevector_some_x: Binary I/O
scm_get_internal_real_time: Time
scm_get_internal_run_time: Time
scm_get_output_string: String Ports
scm_get_u8: Binary I/O
SCM_GLOBAL_SYMBOL: Snarfing Macros
scm_gmtime: Time
scm_gr_p: Comparison
scm_hash: Hash Table Reference
scm_hashq: Hash Table Reference
scm_hashq_create_handle_x: Hash Table Reference
scm_hashq_get_handle: Hash Table Reference
scm_hashq_ref: Hash Table Reference
scm_hashq_remove_x: Hash Table Reference
scm_hashq_set_x: Hash Table Reference
scm_hashv: Hash Table Reference
scm_hashv_create_handle_x: Hash Table Reference
scm_hashv_get_handle: Hash Table Reference
scm_hashv_ref: Hash Table Reference
scm_hashv_remove_x: Hash Table Reference
scm_hashv_set_x: Hash Table Reference
scm_hashx_create_handle_x: Hash Table Reference
scm_hashx_get_handle: Hash Table Reference
scm_hashx_ref: Hash Table Reference
scm_hashx_remove_x: Hash Table Reference
scm_hashx_set_x: Hash Table Reference
scm_hash_clear_x: Hash Table Reference
scm_hash_count: Hash Table Reference
scm_hash_create_handle_x: Hash Table Reference
scm_hash_fold: Hash Table Reference
scm_hash_for_each: Hash Table Reference
scm_hash_for_each_handle: Hash Table Reference
scm_hash_get_handle: Hash Table Reference
scm_hash_map_to_list: Hash Table Reference
scm_hash_ref: Hash Table Reference
scm_hash_remove_x: Hash Table Reference
scm_hash_set_x: Hash Table Reference
scm_hash_table_p: Hash Table Reference
SCM_HOOKP: Hook Reference
scm_hook_empty_p: Hook Reference
scm_hook_p: Hook Reference
scm_hook_to_list: Hook Reference
scm_imag_part: Complex
SCM_IMP: Immediate Objects
scm_inet_makeaddr: Network Address Conversion
scm_inet_netof: Network Address Conversion
scm_inet_ntop: Network Address Conversion
scm_inet_pton: Network Address Conversion
scm_inexact_p: Exactness
scm_inexact_to_exact: Exactness
scm_inf: Reals and Rationals
scm_inf_p: Reals and Rationals
scm_init_guile: Initialization
scm_input_port_p: Ports
scm_integer_expt: Bitwise Operations
scm_integer_length: Bitwise Operations
scm_integer_p: Integers
scm_integer_to_char: Characters
scm_interaction_environment: Fly Evaluation
scm_internal_catch: Exceptions and C
scm_isatty_p: Terminals and Ptys
scm_is_array: Array Procedures
scm_is_bitvector: Bit Vectors
scm_is_bool: Booleans
scm_is_bytevector: Bytevector Manipulation
scm_is_complex: Complex Numbers
scm_is_dynamic_state: Fluids and Dynamic States
scm_is_eq: Equality
scm_is_exact: Exactness
scm_is_exact_integer: Integers
scm_is_false: Booleans
scm_is_inexact: Exactness
scm_is_integer: Integers
scm_is_keyword: Keyword Procedures
scm_is_null: List Predicates
scm_is_number: Numerical Tower
scm_is_pair: Pairs
scm_is_rational: Reals and Rationals
scm_is_real: Reals and Rationals
scm_is_signed_integer: Integers
scm_is_string: String Predicates
scm_is_symbol: Symbol Primitives
scm_is_true: Booleans
scm_is_typed_array: Array Procedures
scm_is_unsigned_integer: Integers
scm_is_vector: Vector Creation
scm_join_thread: Threads
scm_join_thread_timed: Threads
SCM_KEYWORD: Snarfing Macros
scm_keyword_p: Keyword Procedures
scm_keyword_to_symbol: Keyword Procedures
scm_kill: Signals
scm_last_pair: List Selection
scm_lcm: Integer Operations
scm_length: List Selection
scm_leq_p: Comparison
scm_less_p: Comparison
scm_link: File System
scm_listen: Network Sockets and Communication
scm_list_1: List Constructors
scm_list_2: List Constructors
scm_list_3: List Constructors
scm_list_4: List Constructors
scm_list_5: List Constructors
scm_list_cdr_set_x: List Modification
scm_list_copy: List Constructors
scm_list_head: List Selection
scm_list_n: List Constructors
scm_list_p: List Predicates
scm_list_ref: List Selection
scm_list_set_x: List Modification
scm_list_tail: List Selection
scm_list_to_bitvector: Bit Vectors
scm_list_to_c32vector: SRFI-4 API
scm_list_to_c64vector: SRFI-4 API
scm_list_to_char_set: Creating Character Sets
scm_list_to_char_set_x: Creating Character Sets
scm_list_to_f32vector: SRFI-4 API
scm_list_to_f64vector: SRFI-4 API
scm_list_to_s16vector: SRFI-4 API
scm_list_to_s32vector: SRFI-4 API
scm_list_to_s64vector: SRFI-4 API
scm_list_to_s8vector: SRFI-4 API
scm_list_to_typed_array: Array Procedures
scm_list_to_u16vector: SRFI-4 API
scm_list_to_u32vector: SRFI-4 API
scm_list_to_u64vector: SRFI-4 API
scm_list_to_u8vector: SRFI-4 API
scm_lnaof: Network Address Conversion
scm_load_extension: Foreign Extensions
scm_load_thunk_from_file: Bytecode
scm_load_thunk_from_memory: Bytecode
scm_locale_p: i18n Introduction
scm_locale_string_to_inexact: Number Input and Output
scm_locale_string_to_integer: Number Input and Output
scm_localtime: Time
scm_local_eval: Local Evaluation
scm_lock_mutex: Mutexes and Condition Variables
scm_logand: Bitwise Operations
scm_logbit_p: Bitwise Operations
scm_logcount: Bitwise Operations
scm_logior: Bitwise Operations
scm_lognot: Bitwise Operations
scm_logtest: Bitwise Operations
scm_lookahead_u8: Binary I/O
scm_lookup: Accessing Modules from C
scm_loxor: Bitwise Operations
scm_lstat: File System
scm_macro_binding: Internal Macros
scm_macro_name: Internal Macros
scm_macro_p: Internal Macros
scm_macro_transformer: Internal Macros
scm_macro_type: Internal Macros
scm_magnitude: Complex
scm_major_version: Build Config
scm_make_array: Array Procedures
scm_make_bytevector: Bytevector Manipulation
scm_make_c32vector: SRFI-4 API
scm_make_c64vector: SRFI-4 API
scm_make_condition_variable: Mutexes and Condition Variables
scm_make_doubly_weak_hash_table: Weak hash tables
scm_make_f32vector: SRFI-4 API
scm_make_f64vector: SRFI-4 API
scm_make_fluid: Fluids and Dynamic States
scm_make_fluid_with_default: Fluids and Dynamic States
scm_make_foreign_object_0: Foreign Objects
scm_make_foreign_object_1: Foreign Objects
scm_make_foreign_object_2: Foreign Objects
scm_make_foreign_object_3: Foreign Objects
scm_make_foreign_object_n: Foreign Objects
scm_make_foreign_object_type: Foreign Objects
scm_make_guardian: Guardians
scm_make_hook: Hook Reference
scm_make_locale: i18n Introduction
scm_make_mutex: Mutexes and Condition Variables
scm_make_mutex_with_kind: Mutexes and Condition Variables
scm_make_polar: Complex
scm_make_port_type: I/O Extensions
scm_make_procedure_with_setter: Procedures with Setters
scm_make_rectangular: Complex
scm_make_recursive_mutex: Mutexes and Condition Variables
scm_make_regexp: Regexp Functions
scm_make_s16vector: SRFI-4 API
scm_make_s32vector: SRFI-4 API
scm_make_s64vector: SRFI-4 API
scm_make_s8vector: SRFI-4 API
scm_make_shared_array: Shared Arrays
scm_make_smob_type: Smobs
scm_make_socket_address: Network Socket Address
scm_make_stack: Stack Capture
scm_make_string: String Constructors
scm_make_struct: Structure Basics
scm_make_struct_layout: Meta-Vtables
scm_make_symbol: Symbol Uninterned
scm_make_thread_local_fluid: Thread Local Variables
scm_make_typed_array: Array Procedures
scm_make_u16vector: SRFI-4 API
scm_make_u32vector: SRFI-4 API
scm_make_u64vector: SRFI-4 API
scm_make_u8vector: SRFI-4 API
scm_make_unbound_fluid: Fluids and Dynamic States
scm_make_undefined_variable: Variables
scm_make_variable: Variables
scm_make_vector: Vector Creation
scm_make_weak_key_hash_table: Weak hash tables
scm_make_weak_value_hash_table: Weak hash tables
scm_make_weak_vector: Weak vectors
scm_malloc: Memory Blocks
scm_map: List Mapping
scm_markcdr: Smobs
scm_max: Arithmetic
scm_member: List Searching
scm_memq: List Searching
scm_memv: List Searching
scm_merge: Sorting
scm_merge_x: Sorting
scm_micro_version: Build Config
scm_min: Arithmetic
scm_minor_version: Build Config
scm_misc_error: Handling Errors
scm_mkdir: File System
scm_mkdirat: File System
scm_mkdtemp: File System
scm_mknod: File System
scm_mktime: Time
scm_module_define: Accessing Modules from C
scm_module_ensure_local_variable: Accessing Modules from C
scm_module_lookup: Accessing Modules from C
scm_module_reverse_lookup: Accessing Modules from C
scm_module_variable: Accessing Modules from C
scm_modulo: Integer Operations
scm_modulo_expt: Integer Operations
scm_mutex_level: Mutexes and Condition Variables
scm_mutex_locked_p: Mutexes and Condition Variables
scm_mutex_owner: Mutexes and Condition Variables
scm_mutex_p: Mutexes and Condition Variables
scm_nan: Reals and Rationals
scm_nan_p: Reals and Rationals
scm_native_endianness: Bytevector Endianness
scm_negative_p: Comparison
scm_new_double_smob: Smobs
scm_new_smob: Smobs
scm_ngettext: Gettext Support
scm_nice: Processes
scm_not: Booleans
scm_null_p: List Predicates
scm_number_p: Numerical Tower
scm_number_to_string: Conversion
scm_numerator: Reals and Rationals
scm_num_eq_p: Comparison
scm_num_overflow: Handling Errors
scm_object_properties: Object Properties
scm_object_property: Object Properties
scm_object_to_string: General Conversion
scm_odd_p: Integer Operations
scm_oneminus: Arithmetic
scm_oneplus: Arithmetic
scm_open: Ports and File Descriptors
scm_openat: Ports and File Descriptors
scm_opendir: File System
scm_open_bytevector_input_port: Bytevector Ports
scm_open_bytevector_output_port: Bytevector Ports
scm_open_fdes: Ports and File Descriptors
scm_open_fdes_at: Ports and File Descriptors
scm_open_file: File Ports
scm_open_file_with_encoding: File Ports
scm_open_input_string: String Ports
scm_open_output_string: String Ports
scm_output_port_p: Ports
scm_out_of_range: Handling Errors
scm_pair_p: Pairs
scm_parse_path: Load Paths
scm_parse_path_with_ellipsis: Load Paths
scm_pause: Signals
scm_permanent_object: Garbage Collection Functions
scm_pipe: Ports and File Descriptors
scm_pointer_address: Foreign Pointers
scm_pointer_to_bytevector: Void Pointers and Byte Access
scm_pointer_to_procedure: Foreign Functions
scm_pointer_to_procedure_with_errno: Foreign Functions
scm_port_closed_p: Ports
scm_port_column: Textual I/O
scm_port_conversion_strategy: Encoding
scm_port_encoding: Encoding
scm_port_filename: File Ports
scm_port_for_each: Ports and File Descriptors
scm_port_line: Textual I/O
scm_port_mode: File Ports
scm_port_p: Ports
scm_port_revealed: Ports and File Descriptors
scm_positive_p: Comparison
scm_primitive_eval: Fly Evaluation
scm_primitive_exit: Processes
scm_primitive_load: Loading
scm_primitive_load_path: Load Paths
scm_primitive_move_to_fdes: Ports and File Descriptors
scm_primitive__exit: Processes
scm_private_lookup: Accessing Modules from C
scm_private_ref: Accessing Modules from C
scm_private_variable: Accessing Modules from C
scm_procedure: Procedures with Setters
scm_procedure_documentation: Procedure Properties
scm_procedure_name: Procedure Properties
scm_procedure_p: Procedure Properties
scm_procedure_properties: Procedure Properties
scm_procedure_property: Procedure Properties
scm_procedure_source: Procedure Properties
scm_procedure_to_pointer: More Foreign Functions
scm_procedure_with_setter_p: Procedures with Setters
scm_product: Arithmetic
scm_program_arguments: Runtime Environment
scm_program_arities: Compiled Procedures
scm_program_code: Compiled Procedures
scm_program_free_variable-ref: Compiled Procedures
scm_program_free_variable_set_x: Compiled Procedures
scm_program_num_free_variables: Compiled Procedures
scm_program_p: Compiled Procedures
scm_promise_p: Delayed Evaluation
scm_pthread_cond_timedwait: Blocking
scm_pthread_cond_wait: Blocking
scm_pthread_mutex_lock: Blocking
scm_public_lookup: Accessing Modules from C
scm_public_ref: Accessing Modules from C
scm_public_variable: Accessing Modules from C
scm_putenv: Runtime Environment
scm_put_bytevector: Binary I/O
scm_put_u8: Binary I/O
scm_quotient: Integer Operations
scm_raise: Signals
scm_random: Random
scm_random_exp: Random
scm_random_hollow_sphere_x: Random
scm_random_normal: Random
scm_random_normal_vector_x: Random
scm_random_solid_sphere_x: Random
scm_random_state_from_platform: Random
scm_random_state_to_datum: Random
scm_random_uniform: Random
scm_rationalize: Reals and Rationals
scm_rational_p: Reals and Rationals
scm_read: Scheme Read
scm_readdir: File System
scm_readlink: File System
scm_read_delimited_x: Line/Delimited
scm_read_hash_extend: Reader Extensions
scm_read_line: Line/Delimited
scm_realloc: Memory Blocks
scm_real_p: Reals and Rationals
scm_real_part: Complex
scm_recv: Network Sockets and Communication
scm_recvfrom: Network Sockets and Communication
scm_redirect_port: Ports and File Descriptors
scm_regexp_exec: Regexp Functions
scm_regexp_p: Regexp Functions
scm_remainder: Integer Operations
scm_remember_upto_here_1: Garbage Collection Functions
scm_remember_upto_here_2: Garbage Collection Functions
scm_remove_hook_x: Hook Reference
scm_rename: File System
scm_renameat: File System
scm_reset_hook_x: Hook Reference
scm_resolve_module: Module System Reflection
scm_restore_signals: Signals
scm_restricted_vector_sort_x: Sorting
scm_reverse: Append/Reverse
scm_reverse_list_to_string: String Constructors
scm_reverse_x: Append/Reverse
scm_rewinddir: File System
scm_rmdir: File System
scm_round_ash: Bitwise Operations
scm_round_divide: Arithmetic
scm_round_number: Arithmetic
scm_round_quotient: Arithmetic
scm_round_remainder: Arithmetic
scm_run_finalizers: Foreign Objects
scm_run_hook: Hook Reference
scm_s16vector: SRFI-4 API
scm_s16vector_elements: SRFI-4 API
scm_s16vector_length: SRFI-4 API
scm_s16vector_p: SRFI-4 API
scm_s16vector_ref: SRFI-4 API
scm_s16vector_set_x: SRFI-4 API
scm_s16vector_to_list: SRFI-4 API
scm_s16vector_writable_elements: SRFI-4 API
scm_s32vector: SRFI-4 API
scm_s32vector_elements: SRFI-4 API
scm_s32vector_length: SRFI-4 API
scm_s32vector_p: SRFI-4 API
scm_s32vector_ref: SRFI-4 API
scm_s32vector_set_x: SRFI-4 API
scm_s32vector_to_list: SRFI-4 API
scm_s32vector_writable_elements: SRFI-4 API
scm_s64vector: SRFI-4 API
scm_s64vector_elements: SRFI-4 API
scm_s64vector_length: SRFI-4 API
scm_s64vector_p: SRFI-4 API
scm_s64vector_ref: SRFI-4 API
scm_s64vector_set_x: SRFI-4 API
scm_s64vector_to_list: SRFI-4 API
scm_s64vector_writable_elements: SRFI-4 API
scm_s8vector: SRFI-4 API
scm_s8vector_elements: SRFI-4 API
scm_s8vector_length: SRFI-4 API
scm_s8vector_p: SRFI-4 API
scm_s8vector_ref: SRFI-4 API
scm_s8vector_set_x: SRFI-4 API
scm_s8vector_to_list: SRFI-4 API
scm_s8vector_writable_elements: SRFI-4 API
scm_search_path: Load Paths
scm_seed_to_random_state: Random
scm_seek: Random Access
scm_select: Ports and File Descriptors
scm_send: Network Sockets and Communication
scm_sendfile: File System
scm_sendto: Network Sockets and Communication
scm_setaffinity: Processes
scm_setegid: Processes
scm_seteuid: Processes
scm_setgid: Processes
scm_setgrent: User Information
scm_setgroups: Processes
scm_sethost: Network Databases
scm_sethostname: System Identification
scm_setitimer: Signals
scm_setlocale: Locales
scm_setnet: Network Databases
scm_setpgid: Processes
scm_setpriority: Processes
scm_setproto: Network Databases
scm_setpwent: User Information
scm_setserv: Network Databases
scm_setsid: Processes
scm_setsockopt: Network Sockets and Communication
scm_setuid: Processes
scm_setvbuf: Buffering
scm_set_automatic_finalization_enabled: Foreign Objects
scm_set_car_x: Pairs
scm_set_cdr_x: Pairs
SCM_SET_CELL_OBJECT: Accessing Heap Object Fields
SCM_SET_CELL_OBJECT_0: Accessing Heap Object Fields
SCM_SET_CELL_OBJECT_1: Accessing Heap Object Fields
SCM_SET_CELL_OBJECT_2: Accessing Heap Object Fields
SCM_SET_CELL_OBJECT_3: Accessing Heap Object Fields
SCM_SET_CELL_TYPE: Heap Object Type Information
SCM_SET_CELL_WORD: Accessing Heap Object Fields
SCM_SET_CELL_WORD_0: Accessing Heap Object Fields
SCM_SET_CELL_WORD_1: Accessing Heap Object Fields
SCM_SET_CELL_WORD_2: Accessing Heap Object Fields
SCM_SET_CELL_WORD_3: Accessing Heap Object Fields
scm_set_current_dynamic_state: Fluids and Dynamic States
scm_set_current_error_port: Default Ports
scm_set_current_input_port: Default Ports
scm_set_current_module: Module System Reflection
scm_set_current_output_port: Default Ports
scm_set_object_properties_x: Object Properties
scm_set_object_property_x: Object Properties
scm_set_port_close: I/O Extensions
scm_set_port_column_x: Textual I/O
scm_set_port_conversion_strategy_x: Encoding
scm_set_port_encoding_x: Encoding
scm_set_port_filename_x: File Ports
scm_set_port_get_natural_buffer_sizes: I/O Extensions
scm_set_port_line_x: Textual I/O
scm_set_port_needs_close_on_gc: I/O Extensions
scm_set_port_print: I/O Extensions
scm_set_port_random_access_p: I/O Extensions
scm_set_port_read_wait_fd: I/O Extensions
scm_set_port_revealed_x: Ports and File Descriptors
scm_set_port_seek: I/O Extensions
scm_set_port_truncate: I/O Extensions
scm_set_port_write_wait_fd: I/O Extensions
scm_set_procedure_properties_x: Procedure Properties
scm_set_procedure_property_x: Procedure Properties
scm_set_program_arguments: Runtime Environment
scm_set_program_arguments_scm: Runtime Environment
scm_set_smob_equalp: Smobs
scm_set_smob_free: Smobs
scm_set_smob_mark: Smobs
scm_set_smob_print: Smobs
scm_set_source_properties_x: Source Properties
scm_set_source_property_x: Source Properties
scm_set_struct_vtable_name_x: Vtable Contents
scm_shared_array_increments: Shared Arrays
scm_shared_array_offset: Shared Arrays
scm_shared_array_root: Shared Arrays
scm_shell: Initialization
scm_shutdown: Network Sockets and Communication
scm_sigaction: Signals
scm_sigaction_for_thread: Signals
scm_signal_condition_variable: Mutexes and Condition Variables
scm_simple_format: Simple Output
SCM_SIMPLE_VECTOR_LENGTH: Vector Accessing from C
SCM_SIMPLE_VECTOR_REF: Vector Accessing from C
SCM_SIMPLE_VECTOR_SET: Vector Accessing from C
scm_sint_list_to_bytevector: Bytevectors and Integer Lists
scm_sizeof: Foreign Structs
scm_sleep: Signals
scm_sloppy_assoc: Sloppy Alist Functions
scm_sloppy_assq: Sloppy Alist Functions
scm_sloppy_assv: Sloppy Alist Functions
SCM_SNARF_INIT: Snarfing Macros
scm_socket: Network Sockets and Communication
scm_socketpair: Network Sockets and Communication
scm_sort: Sorting