Guile Reference Manual

$Id: guile.texi,v 1.15 2002/03/16 13:51:03 ossau Exp $

For use with Guile

• Preface
  • The Guile License
• The Guile License
  • Layout of this Manual
• Layout of this Manual
  • Manual Conventions
• Conventions used in this Manual
• What is Guile?
• A Whirlwind Tour
  • Running Guile Interactively
  • Guile Scripts
    • The Top of a Script File
    • Scripting Examples
  • Linking Programs With Guile
    • Guile Initialization Functions
    • A Sample Guile Main Program
  • Writing Extensions for Guile
    • A Sample Guile Extension
  • Guile Modules
    • Intro to Using Existing Modules
    • Intro to Writing New Modules
    • Intro to Modules and Extensions
• Obtaining and Installing Guile
  • The Basic Guile Package
  • Packages not shipped with Guile
• Reporting Bugs
• Part II: Programming with Guile
• An Overview of Guile Programming
  • Example: Using Guile for an Application Testbed
  • A Choice of Programming Options
    • What Functionality is Already Available?
    • Functional and Performance Constraints
    • Your Preferred Programming Style
    • What Controls Program Execution?
  • How About Application Users?
• Introduction to Guile Scheme
  • Layout
• Basic Ideas in Scheme
  • Data Types, Values and Variables
    • Latent Typing
    • Values and Variables
    • Defining and Setting Variables
  • The Representation and Use of Procedures
    • Procedures as Values
    • Simple Procedure Invocation
    • Creating and Using a New Procedure
    • Lambda Alternatives
  • Expressions and Evaluation
    • Evaluating Expressions and Executing Programs
      • Evaluating Literal Data
      • Evaluating a Variable Reference
      • Evaluating a Procedure Invocation Expression
      • Evaluating Special Syntactic Expressions
    • Using the Guile REPL
    • Summary of Common Syntax
  • The Concept of Closure
    • Names, Locations, Values and Environments
    • Local Variables and Environments
    • Environment Chaining
    • Lexical Scope
      • An Example of Non-Lexical Scoping
    • Closure
    • Example 1: A Serial Number Generator
    • Example 2: A Shared Persistent Variable
    • Example 3: The Callback Closure Problem
    • Example 4: Object Orientation
• Guile Scripting
  • Invoking Guile
  • The Meta Switch
• Handling Command Line Options and Arguments
  • Using Command Line Arguments
  • The (ice-9 getopt-long) Module
    • A Short getopt-long Example
    • How to Write an Option Specification
    • Expected Command Line Format
    • Reference Documentation for getopt-long
    • Reference Documentation for option-ref
• Using Guile as an Extension Language
• Overview of the Guile API
  • Identical Function in both Scheme and C
    • Transforming Scheme name to C name
    • Structuring argument lists for C functions
  • Elements Available Only in C
  • Elements Available Only in Scheme
• Data Representation in Guile
  • Data Representation in Scheme
    • A Simple Representation
    • Faster Integers
    • Cheaper Pairs
    • Guile Is Hairier
  • How Guile does it
    • General Rules
    • Conservative Garbage Collection
    • Immediates vs Non-immediates
    • Immediate Datatypes
      • Integers
      • Characters
      • Booleans
      • Unique Values
    • Non-immediate Datatypes
      • Pairs
      • Vectors, Strings, and Symbols
      • Procedures
      • Closures
      • Subrs
      • Ports
    • Signalling Type Errors
    • Unpacking the SCM Type
      • Relationship between SCM and scm_t_bits
      • Immediate objects
      • Non-immediate objects
      • Allocating Cells
      • Heap Cell Type Information
      • Accessing Cell Entries
      • Basic Rules for Accessing Cell Entries
  • Defining New Types (Smobs)
    • Describing a New Type
    • Creating Instances
    • Type checking
    • Garbage Collecting Smobs
    • A Common Mistake In Allocating Smobs
    • Garbage Collecting Simple Smobs
    • A Complete Example
• GH: A Portable C to Scheme Interface
  • Why the GH Interface is Now Deprecated
  • gh preliminaries
  • Data types and constants defined by gh
  • Starting and controlling the interpreter
  • Error messages
  • Executing Scheme code
  • Defining new Scheme procedures in C
  • Converting data between C and Scheme
    • C to Scheme
    • Scheme to C
  • Type predicates
  • Equality predicates
  • Memory allocation and garbage collection
  • Calling Scheme procedures from C
  • Mixing gh and scm APIs
  • Transitioning to the scm Interface
• Debugger User Interface
  • Single-Step
  • Trace
  • Backtrace
  • Stacks and Frames
• Autoconf Support
  • Autoconf Background
  • Autoconf Macros
  • Using Autoconf Macros
  • Autofrisk
  • Using Autofrisk
• Miscellaneous Tools
  • Snarfing
    • Init Snarfing with guile-snarf
      • How guile-snarf works
      • Macros guile-snarf recognizes
    • Doc Snarfing
  • Executable Modules
    • Writing Executable Modules
• Further Reading
• Part III: Guile API Reference
• Simple Generic Data Types
  • Booleans
  • Numerical data types
    • Scheme's Numerical "Tower"
    • Integers
    • Real and Rational Numbers
    • Complex Numbers
    • Exact and Inexact Numbers
    • Read Syntax for Numerical Data
    • Operations on Integer Values
    • Comparison Predicates
    • Converting Numbers To and From Strings
    • Complex Number Operations
    • Arithmetic Functions
    • Scientific Functions
    • Primitive Numeric Functions
    • Bitwise Operations
    • Random Number Generation
  • Characters
  • Strings
    • String Read Syntax
    • String Predicates
    • String Constructors
    • List/String conversion
    • String Selection
    • String Modification
    • String Comparison
    • String Searching
    • Alphabetic Case Mapping
    • Appending Strings
  • Regular Expressions
    • Regexp Functions
    • Match Structures
    • Backslash Escapes
  • Symbols
    • Extended Read Syntax for Symbols
    • Operations Related to Symbols
    • Using Symbols as Discrete Values
    • Function Slots and Property Lists
    • Uninterned Symbols
  • Keywords
    • Why Use Keywords?
    • Coding With Keywords
    • Keyword Read Syntax
    • Keyword Procedures
    • Keyword Primitives
  • "Functionality-Centric" Data Types
• Compound Data Types
  • Pairs
  • Lists
    • List Read Syntax
    • List Predicates
    • List Constructors
    • List Selection
    • Append and Reverse
    • List Modification
    • List Searching
    • List Mapping
  • Vectors
    • Vector Read Syntax
    • Vector Predicates
    • Vector Constructors
    • Vector Modification
    • Vector Selection
  • Records
  • Structures
    • Structure Concepts
    • Structure Layout
    • Structure Basics
    • Vtables
  • Arrays
    • Conventional Arrays
    • Array Mapping
    • Uniform Arrays
    • Bit Vectors
  • Association Lists and Hash Tables
    • Dictionary Types
    • Association Lists
      • Alist Key Equality
      • Adding or Setting Alist Entries
      • Retrieving Alist Entries
      • Removing Alist Entries
      • Sloppy Alist Functions
      • Alist Example
    • Hash Tables
      • Hash Table Examples
      • Hash Table Reference
• Procedures and Macros
  • Lambda: Basic Procedure Creation
  • Optional Arguments
    • let-optional Reference
    • let-keywords Reference
    • lambda* Reference
    • define* Reference
  • Procedure Properties and Meta-information
  • Procedures with Setters
  • Lisp Style Macro Definitions
  • The R5RS syntax-rules System
    • The syntax-rules Pattern Language
    • Top Level Syntax Definitions
    • Local Syntax Definitions
  • Support for the syntax-case System
  • Internal Representation of Macros and Syntax
• General Utility Functions
  • Equality
  • Object Properties
    • Low Level Property Implementation.
    • An Older Approach to Properties
  • Sorting
  • Copying Deep Structures
  • General String Conversion
  • Hooks
    • Hook Usage by Example
    • Hook Reference
    • Hooks For C Code.
    • Hooks Provided by Guile
      • Hooks for Garbage Collection
      • Hooks into the Guile REPL
• Definitions and Variable Bindings
  • Top Level Variable Definitions
  • Local Variable Bindings
  • Internal definitions
  • Querying variable bindings
• Controlling the Flow of Program Execution
  • Evaluating a Sequence of Expressions
  • Simple Conditional Evaluation
  • Conditional Evaluation of a Sequence of Expressions
  • Iteration mechanisms
  • Continuations
  • Returning and Accepting Multiple Values
  • Exceptions
    • Exception Terminology
    • Catching Exceptions
    • Throwing Exceptions
    • Catch Without Unwinding
    • How Guile Implements Exceptions
  • Procedures for Signaling Errors
  • Dynamic Wind
  • How to Handle Errors in C Code
    • C Support
• Input and Output
  • Ports
  • Reading
  • Writing
  • Closing
  • Random Access
  • Line Oriented and Delimited Text
  • Block reading and writing
  • Default Ports for Input, Output and Errors
  • Types of Port
    • File Ports
    • String Ports
    • Soft Ports
    • Void Ports
  • Using and Extending Ports in C
    • C Port Interface
      • Port basics
      • Port buffers
      • The rw_random flag
      • The rw_active variable
      • Reading from a port.
      • Writing to a port.
    • Port Implementation
• Reading and Evaluating Scheme Code
  • Scheme Syntax: Standard and Guile Extensions
    • Expression Syntax
    • Comments
    • Block Comments
    • Case Sensitivity
    • Keyword Syntax
    • Reader Extensions
  • Reading Scheme Code
  • Procedures for On the Fly Evaluation
  • Loading Scheme Code from File
  • Delayed Evaluation
  • Local Evaluation
  • Evaluator Behaviour
• Memory Management and Garbage Collection
  • Garbage Collection
  • Memory Blocks
    • Upgrading from scm_must_malloc et al
  • Weak References
    • Weak key hashes
    • Weak vectors
  • Guardians
• Objects
• Modules
  • Scheme and modules
  • The Guile module system
    • General Information about Modules
    • Using Guile Modules
    • Creating Guile Modules
    • More Module Procedures
    • Module System Quirks
    • Included Guile Modules
  • Dynamic Libraries
    • Low level dynamic linking
    • Putting Compiled Code into Modules
    • Dynamic Linking and Compiled Code Modules
  • Variables
• Threads, Mutexes, Asyncs and Dynamic Roots
  • Arbiters
  • Asyncs
  • Dynamic Roots
  • Threads
    • Low level thread primitives
    • Higher level thread procedures
  • Fluids
• Runtime Options and Configuration
  • General option interface
  • Reader options
  • Printing options
  • Evaluator options
  • Evaluator trap options
  • Debugger options
  • Examples of option use
  • Installation and Configuration Data
  • Feature Tracking
    • Feature Manipulation
    • Common Feature Symbols
• Support for Translating Other Languages
  • Emacs Lisp Support
• Internal Debugging Interface
• Deprecated
• SLIB
  • SLIB installation
  • JACAL
• POSIX System Calls and Networking
  • POSIX Interface Conventions
  • Ports and File Descriptors
  • File System
  • User Information
  • Time
  • Runtime Environment
  • Processes
  • Signals
  • Terminals and Ptys
  • Pipes
  • Networking
    • Network Address Conversion
      • IPv4 Address Conversion
      • IPv6 Address Conversion
    • Network Databases
      • The Host Database
      • The Network Database
      • The Protocol Database
      • The Service Database
    • Network Sockets and Communication
  • System Identification
  • Locales
  • Encryption
• SRFI Support Modules
  • About SRFI Usage
  • SRFI-0 - cond-expand
  • SRFI-1 - List library
    • Constructors
    • Predicates
    • Selectors
    • Length, Append, Concatenate, etc.
    • Fold, Unfold & Map
    • Filtering and Partitioning
    • Searching
    • Deleting
    • Association Lists
    • Set Operations on Lists
  • SRFI-2 - and-let*
  • SRFI-4 - Homogeneous numeric vector datatypes.
    • SRFI-4 - Read Syntax
    • SRFI-4 Procedures
  • SRFI-6 - Basic String Ports
  • SRFI-8 - receive
  • SRFI-9 - define-record-type
  • SRFI-10 - Hash-Comma Reader Extension
  • SRFI-11 - let-values
  • SRFI-13 - String Library
    • Loading SRFI-13
    • Predicates
    • Constructors
    • List/String Conversion
    • Selection
    • Modification
    • Comparison
    • Prefixes/Suffixes
    • Searching
    • Alphabetic Case Mapping
    • Reverse/Append
    • Fold/Unfold/Map
    • Replicate/Rotate
    • Miscellaneous
    • Filtering/Deleting
  • SRFI-14 - Character-set Library
    • Loading SRFI-14
    • Character Set Data Type
    • Predicates/Comparison
    • Iterating Over Character Sets
    • Creating Character Sets
    • Querying Character Sets
    • Character-Set Algebra
    • Standard Character Sets
  • SRFI-16 - case-lambda
  • SRFI-17 - Generalized set!
  • SRFI-19 - Time/Date Library
    • SRFI-19 Constants
    • SRFI-19 Current time and clock resolution
    • SRFI-19 Time object and accessors
    • SRFI-19 Time comparison procedures
    • SRFI-19 Time arithmetic procedures
    • SRFI-19 Date object and accessors
    • SRFI-19 Time/Date/Julian Day/Modified Julian Day converters
    • SRFI-19 Date to string/string to date converters
• Readline Support
  • Loading Readline Support
  • Readline Options
• Value History
• Pretty Printing
• Formatted Output
• The Rx Regular Expression Library
• Expect
• The Scheme shell (scsh)
• Concept Index
• Procedure Index
• Variable Index
• Type Index
• R5RS Index
• Guile Extensions Index

This document was generated on 26 March 2002 using texi2html 1.56k.