lispdoc - results for progn

(progn &rest forms)
Function: PROGN form* Evaluates each FORM in order, returning the values of the last form. With no forms, returns NIL.
Example:
(defun bst-insert! (obj bst <)
  (if (null bst)
      (make-node :elt obj)
      (progn (bsti obj bst <) bst)))
Mentioned in:
CLtL2 - 11.7. Package System Functions and Variables
CLtL2 - 21.2. Creating New Streams
CLtL2 - 23.2. Opening and Closing Files
CLtL2 - 25.1. The Compiler
CLtL2 - 25.1.2. Compiled Functions
CLtL2 - 25.3. Debugging Tools
CLtL2 - 25.5. Identity Function
CLtL2 - 26.11. Unconditional Execution
CLtL2 - 26.12. Miscellaneous Features
CLtL2 - 26.12.2. Destructuring
CLtL2 - 26.3. Parsing Loop Clauses
CLtL2 - 26.3.1. Order of Execution
CLtL2 - 28.1.7.4. Built-in Method Combination Types
CLtL2 - 28.2. Functions in the Programmer Interface
CLtL2 - 29.4.7. Establishing Restarts
CLtL2 - 4.7. Defining New Type Specifiers
CLtL2 - 5.3. Top-Level Forms
CLtL2 - 5.3.1. Defining Named Functions
CLtL2 - 5.3.3. Control of Time of Evaluation
CLtL2 - 7. Control Structure
CLtL2 - 7.10.1. Constructs for Handling Multiple Values
CLtL2 - 7.10.2. Rules Governing the Passing of Multiple Values
CLtL2 - 7.11. Dynamic Non-Local Exits
CLtL2 - 7.4. Simple Sequencing
CLtL2 - 7.5. Establishing New Variable Bindings
CLtL2 - 7.6. Conditionals
CLtL2 - 7.7. Blocks and Exits
CLtL2 - 7.8. Iteration
CLtL2 - 7.8.2. General Iteration
CLtL2 - 7.8.3. Simple Iteration Constructs
CLtL2 - 8.1. Macro Definition
CLtL2 - 8.3. Destructuring
CLtL2 - 9.1. Declaration Syntax
CLtL2 - 9.2. Declaration Specifiers
CLtL2 - 9.3. Type Declaration for Forms
CLtL2 - A.3.1. Basic Restrictions
CLtL2 - Index
HyperSpec - Special Operator PROGN
On Lisp - A Query Compiler (AQC)
On Lisp - An ATN Compiler
On Lisp - An Interpreter
On Lisp - Anaphoric Variants
On Lisp - Applications for Macros
On Lisp - Avoiding Capture by Prior Evaluation
On Lisp - Common Lisp Implementation
On Lisp - Continuation-Passing Macros
On Lisp - Destructuring in Parameter Lists
On Lisp - Free Symbol Capture
On Lisp - How Macros Work
On Lisp - Macros as Programs
On Lisp - Macros from Functions
On Lisp - Need for Macros
On Lisp - Objects in Plain Lisp
On Lisp - The with- Macro
On Lisp - When Capture Occurs
On Lisp - When Nothing Else Will Do
On Lisp - Why Bother?
PCL - adding inheritance and tagged structures
PCL - cond
PCL - condition handlers
PCL - controlling evaluation
PCL - eval when
PCL - fixing the return value
PCL - foo special operators
PCL - macro expansion time vs runtime
PCL - other method combinations
PCL - other special operators
PCL - primitive binary types
PCL - reading binary objects
PCL - refactoring
PCL - the implementation
PCL - the public api
PCL - when and unless
Successful Lisp - chapter09
Successful Lisp - lesson 9
Successful Lisp - tail recursion