Procedure Index

This is an alphabetical list of all the procedures and macros in Guile.

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 Transforming Scheme name to C name.

• $abs: Primitive Numerics
• $acos: Primitive Numerics
• $acosh: Primitive Numerics
• $asin: Primitive Numerics
• $asinh: Primitive Numerics
• $atan: Primitive Numerics
• $atan2: Primitive Numerics
• $atanh: Primitive Numerics
• $cos: Primitive Numerics
• $cosh: Primitive Numerics
• $exp: Primitive Numerics
• $expt: Primitive Numerics
• $log: Primitive Numerics
• $sin: Primitive Numerics
• $sinh: Primitive Numerics
• $sqrt: Primitive Numerics
• $tan: Primitive Numerics
• $tanh: Primitive Numerics
• %library-dir: Install Config
• %make-void-port: Void Ports
• %package-data-dir: Install Config
• %read-delimited!: Line/Delimited
• %read-line: Line/Delimited
• %search-load-path: Loading
• %site-dir: Install Config
• %thread-handler: Higher level thread procedures
• *: Arithmetic
• +: Arithmetic
• -: Arithmetic
• -1+: Miscellaneous Procs
• ->bool: Booleans
• ->char-set: SRFI-14 Creating Character Sets
• /: Arithmetic
• 1+: Miscellaneous Procs
• 1-: Miscellaneous Procs
• <: Comparison
• <=: Comparison
• <group>-disable: General option interface
• <group>-enable: General option interface
• <group>-options: General option interface
• <group>-options-interface: General option interface
• <group>-set!: General option interface
• =: Comparison
• >: Comparison
• >=: Comparison
• abs: Arithmetic
• accept: Network Sockets and Communication
• access?: File System
• accumulator: Efficient Accumulation
• accumulator/counting: Efficient Accumulation
• accumulator/one-only: Efficient Accumulation
• acons: Adding or Setting Alist Entries
• acos: Scientific
• acosh: Scientific
• activate-global-module-system-bindings!: Prior Suffering
• activate-infix: Reading Infix
• add-hook!: Hook Reference
• add-infix-operator: Reading Infix
• add-prefix-operator: Reading Infix
• add-to-load-path!: Preloaded Modules for Interactive Sessions
• adjoin: Common List Operations
• advance-dfa!: Rgx Regexps
• alarm: Signals
• alist-cons: SRFI-1 Association Lists
• alist-copy: SRFI-1 Association Lists
• alist-delete: SRFI-1 Association Lists
• alist-delete!: SRFI-1 Association Lists
• and: and or
• and-let*: SRFI-2
• and-map: List Mapping
• and=>: Miscellaneous Procs
• and?: Common List Operations
• angle: Complex
• any: SRFI-1 Searching
• 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-frame-handler: Evaluator trap options
• apply-to-args: Miscellaneous Procs
• apply:nconc2last: Fly Evaluation
• apropos: Preloaded Modules for Interactive Sessions
• apropos-fold: Preloaded Modules for Interactive Sessions
• apropos-fold-accessible: Preloaded Modules for Interactive Sessions
• apropos-internal: Preloaded Modules for Interactive Sessions
• arity: Preloaded Modules for Interactive Sessions
• array->list: Conventional Arrays
• array-contents: Conventional Arrays
• array-copy!: Conventional Arrays
• array-copy-in-order!: Conventional Arrays
• array-dimensions: Conventional Arrays
• array-equal?: Conventional Arrays
• array-fill!: Conventional Arrays
• array-for-each: Array Mapping
• array-in-bounds?: Conventional Arrays
• array-index-map!: Array Mapping
• array-map!: Array Mapping
• array-map-in-order!: Array Mapping
• array-prototype: Uniform Arrays
• array-rank: Conventional Arrays
• array-ref: Conventional Arrays
• array-set!: Conventional Arrays
• array-shape: Conventional Arrays
• array?: Uniform Arrays
• array?: Conventional Arrays
• ash: Bitwise Operations
• asin: Scientific
• asinh: Scientific
• assoc: SRFI-1 Association Lists
• assoc: Retrieving Alist Entries
• assoc-ref: Retrieving Alist Entries
• assoc-remove!: Removing Alist Entries
• assoc-set!: Adding or Setting Alist Entries
• assq: Retrieving Alist Entries
• assq-ref: Retrieving Alist Entries
• assq-remove!: Removing Alist Entries
• assq-set!: Adding or Setting Alist Entries
• assv: Retrieving Alist Entries
• assv-ref: Retrieving Alist Entries
• assv-remove!: Removing Alist Entries
• assv-set!: Adding or Setting Alist Entries
• async: Asyncs
• async-mark: Asyncs
• atan: Scientific
• atanh: Scientific
• backtrace: Backtrace
• base64-decode: Base64
• base64-encode: Base64
• basename: File System
• batch-mode?: Dynamic Roots
• begin: begin
• begin-thread: Higher level thread procedures
• binary-port?: SRFI-56 Port extensions
• bind: Network Sockets and Communication
• bit-count: Bit Vectors
• bit-count*: Bit Vectors
• bit-extract: Bitwise Operations
• bit-invert!: Bit Vectors
• bit-position: Bit Vectors
• bit-set*!: Bit Vectors
• boolean?: Booleans
• bound?: lambda* Reference
• break: SRFI-1 Searching
• break!: SRFI-1 Searching
• builtin-variable: Variables
• butlast: Common List Operations
• byte-ready?: SRFI-56 I/O extensions
• caar: Pairs
• cadr: Pairs
• call-with-binary-input-file: SRFI-56 Port extensions
• call-with-binary-output-file: SRFI-56 Port extensions
• call-with-current-continuation: Continuations
• call-with-dynamic-root: Dynamic Roots
• call-with-input-file: File Ports
• call-with-input-string: String Ports
• call-with-new-thread: Low level thread primitives
• call-with-output-file: File Ports
• call-with-output-string: String Ports
• call-with-values: Multiple Values
• car: Pairs
• car+cdr: SRFI-1 Selectors
• case: if cond case
• catch: Catch
• cd: Processes
• cdddar: Pairs
• cddddr: Pairs
• cdr: Pairs
• ceiling: Arithmetic
• char->integer: Characters
• char-alphabetic?: Characters
• char-ci<=?: Characters
• char-ci<?: Characters
• char-ci=?: Characters
• char-ci>=?: Characters
• char-ci>?: Characters
• char-downcase: Characters
• char-is-both?: Characters
• char-lower-case?: Characters
• char-numeric?: Characters
• char-ready?: Reading
• char-set: SRFI-14 Creating Character Sets
• char-set->list: SRFI-14 Querying Character Sets
• char-set->string: SRFI-14 Querying Character Sets
• char-set-adjoin: SRFI-14 Character-Set Algebra
• char-set-adjoin!: SRFI-14 Character-Set Algebra
• char-set-any: SRFI-14 Querying Character Sets
• char-set-complement: SRFI-14 Character-Set Algebra
• char-set-complement!: SRFI-14 Character-Set Algebra
• char-set-contains?: SRFI-14 Querying Character Sets
• char-set-copy: SRFI-14 Creating Character Sets
• char-set-count: SRFI-14 Querying Character Sets
• char-set-cursor: SRFI-14 Iterating Over Character Sets
• char-set-cursor-next: SRFI-14 Iterating Over Character Sets
• char-set-delete: SRFI-14 Character-Set Algebra
• char-set-delete!: SRFI-14 Character-Set Algebra
• char-set-diff+intersection: SRFI-14 Character-Set Algebra
• char-set-diff+intersection!: SRFI-14 Character-Set Algebra
• char-set-difference: SRFI-14 Character-Set Algebra
• char-set-difference!: SRFI-14 Character-Set Algebra
• char-set-every: SRFI-14 Querying Character Sets
• char-set-filter: SRFI-14 Creating Character Sets
• char-set-filter!: SRFI-14 Creating Character Sets
• char-set-fold: SRFI-14 Iterating Over Character Sets
• char-set-for-each: SRFI-14 Iterating Over Character Sets
• char-set-hash: SRFI-14 Predicates/Comparison
• char-set-intersection: SRFI-14 Character-Set Algebra
• char-set-intersection!: SRFI-14 Character-Set Algebra
• char-set-map: SRFI-14 Iterating Over Character Sets
• char-set-ref: SRFI-14 Iterating Over Character Sets
• char-set-size: SRFI-14 Querying Character Sets
• char-set-unfold: SRFI-14 Iterating Over Character Sets
• char-set-union: SRFI-14 Character-Set Algebra
• char-set-union!: SRFI-14 Character-Set Algebra
• char-set-xor: SRFI-14 Character-Set Algebra
• char-set-xor!: SRFI-14 Character-Set Algebra
• char-set<=: SRFI-14 Predicates/Comparison
• char-set=: SRFI-14 Predicates/Comparison
• char-set?: SRFI-14 Predicates/Comparison
• char-upcase: Characters
• char-upper-case?: Characters
• char-whitespace?: Characters
• char<=?: Characters
• char<?: Characters
• char=?: Characters
• char>=?: Characters
• char>?: Characters
• char?: Characters
• character-port?: SRFI-56 Port extensions
• chdir: Processes
• chmod: File System
• chown: File System
• circular-list?: SRFI-1 Predicates
• close: Ports and File Descriptors
• close-fdes: Ports and File Descriptors
• close-input-port: Closing
• close-output-port: Closing
• close-pipe: Pipes
• close-port: Closing
• closedir: File System
• closure?: Procedure Properties
• collect: Miscellaneous Procs
• command-line: Runtime Environment
• command-line: The Top of a Script File
• compiled-regexp?: Rgx Regexps
• complex?: Complex Numbers
• concatenate: SRFI-1 Length Append etc
• concatenate!: SRFI-1 Length Append etc
• cond: if cond case
• connect: Network Sockets and Communication
• cons: Pairs
• cons*: List Constructors
• cons-source: Internal Macros
• continuation?: Continuations
• copy-file: File System
• copy-random-state: Random
• copy-tree: Copying
• cos: Scientific
• cosh: Scientific
• count-if: Common List Operations
• create-index-file!: database fcookie
• ctermid: Terminals and Ptys
• current-error-port: Default Ports
• current-input-port: Default Ports
• current-load-port: Loading
• current-module: Module Monkey
• current-output-port: Default Ports
• current-test-prefix: POSIX-Style Testing
• current-time: Time
• cuserid: User Information
• cut: SRFI-26
• cute: SRFI-26
• debug-disable: General option interface
• debug-enable: General option interface
• debug-object?: Debugging
• debug-options: General option interface
• debug-options-interface: Debugging
• debug-set!: General option interface
• default-endian: SRFI-56 Endianness
• default-float-endian: SRFI-56 IEEE floating-point encodings
• default-lazy-handler: Evaluator trap options
• define: Top Level
• define*: define* Reference
• define*-public: define* Reference
• define-inf-guile-transition: REPL Under Emacs
• define-macro: Macros
• define-module: Creating Guile Modules
• define-public: Creating Guile Modules
• define-reader-ctor: SRFI-10
• defined?: Binding Reflection
• definitions-in: Bindings Browsing
• defmacro: Macros
• defmacro*: define* Reference
• defmacro*-public: define* Reference
• delete: SRFI-1 Deleting
• delete: List Modification
• delete!: SRFI-1 Deleting
• delete!: List Modification
• delete-duplicates: SRFI-1 Deleting
• delete-duplicates!: SRFI-1 Deleting
• delete-file: File System
• delete-if!: Common List Operations
• delete-if-not!: Common List Operations
• delete1!: List Modification
• delims: Line/Delimited
• delq: List Modification
• delq!: List Modification
• delq1!: List Modification
• delv: List Modification
• delv!: List Modification
• delv1!: List Modification
• deq!: Queues
• dfa-continuable?: Rgx Regexps
• dfa-final-tag: Rgx Regexps
• dfa-fork: Rgx Regexps
• dimensions->uniform-array: Uniform Arrays
• directory-stream?: File System
• dirname: File System
• disable-module-catalogs!: Module Monkey
• display: Writing
• display-application: Debugging
• display-backtrace: Debugging
• display-error: Handling Errors
• display-grammar-item-table: lang lr0
• display-item-set: lang lr0
• display-item-set-closure: lang lr0
• display-state-stack-entry: lang lr1
• do: while do
• dotted-list?: SRFI-1 Predicates
• doubly-weak-hash-table?: Weak key hashes
• drain-input: Reading
• drop: SRFI-1 Selectors
• 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-args-call: Low level dynamic linking
• dynamic-call: Low level dynamic linking
• dynamic-func: Low level dynamic linking
• dynamic-link: Low level dynamic linking
• dynamic-object?: Low level dynamic linking
• dynamic-root: Dynamic Roots
• dynamic-unlink: Low level dynamic linking
• dynamic-wind: Dynamic Wind
• editing-buffer: Editing Buffer
• eight: SRFI-1 Selectors
• enclose-array: Conventional Arrays
• end-of-char-set?: SRFI-14 Iterating Over Character Sets
• endgrent: User Information
• endhostent: Network Databases
• endnetent: Network Databases
• endprotoent: Network Databases
• endpwent: User Information
• endservent: Network Databases
• enq!: Queues
• enter-frame-handler: Evaluator trap options
• entity?: Objects
• environ: Runtime Environment
• eof-object?: Reading
• eof-token: lang lex
• eof-token?: lang lex
• eq?: Equality
• equal?: Equality
• eqv?: Equality
• error: Handling Errors
• error: Error Reporting
• eval: Fly Evaluation
• eval-disable: Evaluator Behaviour
• eval-enable: Evaluator Behaviour
• eval-in-current-module-proc: Module Monkey
• eval-in-module: Module Monkey
• eval-options: Evaluator Behaviour
• eval-options-interface: Evaluator Behaviour
• eval-set!: Evaluator Behaviour
• eval-string: Fly Evaluation
• evaluator-traps-interface: General option interface
• evaluator-traps-interface: Evaluator Behaviour
• even?: Integer Operations
• every: Common List Operations
• every: SRFI-1 Searching
• exact->inexact: Exactness
• exact?: Exactness
• execl: Processes
• execle: Processes
• execlp: Processes
• exit: Dynamic Roots
• exit-frame-handler: Evaluator trap options
• exp: Scientific
• expect: Expect
• expect-fail: POSIX-Style Testing
• expect-fail-exception: POSIX-Style Testing
• expect-strings: Expect
• export: Creating Guile Modules
• expt: Scientific
• fair-strip-subtask: Run Queues
• false-if-exception: Error Reporting
• false-if-exception: Miscellaneous Procs
• fchmod: File System
• fchown: 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
• fdopen: Ports and File Descriptors
• feature?: Feature Manipulation
• fflush: Writing
• fifth: SRFI-1 Selectors
• file-commentary: Documentation
• fileno: Ports and File Descriptors
• filter: SRFI-1 Filtering and Partitioning
• filter!: SRFI-1 Filtering and Partitioning
• filter-map: SRFI-1 Fold and Map
• find: SRFI-1 Searching
• find-file: Editing Buffer
• find-file-read-only: Editing Buffer
• find-if: Common List Operations
• find-tail: SRFI-1 Searching
• first: SRFI-1 Selectors
• floating-point-byte-string->real: database binconv
• floor: Arithmetic
• fluid-ref: Fluids
• fluid-set!: Fluids
• fluid?: Fluids
• flush-all-ports: Writing
• fn: Defining new Scheme procedures in C
• fob-info: Module Monkey
• fold: SRFI-1 Fold and Map
• fold-right: SRFI-1 Fold and Map
• for-each: SRFI-1 Fold and Map
• for-each: List Mapping
• force: Delayed Evaluation
• force-output: Writing
• format: Formatted Output
• format-test-name: POSIX-Style Testing
• fortune-cookie: database fcookie
• fourth: SRFI-1 Selectors
• frame-arguments: Debugging
• frame-evaluating-args?: Debugging
• frame-next: Debugging
• frame-number: Debugging
• frame-overflow?: Debugging
• frame-previous: Debugging
• frame-procedure: Debugging
• frame-procedure?: Debugging
• frame-real?: Debugging
• frame-source: Debugging
• frame?: Debugging
• fstat: File System
• fsync: Ports and File Descriptors
• ftell: Random Access
• ftruncate: Random Access
• ftw: Filesystem Tree Walk
• ftw-callback: Filesystem Tree Walk
• full-reporter: POSIX-Style Testing
• gb->lines: Gap Buffer
• gb->port!: Gap Buffer
• gb->string: Gap Buffer
• gb->substring: Gap Buffer
• gb-backward-char: Gap Buffer
• gb-beginning-of-line: Gap Buffer
• gb-bobp: Gap Buffer
• gb-bolp: Gap Buffer
• gb-char-after: Gap Buffer
• gb-char-before: Gap Buffer
• gb-delete-char!: Gap Buffer
• gb-delete-region: Gap Buffer
• gb-end-of-line: Gap Buffer
• gb-eobp: Gap Buffer
• gb-eolp: Gap Buffer
• gb-erase!: Gap Buffer
• gb-filter!: Gap Buffer
• gb-filter-lines!: Gap Buffer
• gb-forward-char: Gap Buffer
• gb-forward-line: Gap Buffer
• gb-goto-char: Gap Buffer
• gb-insert: Gap Buffer
• gb-insert-char!: Gap Buffer
• gb-insert-string!: Gap Buffer
• gb-looking-at: Gap Buffer
• gb-match-beginning: Gap Buffer
• gb-match-end: Gap Buffer
• gb-match-string: Gap Buffer
• gb-point: Gap Buffer
• gb-point-max: Gap Buffer
• gb-point-min: Gap Buffer
• gb-re-search-forward: Gap Buffer
• gb-replace-match: Gap Buffer
• gb-search-backward: Gap Buffer
• gb-search-forward: Gap Buffer
• gb-toggle-read-only: Gap Buffer
• gb?: Gap Buffer
• gc: Garbage Collection
• gc-stats: Garbage Collection
• gcd: Integer Operations
• gensym: Symbol Primitives
• get-internal-real-time: Time
• get-internal-run-time: Time
• get-output-string: String Ports
• get-print-state: Writing
• 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
• getlogin: User Information
• getnet: Network Databases
• getnetbyaddr: Network Databases
• getnetbyname: Network Databases
• getnetent: Network Databases
• getopt-long: getopt-long Reference
• getpeername: Network Sockets and Communication
• getpgrp: Processes
• getpid: Processes
• getppid: 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
• getsockname: Network Sockets and Communication
• getsockopt: Network Sockets and Communication
• gettimeofday: Time
• getuid: Processes
• GH_ALLOW_INTS: Defining new Scheme procedures in C
• gh_append: Calling Scheme procedures from C
• gh_append2: Calling Scheme procedures from C
• gh_append3: Calling Scheme procedures from C
• gh_append4: Calling Scheme procedures from C
• gh_apply: Calling Scheme procedures from C
• gh_assoc: Calling Scheme procedures from C
• gh_assq: Calling Scheme procedures from C
• gh_assv: Calling Scheme procedures from C
• gh_bool2scm: C to Scheme
• gh_boolean_p: Type predicates
• gh_call0: Calling Scheme procedures from C
• gh_call1: Calling Scheme procedures from C
• gh_call2: Calling Scheme procedures from C
• gh_call3: Calling Scheme procedures from C
• GH_CALLER0_FROM_VAR: Creating Guile Modules
• GH_CALLER1_FROM_VAR: Creating Guile Modules
• GH_CALLER2_FROM_VAR: Creating Guile Modules
• GH_CALLER3_FROM_VAR: Creating Guile Modules
• gh_car: Calling Scheme procedures from C
• gh_catch: Calling Scheme procedures from C
• gh_cdr: Calling Scheme procedures from C
• gh_char2scm: C to Scheme
• gh_char_p: Type predicates
• gh_chars2byvect: C to Scheme
• gh_cons: Calling Scheme procedures from C
• GH_DEFER_INTS: Defining new Scheme procedures in C
• gh_define: Calling Scheme procedures from C
• GH_DEFPROC: Creating Guile Modules
• gh_display: GH Input/Output
• gh_double2scm: C to Scheme
• gh_doubles2dvect: C to Scheme
• gh_doubles2scm: C to Scheme
• gh_enter: Starting and controlling the interpreter
• gh_eq_p: Equality predicates
• gh_equal_p: Equality predicates
• gh_eqv_p: Equality predicates
• gh_eval_file: Executing Scheme code
• gh_eval_file_with_catch: Executing Scheme code
• gh_eval_file_with_standard_handler: Executing Scheme code
• gh_eval_str: Executing Scheme code
• gh_eval_str_with_catch: Executing Scheme code
• gh_eval_str_with_stack_saving_handler: Executing Scheme code
• gh_eval_str_with_standard_handler: Executing Scheme code
• gh_exact_p: Type predicates
• gh_floats2fvect: C to Scheme
• gh_get_substr: Scheme to C
• gh_inexact_p: Type predicates
• gh_int2scm: C to Scheme
• gh_int2scmb: C to Scheme
• gh_ints2scm: C to Scheme
• gh_is_eq: Calling Scheme procedures from C
• gh_is_equal: Calling Scheme procedures from C
• gh_is_eqv: Calling Scheme procedures from C
• gh_length: Calling Scheme procedures from C
• gh_list: Calling Scheme procedures from C
• gh_list_p: Type predicates
• gh_list_ref: Calling Scheme procedures from C
• gh_list_tail: Calling Scheme procedures from C
• gh_list_to_vector: Calling Scheme procedures from C
• gh_load: Executing Scheme code
• gh_long2scm: C to Scheme
• gh_longs2ivect: C to Scheme
• gh_lookup: Calling Scheme procedures from C
• gh_make_vector: Calling Scheme procedures from C
• gh_member: Calling Scheme procedures from C
• gh_memq: Calling Scheme procedures from C
• gh_memv: Calling Scheme procedures from C
• GH_MODULE_LINK_FUNC: Creating Guile Modules
• gh_module_lookup: Calling Scheme procedures from C
• GH_NEEDY_MODULE_LINK_FUNC: Creating Guile Modules
• gh_new_procedure: Defining new Scheme procedures in C
• gh_newline: GH Input/Output
• gh_not: Calling Scheme procedures from C
• gh_null_p: Equality predicates
• gh_number_p: Type predicates
• gh_obj_length: Calling Scheme procedures from C
• gh_pair_p: Type predicates
• gh_procedure_p: Type predicates
• gh_repl: Starting and controlling the interpreter
• gh_reverse: Calling Scheme procedures from C
• gh_scm2bool: Scheme to C
• gh_scm2char: Scheme to C
• gh_scm2chars: Scheme to C
• gh_scm2double: Scheme to C
• gh_scm2doubles: Scheme to C
• gh_scm2floats: Scheme to C
• gh_scm2int: Scheme to C
• gh_scm2long: Scheme to C
• gh_scm2longs: Scheme to C
• gh_scm2newstr: Scheme to C
• gh_scm2shorts: Scheme to C
• gh_scm2ulong: Scheme to C
• GH_SELECT_MODULE_VAR: Creating Guile Modules
• gh_set_car_x: Calling Scheme procedures from C
• gh_set_cdr_x: Calling Scheme procedures from C
• gh_set_substr: C to Scheme
• gh_shorts2svect: C to Scheme
• GH_STONED: Creating Guile Modules
• gh_str02scm: C to Scheme
• gh_str2scm: C to Scheme
• gh_string_equal_p: Equality predicates
• gh_string_p: Type predicates
• gh_symbol2newstr: Scheme to C
• gh_symbol2scm: C to Scheme
• gh_symbol_p: Type predicates
• gh_throw: Calling Scheme procedures from C
• gh_ulong2scm: C to Scheme
• gh_ulongs2uvect: C to Scheme
• gh_uniform_vector_length: Calling Scheme procedures from C
• gh_uniform_vector_ref: Calling Scheme procedures from C
• GH_UPSTREAM_MODULE_REF_COMMA: Creating Guile Modules
• GH_UPSTREAM_MODULE_REFS1: Creating Guile Modules
• GH_UPSTREAM_MODULE_REFS2: Creating Guile Modules
• GH_UPSTREAM_MODULE_REFS3: Creating Guile Modules
• GH_UPSTREAM_MODULE_REFS4: Creating Guile Modules
• GH_USE_MODULE: Creating Guile Modules
• gh_vector: Calling Scheme procedures from C
• gh_vector_length: Calling Scheme procedures from C
• gh_vector_p: Type predicates
• gh_vector_ref: Calling Scheme procedures from C
• gh_vector_set_x: Calling Scheme procedures from C
• gh_vector_to_list: Calling Scheme procedures from C
• gh_write: GH Input/Output
• gmtime: Time
• gnudbm-close!: database gnudbm
• gnudbm-delete!: database gnudbm
• gnudbm-exists?: database gnudbm
• gnudbm-fdesc: database gnudbm
• gnudbm-fetch: database gnudbm
• gnudbm-first-key: database gnudbm
• gnudbm-next-key: database gnudbm
• gnudbm-open: database gnudbm
• gnudbm-reorganize!: database gnudbm
• gnudbm-setopt!: database gnudbm
• gnudbm-store!: database gnudbm
• gnudbm-sync!: database gnudbm
• gnudbm-version: database gnudbm
• gnudbm?: database gnudbm
• grammar-cache: lang grammar
• grammar-item-table: lang lr0
• grammar-non-terminals: lang grammar
• grammar-nullables: lang grammar
• grammar-start-symbol: lang grammar
• grammar-terminals: lang grammar
• grammar-with-nicknames: lang lr0
• group:gid: User Information
• group:mem: User Information
• group:name: User Information
• group:passwd: User Information
• GUILE_C2X_METHOD: Autoconf Macros
• GUILE_CHECK: Autoconf Macros
• GUILE_CHECK_ICE9_OPTARGS: Autoconf Macros
• GUILE_FLAGS: Autoconf Macros
• GUILE_LIBSITE_DIR: Autoconf Macros
• GUILE_MODSUP_H: Autoconf Macros
• GUILE_MODULE_AVAILABLE: Autoconf Macros
• GUILE_MODULE_CATALOG_PREP: Autoconf Macros
• GUILE_MODULE_CHECK: Autoconf Macros
• GUILE_MODULE_EXPORTS: Autoconf Macros
• GUILE_MODULE_REQUIRED: Autoconf Macros
• GUILE_MODULE_REQUIRED_EXPORT: Autoconf Macros
• GUILE_PROGS: Autoconf Macros
• GUILE_PROVIDEDP: Autoconf Macros
• GUILE_SITE_DIR: Autoconf Macros
• GUILE_TOOLS_PROG: Autoconf Macros
• has-duplicates?: Common List Operations
• hash: Hash Table Reference
• hash-create-handle!: Hash Table Reference
• hash-fold: Hash Table Reference
• hash-for-each: Hash Table Reference
• hash-get-handle: Hash Table Reference
• hash-ref: Hash Table Reference
• hash-remove!: Hash Table Reference
• hash-set!: Hash Table Reference
• hash-table-mapping: New Hash Mappings
• hash-table?: Hash Table Reference
• hashq: Hash Table Reference
• hashq-cons: Double-Key Hash Tables
• hashq-cons-assoc: Double-Key Hash Tables
• hashq-cons-create-handle!: Double-Key Hash Tables
• hashq-cons-get-handle: Double-Key Hash Tables
• hashq-cons-hash: Double-Key Hash Tables
• hashq-cons-ref: Double-Key Hash Tables
• hashq-cons-set!: Double-Key Hash Tables
• hashq-conser: Double-Key Hash Tables
• 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
• 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-set!: Hash Table Reference
• help: Preloaded Modules for Interactive Sessions
• helper-nth: Reading Infix
• 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
• htonl: Network Sockets and Communication
• htons: Network Sockets and Communication
• HVQC-MAIN: HVQC-MAIN
• id: Miscellaneous Procs
• identity: Miscellaneous Procs
• if: if cond case
• imag-part: Complex
• in-vicinity: Miscellaneous Procs
• inet-aton: Network Address Conversion
• inet-lnaof: Network Address Conversion
• inet-makeaddr: Network Address Conversion
• inet-netof: Network Address Conversion
• inet-ntoa: Network Address Conversion
• inexact->exact: Exactness
• inexact?: Exactness
• inf-guile-null-transition: REPL Under Emacs
• infix-string->expr: Reading Infix
• input-port?: Ports
• integer->char: Characters
• integer->integer-byte-string: database binconv
• integer-byte-string->integer: database binconv
• integer-expt: Bitwise Operations
• integer-length: Bitwise Operations
• integer?: Integers
• intersection: Common List Operations
• iota: SRFI-1 Constructors
• isatty?: Terminals and Ptys
• item-set-closure: lang lr0
• item-set-reductions: lang lr0
• item-set-start-kernel: lang lr0
• item-set-successor-kernel: lang lr0
• join-thread: Low level thread primitives
• keyword->symbol: Keyword Procedures
• keyword-dash-symbol: Keyword Primitives
• keyword?: Keyword Primitives
• kill: Signals
• known-info: Known Names
• known?: Known Names
• kw-arg-ref: Keyword Procedures
• lambda: Lambda
• lambda*: lambda* Reference
• last: SRFI-1 Selectors
• last-pair: List Selection
• last-stack-frame: Debugging
• lazy-catch: Lazy Catch
• lchown: File System
• lcm: Integer Operations
• length: List Selection
• length+: SRFI-1 Length Append etc
• let: while do
• let: Local Bindings
• let*: Local Bindings
• let-keywords: let-keywords Reference
• let-keywords*: let-keywords Reference
• let-optional: let-optional Reference
• let-optional*: let-optional Reference
• let-with-configuration-getter-and-setter: Conventional Calling
• letrec: Local Bindings
• lexeme-reader: lang lex
• lexer-regexp-and-handler: lang lex
• lineio-port?: Line/Delimited
• link: File System
• list: List Constructors
• list->array: Uniform Arrays
• list->char-set: SRFI-14 Creating Character Sets
• list->char-set!: SRFI-14 Creating Character Sets
• list->stream: Streams
• list->string: String Constructors
• list->symbol: Miscellaneous Procs
• list->TAGvector: SRFI-4 - Procedures
• list->uniform-array: Uniform Arrays
• list->uniform-vector: Uniform Arrays
• list->vector: Vector Creation
• list->weak-vector: Weak vectors
• list-cdr-ref: List Selection
• list-cdr-set!: List Modification
• list-copy: List Constructors
• list-head: List Selection
• list-index: SRFI-1 Searching
• list-ref: List Selection
• list-set!: List Modification
• list-tabulate: SRFI-1 Constructors
• list-tail: List Selection
• list=: SRFI-1 Predicates
• list?: List Predicates
• listen: Network Sockets and Communication
• lls: Bindings Browsing
• load: Loading
• load-from-path: Loading
• local-definitions-in: Bindings Browsing
• local-eval: Local Evaluation
• localtime: Time
• lock-mutex: Low level thread primitives
• log: Scientific
• log10: Scientific
• logand: Bitwise Operations
• logbit?: Bitwise Operations
• logcount: Bitwise Operations
• logior: Bitwise Operations
• lognot: Bitwise Operations
• logtest: Bitwise Operations
• logxor: Bitwise Operations
• lol-for-each: LOL Iteration
• lol-map: LOL Iteration
• lr1-parse: lang lr1
• ls: Bindings Browsing
• lset-adjoin: SRFI-1 Set Operations
• 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
• lstat: File System
• macro-name: Internal Macros
• macro-transformer: Internal Macros
• macro-type: Internal Macros
• macro?: Internal Macros
• magnitude: Complex
• main_prog: Starting and controlling the interpreter
• major-version: Install Config
• make-arbiter: Arbiters
• make-array: Conventional Arrays
• make-class-object: Objects
• make-condition-variable: Low level thread primitives
• make-count-reporter: POSIX-Style Testing
• make-doubly-weak-hash-table: Weak key hashes
• make-exclusive-runq: Run Queues
• make-fair-runq: Run Queues
• make-fluid: Fluids
• make-gap-buffer: Gap Buffer
• make-gap-buffer-port: Gap Buffer
• make-gc-buffer: Double-Key Hash Tables
• make-guardian: Guardians
• make-hash-table: Hash Table Reference
• make-hook: Hook Reference
• make-keyword-from-dash-symbol: Keyword Primitives
• make-lexer: lang lex
• make-line-buffering-input-port: Line/Delimited
• make-list: List Constructors
• make-log-reporter: POSIX-Style Testing
• make-mutex: Low level thread primitives
• make-object-property: Object Properties
• make-parameter: SRFI-39
• make-parser-state: lang lr1
• make-polar: Complex
• make-procedure-with-setter: Procedures with Setters
• make-q: Queues
• make-read-tokenizer: Reading Infix
• make-record-type: Records
• make-rectangular: Complex
• make-regexp: Regexp Functions
• make-shared-array: Conventional Arrays
• make-shared-substring: Shared Substrings
• make-soft-port: Soft Ports
• make-stack: Debugging
• make-stream: Streams
• make-string: String Constructors
• make-struct: Structure Basics
• make-struct-layout: Structure Layout
• make-subclass-object: Objects
• make-subordinate-runq-to: Run Queues
• make-TAGvector: SRFI-4 - Procedures
• make-thread: Higher level thread procedures
• make-undefined-variable: Variables
• make-uniform-array: Uniform Arrays
• make-variable: Variables
• make-vector: Vector Creation
• make-void-runq: Run Queues
• make-vtable-vtable: Vtables
• make-weak-key-hash-table: Weak key hashes
• make-weak-value-hash-table: Weak key hashes
• make-weak-vector: Weak vectors
• map: SRFI-1 Fold and Map
• map: List Mapping
• map!: SRFI-1 Fold and Map
• map-in-order: List Mapping
• mapping-create-handle!: New Hash Mappings
• mapping-get-handle: New Hash Mappings
• mapping-ref: New Hash Mappings
• mapping-remove!: New Hash Mappings
• mapping-set!: New Hash Mappings
• mask-signals: Asyncs
• 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
• member: SRFI-1 Searching
• member: List Searching
• member-if: Common List Operations
• memoized-environment: Debugging
• memoized?: Debugging
• memq: List Searching
• memv: List Searching
• merge: Sorting
• merge!: Sorting
• min: Arithmetic
• minor-version: Install Config
• mkdir: File System
• mknod: File System
• mkstemp: database tmpfile
• mktime: Time
• module-catalog-manager: Module Monkey
• module-commentary: Documentation
• modulo: Integer Operations
• monitor: Higher level thread procedures
• move->fdes: Ports and File Descriptors
• negative?: Comparison
• netent:addrtype: Network Databases
• netent:aliases: Network Databases
• netent:name: Network Databases
• netent:net: Network Databases
• newline: Writing
• nftw: Filesystem Tree Walk
• nftw-callback: Filesystem Tree Walk
• nice: Processes
• nick: lang debug-common
• nick!: lang debug-common
• nil-car: Emacs Lisp Support
• nil-cdr: Emacs Lisp Support
• nil-cons: Emacs Lisp Support
• nil-eq: Emacs Lisp Support
• ninth: SRFI-1 Selectors
• noop: Asyncs
• not: Booleans
• not-pair?: SRFI-1 Predicates
• notany: Common List Operations
• notevery: Common List Operations
• ntohl: Network Sockets and Communication
• ntohs: Network Sockets and Communication
• null: Emacs Lisp Support
• null-list?: SRFI-1 Predicates
• null?: List Predicates
• number->string: Conversion
• number?: Numerical Tower
• obarray-gensym: Miscellaneous Procs
• obarray-symbol-append: Miscellaneous Procs
• object->string: General Conversion
• object-documentation: Documentation
• object-properties: Object Properties
• object-property: Object Properties
• odd?: Integer Operations
• open: Ports and File Descriptors
• open-binary-input-file: SRFI-56 Port extensions
• open-binary-output-file: SRFI-56 Port extensions
• open-fdes: Ports and File Descriptors
• open-file: File Ports
• open-input-file: File Ports
• open-input-pipe: Pipes
• open-input-string: String Ports
• open-output-file: File Ports
• open-output-pipe: Pipes
• open-output-string: String Ports
• open-pipe: Pipes
• opendir: File System
• operator?: Objects
• option-ref: option-ref Reference
• or: and or
• or-map: List Mapping
• or?: Common List Operations
• output-port?: Ports
• 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
• parameterize: SRFI-39
• parse-path: Install Config
• parser-action: lang lr1
• parser-context-car: lang lr1
• parser-context-cdr: lang lr1
• parser-context-cdr-ref: lang lr1
• parser-context-cons: lang lr1
• parser-start-state: lang lr1
• parser-state-item-set: lang lr1
• parser-value-car: lang lr1
• parser-value-cdr: lang lr1
• parser-value-cdr-ref: lang lr1
• parser-value-cons: lang lr1
• partition: SRFI-1 Filtering and Partitioning
• partition!: SRFI-1 Filtering and Partitioning
• pass-if: POSIX-Style Testing
• pass-if-exception: POSIX-Style Testing
• 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-byte: SRFI-56 I/O extensions
• peek-char: Reading
• perfect-funcq: Memoization
• pick: Common List Operations
• pick-mappings: Common List Operations
• pipe: Ports and File Descriptors
• popen: Pipes
• port->fdes: Ports and File Descriptors
• port->stream: Streams
• port-closed?: Closing
• port-column: Reading
• port-filename: File Ports
• port-line: Reading
• port-mode: Ports and File Descriptors
• port-mode: File Ports
• port-revealed: Ports and File Descriptors
• port-with-print-state: Writing
• port?: Ports
• positive?: Comparison
• pp-grammar: lang debug-common
• pp-lexer-spec: lang debug-common
• pretty-print: Pretty Printing
• primitive-exit: Processes
• primitive-fork: Processes
• primitive-load: Loading
• primitive-load-path: Loading
• primitive-move->fdes: Ports and File Descriptors
• print-counts: POSIX-Style Testing
• print-disable: General option interface
• print-enable: General option interface
• print-options: General option interface
• print-options-interface: General option interface
• print-options-interface: Writing
• print-set!: General option interface
• procedure: Procedures with Setters
• procedure->macro: Internal Macros
• procedure->memoizing-macro: Internal Macros
• procedure->syntax: Internal Macros
• procedure-documentation: Procedure Properties
• procedure-environment: Procedure Properties
• 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
• production-body: lang grammar
• production-expansion: lang grammar
• production-symbol: lang grammar
• program-arguments: Runtime Environment
• program-arguments: The Top of a Script File
• promise?: Delayed Evaluation
• proper-list?: SRFI-1 Predicates
• protoent:aliases: Network Databases
• protoent:name: Network Databases
• protoent:proto: Network Databases
• provide: Feature Manipulation
• provided?: Feature Manipulation
• pure-funcq: Memoization
• 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
• quit: Dynamic Roots
• quotient: Integer Operations
• raise: Signals
• random: Random
• random:exp: Random
• random:hollow-sphere!: Random
• random:normal: Random
• random:normal-vector!: Random
• random:solid-sphere!: Random
• random:uniform: Random
• rational?: Reals and Rationals
• read: Scheme Read
• read-ber-integer: SRFI-56 Bignum encodings
• read-binary-sint: SRFI-56 General reading
• read-binary-sint16: SRFI-56 Predefined read sizes
• read-binary-sint32: SRFI-56 Predefined read sizes
• read-binary-sint64: SRFI-56 Predefined read sizes
• read-binary-sint8: SRFI-56 Predefined read sizes
• read-binary-uint: SRFI-56 General reading
• read-binary-uint16: SRFI-56 Predefined read sizes
• read-binary-uint32: SRFI-56 Predefined read sizes
• read-binary-uint64: SRFI-56 Predefined read sizes
• read-binary-uint8: SRFI-56 Predefined read sizes
• read-byte: SRFI-56 I/O extensions
• read-char: Reading
• read-delimited: Line/Delimited
• read-delimited!: Line/Delimited
• read-disable: General option interface
• read-disable: Scheme Read
• read-enable: General option interface
• read-enable: Scheme Read
• read-hash-extend: Reader Extensions
• read-ieee-float32: SRFI-56 IEEE floating-point encodings
• read-ieee-float64: SRFI-56 IEEE floating-point encodings
• read-infix-expr: Reading Infix
• read-line: Line/Delimited
• read-line!: Line/Delimited
• read-network-sint16: SRFI-56 Predefined network encodings
• read-network-sint32: SRFI-56 Predefined network encodings
• read-network-sint64: SRFI-56 Predefined network encodings
• read-network-uint16: SRFI-56 Predefined network encodings
• read-network-uint32: SRFI-56 Predefined network encodings
• read-network-uint64: SRFI-56 Predefined network encodings
• read-options: General option interface
• read-options-interface: General option interface
• read-options-interface: Scheme Read
• read-set!: General option interface
• read-set!: Scheme Read
• read-string: Line/Delimited
• read-string!/partial: Block Reading and Writing
• read-string!/partial/never-fewer: Block Reading and Writing
• readdir: File System
• readlink: File System
• real->floating-point-byte-string: database binconv
• real-part: Complex
• real?: Reals and Rationals
• receive: Multiple Values
• record-accessor: Records
• record-constructor: Records
• record-modifier: Records
• record-predicate: Records
• record-type-descriptor: Records
• record-type-fields: Records
• record-type-name: Records
• record?: Records
• recursive-local-define: Bindings Browsing
• recv!: Network Sockets and Communication
• recvfrom!: Network Sockets and Communication
• redirect-port: Ports and File Descriptors
• reduce: Common List Operations
• reduce: SRFI-1 Fold and Map
• reduce-init: Common List Operations
• reduce-right: SRFI-1 Fold and Map
• regcomp: Rgx Regexps
• regexec: Rgx Regexps
• regexp->dfa: Rgx Regexps
• regexp-exec: Regexp Functions
• regexp-match?: Match Structures
• regexp-quote: Backslash Escapes
• regexp-substitute: Regexp Functions
• regexp-substitute/global: Regexp Functions
• regexp?: Regexp Functions
• register-reporter: POSIX-Style Testing
• release-arbiter: Arbiters
• release-port-handle: Ports and File Descriptors
• remainder: Integer Operations
• remove: SRFI-1 Filtering and Partitioning
• remove!: SRFI-1 Filtering and Partitioning
• remove-hook!: Hook Reference
• remove-if: Common List Operations
• remove-if-not: Common List Operations
• remove-keys: lambda* Reference
• rename: File System
• rename-file: File System
• reporter-registered?: POSIX-Style Testing
• reset-dfa!: Rgx Regexps
• reset-hook!: Hook Reference
• restore-signals: Signals
• restricted-vector-sort!: Sorting
• return-it: Miscellaneous Procs
• reverse: Append/Reverse
• reverse!: Append/Reverse
• reverse-list->string: SRFI-13 List/String Conversion
• rewinddir: File System
• rmdir: File System
• round: Arithmetic
• run-asyncs: Asyncs
• run-hook: Hook Reference
• run-test: POSIX-Style Testing
• runq-control: Run Queues
• save-bindings-excursion: Conventional Calling
• scm-error: Handling Errors
• scm-error: Error Reporting
• scm_abs: Arithmetic
• scm_accept: Network Sockets and Communication
• scm_access: File System
• scm_acons: Adding or Setting Alist Entries
• scm_acosh: Primitive Numerics
• scm_add_feature: Feature Manipulation
• scm_add_hook_x: Hook Reference
• scm_alarm: Signals
• scm_append: Append/Reverse
• scm_append_x: Append/Reverse
• SCM_ARG1: Signalling Type Errors
• SCM_ARG2: Signalling Type Errors
• SCM_ARG3: Signalling Type Errors
• SCM_ARG4: Signalling Type Errors
• SCM_ARG5: Signalling Type Errors
• SCM_ARG6: Signalling Type Errors
• SCM_ARG7: Signalling Type Errors
• SCM_ARGn: Signalling Type Errors
• scm_array_contents: Conventional Arrays
• scm_array_copy_x: Conventional Arrays
• scm_array_dimensions: Conventional Arrays
• scm_array_fill_x: Conventional Arrays
• scm_array_for_each: Array Mapping
• scm_array_in_bounds_p: Conventional Arrays
• scm_array_index_map_x: Array Mapping
• scm_array_map: Array Mapping
• scm_array_p: Conventional Arrays
• scm_array_prototype: Uniform Arrays
• scm_array_rank: Conventional Arrays
• scm_array_set_x: Conventional Arrays
• scm_array_to_list: Conventional Arrays
• scm_ash: Bitwise Operations
• scm_asinh: Primitive Numerics
• SCM_ASSERT: Signalling Type 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_async: Asyncs
• scm_async_mark: Asyncs
• scm_atanh: Primitive Numerics
• scm_backtrace: Backtrace
• scm_basename: File System
• scm_bind: Network Sockets and Communication
• scm_bit_count: Bit Vectors
• scm_bit_count_star: Bit Vectors
• scm_bit_extract: Bitwise Operations
• scm_bit_invert_x: Bit Vectors
• scm_bit_position: Bit Vectors
• scm_bit_set_star_x: Bit Vectors
• SCM_BOOL_F: Boolean Data
• SCM_BOOL_NOT: Boolean Data
• SCM_BOOL_T: Boolean Data
• scm_boolean_p: Booleans
• scm_boot_guile: Guile Initialization Functions
• 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_run_hook: Hook Reference
• SCM_CAAR: Pair Data
• SCM_CADR: Pair Data
• scm_call_with_dynamic_root: Dynamic Roots
• scm_call_with_input_string: String Ports
• scm_call_with_output_string: String Ports
• SCM_CAR: Pair Data
• scm_catch: Catch
• SCM_CDAR: Pair Data
• SCM_CDDDDR: Pair Data
• SCM_CDR: Pair Data
• SCM_CELL_OBJECT: Accessing Cell Entries
• SCM_CELL_TYPE: Heap Cell Type Information
• SCM_CELL_WORD: Accessing Cell Entries
• SCM_CHAR: Character Data
• scm_char_alphabetic_p: Characters
• scm_char_ci_eq_p: Characters
• scm_char_ci_geq_p: Characters
• scm_char_ci_gr_p: Characters
• scm_char_ci_leq_p: Characters
• scm_char_ci_less_p: Characters
• scm_char_downcase: Characters
• scm_char_eq_p: Characters
• scm_char_geq_p: Characters
• scm_char_gr_p: Characters
• scm_char_is_both_p: Characters
• scm_char_leq_p: Characters
• scm_char_less_p: Characters
• scm_char_lower_case_p: Characters
• scm_char_numeric_p: Characters
• scm_char_p: Characters
• scm_char_ready_p: Reading
• scm_char_to_integer: Characters
• scm_char_upcase: Characters
• scm_char_upper_case_p: Characters
• scm_char_whitespace_p: Characters
• SCM_CHARP: Character Data
• scm_chdir: Processes
• scm_chmod: File System
• scm_chown: File System
• scm_close: Ports and File Descriptors
• scm_close_fdes: Ports and File Descriptors
• scm_close_input_port: Closing
• scm_close_output_port: Closing
• scm_close_port: Closing
• scm_closedir: File System
• scm_closure_p: Procedure Properties
• SCM_CLOSUREP: Closures
• SCM_CODE: Closures
• scm_connect: Network Sockets and Communication
• scm_cons: Pairs
• scm_cons: Pair Data
• scm_cons_source: Internal Macros
• scm_cons_star: List Constructors
• SCM_CONSP: Basic Rules for Accessing Cell Entries
• SCM_CONSP: Pair Data
• scm_continuation_p: Continuations
• scm_copy_file: File System
• scm_copy_random_state: Random
• scm_copy_tree: Copying
• scm_ctermid: Terminals and Ptys
• scm_current_error_port: Default Ports
• scm_current_input_port: Default Ports
• scm_current_load_port: Loading
• scm_current_output_port: Default Ports
• scm_current_time: Time
• scm_debug_object_p: Debugging
• scm_debug_options: Debugging
• scm_definedp: Binding Reflection
• scm_delete: List Modification
• scm_delete1_x: List Modification
• scm_delete_file: 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_dimensions_to_uniform_array: Uniform Arrays
• scm_directory_stream_p: File System
• scm_dirname: File System
• scm_display_application: Debugging
• scm_display_backtrace: Debugging
• scm_display_error: Handling Errors
• scm_doubly_weak_hash_table_p: Weak key hashes
• scm_drain_input: Reading
• scm_dup2: Ports and File Descriptors
• scm_dup_to_fdes: Ports and File Descriptors
• scm_dynamic_args_call: Low level dynamic linking
• scm_dynamic_call: Low level dynamic linking
• scm_dynamic_func: Low level dynamic linking
• scm_dynamic_link: Low level dynamic linking
• scm_dynamic_object_p: Low level dynamic linking
• scm_dynamic_root: Dynamic Roots
• scm_dynamic_unlink: Low level dynamic linking
• scm_dynamic_wind: Dynamic Wind
• scm_enclose_array: Conventional Arrays
• scm_entity_p: Objects
• SCM_ENV: Closures
• scm_environ: Runtime Environment
• scm_eof_object_p: Reading
• SCM_EOF_VAL: Unique Values
• SCM_EOL: Unique Values
• scm_error_scm: Error Reporting
• scm_eval: Fly Evaluation
• scm_eval_options_interface: Evaluator Behaviour
• scm_eval_string: Fly Evaluation
• scm_evaluator_traps: Evaluator Behaviour
• scm_even_p: Integer Operations
• scm_exact_p: Exactness
• scm_execl: Processes
• scm_execle: Processes
• scm_execlp: Processes
• 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_fluid_p: Fluids
• scm_fluid_ref: Fluids
• scm_fluid_set_x: Fluids
• scm_flush_all_ports: Writing
• scm_force: Delayed Evaluation
• scm_force_output: Writing
• scm_fork: Processes
• scm_frame_arguments: Debugging
• scm_frame_evaluating_args_p: Debugging
• scm_frame_next: Debugging
• scm_frame_number: Debugging
• scm_frame_overflow_p: Debugging
• scm_frame_p: Debugging
• scm_frame_previous: Debugging
• scm_frame_procedure: Debugging
• scm_frame_procedure_p: Debugging
• scm_frame_real_p: Debugging
• scm_frame_source: Debugging
• scm_free0: Garbage Collecting Simple Smobs
• scm_fsync: Ports and File Descriptors
• scm_ftell: Random Access
• scm_gc: Garbage Collection
• scm_gc_mark: Garbage Collecting Smobs
• scm_gc_stats: Garbage Collection
• scm_gensym: Symbol Primitives
• scm_get_internal_real_time: Time
• scm_get_internal_run_time: Time
• scm_get_output_string: String Ports
• scm_get_print_state: Writing
• 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_getnet: Network Databases
• scm_getpeername: Network Sockets and Communication
• scm_getpgrp: Processes
• scm_getpid: Processes
• scm_getppid: Processes
• scm_getproto: Network Databases
• scm_getpwuid: User Information
• scm_getserv: Network Databases
• scm_getsockname: Network Sockets and Communication
• scm_getsockopt: Network Sockets and Communication
• scm_gettimeofday: Time
• scm_getuid: Processes
• scm_gmtime: Time
• scm_hash: Hash Table Reference
• scm_hash_create_handle_x: Hash Table Reference
• scm_hash_fold: Hash Table Reference
• scm_hash_ref: Hash Table Reference
• scm_hash_remove_x: Hash Table Reference
• scm_hash_set_x: 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_remove_x: Hash Table Reference
• scm_hashv_rev: 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_set_x: Hash Table Reference
• scm_hook_empty_p: Hook Reference
• scm_hook_p: Hook Reference
• scm_hook_to_list: Hook Reference
• SCM_HOOKP: C Hooks
• scm_htonl: Network Sockets and Communication
• scm_htons: Network Sockets and Communication
• SCM_IMP: Immediate objects
• SCM_IMP: Immediates vs Non-immediates
• scm_inet_aton: Network Address Conversion
• scm_inet_makeaddr: Network Address Conversion
• scm_inet_netof: Network Address Conversion
• scm_inet_ntoa: Network Address Conversion
• scm_inexact_p: Exactness
• scm_inexact_to_exact: Exactness
• scm_init_guile: Guile Initialization Functions
• 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_INUM: Integer Data
• SCM_INUMP: Integer Data
• scm_isatty_p: Terminals and Ptys
• scm_keyword_dash_symbol: Keyword Primitives
• scm_keyword_p: Keyword Primitives
• scm_kill: Signals
• scm_last_pair: List Selection
• scm_last_stack_frame: Debugging
• scm_lazy_catch: Lazy Catch
• scm_length: List Selection
• SCM_LENGTH: Vector Data
• scm_link: File System
• scm_list: List Constructors
• scm_list_cdr_set_x: List Modification
• scm_list_copy: List Constructors
• scm_list_head: List Selection
• scm_list_p: List Predicates
• scm_list_ref: List Selection
• scm_list_set_x: List Modification
• scm_list_tail: List Selection
• scm_list_to_uniform_array: Uniform Arrays
• scm_listen: Network Sockets and Communication
• scm_lnaof: Network Address Conversion
• scm_local_eval: Local Evaluation
• scm_localtime: Time
• 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_logxor: Bitwise Operations
• scm_lstat: File System
• scm_macro_name: Internal Macros
• scm_macro_p: Internal Macros
• scm_macro_transformer: Internal Macros
• scm_macro_type: Internal Macros
• scm_major_version: Install Config
• scm_makacro: Internal Macros
• scm_make_arbiter: Arbiters
• SCM_MAKE_CHAR: Character Data
• scm_make_class_object: Objects
• scm_make_doubly_weak_hash_table: Weak key hashes
• scm_make_fluid: Fluids
• scm_make_gsubr: Subrs
• scm_make_guardian: Guardians
• scm_make_hook: Hook Reference
• scm_make_keyword_from_dash_symbol: Keyword Primitives
• scm_make_polar: Complex
• scm_make_procedure_with_setter: Procedures with Setters
• scm_make_rectangular: Complex
• scm_make_regexp: Regexp Functions
• scm_make_shared_array: Conventional Arrays
• scm_make_shared_substring: Shared Substrings
• scm_make_smob_type: Describing a New Type
• scm_make_smob_type_mfpe: Describing a New Type
• scm_make_soft_port: Soft Ports
• scm_make_stack: Debugging
• scm_make_string: String Constructors
• scm_make_struct: Structure Basics
• scm_make_struct_layout: Structure Layout
• scm_make_subclass_object: Objects
• scm_make_undefined_variable: Variables
• scm_make_variable: Variables
• scm_make_vector: Vector Creation
• scm_make_vtable_vtable: Vtables
• scm_make_weak_key_hash_table: Weak key hashes
• scm_make_weak_value_hash_table: Weak key hashes
• scm_make_weak_vector: Weak vectors
• SCM_MAKINUM: Integer Data
• scm_makmacro: Internal Macros
• scm_makmmacro: Internal Macros
• scm_map: List Mapping
• scm_markcdr: Garbage Collecting Simple Smobs
• scm_mask_signals: Asyncs
• scm_member: List Searching
• scm_memoized_environment: Debugging
• scm_memoized_p: Debugging
• scm_memq: List Searching
• scm_memv: List Searching
• scm_merge: Sorting
• scm_merge_x: Sorting
• scm_minor_version: Install Config
• scm_mkdir: File System
• scm_mknod: File System
• scm_mktime: Time
• scm_must_free: Creating Instances
• scm_must_malloc: Creating Instances
• scm_must_realloc: Creating Instances
• scm_nconc2last: Fly Evaluation
• SCM_NCONSP: Pair Data
• SCM_NEWCELL: Pair Data
• scm_newline: Writing
• SCM_NEWSMOB: Creating Instances
• SCM_NEWSMOB2: Creating Instances
• SCM_NEWSMOB3: Creating Instances
• SCM_NFALSEP: Boolean Data
• scm_nice: Processes
• scm_nil_car: Emacs Lisp Support
• scm_nil_cdr: Emacs Lisp Support
• scm_nil_cons: Emacs Lisp Support
• scm_nil_eq: Emacs Lisp Support
• SCM_NIMP: Immediates vs Non-immediates
• SCM_NINUMP: Integer Data
• scm_noop: Asyncs
• scm_not: Booleans
• scm_ntohl: Network Sockets and Communication
• scm_ntohs: Network Sockets and Communication
• scm_null: Emacs Lisp Support
• scm_null_p: List Predicates
• scm_number_p: Complex Numbers
• scm_number_p: Numerical Tower
• scm_number_to_string: Conversion
• scm_object_properties: Object Properties
• scm_object_property: Object Properties
• scm_odd_p: Integer Operations
• scm_open: Ports and File Descriptors
• scm_open_fdes: Ports and File Descriptors
• scm_open_file: File Ports
• scm_open_input_string: String Ports
• scm_open_output_string: String Ports
• scm_opendir: File System
• scm_operator_p: Objects
• scm_output_port_p: Ports
• SCM_PACK: Relationship between SCM and scm_bits_t
• scm_pair_p: Pairs
• scm_parse_path: Install Config
• scm_pause: Signals
• scm_peek_char: Reading
• scm_permanent_object: Garbage Collection
• scm_pipe: Ports and File Descriptors
• scm_port_closed_p: Closing
• scm_port_column: Reading
• scm_port_filename: File Ports
• scm_port_line: Reading
• scm_port_mode: Ports and File Descriptors
• scm_port_mode: File Ports
• scm_port_revealed: Ports and File Descriptors
• scm_port_with_print_state: Writing
• scm_primitive_exit: Processes
• scm_primitive_load: Loading
• scm_primitive_load_path: Loading
• scm_primitive_move_to_fdes: Ports and File Descriptors
• scm_print_options: Writing
• scm_procedure: Procedures with Setters
• scm_procedure_documentation: Procedure Properties
• scm_procedure_environment: Procedure Properties
• scm_procedure_name: Procedure Properties
• scm_procedure_p: Procedure Properties
• scm_procedure_p: Procedures
• scm_procedure_properties: Procedure Properties
• scm_procedure_property: Procedure Properties
• scm_procedure_source: Procedure Properties
• scm_procedure_with_setter_p: Procedures with Setters
• SCM_PROCPROPS: Closures
• scm_program_arguments: Runtime Environment
• scm_promise_p: Delayed Evaluation
• scm_protect_object: Garbage Collection
• SCM_PTR2SCM: Non-immediate objects
• scm_putenv: Runtime Environment
• 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_uniform: Random
• scm_read: Scheme Read
• scm_read_char: Reading
• scm_read_delimited_x: Line/Delimited
• scm_read_line: Line/Delimited
• scm_read_options: Scheme Read
• scm_read_string_x_partial: Block Reading and Writing
• scm_readdir: File System
• scm_readlink: File System
• scm_real_p: Reals and Rationals
• 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_register_module_xxx: Compiled Code Modules
• scm_release_arbiter: Arbiters
• scm_remove_hook_x: Hook Reference
• scm_rename: File System
• scm_reset_hook_x: Hook Reference
• scm_restore_signals: Signals
• scm_restricted_vector_sort_x: Sorting
• SCM_RETURN_NEWSMOB: Creating Instances
• SCM_RETURN_NEWSMOB2: Creating Instances
• SCM_RETURN_NEWSMOB3: Creating Instances
• scm_reverse: Append/Reverse
• scm_reverse_x: Append/Reverse
• scm_rewinddir: File System
• scm_rmdir: File System
• SCM_ROLENGTH: Vector Data
• scm_round: Arithmetic
• scm_run_asyncs: Asyncs
• scm_run_hook: Hook Reference
• SCM_SCM2PTR: Non-immediate objects
• scm_search_path: Install Config
• scm_seed_to_random_state: Random
• scm_seek: Random Access
• scm_select: Ports and File Descriptors
• scm_send: Network Sockets and Communication
• scm_sendto: Network Sockets and Communication
• scm_set_car_x: Pairs
• scm_set_cdr_x: Pairs
• SCM_SET_CELL_OBJECT: Accessing Cell Entries
• SCM_SET_CELL_TYPE: Heap Cell Type Information
• SCM_SET_CELL_WORD: Accessing Cell Entries
• scm_set_current_error_port: Default Ports
• scm_set_current_input_port: Default Ports
• scm_set_current_output_port: Default Ports
• scm_set_object_procedure_x: Objects
• scm_set_object_properties_x: Object Properties
• scm_set_object_property_x: Object Properties
• scm_set_port_column_x: Reading
• scm_set_port_filename_x: File Ports
• scm_set_port_line_x: Reading
• scm_set_port_revealed_x: Ports and File Descriptors
• scm_set_procedure_properties_x: Procedure Properties
• scm_set_procedure_property_x: Procedure Properties
• scm_set_smob_equalp: Describing a New Type
• scm_set_smob_free: Describing a New Type
• scm_set_smob_mark: Describing a New Type
• scm_set_smob_print: Describing a New Type
• scm_set_source_properties_x: Procedure Properties
• scm_set_source_property_x: Procedure Properties
• scm_set_struct_vtable_name_x: Vtables
• SCM_SETCAR: Pair Data
• SCM_SETCDR: Pair Data
• scm_setegid: Processes
• scm_seteuid: Processes
• scm_setgid: Processes
• scm_setgrent: User Information
• scm_sethost: Network Databases
• scm_setlocale: Locales
• scm_setnet: Network Databases
• scm_setpgid: Processes
• SCM_SETPROCPROPS: Closures
• 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: Ports and File Descriptors
• scm_shared_array_increments: Conventional Arrays
• scm_shared_array_offset: Conventional Arrays
• scm_shared_array_root: Conventional Arrays
• scm_shell: Guile Initialization Functions
• scm_shutdown: Network Sockets and Communication
• scm_sigaction: Signals
• scm_simple_format: Writing
• scm_sleep: Signals
• scm_sloppy_assoc: Sloppy Alist Functions
• scm_sloppy_assq: Sloppy Alist Functions
• scm_sloppy_assv: Sloppy Alist Functions
• SCM_SNAME: Subrs
• SCM_SNARF_DOCS: Customizing init snarfing
• SCM_SNARF_HERE: Customizing init snarfing
• SCM_SNARF_INIT: Customizing init snarfing
• scm_socket: Network Sockets and Communication
• scm_socketpair: Network Sockets and Communication
• scm_sort: Sorting
• scm_sort_list: Sorting
• scm_sort_list_x: Sorting
• scm_sort_x: Sorting
• scm_sorted_p: Sorting
• scm_source_properties: Procedure Properties
• scm_source_property: Procedure Properties
• scm_stable_sort: Sorting
• scm_stable_sort_x: Sorting
• scm_stack_id: Debugging
• scm_stack_length: Debugging
• scm_stack_p: Debugging
• scm_stack_ref: Debugging
• scm_standard_eval_closure: More Module Procedures
• scm_stat: File System
• scm_status_exit_val: Processes
• scm_status_stop_sig: Processes
• scm_status_term_sig: Processes
• scm_strerror: Error Reporting
• scm_strftime: Time
• scm_string: String Constructors
• scm_string_append: Appending Strings
• scm_string_capitalize: Alphabetic Case Mapping
• scm_string_capitalize_x: Alphabetic Case Mapping
• scm_string_ci_equal_p: String Comparison
• scm_string_ci_geq_p: String Comparison
• scm_string_ci_gr_p: String Comparison
• scm_string_ci_leq_p: String Comparison
• scm_string_ci_less_p: String Comparison
• scm_string_ci_to_symbol: Symbol Primitives
• scm_string_copy: String Selection
• scm_string_downcase: Alphabetic Case Mapping
• scm_string_downcase_x: Alphabetic Case Mapping
• scm_string_equal_p: String Comparison
• scm_string_fill_x: String Modification
• scm_string_geq_p: String Comparison
• scm_string_gr_p: String Comparison
• scm_string_index: String Searching
• scm_string_length: String Selection
• scm_string_leq_p: String Comparison
• scm_string_less_p: String Comparison
• scm_string_null_p: String Predicates
• scm_string_p: String Predicates
• scm_string_ref: String Selection
• scm_string_rindex: String Searching
• scm_string_set_x: String Modification
• scm_string_to_list: List/String Conversion
• scm_string_to_number: Conversion
• scm_string_to_symbol: Symbol Primitives
• scm_string_upcase: Alphabetic Case Mapping
• scm_string_upcase_x: Alphabetic Case Mapping
• SCM_STRINGP: Vector Data
• scm_strptime: Time
• scm_struct_p: Structure Basics
• scm_struct_ref: Structure Basics
• scm_struct_set_x: Structure Basics
• scm_struct_vtable: Vtables
• scm_struct_vtable_name: Vtables
• scm_struct_vtable_p: Vtables
• scm_struct_vtable_tag: Vtables
• scm_substring: String Selection
• scm_substring_fill_x: String Modification
• scm_substring_move_x: String Modification
• scm_symbol_fref: Symbol Props
• scm_symbol_fset_x: Symbol Props
• scm_symbol_hash: Symbol Keys
• scm_symbol_interned_p: Symbol Uninterned
• scm_symbol_p: Symbol Primitives
• scm_symbol_pref: Symbol Props
• scm_symbol_pset_x: Symbol Props
• scm_symbol_to_string: Symbol Primitives
• SCM_SYMBOLP: Vector Data
• scm_symlink: File System
• scm_sync: File System
• scm_sys_atan2: Primitive Numerics
• scm_sys_expt: Primitive Numerics
• scm_sys_library_dir: Install Config
• scm_sys_make_void_port: Void Ports
• scm_sys_package_data_dir: Install Config
• scm_sys_search_load_path: Loading
• scm_sys_site_dir: Install Config
• scm_system: Processes
• scm_system_async: Asyncs
• scm_system_async_mark: Asyncs
• scm_tcgetpgrp: Terminals and Ptys
• scm_tcsetpgrp: Terminals and Ptys
• scm_throw: Throw
• scm_thunk_p: Procedure Properties
• scm_times: Time
• scm_tmpnam: File System
• scm_transpose_array: Conventional Arrays
• scm_truncate: Arithmetic
• scm_truncate_file: Random Access
• scm_try_arbiter: Arbiters
• scm_ttyname: Terminals and Ptys
• scm_tzset: Time
• scm_umask: Processes
• scm_uname: System Identification
• SCM_UNBNDP: Unique Values
• SCM_UNDEFINED: Unique Values
• scm_uniform_array_read_x: Uniform Arrays
• scm_uniform_array_write: Uniform Arrays
• scm_uniform_vector_length: Uniform Arrays
• scm_uniform_vector_ref: Conventional Arrays
• scm_unmask_signals: Asyncs
• scm_unmemoize: Debugging
• SCM_UNPACK: Relationship between SCM and scm_bits_t
• scm_unprotect_object: Garbage Collection
• scm_unread_char: Ports and File Descriptors
• scm_unread_char: Reading
• scm_unread_string: Ports and File Descriptors
• scm_unread_string: Reading
• SCM_UNSPECIFIED: Unique Values
• scm_usleep: Signals
• scm_utime: File System
• scm_values: Multiple Values
• scm_variable_bound_p: Variables
• scm_variable_p: Variables
• scm_variable_ref: Variables
• scm_variable_set_x: Variables
• scm_vector: Vector Creation
• scm_vector_fill_x: Vector Accessors
• scm_vector_length: Vector Accessors
• scm_vector_move_left_x: Vector Accessors
• scm_vector_move_right_x: Vector Accessors
• scm_vector_p: Vector Creation
• scm_vector_ref: Vector Accessors
• scm_vector_set_x: Vector Accessors
• scm_vector_to_list: Vector Creation
• SCM_VECTORP: Vector Data
• scm_waitpid: Processes
• scm_weak_key_hash_table_p: Weak key hashes
• scm_weak_value_hash_table_p: Weak key hashes
• scm_weak_vector: Weak vectors
• scm_weak_vector_p: Weak vectors
• scm_with_fluids: Fluids
• scm_with_traps: Debugging
• scm_write_char: Writing
• scm_write_line: Line/Delimited
• scm_write_string_partial: Block Reading and Writing
• search-documentation-files: Documentation
• search-path: Install Config
• second: SRFI-1 Selectors
• seed->random-state: Random
• seek: Random Access
• select: Ports and File Descriptors
• send: Network Sockets and Communication
• sendto: Network Sockets and Communication
• servent:aliases: Network Databases
• servent:name: Network Databases
• servent:port: Network Databases
• servent:proto: Network Databases
• set-batch-mode?!: Dynamic Roots
• set-car!: Pairs
• set-cdr!: Pairs
• set-current-error-port: Default Ports
• set-current-input-port: Default Ports
• set-current-output-port: Default Ports
• set-difference: Common List Operations
• set-fancy-repl-prompt!: Preloaded Modules for Interactive Sessions
• set-object-procedure!: Objects
• set-object-properties!: Object Properties
• set-object-property!: Object Properties
• set-port-column!: Reading
• set-port-filename!: File Ports
• set-port-line!: Reading
• set-port-revealed!: Ports and File Descriptors
• set-procedure-properties!: Procedure Properties
• set-procedure-property!: Procedure Properties
• set-source-properties!: Procedure Properties
• set-source-property!: Procedure Properties
• set-struct-vtable-name!: Vtables
• set-symbol-property!: Symbol Props
• set-tm:gmtoff: Time
• set-tm:hour: Time
• set-tm:isdst: Time
• set-tm:mday: Time
• set-tm:min: Time
• set-tm:mon: Time
• set-tm:sec: Time
• set-tm:wday: Time
• set-tm:yday: Time
• set-tm:year: Time
• set-tm:zone: Time
• setegid: Processes
• setenv: Runtime Environment
• seteuid: Processes
• setgid: Processes
• setgr: User Information
• setgrent: User Information
• sethost: Network Databases
• sethostent: Network Databases
• setlocale: Locales
• setnet: Network Databases
• setnetent: Network Databases
• setpgid: Processes
• setproto: Network Databases
• setprotoent: Network Databases
• setpw: User Information
• setpwent: User Information
• setserv: Network Databases
• setservent: Network Databases
• setsid: Processes
• setsockopt: Network Sockets and Communication
• setter: Procedures with Setters
• setuid: Processes
• setvbuf: Ports and File Descriptors
• seventh: SRFI-1 Selectors
• shared-array-increments: Conventional Arrays
• shared-array-offset: Conventional Arrays
• shared-array-root: Conventional Arrays
• shutdown: Network Sockets and Communication
• sigaction: Signals
• signal-condition-variable: Low level thread primitives
• simple-format: Writing
• sin: Scientific
• single-active-thread?: Low level thread primitives
• sinh: Scientific
• sixth: SRFI-1 Selectors
• skip-file!: POSIX-Style Testing
• sleep: Signals
• sloppy-assoc: Sloppy Alist Functions
• sloppy-assq: Sloppy Alist Functions
• sloppy-assv: Sloppy Alist Functions
• sockaddr:addr: Network Sockets and Communication
• sockaddr:fam: Network Sockets and Communication
• sockaddr:path: Network Sockets and Communication
• sockaddr:port: Network Sockets and Communication
• socket: Network Sockets and Communication
• socketpair: Network Sockets and Communication
• some: Common List Operations
• sort: Sorting
• sort!: Sorting
• sort-list: Sorting
• sort-list!: Sorting
• sorted?: Sorting
• source: Preloaded Modules for Interactive Sessions
• source-properties: Procedure Properties
• source-property: Procedure Properties
• span: SRFI-1 Searching
• span!: SRFI-1 Searching
• split-at: SRFI-1 Selectors
• split-at!: SRFI-1 Selectors
• sqrt: Scientific
• stable-sort: Sorting
• stable-sort!: Sorting
• stack-catch: Lazy Catch
• stack-id: Debugging
• stack-length: Debugging
• stack-ref: Debugging
• stack?: Debugging
• standard-eval-closure: More Module Procedures
• start-stack: Debugging
• stat: File System
• status:exit-val: Processes
• status:stop-sig: Processes
• status:term-sig: Processes
• stream->list: Streams
• stream->list&length: Streams
• stream->reversed-list: Streams
• stream->reversed-list&length: Streams
• stream->vector: Streams
• stream-car: Streams
• stream-cdr: Streams
• stream-fold: Streams
• stream-for-each: Streams
• stream-map: Streams
• stream-null?: Streams
• strerror: Error Reporting
• strftime: Time
• string: String Constructors
• string->char-set: SRFI-14 Creating Character Sets
• string->char-set!: SRFI-14 Creating Character Sets
• string->list: SRFI-13 List/String Conversion
• string->list: List/String Conversion
• string->number: Conversion
• string->symbol: Symbol Primitives
• string-any: SRFI-13 Predicates
• string-append: Appending Strings
• string-append/shared: SRFI-13 Reverse/Append
• string-capitalize: Alphabetic Case Mapping
• string-capitalize!: Alphabetic Case Mapping
• string-ci->symbol: Symbol Primitives
• string-ci<: SRFI-13 Comparison
• string-ci<=: SRFI-13 Comparison
• string-ci<=?: String Comparison
• string-ci<>: SRFI-13 Comparison
• string-ci<?: String Comparison
• string-ci=: SRFI-13 Comparison
• string-ci=?: String Comparison
• string-ci>: SRFI-13 Comparison
• string-ci>=: SRFI-13 Comparison
• string-ci>=?: String Comparison
• string-ci>?: String Comparison
• string-compare: SRFI-13 Comparison
• string-compare-ci: SRFI-13 Comparison
• string-concatenate: SRFI-13 Reverse/Append
• string-concatenate-reverse: SRFI-13 Reverse/Append
• string-concatenate-reverse/shared: SRFI-13 Reverse/Append
• string-concatenate/shared: SRFI-13 Reverse/Append
• string-contains: SRFI-13 Searching
• string-contains-ci: SRFI-13 Searching
• string-copy: SRFI-13 Selection
• string-copy: String Selection
• string-copy!: SRFI-13 Selection
• string-count: SRFI-13 Searching
• string-delete: SRFI-13 Filtering/Deleting
• string-downcase: SRFI-13 Case Mapping
• string-downcase: Alphabetic Case Mapping
• string-downcase!: SRFI-13 Case Mapping
• string-downcase!: Alphabetic Case Mapping
• string-drop: SRFI-13 Selection
• string-drop-right: SRFI-13 Selection
• string-every: SRFI-13 Predicates
• string-fill!: SRFI-13 Modification
• string-fill!: String Modification
• string-filter: SRFI-13 Filtering/Deleting
• string-fold: SRFI-13 Fold/Unfold/Map
• string-for-each: SRFI-13 Fold/Unfold/Map
• string-hash: SRFI-13 Comparison
• string-hash-ci: SRFI-13 Comparison
• string-index: SRFI-13 Searching
• string-index: String Searching
• string-join: SRFI-13 List/String Conversion
• string-length: String Selection
• string-map: SRFI-13 Fold/Unfold/Map
• string-map!: SRFI-13 Fold/Unfold/Map
• string-match: Regexp Functions
• string-null?: String Predicates
• string-pad: SRFI-13 Selection
• string-pad-right: SRFI-13 Selection
• string-prefix-ci?: SRFI-13 Prefixes/Suffixes
• string-prefix-length: SRFI-13 Prefixes/Suffixes
• string-prefix-length-ci: SRFI-13 Prefixes/Suffixes
• string-prefix?: SRFI-13 Prefixes/Suffixes
• string-ref: String Selection
• string-replace: SRFI-13 Miscellaneous
• string-reverse: SRFI-13 Reverse/Append
• string-reverse!: SRFI-13 Reverse/Append
• string-rindex: String Searching
• string-set!: String Modification
• string-skip: SRFI-13 Searching
• string-skip-right: SRFI-13 Searching
• string-suffix-ci?: SRFI-13 Prefixes/Suffixes
• string-suffix-length: SRFI-13 Prefixes/Suffixes
• string-suffix-length-ci: SRFI-13 Prefixes/Suffixes
• string-suffix?: SRFI-13 Prefixes/Suffixes
• string-tabulate: SRFI-13 Constructors
• string-take: SRFI-13 Selection
• string-take-right: SRFI-13 Selection
• string-titlecase: SRFI-13 Case Mapping
• string-titlecase!: SRFI-13 Case Mapping
• string-tokenize: SRFI-13 Miscellaneous
• string-trim: SRFI-13 Selection
• string-trim-both: SRFI-13 Selection
• string-trim-right: SRFI-13 Selection
• string-unfold: SRFI-13 Fold/Unfold/Map
• string-upcase: SRFI-13 Case Mapping
• string-upcase: Alphabetic Case Mapping
• string-upcase!: SRFI-13 Case Mapping
• string-upcase!: Alphabetic Case Mapping
• string-xcopy!: SRFI-13 Replicate/Rotate
• string<: SRFI-13 Comparison
• string<=: SRFI-13 Comparison
• string<=?: String Comparison
• string<>: SRFI-13 Comparison
• string<?: String Comparison
• string=: SRFI-13 Comparison
• string=?: String Comparison
• string>: SRFI-13 Comparison
• string>=: SRFI-13 Comparison
• string>=?: String Comparison
• string>?: String Comparison
• string?: String Predicates
• strip-sequence: Run Queues
• strptime: Time
• struct-ref: Structure Basics
• struct-set!: Structure Basics
• struct-vtable: Vtables
• struct-vtable-name: Vtables
• struct-vtable-tag: Vtables
• struct-vtable?: Vtables
• struct?: Structure Basics
• substring: String Selection
• substring-fill!: String Modification
• substring-move!: String Modification
• substring-move-left!: String Modification
• substring-move-right!: String Modification
• substring/shared: SRFI-13 Selection
• symbol->keyword: Keyword Procedures
• symbol->string: Symbol Primitives
• symbol-append: Miscellaneous Procs
• symbol-fref: Symbol Props
• symbol-fset!: Symbol Props
• symbol-hash: Symbol Keys
• symbol-interned?: Symbol Uninterned
• symbol-pref: Symbol Props
• symbol-prefix-proc: Using Guile Modules
• symbol-productions: lang grammar
• symbol-property: Symbol Props
• symbol-property-remove!: Symbol Props
• symbol-pset!: Symbol Props
• symbol?: Symbol Primitives
• symlink: File System
• sync: File System
• sync-q!: Queues
• system: Processes
• system-async: Asyncs
• system-async-mark: Asyncs
• system-big-endian?: database binconv
• TAGvector: SRFI-4 - Procedures
• TAGvector->list: SRFI-4 - Procedures
• TAGvector-length: SRFI-4 - Procedures
• TAGvector-ref: SRFI-4 - Procedures
• TAGvector?: SRFI-4 - Procedures
• take: SRFI-1 Selectors
• take!: SRFI-1 Selectors
• take-right: SRFI-1 Selectors
• take-while: SRFI-1 Searching
• take-while!: SRFI-1 Searching
• tan: Scientific
• tanh: Scientific
• tcgetpgrp: Terminals and Ptys
• tcsetpgrp: Terminals and Ptys
• tenth: SRFI-1 Selectors
• third: SRFI-1 Selectors
• throw: Throw
• thunk?: Procedure Properties
• times: Time
• tm:gmtoff: Time
• tm:hour: Time
• tm:isdst: Time
• tm:mday: Time
• tm:min: Time
• tm:mon: Time
• tm:sec: Time
• tm:wday: Time
• tm:yday: Time
• tm:year: Time
• tm:zone: Time
• tmpfile: database tmpfile
• tmpnam: File System
• trace: Trace
• transpose-array: Conventional Arrays
• trap-disable: General option interface
• trap-disable: Evaluator Behaviour
• trap-enable: General option interface
• trap-enable: Evaluator Behaviour
• trap-set!: General option interface
• trap-set!: Evaluator Behaviour
• traps: General option interface
• traps: Evaluator Behaviour
• truncate: Random Access
• truncate: Arithmetic
• truncate-file: Random Access
• try-arbiter: Arbiters
• ttyname: Terminals and Ptys
• tzset: Time
• ucs-range->char-set: SRFI-14 Creating Character Sets
• ucs-range->char-set!: SRFI-14 Creating Character Sets
• umask: Processes
• uname: System Identification
• unfold: SRFI-1 Fold and Map
• unfold-right: SRFI-1 Fold and Map
• uniform-array-read!: Uniform Arrays
• uniform-array-set1!: Conventional Arrays
• uniform-array-write: Uniform Arrays
• uniform-vector-fill!: Uniform Arrays
• uniform-vector-length: Uniform Arrays
• uniform-vector-read!: Uniform Arrays
• uniform-vector-ref: Conventional Arrays
• uniform-vector-write: Uniform Arrays
• union: Common List Operations
• uniq: Common List Operations
• unlink: File System
• unlock-mutex: Low level thread primitives
• unmask-signals: Asyncs
• unmemoize: Debugging
• unread-char: Ports and File Descriptors
• unread-char: Reading
• unread-string: Ports and File Descriptors
• unread-string: Line/Delimited
• unread-string: Reading
• unregister-reporter: POSIX-Style Testing
• untrace: Trace
• unzip1: SRFI-1 Length Append etc
• unzip2: SRFI-1 Length Append etc
• unzip3: SRFI-1 Length Append etc
• unzip4: SRFI-1 Length Append etc
• unzip5: SRFI-1 Length Append etc
• use-modules: Using Guile Modules
• use-syntax: Using Guile Modules
• user-reporter: POSIX-Style Testing
• usleep: Signals
• utime: File System
• utsname:machine: System Identification
• utsname:nodename: System Identification
• utsname:release: System Identification
• utsname:sysname: System Identification
• utsname:version: System Identification
• VALIDATE:item: lang lr0
• VALIDATE:item-set: lang lr0
• VALIDATE:production: lang lr0
• VALIDATE:state-stack-entry: lang lr1
• values: Multiple Values
• variable-bound?: Variables
• variable-ref: Variables
• variable-set!: Variables
• variable?: Variables
• vector: Vector Creation
• vector->list: Vector Creation
• vector->stream: Streams
• vector-fill!: Vector Accessors
• vector-length: Vector Accessors
• vector-move-left!: Vector Accessors
• vector-move-right!: Vector Accessors
• vector-ref: Vector Accessors
• vector-set!: Vector Accessors
• vector?: Vector Creation
• version: Install Config
• wait-condition-variable: Low level thread primitives
• waitpid: Processes
• weak-key-hash-table?: Weak key hashes
• weak-value-hash-table?: Weak key hashes
• weak-vector: Weak vectors
• weak-vector?: Weak vectors
• while: while do
• with-configuration-getter-and-setter: Conventional Calling
• with-delegating-configuration-getter-and-setter: Conventional Calling
• with-delegating-getter-and-setter: Conventional Calling
• with-error-to-file: File Ports
• with-excursion-function: Conventional Calling
• with-excursion-getter-and-setter: Conventional Calling
• with-fluids: Fluids
• with-fluids*: Fluids
• with-getter: Conventional Calling
• with-getter-and-setter: Conventional Calling
• with-input-from-binary-file: SRFI-56 Port extensions
• with-input-from-file: File Ports
• with-input-from-string: String Ports
• with-mutex: Higher level thread procedures
• with-output-to-binary-file: SRFI-56 Port extensions
• with-output-to-file: File Ports
• with-output-to-string: String Ports
• with-test-prefix: POSIX-Style Testing
• with-test-prefix*: POSIX-Style Testing
• with-traps: Debugging
• write-ber-integer: SRFI-56 Bignum encodings
• write-binary-sint: SRFI-56 General writing
• write-binary-sint16: SRFI-56 Predefined write sizes
• write-binary-sint32: SRFI-56 Predefined write sizes
• write-binary-sint64: SRFI-56 Predefined write sizes
• write-binary-sint8: SRFI-56 Predefined write sizes
• write-binary-uint: SRFI-56 General writing
• write-binary-uint16: SRFI-56 Predefined write sizes
• write-binary-uint32: SRFI-56 Predefined write sizes
• write-binary-uint64: SRFI-56 Predefined write sizes
• write-binary-uint8: SRFI-56 Predefined write sizes
• write-byte: SRFI-56 I/O extensions
• write-char: Writing
• write-ieee-float32: SRFI-56 IEEE floating-point encodings
• write-ieee-float64: SRFI-56 IEEE floating-point encodings
• write-line: Line/Delimited
• write-network-sint16: SRFI-56 Predefined network encodings
• write-network-sint32: SRFI-56 Predefined network encodings
• write-network-sint64: SRFI-56 Predefined network encodings
• write-network-uint16: SRFI-56 Predefined network encodings
• write-network-uint32: SRFI-56 Predefined network encodings
• write-network-uint64: SRFI-56 Predefined network encodings
• write-string/partial: Block Reading and Writing
• write-string/partial/never-fewer: Block Reading and Writing
• xcons: SRFI-1 Constructors
• xsubstring: SRFI-13 Replicate/Rotate
• yield: Low level thread primitives
• yy-parse: lang yy
• zero?: Comparison
• zip: SRFI-1 Length Append etc