
- 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 - Packages
In general term of programming languages, a package is designed for providing a way to keep one set of names separate from another. The symbols declared in one package will not conflict with the same symbols declared in another. This way packages reduce the naming conflicts between independent code modules.
The LISP reader maintains a table of all the symbols it has found. When it finds a new character sequence, it creates a new symbol and stores in the symbol table. This table is called a package.
The current package is referred by the special variable *package*.
There are two predefined packages in LISP −
common-lisp − it contains symbols for all the functions and variables defined.
common-lisp-user − it uses the common-lisp package and all other packages with editing and debugging tools; it is called cl-user in short
Package Functions in LISP
The following table provides most commonly used functions used for creating, using and manipulating packages −
Sr.No. | Function and Description |
---|---|
1 |
make-package package-name &key :nicknames :use It creates and returns a new package with the specified package name. |
2 |
in-package package-name &key :nicknames :use Makes the package current. |
3 |
in-package name This macro causes *package* to be set to the package named name, which must be a symbol or string. |
4 |
find-package name It searches for a package. The package with that name or nickname is returned; if no such package exists, find-package returns nil. |
5 |
rename-package package new-name &optional new-nicknames it renames a package. |
6 |
list-all-packages This function returns a list of all packages that currently exist in the Lisp system. |
7 |
delete-package package It deletes a package. |
Creating a LISP Package
The defpackage function is used for creating an user defined package. It has the following syntax −
(defpackage :package-name (:use :common-lisp ...) (:export :symbol1 :symbol2 ...) )
Where,
package-name is the name of the package.
The :use keyword specifies the packages that this package needs, i.e., packages that define functions used by code in this package.
The :export keyword specifies the symbols that are external in this package.
The make-package function is also used for creating a package. The syntax for this function is −
make-package package-name &key :nicknames :use
The arguments and keywords has same meaning as before.
Using a Package
Once you have created a package, you can use the code in this package, by making it the current package. The in-package macro makes a package current in the environment.
Example
Create a new source code file named main.lisp and type the following code in it.
main.lisp
; create a package tom (make-package :tom) ; create a package dick (make-package :dick) ; create a package harry (make-package :harry) ; go to package tom (in-package tom) ; define a function hello in package tom (defun hello () (write-line "Hello! This is Tom's Tutorials Point") ) ; go to package dick (in-package dick) ; define a function hello in package dick (defun hello () (write-line "Hello! This is Dick's Tutorials Point") ) ; go to package harry (in-package harry) ; define a function hello in package harry (defun hello () (write-line "Hello! This is Harry's Tutorials Point") ) ; go to package tom (in-package tom) ; call hello function (hello) ; go to package dick (in-package dick) ; call hello function (hello) ; go to package harry (in-package harry) ; call hello function (hello)
Output
When you execute the code, it returns the following result −
Hello! This is Tom's Tutorials Point Hello! This is Dick's Tutorials Point Hello! This is Harry's Tutorials Point
Deleting a Package
The delete-package macro allows you to delete a package. The following example demonstrates this −
Example
Create a new source code file named main.lisp and type the following code in it.
main.lisp
; create a package tom (make-package :tom) ; create a package dick (make-package :dick) ; create a package harry (make-package :harry) ; go to package tom (in-package tom) ; create a function hello (defun hello () (write-line "Hello! This is Tom's Tutorials Point") ) ; go to package dick (in-package dick) ; define a function hello (defun hello () (write-line "Hello! This is Dick's Tutorials Point") ) ; go to package harry (in-package harry) ; define a function hello (defun hello () (write-line "Hello! This is Harry's Tutorials Point") ) ; go to package tom (in-package tom) ; call hello function (hello) ; go to package dick (in-package dick) ; call hello function (hello) ; go to package harry (in-package harry) ; call hello function (hello) ; delete package tom (delete-package tom) ; go to package tom (in-package tom) ; call hello function (hello)
Output
When you execute the code, it returns the following result −
Hello! This is Tom's Tutorials Point Hello! This is Dick's Tutorials Point Hello! This is Harry's Tutorials Point *** - EVAL: variable TOM has no value