SGI Freeware 2001 May/SGI Freeware 2001 May - Disc 3.iso/dist/fw_elisp-intro.idb/usr/freeware/info/emacs-lisp-intro.info-1.z/emacs-lisp-intro.info-1

GNU Info File | 1998-10-28 | 47.7 KB | 1,126 lines

This is Info file emacs-lisp-intro.info, produced by Makeinfo version
1.67 from the input file emacs-lisp-intro.texi.

   This is an introduction to `Programming in Emacs Lisp', for people
who are not programmers.

   Edition 1.05, 21 October 1997

   Copyright (C) 1990, '91, '92, '93, '94, '95, '97 Free Software
Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "Copying" and "GNU General Public License"
are included exactly as in the original, and provided that the entire
resulting derived work is distributed under the terms of a permission
notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Free Software Foundation.


File: emacs-lisp-intro.info,  Node: Top,  Next: Preface,  Prev: (dir),  Up: (dir)

   This master menu first lists each chapter and index; then it lists
every node in every chapter.

* Menu:

* Preface::                     What to look for.
* List Processing::             What is Lisp?
* Practicing Evaluation::       Running several programs.
* Writing Defuns::              How to write function definitions.
* Buffer Walk Through::         Exploring a few buffer-related functions.
* More Complex::                A few, even more complex functions.
* Narrowing & Widening::        Restricting your and Emacs attention to
                                a region.
* car cdr & cons::              Fundamental functions in Lisp.
* Cutting & Storing Text::      Removing text and saving it.
* List Implementation::         How lists are implemented in the computer.
* Yanking::                     Pasting stored text.
* Loops & Recursion::           How to repeat a process.
* Regexp Search::               Regular expression searches.
* Counting Words::              A review of repetition and regexps.
* Words in a defun::            Counting words in a `defun'.
* Readying a Graph::            A prototype graph printing function.
* Emacs Initialization::        How to write a `.emacs' file.
* Debugging::                   How to run the Emacs Lisp debuggers.
* Conclusion::                  Now you have the basics.
* the-the::                     An appendix: how to find reduplicated words.
* Kill Ring::                   An appendix: how the kill ring works.
* Full Graph::                  How to create a graph with labelled axes.
* Index::
* About the Author::

 -- The Detailed Node Listing --

Preface

* On Reading this Text::        Read, gain familiarity, pick up habits....
* Who You Are::                 For whom this is written.
* Lisp History::
* Note for Novices::            You can read this as a novice.
* Thank You::

List Processing

* Lisp Lists::                  What are lists?
* Run a Program::               Any list in Lisp is a program ready to run.
* Making Errors::               Generating an error message.
* Names & Definitions::         Names of symbols and function definitions.
* Lisp Interpreter::            What the Lisp interpreter does.
* Evaluation::                  Running a program.
* Variables::                   Returning a value from a variable.
* Arguments::                   Passing information to a function.
* set & setq::                  Setting the value of a variable.
* Summary::                     The major points.
* Error Message Exercises::

Lisp Lists

* Lisp Atoms::                  Elemental entities.
* Whitespace in Lists::         Formating lists to be readable.
* Typing Lists::                How GNU Emacs helps you type lists.

The Lisp Interpreter

* Byte Compiling::              Specially processing code for speed.

Evaluation

* Evaluating Inner Lists::      Lists within lists...

Variables

* Void Variable::               The error message for a symbol without a value.

Arguments

* Data types::                  Types of data passed to a function.
* Args as Variable or List::    An argument can be the value
                                of a variable or list.
* Variable Number of Arguments::  Some functions may take a
                                variable number of arguments.
* Wrong Type of Argument::      Passing an argument of the wrong type
                                to a function.
* message::                     A useful function for sending messages.

Setting the Value of a Variable

* Using set::                   Setting values.
* Using setq::                  Setting a quoted value.
* Counting::                    Using `setq' to count.

Practicing Evaluation

* How to Evaluate::             Typing editing commands or `C-x C-e'
                                causes evaluation.
* Buffer Names::                Buffers and files are different.
* Getting Buffers::             Getting a buffer itself, not merely its name.
* Switching Buffers::           How to change to another buffer.
* Buffer Size & Locations::     Where point is located and the size of
                                the buffer.
* Evaluation Exercise::

How To Write Function Definitions

* Primitive Functions::         Some functions are written in C.
* defun::                       The `defun' special form.
* Install::                     Install a Function Definition.
* Interactive::                 Making a function interactive.
* Interactive Options::         Different options for `interactive'.
* Permanent Installation::      Installing code permanently.
* let::                         Creating and initializing local variables.
* if::                          What if?
* else::                        If-then-else expressions.
* Truth & Falsehood::           What Lisp considers false and true.
* save-excursion::              Keeping track of point, mark, and buffer.
* Review::
* defun Exercises::

Install a Function Definition

* Change a defun::              How to change a function definition.

Make a Function Interactive

* multiply-by-seven in detail::  The interactive version.

`let'

* Parts of let Expression::
* Sample let Expression::
* Uninitialized let Variables::

The `if' Special Form

* type-of-animal in detail::    An example of an `if' expression.

`save-excursion'

* Template for save-excursion::  One slot to fill in.

A Few Buffer-Related Functions

* Finding More::                How to find more information.
* simplified-beginning-of-buffer::  Shows `goto-char',
                                `point-min', and `push-mark'.
* mark-whole-buffer::           Almost the same as `beginning-of-buffer'.
* append-to-buffer::            Uses `save-excursion' and
                                `insert-buffer-substring'.
* Buffer Related Review::       Review.
* Buffer Exercises::

The Definition of `mark-whole-buffer'

* Body of mark-whole-buffer::   Only three lines of code.

The Definition of `append-to-buffer'

* append interactive::          A two part interactive expression.
* append-to-buffer body::       Incorporates a `let' expression.
* append save-excursion::       How the `save-excursion' works.

A Few More Complex Functions

* copy-to-buffer::              With `set-buffer', `get-buffer-create'.
* insert-buffer::               Read-only, and with `or'.
* beginning-of-buffer::         Shows `goto-char',
                                `point-min', and `push-mark'.
* Second Buffer Related Review::
* &optional Exercise ::

The Definition of `insert-buffer'

* insert interactive expression::  A read-only situation.
* insert-buffer body::          The body has an `or' and a ` let'.
* if & or::                     Using an `if' instead of an `or'.
* insert or::                   How the  `or' expression works.
* insert let::                  Two `save-excursion' expressions.

The Interactive Expression in `insert-buffer'

* read-only buffer::
* b for interactive::

Complete Definition of `beginning-of-buffer'

* Optional Arguments::
* beginning-of-buffer opt arg::  Example with optional argument.
* beginning-of-buffer complete::

`beginning-of-buffer' with an Argument

* large-case::                  Division and multiplication in a large buffer.
* small-case::                  Functions embedded in parentheses.

Narrowing and Widening

* narrowing advantages::        The Advantages of Narrowing
* save-restriction::            The `save-restriction' special form.
* what-line::                   The number of the line that point is on.
* narrow Exercise::

`car', `cdr', `cons': Fundamental Functions

* Strange Names::               An historical aside: why the strange names?
* car & cdr::                   Functions for extracting part of a list.
* cons::                        Constructing a list.
* nthcdr::                      Calling `cdr' repeatedly.
* setcar::                      Changing the first element of a list.
* setcdr::                      Changing the rest of a list.
* cons Exercise::

`cons'

* length::                      How to find the length of a list.

Cutting and Storing Text

* Storing Text::                Text is stored in a list.
* zap-to-char::                 Cutting out text up to a character.
* kill-region::                 Cutting text out of a region.
* delete-region::               A digression into C.
* defvar::                      How to give a variable an initial value.
* copy-region-as-kill::         A definition for copying text.
* cons & search-fwd Review::
* search Exercises::

`zap-to-char'

* zap-to-char interactive::     A three part interactive expression.
* zap-to-char body::            A short overview.
* search-forward::              How to search for a string.
* progn::                       The `progn' function.
* Summing up zap-to-char::      Using `point' and `search-forward'.
* v-18-zap-to-char::            The version 18 implementation.

The Version 18 Implementation

* progn body::                  The body of the `progn' expression

`copy-region-as-kill'

* copy-region-as-kill body::    The body of `copy-region-as-kill'

The Body of `copy-region-as-kill'

* kill-append function::        The `kill-append' function
* copy-region-as-kill else-part::  The else-part of `copy-region-as-kill'

How Lists are Implemented

* List Exercise::

Yanking Text Back

* Kill Ring Overview::          The kill ring is a list.
* kill-ring-yank-pointer::      The `kill-ring-yank-pointer' variable.
* yank nthcdr Exercises::

Loops and Recursion

* while::                       Causing a stretch of code to repeat.
* Recursion::                   Causing a function to call itself.
* Looping exercise::

`while'

* Loop Example::                A `while' loop that uses a list.
* print-elements-of-list::      Uses `while', `car', `cdr'.
* Incrementing Loop::           A loop with an incrementing counter.
* Decrementing Loop::           A loop with a decrementing counter.

A Loop with an Incrementing Counter

* Incrementing Example::        Counting pebbles in a triangle.
* Inc Example parts::           The parts of the function definition.
* Inc Example altogether::      Putting the function definition together.

Loop with a Decrementing Counter

* Decrementing Example::        More pebbles on the beach.
* Dec Example parts::           The parts of the function definition.
* Dec Example altogether::      Putting the function definition together.

Recursion

* Recursion with list::         Using a list as the test whether to recurse.
* Recursive triangle function::  Replacing a `while' loop with recursion.
* Recursion with cond::         Recursion example with a different conditional.

Recursion in Place of a Counter

* Recursive Example arg of 3::

Regular Expression Searches

* sentence-end::                The regular expression for `sentence-end'.
* re-search-forward::           Very similar to `search-forward'.
* forward-sentence::            A straightforward example of regexp search.
* forward-paragraph::           A somewhat complex example.
* etags::                       How to create your own `TAGS' table.
* Regexp Review::
* re-search Exercises::

`forward-sentence'

* fwd-sentence while loops::    Two `while' loops.
* fwd-sentence re-search::      A regular expression search.

`forward-paragraph': a Goldmine of Functions

* fwd-para let::                The `let*' expression.
* fwd-para while::              The forward motion `while' loop.
* fwd-para between paragraphs::  Movement between paragraphs.
* fwd-para within paragraph::   Movement within paragraphs.
* fwd-para no fill prefix::     When there is no fill prefix.
* fwd-para with fill prefix::   When there is a fill prefix.
* fwd-para summary::            Summary of `forward-paragraph' code.

Counting: Repetition and Regexps

* Why Count Words::             Emacs lacks a word count command.
* count-words-region::          Use a regexp, but find a problem.
* recursive-count-words::       Start with case of no words in region.
* Counting Exercise::

The `count-words-region' Function

* Whitespace Bug::              The Whitespace Bug in `count-words-region'

Counting Words in a `defun'

* Divide and Conquer::          Split a daunting project into parts.
* Words and Symbols::           What to count?
* Syntax::                      What constitutes a word or symbol?
* count-words-in-defun::        Very like `count-words'.
* Several defuns::              Counting several defuns in a file.
* Find a File::                 Do you want to look at a file?
* lengths-list-file::           A list of the lengths of many definitions.
* Several files::               Counting in definitions in different files.
* Several files recursively::   Recursively counting in different files.
* Prepare the data::            Prepare the data for display in a graph.

Count Words in `defuns' in Different Files

* append::                      Attaching one list to another.

Prepare the Data for Display in a Graph

* Sorting::                     Sorting lists.
* Files List::                  Making a list of files.

Readying a Graph

* Columns of a graph::          How to print individual columns.
* graph-body-print::            How to print the body of a graph.
* recursive-graph-body-print::
* Printed Axes::
* Line Graph Exercise::

Your `.emacs' File

* Default Configuration::       Emacs has sensible defaults.
* Site-wide Init::              You can write site-wide init files.
* edit-options::                How to set some variables for a session.
* Beginning a .emacs File::     How to write a `.emacs file'.
* Text and Auto-fill::          Automatically wrap lines.
* Mail Aliases::                Use abbreviations for email addresses.
* Indent Tabs Mode::            Don't use tabs with TeX
* Keybindings::                 Create some personal keybindings.
* Loading Files::               Load (i.e. evaluate) files automatically.
* Autoload::                    Make functions available.
* Simple Extension::            Define a function; bind it to a key.
* Keymaps::                     More about key binding.
* X11 Colors::                  Colors in version 19 in X.
* V19 Miscellaneous::           Automatically resize minibuffer, and more.
* Mode Line::                   How to customize your mode line.

Debugging

* debug::                       How to use the built-in debugger.
* debug-on-entry::              Start debugging when you call a function.
* debug-on-quit::               Start debugging when you quit with `C-g'.
* edebug::                      How to use Edebug, a source level debugger.
* Debugging Exercises::

Handling the Kill Ring

* rotate-yank-pointer::         Move a pointer along a list and around.
* yank::                        Paste a copy of a clipped element.
* yank-pop::                    Insert first element pointed to.

The `rotate-yank-pointer' Function

* rotate-yk-ptr body::          The Body of `rotate-yank-pointer'.

The Body of `rotate-yank-pointer'

* rotate-yk-ptr else-part::     The else-part of the `if' expression.
* Remainder Function::          The remainder, `%', function.
* rotate-yk-ptr remainder::     Using `%' in `rotate-yank-pointer'.
* kill-rng-yk-ptr last elt::    Pointing to the last element.

`yank'

* rotate-yk-ptr arg::           Pass the argument to `rotate-yank-pointer'.
* rotate-yk-ptr negative arg::  Pass a negative argument.

A Graph with Labelled Axes

* Labelled Example::            How a finished graph should look.
* print-graph Varlist::         `let' expression in `print-graph'.
* print-Y-axis::                Print a label for the vertical axis.
* print-X-axis::                Print a horizontal label.
* Print Whole Graph::           The function to print a complete graph.

The `print-Y-axis' Function

* Compute a Remainder::         How to compute the remainder of a division.
* Y Axis Element::              Construct a line for the Y axis.
* Y-axis-column::               Generate a list of Y axis labels.
* print-Y-axis Final::          Print a vertical axis, final version.

The `print-X-axis' Function

* X Axis Tic Marks::            Create tic marks for the horizontal axis.

Printing the Whole Graph

* Test print-graph::            Run a short test.
* Graphing words in defuns::    Executing the final code.
* Final Printed Graph::         The graph itself!

Graphing Numbers of Words and Symbols

* lambda::                      How to write an anonymous function.
* mapcar::                      Apply a function to elements of a list.
* Another Bug::                 Yet another ... of a most insidious type.


File: emacs-lisp-intro.info,  Node: Preface,  Next: List Processing,  Prev: Top,  Up: Top

Preface
*******

   Most of the GNU Emacs text editor is written in the programming
language called Emacs Lisp.  The code written in this programming
language is the software--the sets of instructions--that tell the
computer what to do when you give it commands.  Emacs is designed so
that you can write new code in Emacs Lisp and easily install it as an
extension to the editor.  This is why Emacs is called the "extensible
editor".

   (Indeed, since Emacs does so much more than provide editing
capabilities, it should perhaps be called an "extensible computing
environment", but that phrase is quite a mouthful.  Also, everything
you do in Emacs--find the Mayan date and phases of the moon, simplify
polynomials, debug code, manage files, read letters, write books--all
these activities are kinds of editing in the most general sense of the
word.)

   Although Emacs Lisp is usually thought of in association with the
text editor, it is a full computer programming language.  You can use
it as you would any other programming language.

   Perhaps you want to understand programming; perhaps you want to
extend Emacs; or perhaps you want to become a programmer.  This
introduction to Emacs Lisp is designed to get you started: to guide you
in learning the fundamentals of programming, and more importantly, to
show you how you can teach yourself to go further.

* Menu:

* On Reading this Text::        Read, gain familiarity, pick up habits....
* Who You Are::                 For whom this is written.
* Lisp History::
* Note for Novices::            You can read this as a novice.
* Thank You::


File: emacs-lisp-intro.info,  Node: On Reading this Text,  Next: Who You Are,  Prev: Preface,  Up: Preface

On Reading this Text
====================

   All through this document, you will see little sample programs you
can run inside of Emacs.  If you read this document in Info inside of
GNU Emacs, you can run the programs as they appear.  (This is easy to
do and is explained when the examples are presented.)  Alternatively,
you can read this introduction as a printed book while sitting beside a
computer running Emacs.  (This is what I like to do; I like printed
books.)  If you don't have a running Emacs beside you, you can still
read this book, but in this case, it is best to treat it as a novel or
as a travel guide to a country not yet visited: interesting, but not
the same as being there.

   Much of this introduction is dedicated to walk-throughs or guided
tours of code used in GNU Emacs.  These tours are designed for two
purposes: first, to give you familiarity with real, working code (code
you use every day); and, second, to give you familiarity with the way
Emacs works.  It is interesting to see how an editor is implemented.
Also, I hope that you will pick up the habit of browsing through source
code.  You can learn from it and mine it for ideas.  Having GNU Emacs
is like having a dragon's cave of treasures.

   In addition to learning about Emacs as an editor and Emacs Lisp as a
programming language, the examples and guided tours will give you an
opportunity to get acquainted with Emacs as a Lisp programming
environment.  GNU Emacs supports programming and provides tools that
you will want to become comfortable using, such as `M-.' (the key which
invokes the `find-tag' command).  You will also learn about buffers and
other objects that are part of the editing environment.  Learning about
these features of Emacs is like learning new routes around your home
town.

   Finally, I hope to convey some of the skills for using Emacs to
learn aspects of programming that you don't know.  You can often use
Emacs to help you understand what puzzles you or to find out how to do
something new.  This self-reliance is not only a pleasure, but an
advantage.


File: emacs-lisp-intro.info,  Node: Who You Are,  Next: Lisp History,  Prev: On Reading this Text,  Up: Preface

For Whom This is Written
========================

   This text is written as an elementary introduction for people who are
not programmers.  If you are a programmer, you may not be satisfied with
this primer.  The reason is that you may have become expert at reading
reference manuals and be put off by the way this text is organized.

   An expert programmer who reviewed this text said to me:

     I prefer to learn from reference manuals.  I "dive into" each
     paragraph, and "come up for air" between paragraphs.

     When I get to the end of a paragraph, I assume that that subject is
     done, finished, that I know everything I need (with the possible
     exception of the case when the next paragraph starts talking about
     it in more detail).  I expect that a well written reference manual
     will not have a lot of redundancy, and that it will have excellent
     pointers to the (one) place where the information I want is.

   This introduction is not written for this person!

   Firstly, I try to say everything at least three times: first, to
introduce it; second, to show it in context; and third, to show it in a
different context, or to review it.

   Secondly, I hardly ever put all the information about a subject in
one place, much less in one paragraph.  To my way of thinking, that
imposes too heavy a burden on the reader.  Instead I try to explain
only what you need to know at the time.  (Sometimes I include a little
extra information so you won't be surprised later when the additional
information is formally introduced.)

   When you read this text, you are not expected to learn everything the
first time.  Frequently, you need only make, as it were, a `nodding
acquaintance' with some of the items mentioned.  My hope is that I have
structured the text and given you enough hints that you will be alert to
what is important, and concentrate on it.

   You will need to "dive into" some paragraphs; there is no other way
to read them.  But I have tried to keep down the number of such
paragraphs.  This book is intended as an approachable hill, rather than
as a daunting mountain.

   This *introduction* to `Programming in Emacs Lisp' has a companion
document, *Note The GNU Emacs Lisp Reference Manual: (elisp)Top.  The
reference manual has more detail than this introduction.  In the
reference manual, all the information about one topic is concentrated
in one place.  You should turn to it if you are like the programmer
quoted above.  And, of course, after you have read this `Introduction',
you will find the `Reference Manual' useful when you are writing your
own programs.


File: emacs-lisp-intro.info,  Node: Lisp History,  Next: Note for Novices,  Prev: Who You Are,  Up: Preface

Lisp History
============

   Lisp was first developed in the late 1950s at the Massachusetts
Institute of Technology for research in artificial intelligence.  The
great power of the Lisp language makes it superior for other purposes as
well, such as writing editor commands.

   GNU Emacs Lisp is largely inspired by Maclisp, which was written at
MIT in the 1960's.  It is somewhat inspired by Common Lisp, which
became a standard in the 1980s.  However, Emacs Lisp is much simpler
than Common Lisp.  (The standard Emacs distribution contains an
optional extensions file, `cl.el', that adds many Common Lisp features
to Emacs Lisp.)


File: emacs-lisp-intro.info,  Node: Note for Novices,  Next: Thank You,  Prev: Lisp History,  Up: Preface

A Note for Novices
==================

   If you don't know GNU Emacs, you can still read this document
profitably.  However, I recommend you learn Emacs, if only to learn to
move around your computer screen.  You can teach yourself how to use
Emacs with the on-line tutorial.  To use it, type `C-h t'.  (This means
you press and release the <CTRL> key and the `h' at the same time, and
then press and release `t'.)

   Also, I often refer to one of Emacs's standard commands by listing
the keys which you press to invoke the command and then giving the name
of the command in parentheses, like this: `M-C-\' (`indent-region').
What this means is that the `indent-region' command is customarily
invoked by typing `M-C-\'.  (You can, if you wish, change the keys that
are typed to invoke the command; this is called "rebinding".  *Note
Keymaps: Keymaps.)  The abbreviation `M-C-\' means that you type your
<META> key, <CTRL> key and <\> key all at the same time.  Sometimes a
combination like this is called a keychord, since it is similar to the
way you play a chord on a piano.  If your keyboard does not have a
<META> key, the <ESC> key prefix is used in place of it.  In this case,
`M-C-\' means that you press and release your <ESC> key and then type
the <CTRL> key and the <\> key at the same time.

   If you are reading this in Info using GNU Emacs, you can read through
this whole document just by pressing the space bar, <SPC>.  (To learn
about Info, type `C-h i' and then select Info.)

   A note on terminology:  when I use the word Lisp alone, I am usually
referring to the various dialects of Lisp in general, but when I speak
of Emacs Lisp, I am referring to GNU Emacs Lisp in particular.


File: emacs-lisp-intro.info,  Node: Thank You,  Prev: Note for Novices,  Up: Preface

Thank You
=========

   My thanks to all who helped me with this book.  My especial thanks to
Jim Blandy, Noah Friedman, Jim Kingdon, Roland McGrath, Frank Ritter,
Randy Smith, Richard M. Stallman, and Melissa Weisshaus.  My thanks
also go to both Philip Johnson and David Stampe for their patient
encouragement.  My mistakes are my own.


File: emacs-lisp-intro.info,  Node: List Processing,  Next: Practicing Evaluation,  Prev: Preface,  Up: Top

List Processing
***************

   To the untutored eye, Lisp is a strange programming language.  In
Lisp code there are parentheses everywhere.  Some people even claim
that the name stands for `Lots of Isolated Silly Parentheses'.  But the
claim is unwarranted.  Lisp stands for LISt Processing and the
programming language handles *lists* (and lists of lists) by putting
them between parentheses.  The parentheses mark the boundaries of the
list.  Sometimes a list is preceded by a single apostrophe or quotation
mark, `''.  Lists are the basis of Lisp.

* Menu:

* Lisp Lists::                  What are lists?
* Run a Program::               Any list in Lisp is a program ready to run.
* Making Errors::               Generating an error message.
* Names & Definitions::         Names of symbols and function definitions.
* Lisp Interpreter::            What the Lisp interpreter does.
* Evaluation::                  Running a program.
* Variables::                   Returning a value from a variable.
* Arguments::                   Passing information to a function.
* set & setq::                  Setting the value of a variable.
* Summary::                     The major points.
* Error Message Exercises::


File: emacs-lisp-intro.info,  Node: Lisp Lists,  Next: Run a Program,  Prev: List Processing,  Up: List Processing

Lisp Lists
==========

   In Lisp, a list looks like this: `'(rose violet daisy buttercup)'.
This list is preceded by a single apostrophe.  It could just as well be
written as follows, which looks more like the kind of list you are
likely to be familiar with:

     '(rose
       violet
       daisy
       buttercup)

The elements of this list are the names of the four different flowers,
separated from each other by whitespace and surrounded by parentheses,
like flowers in a field with a stone wall around them.

   Lists can also have numbers in them, as in this list: `(+ 2 2)'.
This list has a plus-sign, `+', followed by two `2's, each separated by
whitespace.

   In Lisp, both data and programs are represented the same way; that
is, they are both lists of words, numbers, or other lists, separated by
whitespace and surrounded by parentheses.  (Since a program looks like
data, one program may easily serve as data for another; this is a very
powerful feature of Lisp.)  (Incidentally, these two parenthetical
remarks are *not* Lisp lists, because they contain `;' and `.' as
punctuation marks.)

   Here is another list, this time with a list inside of it:

     '(this list has (a list inside of it))

   The components of this list are the words `this', `list', `has', and
the list `(a list inside of it)'.  The interior list is made up of the
words `a', `list', `inside', `of', `it'.

* Menu:

* Lisp Atoms::                  Elemental entities.
* Whitespace in Lists::         Formating lists to be readable.
* Typing Lists::                How GNU Emacs helps you type lists.


File: emacs-lisp-intro.info,  Node: Lisp Atoms,  Next: Whitespace in Lists,  Prev: Lisp Lists,  Up: Lisp Lists

Lisp Atoms
----------

   In Lisp, what we have been calling words are called "atoms".  This
term comes from the historical meaning of the word atom, which means
`indivisible'.  As far as Lisp is concerned, the words we have been
using in the lists cannot be divided into any smaller parts and still
mean the same thing as part of a program; likewise with numbers and
single character symbols like `+'.  On the other hand, unlike an atom,
a list can be split into parts.  (*Note `car' `cdr' & `cons'
Fundamental Functions: car cdr & cons.)

   In a list, atoms are separated from each other by whitespace.  They
can be right next to a parenthesis.

   Technically speaking, a list in Lisp consists of parentheses
surrounding atoms separated by whitespace or surrounding other lists or
surrounding both atoms and other lists.  A list can have just one atom
in it or have nothing in it at all.  A list with nothing in it looks
like this: `()', and is called the "empty list".  Unlike anything else,
an empty list is considered both an atom and a list at the same time.

   The printed representation of both atoms and lists are called
"symbolic expressions" or, more concisely, "s-expressions".  The word
"expression" by itself can refer to either the printed representation,
or to the atom or list as it is held internally in the computer.
Often, people use the term "expression" indiscriminately.  (Also, in
many texts, the word "form" is used as a synonym for expression.)

   Incidentally, the atoms that make up our universe were named such
when they were thought to be indivisible; but it has been found that
physical atoms are not indivisible.  Parts can split off an atom or it
can fission into two parts of roughly equal size.  Physical atoms were
named prematurely, before their truer nature was found.  In Lisp,
certain kinds of atom, such as an array, can be separated into parts;
but the mechanism for doing this is different from the mechanism for
splitting a list.  As far as list operations are concerned, the atoms
of a list are unsplittable.

   As in English, the meanings of the component letters of a Lisp atom
are different from the meaning the letters make as a word.  For
example, the word for the South American sloth, the `ai', is completely
different from the two words, `a', and `i'.

   There are many kinds of atom in nature but only a few in Lisp: for
example, "numbers", such as 37, 511, or 1729, and "symbols", such as
`+', `foo', or `forward-line'.  The words we have listed in the
examples above are all symbols.  In everyday Lisp conversation, the
word "atom" is not often used, because programmers usually try to be
more specific about what kind of atom they are dealing with.  Lisp
programming is mostly about symbols (and sometimes numbers) within
lists.  (Incidentally, the preceding three word parenthetical remark is
a proper list in Lisp, since it consists of atoms, which in this case
are symbols, separated by whitespace and enclosed by parentheses,
without any non-Lisp punctuation.)

   In addition, text between double quotation marks--even sentences or
paragraphs--is an atom.  Here is an example:

     '(this list includes "text between quotation marks.")

In Lisp, all of the quoted text including the punctuation mark and the
blank spaces is a single atom.  This kind of atom is called a "string"
(for `string of characters') and is the sort of thing that is used for
messages that a computer can print for a human to read.  Strings are a
different kind of atom than numbers or symbols and are used differently.


File: emacs-lisp-intro.info,  Node: Whitespace in Lists,  Next: Typing Lists,  Prev: Lisp Atoms,  Up: Lisp Lists

Whitespace in Lists
-------------------

   The amount of whitespace in a list does not matter.  From the point
of view of the Lisp language,

     '(this list
        looks like this)

is exactly the same as this:

     '(this list looks like this)

   Both examples show what to Lisp is the same list, the list made up of
the symbols `this', `list', `looks', `like', and `this' in that order.

   Extra whitespace and newlines are designed to make a list more
readable by humans.  When Lisp reads the expression, it gets rid of all
the extra whitespace (but it needs to have at least one space between
atoms in order to tell them apart.)

   Odd as it seems, the examples we have seen cover almost all of what
Lisp lists look like!  Every other list in Lisp looks more or less like
one of these examples, except that the list may be longer and more
complex.  In brief, a list is between parentheses, a string is between
quotation marks, a symbol looks like a word, and a number looks like a
number.  (For certain situations, square brackets, dots and a few other
special characters may be used; however, we will go quite far without
them.)


File: emacs-lisp-intro.info,  Node: Typing Lists,  Prev: Whitespace in Lists,  Up: Lisp Lists

GNU Emacs Helps You Type Lists
------------------------------

   If you type a Lisp expression in GNU Emacs using either Lisp
Interaction mode or Emacs Lisp mode, you will have available to you
several commands to format the Lisp expression so it is easy to read.
For example, pressing the <TAB> key automatically indents the line the
cursor is on by the right amount.  A command to properly indent the
code in a region is customarily bound to `M-C-\'.  Indentation is
designed so that you can see which elements of a list belongs to which
list--elements of a sub-list are indented more than the elements of the
enclosing list.

   In addition, when you type a closing parenthesis, Emacs momentarily
jumps the cursor back to the matching opening parenthesis, so you can
see which one it is.  This is very useful, since every list you type in
Lisp must have its closing parenthesis match its opening parenthesis.
(*Note Major Modes: (emacs)Major Modes, for more information about
Emacs' modes.)


File: emacs-lisp-intro.info,  Node: Run a Program,  Next: Making Errors,  Prev: Lisp Lists,  Up: List Processing

Run a Program
=============

   A list in Lisp--any list--is a program ready to run.  If you run it
(for which the Lisp jargon is "evaluate"), the computer will do one of
three things: do nothing except return to you the list itself; send you
an error message; or, treat the first symbol in the list as a command
to do something.  (Usually, of course, it is the last of these three
things that you really want!)

   The single apostrophe, `'', that I put in front of some of the
example lists in preceding sections is called a "quote"; when it
precedes a list, it tells Lisp to do nothing with the list, other than
take it as it is written.  But if there is no quote preceding a list,
the first item of the list is special: it is a command for the computer
to obey.  (In Lisp, these commands are called *functions*.)  The list
`(+ 2 2)' shown above did not have a quote in front of it, so Lisp
understands that the `+' is an instruction to do something with the
rest of the list; in this case, to add the numbers that follow.

   If you are reading this inside of GNU Emacs in Info, here is how you
can evaluate such a list:  place your cursor immediately after the right
hand parenthesis of the following list and then type `C-x C-e':

     (+ 2 2)

You will see the number `4' appear in the echo area.  (In the jargon,
what you have just done is "evaluate the list."  The echo area is the
line at the bottom of the screen that displays or "echoes" text.)  Now
try the same thing with a quoted list:  place the cursor right after
the following list and type `C-x C-e':

     '(this is a quoted list)

In this case, you will see `(this is a quoted list)' appear in the echo
area.

   In both cases, what you are doing is giving a command to the program
inside of GNU Emacs called the "Lisp interpreter"--giving the
interpreter a command to evaluate the expression.  The name of the Lisp
interpreter comes from the word for the task done by a human who comes
up with the meaning of an expression--who "interprets" it.

   You can also evaluate an atom that is not part of a list--one that is
not surrounded by parentheses; again, the Lisp interpreter translates
from the humanly readable expression to the language of the computer.
But before discussing this (*note Variables::.), we will discuss what
the Lisp interpreter does when you make an error.


File: emacs-lisp-intro.info,  Node: Making Errors,  Next: Names & Definitions,  Prev: Run a Program,  Up: List Processing

Generate an Error Message
=========================

   Partly so you won't worry if you do it accidentally, we will now give
a command to the Lisp interpreter that generates an error message.
This is a harmless activity; and indeed, we will often try to generate
error messages intentionally.  Once you understand the jargon, error
messages can be informative.  Instead of being called "error" messages,
they should be called "help" messages.  They are like signposts to a
traveller in a strange country; decyphering them can be hard, but once
understood, they can point the way.

   What we will do is evaluate a list that is not quoted and does not
have a meaningful command as its first element.  Here is a list almost
exactly the same as the one we just used, but without the single-quote
in front of it.  Position the cursor right after it and type `C-x C-e':

     (this is an unquoted list)

This time, you will see the following appear in the echo area:

     Symbol's function definition is void: this

(Also, your terminal may beep at you--some do, some don't; and others
blink.  This is just a device to get your attention.)  The message goes
away as soon as you type another key, even just to move the cursor.

   Based on what we already know, we can almost read this error message.
We know the meaning of the word `Symbol'.  In this case, it refers to
the first atom of the list, the word `this'.  The word `function' was
mentioned once before.  It is a very important word.  For our purposes,
we can define it by saying that a "function" is a set of instructions
to the computer that tell the computer to do something.  (Technically,
the symbol tells the computer where to find the instructions, but this
is a complication we can ignore for the moment.)

   Now we can begin to understand the error message: `Symbol's function
definition is void: this'.  The symbol (that is, the word `this') does
not have a definition of any set of instructions for the computer to
carry out.

   The slightly odd wording of the message, `function definition is
void', is designed to cover the way Emacs Lisp is implemented, which is
that when the symbol does not have a function definition attached to it,
the place that should contain the instructions is `void'.

   On the other hand, since we were able to add 2 plus 2 successfully,
by evaluating `(+ 2 2)', we can infer that the symbol `+' must have a
set of instructions for the computer to obey and those instructions
must be to add the numbers that follow the `+'.


File: emacs-lisp-intro.info,  Node: Names & Definitions,  Next: Lisp Interpreter,  Prev: Making Errors,  Up: List Processing

Symbol Names and Function Definitions
=====================================

   We can articulate another characteristic of Lisp based on what we
have discussed so far--an important characteristic: a symbol, like `+',
is not itself the set of instructions for the computer to carry out.
Instead, the symbol is used, perhaps temporarily, as a way of locating
the definition or set of instructions.  What we see is the name through
which the instructions can be found.  Names of people work the same
way.  I can be referred to as `Bob'; however, I am not the letters `B',
`o', `b' but am the consciousness consistently associated with a
particular life-form.  The name is not me, but it can be used to refer
to me.

   In Lisp, one set of instructions can be attached to several names.
For example, the computer instructions for adding numbers can be linked
to the symbol `plus' as well as to the symbol `+' (and are in some
dialects of Lisp).  Among humans, I can be referred to as `Robert' as
well as `Bob' and by other words as well.

   On the other hand, a symbol can have only one function definition
attached to it at a time.  Otherwise, the computer would be confused as
to which definition to use.  If this were the case among people, only
one person in the world could be named `Bob'.  However, the function
definition to which the name refers can be changed readily.  (*Note
Install a Function Definition: Install.)

   Since Emacs Lisp is large, it is customary to name symbols in a way
that identifies the part of Emacs to which the function belongs.  Thus,
all the names for functions that deal with Texinfo start with
`texinfo-' and those for functions that deal with reading mail start
with `rmail-'.


File: emacs-lisp-intro.info,  Node: Lisp Interpreter,  Next: Evaluation,  Prev: Names & Definitions,  Up: List Processing

The Lisp Interpreter
====================

   Based on what we have seen, we can now start to figure out what the
Lisp interpreter does when we command it to evaluate a list.  First, it
looks to see whether there is a quote before the list; if there is, the
interpreter just gives us the list.  On the other hand, if there is no
quote, the interpreter looks at the first element in the list and sees
whether it has a function definition.  If it does, the interpreter
carries out the instructions in the function definition.  Otherwise,
the interpreter prints an error message.

   This is how Lisp works.  Simple.  There are added complications
which we will get to in a minute, but these are the fundamentals.  Of
course, to write Lisp programs, you need to know how to write function
definitions and attach them to names, and how to do this without
confusing either yourself or the computer.

   Now, for the first complication.  In addition to lists, the Lisp
interpreter can evaluate a symbol that is not quoted and does not have
parentheses around it.  In this case, the Lisp interpreter will attempt
to determine the symbol's value as a "variable".  This situation is
described in the section on variables.  (*Note Variables::.)

   The second complication occurs because some functions are unusual
and do not work in the usual manner.  Those that don't are called
"special forms".  They are used for special jobs, like defining a
function, and there are not many of them.  In the next few chapters,
you will be introduced to several of the more important special forms.

   The third and final complication is this: if the function that the
Lisp interpreter is looking at is not a special form, and if it is part
of a list, the Lisp interpreter looks to see whether the list has a list
inside of it.  If there is an inner list, the Lisp interpreter first
figures out what it should do with the inside list, and then it works on
the outside list.  If there is yet another list embedded inside the
inner list, it works on that one first, and so on.  It always works on
the innermost list first.  The interpreter works on the innermost list
first in order to find out the result of doing that.  The result may be
used by the enclosing expression.

   Otherwise, the interpreter works left to right, from one expression
to the next.

* Menu:

* Byte Compiling::              Specially processing code for speed.


File: emacs-lisp-intro.info,  Node: Byte Compiling,  Prev: Lisp Interpreter,  Up: Lisp Interpreter

Byte Compiling
--------------

   One other aspect of interpreting: the Lisp interpreter is able to
interpret two kinds of entity: humanly readable code, on which we will
focus exclusively, and specially processed code, called "byte compiled"
code, which is not humanly readable.  Byte compiled code runs faster
than humanly readable code.

   You can transform humanly readable code into byte compiled code by
running one of the compile commands such as `byte-compile-file'.  Byte
compiled code is usually stored in a file that ends with a `.elc'
extension rather than a `.el' extension.  You will see both kinds of
file in the `emacs/lisp' directory; the files to read are those with
`.el' extensions.

   As a practical matter, for most things you might do to customize or
extend Emacs, you do not need to byte compile; and I will not discuss
the topic here.  *Note Byte Compilation: (elisp)Byte Compilation, for a
full description of byte compilation.


File: emacs-lisp-intro.info,  Node: Evaluation,  Next: Variables,  Prev: Lisp Interpreter,  Up: List Processing

Evaluation
==========

   When the Lisp interpreter works on an expression, the term for the
activity is called "evaluation".  We say that the interpreter
`evaluates the expression'.  I've used this term several times before.
The word comes from its use in everyday language, `to ascertain the
value or amount of; to appraise', according to `Webster's New
Collegiate Dictionary'.

   After evaluating an expression, the Lisp interpreter will most likely
"return" the value that the computer produces by carrying out the
instructions it found in the function definition, or perhaps it will
give up on that function and produce an error message.  (The interpreter
may also find itself tossed, so to speak, to a different function or it
may attempt to repeat continually what it is doing for ever and ever in
what is called an `infinite loop'.  These actions are less common; and
we can ignore them.)  Most frequently, the interpreter returns a value.

   At the same time the interpreter returns a value, it may do something
else as well, such as move a cursor or copy a file; this other kind of
action is called a "side effect".  Actions that we humans think are
important, such as printing results, are often "side effects" to the
Lisp interpreter.  The jargon can sound peculiar, but it turns out that
it is fairly easy to learn to use side effects.

   In summary, evaluating a symbolic expression most commonly causes the
Lisp interpreter to return a value and perhaps carry out a side effect;
or else produce an error.

* Menu:

* Evaluating Inner Lists::      Lists within lists...