Guile Reference Manual

Table of Contents

• The Guile Reference Manual
• 1 Preface
  • 1.1 Layout of this Manual
  • 1.2 Conventions used in this Manual
  • 1.3 Contributors to this Manual
  • 1.4 The Guile License
• 2 Introduction to Guile
  • 2.1 What is Guile?
  • 2.2 Obtaining and Installing Guile
  • 2.3 A Whirlwind Tour
    • 2.3.1 Running Guile Interactively
    • 2.3.2 Running Guile Scripts
    • 2.3.3 Linking Guile into Programs
    • 2.3.4 Writing Guile Extensions
    • 2.3.5 Using the Guile Module System
      • 2.3.5.1 Using Modules
      • 2.3.5.2 Writing new Modules
      • 2.3.5.3 Putting Extensions into Modules
  • 2.4 Discouraged and Deprecated
  • 2.5 Reporting Bugs
• 3 Programming in Scheme
  • 3.1 Basic Ideas in Scheme
    • 3.1.1 Data Types, Values and Variables
      • 3.1.1.1 Latent Typing
      • 3.1.1.2 Values and Variables
      • 3.1.1.3 Defining and Setting Variables
    • 3.1.2 The Representation and Use of Procedures
      • 3.1.2.1 Procedures as Values
      • 3.1.2.2 Simple Procedure Invocation
      • 3.1.2.3 Creating and Using a New Procedure
      • 3.1.2.4 Lambda Alternatives
    • 3.1.3 Expressions and Evaluation
      • 3.1.3.1 Evaluating Expressions and Executing Programs
      • 3.1.3.2 Tail calls
      • 3.1.3.3 Using the Guile REPL
      • 3.1.3.4 Summary of Common Syntax
    • 3.1.4 The Concept of Closure
      • 3.1.4.1 Names, Locations, Values and Environments
      • 3.1.4.2 Local Variables and Environments
      • 3.1.4.3 Environment Chaining
      • 3.1.4.4 Lexical Scope
      • 3.1.4.5 Closure
      • 3.1.4.6 Example 1: A Serial Number Generator
      • 3.1.4.7 Example 2: A Shared Persistent Variable
      • 3.1.4.8 Example 3: The Callback Closure Problem
      • 3.1.4.9 Example 4: Object Orientation
  • 3.2 Guile's Implementation of Scheme
  • 3.3 Guile Scripting
    • 3.3.1 The Top of a Script File
    • 3.3.2 Invoking Guile
    • 3.3.3 The Meta Switch
    • 3.3.4 Command Line Handling
    • 3.3.5 Scripting Examples
  • 3.4 Using Guile Interactively
    • 3.4.1 Readline
    • 3.4.2 Value History
    • 3.4.3 Error Handling
    • 3.4.4 Using the Interactive Debugger
      • 3.4.4.1 Display Backtrace
      • 3.4.4.2 Frame Selection
      • 3.4.4.3 Frame Information
      • 3.4.4.4 Frame Evaluation
      • 3.4.4.5 Single Stepping and Continuing Execution
  • 3.5 Using Guile in Emacs
    • 3.5.1 GDS Introduction
    • 3.5.2 GDS Architecture
    • 3.5.3 Getting Started with GDS
      • 3.5.3.1 Invoking GDS when an Exception Occurs
      • 3.5.3.2 Accepting GDS Instructions at Any Time
      • 3.5.3.3 Utility Guile Implementation
    • 3.5.4 Working with GDS in Scheme Buffers
      • 3.5.4.1 Access to Guile Help and Completion
      • 3.5.4.2 Evaluating Scheme Code
    • 3.5.5 Displaying the Scheme Stack
    • 3.5.6 Continuing Execution
    • 3.5.7 Associating Buffers with Clients
    • 3.5.8 An Example GDS Session
  • 3.6 Further Reading
• 4 Programming in C
  • 4.1 Linking Programs With Guile
    • 4.1.1 Guile Initialization Functions
    • 4.1.2 A Sample Guile Main Program
  • 4.2 Linking Guile with Libraries
    • 4.2.1 A Sample Guile Extension
  • 4.3 General concepts for using libguile
    • 4.3.1 Dynamic Types
    • 4.3.2 Garbage Collection
    • 4.3.3 Control Flow
    • 4.3.4 Asynchronous Signals
    • 4.3.5 Multi-Threading
  • 4.4 Defining New Types (Smobs)
    • 4.4.1 Describing a New Type
    • 4.4.2 Creating Smob Instances
    • 4.4.3 Type checking
    • 4.4.4 Garbage Collecting Smobs
    • 4.4.5 Garbage Collecting Simple Smobs
    • 4.4.6 Remembering During Operations
    • 4.4.7 Double Smobs
    • 4.4.8 The Complete Example
  • 4.5 Function Snarfing
  • 4.6 An Overview of Guile Programming
    • 4.6.1 How One Might Extend Dia Using Guile
      • 4.6.1.1 Deciding Why You Want to Add Guile
      • 4.6.1.2 Four Steps Required to Add Guile
      • 4.6.1.3 How to Represent Dia Data in Scheme
      • 4.6.1.4 Writing Guile Primitives for Dia
      • 4.6.1.5 Providing a Hook for the Evaluation of Scheme Code
      • 4.6.1.6 Top-level Structure of Guile-enabled Dia
      • 4.6.1.7 Going Further with Dia and Guile
    • 4.6.2 Why Scheme is More Hackable Than C
    • 4.6.3 Example: Using Guile for an Application Testbed
    • 4.6.4 A Choice of Programming Options
      • 4.6.4.1 What Functionality is Already Available?
      • 4.6.4.2 Functional and Performance Constraints
      • 4.6.4.3 Your Preferred Programming Style
      • 4.6.4.4 What Controls Program Execution?
    • 4.6.5 How About Application Users?
• 5 API Reference
  • 5.1 Overview of the Guile API
  • 5.2 The SCM Type
  • 5.3 Initializing Guile
  • 5.4 Snarfing Macros
  • 5.5 Simple Generic Data Types
    • 5.5.1 Booleans
    • 5.5.2 Numerical data types
      • 5.5.2.1 Scheme's Numerical “Tower”
      • 5.5.2.2 Integers
      • 5.5.2.3 Real and Rational Numbers
      • 5.5.2.4 Complex Numbers
      • 5.5.2.5 Exact and Inexact Numbers
      • 5.5.2.6 Read Syntax for Numerical Data
      • 5.5.2.7 Operations on Integer Values
      • 5.5.2.8 Comparison Predicates
      • 5.5.2.9 Converting Numbers To and From Strings
      • 5.5.2.10 Complex Number Operations
      • 5.5.2.11 Arithmetic Functions
      • 5.5.2.12 Scientific Functions
      • 5.5.2.13 Primitive Numeric Functions
      • 5.5.2.14 Bitwise Operations
      • 5.5.2.15 Random Number Generation
    • 5.5.3 Characters
    • 5.5.4 Character Sets
      • 5.5.4.1 Character Set Predicates/Comparison
      • 5.5.4.2 Iterating Over Character Sets
      • 5.5.4.3 Creating Character Sets
      • 5.5.4.4 Querying Character Sets
      • 5.5.4.5 Character-Set Algebra
      • 5.5.4.6 Standard Character Sets
    • 5.5.5 Strings
      • 5.5.5.1 String Read Syntax
      • 5.5.5.2 String Predicates
      • 5.5.5.3 String Constructors
      • 5.5.5.4 List/String conversion
      • 5.5.5.5 String Selection
      • 5.5.5.6 String Modification
      • 5.5.5.7 String Comparison
      • 5.5.5.8 String Searching
      • 5.5.5.9 Alphabetic Case Mapping
      • 5.5.5.10 Reversing and Appending Strings
      • 5.5.5.11 Mapping, Folding, and Unfolding
      • 5.5.5.12 Miscellaneous String Operations
      • 5.5.5.13 Conversion to/from C
    • 5.5.6 Bytevectors
      • 5.5.6.1 Endianness
      • 5.5.6.2 Manipulating Bytevectors
      • 5.5.6.3 Interpreting Bytevector Contents as Integers
      • 5.5.6.4 Converting Bytevectors to/from Integer Lists
      • 5.5.6.5 Interpreting Bytevector Contents as Floating Point Numbers
      • 5.5.6.6 Interpreting Bytevector Contents as Unicode Strings
      • 5.5.6.7 Accessing Bytevectors with the Generalized Vector API
    • 5.5.7 Regular Expressions
      • 5.5.7.1 Regexp Functions
      • 5.5.7.2 Match Structures
      • 5.5.7.3 Backslash Escapes
    • 5.5.8 Symbols
      • 5.5.8.1 Symbols as Discrete Data
      • 5.5.8.2 Symbols as Lookup Keys
      • 5.5.8.3 Symbols as Denoting Variables
      • 5.5.8.4 Operations Related to Symbols
      • 5.5.8.5 Function Slots and Property Lists
      • 5.5.8.6 Extended Read Syntax for Symbols
      • 5.5.8.7 Uninterned Symbols
    • 5.5.9 Keywords
      • 5.5.9.1 Why Use Keywords?
      • 5.5.9.2 Coding With Keywords
      • 5.5.9.3 Keyword Read Syntax
      • 5.5.9.4 Keyword Procedures
    • 5.5.10 “Functionality-Centric” Data Types
  • 5.6 Compound Data Types
    • 5.6.1 Pairs
    • 5.6.2 Lists
      • 5.6.2.1 List Read Syntax
      • 5.6.2.2 List Predicates
      • 5.6.2.3 List Constructors
      • 5.6.2.4 List Selection
      • 5.6.2.5 Append and Reverse
      • 5.6.2.6 List Modification
      • 5.6.2.7 List Searching
      • 5.6.2.8 List Mapping
    • 5.6.3 Vectors
      • 5.6.3.1 Read Syntax for Vectors
      • 5.6.3.2 Dynamic Vector Creation and Validation
      • 5.6.3.3 Accessing and Modifying Vector Contents
      • 5.6.3.4 Vector Accessing from C
    • 5.6.4 Uniform Numeric Vectors
    • 5.6.5 Bit Vectors
    • 5.6.6 Generalized Vectors
    • 5.6.7 Arrays
      • 5.6.7.1 Array Syntax
      • 5.6.7.2 Array Procedures
      • 5.6.7.3 Shared Arrays
      • 5.6.7.4 Accessing Arrays from C
    • 5.6.8 Records
    • 5.6.9 Structures
      • 5.6.9.1 Vtables
      • 5.6.9.2 Structure Basics
      • 5.6.9.3 Vtable Contents
      • 5.6.9.4 Vtable Vtables
    • 5.6.10 Dictionary Types
    • 5.6.11 Association Lists
      • 5.6.11.1 Alist Key Equality
      • 5.6.11.2 Adding or Setting Alist Entries
      • 5.6.11.3 Retrieving Alist Entries
      • 5.6.11.4 Removing Alist Entries
      • 5.6.11.5 Sloppy Alist Functions
      • 5.6.11.6 Alist Example
    • 5.6.12 Hash Tables
      • 5.6.12.1 Hash Table Examples
      • 5.6.12.2 Hash Table Reference
  • 5.7 Smobs
  • 5.8 Procedures and Macros
    • 5.8.1 Lambda: Basic Procedure Creation
    • 5.8.2 Primitive Procedures
    • 5.8.3 Compiled Procedures
    • 5.8.4 Optional Arguments
      • 5.8.4.1 lambda* and define*.
      • 5.8.4.2 (ice-9 optargs)
    • 5.8.5 Case-lambda
    • 5.8.6 Procedure Properties and Meta-information
    • 5.8.7 Procedures with Setters
    • 5.8.8 Lisp Style Macro Definitions
    • 5.8.9 The R5RS syntax-rules System
      • 5.8.9.1 The syntax-rules Pattern Language
      • 5.8.9.2 Top Level Syntax Definitions
      • 5.8.9.3 Local Syntax Definitions
    • 5.8.10 Support for the syntax-case System
    • 5.8.11 Internal Representation of Macros and Syntax
  • 5.9 General Utility Functions
    • 5.9.1 Equality
    • 5.9.2 Object Properties
      • 5.9.2.1 Low Level Property Implementation.
      • 5.9.2.2 An Older Approach to Properties
    • 5.9.3 Sorting
    • 5.9.4 Copying Deep Structures
    • 5.9.5 General String Conversion
    • 5.9.6 Hooks
      • 5.9.6.1 Hook Usage by Example
      • 5.9.6.2 Hook Reference
      • 5.9.6.3 Handling Scheme-level hooks from C code
      • 5.9.6.4 Hooks For C Code.
      • 5.9.6.5 Hooks for Garbage Collection
      • 5.9.6.6 Hooks into the Guile REPL
  • 5.10 Definitions and Variable Bindings
    • 5.10.1 Top Level Variable Definitions
    • 5.10.2 Local Variable Bindings
    • 5.10.3 Internal definitions
    • 5.10.4 Querying variable bindings
  • 5.11 Controlling the Flow of Program Execution
    • 5.11.1 Evaluating a Sequence of Expressions
    • 5.11.2 Simple Conditional Evaluation
    • 5.11.3 Conditional Evaluation of a Sequence of Expressions
    • 5.11.4 Iteration mechanisms
    • 5.11.5 Continuations
    • 5.11.6 Returning and Accepting Multiple Values
    • 5.11.7 Exceptions
      • 5.11.7.1 Exception Terminology
      • 5.11.7.2 Catching Exceptions
      • 5.11.7.3 Throw Handlers
      • 5.11.7.4 Catch Without Unwinding
      • 5.11.7.5 Throwing Exceptions
      • 5.11.7.6 How Guile Implements Exceptions
    • 5.11.8 Procedures for Signaling Errors
    • 5.11.9 Dynamic Wind
    • 5.11.10 How to Handle Errors
      • 5.11.10.1 C Support
    • 5.11.11 Continuation Barriers
  • 5.12 Input and Output
    • 5.12.1 Ports
    • 5.12.2 Reading
    • 5.12.3 Writing
    • 5.12.4 Closing
    • 5.12.5 Random Access
    • 5.12.6 Line Oriented and Delimited Text
    • 5.12.7 Block reading and writing
    • 5.12.8 Default Ports for Input, Output and Errors
    • 5.12.9 Types of Port
      • 5.12.9.1 File Ports
      • 5.12.9.2 String Ports
      • 5.12.9.3 Soft Ports
      • 5.12.9.4 Void Ports
    • 5.12.10 R6RS I/O Ports
      • 5.12.10.1 The End-of-File Object
      • 5.12.10.2 Port Manipulation
      • 5.12.10.3 Binary Input
      • 5.12.10.4 Binary Output
    • 5.12.11 Using and Extending Ports in C
      • 5.12.11.1 C Port Interface
      • 5.12.11.2 Port Implementation
  • 5.13 Reading and Evaluating Scheme Code
    • 5.13.1 Scheme Syntax: Standard and Guile Extensions
      • 5.13.1.1 Expression Syntax
      • 5.13.1.2 Comments
      • 5.13.1.3 Block Comments
      • 5.13.1.4 Case Sensitivity
      • 5.13.1.5 Keyword Syntax
      • 5.13.1.6 Reader Extensions
    • 5.13.2 Reading Scheme Code
    • 5.13.3 Procedures for On the Fly Evaluation
    • 5.13.4 Compiling Scheme Code
    • 5.13.5 Loading Scheme Code from File
    • 5.13.6 Character Encoding of Source Files
    • 5.13.7 Delayed Evaluation
    • 5.13.8 Local Evaluation
    • 5.13.9 Evaluator Behaviour
    • 5.13.10 VM Behaviour
  • 5.14 Memory Management and Garbage Collection
    • 5.14.1 Function related to Garbage Collection
    • 5.14.2 Memory Blocks
      • 5.14.2.1 Upgrading from scm_must_malloc et al.
    • 5.14.3 Weak References
      • 5.14.3.1 Weak hash tables
      • 5.14.3.2 Weak vectors
    • 5.14.4 Guardians
  • 5.15 Objects
  • 5.16 Modules
    • 5.16.1 provide and require
    • 5.16.2 Environments
    • 5.16.3 The Guile module system
      • 5.16.3.1 General Information about Modules
      • 5.16.3.2 Using Guile Modules
      • 5.16.3.3 Creating Guile Modules
      • 5.16.3.4 Module System Reflection
      • 5.16.3.5 Module System Quirks
      • 5.16.3.6 Included Guile Modules
      • 5.16.3.7 Accessing Modules from C
    • 5.16.4 Dynamic Libraries
      • 5.16.4.1 Low level dynamic linking
      • 5.16.4.2 Putting Compiled Code into Modules
      • 5.16.4.3 Dynamic Linking and Compiled Code Modules
      • 5.16.4.4 Compiled Code Installation
    • 5.16.5 Variables
  • 5.17 Threads, Mutexes, Asyncs and Dynamic Roots
    • 5.17.1 Arbiters
    • 5.17.2 Asyncs
      • 5.17.2.1 System asyncs
      • 5.17.2.2 User asyncs
    • 5.17.3 Threads
    • 5.17.4 Mutexes and Condition Variables
    • 5.17.5 Blocking in Guile Mode
    • 5.17.6 Critical Sections
    • 5.17.7 Fluids and Dynamic States
    • 5.17.8 Parallel forms
  • 5.18 Configuration, Features and Runtime Options
    • 5.18.1 Configuration, Build and Installation
    • 5.18.2 Feature Tracking
      • 5.18.2.1 Feature Manipulation
      • 5.18.2.2 Common Feature Symbols
    • 5.18.3 Runtime Options
      • 5.18.3.1 Low Level Options Interfaces
      • 5.18.3.2 User Level Options Interfaces
      • 5.18.3.3 Reader options
      • 5.18.3.4 Printing options
      • 5.18.3.5 Evaluator options
      • 5.18.3.6 Evaluator trap options
      • 5.18.3.7 Debugger options
      • 5.18.3.8 Examples of option use
  • 5.19 Support for Translating Other Languages
    • 5.19.1 Emacs Lisp Support
  • 5.20 Support for Internationalization
    • 5.20.1 Internationalization with Guile
    • 5.20.2 Text Collation
    • 5.20.3 Character Case Mapping
    • 5.20.4 Number Input and Output
    • 5.20.5 Accessing Locale Information
    • 5.20.6 Gettext Support
  • 5.21 Debugging Infrastructure
    • 5.21.1 Evaluation and the Scheme Stack
      • 5.21.1.1 Capturing the Stack or Innermost Stack Frame
      • 5.21.1.2 Examining the Stack
      • 5.21.1.3 Examining Stack Frames
      • 5.21.1.4 Source Properties
      • 5.21.1.5 Decoding Memoized Source Expressions
      • 5.21.1.6 Starting a New Stack
    • 5.21.2 Debugging when an error occurs
      • 5.21.2.1 Intercepting basic error information
      • 5.21.2.2 Capturing the full error stack
      • 5.21.2.3 Displaying or interrogating the captured stack
      • 5.21.2.4 What the Guile REPL does
    • 5.21.3 Traps
      • 5.21.3.1 A Quick Note on Terminology
      • 5.21.3.2 How to Set a Trap
      • 5.21.3.3 Specifying Trap Behaviour
      • 5.21.3.4 Trap Context
      • 5.21.3.5 Tracing Examples
      • 5.21.3.6 Tracing Configuration
      • 5.21.3.7 Tracing and (ice-9 debug)
      • 5.21.3.8 Traps Installing More Traps
      • 5.21.3.9 Common Trap Options
      • 5.21.3.10 Procedure Traps
      • 5.21.3.11 Exit Traps
      • 5.21.3.12 Entry Traps
      • 5.21.3.13 Apply Traps
      • 5.21.3.14 Step Traps
      • 5.21.3.15 Source Traps
      • 5.21.3.16 Location Traps
      • 5.21.3.17 Trap Shorthands
      • 5.21.3.18 Trap Utilities
    • 5.21.4 Debugging Examples
      • 5.21.4.1 Single Stepping through a Procedure's Code
      • 5.21.4.2 Profiling or Tracing a Procedure's Code
• 6 Guile Modules
  • 6.1 SLIB
    • 6.1.1 SLIB installation
    • 6.1.2 JACAL
  • 6.2 POSIX System Calls and Networking
    • 6.2.1 POSIX Interface Conventions
    • 6.2.2 Ports and File Descriptors
    • 6.2.3 File System
    • 6.2.4 User Information
    • 6.2.5 Time
    • 6.2.6 Runtime Environment
    • 6.2.7 Processes
    • 6.2.8 Signals
    • 6.2.9 Terminals and Ptys
    • 6.2.10 Pipes
    • 6.2.11 Networking
      • 6.2.11.1 Network Address Conversion
      • 6.2.11.2 Network Databases
      • 6.2.11.3 Network Socket Address
      • 6.2.11.4 Network Sockets and Communication
      • 6.2.11.5 Network Socket Examples
    • 6.2.12 System Identification
    • 6.2.13 Locales
    • 6.2.14 Encryption
  • 6.3 The (ice-9 getopt-long) Module
    • 6.3.1 A Short getopt-long Example
    • 6.3.2 How to Write an Option Specification
    • 6.3.3 Expected Command Line Format
    • 6.3.4 Reference Documentation for getopt-long
    • 6.3.5 Reference Documentation for option-ref
  • 6.4 SRFI Support Modules
    • 6.4.1 About SRFI Usage
    • 6.4.2 SRFI-0 - cond-expand
    • 6.4.3 SRFI-1 - List library
      • 6.4.3.1 Constructors
      • 6.4.3.2 Predicates
      • 6.4.3.3 Selectors
      • 6.4.3.4 Length, Append, Concatenate, etc.
      • 6.4.3.5 Fold, Unfold & Map
      • 6.4.3.6 Filtering and Partitioning
      • 6.4.3.7 Searching
      • 6.4.3.8 Deleting
      • 6.4.3.9 Association Lists
      • 6.4.3.10 Set Operations on Lists
    • 6.4.4 SRFI-2 - and-let*
    • 6.4.5 SRFI-4 - Homogeneous numeric vector datatypes
    • 6.4.6 SRFI-6 - Basic String Ports
    • 6.4.7 SRFI-8 - receive
    • 6.4.8 SRFI-9 - define-record-type
    • 6.4.9 SRFI-10 - Hash-Comma Reader Extension
    • 6.4.10 SRFI-11 - let-values
    • 6.4.11 SRFI-13 - String Library
    • 6.4.12 SRFI-14 - Character-set Library
    • 6.4.13 SRFI-16 - case-lambda
    • 6.4.14 SRFI-17 - Generalized set!
    • 6.4.15 SRFI-18 - Multithreading support
      • 6.4.15.1 SRFI-18 Threads
      • 6.4.15.2 SRFI-18 Mutexes
      • 6.4.15.3 SRFI-18 Condition variables
      • 6.4.15.4 SRFI-18 Time
      • 6.4.15.5 SRFI-18 Exceptions
    • 6.4.16 SRFI-19 - Time/Date Library
      • 6.4.16.1 SRFI-19 Introduction
      • 6.4.16.2 SRFI-19 Time
      • 6.4.16.3 SRFI-19 Date
      • 6.4.16.4 SRFI-19 Time/Date conversions
      • 6.4.16.5 SRFI-19 Date to string
      • 6.4.16.6 SRFI-19 String to date
    • 6.4.17 SRFI-26 - specializing parameters
    • 6.4.18 SRFI-30 - Nested Multi-line Comments
    • 6.4.19 SRFI-31 - A special form `rec' for recursive evaluation
    • 6.4.20 SRFI-34 - Exception handling for programs
    • 6.4.21 SRFI-35 - Conditions
    • 6.4.22 SRFI-37 - args-fold
    • 6.4.23 SRFI-39 - Parameters
    • 6.4.24 SRFI-55 - Requiring Features
    • 6.4.25 SRFI-60 - Integers as Bits
    • 6.4.26 SRFI-61 - A more general cond clause
    • 6.4.27 SRFI-69 - Basic hash tables
      • 6.4.27.1 Creating hash tables
      • 6.4.27.2 Accessing table items
      • 6.4.27.3 Table properties
      • 6.4.27.4 Hash table algorithms
    • 6.4.28 SRFI-88 Keyword Objects
    • 6.4.29 SRFI-98 Accessing environment variables.
  • 6.5 Readline Support
    • 6.5.1 Loading Readline Support
    • 6.5.2 Readline Options
    • 6.5.3 Readline Functions
      • 6.5.3.1 Readline Port
      • 6.5.3.2 Completion
  • 6.6 Value History
  • 6.7 Pretty Printing
  • 6.8 Formatted Output
  • 6.9 File Tree Walk
  • 6.10 Queues
  • 6.11 Streams
  • 6.12 Buffered Input
  • 6.13 Expect
  • 6.14 The Scheme shell (scsh)
  • 6.15 Tracing
• 7 GOOPS
  • 7.1 Quick Start
    • 7.1.1 Methods
    • 7.1.2 User-defined types
    • 7.1.3 Types
  • 7.2 Tutorial
    • 7.2.1 Copyright
    • 7.2.2 Class definition
    • 7.2.3 Instance creation and slot access
    • 7.2.4 Slot description
    • 7.2.5 Inheritance
      • 7.2.5.1 Class hierarchy and inheritance of slots
      • 7.2.5.2 Class precedence list
    • 7.2.6 Generic functions
      • 7.2.6.1 Generic functions and methods
      • 7.2.6.2 Next-method
      • 7.2.6.3 Example
  • 7.3 Reference Manual
    • 7.3.1 Introductory Remarks
      • 7.3.1.1 Metaobjects and the Metaobject Protocol
      • 7.3.1.2 Terminology
    • 7.3.2 Defining New Classes
      • 7.3.2.1 Basic Class Definition
      • 7.3.2.2 Class Options
      • 7.3.2.3 Slot Options
      • 7.3.2.4 Class Definition Internals
      • 7.3.2.5 Customizing Class Definition
      • 7.3.2.6 STKlos Compatibility
    • 7.3.3 Creating Instances
      • 7.3.3.1 Basic Instance Creation
      • 7.3.3.2 Customizing Instance Creation
    • 7.3.4 Accessing Slots
      • 7.3.4.1 Instance Slots
      • 7.3.4.2 Class Slots
      • 7.3.4.3 Handling Slot Access Errors
    • 7.3.5 Creating Generic Functions
      • 7.3.5.1 Basic Generic Function Creation
      • 7.3.5.2 Generic Function Internals
      • 7.3.5.3 Extending Guile's Primitives
    • 7.3.6 Adding Methods to Generic Functions
      • 7.3.6.1 Basic Method Definition
      • 7.3.6.2 Method Definition Internals
    • 7.3.7 Invoking Generic Functions
      • 7.3.7.1 Determining Which Methods to Apply
      • 7.3.7.2 Handling Invocation Errors
    • 7.3.8 Redefining a Class
      • 7.3.8.1 Default Class Redefinition Behaviour
      • 7.3.8.2 Customizing Class Redefinition
    • 7.3.9 Changing the Class of an Instance
    • 7.3.10 Introspection
      • 7.3.10.1 Classes
      • 7.3.10.2 Slots
      • 7.3.10.3 Instances
      • 7.3.10.4 Generic Functions
      • 7.3.10.5 Generic Function Methods
    • 7.3.11 Miscellaneous Functions
      • 7.3.11.1 Administration Functions
      • 7.3.11.2 Error Handling
      • 7.3.11.3 Object Comparisons
      • 7.3.11.4 Cloning Objects
      • 7.3.11.5 Write and Display
  • 7.4 MOP Specification
    • 7.4.1 Class Definition
    • 7.4.2 Instance Creation
    • 7.4.3 Class Redefinition
    • 7.4.4 Method Definition
    • 7.4.5 Generic Function Invocation
• 8 Guile Implementation
  • 8.1 A Brief History of Guile
    • 8.1.1 The Emacs Thesis
    • 8.1.2 Early Days
    • 8.1.3 A Scheme of Many Mantainers
    • 8.1.4 A Timeline of Selected Guile Releases
    • 8.1.5 Status, or: Your Help Needed
  • 8.2 Data Representation in Scheme
    • 8.2.1 A Simple Representation
    • 8.2.2 Faster Integers
    • 8.2.3 Cheaper Pairs
    • 8.2.4 Guile Is Hairier
  • 8.3 The Libguile Runtime Environment
    • 8.3.1 General Rules
    • 8.3.2 Conservative Garbage Collection
    • 8.3.3 Immediates vs Non-immediates
    • 8.3.4 Immediate Datatypes
      • 8.3.4.1 Integers
      • 8.3.4.2 Characters
      • 8.3.4.3 Booleans
      • 8.3.4.4 Unique Values
    • 8.3.5 Non-immediate Datatypes
      • 8.3.5.1 Pairs
      • 8.3.5.2 Vectors, Strings, and Symbols
      • 8.3.5.3 Procedures
      • 8.3.5.4 Closures
      • 8.3.5.5 Subrs
      • 8.3.5.6 Ports
    • 8.3.6 Signalling Type Errors
    • 8.3.7 Unpacking the SCM Type
      • 8.3.7.1 Relationship between SCM and scm_t_bits
      • 8.3.7.2 Immediate objects
      • 8.3.7.3 Non-immediate objects
      • 8.3.7.4 Allocating Cells
      • 8.3.7.5 Heap Cell Type Information
      • 8.3.7.6 Accessing Cell Entries
      • 8.3.7.7 Basic Rules for Accessing Cell Entries
  • 8.4 A Virtual Machine for Guile
    • 8.4.1 Why a VM?
    • 8.4.2 VM Concepts
    • 8.4.3 Stack Layout
    • 8.4.4 Variables and the VM
    • 8.4.5 Compiled Procedures are VM Programs
    • 8.4.6 Instruction Set
      • 8.4.6.1 Environment Control Instructions
      • 8.4.6.2 Branch Instructions
      • 8.4.6.3 Loading Instructions
      • 8.4.6.4 Procedural Instructions
      • 8.4.6.5 Data Control Instructions
      • 8.4.6.6 Miscellaneous Instructions
      • 8.4.6.7 Inlined Scheme Instructions
      • 8.4.6.8 Inlined Mathematical Instructions
      • 8.4.6.9 Inlined Bytevector Instructions
  • 8.5 Compiling to the Virtual Machine
    • 8.5.1 Compiler Tower
    • 8.5.2 The Scheme Compiler
    • 8.5.3 Tree-IL
    • 8.5.4 GLIL
    • 8.5.5 Assembly
    • 8.5.6 Bytecode and Objcode
    • 8.5.7 Writing New High-Level Languages
    • 8.5.8 Extending the Compiler
• 9 Autoconf Support
  • 9.1 Autoconf Background
  • 9.2 Autoconf Macros
  • 9.3 Using Autoconf Macros
  • 9.4 Autofrisk
  • 9.5 Using Autofrisk
• Appendix A GNU Free Documentation License
  • A.0.1 ADDENDUM: How to use this License for your documents
• Concept Index
• Procedure Index
• Variable Index
• Type Index
• R5RS Index