
- LISP Tutorial
- LISP - Home
- LISP - Overview
- LISP - Environment
- LISP - REPL
- LISP - Program Structure
- LISP - Basic Syntax
- LISP - Data Types
- Lisp Macros
- LISP - Macros
- LISP - Backquote and Comma
- LISP - Code Generation Using Macro
- LISP - Variable Capture and Hygienic macro
- LISP - Scope and Binding
- LISP - Macro Writing Style
- LISP - Macro Characters
- LISP - Read-Time Macros
- LISP - Compiler Macros
- LISP - Uses of Macros
- Lisp Functions
- LISP - Functions
- LISP - Functions vs Macros
- LISP - Calling Function using funcall
- LISP - Calling Function using apply
- LISP - Closures
- LISP - Functions as Arguments
- LISP - Functions as Return Values
- LISP - Recursion
- LISP - Built-in Functions
- Lisp Predicates
- LISP - Predicates
- LISP - Generic Data Type Predicates
- LISP - Specific Data Type Predicates
- LISP - Equality Predicates
- LISP - Numeric Predicates
- LISP - Comparison Predicates
- LISP - Logical Predicates
- LISP - List Predicates
- LISP - Custom Predicates
- LISP - Chaining Predicates
- Lisp Arrays
- LISP - Arrays
- LISP - Adjustable Arrays
- LISP - Fill Pointers in Arrays
- LISP - Specialized Arrays
- LISP - Arrays Properties
- LISP - Iterating over Arrays
- LISP - Multidimensional Arrays
- LISP - Row-Major Order
- Lisp Strings
- LISP - Strings
- LISP - String Concatenation
- LISP - String Comparison
- LISP - String Case Conversion
- LISP - String Trimmimg
- LISP - String Searching
- LISP - Getting Substring
- LISP - String Replacement
- LISP - Sorting Strings
- LISP - Merging Strings
- LISP - Accessing Characters of String
- LISP - String length
- LISP - Escape Sequences
- Lisp Sequences
- LISP - Sequences
- LISP - Accessing Element of Sequence
- LISP - Sequence length
- LISP - Getting Subsequence
- LISP - Search Element in Sequence
- LISP - Sequence Concatenation
- LISP - Reversing a Sequence
- LISP - Mapping Sequence Element
- LISP - position of Element
- LISP - Remove an Element
- LISP - Sort Sequence
- LISP - Merge Sequences
- LISP - every function
- LISP - some function
- LISP - notany function
- LISP - notevery function
- Lisp Lists
- LISP - Lists
- LISP - Accessing Elements of Lists
- LISP - Modifications to Lists
- LISP - Using mapcar on List
- LISP - Using mapc on List
- LISP - Using reduce on List
- LISP - Removing elements from List
- LISP - Reversing a List
- LISP - Sorting a List
- LISP - Searching a List
- LISP - List vs Vectors
- LISP - Matrix Multiplication
- Lisp Vectors
- LISP - Vectors
- LISP - Creating Vectors
- LISP - Accessing Elements of Vectors
- LISP - Modifications to Vectors
- LISP - Adjustable Vectors
- LISP - Specialized Vectors
- LISP - Vector Functions
- Lisp Set
- LISP - Set
- LISP - Adding elements to the Set
- LISP - Getting SubSet from a Set
- LISP - Set Difference
- LISP - Set Exclusive OR
- LISP - Set Intersection
- LISP - Set Union
- LISP - Representing Set with HashTable
- LISP - List as Set vs HashTable as Set
- Lisp Tree
- LISP - Tree
- LISP - Recursive Traversal
- LISP - Inorder Traversal
- LISP - Preorder Traversal
- LISP - Postorder Traversal
- LISP - Depth First Traversal
- LISP - Modifying Tree
- LISP - Search Tree
- LISP - Binary Tree
- Lisp Hash Table
- LISP - Hash Table
- Adding Values to Hash Table
- Removing Values from Hash Table
- Updating Values of Hash Table
- Iterating Hash Table Entries
- Searching key in HashTable
- Checking Size of HashTable
- Using Custom Equality Check
- Lisp - Input − Output
- LISP - Input − Output
- LISP - Streams
- LISP - Reading Data from Streams
- LISP - Writing Data to Streams
- LISP - File I/O
- LISP - String I/O
- LISP - Formatting with Format
- LISP - Interactive I/O
- LISP - Error Handling
- LISP - Binary I/O
- Lisp - Structures
- LISP - Structures
- LISP - Accessors and Mutators
- LISP - Structure Options
- LISP - Structure Types
- LISP - Applications and Best Practices
- Lisp - CLOS
- LISP - CLOS
- Lisp - Objects
- LISP - Class
- LISP - Slots and Accessors
- LISP - Generic Functions
- LISP - Class Precedence
- LISP - Metaobject Protocol
- LISP - Multimethods
- LISP - Multiple Inheritance
- LISP - Method Combinations
- LISP - Method Combinations
- LISP - :before Method Combination
- LISP - :primary Method Combination
- LISP - :after Method Combination
- LISP - :around Method Combination
- LISP - + Method Combination
- LISP - and Method Combination
- LISP - append Method Combination
- LISP Useful Resources
- Lisp - Quick Guide
- Lisp - Useful Resources
- Lisp - Discussion
Lisp - Variable Capture and Hygienic Macros
A Variable Capture is a problem which occurs when a Macro introduces a variable of same name as that passed as an argument leading to unintentional result. A macros facing such variable capture is termed as unhygienic macro. LISP provides multiple ways to sort variable capture problem. In this chapter, we'll explore variable capture and writing hygienic macros with examples.
Example - Variable Capture in Macro
main.lisp
; define a macro to swap two numbers (defmacro swap (x y) `(let ((temp ,x)) ; variable capturing occurs when x is passed as temp (setf ,x ,y) (setf ,y temp))) ; define two variables temp and my-var (let ((temp 1) (my-var 2)) (swap temp my-var) ; swap macro unintentionally uses local temp over passed argument temp (print temp) ; temp is not modified (print my-var)) ; my-var is not modified
Output
When you execute the code, it returns the following result −
1 2
Explanation
(defmacro swap (x y) − macro swap is defined using defmacro with arguments x and y
`(...,) − a template is created using backquote and using comma, value of x will be inserted in the template.
(let ((temp ,x)) − a local variable temp is created, with value of x
(setf ,x ,y) − value of x is replaced with value of y
(setf ,y ,temp) − value of y is replaced with value of temp thus swapping the numbers
(let ((temp 1) (my-var 2)) − local variable temp and my-var are initialized with 1 and 2 respectively.
(swap temp my-var) − macro will replace the code with temp and var as passed arguments. As temp is already present in local scope, passed argument is not used.
(print temp) − prints the unmodified value of temp variable.
(print my-var) − prints the unmodified value of my-var variable.
Example - Hygienic Macro
In order to solve variable capture problem, we can use gensym function to generate the unique symbol for the local variable of macro. In above code we can replace `(let ((temp ,x)) with (let ((temp (gensym))) `(let ((,temp ,x)) so that temp variable in renamed to a unique name in macro as shown in example below.
main.lisp
; define a macro to swap two numbers (defmacro swap (x y) (let ((temp (gensym))) ; create a unique variable `(let ((,temp ,x)) ; insert the unique variable and value of x (setf ,x ,y) (setf ,y ,temp)))) (let ((temp 1) (my-var 2)) (swap temp my-var) ; swap macro correctly uses passed temp argument (print temp) (print my-var))
Output
When you execute the code, it returns the following result −
2 1
Explanation
(defmacro swap (x y) − macro swap is defined using defmacro with arguments x and y
-
(let ((temp (gensym)))− creates a temp variable appended with a unique symbol say 123, as temp123.
`(...,) − a template is created using backquote and using comma, value of x will be inserted in the template.
(let ((,temp ,x)) − a variable temp is inserted a new variable name created using gensym, with value of x
(setf ,x ,y) − value of x is replaced with value of y
(setf ,y ,temp) − value of y is replaced with value of temp thus swapping the numbers
(let ((temp 1) (my-var 2)) − local variable temp and my-var are initialized with 1 and 2 respectively.
(swap temp my-var) − macro will replace the code with temp and var as passed arguments. As temp is not present in local scope now, passed argument is used.
(print temp) − prints the modified value of temp variable.
(print my-var) − prints the modified value of my-var variable.