Node:Procedure Index, Next:Variable Index, Previous:Concept Index, Up:Top

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 See 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: Build Config
• %make-void-port: Void Ports
• %package-data-dir: Build Config
• %read-delimited!: Line/Delimited
• %read-line: Line/Delimited
• %search-load-path: Loading
• %site-dir: Build Config
• %thread-handler: Higher level thread procedures
• *: C Hooks, Arithmetic
• *gh_scm2chars: Scheme to C
• *gh_scm2doubles: Scheme to C
• *gh_scm2floats: Scheme to C
• *gh_scm2longs: Scheme to C
• *gh_scm2newstr: Scheme to C
• *gh_scm2shorts: Scheme to C
• *gh_symbol2newstr: Scheme to C
• +: Arithmetic
• -: Arithmetic
• ->char-set: SRFI-14 Creating Character Sets
• /: Arithmetic
• <: Comparison
• <=: Comparison
• <group>-disable: User level options interfaces
• <group>-enable: User level options interfaces
• <group>-options: User level options interfaces
• <group>-set!: User level options interfaces
• =: Comparison
• >: Comparison
• >=: Comparison
• abs: Arithmetic
• accept: Network Sockets and Communication
• access?: File System
• acons: Adding or Setting Alist Entries
• acos: Scientific
• acosh: Scientific
• add-hook!: Hook Reference
• advance-dfa!: Rx 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
• 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:nconc2last: Fly Evaluation
• 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, Conventional Arrays
• ash: Bitwise Operations
• asin: Scientific
• asinh: Scientific
• assoc: SRFI-1 Association Lists, 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
• basename: File System
• batch-mode?: Dynamic Roots
• begin: begin
• begin-thread: Higher level thread procedures
• 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
• break: SRFI-1 Searching
• break!: SRFI-1 Searching
• builtin-bindings: Obarray Symbols
• caar: Pairs
• cadr: Pairs
• 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-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
• chdir: Processes
• chmod: File System
• chown: File System
• chroot: Processes
• circular-list: SRFI-1 Constructors
• circular-list?: SRFI-1 Predicates
• close: Ports and File Descriptors
• close-all-ports-except: Close All Ports
• 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
• command-line: Runtime Environment, The Top of a Script File
• compiled-regexp?: Rx 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
• copy-file: File System
• copy-random-state: Random
• copy-tree: Copying
• cos: Scientific
• cosh: Scientific
• crypt: Encryption
• ctermid: Terminals and Ptys
• current-error-port: Default Ports
• current-input-port: Default Ports
• current-load-port: Loading
• current-output-port: Default Ports
• current-time: Time
• cuserid: User Information
• debug-disable: User level options interfaces
• debug-enable: User level options interfaces
• debug-object?: Using Traps
• debug-options: User level options interfaces
• debug-options-interface: Low level options interfaces
• debug-set!: User level options interfaces
• define: Top Level
• define*: define* Reference
• define*-public: define* Reference
• define-macro: Macros
• define-module: Creating Guile Modules
• define-public: Creating Guile Modules
• define-reader-ctor: SRFI-10
• defined?: Binding Reflection
• defmacro: Macros
• defmacro*: define* Reference
• defmacro*-public: define* Reference
• delete: SRFI-1 Deleting, List Modification
• delete!: SRFI-1 Deleting, List Modification
• delete-duplicates: SRFI-1 Deleting
• delete-duplicates!: SRFI-1 Deleting
• delete-file: File System
• delete1!: List Modification
• delq: List Modification
• delq!: List Modification
• delq1!: List Modification
• delv: List Modification
• delv!: List Modification
• delv1!: List Modification
• destroy-guardian!: Guardians
• dfa-continuable?: Rx Regexps
• dfa-final-tag: Rx Regexps
• dfa-fork: Rx Regexps
• dimensions->uniform-array: Uniform Arrays
• directory-stream?: File System
• dirname: File System
• display: Writing
• display-application: Examining Stack Frames
• display-backtrace: Examining the Stack
• display-error: Handling Errors
• 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
• eighth: 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
• entity?: Objects
• environ: Runtime Environment
• eof-object?: Reading
• eq?: Equality
• equal?: Equality
• eqv?: Equality
• error: Handling Errors, Error Reporting
• eval: Fly Evaluation
• eval-disable: Evaluator Behaviour
• eval-enable: Evaluator Behaviour
• eval-options: Evaluator Behaviour
• eval-options-interface: Low level options interfaces, Evaluator Behaviour
• eval-set!: Evaluator Behaviour
• eval-string: Fly Evaluation
• eval2: Strange Eval
• evaluator-traps-interface: Low level options interfaces, Evaluator Behaviour
• even?: Integer Operations
• every: SRFI-1 Searching
• exact->inexact: Exactness
• exact?: Exactness
• execl: Processes
• execle: Processes
• execlp: Processes
• exp: Scientific
• expect: Expect
• expect-strings: Expect
• export: Creating Guile Modules
• expt: Scientific
• false-if-exception: Error Reporting
• 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-port?: File Ports
• 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-tail: SRFI-1 Searching
• first: SRFI-1 Selectors
• flock: Ports and File Descriptors
• floor: Arithmetic
• fluid-ref: Fluids
• fluid-set!: Fluids
• fluid?: Fluids
• flush-all-ports: Writing
• fn: Defining new Scheme procedures in C
• fold: SRFI-1 Fold and Map
• fold-right: SRFI-1 Fold and Map
• for-each: SRFI-1 Fold and Map, List Mapping
• force: Delayed Evaluation
• force-output: Writing
• format: Formatted Output
• fourth: SRFI-1 Selectors
• frame-arguments: Examining Stack Frames
• frame-evaluating-args?: Examining Stack Frames
• frame-next: Examining Stack Frames
• frame-number: Examining Stack Frames
• frame-overflow?: Examining Stack Frames
• frame-previous: Examining Stack Frames
• frame-procedure: Examining Stack Frames
• frame-procedure?: Examining Stack Frames
• frame-real?: Examining Stack Frames
• frame-source: Examining Stack Frames
• frame?: Examining Stack Frames
• fstat: File System
• fsync: Ports and File Descriptors
• ftell: Random Access
• ftruncate: Random Access
• gc: Garbage Collection
• gc-stats: Garbage Collection
• gcd: Integer Operations
• gensym: Symbol Primitives
• gentemp: Obarray Symbols
• 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
• gethostname: System Identification
• getitimer: Signals
• getlogin: User Information
• getnet: Network Databases
• getnetbyaddr: Network Databases
• getnetbyname: Network Databases
• getnetent: Network Databases
• getopt-long: getopt-long Reference
• getpass: Encryption
• getpeername: Network Sockets and Communication
• getpgrp: Processes
• getpid: Processes
• getppid: Processes
• getpriority: Processes
• getproto: Network Databases
• getprotobyname: Network Databases
• getprotobynumber: Network Databases
• getprotoent: Network Databases
• getpw: User Information
• getpwent: User Information
• getpwnam: User Information
• getpwuid: User Information
• getserv: Network Databases
• getservbyname: Network Databases
• getservbyport: Network Databases
• getservent: Network Databases
• 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_c: Calling Scheme procedures from C
• 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_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_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_str: 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_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_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_new_procedure: Defining new Scheme procedures in C
• gh_null_p: Equality 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_scm2double: Scheme to C
• gh_scm2long: Scheme to C
• gh_scm2ulong: Scheme to C
• 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_str02scm: C to Scheme
• gh_str2scm: C to Scheme
• gh_string_equal_p: Equality predicates
• 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_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: Calling Scheme procedures from C
• gmtime: Time
• guardian-destroyed?: Guardians
• guardian-greedy?: Guardians
• GUILE_CHECK_RETVAL: Autoconf Macros
• GUILE_FLAGS: Autoconf Macros
• GUILE_MODULE_AVAILABLE: 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_SITE_DIR: Autoconf Macros
• hash: Hash Table Reference
• hash-create-handle!: Hash Table Reference
• hash-fold: Hash Table Reference
• hash-get-handle: Hash Table Reference
• hash-ref: Hash Table Reference
• hash-remove!: Hash Table Reference
• hash-set!: Hash Table Reference
• hashq: Hash Table Reference
• hashq-create-handle!: Hash Table Reference
• hashq-get-handle: Hash Table Reference
• hashq-ref: Hash Table Reference
• hashq-remove!: Hash Table Reference
• hashq-set!: Hash Table Reference
• 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
• 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
• if: if cond case
• imag-part: Complex
• 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
• inet-ntop: Network Address Conversion
• inet-pton: Network Address Conversion
• inexact->exact: Exactness
• inexact?: Exactness
• input-port?: Ports
• integer->char: Characters
• integer-expt: Bitwise Operations
• integer-length: Bitwise Operations
• integer?: Integers
• interaction-environment: Fly Evaluation
• intern-symbol: Obarray Symbols
• iota: SRFI-1 Constructors
• isatty?: Terminals and Ptys
• join-thread: Low level thread primitives
• key: Evaluator trap options
• keyword->symbol: Keyword Procedures
• keyword-dash-symbol: Keyword Primitives
• keyword?: Keyword Primitives
• kill: Signals
• lambda: Lambda
• lambda*: lambda* Reference
• last: SRFI-1 Selectors
• last-pair: List Selection
• last-stack-frame: Capturing the Stack or Innermost Stack Frame
• lazy-catch: Lazy Catch
• lchown: File System
• lcm: Integer Operations
• length: List Selection
• length+: SRFI-1 Length Append etc
• let: while do, Local Bindings
• let*: Local Bindings
• let-keywords: let-keywords Reference
• let-optional: let-optional Reference
• let-optional*: let-optional Reference
• letrec: Local Bindings
• link: File System
• list: List Constructors
• list->char-set: SRFI-14 Creating Character Sets
• list->char-set!: SRFI-14 Creating Character Sets
• list->string: String Constructors
• 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
• load: Loading
• load-from-path: Loading
• 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
• 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: Build Config
• make-arbiter: Arbiters
• make-array: Conventional Arrays
• make-class-object: Objects
• make-condition-variable: Low level thread primitives
• make-doubly-weak-hash-table: Weak key hashes
• make-fluid: Fluids
• make-guardian: Guardians
• make-hash-table: Hash Table Reference
• make-hook: Hook Reference
• make-keyword-from-dash-symbol: Keyword Primitives
• make-list: List Constructors
• make-mutex: Low level thread primitives
• make-object-property: Object Properties
• make-polar: Complex
• make-procedure-with-setter: Procedures with Setters
• 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: Capturing the Stack or Innermost Stack Frame
• make-string: String Constructors
• make-struct: Structure Basics
• make-struct-layout: Structure Layout
• make-subclass-object: Objects
• make-TAGvector: SRFI-4 - Procedures
• make-thread: Higher level thread procedures
• make-undefined-variable: Variables
• make-uniform-array: Uniform Arrays
• make-uniform-vector: Uniform Arrays
• make-variable: Variables
• make-vector: Vector Creation
• 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
• malloc-stats: Garbage Collection
• map: SRFI-1 Fold and Map, List Mapping
• map!: SRFI-1 Fold and Map
• map-in-order: List Mapping
• 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, List Searching
• memoized-environment: Decoding Memoized Source Expressions
• memoized?: Decoding Memoized Source Expressions
• memq: List Searching
• memv: List Searching
• merge: Sorting
• merge!: Sorting
• micro-version: Build Config
• min: Arithmetic
• minor-version: Build Config
• mkdir: File System
• mknod: File System
• mkstemp!: File System
• mktime: Time
• 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
• nice: Processes
• 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
• ntohl: Network Sockets and Communication
• ntohs: Network Sockets and Communication
• null: Emacs Lisp Support
• null-environment: Environments
• null-list?: SRFI-1 Predicates
• null?: List Predicates
• number->string: Conversion
• number?: Numerical Tower
• object->string: General Conversion
• object-address: Garbage Collection
• object-properties: Old-fashioned Properties
• object-property: Old-fashioned Properties
• odd?: Integer Operations
• open: Ports and File Descriptors
• 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
• 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
• parse-path: Build Config
• partition: SRFI-1 Filtering and Partitioning
• partition!: SRFI-1 Filtering and Partitioning
• pause: Signals
• pclose: Pipes
• peek-char: Reading
• pipe: Ports and File Descriptors
• popen: Pipes
• port->fdes: Ports and File Descriptors
• port-closed?: Closing
• port-column: Reading
• port-filename: File Ports
• port-for-each: Ports and File Descriptors
• port-line: Reading
• port-mode: Ports and File Descriptors, File Ports
• port-revealed: Ports and File Descriptors
• port-with-print-state: Writing
• port?: Ports
• positive?: Comparison
• pretty-print: Pretty Printing
• primitive-eval: Fly Evaluation
• primitive-exit: Processes
• primitive-fork: Processes
• primitive-load: Loading
• primitive-load-path: Loading
• primitive-make-property: Property Primitives
• primitive-move->fdes: Ports and File Descriptors
• primitive-property-del!: Property Primitives
• primitive-property-ref: Property Primitives
• primitive-property-set!: Property Primitives
• print-disable: User level options interfaces
• print-enable: User level options interfaces
• print-options: User level options interfaces
• print-options-interface: Low level options interfaces, Writing
• print-set!: User level options interfaces
• 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
• program-arguments: Runtime Environment, 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
• PTR2SCM: Non-immediate objects
• putenv: Runtime Environment
• pwd: Processes
• 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-and-eval!: Strange Eval
• read-char: Reading
• read-delimited: Line/Delimited
• read-delimited!: Line/Delimited
• read-disable: User level options interfaces, Scheme Read
• read-enable: User level options interfaces, Scheme Read
• read-hash-extend: Reader Extensions
• read-line: Line/Delimited
• read-line!: Line/Delimited
• read-only-string?: Read Only Strings
• read-options: User level options interfaces, Scheme Read
• read-options-interface: Low level options interfaces, Scheme Read
• read-set!: User level options interfaces, Scheme Read
• read-string!/partial: Block Reading and Writing
• readdir: File System
• readlink: File System
• 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
• recv!: Network Sockets and Communication
• recvfrom!: Network Sockets and Communication
• redirect-port: Ports and File Descriptors
• reduce: SRFI-1 Fold and Map
• reduce-right: SRFI-1 Fold and Map
• regcomp: Rx Regexps
• regexec: Rx Regexps
• regexp->dfa: Rx 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
• 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
• rename: File System
• rename-file: File System
• reset-dfa!: Rx Regexps
• reset-hook!: Hook Reference
• restore-signals: Signals
• restricted-vector-sort!: Sorting
• 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
• scheme-report-environment: Environments
• scm-error: Handling Errors, Error Reporting
• SCM2PTR: Non-immediate objects
• scm_abs: Arithmetic
• scm_accept: Network Sockets and Communication
• scm_access: File System
• scm_acons: Adding or Setting Alist Entries
• scm_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_x: 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_builtin_bindings: Obarray Symbols
• scm_c_call_with_current_module: Accessing Modules from C
• scm_c_define: Accessing Modules from C, Top Level
• scm_c_define_gsubr: Subrs
• scm_c_define_module: Accessing Modules from C
• scm_c_export: Accessing Modules from C
• scm_c_hook_add: C Hooks
• scm_c_hook_init: C Hooks
• scm_c_hook_remove: C Hooks
• scm_c_lookup: Accessing Modules from C
• scm_c_module_define: Accessing Modules from C
• scm_c_module_lookup: Accessing Modules from C
• scm_c_resolve_module: Accessing Modules from C
• scm_c_run_hook: Hook Reference
• scm_c_use_module: Accessing Modules from C
• 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_downcase: Characters
• scm_char_is_both_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_chroot: Processes
• scm_close: Ports and File Descriptors
• scm_close_all_ports_except: Close All Ports
• 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, Pair Data
• scm_cons_source: Internal Macros
• scm_cons_star: List Constructors
• SCM_CONSP: Basic Rules for Accessing Cell Entries, Pair Data
• scm_copy_file: File System
• scm_copy_random_state: Random
• scm_copy_tree: Copying
• scm_crypt: Encryption
• scm_ctermid: Terminals and Ptys
• scm_current_error_port: Default Ports
• scm_current_input_port: Default Ports
• scm_current_load_port: Loading
• scm_current_module: Accessing Modules from C
• scm_current_output_port: Default Ports
• scm_current_time: Time
• scm_cuserid: User Information
• scm_debug_object_p: Using Traps
• scm_debug_options: Low level options interfaces
• scm_define: Accessing Modules from C, Top Level
• 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_destroy_guardian_x: Guardians
• scm_dimensions_to_uniform_array: Uniform Arrays
• scm_directory_stream_p: File System
• scm_dirname: File System
• scm_display_application: Examining Stack Frames
• scm_display_backtrace: Examining the Stack
• 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_eval2: Strange Eval
• scm_eval_options_interface: Low level options interfaces, Evaluator Behaviour
• scm_eval_string: Fly Evaluation
• scm_evaluator_traps: Low level options interfaces, 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_file_port_p: File Ports
• scm_fileno: Ports and File Descriptors
• scm_flock: 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: Examining Stack Frames
• scm_frame_evaluating_args_p: Examining Stack Frames
• scm_frame_next: Examining Stack Frames
• scm_frame_number: Examining Stack Frames
• scm_frame_overflow_p: Examining Stack Frames
• scm_frame_p: Examining Stack Frames
• scm_frame_previous: Examining Stack Frames
• scm_frame_procedure: Examining Stack Frames
• scm_frame_procedure_p: Examining Stack Frames
• scm_frame_real_p: Examining Stack Frames
• scm_frame_source: Examining Stack Frames
• 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_gentemp: Obarray Symbols
• 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_gethostname: System Identification
• scm_getitimer: Signals
• scm_getlogin: User Information
• scm_getnet: Network Databases
• scm_getpass: Encryption
• scm_getpeername: Network Sockets and Communication
• scm_getpgrp: Processes
• scm_getpid: Processes
• scm_getppid: Processes
• scm_getpriority: Processes
• scm_getproto: Network Databases
• scm_getpwuid: User Information
• scm_getserv: Network Databases
• scm_getsockname: Network Sockets and Communication
• scm_getsockopt: Network Sockets and Communication
• scm_gettimeofday: Time
• scm_getuid: Processes
• scm_gmtime: Time
• scm_guardian_destroyed_p: Guardians
• scm_guardian_greedy_p: Guardians
• scm_hash: Hash Table Reference
• scm_hash_create_handle_x: Hash Table Reference
• scm_hash_fold: Hash Table Reference
• scm_hash_get_handle: 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_ref: Hash Table Reference
• scm_hashv_remove_x: Hash Table Reference
• scm_hashv_set_x: Hash Table Reference
• scm_hashx_create_handle_x: Hash Table Reference
• scm_hashx_get_handle: Hash Table Reference
• scm_hashx_ref: Hash Table Reference
• scm_hashx_set_x: Hash Table Reference
• scm_hook_empty_p: Hook Reference
• scm_hook_p: Hook Reference
• scm_hook_to_list: Hook Reference
• SCM_HOOKP: Hook Reference
• scm_htonl: Network Sockets and Communicati