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
• 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
• 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