Draft Proposed American National Standard for Information Systems—Programming Language—Common Lisp

---

SOME OF THE BOOK CONTENTS

• Symbols Naming Both Lexical and Dynamic Variables — discussion of symbols that reference both lexical and dynamic bindings
• Conses as Forms — overview of cons cells used as evaluable forms
  • Special Forms — language-defined forms evaluated in special ways
  • Macro Forms — forms expanded by macros before evaluation
  • Function Forms — expressions treated as function calls
  • Lambda Forms — anonymous function representations
• Self-Evaluating Objects — objects that evaluate to themselves
  • Examples of Self-Evaluating Objects — numbers, strings, characters, etc.
• Lambda Expressions — syntax and semantics of lambda constructs
• Closures and Lexical Binding — how functions capture lexical environments
• Shadowing — when one variable or function name hides another
• Extent — explanation of dynamic vs. lexical extent
• Return Values — rules governing return values in expressions
• Compilation — how code is compiled in the system
  • Compiler Terminology — definitions of compiler-related concepts
  • Compilation Semantics — behavior of compiled forms
    • Compiler Macros — macros used specifically during compilation
      • Purpose of Compiler Macros
      • Naming of Compiler Macros
      • When Compiler Macros Are Used
      • Notes on the Implementation of Compiler Macros
    • Minimal Compilation — requirements for minimal compilation behavior
    • Semantic Constraints — restrictions on compilation semantics
  • File Compilation — processing of whole files during compilation
    • Processing of Top-Level Forms
      • Processing of Defining Macros
      • Constraints on Macros and Compiler Macros
  • Literal Objects in Compiled Files — treatment of literal data
    • Externalizable Objects — which objects can be externalized
    • Similarity of Literal Objects — rules about object identity
      • Similarity of Aggregate Objects
      • Definition of Similarity
    • Extensions to Similarity Rules
    • Additional Constraints on Externalizable Objects
  • Exceptional Situations in the Compiler — errors and edge cases
• Declarations — how declarations influence compilation and execution
  • Minimal Declaration Processing Requirements
  • Declaration Specifiers — types of declarations
  • Declaration Identifiers
    • Shorthand Notation for Type Declarations
  • Declaration Scope — where declarations apply
    • Examples of Declaration Scope
• Lambda Lists — syntax structure for parameter lists
  • Ordinary Lambda Lists
    • Specifiers for Required Parameters

Book Description

The ANSI Common Lisp Standard (Draft Version 15.17R, X3J13/94-101R) is more than just a dense documentit’s the backbone for understanding how Common Lisp operates. This draft version is packed with technical details, precise definitions, and all the nitty-gritty that programmers (and language lovers) crave. Whether you’re a student, a professional developer, or just a curious soul who likes to know how things work under the hood, this standard gives you an unfiltered look at Common Lisp’s design. It’s not exactly light reading, but if you’ve ever wondered why Lisp does what it does, this is where you’ll find your answers.

Book Overview

So, what’s inside? The ANSI Common Lisp Standard isn’t just a bunch of rulesit’s a living history of programming wisdom. This draft version captures discussions and decisions made by the X3J13 committee, who basically shaped the way modern Lisp looks today. You’ll find everything from data types and control structures to error handling and macros. If you’re thinking it sounds a bit nerdy, you’re right! But hey, isn’t that what makes it awesome? The document is organized into sections that build up from basic concepts to more advanced features. You’ll get clear explanations (well, as clear as standards documents get), references to earlier drafts, and enough footnotes to keep any detail-oriented reader happy.

Why Read This Book

Let’s be honestmost people don’t read programming standards for fun. But if you’re the kind of person who wants to truly understand why your code works (or doesn’t), this draft is pure gold. Reading through it can feel like stepping into a time machine back to when programming languages were being carefully crafted by passionate experts. You’ll pick up insights that go way beyond what most tutorials or textbooks ever mention. Plus, knowing the standard means you’ll be able to write more robust code and maybe even impress your colleagues at your next team meeting. Who wouldn’t want that?

Who This Book Is For

If you’re new to Lisp and want to get serious about learning it right, this standard will become your best friend (or maybe your frenemy on tough days). Experienced programmers will appreciate its depth and attention to detailespecially those who love geeking out over language specs. It’s also perfect for computer science students tackling advanced courses or anyone working on projects that need strict adherence to language standards. Even if you don’t plan on memorizing every section (who does?), having this draft handy is like having an expert sitting next to you.

What You Will Learn

• The official syntax and semantics of Common Lisp
• How data types and control structures are defined and used
• The philosophy behind key design decisions in the language
• Error handling mechanisms and best practices in Lisp
• Advanced topics like macros and object-oriented features
• The historical context behind the evolution of Lisp standards
• How to write code that’s portable across different implementations
• Tons of quirky details only true language fans would appreciate

Report Broken Link

File Copyright Claim