\input texinfo                       @c -*- mode: texinfo; coding: utf-8 -*-
@c ===========================================================================
@c
@c This file was generated with po4a. Translate the source file.
@c
@c ===========================================================================

@comment %**start of header
@setfilename ../../info/eintr.info
@settitle programmeren in Emacs Lisp
@documentlanguage nl
@include docstyle.texi
@syncodeindex vr cp
@syncodeindex fn cp
@documentencoding UTF-8
@set TEL-WOORDEN tel-woorden-voorbeeld
@finalout

@include /dev/null

@c ================ How to Print a Book in Various Sizes ================

@c This book can be printed in any of three different sizes.
@c Set the following @-commands appropriately.

@c     7 by 9.25 inches:
@c              @smallbook
@c              @clear largebook

@c     8.5 by 11 inches:
@c              @c smallbook
@c              @set largebook

@c     European A4 size paper:
@c              @c smallbook
@c              @afourpaper
@c              @set largebook

@c (Note: if you edit the book so as to change the length of the
@c table of contents, you may have to change the value of 'pageno' below.)

@c <<<< For hard copy printing, this file is now
@c      set for smallbook, which works for all sizes
@c      of paper, and with PostScript figures >>>>

@set smallbook
@ifset smallbook
@smallbook
@clear largebook
@end ifset

@comment %**end of header

@c per rms and peterb, use 10pt fonts for the main text, mostly to
@c save on paper cost.
@c Do this inside @tex for now, so current makeinfo does not complain.
@tex
@ifset smallbook
@fonttextsize 10

@end ifset
\global\hbadness=6666 % don't worry about not-too-underfull boxes
@end tex

@c For next or subsequent edition:
@c   create function using with-output-to-temp-buffer
@c   create a major mode, with keymaps
@c   run an asynchronous process, like grep or diff

@c For 8.5 by 11 inch format: do not use such a small amount of
@c whitespace between paragraphs as smallbook format
@ifset largebook
@tex
\global\parskip 6pt plus 1pt
@end tex
@end ifset

@c For all sized formats:  print within-book cross
@c reference with ``...''  rather than [...]

@c This works with the texinfo.tex file, version 2003-05-04.08,
@c in the Texinfo version 4.6 of the 2003 Jun 13 distribution.

@tex
\if \xrefprintnodename
 \global\def\xrefprintnodename#1{\unskip, ``#1''}
 \else
 \global\def\xrefprintnodename#1{ ``#1''}
\fi
% \global\def\xrefprintnodename#1{, ``#1''}
@end tex

@c ----------------------------------------------------

@dircategory Emacs lisp
@direntry
* Emacs Lisp Intro: (eintr).  Eenvoudige introductie in Emacs Lisp 
                                programmeren.
@end direntry

@c When printing, define edition-number to be the printed edition
@c number, titlepage-edition-number to be the spelled out edition
@c number suitable for the title page, and update-date to be the date,
@c in the preferred style for these.  E.g., run the shell command:
@c   texi2any -D 'edition-number 3.11' \
@c            -D 'titlepage-edition-number Revised Third Edition' \
@c            -D 'update-date 31 March 2020'
@c This relates mainly to the published book sold by the FSF.

@copying
Dit is @cite{Een introductie in Programmeren in Emacs Lisp}, voor mensen die
geen programmeur zijn.
@sp 1
@ifset edition-number
Edition @value{edition-number}, @value{update-date}
@end ifset
@sp 1
Gedistribueerd met Emacs versie @value{EMACSVER}.
@sp 1
Copyright @copyright{} 1990--1995, 1997, 2001--2026 Free Software
Foundation, Inc.
@sp 1

@iftex
Gepubliceerd door de:@*

GNU Press, @hfill @uref{https://www.fsf.org/licensing/gnu-press/}@* a
division of the @hfill email: @email{sales@@fsf.org}@* Free Software
Foundation, Inc.  @hfill Tel: +1 (617) 542-5942@* 31 Milk Street, # 960789
@hfill Fax: +1 (617) 542-2652@* Boston, MA 02196 USA
@end iftex

@ifnottex
Gedrukte exemplaren verkrijgbaar bij
@uref{https://shop.fsf.org/}. Gepubliceerd door:

@example
GNU Press,                        https://www.fsf.org/licensing/gnu-press/
a division of the                 email: sales@@fsf.org
Free Software Foundation, Inc.    Tel: +1 (617) 542-5942
31 Milk Street, # 960789          Fax: +1 (617) 542-2652
Boston, MA 02196 USA
@end example
@end ifnottex

@sp 1
ISBN 1-882114-43-4

@quotation
Het is toegestaan dit document te kopiëren, distribueren en/of te wijzigen
onder de termen van de GNU Free Documentation License, Version 1.3 of een
latere versie gepubliceerd door de Free Software Foundation; er is geen
andere sectie met de voorpagina tekst ``A GNU Manual'', en met de
achterpagina tekst als in (a) hieronder. Een exemplaar van de licentie is
opgenomen in de sectie met de titel ``GNU Free Documentation License''.

De FSF's achterkant tekst is: ``Je hebt de vrijheid deze GNU handleiding te
kopiëren en te wijzigen. Met het kopen van exemplaren ondersteun je de FSF
in het ontwikkelen van GNU en het promoten van software vrijheid.''
@end quotation
@end copying

@c half title; two lines here, so do not use 'shorttitlepage'
@tex
{\begingroup%
    \hbox{}\vskip 1.5in \chaprm \centerline{Een introductie in}%
        \endgroup}%
{\begingroup\hbox{}\vskip 0.25in \chaprm%
        \centerline{programmeren in Emacs Lisp}%
        \endgroup\page\hbox{}\page}
@end tex

@titlepage
@sp 6
@center @titlefont{Een introductie in}
@sp 2
@center @titlefont{programmeren in Emacs Lisp}
@sp 2
@ifset titlepage-edition-number
@center @value{titlepage-edition-number}
@end ifset
@sp 4
@center door by Robert J. Chassell

@page
@vskip 0pt plus 1filll
@insertcopying
@end titlepage

@iftex
@headings off
@evenheading @thispage @| @| @thischapter
@oddheading @thissection @| @| @thispage
@end iftex

@ifnothtml
@c     Keep T.O.C. short by tightening up for largebook
@ifset largebook
@tex
\global\parskip 2pt plus 1pt
\global\advance\baselineskip by -1pt
@end tex
@end ifset
@end ifnothtml

@c If you think this manual is too large for an introduction, please
@c consider this email exchange:
@c
@c       >> The intro is almost 300 pages in full.  I had expected 60 pages.
@c       >
@c       > This is an important point in its own right.  Could you
@c       > write a simplified introduction that is only 50 pages or so?
@c       > That would be helpful to many potential users, I'd think.
@c
@c   > The problem with the introduction is that it was written when
@c   > programming was only starting to be a skill "normal" people could
@c   > have access to.  So the text is extremely verbose and is
@c   > sometimes hard to follow because of that.  The gist of the
@c   > document could be summarized in 50 pages.
@c
@c This book is intentionally addressed to people who don't know how to
@c program.  That is its purpose.  We recommend people start learning to
@c program using this book.
@c
@c If you DO know how to program in some other language, you can probably
@c learn Emacs Lisp starting with the Emacs Lisp Reference Manual.
@c
@c        Richard Stallman <rms@gnu.org>,
@c        https://lists.gnu.org/r/emacs-devel/2018-05/msg00374.html

@shortcontents
@contents

@ifnottex
@node Top
@top Een introductie in programmeren in Emacs Lisp

@ifset WWW_GNU_ORG
@html
<p>De GNU Emacs website
is<href="/software/emacs/">https://www.gnu.org/software/emacs/</a>.<br> Om
deze handleiding in andere formaten te zien, klikt <a
href="/software/emacs/manual/eintr.html">hier</a>.
@end html
@end ifset

@insertcopying

Dit hoofdmenu toont eerst elk hoofdstuk en een index, daarna elk onderdeel
van elk hoofdstuk.
@end ifnottex

@c Uncomment the 3 lines below, starting with @iftex, if you want the
@c pages of Preface to be numbered in roman numerals.  Use -9 instead
@c of -11 for smallbook format.

@c >>>> Set pageno appropriately <<<<

@c The first page of the Preface is a roman numeral; it is the first
@c right handed page after the Table of Contents; hence the following
@c setting must be for an odd negative number.

@c iftex
@c global@pageno = -11
@c end iftex

@set COUNT-WORDS count-words-example
@c Length of variable name chosen so that things still line up when expanded.

@menu
* Voorwoord::                Wat je hier vindt.
* Lijsten verwerken::        Wat is Lisp?
* Oefenen van evaluatie::    Verschillende programma's draaien
* Defuns schrijven::         Hoe functiedefinities te schrijven
* Buffer rondleiding::       Ontdek een paar buffer gerelateerde functies.
* Meer complex::             Enkele nog complexere functies.
* Versmallen en verbreden::  Beperk jouw en Emacs aandacht tot een region.
* car cdr en cons::          Fundamentele functies in Lisp.
* Knippen en opslaan van tekst::  Tekst verwijderen en bewaren
* Implementatie van lijsten::  Hoe lijsten zijn geïmplementeerd in de 
                                 computer
* Yanking::                  Opgeslagen tekst plakken
* Loops en recursie::        Hoe een proces te herhalen
* Regexp zoeken::            Reguliere expressie zoekopdrachten
* Woorden tellen::           Een terugblik op herhaling en regexps.
* Woorden in een defun::     Woorden tellen in een @code{defun}.
* Een grafiek voorbereiden::  Een prototype grafiek print functie.
* Initialisatie van Emacs::  Hoe een @file{.emacs} bestand te schrijven.
* Debuggen.::                Hoe Emacs Lisp debuggers te draaien.
* Conclusie::                Nu heb je de basis.
* de-de::                    Een appendix: hoe vind je gerepliceerde 
                               woorden.
* Killring::                 Een appendix: hoe de killring werkt.
* Volledige grafiek::        Hoe een grafiek met labels op de assen te 
                               maken.
* Vrije software en vrije handleidingen::  Vrije software en vrije 
                                             handleidingen
* GNU Free Documentation License::  GNU Free Documentation License
* Index::                    Index
* Over de auteur::           Over de auteur

@detailmenu
 --- De gedetaileerde onderdelen lijst ---



Voorwoord



* Waarom::                   Waarom Emacs Lisp leren?
* Over het lezen van deze tekst::  Lees, raak vertrouwd en ontwikkel 
                                     gewoontes ...
* Doelgroep::                Voor wie dit is geschreven
* Geschiedenis van Lisp::    Geschiedenis van Lisp
* Opmerking voor beginners::  Je kunt dit lezen als beginner
* Dank::                     Dank

Lijsten verwerken



* Lisp lijsten::             Wat zijn lijsten
* Draai een programma::      Elke lijst in Lisp is een programma gereed om 
                               te draaien.
* Fouten maken::             Een foutboodschap genereren
* Namen en definities::      Namen van symbolen en functie-definities.
* Lisp interpreter::         Wat de Lisp interpreter doet.
* Evaluatie::                Een programma draaien
* Variabelen::               Een waarde van een variabele teruggeven
* Argumenten::               Informatie doorgeven aan een functie
* setq::                     De waarde van een variabele zetten.
* Samenvatting::             De belangrijkste punten
* Foutmelding oefeningen::   Foutmelding oefeningen

Lisp lijsten



* Genummerde lijsten::       Lijsten bevatten getallen en andere lijsten
* Lisp atomen::              Elementaire entiteiten
* Whitespace in lijsten::    Lijsten leesbaar formatteren
* Typen van lijsten::        Hoe GNU Emacs helpt bij het typen van lijsten

De Lisp interpreter



* Complicaties::             Variabelen, speciale vormen, lijsten daarbinnen
* Byte compiling::           Speciale verwerkingscode voor snelheid.

Evaluatie



* Hoe de interpreter werkt::  Returns en zij-effecten...
* Geneste lijsten evalueren::  Lijsten binnen lijsten...

Variabelen



* fill-column voorbeeld::    fill-column voorbeeld
* Void functie::             De foutmelding voor een symbool zonder functie.
* Void variabele::           De foutmelding voor een symbool zonder waarde.

Argumenten



* Data typen::               Typen van data doorgegeven naar een functie.
* Argumenten als variabele of als lijst::  Een argument kan de waarde van 
                                             een variabele of lijst zijn
* Variabel aantal argumenten::  Sommige functies accepteren een variable 
                                  aantal argumenten.
* Verkeerde type argument::  Een argument van het verkeerde type aan een 
                               functie doorgeven
* message::                  Een nuttige functie om boodschappen te zenden.

De waarde van een variabele zetten



* Setq gebruiken::           Een gequote waarde instellen.
* Tellen::                   @code{setq} gebruiken om te tellen.

Oefenen van evaluatie



* Hoe te evalueren::         Het typen van commando's of @kbd{C-x C-e} 
                               veroorzaakt evalatie.
* Buffer namen::             Buffers en bestanden zijn verschillend.
* Buffers pakken::           Pak een buffer zelf, niet slechts zijn naam.
* Van buffer verwisselen::   Hoe je naar een andere buffer overschakelt
* Buffer grootte en locatie::  De locatie van point en de grootte van het 
                                 buffer.
* Evaluatie oefening::       Evaluatie oefening

Hoe functiedefinities te schrijven



* Primitieve functies::      Primitieve functies
* defun::                    De @code{defun} macro.
* Installeer::               Installeer een functiedefinitie
* Interactief::              Een functie interactief maken.
* Interactieve opties::      Verschillende opties voor @code{interactive}.
* Permanent installeren::    Installeer code permanent
* let::                      Locale variabelen maken en initialiseren
* if::                       Wat als?
* else::                     If--then--else expressies.
* Waar en onwaarheid::       Wat Lisp als waar en onwaar beschouwt.
* save-excursion::           Point en buffer volgen
* Terugblik::                Terugblik
* defun oefeningen::         defun oefeningen

Installeer een functiedefinitie



* Effect van installatie::   Effect van installatie
* Een defun wijzigen::       Hoe een functiedefinitie te wijzigen.

Een functie interactief maken



* Interactieve vermenigvuldig-met-zeven::  Een overzicht
* vermenigvuldig-met-zeven in detail::  De interactieve versie

@code{let}



* Voorkom verwarring::       Voorkom verwarring
* Delen van een let expressie::  Delen van een let expressie
* Voorbeeld let expressie::  Voorbeeld let expressie
* Niet-geïnitialiseerde let variabelen::  Niet-geïnitialiseerde let 
                                            variabelen

De @code{if} speciale vorm



* if in meer detail::        if in meer detail
* type-dier in detail::      Voorbeeld van een @code{if} expressie.

Waar en onwaarheid in Emacs Lisp



* nil uitgelegd::            @code{nil} heeft twee betekenissen.

@code{save-excursion}



* Point en mark::            Een overzicht van verschillende locaties.
* Template voor save-excursion::  Template voor save-excursion

Enkele buffer gerelateerde functies



* Meer vinden::              Hoe meer informatie te vinden
* versimpelde-beginning-of-buffer::  Toon @code{goto-char}, @code{point-min} 
                                       en @code{push-mark}.
* mark-whole-buffer::        Bijna hetzelde als @code{beginning-of-buffer}.
* append-to-buffer::         Gebruikt @code{save-excursion} en 
                               @code{insert-buffer-substring}.
* Buffer gerelateerde terugblik::  Terugblik.
* Buffer oefeningen::        Buffer oefeningen

De definitie van @code{mark-whole-buffer}



* mark-whole-buffer overzicht::  mark-whole-buffer overzicht
* Body van mark-whole-buffer::  Slechts drie regels met code

De definitie van @code{append-to-buffer}



* append-to-buffer overzicht::  append-to-buffer overzicht
* append interactief::       Een tweedelige interactieve expressie.
* append-to-buffer body::    Bevat een @code{let} expressie.
* append save-excursion::    Hoe de @code{save-excursion} werkt.

Enkele meer complexe functies



* copy-to-buffer::           Met @code{set-buffer} en 
                               @code{get-buffer-create}.
* insert-buffer::            Read-only en met @code{or}
* beginning-of-buffer::      Toon @code{goto-char}, @code{point-min} en 
                               @code{push-mark}.
* Tweede buffer gerelateerde terugblik::  Tweede buffer gerelateerde 
                                            terugblik
* optionele oefening::       optionele oefening

De definitie van @code{insert-buffer}



* insert-buffer code::       insert-buffer code
* insert-buffer interactief::  Wanneer je kan lezen maar niet schrijven.
* insert-buffer body::       The body heeft een @code{or} en een @code{let}.
* if en or::                 Gebruik een @code{if} in plaats van een 
                               @code{or}.
* Voeg or in::               Hoe de @code{or} expressie werkt.
* Voeg let in::              Twee @code{save-excursion} expressies.
* Nieuwe insert-buffer::     Nieuwe insert-buffer

De interactieve expressie in @code{insert-buffer}



* Read-only buffer::         Wanneer een buffer niet gewijzigd kan worden.
* b for interactief::        Een bestaand buffer of anders zijn naam.

Complete definitie van @code{beginning-of-buffer}



* Optionele argumenten::     Optionele argumenten
* beginning-of-buffer opt arg::  Voorbeeld met optioneel argument.
* beginning-of-buffer compleet::  beginning-of-buffer compleet

@code{beginning-of-buffer} met een argument



* Ontrafelen beginning-of-buffer::  Ontrafelen beginning-of-buffer
* In geval van een groot buffer::  In geval van een groot buffer
* In geval van een klein buffer::  In geval van een klein buffer

Versmallen en verbreden



* Voordelen van versmallen::  De voordelen van versmallen
* save-restriction::         De @code{save-restriction} speciale vorm.
* what-line::                Het regelnummer waarop de point is.
* versmal oefening::         versmal oefening

@code{car}, @code{cdr}, @code{cons}: Fundamentele functies



* Vreemde namen::            Een historische terzijde: waarom de vreemde 
                               namen?
* car en cdr::               Functies om een deel van een lijst te 
                               extraheren.
* cons::                     Een lijst construeren.
* nthcdr::                   @code{cdr} herhaaldelijk aanroepen.
* nth::                      nth
* setcar::                   Het eerste element van een lijst veranderen.
* setcdr::                   De rest van de lijst veranderen.
* cons oefening::            cons oefening

@code{cons}



* Bouw een lijst::           Bouw een lijst
* length::                   Hoe de lengte van een lijst te vinden.

Tekst knippen en opslaan



* Tekst opslaan::            Tekst wordt opgeslagen in een lijst.
* zap-to-char::              Tekst tot aan een karakter knippen.
* kill-region::              Tekst uit een gebied knippen.
* copy-region-as-kill::      Een definitie van tekst kopiëren.
* Uitwijding naar C::        Kleine opmerking over C programmeertaal macros.
* defvar::                   Hoe een variabele een initiële waarde te geven.
* cons en search-fwd terugblik::  cons en search-fwd terugblik
* zoek oefening::            zoek oefening

@code{zap-to-char}



* Complete zap-to-char::     De complete implementatie.
* zap-to-char interactief::  Een driedelige iteractive expressie.
* zap-to-char body::         Een kort overzicht.
* search-forward::           Hoe naar een string te zoeken.
* progn::                    De @code{progn} speciale vorm.
* Samenvatting zap-to-char::  Gebruik @code{point} en @code{search-forward}.

@code{kill-region}



* Complete kill-region::     De functiedefinitie.
* condition-case::           Met een probleem omgaan
* Lisp macro::               Lisp macro

@code{copy-region-as-kill}



* Complete copy-region-as-kill::  De complete functiedefinitie.
* copy-region-as-kill body::  De body van @code{copy-region-as-kill}.

De body van @code{copy-region-as-kill}



* last-command en this-command::  last-command en this-command
* kill-append functie::      kill-append functie
* kill-new functie::         kill-new functie

Initialiseer een variabele met @code{defvar}



* Inzien huidige variabele waarde::  Inzien huidige variabele waarde
* defvar en asterisk::       defvar en asterisk

Hoe lijsten zijn geïmplementeerd



* Lijsten uitgetekend::      Lijsten uitgetekend
* Symbolen als ladekast::    Een krachtige metafoor verkennen.
* Lijst oefening::           Lijst oefening

Tekst terug yanken



* Killring overzicht::       Killring overzicht
* kill-ring-yank-pointer::   De killring is een lijst.
* yank nthcdr oefeningen::   De @code{kill-ring-yank-pointer} variabele.

Loops en recursie



* while::                    Een stuk code zich laten herhalen.
* dolist dotimes::           dolist dotimes
* Recursie::                 Een functie zichzelf laten aanroepen.
* Looping oefening::         Looping oefening

@code{while}



* Looping met while::        Herhaal zolang de test waar teruggeeft.
* Loop voorbeeld::           Een @code{while} loop die een lijst gebruikt.
* print-elements-of-list::   Gebruik @code{while}, @code{car}, @code{cdr}.
* Incrementele loop::        Een loop met een incrementele teller.
* Incrementele loop details::  Incrementele loop details
* Decrementele loop::        Een loop met een aflopende teller.

Details van een incrementele loop



* Incrementeel voorbeeld::   Steentjes in een driehoek tellen.
* Inc voorbeeld onderdelen::  De onderdelen van een functiedefinitie.
* inc voorbeeld samengesteld::  De functiedefinitie samenstellen.

Loop met een decrementele teller



* Decerementeel voorbeeld::  Meer steentjes op het strand.
* Dec voorbeeld onderdelen::  De onderdelen van een functiedefinitie.
* Dec voorbeeld samengesteld::  De functiedefinitie samenstellen.

Bespaar je tijd: @code{dolist} en @code{dotimes}



* dolist::                   dolist
* dotimes::                  dotimes

Recursie



* Robots bouwen::            Zelfde model, verschillend serienummer ...
* Recursive definitie onderdelen::  Loop totdat je stopt ...
* Recursie met lijst::       Een lijst gebruiken als test of je moet 
                               recursen.
* Recursieve driehoek functie::  Recursieve driehoek functie
* Recursie met cond::        Recursie met cond
* Recursieve patronen::      Veelgebruikte templates.
* Geen uitstel::             Sla geen werk op ...
* Zonder uitstel oplossing::  Zonder uitstel oplossing

Recursie in plaats van een teller



* Recursief voorbeeld arg van 1 of 2::  Recursief voorbeeld arg van 1 of 2
* Recursief voorbeeld arg van 3 of 4::  Recursief voorbeeld arg van 3 of 4

Recursieve patronen



* Elke::                     Elke
* Accumuleren::              Accumuleren
* Bewaar::                   Bewaar

Reguliere expressie zoekopdrachten



* sentence-end::             De reguliere expressie van @code{sentence-end}.
* re-search-forward::        Erg vergelijkbaar met @code{search-forward}.
* forward-sentence::         Een eenvoudig voorbeeld van regexp 
                               zoekopdracht.
* forward-paragraph::        Een iets complexer voorbeeld.
* Regexp terugblik::         Regexp terugblik
* re-search oefeningen::     re-search oefeningen

@code{forward-sentence}



* Complete forward-sentence::  Complete forward-sentence
* fwd-sentence while loops::  Twee @code{while} loops.
* fwd-sentence re-search::   Een reguliere expressie zoekopdracht.

@code{forward-paragraph}: een goudmijn van functies



* forward-paragraph in het kort::  Belangrijke onderdelen van de 
                                     functiedefinitie.
* fwd-para let::             De @code{let*} expressie
* fwd-para while::           De voorwaartse beweging @code{while} loop.

Tellen: repetitie en regexps



* Waarom woorden tellen::    Waarom woorden tellen
* @value{TEL-WOORDEN}::      Gebruik een regexp, maar vindt een probleem.
* recursive-count-words::    Start met het geval van geen woorden in de 
                               region.
* Tellen voorbeeld::         Tellen voorbeeld

De @code{@value{TEL-WOORDEN}} functie



* Ontwerp @value{TEL-WOORDEN}::  De definitie met @code{while} loop.
* Witte ruimte bug::         De witte ruimte bug in 
                               @code{@value{TEL-WOORDEN}}

Woorden tellen in een @code{defun}



* Verdeel en heers::         Verdeel en heers
* Woorden en symbolen::      Wat te tellen?
* Syntax::                   Wat vormt een woord of een symbool?
* count-words-in-defun::     Erg vergelijkbaar met 
                               @code{@value{TEL-WOORDEN}}
* Enkele defuns::            Enkele defuns in een bestand tellen.
* Een bestand vinden::       Wil je naar een bestand kijken?
* lengte-lijst-bestand::     Een lijst met de lengtes van veel definities.
* Enkele bestanden::         Tellen in definities in verschillende 
                               bestanden.
* Enkele bestanden recursief::  Recursief tellen in verschillende bestanden.
* De data voorbereiden::     De data voorbereiden om in een grafiek te 
                               tonen.

Woorden tellen in  @code{defuns} in verschillende bestanden



* lengths-list-many-files::  Een lijst met de lengte van defuns teruggeven.
* append::                   Een lijst aan een andere koppelen.

De data voorbereiden om in een grafiek te tonen



* Data in detail te tonen::  Data in detail te tonen
* Sorteren::                 Lijsten sorteren
* Bestandenlijst::           Een lijst van bestanden maken.
* Functiedefinities tellen::  Functiedefinities tellen

Een grafiek voorbereiden



* Kolommen van een grafiek::  Kolommen van een grafiek
* graph-body-print::         Hoe de body van een grafiek af te drukken.
* recursive-graph-body-print::  recursive-graph-body-print
* Afgedrukte assen::         Afgedrukte assen
* Lijngrafiek oefening::     Lijngrafiek oefening

Jouw @file{.emacs} bestand



* Default configuratie::     Default configuratie
* Site-wide init::           Je kunt systeem-brede init bestanden schrijven.
* defcustom::                Emacs schrijft de code voor je.
* Een init bestand beginnen::  Hoe een @file{.emacs} init bestand te 
                                 schrijven.
* Tekst en auto-fill::       Automatisch regels afbreken.
* Mail aliasen::             Gebruik afkortingen voor e-mailadressen.
* Indent Tabs Mode::         Gebruik geen tabs met @TeX{}
* Key bindings::             Enkele persoonlijke key bindings maken.
* Keymaps::                  Meer over key binding.
* Bestanden laden::          Automatisch bestanden laden (en dus evalueren).
* Autoload::                 Functies beschikbaar maken.
* Eenvoudige uitbreiding::   Definieer een functie, bind het aan een toets.
* X11 kleuren::              Kleuren in X.
* Diverse::                  Diverse
* Mode line::                Hoe je mode line aan te passen

Debuggen.



* debug::                    Hoe de ingebouwde debugger te gebruiken.
* debug-on-entry::           Start debugen wanneer je een functie aanroept.
* debug-on-quit::            Start debuggen wanneer je quit met @kbd{C-g}.
* edebug::                   Hoe je Edebug gebruikt, een source level 
                               debugger.
* Debuggen oefeningen::      Debuggen oefeningen

De killring hanteren



* Wat de killring doet::     Wat de killring doet
* current-kill::             current-kill
* yank::                     Plak een kopie van een afgeknipt element
* yank-pop::                 Element waar naar verwezen wordt invoegen.
* ring bestand::             ring bestand

De @code{current-kill} functie



* Code voor current-kill::   Code voor current-kill
* current-kill begrijpen::   current-kill begrijpen

Overzicht @code{current-kill}



* Body van current-kill::    Body van current-kill
* Uitwijding over fout::     Hoe mensen te misleiden, maar niet computers.
* Het element vaststellen::  Het element vaststellen

Een grafiek met labels op de assen



* Gelabeld voorbeeld::       Gelabeld voorbeeld
* print-graph varlist::      @code{let} expressie in @code{print-graph}
* print-Y-axis::             Print een label voor de verticale as
* print-X-axis::             Print een horizontaal label
* De gehele grafiek afdrukken::  De functie om een hele grafiek te printen.

De @code{print-Y-axis} functie



* print-Y-axis in detail::   print-Y-axis in detail
* Hoogte van label::         Welke hoogte voor de Y-as?
* Bereken het restant::      Hoe het restant van een deling te berekenen.
* Y-as element::             Een lijn voor de y-as construeren.
* Y-axis-column::            Een lijst van y-as labels genereren.
* print-Y-axis enalaatste::  Nog niet finale versie

De @code{print-X-axis} functie



* Overeenkomsten verschillen::  Grotendeels als @code{print-Y-axis}, maar 
                                  niet helemaal gelijk.
* X-as tic marks::           Maak tic marks voor de horizontale as.

De hele grafiek afdrukken



* De finale versie::         Enkele veranderingen.
* Test print-graph::         Een korte test draaien.
* Woorden in defuns grafisch weergeven::  De finale code uitvoeren.
* lambda::                   Hoe een anonyme functie te schrijven
* mapcar::                   Een functie toepassen op de elementen van een 
                               lijst.
* Een andere bug::           Weer een andere bug @dots{} erg verraderlijk.
* Finale afgedrukte grafiek::  De grafiek zelf

@end detailmenu
@end menu

@node Voorwoord
@unnumbered Voorwoord

Het grootste deel van de GNU Emacs geïntegreerde omgeving is geschreven in
de programmeertaal met de naam Emacs Lisp. De code in deze taal is de
software, de verzameling instructies, die de computer vertellen wat te doen
wanneer je die commando's geeft. Emacs is zo ontworpen dat je nieuwe code in
Emacs Lisp kunt schrijven en die makkelijk als uitbreiding op de editor
installeert.

(GNU Emacs wordt soms een `uitbreidbare editor'' genoemd, maar biedt veel
meer dan mogelijkheden voor tekstbewerking. Het is beter om Emacs als een
``uitbreidbare computer omgeving'' te beschrijven. Dat is echter nogal een
mond vol. Het is eenvoudiger om Emacs een editor te noemen. Bovendien is
alles wat je in Emacs doet, zoals het vinden van de Maya-datum, fasen van de
maan, het vereenvoudigen van polynomen, code debuggen, bestanden beheren,
brieven lezen, boeken schrijven, al deze activiteiten komen neer op tekst
bewerken in de breedste zin van het woord.)

@menu
* Waarom::                   Waarom Emacs Lisp leren?
* Over het lezen van deze tekst::  Lees, raak vertrouwd en ontwikkel 
                                     gewoontes ...
* Doelgroep::                Voor wie dit is geschreven
* Geschiedenis van Lisp::    Geschiedenis van Lisp
* Opmerking voor beginners::  Je kunt dit lezen als beginner
* Dank::                     Dank
@end menu

@ifnottex
@node Waarom
@unnumberedsec Why Study Emacs Lisp?
@end ifnottex

Alhoewel men Emacs Lisp meestal alleen in samenhang met Emacs ziet, is het
een volwaardige computer programmeertaal. Je kunt Emacs Lisp net als elke
andere programmeertaal gebruiken.

Misschien wil je programmeren begrijpen, misschien wil je Emacs uitbreiden,
of misschien wil je een programmeur worden. Deze introductie in Emacs Lisp
is bedoeld om je op weg te helpen, je te begeleiden bij het leren van de
beginselen van programmeren en, belangrijker, te laten zien hoe je jezelf
kunt leren verder te gaan.

@node Over het lezen van deze tekst
@unnumberedsec Over het lezen van deze tekst

Verspreid over dit document kom je kleine voorbeeldprogramma's tegen die je
in Emacs kunt draaien. Wanneer je dit document in Info binnen GNU Emacs
leest, dan draai je de programma's zoals ze verschijnen. (Dit is eenvoudig
te doen en wordt uitgelegd bij de presentatie van de voorbeelden.) Daarnaast
kan je deze introductie lezen in een gedrukt boek zittend bij een computer
waarop Emacs draait. (Dit is wat ik graag doe, ik hou van gedrukte boeken.)
Wanneer je geen draaiende Emacs bij de hand hebt dan kan je nog steeds dit
boek lezen. Beschouw het in dat geval als een roman of een reisgids naar een
land waar je niet geweest bent, interessant, maar niet hetzelfde als er
daadwerkelijk zijn.

Een groot deel van deze introductie leidt je rond door de code van GNU
Emacs. Deze rondleidingen dienen twee doeleinden. Ten eerste om je vertrouwd
te maken met de echte, werkende code (code die je dagelijks gebruikt) en ten
tweede om je vertrouwd te maken met de manier waarop Emacs werkt. Het is
interessant te zien hoe een werkomgeving is geïmplementeerd. Ook hoop ik dat
je de gewoonte overneemt om de source code door te bladeren. Je kan er van
leren en je kunt er ideeën uit halen. GNU Emacs hebben is zoals een
drakengrot vol schatten hebben.

Naast het leren van Emacs als editor en Emacs Lisp als programmeertaal geven
de voorbeelden en de rondleiding je de gelegenheid vertrouwd te raken met
Emacs als een Lisp programmeeromgeving. GNU Emacs ondersteunt het
programmeren en verschaft gereedschappen waar je comfortabel gebruik van
wilt maken, zoals @kbd{M-.} (de toetsaanslag waarmee je het
@code{xref-find-definitions} commando start). Je leert ook over buffers en
andere objecten die onderdeel van de omgeving uitmaken. Deze
functionaliteiten van Emacs ontdekken is als nieuwe routes door je
geboorteplaats ontdekken.

@ignore
In addition, I have written several programs as extended examples.
Although these are examples, the programs are real.  I use them.
Other people use them.  You may use them.  Beyond the fragments of
programs used for illustrations, there is very little in here that is
just for teaching purposes; what you see is used.  This is a great
advantage of Emacs Lisp: it is easy to learn to use it for work.
@end ignore

Tenslotte hoop ik hiermee vaardigheden over te brengen over het gebruik van
Emacs om aspecten van het programmeren te leren die je nog niet weet. Vaak
kan Emacs je helpen om dingen te begrijpen of te ontdekken hoe je iets
nieuws doet. Deze zelfredzaamheid is niet alleen prettig, maar ook een
voordeel.

@node Doelgroep
@unnumberedsec Voor wie dit is geschreven

De tekst is bedoeld als een elementaire introductie voor mensen die geen
programmeur zijn. Wanneer je een programmeur bent, zal je niet tevreden zijn
met deze introductie. De reden daarvoor is dat je waarschijnlijk een expert
bent geworden in het lezen van referentiehandleidingen en niet blij wordt
van de manier waarop deze tekst is opgezet.

Een expert-programmeur die deze tekst heeft gereviewed zei me:

@quotation
@i{Ik geeft de voorkeur aan het bestuderen van referentiehandleidingen. Ik
``duik'' in elke paragraaf en ``kom boven voor lucht'' tussen de
paragrafen. }

@i{Wanneer ik aan het einde van een paragraaf ben verwacht ik dat het onderwerp
klaar is, dat ik alles weet wat ik moet weten (met als mogelijke
uitzondering het geval de volgende paragraaf dieper op de inhoud ingaat). Ik
verwacht dat een goed geschreven referentiehandleiding weinig herhaling
bevat en dat het uitstekende verwijzingen heeft naar de (enige) plek waar de
informatie is die ik zoek.}
@end quotation

Deze introductie in niet voor die persoon geschreven!

Ten eerste probeer ik alles tenminste drie keer te behandelen: eerst om het
te introduceren, dan om het in context te laten zien, en vervolgens in een
andere context, of om het te herhalen.

Ten tweede stop ik vrijwel nooit alle informatie over een onderwerp op een
enkele plek, laat staat in een paragraaf. In mijn manier van denken legt dit
een te zware last op de lezer. In plaats daarvan probeer ik alleen uit te
leggen wat de lezer op dat moment moet weten. (Soms voeg ik wat extra
informatie toe zodat je later niet verrast wordt wanneer de aanvullende
informatie formeel wordt geïntroduceerd.)

Wanneer je deze test leest wordt niet van je verwacht dat je alles meteen de
eerste keer leert. Je hoeft slechts vluchtig kennis te maken met enkele van
de genoemde onderdelen. Ik hoop dat ik de tekst zo gestructureerd heb en je
genoeg hints gegeven heb dat je bewust bent van wat belangrijk is en je
daarop concentreert.

Je zult in sommige paragrafen moeten duiken, er is geen andere manier om die
te lezen. Maar ik heb geprobeerd hun aantal zo klein mogelijk te houden. Dit
boek is bedoeld als een toegankelijke heuvel in plaats van een ontmoedigende
berg.

Dit boek, @cite{Een introductie in programmeren in Emacs Lisp}, heeft een
bijpassend document,
@iftex
@cite{The GNU Emacs Lisp Reference Manual}.
@end iftex
@ifnottex
@ref{Top, , The GNU Emacs Lisp Reference Manual, elisp, The GNU Emacs Lisp
Reference Manual}.
@end ifnottex
Deze referentiehandleiding bevat meer details dan deze introductie. In de
referentiehandleiding is alle informatie met betrekking tot een onderwerp op
een plek geconcentreerd. Je zou die moeten gebruiken wanneer je bent zoals
de hierboven genoemde programmeur. En nadat je deze @cite{Introductie}
gelezen hebt is de @cite{Reference Manual} natuurlijk  bruikbaar tijdens het
schrijven van je eigen programma's.

@node Geschiedenis van Lisp
@unnumberedsec Geschiedenis van Lisp
@cindex Lisp geschiedenis

Lisp is oorspronkelijk eind jaren '50 ontwikkeld in het Massachusetts
Institute of Technology voor onderzoek op het gebied van kunstmatige
intelligentie. De grote kracht van de Lisp taal maakt het ook voor andere
toepassingen superieur, zoals het schrijven van editor-commando's en
geïntegreerde omgevingen. 

@cindex Maclisp
@cindex Common Lisp
GNU Emacs Lisp is grotendeels geïnspireerd door Maclisp, dat in de jaren '60
in het MIT is geschreven. Het is ook enigszins geïnspireerd door Common
Lisp, dat in de jaren '80 een standaard werd. Emacs Lisp is echter een stuk
eenvoudiger dan Common Lisp. (De standaard Emacs distributie bevat een
optioneel uitbreidingsbestand @file{cl-lib.el}, dat veel Common Lisp
functionaliteiten aan Emacs Lisp toevoegt.)

@node Opmerking voor beginners
@unnumberedsec Een opmerking voor beginners

Ook als je GNU Emacs niet kent heeft het lezen van dit document  veel
nut. Ik raad je echter aan om Emacs te leren, al is het alleen maar te leren
hoe je over het scherm beweegt. Je kunt zelf het gebruik van Emacs leren met
de ingebouwde tutorial. Om die  te gebruiken, type je @kbd{C-h t}. (Dit
betekent dat je de toetsen @key{CTRL} @kbd{h} tegelijk indrukt en loslaat,
en daarna de toets @kbd{t} indrukt en loslaat.) 

Ook verwijs ik vaak naar Emacs's standaard commando's door de
toetscombinaties te noemen die je gebruikt om het commando aan te roepen en
vervolgens de naam van het commando tussen haakjes, zoals dit:x @kbd{C-M-\}
(@code{indent-region}). Wat dit betekent is dat het @code{indent-region}
commando gebruikelijk wordt aangeroepen door @kbd{C-M-\} te typen. (Je kunt,
als je dat wilt, de toetscombinaties  om commando's aan te roepen wijzigen,
dit heet @dfn{rebinding}.  @xref{Keymaps, , Keymaps}.)  De afkorting
@kbd{C-M-\} betekent dat je de @key{CTRL}-toets, de @key{META}-toets en de
@kbd{\}-toets  allemaal tegelijk indrukt. Soms wordt een toetscombinatie als
dit een keychord genoemd, omdat het vergelijkbaar is met de manier waarop je
een akkoord op een piano speelt. Wanneer je toetsenbord geen
@key{META}-toets heeft, dan gebruik je de @key{ESC}-toets als prefix. In dat
geval betekent @kbd{C-M-\} dat je eerst de @key{ESC} indrukt en loslaat en
daarna tegelijkertijd de @key{CTRL}-toets en de @kbd{\}-toets indrukt. Maar
meestal betekent @kbd{C-M-\} dat je de @key{CTRL}-toets samen met de toets
die als @key{ALT} is gelabeld indrukt en tegelijkertijd de @kbd{\}-toets
indrukt.

In aanvulling op het typen van een toetscombinatie, kan je wat je typt
uitbreiden met de prefix @kbd{C-u}, wat het @dfn{universal argument}
heet. De @kbd{C-u}-toetscombinatie geeft een argument door aan het
eerstvolgende commando. Dus, om een gebied met gewone tekst 6 spaties te
indenten, markeer je het gebied en vervolgens type je @w{@kbd{C-u 6
C-M-\}}. (Wanneer je geen getal opgeeft, dan geeft Emacs hetzij het getal 4
door aan het commando, of voert het commando anders uit). @xref{Arguments, ,
Numeric Arguments, emacs, The GNU Emacs Manual}.

Wanneer je dit in Info met GNU Emacs leest, dan kun je het hele document
lezen slechts door het indrukken van de spatiebalk, @key{SPC}. (Om meer over
Info te leren, type @kbd{C-h i} en selecteer daarna Info.)

Een opmerking over terminologie: wanneer ik het woord Lisp alleen gebruik,
dan refereer ik meestal naar de verschillende dialecten van Lisp in het
algemeen, maar wanneer ik het over Emacs Lisp heb, dan refereer ik naar GNU
Emacs Lisp in het bijzonder.

@node Dank
@unnumberedsec Dank

Mijn dank aan iedereen die met met dit boek hielpen. Mijn speciale dank gaat
uit naar @r{Jim Blandy}, @r{Noah Friedman}, @w{Jim Kingdon}, @r{Roland
McGrath}, @w{Frank Ritter}, @w{Randy Smith}, @w{Richard M. Stallman} en
@w{Melissa Weisshaus}. Mijn dank gaat ook uit naar @w{Philip Johnson} en
@w{David Stampe} voor hun geduldige aanmoediging. Mijn vergissingen zijn van
mij zelf. 

@flushright
Robert J. Chassell
@ifnothtml
@email{bob@@gnu.org}
@end ifnothtml
@ifhtml
bob@@gnu.org
@end ifhtml
@end flushright

@c ================ Beginning of main text ================

@c Start main text on right-hand (verso) page

@tex
\par\vfill\supereject
\headings off
\ifodd\pageno
    \par\vfill\supereject
\else
    \par\vfill\supereject
    \page\hbox{}\page
    \par\vfill\supereject
\fi
@end tex

@c Note: this resetting of the page number back to 1 causes TeX to gripe
@c about already having seen page numbers 1-4 before (in the preface):
@c   pdfTeX warning (ext4): destination with the same identifier (name{1})
@c   has been already used, duplicate ignored
@c I guess that is harmless (what happens if a later part of the text
@c makes a link to something in the first 4 pages though?).
@c E.g., note that the Emacs manual has a preface, but does not bother
@c resetting the page numbers back to 1 after that.
@c Alternatively, uncomment the 3 lines above (search for ``pageno'')
@c to have the preface numbered in roman numerals.
@iftex
@headings off
@evenheading @thispage @| @| @thischapter
@oddheading @thissection @| @| @thispage
@global@pageno = 1
@end iftex

@node Lijsten verwerken
@chapter Lijsten verwerken

Voor het ongetrainde oog is Lisp een vreemde programmeertaal. In Lisp code
staan overal haakjes. Sommige mensen stellen zelfs dat de naam voor ``Lots
of Isolated Silly Parentheses'' staat. Maar die stelling is ongegrond. Lisp
staat voor  LISt Processing en de programmeertaal behandelt @emph{lijsten}
(en lijsten van lijsten) door ze tussen haakjes te zetten. De haakjes
markeren de grenzen van de lijst. Soms wordt een lijst voorafgegaan door een
apostrof @samp{'}, in Lips heet dat een @dfn{single-quote}. @footnote{Een
single-quote is een afkorting voor de speciale vorm @code{quote}. Je hoeft
nu nog niet over speciale vormen na te denken.
@ifnottex
@xref{Complicaties}.
@end ifnottex
@iftex
@xref{Lisp interpreter}.
@end iftex
} Lijsten zijn de basis van Lisp.

@menu
* Lisp lijsten::             Wat zijn lijsten
* Draai een programma::      Elke lijst in Lisp is een programma gereed om 
                               te draaien.
* Fouten maken::             Een foutboodschap genereren
* Namen en definities::      Namen van symbolen en functie-definities.
* Lisp interpreter::         Wat de Lisp interpreter doet.
* Evaluatie::                Een programma draaien
* Variabelen::               Een waarde van een variabele teruggeven
* Argumenten::               Informatie doorgeven aan een functie
* setq::                     De waarde van een variabele zetten.
* Samenvatting::             De belangrijkste punten
* Foutmelding oefeningen::   Foutmelding oefeningen
@end menu

@node Lisp lijsten
@section Lisp lijsten
@cindex Lisp lijsten

In Lisp ziet een lijst er zo uit: @code{'(roos viool madelief
boterbloem)}. Deze lijst wordt voorafgegaan door een enkele apostrof. Het
kon net zo goed als volgt geschreven worden, wat meer lijkt op de soort van
lijsten waar je waarschijnlijk bekend mee bent:

@smallexample
@group
'(roos
  viool
  madelief
  boterbloem)
@end group
@end smallexample

@noindent
De elementen van deze lijst zijn de namen van vier verschillende bloemen,
onderling gescheiden door witte ruimte en omgeven door haakjes, net als
bloemen in een veld met een stenen muur er omheen.
@cindex Bloemen in een veld

@menu
* Genummerde lijsten::       Lijsten bevatten getallen en andere lijsten
* Lisp atomen::              Elementaire entiteiten
* Whitespace in lijsten::    Lijsten leesbaar formatteren
* Typen van lijsten::        Hoe GNU Emacs helpt bij het typen van lijsten
@end menu

@ifnottex
@node Genummerde lijsten
@unnumberedsubsec Getallen, lijsten binnen lijsten
@end ifnottex

Lijsten kunnen ook getallen bevatten, zoals deze lijst: @code{(+ 2 2)}. Deze
lijst heeft een plusteken, @samp{+}, gevolgd door twee @samp{2}-en,
onderling gescheiden met witte ruimte.

In Lisp worden zowel data als programma's op dezelfde manier
gerepresenteerd. Het zijn beiden lijsten van woorden, getallen, andere
lijsten, gescheiden door witte ruimte en omgeven door haakjes. (Omdat een
programma er uit ziet als data, kan het ene programma makkelijk dienen als
data voor een ander; dit is een erg krachtige eigenschap van Lisp.)
(Overigens, deze twee opmerkingen tussen haakjes zijn @emph{geen} Lisp
lijsten, omdat zij @samp{;} en @samp{.} als leesteken bevatten.) 

@need 1200
Hier is een andere lijst, deze keer met daarin een lijst.

@smallexample
'(deze lijst heeft (van binnen een lijst))
@end smallexample

De componenten van deze lijst zijn de woorden @samp{deze}, @samp{lijst},
@samp{heeft} en de lijst @samp{(van binnen een lijst)}. De binnenste lijst
bestaat uit de woorden @samp{van}, @samp{binnen}, @samp{een} en
@samp{lijst}. 

@node Lisp atomen
@subsection Lisp atomen
@cindex Lisp atomen

Wat we woorden genoemd hebben, heten in Lisp @dfn{atomen}. Deze term komt
van de historische betekenis van het woord atoom, wat ``onscheidbaar''
betekent. Wat Lisp betreft kunnen de woorden die we in de lijst gebruikt
hebben niet in kleinere delen opgedeeld worden en nog steeds dezelfde
betekenis als onderdeel van een programma hebben, net als getallen en
enkele-karakter symbolen zoals @samp{+}. Aan de andere kant, in
tegenstelling tot het oude atoom, kan een lijst in delen worden
opgesplitst. (@xref{car cdr en cons, , @code{car} @code{cdr} en @code{cons}
Fundamentele functies}.) 

In een lijst worden atomen onderling gescheiden door witte ruimte. Zij
kunnen meteen naast een haakje staan.

@cindex @samp{empty list} gedefinieerd
Technisch gesproken bestaat een lijst in Lisp uit haakjes rondom atomen
gescheiden door witte ruimte of rondom andere lijsten of rondom zowel atomen
als andere lijsten. Een list kan slechts een atoom bevatten, of helemaal
niets bevatten. Een lijst met niets er in ziet er zo uit: @code{()}, en heet
een @dfn{lege lijst}. In tegenstelling tot alles anders wordt een lege lijst
tegelijk zowel als een atoom als een lijst beschouwd. 

@cindex Symbolische expressies, geïntroduceerd
@cindex @samp{expressie} gedefinieerd
@cindex @samp{vorm} gedefinieerd
De afgedrukte representatie van zowel atomen als lijsten heten
@dfn{symbolische expressies} of, korter, @dfn{s-expressies}. Het woord
@dfn{expressie} op zichzelf kan hetzij naar de afgedrukte representatie
hetzij naar het atoom of lijst zoals die intern in de computer staat
verwijzen. Vaak gebruiken mensen de term @dfn{expressie} willekeurig. (Ook
wordt in veel teksten het woord @dfn{vorm} gebruikt als synoniem voor
expressie.)

@c This and the next paragraph say ``kinds of atom'', but that is not
@c a typo, just slightly ``old-fashioned wording which adds a fillip
@c of interest to it'', and ``is more elegant writing'', according to
@c RMS.
Toevallig werden de atomen waaruit ons universum bestaat zo genoemd omdat
men dacht dat ze ondeelbaar zijn, maar er is vastgesteld dat fysieke atomen
niet ondeelbaar zijn. Deeltjes kunnen van een atoom afsplitsen of het kan
zich in twee ongeveer even grote delen opsplitsen. Fysieke atomen werden
voortijdig zo genoemd, voordat hun ware aard was ontdekt. In Lisp kunnen
sommige soorten atomen, zoals een array, in delen worden gescheiden, maar
het mechanisme om dit te doen wijkt af van het mechanisme om een lijst op te
splitsen. Voor zover het lijst-operaties betreft, zijn de atomen van een
lijst ondeelbaar.

Net als in het Engels, is de betekenis van de samenstellende letters van een
Lisp atoom verschillend van de betekenis die de letters als woord
maken. Bijvoorbeeld het Engelse woord voor de Zuid-Amerikaanse luiaard,
@samp{ai}, is volledig anders dan de twee Engelse woorden @samp{a} en
@samp{i}. 

In de natuur bestaan veel verschillende soorten atomen, maar slechts een
paar in Lisp: bijvoorbeeld @dfn{getallen}, zoals 37, 511 of 1729, en
@dfn{symbolen}, zoals @samp{+}, @samp{foo}, of @samp{forward-line}. In het
dagelijks Lisp taalgebruik wordt het woord ``atoom'' maar weinig gebruikt,
omdat programmeurs meestal specifieker zijn over het soort atoom waar ze mee
te maken hebben. Lisp programmeren betreft hoofdzakelijk symbolen (en soms
getallen) binnen lijsten. (Overigens, de voorgaande opmerking met drie
woorden tussen haakjes is een geldige lijst in Lisp, omdat het uit atomen
bestaat, welke in dit geval symbolen zijn, gescheiden door witte ruimte en
omgeven door haakjes, zonder enige non-Lisp leestekens.)

@need 1250
Tekst tussen dubbele aanhalingstekens ---zelfs zinnen en paragrafen--- is
ook een atoom. Hier is een voorbeeld:
@cindex Tekst tussen dubbele aanhalingstekens

@smallexample
'(deze lijst bevat "tekst tussen aanhalingstekens.")
@end smallexample

@cindex @samp{string} gedefinieerd
@noindent
In Lisp is alle gequote tekst inclusief leestekens en witte ruimte een
enkele atoom. Deze atoom-soort heet een @dfn{string} (wegens ``string of
characters'') en is het soort dingen dat gebruikt wordt voor boodschappen
die de computer toont om door mensen gelezen te worden. Strings zijn een
andere atoom-soort dan getallen of symbolen en worden anders gebruikt.

@node Whitespace in lijsten
@subsection Whitespace in lijsten
@cindex Witte ruimte in lijsten

@need 1200
De hoeveelheid witte ruimte in een lijst maakt niet uit. Vanuit het
gezichtspunt van de Lisp taal, is

@smallexample
@group
'(deze lijst
    lijkt op dit)
@end group
@end smallexample

@need 800
@noindent
exact hetzelfde als dit:

@smallexample
'(deze lijst lijkt op dit)
@end smallexample

Beide voorbeelden tonen wat Lisp als dezelfde lijst ziet, de lijst
samengesteld uit de symbolen @samp{deze}, @samp{lijst}, @samp{lijkt},
@samp{op} en @samp{dit} in die volgorde.

Extra witte ruimte en regels zijn bedoeld om de lijst meer voor mensen
leesbaar te maken. Wanneer Lisp de expressie leest, verwijdert het alle
extra witte ruimte (maar heeft tenminste een spatie tussen de atomen nodig
om ze uit elkaar te houden).

Hoe vreemd het ook lijkt, de voorbeelden die we gezien hebben dekken alles
hoe lijsten er uit zien! Elke andere lijst in Lisp ziet er min of meer
hetzelfde uit als een van deze voorbeelden, behalve dat de lijst langer of
meer complex kan zijn. In het kort, een lijst is tussen haakjes, een string
tussen aanhalingstekens, een symbool ziet er uit als een woord en een getal
als een getal. (Voor bepaalde situaties worden vierkante haken, punten en
enkele andere speciale karakters gebruikt, maar we gaan vrij ver zonder
hen.)

@node Typen van lijsten
@subsection GNU Emacs helpt je om lijsten te typen
@cindex Hulp bij lijsten typen
@cindex Hulp bij formatteren

Wanneer je een Lisp expressie in GNU Emacs typt, met hetzij Lisp Interaction
mode of Emacs Lisp mode, dan zijn verschillende commando's beschikbaar om de
Lisp expressie zo te formatteren dat deze makkelijk te lezen
is. Bijvoorbeeld het indrukken van de @key{TAB}-toets laat de regel waar de
cursor is automatisch met de juiste hoeveelheid inspringen. Het commando om
de code in een region juist te laten inspringen is normaal gesproken
gebonden aan @kbd{C-M-\}. De inspringingen zijn ontworpen om te laten zien
welke elementen van een lijst bij welke lijst horen---elementen van een
sub-lijst springen meer in dan elementen van de insluitende lijst.

Bovendien, wanneer je een haakje sluiten typt, dan laat Emacs tijdelijk de
cursor terugspringen naar het bijbehorende haakje openen, zodat je kunt zien
welke dat is. Dit is erg zinvol, omdat elke lijst die je typt in Lisp een
haakje sluiten horend bij zijn haakje openen moet hebben. (@xref{Major
Modes, , Major Modes, emacs, The GNU Emacs Manual}, voor meer informatie
over Emacs's modes.)

@node Draai een programma
@section Draai een programma
@cindex Een programma draaien
@cindex Draai een programma

@cindex @samp{evaluate} gedefinieerd
Een lijst in Lisp---elke lijst---is een programma om te draaien. Wanneer je
het draait (wat in Lisp-jargon @dfn{evalueren} is), doet de computer een van
deze drie dingen: doe niets behalve de lijst zelf teruggeven; een
foutmelding geven; of het eerste symbool in de lijst behandelen als commando
om iets te doen. (Meestal is dat laatste natuurlijk wat je echt wilt!)

@c use code for the single apostrophe, not samp.
@findex quote
@cindex @code{'} om te quoten
@cindex quoten met de apostrof
@cindex apostrof om te quoten
De enkele apostrof, @code{'}, die ik aan de voorkant van enkele voorbeeld
lijsten in de voorgaande hoofdstukken gebruikte, heten een
@dfn{quote}. Wanneer die aan een lijst voorafgaan, dan vertelt dat Lisp om
niets met de lijst te doen, anders dan te accepteren precies zoals die is
geschreven. Maar wanneer er geen quote aan de lijst voorafgaat, dan is het
eerste element in de lijst speciaal: het is een commando voor de computer om
te gehoorzamen. (In Lisp, heten deze commando's @emph{functies}.) De eerder
genoemde lijst @code{(+ 2 2)} is een instructie om iets met de rest van de
lijst te doen: tel de getallen die volgen op.

@need 1250
Wanneer je dit binnen GNU Emacs in Info leest, dan kun je de lijst als volgt
evalueren: ga met de cursor direct achter het rechtse haakje sluiten staan
van de volgende lijst en typ vervolgens @kbd{C-x C-e}:

@smallexample
(+ 2 2)
@end smallexample

@c use code for the number four, not samp.
@noindent
Je ziet het getal @code{4} verschijnen in het echogebied @footnote{Emacs
toont integer waardes in decimaal, in octaal en in hex en ook als een
karakter, maar laten we deze gemaksfunctie nu even negeren.}. (Wat je
zojuist gedaan hebt is het evalueren van de lijst. Het  echogebied is de
regel aan de onderkant van het scherm dat de  echotekst toont.) Probeer nu
hetzelfde met een gequote lijst: plaats de cursor meteen achter de volgende
lijst en type @kbd{C-x C-e}:

@smallexample
'(dit is een gequote lijst)
@end smallexample

@noindent
Je ziet @code{(dit is een gequote lijst)} in het echogebied verschijnen.

@cindex Lisp interpreter, uitgelegd
@cindex Interpreter, Lisp, uitgelegd
Wat je in beide gevallen deed is het geven van een commando aan een
programma in GNU Emacs met de naam @dfn{Lisp interpreter}---de interpreter
een commando geven om de expressie te evalueren. De naam van de Lisp
interpreter komt van het woord voor de taak die een mens uitvoert die de
betekenis van de expressie bedenkt---die het interpreteert.

Je kunt ook een atoom evalueren dat geen deel van een lijst is---een die
niet door haakjes ingesloten is. Weer vertaalt de Lisp interpreter van de
voor mensen leesbare expressie naar de taal van de computer. Maar voor we
dit bespreken (@pxref{Variabelen}), bespreken we eerste wat de Lisp
interpreter doet wanneer je een fout maakt. 

@node Fouten maken
@section Een foutmelding genereren
@cindex Genereer een foutmelding
@cindex Foutmelding generatie

Deels zodat je je geen zorgen hoeft te maken wanneer je het per ongeluk
doet, geven we nu een commando aan de Lisp interpreter dat een foutmelding
genereert. Dit is een onschuldige activiteit, en wij zullen inderdaad vaker
proberen expres een foutmelding te genereren. Wanneer je eenmaal het jargon
begrijpt, kunnen foutmeldingen informatief zijn. In plaats van
``fout''-meldingen zouden ze ``hulp''-meldingen moeten heten. Zij zijn als
wegwijzers voor een reiziger in een vreemd land. Ze ontcijferen kan moeilijk
zijn, maar wanneer je ze begrijpt wijzen ze je de weg.

De foutmelding wordt gegenereerd door een ingebouwde GNU Emacs debugger. Wij
gaan de debugger binnen. Je verlaat de debugger met het typen van @code{q}.

Wat we gaan doen is het evalueren van een lijst die niet gequote is en niet
een betekenisvol commando als eerste element heeft. Hier is een lijst die
bijna gelijk is aan die we niet gebruikt hebben, maar zonder de voorafgaande
enkele quote. Positioneer de cursor direct er achter en type @kbd{C-x C-e}:

@smallexample
(dit is een ongequote lijst)
@end smallexample

Een @file{*Backtrace*} window opent waarin je het volgende zou moeten zien:

@smallexample
@group
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function dit)
  (dit is een ongequote lijst)
  eval((dit is een ongequote lijst) nil)
  elisp--eval-last-sexp(nil)
  eval-last-sexp(nil)
  funcall-interactively(eval-last-sexp nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------
@end group
@end smallexample

@need 1200
@noindent
Je cursor staat in dit venster (mogelijk moet je een paar seconden wachten
voordat het zichtbaar wordt). Om de debugger af te sluiten en het venster te
laten verdwijnen, typ je:

@smallexample
q
@end smallexample

@noindent
Gelieve @kbd{q} nu te typen, zodat je zelfverzekerd de debugger weet te
verlaten. Type vervolgens weer @kbd{C-x C-e} om er opnieuw in te gaan.

@cindex @samp{functie} gedefinieerd
Gebaseerd op wat we al weten, kunnen we bijna deze foutmelding lezen.

Je leest de @file{*Backtrace*} buffer van beneden naar boven; het vertelt je
wat Emacs deed. Toen je @kbd{C-x C-e} typte, maakte je een interactieve
aanroep naar het commando @code{eval-last-sexp}. @code{eval} is een
afkorting van ``evalueer'' en @code{sexp} is een afkorting voor
``symbolische expressie'', de expressie vlak voor de cursor.

Elke regel er boven vertelt je wat de Lisp interpreter er na evalueerde. De
meest recente actie staat bovenaan. Het buffer heet het @file{*Backtrace*}
buffer omdat het je in staat stelt Emacs achterwaarts te volgen.

@need 800
Bovenaan het @file{*Backtrace*} buffer zie je de regel:

@smallexample
Debugger entered--Lisp error: (void-function dit)
@end smallexample

@noindent
De Lisp interpreter probeerde het eerste atoom van de lijst te evalueren,
het woord @samp{dit}. Het is deze actie die de foutmelding
@samp{(void-function dit)} genereerde.

De melding bevat de woorden @samp{void-function} en @samp{dit}.

@cindex @samp{functie} gedefinieerd
Het woord @samp{functie} is een keer eerder genoemd. Het is een erg
belangrijk woord. Voor onze doeleinden kunnen we definiëren door te zeggen
dat een @samp{functie} een verzameling instructies is die de computer
vertellen iets te doen.

Nu beginnen we de foutmelding te begrijpen: @samp{void-function dit}. De
functie (het woord @samp{dit}) heeft geen definitie van enige verzameling
instructies voor de computer om uit te voeren.

Het ietwat vreemde woord @samp{void-function} is ontworpen voor de manier
waarop Emacs Lisp is geïmplementeerd, dat is wat het doet wanneer een
symbool geen functiedefinitie heeft waaraan het gekoppeld is, de plaats die
de instructies zou moeten bevatten is leeg.

Aan de andere kant, omdat we in staat waren 2 plus 2 succesvol op te tellen
door @code{(+ 2 2)} te evalueren, kunnen we afleiden dat het symbool
@code{+} een verzameling instructies moet hebben voor de computer om te
gehoorzamen en dat deze instructies het optellen van de getallen achter de
@code{+} moeten zijn.

Het is mogelijk te voorkomen dat Emacs de debugger in gaat in situaties
zoals deze. Hier leggen we niet uit hoe je dat doet, maar we vertellen hoe
het resultaat er uit ziet, omdat je een vergelijkbare situatie kunt
tegenkomen wanneer er een bug zit in de Emacs code die je gebruikt. In zulke
gevallen zie je een foutmelding met maar een regel, het verschijnt in het
echogebied en ziet er als volgt uit:

@smallexample
Symbol's function definition is void:@: dit
@end smallexample

@noindent
@ignore
(Also, your terminal may beep at you---some do, some don't; and others
blink.  This is just a device to get your attention.)
@end ignore
De melding gaat weg zodra je een toets aanslaat of zelfs de cursor
verplaatst.

We kennen de betekenis van het woord @samp{Symbool}. Het refereert naar de
eerste atoom van de lijst, het woord @samp{dit}. Het woord @samp{functie}
refereert naar de instructies die de computer vertellen wat te
doen. (Technisch gezien, vertelt het symbool de computer waar de instructies
zijn te vinden, maar dit is een complicatie dit we op dit moment kunnen
negeren.)

De foutmelding kan begrepen worden: @samp{Symbol's function definition is
void:@: dit}. Het symbool (het woord @samp{dit}) mist instructies die de
computer kan uitvoeren.

@node Namen en definities
@section Symboolnamen en functiedefinities
@cindex Symboolnamen

We kunnen een ander kenmerk van Lisp verwoorden op basis van wat we tot nu
toe besproken hebben---en belangrijk kenmerk: een symbool, zoals @code{+},
is zelf geen verzameling van instructies die de computer kan uitvoeren. In
plaats daarvan wordt het symbool gebruikt, misschien tijdelijk, als een
manier om de instructies te lokaliseren. Namen van mensen werken op de
zelfde manier. Ik kan worden gerefereerd als @samp{Bob}. Ik ben echter niet
de letters @samp{B}, @samp{o} en @samp{b} maar ik ben of was het bewustzijn
dat consequent met een bepaalde levensvorm wordt geassocieerd. De naam is
niet mij, maar het kan worden gebruikt om naar mij te refereren. 

In Lisp kan een enkele verzameling instructies meerdere namen hebben. De
computer instructies om getallen op te tellen kan bijvoorbeeld zijn
gekoppeld aan zowel het symbool @code{plus} als het symbool @code{+} (en
zijn dat in sommige Lisp-dialecten). Onder mensen kan ik gerefereerd met
zowel @samp{Robert} als met  @samp{Bob} en ook nog andere woorden.

Aan de andere kant kan maar aan een functiedefinitie tegelijk zijn
gekoppeld. Anders zou de computer in verwarring raken over welke definitie
te gebruiken. Wanneer dit onder mensen het geval zou zijn, dan kan er in de
hele wereld maar een persoon de naam @samp{Bob} hebben. Echter de
functiedefinitie naar de naam naar refereert kan makkelijk worden
aangepast. (@xref{Installeer, , Installeer een functiedefinitie}.)

Omdat Emacs erg groot is, is het gebruikelijk om de symbolen zo te benoemen
dat zij het deel van Emacs waar zij thuishoren identificeren. Alle namen
voor functies die met Texinfo te maken hebben beginnen met @samp{texinfo-}
en die voor de functies die met e-mail lezen te maken hebben beginnen met
@samp{rmail-}.

@node Lisp interpreter
@section De Lisp interpreter
@cindex Lisp interpreter, wat die doet
@cindex Lisp interpreter, wat die doet

Op basis van wat we nu gezien hebben kunnen we beginnen te achterhalen wat
de Lisp interpreter doet wanneer we de opdracht geven een lijst te
evalueren. Eerst kijkt die of er een quote voor de lijst staat. Als die er
is, dan geeft de interpreter ons slechts de lijst. Aan de andere kant, als
er geen quote is, dan kijkt de interpreter naar het eerste element van de
lijst om te zien of die een functiedefinitie heeft. Wanneer dat het geval
is, dan voert de interpreter de instructies in de functiedefinitie uit. Zo
niet, dan drukt de interpreter een foutmelding af. 

Dit is hoe Lisp werkt. Simpel. Er zijn aanvullende complicaties waar we zo
aan toe komen, maar dit zijn de basisprincipes. Om Lisp-programma's te
schrijven moet je natuurlijk weten hoe je functiedefinities schrijft en aan
een naam koppelt, en hoe je dit doet zonder zelf of de computer in
verwarring te brengen.

@menu
* Complicaties::             Variabelen, speciale vormen, lijsten daarbinnen
* Byte compiling::           Speciale verwerkingscode voor snelheid.
@end menu

@ifnottex
@node Complicaties
@unnumberedsubsec Complicaties
@end ifnottex

Nu komt de eerste complicatie. Naast lijsten kan de Lisp interpreter een
symbool evalueren dat niet is gequote en niet tussen haakjes staat. De Lisp
interpreter zal proberen de waarde van het symbool als een @dfn{variabele}
te bepalen. Deze situatie wordt besproken in het hoofdstuk over
variabelen. (@xref{Variabelen}.)

@cindex Speciale vorm
De tweede complicatie ontstaat doordat sommige functies ongebruikelijk zijn
en niet op de normale manier werken. Zij die dat niet doen worden
@dfn{speciale vormen} genoemd. Zij worden voor speciale taken gebruikt,
zoals het definieren van een functie, er er zijn er niet veel van. In enkele
van de volgende hoofdstukken maak je kennis met verschillende belangrijkere
speciale vormen.

Naast speciale vormen zijn er ook @dfn{macros}. Een macro is een in Lisp
gedefineerde constructie die afwijkt van een functie omdat het een Lisp
expressie vertaalt in een andere expressie, die in plaats van de orginele
expressie geëvalueerd gaat worden. 

Voor deze introductie hoef je je niet al te veel zorgen te maken of iets een
speciale vorm, een macro of een gewone functie is. @code{if} bijvoorbeeld is
een speciale vorm (@pxref{if}), maar @code{when} is een macro. In eerdere
versies van Emacs was @code{defun} een speciale vorm, maar nu is het een
macro (@pxref{defun}). Het gedraagt zich nog steeds op dezelfde manier. 

De laatste complicatie is het volgende: wanneer een functie waar de Lisp
interpreter naar kijkt geen speciale vorm is, en deel van een lijst
uitmaakt, dan kijkt de interpreter of de lijst een lijst in zich
bevat. Wanneer er een binnenliggende lijst is, dan zoekt de interpreter
eerst uit wat het moet doen met die binnenliggende lijst en daarna gaat die
met de buitenste lijst aan de slag. Als er weer een lijst opgenomen is in de
binnenliggende lijst, dan werkt die eerst aan die lijst, enzovoorts. Het
begint steeds met de meest binnenliggende lijst, om het resultaat van die
lijst te evalueren. Het resultaat kan gebruikt worden door de omsluitende
expressie. 

Zo niet, dan werkt de interpreter van links naar rechts, van de ene
expressie naar de ander.

@node Byte compiling
@subsection Byte compiling
@cindex Byte compiling

Een ander aspect van interpreteren: de Lisp interpreter is in staat om twee
soorten entiteiten te interpreteren: voor mensen leesbare code, op welke wij
ons exclusief richten, en speciaal geproduceerde code, @dfn{byte compiled}
code genoemd, die niet door mensen te lezen is. Byte compiled code draait
sneller dan voor mensen leesbare code.

Je transformeert voor mensen leesbare code in byte compiled code met een van
de compile commando's zoals @code{byte-compile-file}. Byte compiled code is
meestal opgeslagen in een bestand dat eindigt met de extensie
@file{.elc}. Je ziet beide soorten bestanden in de @file{emacs/lisp}
directory. De bestanden om te lezen zijn die met de extensie @file{.el}.

Praktisch gesproken, voor de meeste dingen die je doet om Emacs aan te
passen of uit te breiden is er geen noodzaak voor byte compile, en ik
bespreek dit onderwerp hier niet. @xref{Byte Compilation, , Byte
Compilation, elisp, The GNU Emacs Lisp  Reference Manual}, voor een
volledige beschrijving van byte compilation.

@node Evaluatie
@section Evaluatie
@cindex Evaluatie

Wanneer de Lisp interpreter een expressie verwerkt, dan is de term voor die
activiteit @dfn{evaluatie}. We zeggen dat de interpreter ``de expressie
evalueert''. Ik heb deze term verschillende keren eerder gebruikt. Het woord
komt van het gebruik in alledaagse taal, ``de waarde vaststellen'',
``taxeren'', volgens de @cite{Webster's New Collegiate Dictionary}.

@menu
* Hoe de interpreter werkt::  Returns en zij-effecten...
* Geneste lijsten evalueren::  Lijsten binnen lijsten...
@end menu

@ifnottex
@node Hoe de interpreter werkt
@unnumberedsubsec Hoe de Lisp interpreter acteert
@end ifnottex

@cindex @samp{teruggegeven waarde} uitgelegd
Na het evalueren van een expressie zal de Lisp interpreter
hoogstwaarschijnlijk de waarde @dfn{teruggeven} die de computer produceert
bij het uitvoeren van de instructies die die in de functiedefinitie vondt,
of misschien geeft die de functie op en produceert een foutmelding. (De
interpreter kan bij wijze van spreken ook naar een andere functie geworpen
worden, of het kan proberen continue wat het doet voor altijd en eeuwig te
herhalen in een oneindige loop. Deze activiteiten zijn minder gebruikelijk
en wij kunnen ze negeren.) Meestal geeft de interpreter een waarde terug.

@cindex @samp{zij-effect} gedefinieerd
Op hetzelfde moment dat de interpreter een waarde terug geeft kan het ook
iets anders doen, zoals de cursor verplaatsen of een bestand kopiëren. Deze
andere soort activiteit heet een @dfn{zij-effect}. Acties die wij belangrijk
vinden, zoals het tonen van resultaten, zijn vaak zij-effecten voor de Lisp
interpreter. Het is vrij eenvoudig te leren hoe deze zij-effecten te
gebruiken.

Samenvattend, het meest gebruikelijk is dat het evalueren van een
symbolische expressie zorgt dat de Lisp interpreter een waarde teruggeeft en
misschien ook een zij-effect uitvoert, of anders een fout produceert.

@node Geneste lijsten evalueren
@subsection Geneste lijsten evalueren
@cindex Binnenste lijst evaluatie
@cindex Het evalueren van een binnenste lijst

Wanneer de evaluatie van toepassing is op een lijst die binnen een andere
lijst zit, kan de omsluitende lijst de waarde gebruiken van de eerste
evaluatie als informatie bij het evalueren van de omsluitende lijst. Dit
verklaart waarom de binnenste expressies het eerst worden geëvalueerd: de
waarden die zij teruggeven worden gebruikt door de buitenliggende
expressies. 

@need 1250
Wij kunnen dit proces onderzoeken door het evalueren van een ander
optelvoorbeeld. Plaats je cursor achter de volgende expressie en type
@kbd{C-x C-e}: 

@smallexample
(+ 2 (+ 3 3))
@end smallexample

@noindent
Het getal 8 zal in het echogebied verschijnen.

Wat er gebeurt is dat de Lisp interpreter eerst de waarde van de binnenste
expressie, @code{(+ 3 3)} evalueert, wat de waarde 6 teruggeeft. Vervolgens
evalueert het de buitenste expressie alsof die als @code{(+ 2 6)} geschreven
was, wat de waarde 8 teruggeeft. Omdat er geen omsluitende expressies meer
te evalueren zijn, toont de interpreter de waarde in het echogebied.

Nu is de naam van het commando aangeroepen met de toetsaanslagen @kbd{C-x
C-e} te begrijpen: de naam is @code{eval-last-sexp}. De letters @code{sexp}
zijn een afkorting van ``symbolische expressie'', en @code{eval} is een
afkorting van ``evalueer''. Het commando evalueert de laatste symbolische
expressie.

Als een experiment kan je proberen de expressie te evalueren door de cursor
aan het begin van de regel direct onder de expressie te plaatsen, of binnen
de expressie.

@need 800
Hier is een andere kopie van de expressie:

@smallexample
(+ 2 (+ 3 3))
@end smallexample

@noindent
Als je de cursor aan het begin van de lege regel die onmiddellijk op de
expressie volgt plaatst en je @kbd{C-x C-e} typt, krijg je nog steeds de
waarde 8 getoond in het echogebied. Probeer nu de cursor binnen de expressie
te plaatsen. Als je die rechts achter het een-na-laatste haakje plaatst
(zodat het lijkt of die bovenop het laatste haakje zit), dan krijg je een 6
getoond het echogebied! Dit is omdat het commando de expressie @code{(+ 3
3)} evalueert.

Plaats nu de cursor direct achter een getal. Typ @kbd{C-x C-e} en je krijgt
het getal zelf. Wanneer je in Lisp een getal evalueert, dan krijg je het
getal zelf---dit is hoe getallen verschillen van symbolen. Wanneer je een
lijst evalueert die begint met een symbool zoals @code{+}, dan krijg je de
waarde terug die het resultaat is van de computer die de instructies
uitvoert die zijn gekoppeld aan die naam. Wanneer je het symbool op zichzelf
evalueert, dan gebeurt er iets anders, zoals we in het volgende hoofdstuk
zien. 

@node Variabelen
@section Variabelen
@cindex Variabelen

In Emacs Lisp kan een symbool een waarde aan zich gekoppeld hebben, net
zoals het een functiedefinitie aan zich gekoppeld kan hebben. Die twee zijn
verschillend. De functiedefinitie is een verzameling instructies die de
computer zal gehoorzamen. Daartegenover is een waarde iets, zoals een getal
of een naam die kan variëren (daarom wordt zo'n symbool een variabele
genoemd). De waarde van een symbool kan elke expressie in Lisp zijn, zoals
een symbool, getal, lijst of string. Een symbool die een waarde heeft wordt
vaak een @dfn{variabele} genoemd.

Een symbool kan zowel een functiedefinitie als een waarde tegelijkertijd aan
zich gekoppeld hebben. Of het kan slechts een van die tee hebben. De twee
staan los van elkaar. Dit is ongeveer vergelijkbaar me de manier waarop
Cambridge kan refereren naar een stad in Massachusetts en informatie aan de
naam gekoppeld kan hebben, zoals ``geweldig programmeercentrum''.

@ignore
(Incidentally, in Emacs Lisp, a symbol can have two
other things attached to it, too: a property list and a documentation
string; these are discussed later.)
@end ignore

Een andere manier om hierover te denken is een symbool voor te stellen als
een ladekast. De functiedefinitie wordt in de ene lade gestopt, de waarde in
een andere, enzovoorts. Wat in de lade die de waarde bevat gestopt is kan
worden veranderd zonder effect te hebben op de lade die de functiedefinitie
bevat, en omgekeerd. 

@menu
* fill-column voorbeeld::    fill-column voorbeeld
* Void functie::             De foutmelding voor een symbool zonder functie.
* Void variabele::           De foutmelding voor een symbool zonder waarde.
@end menu

@ifnottex
@node fill-column voorbeeld
@unnumberedsubsec @code{fill-column}, een voorbeeldvariabele
@end ifnottex

@findex fill-column@r{, een voorbeeldvariabele}
@cindex Voorbeeldvariabele, @code{fill-column}
@cindex Variabele, voorbeeld van, @code{fill-column}
De variabele @code{fill-column} illustreert een symbool waar een waarde aan
gekoppeld is. In elk GNU Emacs buffer is dit symbool op een bepaalde waarde
ingesteld, meetal 72 of 70, maar soms een andere waarde. Om de waarde van
dit symbool te vinden evalueer je het op zichzelf. Wanneer je dit in Info
binnen GNU Emacs leest, dan doe je dit door de cursor achter het symbool te
zetten en vervolgens @kbd{C-x C-e} te typen:

@smallexample
fill-column
@end smallexample

@noindent
Nadat ik @kbd{C-x C-e} typte, toonde Emacs het getal 72 in mijn
echogebied. Dit is waarde waar voor mij @code{fill-column} op is ingesteld
terwijl ik dit schrijf. Het kan verschillend zijn in jouw Infobuffer. Merk
op dat de waarde die de variabele teruggeeft op precies dezelfde manier
wordt getoond als de waarde die teruggeven wordt door een functie die zijn
instructies uitvoert. Vanuit het gezichtspunt van de Lisp interpreter is een
teruggeven waarde een teruggegeven waarde. Van wat voor soort expresse het
vandaan kwam doet er niet meer toe zodra de waarde bekend is.

Een symbool kan elke waarde aan zich gekoppeld hebben, of om het jargon te
gebruiken, we kunnen de variabele aan een waarde @dfn{binden}: aan een
getal, zoals 72, aan een string @code{"zoals deze"}, aan een lijst, zoals
@code{(spar den eik)}; we kunnen zelfs een variabele aan een
functiedefinitie binden.

Een symbool kan op verschillende manieren aan een waarde worden
gebonden. @xref{setq, , De waarde van een variabele zetten}, voor informatie
over een manier om dit te doen.

@node Void functie
@subsection Foutmelding voor een symbool zonder functie
@cindex Symbool zonder functie foutmelding
@cindex Fout van symbool zonder functie

Bij het evalueren van @code{fill-column} om de waarde daarvan als een
variabele te ontdekken, plaatsten we geen haakjes rondom het woord. Dit is
omdat we het niet als functienaam wilden gebruiken.

Wanneer @code{fill-column} het eerste of enige element van een lijst was,
zou de Lisp interpreter proberen de er aangekoppelde functiedefinitie te
vinden. Maar @code{fill-column} heeft geen functiedefinitie. Probeer dit te
evalueren:

@smallexample
(fill-column)
@end smallexample

@need 1250
@noindent
Je maakt een @file{*Backtrace*} buffer dat het volgende toont:

@smallexample
@group
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function fill-column)
  (fill-column)
  eval((fill-column) nil)
  elisp--eval-last-sexp(nil)
  eval-last-sexp(nil)
  funcall-interactively(eval-last-sexp nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------
@end group
@end smallexample

@noindent
(Onthoud, om de debugger te sluiten en het debugger window te laten
verdwijnen typ je @kbd{q} in het @file{*Backtrace*} buffer.)

@node Void variabele
@subsection Foutmelding voor een symbool zonder waarde
@cindex Symbool zonder waarde fout
@cindex Fout voor symbool zonder waarde

Wanneer je een symbool dat geen waarde aan zich gekoppeld heeft probeert te
evalueren, dan krijg je een foutmelding. Dit kan je zien door te
experimenteren met onze 2 plus 2 optelling. Zet de cursor meteen achter de
@code{+}, voor het eerste getal 2 in de volgende expressie, en typ @kbd{C-x
C-e}:

@smallexample
(+ 2 2)
@end smallexample

@need 1500
@noindent
In GNU Emacs 22 maak je een @file{*Backtrace*} buffer dat het volgende
toont:

@smallexample
@group
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-variable +)
  eval(+)
  elisp--eval-last-sexp(nil)
  eval-last-sexp(nil)
  funcall-interactively(eval-last-sexp nil)
  call-interactively(eval-last-sexp nil nil)
  command-execute(eval-last-sexp)
---------- Buffer: *Backtrace* ----------
@end group
@end smallexample

@noindent
(Je sluit de debugger opnieuw door @kbd{q} in het @file{*Backtrace*} buffer
te typen.)

Deze backtrace verschilt van de allereerste foutmelding die we zagen, die
toonde @samp{Debugger entered--Lisp error: (void-function dit)}. In dit
geval heeft de functie geen waarde als variabele, terwijl in de andere
foutmelding, de functie (het woord @samp{dit}) geen definitie had.

Wat we in het experiment met de @code{+} deden liet de Lisp interpreter de
@code{+} evaluaren en zoeken naar de waarde van de variabele in plaats van
de functiedefinitie. We deden dit door de cursor meteen achter het symbool
te plaatsen in plaats van achter het haakje van de omsluitende lijst, zoals
we eerder deden. Als gevolg hiervan evalueerde de Lisp interpreter de
voorafgaande s-expressie, in dit geval @code{+} op zichzelf.

Omdat @code{+} geen waarde aan zich gekoppeld heeft en alleen een
functiedefinitie, rapporteerde de foutmelding dat de waarde van het symbool
als variabele leeg was.

@node Argumenten
@section Argumenten
@cindex Argumenten
@cindex Informatie naar functies doorgeven

Laten we nog eens naar ons oude voorbeeld kijken om te zien hoe informatie
tussen functies doorgegeven wordt, de optelling van twee plus twee. In Lisp
schrijven we dit als volgt:

@smallexample
(+ 2 2)
@end smallexample

Wanneer je deze expressie evalueert verschijnt het getal in je
echogebied. Wat de Lisp interpreter doet is het optellen van de getallen die
volgen na de @code{+}.

@cindex @samp{argument} gedefinieerd
De getallen toegevoegd aan @code{+} heten de @dfn{argumenten} van de functie
@code{+}. Deze getallen vormen de informatie die @dfn{doorgegeven} wordt aan
de de functie.

Het woord ``argument'' komt van de manier waarop het gebruikt wordt in
wiskunde en refereert niet naar een dispuut tussen twee mensen. In plaats
daarvan refereert het naar de informatie gegeven aan een functie, in dit
geval aan de @code{+}. In Lisp zijn de argumenten van een functie de atomen
of lijsten die volgen op de functie. De waarde die de evaluatie van deze
atomen of lijsten teruggeeft worden doorgegeven aan de
functie. Verschillende functies vereisen een verschillend aantal argumenten,
sommige functies vereisen er geen.@footnote{Het is interessant om het pad te
volgen dat voor het woord ``argument'' tot twee verschillende betekenissen
leidde, eentje in wiskunde en eentje in dagelijks Engels. Volgens de
@cite{Oxford English Dictionary} is het woord afgeleid van het Latijn voor
@samp{duidelijk maken, bewijzen}. Via één tak van de afleiding kreeg het de
betekenis ``het bewijsmateriaal aangereikt als bewijs'', met andere woorden
``de aangeboden informatie'', wat tot de betekenis van het woord in Lisp
leidde. In de andere tak van de afleiding kreeg het de betekenis ``iets
beweren op een manier waarop anderen een tegenbewering maken'', wat leidde
tot de betekenis van het woord als dispuut. (Merk op dat het Engelse woord
hier tegelijk aan twee betekenissen zich gekoppeld heeft. In tegenstelling
kan in Emacs Lisp een symbool geen twee verschillende functiedefinities
tegelijk kan hebben.)}

@menu
* Data typen::               Typen van data doorgegeven naar een functie.
* Argumenten als variabele of als lijst::  Een argument kan de waarde van 
                                             een variabele of lijst zijn
* Variabel aantal argumenten::  Sommige functies accepteren een variable 
                                  aantal argumenten.
* Verkeerde type argument::  Een argument van het verkeerde type aan een 
                               functie doorgeven
* message::                  Een nuttige functie om boodschappen te zenden.
@end menu

@node Data typen
@subsection Data typen van argumenten
@cindex Data typen
@cindex Typen van data
@cindex Data typen van argumenten

Het type data dat aan een functie moet worden doorgegeven hangt af van het
soort informatie dat die gebruikt. De argumenten voor een functie zoals
@code{+} moeten waarden hebben die getallen zijn, omdat @code{+} getallen
optelt. Andere functies gebruiken andere vormen van data voor hun
argumenten.

@need 1250
@findex concat
De functie @code{concat} bijvoorbeeld koppelt of verbindt twee of meer
tekstreeksen om een string te produceren. De argumenten zijn strings. Het
concatenaten van de twee tekenreeksen @code{abc} en @code{def} produceert de
enkele string @code{abcdef}. Dit is te zien door het volgende te evalueren:

@smallexample
(concat "abc" "def")
@end smallexample

@noindent
De waarde die het evalueren van deze expressie produceert is
@code{"abcdef"}.

@cindex substring
Een functie zoals @code{substring} gebruikt zowel een string en getallen als
argumenten. De functie geeft een van de string terug, een @dfn{substring}
van zijn eerste argument. Deze functie accepteert drie argumenten. Het
eerste argument is de tekenreeks, het tweede en derde argument zijn de
getallen die het begin (inclusief) en het einde (exclusief) van de substring
aanduiden. De getallen zijn een telling van het aantal karakters (inclusief
spaties en leestekens) vanaf het begin van de string. Merk op dat de
karakters vanaf nul zijn genummerd, niet vanaf één.

@need 800
Bijvoorbeeld, als je het volgende evalueert:

@smallexample
(substring "The quick brown fox jumped." 16 19)
@end smallexample

@noindent
dan zie je @code{"fox"} in het echogebied verschijnen. De argumenten zijn de
string en twee getallen.

Merk op dat de aan @code{substring} doorgegeven string een enkelvoudig atoom
is, alhoewel het is opgebouwd uit meerdere woorden gescheiden door
spaties. Lisp rekent alles tussen de twee aanhalingstekens als onderdeel van
de string, inclusief de spaties. Je kunt de @code{substring} functie als een
soort van atoombreker zien, omdat het een anders ondeelbaar atoom neemt en
daar een onderdeel uit haalt. @code{substring} is echter alleen in staat een
substring uit een argument te halen dat een string is, niet van ander soort
atoom zoals een getal of een symbool.

@node Argumenten als variabele of als lijst
@subsection Een argument als de waarde van een variabele of lijst

Een argument kan een symbool zijn die een waarde teruggeeft wanneer het
wordt geëvalueerd. Wanneer bijvoorbeeld het symbool @code{fill-column} op
zichzelf wordt geëvalueerd, geeft het een getal terug. Dit getal kan in een
optelling worden gebruikt.

@need 1250
Plaats de cursor achter de volgende expressie en typ @kbd{C-x C-e}:

@smallexample
(+ 2 fill-column)
@end smallexample

@noindent
De waarde is een getal, twee groter dan wat je krijgt door het evalueren van
alleen @code{fill-column}. Voor mij is dit 74, omdat mijn waarde van
@code{fill-column} 72 is.

Zoals we zojuist zagen kan een argument een symbool zijn dat een waarde
teruggeeft wanneer het geëvalueerd wordt. Daarnaast kan een argument een
lijst zijn die een waarde teruggeeft wanneer die geëvalueerd
wordt. Bijvoorbeeld in de volgende expressie zijn de argumenten voor de
functie @code{concat} de strings @w{@code{"De "}} en @w{@code{" rode
vossen."}} en de lijst @code{(number-to-string (+ 2 fill-column))}.

@smallexample
(concat "De " (number-to-string (+ 2 fill-column)) " rode vossen.")
@end smallexample

@noindent
Wanneer je deze expressie evalueert---en als, zoals met mijn Emacs,
@code{fill-column} naar 72 evalueert---verschijnt @code{"De 74 rode
vossen."} in het echogebied. (Merk op dat je spaties achter het woord
@samp{De} en voor het voord @samp{rode} zet zodat deze in de uiteindelijke
string verschijnen. De functie @code{number-to-string} converteert de
integer die de optelling teruggeeft naar een string. @code{number-to-string}
is ook bekend als @code{int-to-string}.)

@node Variabel aantal argumenten
@subsection Variabel aantal argumenten
@cindex Variabel aantal argumenten
@cindex Argumenten, variabel aantal

Sommige functies, zoals  @code{concat}, @code{+} of @code{*} accepteren elk
aantal argumenten. (De @code{*} is het symbool voor vermenigvuldiging.) Dit
is te zien door het op de gebruikelijke manier evalueren van elk van de
volgende expressies. Wat je in het echogebied ziet verschijnen is deze tekst
achter @samp{@result{}} wat je kunt lezen als ``evalueert naar''. 

@need 1250
In de eerste groep hebben de functies geen argumenten:

@smallexample
@group
(+)       @result{} 0

(*)       @result{} 1
@end group
@end smallexample

@need 1250
In deze groep hebben de functies elk één argument:

@smallexample
@group
(+ 3)     @result{} 3

(* 3)     @result{} 3
@end group
@end smallexample

@need 1250
In deze groep hebben de functies elk drie argumenten:

@smallexample
@group
(+ 3 4 5) @result{} 12

(* 3 4 5) @result{} 60
@end group
@end smallexample

@node Verkeerde type argument
@subsection Het verkeerde object type als argument gebruiken
@cindex Verkeerde type argument
@cindex Argument, verkeerde type

Wanneer aan een functie een argument van een verkeerde type wordt
doorgegeven, produceert de Lisp interpreter een foutmelding. Bijvoorbeeld
verwacht de @code{+} functie dat de waarden van zijn argumenten getallen
zijn. Als experiment kunnen we het gequote symbool @code{hello} in plaats
van een getal doorgeven. Plaats de cursor achter de volgende expressie en
typ @kbd{C-x C-e}:

@smallexample
(+ 2 'hello)
@end smallexample

@noindent
Wanneer je dit doet dan genereer je een foutmelding. Wat gebeurde is dat
@code{+} geprobeerd het 2 op te tellen bij de waarde teruggegeven door
@code{'hello}, maar de waarde teruggegeven door @code{'hello} is het symbool
@code{hello}, geen getal. Alleen getallen kunnen worden opgeteld. Daardoor
kon @code{+} zijn optelling niet uitvoeren.

@need 1250
Je maakt en betreedt een @file{*Backtrace*} buffer die toont:

@noindent
@smallexample
@group
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error:
         (wrong-type-argument number-or-marker-p hello)
  +(2 hello)
  eval((+ 2 'hello) nil)
  elisp--eval-last-sexp(t)
  eval-last-sexp(nil)
  funcall-interactively(eval-print-last-sexp nil)
  call-interactively(eval-print-last-sexp nil nil)
  command-execute(eval-print-last-sexp)
---------- Buffer: *Backtrace* ----------
@end group
@end smallexample

@need 1250
Zoals gebruikelijk probeert de foutmelding behulpzaam te zijn en klinkt
logisch nadat je geleerd hebt hoe die te lezen.@footnote{@code{(quote
hello)} is een expansie van de afkorting @code{'hello}.}

Het eerste deel van de foutmelding is eenvoudig, het toont @samp{wrong type
argument}. Daarna komt in mysterieus jargon het woord
@w{@samp{number-or-marker-p}}. Dit woord probeert je aan te geven welk type
argument de @code{+} verwachtte.

Het symbool @code{number-or-marker-p} geeft aan dat de Lisp interpreter
probeert vast te stellen of de informatie die het kreeg een getal is of een
marker (een speciaal object dat een bufferpositie vertegenwoordigt). Wat het
doet is testen of de @code{+} getallen kreeg om op te tellen. Ook test of
het argument iets is dat een marker genoemd wordt, wat een specifieke
eigenschap van Emacs Lisp is. (In Emacs worden locaties in een buffer
geregistreerd als markers. Wanneer de mark is gezet met het @kbd{C-@@} of
@kbd{C-@key{SPC}} commando, wordt zijn positie bewaard als een marker. De
mark kan worden beschouwd als een getal--het aantal karakters van de lokatie
ten opzichte van het begin van de buffer.) In Emacs Lisp kan @code{+}
gebruikt worden om de numerieke waarde van de marker-posities als getallen
op te tellen.

@cindex @samp{predicate} gedefinieerd
De @samp{p} in @code{number-or-marker-p} is de belichaming van een praktijk
die startte in de beginjaren van Lisp programmeren. De @samp{p} staat voor
@dfn{predicate}. In het jargon dat de eerste Lisp onderzoekers gebruikten,
refereert een predicate aan een functie die bepaalt of een bepaalde
eigenschap waar of onwaar is. De @samp{p} vertelt ons dus dat
@code{number-or-marker-p} de naam van een functie is die bepaalt of het waar
of onwaar is dat het doorgegeven argument een getal of een marker is. Andere
Lisp symbolen die eindigen in @samp{p} zijn onder andere @code{zerop}, een
functie die test of zijn argument de waarde nul heeft, en @code{listp}, een
functie die test of zijn argument een lijst is.

Het laatste deel van de foutmelding tenslotte is het symbool
@code{hello}. Dit is de waarde van het argument dat was doorgegeven aan
@code{+}. Wanneer het juiste type object aan de optelling was doorgegeven,
dan was de waarde die was doorgegeven een getal, zoals 37, in plaats van een
symbool zoals @code{hello}. Maar dan had je geen foutmelding gekregen.

@node message
@subsection De @code{message} functie
@findex message

Net als @code{+} accepteert de @code{message} functie een variabel aantal
argumenten. Het wordt gebruikt om berichten naar de gebruiker te sturen en
is zo nuttig dat we het hier beschrijven. 

@need 1250
Een bericht wordt getoond in het echogebied. Je kunt bijvoorbeeld een
bericht in je echogebied tonen door het evalueren van de volgende lijst:

@smallexample
(message "Dit bericht verschijnt in het echogebied!")
@end smallexample

De hele string tussen de dubbele aanhalingstekens in een enkelvoudig
argument en wordt volledig getoond. (Merk op dat in dit voorbeeld het
bericht zelf in het echogebied wordt getoond tussen dubbele
aanhalingstekens. Dat is omdat je de waarde ziet die de @code{message}
functie teruggeeft. In de meeste toepassingen van @code{message} in
programma's die je schrijft wordt de tekst getoond in het echogebied als
zij-effect, zonder aanhalingstekens.
@xref{vermenigvuldig-met-zeven in detail, , @code{vermenigvuldig-met-zeven}
in detail},
voor een voorbeeld hiervan).

Wanneer er echter een @samp{%s} in de string tussen aanhalingstekens staat,
toont de @code{message}-functie de @samp{%s} niet als zodanig, maar kijkt
naar het argument dat op de string volgt. Het evalueert het tweede argument
en toont de waarde op de locatie in de string waar de @samp{%s} staat.

@need 1250
De kun je zien door de cursor achter de volgende expressie te plaatsen en
@kbd{C-x C-e} te typen:

@smallexample
(message "De naam van dit buffer is: %s." (buffer-name))
@end smallexample

@noindent
In Info zal @code{"De naam van dit buffer is: *info*."} in het echogebied
verschijnen. De functie @code{buffer-name} geeft de naam van het buffer
terug als string, die de @code{message} functie invoegt op de plek van de
@code{%s}.

Om de waarde als een integer te tonen gebruik je @samp{%d} op dezelfde
manier als @samp{%s}. Bijvoorbeeld om een bericht in het echogebied te tonen
dat de waarde van @code{fill-column} opgeeft, evalueer je het volgende:

@smallexample
(message "De waarde van fill-column is %d." fill-column)
@end smallexample

@noindent
Wanneer ik op mijn systeem de lijst evalueer, verschijnt @code{"De waarde
van fill-column is 72."} in mijn echogebied @footnote{Je kunt trouwens
@code{%s} gebruiken om een getal te tonen. Het is niet-specifiek. @code{%d}
toont alleen het deel van het getal dat links van het decimale teken staan,
en niets dat geen getal is.}

Wanneer er meer dan een @samp{%s} in de string tussen aanhalingstekens
staat, wordt de waarde van het eerste argument dat volgt op de string tussen
aanhalingstekens op de plaats van de eerste @samp{%s} getoond, de waarde van
het tweede argument op de plaats van de tweede @samp{%s}, enzovoorts.

@need 1250
Wanneer je bijvoorbeeld het volgende evalueert,

@smallexample
@group
(message "Er zijn %d %s in het kantoor!"
         (- fill-column 14) "paarse olifanten")
@end group
@end smallexample

@noindent
zal een nogal eigenaardig bericht in je echogebied verschijnen. Op mijn
systeem zegt het @code{"Er zijn 58 paarse olifanten in het kantoor!"}.

De expressie @code{(- fill-column 14)} wordt geëvalueerd and het
resulterende getal wordt ingevoegd op de plaats van @samp{%d} en de string
in dubbele aanhalingstekens @code{"paarse olifanten"} wordt behandeld als
een enkelvoudig argument ingevoegd o de plaats van @samp{%s}. (Dat wil
zeggen dat een string tussen dubbele aanhalingstekens naar zichzelf
evalueert, net als een getal.

Tenslotte is hier een enigszins complex voorbeeld dat niet alleen de
berekening van een getal illustreert, maar ook hoe je een expressie binnen
een expressie gebruikt om een tekst te genereren die @samp{%s} vervangt:

@smallexample
@group
(message "He saw %d %s"
         (- fill-column 32)
         (concat "red "
                 (substring
                  "The quick brown foxes jumped." 16 21)
                 " leaping."))
@end group
@end smallexample

In dit voorbeeld heeft @code{message} drie argumenten: de string @code{"He
saw %d %s"}, de expressie @code{(- fill-column 32)} en de expressie
beginnend met de functie @code{concat}. De waarde resulterend van de
evaluatie van @code{(- fill-column 32)} wordt ingevoegd op de plaats van de
@samp{%d} en de waarde teruggeven door de expressie beginnend met
@code{concat} wordt ingevoegd op de plaats van de @samp{%s}.

Wanneer jouw fill column 70 is en je de expressie evalueert, verschijnt
@code{"He saw 38 red foxes leaping."} in je echogebied.

@node setq
@section De waarde van een variabele zetten
@cindex Variabele, waarde zetten
@cindex De waarde van een variabele zetten

@cindex @samp{bind} gedefinieerd
Er zijn verschillende manieren waarop een variabele een waarde kan
krijgen. Een van de manieren is het gebruik van de speciale vorm
@code{setq}. Een andere manier is het gebruik van @code{let}
(@pxref{let}). (Het jargon voor dit proces is @dfn{bind} een variabele aan
een waarde.)

De volgende paragrafen beschrijven niet alleen hoe @code{setq} werkt maar
illustreren tevens hoe argumenten worden doorgegeven.

@menu
* Setq gebruiken::           Variabelen zetten
* Tellen::                   @code{setq} gebruiken om te tellen.
@end menu

@node Setq gebruiken
@subsection Gebruik van @code{setq}
@findex set

Om de waarde van het symbool @code{bloemen} op de lijst @code{roos viool
madelief boterbloem} te zetten evalueer je de volgende expressie door de
cursor achter de expressie te zetten en @kbd{C-x C-e} te typen:

@smallexample
(setq bloemen '(roos viool madelief boterbloem))
@end smallexample

@noindent
De lijst @code{(roos viool madelief boterbloem)} verschijnt in het
echogebied. Dat is wat is @emph{teruggegeven} door de speciale vorm
@code{setq}. Als zij-effect is het symbool @code{bloemen} aan de lijst
gebonden. Dat wil zeggen dat het symbool @code{bloemen}, welke als een
variabel gezien kan worden, de lijst als waarde krijgt. (Overigens
illustreert dit proces hoe een zij-effect voor de Lisp interpreter, de
waarde zetten, het primaire effect kan zijn waar wij mensen in
geïnteresseerd zijn.. Dit is omdat elke Lisp functie een waarde moet
teruggeven wanneer het geen fout krijgt, maar alleen een zij-effect heeft
wanneer die is ontworpen om er een te hebben.

Nadat je de @code{setq} expressie hebt geëvalueerd, kun je het symbool
@code{bloemen} evalueren, dit geeft je de waarde terug die je zojuist gezet
hebt. Hier is het symbool. Plaats je cursor er achter en typ @kbd{C-x C-e}.

@smallexample
bloemen
@end smallexample

@noindent
Wanneer je @code{bloemen} evalueert, verschijnt de lijst @code{(roos viool
madelief boterbloem)} in het echogebied.

Overigens, wanneer je @code{'bloemen} evalueert, de variabele met een enkele
quote er voor, dat zie je in het echogebied het symbool zelf,
@code{bloemen}. Hier is het gequote symbool, zodat je het kunt proberen:

@smallexample
'bloemen
@end smallexample

Als extra gemak staat @code{setq} je toe verschillende variablen naar
verschillende waarden te zetten, in een enkele expressie.

Om de waarde van de variabele @code{carnivoren} met @code{setq} naar de
lijst @code{'(leeuw tijger luipaard)} te zetten is de volgende expressie
gebruikt:

@smallexample
(setq carnivoren '(leeuw tijger luipaard)
@end smallexample

@code{setq} kan ook gebruikt worden om verschillende waarden naar
verschillende variabelen toe te kennen. Het eerste argument wordt gebonden
aan de waarde van het tweede argument, het derde argument aan de waarde van
het vierde argument, enzovoorts. Bijvoorbeeld kan je het volgende gebruiken
om een lijst van bomen aan het symbool @code{bomen} en een lijst van
herbivoren aan het symbool @code{herbivoren} toe te kennen:

@smallexample
@group
(setq bomen '(den spar eik esdoorn)
      herbivoren '(gazelle antiloop zebra)
@end group
@end smallexample

@noindent
(De expressie had net zo goed op een enkele regel gekund, maar het zou
misschien niet op een bladzijde passen, en mensen vinden het makkelijker om
mooi opemaakte lijsten te lezen).

Alhoewel ik de term ``toekennen'' heb gebruikt, is er een andere manier over
de werking van @code{setq} te denken, en dat zo te zeggen dat @code{setq}
het symbool laat @emph{wijzen} naar de lijst. Deze laatste manier van denken
is erg gebruikelijk en in de volgende hoofdstukken zullen we een symbool
tegenkomen dat ``pointer'' als onderdeel van zijn naam heeft. De naam is
gekozen omdat het symbool een waarde, in het bijzonder een lijst aan zich
gebonden heeft, of, op een andere manier uitgedrukt, het symbool is
ingesteld om naar de lijst te wijzen.

@node Tellen
@subsection Tellen
@cindex Tellen

Hier volgt een voorbeeld dat laat zien hoe je @code{setq} in een teller
gebruikt. Je kunt dit gebruiken om te tellen hoe vaak een deel van je
programma zichzelf herhaalt. Stel eerst een variabele op nul. Vervolgens tel
je iedere keer dat het programma zich herhaalt een bij het getal op. Om dit
te doen heb je een variabele nodig die dienst doet als teller, en twee
expressies: een initiële @code{setq} expressie die de variabele instelt op
nul, en een tweede @code{setq} expressie die elke keer dat die wordt
geëvalueerd de teller verhoogt.

@smallexample
@group
(setq counter 0)                ; @r{Laten wij dit de initialisator noemen.}

(setq counter (+ counter 1))    ; @r{Dit is de incrementer.}

counter                         ; @r{Dit is de teller.}
@end group
@end smallexample

@noindent
(De tekst die volgt na de @samp{;} zijn comments.  @xref{Een defun wijzigen,
, Wijzig een functiedefinitie}.)

Wanneer je de eerste van deze drie expressies evalueert, de initialisator,
@code{(setq counter 0)}, en daarna evalueer je de derde expressie,
@code{counter}. dan verschijnt het getal @code{0} in het echogebied. Wanneer
je de tweede expressie, de incrementer, @code{(setq counter (+ counter 1))},
evalueert, dan verschijnt het getal @code{1} in het echogebied. Elke keer
dat je de tweede expressie evalueert, wordt de waarde van de counter
verhoogd.

Wanneer je de incrementer, @code{(setq counter (+ counter 1))} evalueert,
evalueert de Lisp interpreter eerst de meest binnenste lijst, dit is de
optelling. Om deze lijst te evalueren, moet het de variabele @code{counter}
en het getal @code{1} evalueren. Wanneer het de variabele @code{counter}
evalueert, krijgt het diens huidige waarde. Het geeft deze waarde en het
getal @code{1} door aan de @code{+}, die ze bij elkaar optelt. De som wordt
teruggegeven als de waarde van de binnenste lijst en doorgegeven aan de
@code{setq}, die de variabele @code{counter} op deze nieuwe waarde
instelt. Zo is de waarde van de variabele @code{counter} gewijzigd.

@node Samenvatting
@section Samenvatting

Lisp leren is net zo iets als een heuvel beklimmen, waar het eerste deel het
steilste is. Je hebt inmiddels het moeilijkste deel beklommen, wat
overblijft wordt makkelijker naarmate je verder komt.

@need 1000
Samenvattend,

@itemize @bullet

@item
Lisp programma's zijn gemaakt van expressies, elke lijsten of enkelvoudige
atomen zijn.

@item
Lijsten zijn gemaakt van nul of meer atomen of binnenliggende lijsten,
gescheiden door witte ruimte en omgeven door haakjes. Een lijst kan leeg
zijn.

@item
Atomen zijn multi-karakter symbolen, zoals @code{forward-paragraph},
enkele-karakter symboleen zoals @code{+}, strings of karakters tussen
dubbele aanhalingstekens, of getallen.

@item
Een getal evalueert naar zichzelf.

@item
Een string tussen dubbele aanhalingstekens evalueert ook naar zichzelf.

@item
Wanneer je een symbool op zichzelf evalueert, wordt zijn waarde
teruggegeven.

@item
Wanneer je een lijst evalueert, kijkt de Lisp interpreter naar het eerste
symbool in de lijst en vervolgens naar de functiedefinitie die aan dat
symbool gebonden is. Daarvan worden de instructies in de functiedefinitie
uitgevoerd. 

@item
Een enkele quote @samp{'} vertelt de Lisp interpreter dat het de
daaropvolgende expressie moet teruggeven zoals die is geschreven, en niet
evalueren alsof de quote er niet was. 

@item
Argumenten vormen de informatie die aan een functie wordt doorgegeven. De
argumenten voor een functie worden berekend door de rest van de elementen
van de lijst te evalueren, waarvan de functie het eerste element is.

@item
Een functie geeft altijd een waarde terug wanneer die wordt geëvalueerd
(tenzij het een fout krijgt). Ook kan die een actie uitvoeren dat een
zij-effect is. In veel gevallen is het creëren van zij-effecten het primaire
doel.
@end itemize

@node Foutmelding oefeningen
@section Oefeningen

Enkele simpele oefeningen:

@itemize @bullet
@item
Genereer een foutmelding door een geschikt symbool te evalueren dat niet
tussen haakjes staat.

@item
Genereer een foutmelding door een geschikt symbool te evalueren dat tussen
haakjes staat.

@item
Maak een teller die met twee verhoogt in plaats van een.

@item
Schrijf een expressie die een boodschap in het echogebied toont wanneer die
wordt geëvalueerd.
@end itemize

@node Oefenen van evaluatie
@chapter Oefenen van evaluatie
@cindex Evaluatie oefenen
@cindex Evaluatiepraktijk

Voordat je leert hoe je een functiedefinitie in Emacs Lisp schrijft, is het
zinnig om wat tijd te besteden aan het evalueren van diverse expressies die
al zijn geschreven. Deze expressies zijn lijsten met de functies als hun
eerste (en vaak enige) element. Omdat sommige buffer-geassocieerde functies
zowel eenvoudig als interessant zijn, beginnen we met die. In deze sectie
evalueren we enkele daarvan. In een andere sectie bestuderen we de code van
verscheidene andere buffer-gerelateerde functies om te zien hoe die zijn
geschreven. 

@menu
* Hoe te evalueren::         Het typen van commando's of @kbd{C-x C-e} 
                               veroorzaakt evalatie.
* Buffer namen::             Buffers en bestanden zijn verschillend.
* Buffers pakken::           Pak een buffer zelf, niet slechts zijn naam.
* Van buffer verwisselen::   Hoe je naar een andere buffer overschakelt
* Buffer grootte en locatie::  De locatie van point en de grootte van het 
                                 buffer.
* Evaluatie oefening::       Evaluatie oefening
@end menu

@ifnottex
@node Hoe te evalueren
@unnumberedsec Hoe te evalueren
@end ifnottex

@i{Telkens wanneer je een edit-commando} aan Emacs Lisp geeft, zoals het
commando om de cursor te verplaatsen of het scherm te scrollen, @i{evalueer
je een expressie}, waarvan het eerste element een functie is. @i{Dit is hoe
Emacs werkt.}

@cindex @samp{interactive function} gedefinieerd
@cindex @samp{command} gedefinieerd
Wanneer je toetsen aanslaat laat je de Lisp interpreter een expressie
evalueren en zo krijg je je resultaten. Zelfs het typen van platte tekst
houdt het evalueren van een Emacs Lisp functie in, in dit geval eentje dat
het @code{self-insert-command} gebruikt, die eenvoudig het karakter dat je
typte invoegt. De functies die je evalueert met het typen van toetsaanslagen
worden @dfn{interactief} genoemd, of @dfn{commando's}. Hoe je een functie
interactief maakt wordt in het volgende hoofdstuk
geïllustreerd. @xref{Interactief, , Een functie interactief maken}.

Naast het typen van toetsenbord commando's, hebben we een tweede manier
gezien om een expressie te evalueren: door de cursor achter de lijst te
plaatsen en @kbd{C-x C-e} te typen. Dit is wat we in rest van deze sectie
zullen doen. Er zijn nog meer manieren om een expressie te evalueren, deze
zullen we beschrijven wanneer die aan de orde komen.

Naast dat we ze voor evaluatie-oefeningen gebruiken, zijn de functies die in
volgende secties behandeld worden op zichzelf belangrijk. Het bestuderen van
deze functies verheldert het verschil tussen buffers en bestanden, hoe
tussen buffer te schakelen, en hoe een locatie er binnen vast te stellen.

@node Buffer namen
@section Buffer namen
@findex buffer-name
@findex buffer-file-name

De twee functies @code{buffer-name} en @code{buffer-file-name} tonen het
verschil tussen een buffer en een bestand. Wanneer je volgende expressie
evalueert, @code{(buffer-name)}, verschijnt de naam van het buffer in het
echogebied. Wanneer je @code{(buffer-file-name)} evalueert, verschijnt de
naam van het bestand waar het buffer naar refereert in het
echogebied. Meestal is de naam die @code{(buffer-name)} teruggeeft hetzelfde
als de naam van het bestand waarnaar het refereert, en is de naam die
@code{(buffer-file-name)} teruggeeft de volledige padnaam van het bestand.

Een bestand en een buffer zijn twee verschillende entiteiten. Een bestand is
informatie permanent opgeslagen op de computer (tenzij je het
verwijdert). Een buffer daarentegen is informatie binnen Emacs, die
verdwijnt aan het einde van de editing sessie (of wanneer je het buffer
killt). Meestal bevat een buffer informatie die je van een bestand
gekopieerd hebt, we zeggen dat het buffer het bestand @dfn{bezoekt}. Deze
kopie is waar je op werkt en wijzigt. Veranderingen in het buffer wijzigen
het bestand niet, totdat je het buffer opslaat. Wanneer je het buffer
opslaat, wordt het buffer gekopieerd naar het bestand en zo permanent
opgeslagen.

@need 1250
Wanneer je dit in Info leest binnen Emacs, kan je elk van de volgende
expressies evalueren door de cursor er achter te zetten en @kbd{C-x C-e} te
typen. 

@example
@group
(buffer-name)

(buffer-file-name)
@end group
@end example

@noindent
Wanneer ik dit in Info doe, geeft evaluatie van @code{(buffer-name)} de
waarde @file{"*info*"} terug, en is de waarde die de evaluatie van
@code{(buffer-file-name)} teruggeeft @file{nil}.

Anderzijds, terwijl ik dit document schrijf is de waarde die het evalueren
van @code{(buffer-name)} teruggeeft, @file{"introduction.texinfo"} en de
waarde die de evaluatie van @code{(buffer-file-name)} teruggeeft
@file{"/gnu/work/intro/introduction.texinfo"}.

@cindex @code{nil}, geschiedenis van woord
De eerste is de naam van het buffer en het tweede is de naam van het
bestand. In Info is de naam van het buffer @file{"*info*"}. Info wijst niet
naar een bestand, waardoor @file{nil} het resultaat van de evaluatie
@code{(buffer-file-name)} is. Het symbool @file{nil} is van het Latijnse
woord voor ``niets'', in dit geval betekent het dat het buffer met geen
enkel bestand geassocieerd is. (In Lisp betekent @code{nil} ook ``onwaar''
en is synoniem voor de lege lijst, @code{()}.)

Wanneer ik schrijf is de naam van mijn buffer
@file{"introduction.texinfo"}. De naam van het bestand waar het naar wijst
is @file{"/gnu/work/intro/introduction.texinfo"}.

(In de expressies vertellen de haakjes aan de Lisp interpreter om
@w{@code{buffer-name}} en @w{@code{buffer-file-name}} als functies te
behandelen. Zonder de haakjes zou de interpreter proberen de symbolen als
variabelen te behandelen. @xref{Variabelen}.)

Ondanks het onderscheid tussen bestanden en buffers zie je vaak dat mensen
aan een bestand refereren wanneer ze een buffer bedoelen en
andersom. Inderdaad zeggen de meeste mensen ``ik edit een bestand'' in
plaats van ``ik edit een buffer dat ik binnenkort naar een bestand ga
saven''. Het is vrijwel altijd duidelijk van de context wat mensen
bedoelen. Wanneer we met computerprogramma's werken is het belangrijk het
onderscheid in gedachten te houden, want computers zijn niet zo slim als
mensen.

@cindex Buffer, geschiedenis van woord
Overigens komt het woord ``buffer'' van de betekenis van het woord als een
``kussen dat de kracht van een botsing opvangt''. In de eerste computers
verzachtte een buffer de interactie tussen bestanden en de centrale
verwerkingseenheid. De drums of tapes die het bestand bevatten en de
centrale verwerkingseenheid waren onderdelen van de apparatuur die zeer
verschillend van elkaar waren en op hun eigen snelheid werkten, in
stoten. Uiteindelijk groeide het buffer van een intermediair, een tijdelijke
opslagplaats uit naar de plaats waar het werk wordt gedaan. Deze
transformatie is ongeveer zoals een kleine zeehaven uitgroeide naar een
grote stad. Eens was het slechts de plaats waar lading tijdelijk in
magazijnen werd opgeslagen voordat het op schepen werd verladen en daarna
een zakelijk en cultureel centrum op zichzelf werd.

Niet alle buffers zijn geassocieerd met bestanden. Bijvoorbeeld een
@file{*scratch*}-buffer bezoekt geen enkel bestand. Op dezelfde manier is
het @file{*Help*}-buffer met geen enkel bestand geassocieerd.

Wanneer je vroeger geen @file{~/.emacs} bestand had en een Emacs sessie
startte door het typen van alleen het commando @code{emacs}, zonder enig
bestand te noemen, startte Emacs met het @file{*scratch*} buffer
zichtbaar. Tegenwoordig zie je een startscherm. Je kunt een van de
commando's volgen die op het startscherm gesuggereerd worden, een bestand
bezoeken of op @kbd{q} drukken om het startscherm te sluiten en het
@file{*scratch*}-buffer te bereiken.

Schakel over naar het @file{*scratch*}-buffer en typ @code{(buffer-name)},
plaats de cursor direct er achter, en typ vervolgens @kbd{C-x C-e} om de
expressie te evalueren. De naam @code{"*scratch*"} wordt teruggegeven en
verschijnt in het echogebied. @code{"*scratch*"} is de naam van het
buffer. Wanneer je @code{(buffer-file-name)} in het @file{*scratch*} buffer
typt en dat evalueert, verschijnt @code{nil} in het echogebied, net zoals
dat gebeurt wanneer je @code{(buffer-file-name)} in Info evalueert.

Overigens, als je in het @file{*scratch*} buffer bent en door een expressie
teruggeven waarde in het @file{*scratch*} wilt laten verschijnen in plaats
van het echogebied, typ je @kbd{C-u C-x C-e} in plaats van @kbd{C-x
C-e}. Dit zorgt dat de teruggegeven waarde achter de expressie
verschijnt. Het buffer ziet er zo uit:

@smallexample
(buffer-name)"*scratch*"
@end smallexample

@noindent
Je kunt dit niet in Info doen, omdat Info read-only is en je niet toestaat
de inhoud van het buffer te wijzigen. Maar je kunt dit in elk buffer doen
dat je kunt editen. Wanneer je code schrijft of documentatie (zoals dit
boek), is deze eigenschap erg nuttig.

@node Buffers pakken
@section Buffers pakken
@findex current-buffer
@findex other-buffer
@cindex Een buffer krijgen

De @code{buffer-name}-functie geeft de @emph{naam} van het buffer. Om het
buffer @emph{zelf} te krijgen is een andere functie benodigd, de  functie
@code{current-buffer}. Wanneer je deze functie in code gebruikt krijg je het
buffer zelf.

Een naam en het object of entiteit waar de naam aan refereert zijn van
elkaar verschillend. Jij bent niet je naam. Je bent een persoon die anderen
bij naam noemen. Wanneer je vraagt om met George te spreken en iemand geeft
je een kaart met de letters @samp{G}, @samp{e}, @samp{o}, @samp{r}, @samp{g}
en @samp{e}, dan kan dat je amuseren, maar je zal er niet tevreden mee
zijn. Je wilt niet met de naam spreken, maar met de persoon die met die naam
genoemd is. Een buffer is vergelijkbaar: de naam van het scratch-buffer is
@file{*scratch*}, maar de naam is niet het buffer. Om het buffer zelf te
krijgen, heb je een functie nodig zoals @code{current-buffer}. 

Er is echter een kleine complicatie: wanneer je @code{current-buffer} zelf
evalueert in een expressie, zoals we hier gaan doen, dan wordt de de
representatie van de naam van het buffer getoond zonder de inhoud van het
buffer. Emacs werkt op deze manier wegens twee redenen: het buffer kan
duizenden regels lang zijn---te lang om handig weer te geven, en een ander
buffer kan dezelfde inhoud maar een andere naam hebben en het is belangrijk
om onderscheid tussen hen te maken.

@need 800
Hier is een expressie die de functie bevat:

@smallexample
(current-buffer)
@end smallexample

@noindent
Wanneer je deze expressie in Info in Emacs op de gebruikelijke manier
evalueert, verschijnt @file{#<buffer *info*>} in het echogebied. Het
speciale formaat geeft aan dat het buffer zelf is teruggegeven in plaats van
slechts de naam.

Overigens, hoewel je een getal of symbool in een programma kunt typen, kan
je dit niet doen met de getoonde representatie van een buffer: de enige
manier om een buffer zelf te krijgen is met een functie zoals
@code{current-buffer}.

Een gerelateerde functie is @code{other-buffer}. Deze geeft de meest recent
geselecteerde buffer terug, anders dan degene waar je nu in bent, en niet de
getoonde representatie van de naam. Wanneer je recentelijk heen en weer
tussen het @file{*scratch*} buffer geschakeld hebt, dan zal
@code{other-buffer} dat buffer teruggeven.

@need 800
Dit zie je door de volgende expressie te evalueren:

@smallexample
(other-buffer)
@end smallexample

@noindent
Je zou @file{#<buffer *scratch*>} moeten zien verschijnen in het echogebied,
of de naam van welk ander buffer je het meest recent van teruggeschakeld
hebt. @footnote{Eigenlijk wanneer het buffer waar je laatst vandaan
schakelde voor je zichtbaar is in een ander venster. zal standaard
@code{other-buffer} het meest recente buffer kiezen dat je niet kunt
zien. Dit is een subtiliteit die ik meestal vergeet.}

@node Van buffer verwisselen
@section Van buffer verwisselen
@findex switch-to-buffer
@findex set-buffer
@cindex Switching to a buffer

De @code{other-buffer}-functie biedt eigenlijk een buffer wanneer het
gebruikt wordt als een argument voor een functie die er een vereist. We zien
dit door @code{other-buffer} en @code{switch-to-buffer} te gebruiken om naar
een ander buffer te schakelen.

Maar eerst een korte introductie van de @code{switch-to-buffer}
functie. Toen je heen en weer schakelde tussen Info en het
@file{*scratch*}-buffer om @code{(buffer-name)} te evalueren, heb je
hoogstwaarschijnlijk @kbd{C-x b} en daarna @file{*scratch*}
getypt@footnote{Of beter gezegd, om toetsaanslagen te besparen, heb je
waarschijnlijk alleen @kbd{RET} getypt indien het default buffer
@file{*scratch*} was, of wanneer het niet zo was, je slechts een gedeelte
van de naam typte, zoals @code{*sc}, en de @kbd{TAB}-toets gebruikte zodat
het expandeerde naar de volledige naam, en daarna @kbd{RET} typte.} toen je
in het minibuffer gevraagd werd naar de naam van het buffer waar naar toe te
schakelen. De toetsaanslagen @kbd{C-x b} laten de Lisp interpreter de
interactieve @code{switch-to-buffer}-functie evalueren. Zoals we eerder
gezegd hebben, dit is hoe Emacs werkt: verschillende toetsaanslagen roepen
verschillende functies aan of draaien die. Bijvoorbeeld @kbd{C-f} roept
@code{forward-char} aan, @kbd{M-e} roept @code{forward-sentence} aan,
enzovoorts.

Door @code{switch-to-buffer} in een expressie te schrijven en het een
buffernaam te geven om naar te schakelen, kunnen we buffers schakelen op
dezelfde manier zoals @kbd{C-x b} doet:

@smallexample
(switch-to-buffer (other-buffer))
@end smallexample

@noindent
@c noindent
Het symbool @code{switch-to-buffer} is het eerste element in de lijst, dus
zal de Lisp interpreter het als een functie behandelen en de instructies
uitvoeren die daaraan gekoppeld zijn. Maar voordat die dat doet, merkt de
interpreter op dat @code{other-buffer} tussen haakjes staat en eerst dat
symbool verwerkt. @code{other-buffer} is het eerste (en in dit geval enige)
element in deze lijst, dus de Lisp interpreter roept of runt deze
functie. Het geeft een ander buffer terug. Vervolgens runt de interpreter
@code{switch-to-buffer} en geeft het andere buffer als argument door, waar
Emacs naar zal omschakelen. Wanneer je dit in Info leest, probeer het dan nu
direct. Evalueer de expressie. (Typ @kbd{C-x b @key{RET}} om terug te gaan.)
@footnote{Onthoudt, deze expressie zal je naar het meest recent
geselecteerde buffer brengen, die je niet kunt zien. Wanneer je werkelijk
naar je meest recent geselecteerde buffer wilt gaan, zelfs wanneer je die
kunt zien, evalueer dan de volgende expressie:
@smallexample
(switch-to-buffer (other-buffer (current-buffer) t))
@end smallexample
In dit geval vertelt het eerste argument van  @code{other-buffer} welk
buffer het moet overslaan---het huidige---en het tweede argument vertelt
@code{other-buffer} dat het OK is om naar een zichtbaar buffer te
schakelen. Bij normaal gebruik neemt @code{switch-to-buffer} je naar een
buffer dat niet in vensters zichtbaar is omdat je hoogst waarschijnlijk
@kbd{C-x o} (@code{other-window}) gebruikt om naar een ander zichtbaar
buffer te gaan.}

In de programmeervoorbeelden in volgende secties van dit document zie je de
functie @code{set-buffer} vaker dan @code{switch-to-buffer}. Dit is wegens
een verschil tussen computerprogramma's en mensen: mensen hebben ogen en
verwachten het buffer te zien waarop ze werken op hun computerterminals. Dit
is zo voor de hand liggend, het spreekt bijna voor zich. Echter, programma's
hebben geen ogen. Wanneer een computerprogramma op een buffer werkt, dan
hoeft dat buffer niet op het scherm zichtbaar te zijn.

@code{switch-to-buffer} is ontworpen voor mensen en doet twee verschillende
dingen: het schakelt het buffer waar de aandacht van Emacs op is gevestigd
en het schakelt het buffer dat getoond wordt in het venster naar een nieuw
buffer. @code{set-buffer} anderzijds doet meer een enkel ding: het schakelt
de aandacht van het computerprogramma naar een ander buffer. Het buffer op
het scherm blijft onveranderd (uiteraard gebeurt er niets totdat het
commando klaar is met lopen).

@cindex @samp{aanroepen} gedefinieerd
Ook hebben we net een ander jargon term geïntroduceerd, het woord
@dfn{aanroepen}. Wanneer je een lijst evalueert waar het eerste symbool een
functie is, dan roep je die functie aan. Het gebruik van deze term komt
voort uit het begrip van de functie als entiteit dan iets voor je kan doen
wanneer je het aanroept---net als een loodgieter een entiteit is die een lek
kan repareren wanneer je hem of haar roept.

@node Buffer grootte en locatie
@section Buffergrootte en de locatie van point
@cindex Buffergrootte
@cindex Buffergrootte
@cindex Locatie van point
@cindex Locatie van point

Laten wij tenslotte naar enkele nogal eenvoudige functies kijken,
@code{buffer-size}, @code{point}, @code{point-min} en @code{point-max}. Deze
geven informatie over de grootte van een buffer en de locatie van point
daarin.

De functie @code{buffer-size} vertelt je hoe groot het huidige buffer
is. Dit houdt in dat de functie de som van het aantal karakters in het
buffer teruggeeft.

@smallexample
(buffer-size)
@end smallexample

@noindent
Je kunt dit op de gebruikelijke manier evalueren door de cursor achter de
expressie te plaatsen en @kbd{C-x C-e} te typen.

@cindex @samp{point} gedefinieerd
In Emacs wordt de huidige positie van de cursor @dfn{point} genoemd. De
expressie @code{(point)} geeft een getal terug dat je vertelt waar de cursor
is gepositioneerd als een telling van het aantal karakters vanaf het begin
van het buffer tot point.

@need 1250
Je kunt de karaktertelling voor point in dit buffer zien door het op de
gebruikelijke manier evalueren van de volgende expressie:

@smallexample
(point)
@end smallexample

@noindent
Terwijl ik dit schrijf is de waarde van point 65724. De @code{point} functie
wordt vaak gebruikt in sommige voorbeelden later in dit boek.

@need 1250
De waarde van point hangt natuurlijk af van zijn locatie in het
buffer. Wanneer je point op deze plek evalueert, is het getal groter:

@smallexample
(point)
@end smallexample

@noindent
Voor mij is de waarde van point op deze plek 66043, wat betekent dat er 319
karakters (inclusief spaties) tussen de twee expressies zijn. (Ongetwijfeld
zie je verschillende getallen, omdat ik dit heb geschreven heb na de eerste
evaluatie van point.)

@cindex @samp{narrowing} defined
De functie @code{point-min} lijkt enigszins op @code{point}, maar het geeft
de waarde van de minimum toegestane waarde van point in het huidige
buffer. Dit is het getal 1 tenzij @dfn{versmallen} van toepassing
is. (Versmallen is het mechanisme waarmee je jezelf of een programma beperkt
tot operaties op slechts een deel van een buffer. @xref{Versmallen en
verbreden, , Versmallen en verbreden}.) Evenzo geeft de functie
@code{point-max} de maximum toegestane waarde van point in het huidige
buffer.

@node Evaluatie oefening
@section Oefening

Vindt een bestand waarmee je werkt en ga naar het midden. Vindt zijn
buffernaam, bestandsnaam, lengte en je positie in het bestand.

@node Defuns schrijven
@chapter Hoe functiedefinities te schrijven
@cindex Definitie schrijven
@cindex Functiedefinitie schrijven
@cindex Schrijven van een functiedefinitie

Wanneer de Lisp interpreter een lijst evalueert, kijkt het of het eerste
symbool in de lijst een functiedefinitie aan zich gekoppeld heeft, met
andere woorden, of het symbool naar een functiedefinitie wijst. Een symbool
met een functiedefinitie wordt eenvoudig een functie genoemd (alhoewel,
eigenlijk is de definitie de functie en verwijst het symbool er naar).

@menu
* Primitieve functies::      Primitieve functies
* defun::                    De @code{defun} macro.
* Installeer::               Installeer een functiedefinitie
* Interactief::              Een functie interactief maken.
* Interactieve opties::      Verschillende opties voor @code{interactive}.
* Permanent installeren::    Installeer code permanent
* let::                      Locale variabelen maken en initialiseren
* if::                       Wat als?
* else::                     If--then--else expressies.
* Waar en onwaarheid::       Wat Lisp als waar en onwaar beschouwt.
* save-excursion::           Point en buffer volgen
* Terugblik::                Terugblik
* defun oefeningen::         defun oefeningen
@end menu

@ifnottex
@node Primitieve functies
@unnumberedsec Een terzijde over primitieve functies
@end ifnottex
@cindex Primitieve functies
@cindex Functies, primitief

@cindex C-taal primitieven
@cindex Primitieven geschreven in C
Alle functies zijn beschreven in termen van andere functies, behalve enkele
@dfn{primitieve} functies die in de C programmeertaal geschreven
zijn. Wanneer je functiedefinities schrijft, schrijf je ze in Emacs Lisp en
je gebruikt andere functies als bouwstenen. Sommige functies die je gebruikt
zijn zelf geschreven in Emacs Lisp (misschien door jezelf) en sommige zijn
primitieven geschreven in C@. De primitieve functies worden precies zo
gebruikt als de in Emacs Lisp geschreven functies en gedragen zich net
zo. Zij zijn in C geschreven zodat we GNU Emacs makkelijk op elke computer
kunnen draaien die voldoende krachtig is en C kan draaien.

Laat me dit nogmaals benadrukken: wanneer je code in Emacs Lisp schrijft,
maak je geen onderscheid tussen het gebruik van functies geschreven in C en
functies geschreven in Emacs Lisp. Het verschil is irrelevant. Ik noem het
onderscheid alleen omdat is interessant is het te weten. Inderdaad, tenzij
je het onderzoekt, zou je niet weten of een reeds geschreven functie is
geschreven in Emacs Lisp of C.

@node defun
@section De @code{defun} macro
@findex defun

@cindex @samp{functiedefinitie} gedefinieerd
In Lisp heeft een symbool zoals @code{mark-whole-buffer} code aan zich
gekoppeld die de computer vertelt wat te doen wanneer die functie wordt
aangeroepen. Deze code heet de @dfn{functiedefinitie} en is gecreëerd door
het evalueren van een Lisp expressie die start met het symbool @code{defun}
(wat een afkorting is van @emph{definieer functie}).

In volgende secties kijken we naar functiedefinities van de Emacs broncode,
zoals @code{mark-whole-buffer}. In deze sectie beschrijven we een eenvoudige
functiedefinitie zodat je kunt zien hoe die eruitzien. Dat voorbeeld
gebruikt rekenkunde omdat het tot een eenvoudig voorbeeld leidt. Sommige
mensen houden niet van voorbeelden met rekenkunde, echter wanneer je zo'n
persoon bent, wanhoop niet. Nauwelijks enige code die we in de rest van deze
introductie behandelen heeft met rekenkunde of wiskunde te maken. De
voorbeelden hebben hoofdzakelijk op de een of andere manier met tekst te
maken.

Een functiedefinitie bestaat uit maximaal vijf onderdelen volgend op het
woord @code{defun}: 

@enumerate
@item
De naam van het symbool waaraan de functiedefinitie gekoppeld moet worden.

@item
Een lijst met de argumenten die aan de functie zullen worden
doorgegeven. Wanneer geen argumenten aan de functie zullen worden
doorgegeven is dit een lege lijst, @code{()}.

@item
Documentatie die de functie beschrijft. (Technisch optioneel, maar sterk
aanbevolen.)

@item
Optioneel een expressie die de functie interactief maakt zodat je die kunt
gebruiken door @kbd{M-x} gevolgd door de naam van de functie te typen, of
door het typen van een passende toets of toetscombinatie.

@cindex @samp{body} gedefinieerd
@item
De code die de computer instrueert wat de doen de @dfn{body} van de
functiedefinitie.
@end enumerate

Het is nuttig om de vijf delen van een functiedefinitie te beschouwen als
een sjabloon met vijf slots voor elk onderdeel: 

@smallexample
@group
(defun @var{functienaam} (@var{argumenten}@dots{})
  "@var{optionele-documentatie}@dots{}"
  (interactive @var{argument-doorgevende-info})     ; @r{optioneel}
  @var{body}@dots{})
@end group
@end smallexample

Als een voorbeeld is hier de code voor een functie die zijn argument met 7
vermenigvuldigt. (Het voorbeeld is niet interactief. @xref{Interactief, ,
Een functie interactief maken}, voor die informatie.)

@smallexample
@group
(defun vermenigvuldig-met-zeven (getal)
  "Vermenigvuldig GETAL met zeven."
  (* 7 getal))
@end group
@end smallexample

Deze definitie begint met een haakje en het symbool @code{defun}, gevolgd
door de naam van de functie.

@cindex @samp{argumentlijst} gedefinieerd
De naam van de functie wordt gevolgd door een lijst die de argumenten bevat
die aan de functie zullen worden doorgegeven. Deze lijst heet de
@dfn{argumentlijst}. In dit voorbeeld heeft de lijst maar één element, het
symbool @code{getal}. Wanneer de functie wordt gebruikt wordt het symbool
gebonden aan de waarde die als argument van de functie is gebruikt.

In plaats van te kiezen voor het woord @code{getal} als naam van het
argument had ik elke andere naam kunnen pakken. Bijvoorbeeld had ik kunnen
kiezen voor het woord @code{multiplicant}. Ik pakte het woord ``getal''
omdat het vertelt wat voor soort waarde bedoeld is voor het slot, maar ik
net zo goed het woord ``multiplicant'' kunnen kiezen om de rol aan te geven
die de in dit slot geplaatste waarde speelt in de werking van de functie. Ik
had het ook @code{foogle} kunnen noemen, maar dat zou een slechte keuze zijn
omdat het niet aan mensen vertelt wat het betekent. De keuze van de naam is
aan de programmeur en moet zo gekozen worden dat het de betekenis van de
functie duidelijk maakt.

Je kunt inderdaad elke naam die je maar wilt kiezen voor een symbool in de
argumentlijst, zelfs de naam van een symbool die in een andere functie
gebruikt wordt: de naam die je gebruikt in de argumentlijst is privé voor
die specifieke definitie. In die definitie refereert de naam naar een andere
entiteit dan elk gebruik van de zelfde naam buiten de functiedefinitie. Stel
je hebt de bijnaam ``Kleintje'' in je familie, dan refereren familieleden
met ``Kleintje'' naar jou. Maar buiten jouw familie, bijvoorbeeld in een
speelfilm, refereert de naam ``Kleintje'' naar iemand anders. Omdat de naam
in de argumentlijst privé is voor de functiedefinitie kan je de waarde van
zo'n symbool binnen de body van de functie wijzigen zonder de waarde buiten
de functie te wijzigen. Het effect is vergelijkbaar met dat geproduceerd
door de @code{let}-expressie. (@xref{let, , @code{let}}.)

@ignore
Note also that we discuss the word ``number'' in two different ways: as a
symbol that appears in the code, and as the name of something that will
be replaced by a something else during the evaluation of the function.
In the first case, @code{number} is a symbol, not a number; it happens
that within the function, it is a variable who value is the number in
question, but our primary interest in it is as a symbol.  On the other
hand, when we are talking about the function, our interest is that we
will substitute a number for the word @var{number}.  To keep this
distinction clear, we use different typography for the two
circumstances.  When we talk about this function, or about how it works,
we refer to this number by writing @var{number}.  In the function
itself, we refer to it by writing @code{number}.
@end ignore

De argumentlijst wordt gevolgd door de documentatiestring die de functie
beschrijft. Dat is wat je ziet als je @w{@kbd{C-h f}} en de naam van de
functie typt. Overigens, wanneer je een documentatiestring als deze schrijft
moet je van de eerste regel een complete zin maken, omdat sommige
commando's, zoals @code{apropos}, alleen de eerste regel tonen van een
meerregelige documentatiestring. Ook moet je de tweede regel van een
documentatiestring, wanneer die er is, niet laten inspringen, omdat dit er
raar uitziet wanner je @kbd{C-h f} (@code{describe-function}) gebruikt. De
documentatiestring is optioneel, maar is zo nuttig, dat die deel van vrijwel
elke functie die je schrijft zou moeten zijn.

@findex * @r{(vermenigvuldiging)}
De derde regel van ons voorbeeld bestaat uit de body van de
functiedefinitie. (De meeste functiedefinities zijn natuurlijk langer dan
deze.) In dit voorbeeld is de body de lijst @code{(* 7 getal)}, die zegt
vermenigvuldig de waarde van @var{getal} met 7. (In Emacs Lisp, is @code{*}
de functie voor vermenigvuldiging, net zoals @code{+} de functie voor
optellen is.)

Wanneer je de functie @code{vermenigvuldig-met-zeven} gebruikt evalueert
@code{getal} naar het daadwerkelijk getal dat je wilt gebruiken. Hier is een
voorbeeld dat toont hoe je @code{vermenigvuldig-met-zeven} gebruikt, maar
probeer het nu nog niet te evalueren!

@smallexample
(vermenigvuldig-met-zeven 3)
@end smallexample

@noindent
Het symbool @code{getal}, gespecificeerd in de functiedefinitie in de
volgende sectie, is gebonden aan de waarde 3 in het daadwerkelijk gebruik
van de functie. Merk op dat hoewel @code{getal} tussen haakjes in de
functiedefinitie stond, het argument dat aan de functie
@code{vermenigvuldig-met-zeven} wordt doorgegeven niet tussen haakjes
staat. De haakjes worden in de functiedefinitie geschreven zodat de computer
uit kan zoeken waar de argumentlijst eindigt en de rest van de functie
begint.

Wanneer je dit voorbeeld evalueert, krijgt je waarschijnlijk een
foutmelding. (Ga je gang, probeer het!) Dit is omdat we de functiedefinitie
hebben geschreven maar de computer nog niet op de hoogte gebracht hebben van
de definitie---wij hebben de functiedefinitie nog niet in Emacs geladen. Het
installeren van een functie is het proces dat de Lisp interpreter op de
hoogte brengt van de functie. Het installeren wordt in de volgende sectie
beschreven.

@node Installeer
@section Installeer een functiedefinitie
@cindex Installeer een functiedefinitie
@cindex Definitie installatie
@cindex functiedefinitie installatie

Wanneer je dit binnen Info in Emacs leest, kan je de functie
@code{vermenigvuldig-met-zeven} proberen door eerst de functiedefinitie te
evalueren en daarna @code{(vermenigvuldig-met-zeven 3)} te evalueren. Een
exemplaar van de functiedefinitie volgt. Plaats de cursor achter het laatste
haakje van de functiedefinitie en typ @kbd{C-x C-e}. Wanneer je dit doet,
verschijnt @code{vermenigvuldig-met-zeven} in het echogebied. (Wat dit
betekent is dat wanneer een functiedefinitie wordt geëvalueerd, de waarde
die het teruggeeft de naam van de gedefinieerde functie is.) Tegelijkertijd
installeert deze actie de functiedefinitie.

@smallexample
@group
(defun vermenigvuldig-met-zeven (getal)
  "Vermenigvuldig GETAL met zeven."
  (* 7 getal))
@end group
@end smallexample

@noindent
Met het evalueren van deze @code{defun} heb je zojuist
@code{vermenigvuldig-met-zeven} in Emacs geïnstalleerd. De functie is nu net
zo goed onderdeel van Emacs als
@code{forward-word}.(@code{vermenigvuldig-met-zeven} blijft geïnstalleerd
totdat je Emacs afsluit. Om de code automatisch opnieuw te laden wanneer je
Emacs start, zie @ref{Permanent installeren, , Installeer code permanent}.)

@menu
* Effect van installatie::   Effect van installatie
* Een defun wijzigen::       Hoe een functiedefinitie te wijzigen.
@end menu

@ifnottex
@node Effect van installatie
@unnumberedsubsec Het effect van de installatie
@end ifnottex

Je kunt het effect van het installeren van @code{vermenigvuldig-met-zeven}
zien dor het volgende voorbeeld te evalueren. Plaats de cursor achter de
volgende expressie en typ @kbd{C-x C-e}. Het getal 21 verschijnt in het
echogebied.

@smallexample
(vermenigvuldig-met-zeven 3)
@end smallexample

Als je dat wilt kun je de documentatie van de functie lezen door het typen
van @kbd{C-h f} (@code{describe-function}) en dan de naam van de functie
@code{vermenigvuldig-met-zeven}. Wanneer je dat doet dan verschijnt een
@file{*Help*}-venster op het scherm, dat zegt:

@smallexample
@group
vermenigvuldig-met-zeven is an interpreted-function.

(vermenigvuldig-met-zeven GETAL)
Vermenigvuldig-met-zeven GETAL met zeven.
@end group
@end smallexample

@noindent
(Om terug te gaan naan een enkel venster op je scherm, typ @kbd{C-x 1}.)

@node Een defun wijzigen
@subsection Wijzig een functiedefinitie
@cindex Een functiedefinitie wijzigen
@cindex Functiedefinitie, hoe te wijzigen
@cindex Definitie, hoe te wijzigen

Wanneer je de code in @code{vermenigvuldig-met-zeven} wilt wijzigen,
herschrijf je die. Om een nieuwe versie in plaats van de oude te installeren
evalueer je de functiedefinitie opnieuw. Dit is hoe je code in Emacs
aanpast. Dat is erg eenvoudig.

Als een voorbeeld kan je de @code{vermenigvuldig-met-zeven}-functie wijzigen
zodat die het getal zeven keer met zichzelf optelt, in plaats van het
vermenigvuldigen van het getal met zeven. Het produceert hetzelfde antwoord,
maar via een andere route. Tegelijkertijd voegen we commentaar toe aan de
code. Commentaar is tekst die de Lisp interpreter negeert, maar die de
menselijke lezer nuttig of verhelderend kan vinden. Het commentaar is dat
dit de tweede versie is.

@smallexample
@group
(defun vermenigvuldig-met-zeven (getal)       ; @r{Tweede versie.}
  "Multiply GETAL by seven."
  (+ getal getal getal getal getal getal getal))
@end group
@end smallexample

@cindex Commentaar in Lisp code
Het commentaar volgt op een puntkomma, @samp{;}. In Lisp is alles op een
regel dat volgt achter een puntkomma commentaar. Het einde van de regel is
het einde van het commentaar. Om het commentaar over twee of meer regels te
spreiden, begin je elke regel met een puntkomma.

@xref{Een init bestand beginnen, , Starten met een @file{.emacs} bestand},
en @ref{Comments, , Comments, elisp, The GNU Emacs Lisp Reference Manual},
voor meer over commentaar.

Je kunt deze versie van @code{vermenigvuldig-met-zeven} installeren door het
op dezelfde manier te evalueren als je de eerste functie geëvalueerd hebt:
plaats de cursor achter het laatste haakje en typ @kbd{C-x C-e}.

Samengevat, dit is hoe je code in Emacs Lisp schrijft: je schrijft een
functie, installeert die, test die en dan maak je verbeteringen of
uitbreidingen en installeert die opnieuw.

@node Interactief
@section Een functie interactief maken
@cindex Interactieve functies
@findex interactive

Je maakt een functie interactief door een lijst die begint met de speciale
vorm @code{interactive} direct achter de documentatie. Een gebruiker kan een
interactieve functie starten door het typen van @kbd{M-x} en daarna de naam
van de functie, of door het typen van de toetscombinatie waaraan die is
gebonden, bijvoorbeeld door het typen van @kbd{C-n} voor @code{next-line} of
@kbd{C-x h} voor @code{mark-whole-buffer}.

Het is interessant dat wanneer je een interactieve functie interactief
aanroept, de teruggegeven waarde niet automatisch in het echogebied wordt
getoond. Dit is omdat je vaak een interactieve functie aanroept wegens de
zij-effecten, zoals een woord of regel verder gaan, en niet voor de
teruggegeven waarde. Wanneer de teruggegeven waarde elke keer dat je een
toets aanslaat in het echogebied getoond zou worden, zou dat erg afleiden.

@menu
* Interactieve vermenigvuldig-met-zeven::  Een overzicht
* vermenigvuldig-met-zeven in detail::  De interactieve versie
@end menu

@ifnottex
@node Interactieve vermenigvuldig-met-zeven
@unnumberedsubsec Een interactieve @code{vermenigvuldig-met-zeven}, een overzicht
@end ifnottex

Zowel het gebruik van de speciale vorm @code{interactive} en een manier om
de waarde in het echogebied te tonen kan door het maken van een interactieve
versie van @code{vermenigvuldig-met-zeven} worden geïllustreerd.

@need 1250
Hier is de code:

@smallexample
@group
(defun vermenigvuldig-met-zeven (getal)       ; @r{Interactieve versie.}
  "Vermenigvuldig GETAL met zeven."
  (interactive "p")
  (message "Het resultaat is %d" (* 7 getal)))
@end group
@end smallexample

@noindent
Je installeert deze code door de cursor er achter te plaatsen en @kbd{C-x
C-e} te typen. De naam van de functie verschijnt in je
echogebied. Vervolgens kan je deze code gebruiken door het typen van
@kbd{C-u} en een getal, en daarna @kbd{M-x vermenigvuldig-met-zeven} te
typen en op @key{RET} te drukken. De zin @samp{Het resultaat is @dots{}}
gevolgd door het product verschijnt in het echogebied.

Meer algemeen gesproken roep je een functie zoals deze aan op een van de
twee manieren: 

@enumerate
@item
Door het typen van een prefix-argument dat het door te geven getal bevat en
daarna @kbd{M-x} en de naam van de functie te typen, zoals met @kbd{C-u 3
M-x forward-sentence}; of,

@item
Door welke toets of toetscombinatie dan ook de functie aan gebonden is,
zoals met @kbd{C-u 3 M-e}.
@end enumerate

@noindent
Beide zojuist genoemde voorbeelden werken identiek om point drie zinnen
verder te plaatsen. (Omdat @code{vermenigvuldig-met-zeven} niet aan een
toets gebonden is, kan dit niet gebruikt worden als voorbeeld van een key
binding.) 

(@xref{Key bindings, , Sommige key bindings}, om te leren hoe je een
commando aan een key bindt.) 

Een @dfn{prefix-argument} wordt aan een interactieve functie gegeven door
het aanslaan van de @key{META} toets gevolg door een cijfer, bijvoorbeeld
@kbd{M-3 M-e}, of door het aanslaan van @kbd{C-u} en daarna een getal,
bijvoorbeeld @kbd{C-u 3 M-e} (wanneer je @kbd{C-u} zonder getal aanslaat, is
de standaard waarde 4).

@node vermenigvuldig-met-zeven in detail
@subsection Een interactieve @code{vermenigvuldig-met-zeven}

Laten we naar het gebruik van de speciale vorm @code{intertive} kijken en
daarna naar de functie @code{message} in de interactieve versie van
@code{vermenigvuldig-met-zeven}. Je herinnert dat de functiedefinitie er zo
uitziet:

@smallexample
@group
(defun vermenigvuldig-met-zeven (getal)       ; @r{Interactieve versie.}
  "Vermenigvuldig GETAL met zeven."
  (interactive "p")
  (message "Het resultaat is %d" (* 7 getal)))
@end group
@end smallexample

In deze functie is de expressie  @code{(interactive "p")} een lijst met twee
elementen. De @code{"p"} vertelt Emacs om het prefix-argument door te geven
aan de functie en zijn waarde te gebruiken voor het argument van de functie.

@need 1000
Het argument is een getal. Dit betekent dat het symbool @code{getal} wordt
gebonden aan een getal in de regel:

@smallexample
(message "Het resultaat is %d" (* 7 getal))
@end smallexample

@need 1250
@noindent
Bijvoorbeeld wanneer je prefix-argument 5 is, zal de Lisp interpreter de
regel evalueren alsof het was:

@smallexample
(message "Het resultaat is %d" (* 7 5))
@end smallexample

@noindent
(Wanneer je dit in GNU Emacs leest, kan je zelf deze expressie evalueren.)
Eerst zal de interpreter de binnenste lijst evalueren, dus @code{(* 7
5)}. Dit geeft een waarde van 35 terug. Daarna zal het de buitenste lijst
evalueren, en daarbij de waardes van tweede en volgende elementen van de
lijst doorgeven aan de functie @code{message}.

Zoals we hebben gezien is @code{message} een Emacs Lisp functie specifiek
ontworpen om een eenregelige boodschap naar de gebruiker te
sturen. (@xref{message, , De @code{message} functie}.) Samengevat, de
@code{message} functie toont zijn argumenten in het gebied zoals ze zijn,
met uitzondering van gevallen zoals @samp{%d} of @samp{%s} (en diverse
andere %-reeksen die we nog niet genoemd hebben). Wanneer het een
control-reeks ziet, kijkt de functie naar het tweede en volgende argumenten
en toont de waarde van de argumenten in de string op de plek waar de
control-reeks staat.

In de interactieve @code{vermenigvuldig-met-zeven}-functie is de
control-reeks @samp{%d}, die een getal vereist, en de waarde die de
evaluatie van @code{(* 7 5)} teruggeeft is het getal 35. Daarom wordt het
getal 35 getoond op de plaats van @samp{%d} en is de boodschap @samp{Het
resultaat is 35}.

(Merk op dat wanneer je de functie @code{vermenigvuldig-met-zeven} aanroept,
de boodschap zonder aanhalingstekens getoond wordt. Dit komt omdat de waarde
die door @code{message} wordt teruggeven in het echogebied verschijnt
wanneer je een expressie evalueert wiens eerste element @code{message} is,
maar wanneer het in een functie is ingebed, toont @code{message} de tekst
als een zij-effect zonder de aanhalingstekens.)

@node Interactieve opties
@section Verschillende opties voor @code{interactive}
@cindex Opties voor @code{interactive}
@cindex Interactieve opties

In het voorbeeld gebruikte @code{vermenigvuldig-met-zeven} @code{"p"} als
argument voor @code{interactive}. Dit argument vertelde Emacs om door wat je
typte, hetzij @kbd{C-u} gevolgd door een getal of @key{META} gevold door een
cijfer, te interpreteren als een commando om dat getal door te geven aan de
functie als zijn argument. Emacs heeft meer dan twintig karakters
voorgedefinieerd om met @code{interactive} te gebruiken. In vrijwel alle
gevallen maakt een van deze opties het je mogelijk de juiste informatie
interactief aan een functie door te geven. (@xref{Interactive Codes, , Code
Characters for @code{interactive}, elisp, The GNU Emacs Lisp Reference
Manual}.)

@need 1250
Beschouw de functie @code{zap-to-char}. De interactieve expressie daarvan is

@c FIXME: the interactive expression of zap-to-char has been changed
@c (in 2012-04-10).

@smallexample
(interactive "p\ncZap to char: ")
@end smallexample

Het eerste deel van het argument van @code{interactive} is @samp{p}, waarmee
je al vertrouwd bent. Dit argument vertelt Emacs een prefix als getal te
interpreteren om aan de functie door te geven. Je geeft het prefix op hetzij
door @kbd{C-u} gevolgd door een getal te typen, of door het typen van
@key{META} gevolgd door een cijfer. Het prefix is het aantal van het
opgegeven karakter. Dus als je prefix drie is en het opgegeven karakter
@samp{x}, dan verwijder je alle tekst tot en met de derde volgende
@samp{x}. Wanneer je geen prefix gebruikt dan verwijder je alle tekst tot en
met het gespecificeerde karakter, maar niet meer.

De @samp{c} vertelt de functie de naam van het karakter tot waar te
verwijderen.

Meer formeel, een functie met twee of meer argumenten kan voor elk argument
informatie doorgegeven krijgen door delen toe te voegen aan de string die
volgt op @code{interactive}. Wanneer je dit doet is de informatie die
doorgegeven wordt in dezelfde volgorde als gespecificeerd is de
@code{interactive} lijst. In de string is elk deel gescheiden van het
volgende deel door een @samp{\n}, wat een nieuwe regel is. Bijvoorbeeld, je
kunt @samp{p} opvolgen met een @samp{\n} en een @samp{cZap to char:@: }. Dit
laat Emacs de waarde doorgeven van het prefix-argument (als er een is) en
het karakter.

In dit geval ziet de functiedefinitie er als volgt uit, waarbij @code{arg}
en @code{char} de symbolen zijn waaraan @code{interactive} het
prefix-argument en het gespecificeerde karakter bindt:

@smallexample
@group
(defun @var{name-of-function} (arg char)
  "@var{documentation}@dots{}"
  (interactive "p\ncZap to char: ")
  @var{body-of-function}@dots{})
@end group
@end smallexample

@noindent
(De spatie achter de dubbele punt in de prompt maakt dat het er beter
uitziet wanneer je wordt geprompt. @xref{copy-to-buffer, , De definitie van
@code{copy-to-buffer}}, bijvoorbeeld.)

Wanneer een functie geen argumenten heeft, hoeft @code{interactive} er geen
te hebben. Zo'n functie bevat de eenvoudige expressie
@code{(interactive)}. De functie @code{mark-whole-buffer} is er zo een.

Daarnaast kun je, wanneer de speciale letter-codes niet geschikt zijn voor
jouw applicatie, je eigen argumenten als lijst doorgeven aan
@code{interactive}.

@xref{append-to-buffer, , De definitie van @code{append-to-buffer}}, voor
een voorbeeld. @xref{Using Interactive, , Using @code{Interactive}, elisp,
The GNU Emacs Lisp Reference Manual}, voor een meer complete uitleg over
deze techniek.

@node Permanent installeren
@section Code permanent installeren
@cindex Code permanent installeren
@cindex Permanente code installatie
@cindex Code installtie

Wanneer je een functiedefinitie installeert door het te evalueren, blijft
het geïnstalleerd totdat je Emacs sluit. De volgende keer dat je een nieuwe
sessie van Emacs start, is de functie niet geïnstalleerd tenzij je de
functiedefinitie opnieuw evalueert.

Op een gegeven moment wil je de code automatisch geïnstalleerd hebben
wanneer je een nieuwe Emacs sessie start. Er zijn verschillende manieren om
dit te doen:

@itemize @bullet
@item
Wanneer je code hebt die uitsluitend voor jezelf is, kan je de code voor de
functiedefinitie opnemen in je @file{.emacs} initialisatiebestand.

@item
Een andere manier is de functiedefinities die je geïnstalleerd wilt hebben
zelf in een of meer bestanden opnemen en de functie @code{load} gebruiken om
Emacs ze te laten evalueren en daarmee elk van de functies in de bestanden
installeren. @xref{Bestanden laden, , Bestanden laden}.

@item
Ten derde, wanneer je code hebt die je systeem-breed wilt gebruiken, is het
gebruikelijk die in een bestand op te nemen met de naam @file{site-init.el},
die wordt geladen wanneer Emacs wordt gebouwd. Dit maakt de code beschikbaar
voor iedereen die jouw machine gebruikt. (Zie het bestand @file{INSTALL} dat
onderdeel is van je Emacs distributie.)
@end itemize

Tenslotte, wanneer je code hebt die iedereen die Emacs gebruikt zou willen
hebben, dan kun je het op een computernetwerk posten of een exemplaar naar
de Free Software Foundation sturen. (Wanneer je dit doet, breng dan
alsjeblieft de code en de bijbehorende documentatie onder een licentie die
andere mensen toestaat het te draaien, kopiëren, bestuderen, aan te passen
en verder te distribueren en die je beschermt tegen dat je werk van je
afgenomen wordt.) Wanneer je een exemplaar van jouw code naar de Free
Software Foundation stuurt, en jezelf en anderen juist beschermt, dan zou
het in een volgende release van Emacs kunnen worden opgenomen. Dit is
grotendeels hoe Emacs over de jaren gegroeid is, door donaties.

@xref{Contributing, Contributing to Emacs Development,, emacs, The GNU Emacs
Manual}, over hoe bij te dragen met opname van je code in Emacs.

@node let
@section @code{let}
@findex let

De @code{let} expressie is een speciale vorm in Lisp die je in de meeste
functiedefinities nodig hebt.

@code{let} wordt gebruikt om een symbool aan een variabele te koppelen of te
binden op zo'n manier dat de Lisp interpreter het niet verwart met een
variabele met dezelfde naam die geen onderdeel van de functie is.

Om te begrijpen waarom de speciale vorm @code{let} nodig is, beschouw de
situatie waarin je in het algemeen aan jouw huis refereert als ``het huis'',
zoals in de zin ``Het huis moet geverfd worden''. Wanneer je een vriend
bezoekt en de gastheer refereert aan ``het huis'', refereert hij
waarschijnlijk aan @emph{zijn} huis, niet het jouwe, dus aan een ander huis.

Wanneer je vriend naar zijn huis refereert en jij denkt dat hij naar jouw
huis refereert, dan kan dat verwarrend zijn. Hetzelfde kan in Lisp gebeuren
wanneer een variabele die binnen de ene functie gebruikt wordt dezelfde naam
heeft als een variabele die binnen een andere functie gebruikt wordt, en de
twee zijn niet bedoeld om naar dezelfde waarde te refereren. De speciale
vorm @code{let} voorkomt dit soort verwarring.

@menu
* Voorkom verwarring::       Voorkom verwarring
* Delen van een let expressie::  Delen van een let expressie
* Voorbeeld let expressie::  Voorbeeld let expressie
* Niet-geïnitialiseerde let variabelen::  Niet-geïnitialiseerde let 
                                            variabelen
* Hoe let variabelen bindt::  Hoe let variabelen bindt
@end menu

@ifnottex
@node Voorkom verwarring
@unnumberedsubsec @code{let} voorkomt verwarring
@end ifnottex

@c FIXME!! lexbind!!

@cindex @samp{lokale variabele} gedefinieerd
@cindex @samp{variabele, lokaal}, gedefinieerd
De speciale vorm @code{let} voorkomt verwarring. @code{let} creëert een naam
voor een @dfn{lokale variabele} die elk gebruik van dezelfde naam buiten de
@code{let}-expressie overschaduwt (in computerwetenschappelijk jargon noemen
we dit het @dfn{binden} van de variabele). Dit is vergelijkbaar met
begrijpen dat in het huis van je gastheer, wanneer hij refereert aan ``het
huis'', hij zijn huis bedoelt en niet het jouwe. (De symbolen die gebruikt
worden om functieargumenten te benoemen worden op precies dezelfde manier
als lokale variabelen gebonden. @xref{defun, , De @code{defun} macro}.)

Een andere manier om over @code{let} te denken is dat het een speciaal
gebied in je code definieert: binnen de body van de @code{let}-expressie,
hebben de variabelen die je benoemd hebt hun eigen lokale betekenis. Buiten
de @code{let} body hebben zij een andere betekenis (of ze zijn helemaal niet
gedefinieerd). Dit betekent dat binnen de @code{let} body het aanroepen van
@code{setq} voor een variabele benoemd door de @code{let}-expressie de
waarde instelt voor de @emph{lokale} variabele met die naam. Echter buiten
de @code{let} body (zoals bij het aanroepen van een functie die ergens
anders is gedefinieerd), @code{setq} aanroepen voor een variabele benoemd
door de @code{let}-expressie heeft @emph{geen} effect voor die lokale
variabele.@footnote{Dit beschrijft het gedrag van @code{let} bij het gebruik
van een stijl met de naam ``lexical binding'' (@pxref{Hoe let variabelen
bindt}).} 

@code{let} kan meer dan een variabele tegelijk creëren. Dus @code{let} geeft
iedere variabele die het creëert een initiële waarde, of een door jou
gespecificeerde waarde, of @code{nil}. (In het jargon is dit het binden van
de variabele aan de waarde.) Nadat @code{let} de variabelen heeft gecreëerd
en gebonden voert het de code in de body van de @code{let} uit, als de
waarde van de gehele @code{let}-expressie. (``Uitvoeren'' is een jargon term
die het evalueren van de lijst betekent, het komt van het gebruik van het
woord met de betekenis ``een praktisch effect hebben op'' (@cite{Oxford
English Dictionary}) Wanneer je een expressie evalueert om een actie uit te
voeren, is ``uitvoeren'' geëvolueerd tot synoniem voor ``evalueren''.)

@node Delen van een let expressie
@subsection De delen van een @code{let} expressie
@cindex @code{let} expressie, delen van
@cindex Delen van een let expressie

@cindex @samp{varlist} gedefinieerd
De lijst van een @code{let}-expressie bestaat uit drie delen. Het eerste
deel is het symbool @code{let}. Het tweede deel is een lijst, genaamd
@dfn{varlist}, van wie elk element hetzij een symbool op zichzelf is, of een
lijst met twee elementen, waarvan het eerste element een symbool is. Het
derde deel van de @code{let}-expressie is de body van de @code{let}. De body
bestaat gebruikelijk uit een of meer lijsten.

@need 800
Het sjabloon voor een @code{let}-expressie ziet er zo uit:

@smallexample
(let @var{varlist} @var{body}@dots{})
@end smallexample

@noindent
De symbolen in de varlist zijn de variabelen die een initiële waarde krijgen
door de speciale vorm @code{let}. De symbolen zelf krijgen een initiële
waarde van @code{nil} en elk symbool dat het eerste is van een lijst met
twee elementen is gebonden aan de waarde dat de Lisp interpreter teruggeeft
bij het evalueren van het tweede element.

Een varlist kan er dus als volgt uitzien: @code{(draad (naalden 3))}. In dit
geval, in een @code{let}-expressie, bindt Emacs het symbool @code{draad} aan
een initiële waarde van @code{nil}, en bindt het symbool @code{naalden} aan
een initiële waarde van 3.

Wanneer je een @code{let}-expressie schrijft, dan plaats je de passende
expressies in de slots van het sjabloon voor @code{let}-expressies.

Wanneer de varlist is samengesteld uit lijsten met twee elementen, wat vaak
het geval is, dan ziet het sjabloon voor de @code{let}-expressie er zo uit:

@smallexample
@group
(let ((@var{variable} @var{value})
      (@var{variable} @var{value})
      @dots{})
  @var{body}@dots{})
@end group
@end smallexample

@node Voorbeeld let expressie
@subsection Voorbeeld @code{let} expressie
@cindex Voorbeeld @code{let} expressie
@cindex @code{let} expressie voorbeeld

De volgende expressie creëert en geeft initiele waarden aan de twee
variabelen @code{zebra} en @code{tijger}. De body van de
@code{let}-expressie is een lijst die de @code{message}-functie aanroept.

@smallexample
@group
(let ((zebra "strepen")
      (tijger "woest"))
  (message "Eén soort dieren heeft %s en de ander is %s."
           zebra tijger))
@end group
@end smallexample

Hier is de varlist @code{((zebra "strepen") (tijger "woest"))} 

De twee variabelen zijn @code{zebra} en @code{tijger}. Elke variabele is het
eerste element van een lijst met twee elementen en elke waarde is het tweede
element van die lijst. In de varlist bindt Emacs de variabele @code{zebra}
aan de waarde @code{"strepen"}@footnote{volgens Jared Diamond in @cite{Guns,
Germs, and Steel}, ``@dots{} worden zebras onvoorstelbaar gevaarlijk als ze
ouder worden'' maar de claim hier is dat ze niet zo woest worden als een
tijger. (1997, W. W. Norton and Co., ISBN 0-393-03894-2, page 171)}, en bind
de variabele @code{tijger} aan de waarde @code{"woest"}. In dit voorbeeld
zijn beide waarden strings. De waarde had net zo goed een andere lijst of
een symbool kunnen zijn. De body van de @code{let} is een lijst die de
@code{message}-functie gebruikt om een string in het echogebied te tonen.

@need 1500
Je kunt het voorbeeld op de gebruikelijke manier evalueren door de cursor
achter het laatste haakje te zetten en @kbd{C-x C-e} te typen. Wanneer je
dit doet, verschijnt het volgende in het echogebied:

@smallexample
"Eén soort dieren heeft strepen en de ander is woest."
@end smallexample

Zoals we eerder gezien hebben toont de @code{message}-functie zijn argument,
met uitzondering van @samp{%s}. In dit voorbeeld wordt de waarde van de
variabele @code{zebra} getoond op de plek van de eerste @samp{%s} en wordt
de waarde van de variabele @code{tijger} op de plek van de tweede @samp{%s}
getoond.

@node Niet-geïnitialiseerde let variabelen
@subsection Ongeïnitialiseerde variabelen in een @code{let} statement
@cindex Ongeïnitialiseerde @code{let}  variabelen
@cindex @code{let} variabelen ongeïnitialiseerd

Wanneer je variabelen niet aan een specifieke initiële waarde bindt in een
@code{let} statement, dan worden die automatisch gebonden aan de initiële
waarde @code{nil}, zoals in de volgende expressie:

@smallexample
@group
(let ((berk 3)
      spar
      den
      (eik 'enige))
  (message
   "Hier zijn %d variabelen met %s, %s, en %s waarde."
   berk spar den eik))
@end group
@end smallexample

@noindent
Hier is de varlist @code{((berk 3) spar den (eik 'enige))}

@need 1250
Wanneer je deze expressie op de gebruikelijke manier evalueert, verschijnt
het volgende in je echogebied:

@smallexample
"Hier zijn 3 variabelen met nil, nil, en enige waarde."
@end smallexample

@noindent
In dit voorbeeld bindt Emacs het symbool @code{berk} aan het getal 3, bindt
het symbool @code{spar} en @code{den} aan @code{nil}, en bindt het symbool
@code{eik} aan de waarde @code{enige}.

Merk op dat in het eerste deel van de @code{let}-expressie de variabelen
@code{spar} en @code{den} op zichzelf staan als atomen en niet omgeven zijn
met haakjes. Dit is omdat ze aan @code{nil} gebonden worden, de lege
lijst. Maar @code{eik} is gebonden aan @code{enige} en daarom is een deel
van de lijst @code{(eik 'enige)}. @code{berk} is op dezelfde manier gebonden
aan het getal 3 en staat daarom in een lijst met dat getal. (Omdat een getal
naar zichzelf evalueert hoeft een getal niet gequote te worden. Ook wordt
het getal in de boodschap getoond met @samp{%d} in plaats van @samp{%s}.) De
vier variabelen zijn als groep in de lijst geplaatst om ze te scheiden van
de body van de @code{let}. 

@node Hoe let variabelen bindt
@subsection Hoe @code{let} variabelen bindt

Emacs Lisp ondersteunt twee manieren om een variabele namen aan hun waarde
te binden. Deze manieren raken de delen van je programma waar een bepaalde
binding geldig is. Wegens historische redenen gebruikt Emacs Lisp standaard
een vorm van variabele binding met de naam @dfn{dynamic binding}. Echter in
deze handleiding behandelen we de voorkeursvorm voor binding, met de naam
@dfn{lexical binding}, tenzij anders vermeld (de Emacs-beheerders zijn van
plan in de toekomst de standaard te wijzigen naar lexical binding). Wanneer
je eerder in andere talen geprogrammeerd hebt, ben je waarschijnlijk
vertrouwd met hoe lexical binding zich gedraagt.

Om lexical binding in een programma te gebruiken zet je dit in de eerste
regel van je Emacs Lisp bestand:

@example
;;; -*- lexical-binding: t -*-
@end example

Voor meer informatie hierover @pxref{Variable Scoping, , , elisp, The Emacs
Lisp Reference Manual}.

@menu
* Lexical en dynamische binding verschillen::  Lexical en dynamische binding 
                                                 verschillen
* Lexical vs dynamische binding voorbeeld::  Lexical vs dynamische binding 
                                               voorbeeld
@end menu

@node Lexical en dynamische binding verschillen
@unnumberedsubsubsec Verschillen tussen lexical en dynamische binding

@cindex Lexical binding
@cindex Binding, lexical
Zoals eerder besproken
@iftex
(@pxref{Permanent installeren}),
@end iftex
@ifnottex
(@pxref{Voorkom verwarring}),
@end ifnottex
wanneer je lokale variabelen met @code{let} onder lexical binding creëert,
zijn die variabelen alleen geldig in de body van de @code{let}-expressie. In
andere delen van je code hebben ze geen betekenis, dus wanneer je een elders
gedefinieerde functie aanroept vanuit de @code{let} body, kan die functie de
lokale variabelen die je gemaakt hebt niet ``zien''. (Anderzijds, wanneer je
een functie aanroept die was gedefinieerd in een @code{let} body. @emph{zou}
die functie de lokale variabelen van die @code{let}-expressie moeten kunnen
zien en wijzigen.

@cindex Dynamische binding
@cindex Binding, dynamisch
Onder dynamische binding zijn de regels verschillend: wanneer je @code{let}
gebruikt. zijn de lokale variabelen geldig gedurende de uitvoering van de
@code{let}-expressie. Dit betekent dat wanneer je @code{let}-expressie een
functie aanroept, die functie deze lokale variabelen kan zien, ongeacht waar
de functie is gedefinieerd (inclusief wanneer dit zelfs in een heel ander
bestand staat).

Een andere manier om over @code{let} bij het gebruik van dynamische binding
te denken is dat elke variabele naam een globale ``stapel'' van bindings
heeft, en wanneer je de naam van de variabele gebruikt, dat refereert aan de
bovenkant van de stapel. (Je kan je dit voorstellen als een stapel papieren
op je bureau waarop de waarden zijn geschreven.) Wanneer je een variabele
dynamisch bindt met @code{let}, plaatst het de nieuw gespecificeerde binding
bovenop de stapel en voert vervolgens de @code{let} body uit. Nadat de
@code{let} body eindigt, neemt het die binding van de stapel, en toont
diegene die er voor de @code{let}-expressie was (als er een was).

@node Lexical vs dynamische binding voorbeeld
@unnumberedsubsubsec Voorbeeld van lexical vs.@: dynamische binding
In sommige gevallen gedragen lexical en dynamische bindingen zich
gelijk. Echter in sommige gevallen kunnen zij de betekenis van je programma
wijzigen. Kijk bijvoorbeeld naar wat gebeurt in deze code onder lexical
binding: 

@example
;;; -*- lexical-binding: t -*-

(setq x 0)

(defun getx ()
  x)

(setq x 1)

(let ((x 2))
  (getx))
     @result{} 1
@end example

@noindent
Het resultaat van @code{(getx)} is hier @code{1}. Onder lexical binding ziet
@code{getx} de waarde van onze @code{let}-expressie niet. Dit is omdat de
body van @code{(getx)} buiten de body van onze @code{let}-expressie
is. Omdat @code{getx} bovenaan, op het globale niveau van code gedefinieerd
is (dus niet binnen de body van enige @code{let}-expressie), zoekt het en
vindt @code{x} eveneens op het globale niveau. De huidige globale waarde van
@code{x} is @code{1} bij de uitvoering van @code{getx}, en dus is dat wat
@code{getx} teruggeeft.

Wanneer we in plaats daarvan dynamisch binding gebruiken, is het gedrag
anders:

@example
;;; -*- lexical-binding: t -*-

(defvar x) ;; Gebruik dynamic binding voor 'x'.

(setq x 0)

(defun getx ()
  x)

(setq x 1)

(let ((x 2))
  (getx))
     @result{} 2
@end example

@noindent
Het resultaat van @code{(getx)} is nu @code{2}. Dat is omdat onder
dynamische binding bij het uitvoeren van @code{getx} de huidige binding voor
@code{x} op de bovenkant van onze stapel die is van onze @code{let}
binding. Deze keer ziet @code{getx} de globale waarde van @code{x} niet,
omdat deze binding onder degene van onze @code{let}-expressie in de stapel
van bindings ligt.

(De @code{defvar} declaratie hierboven maakt zogezegd de variabele
``speciaal'', wat zorgt dat het de dynamische binding regels volgt in plaats
van de standaard binding regels. @xref{defvar, , Initialiseer een variabele
met @code{defvar}}.)

@node if
@section De @code{if} speciale vorm
@findex if
@cindex Conditioneel met @code{if}

Een andere speciale vorm is de conditionele @code{if}. Deze vorm wordt
gebruikt om de computer te instrueren om beslissingen te nemen. Je kunt
functiedefinities schrijven zonder @code{if} te gebruiken, maar het wordt
vaak genoeg gebruikt en is belangrijk genoeg om het hier te behandelen. Het
wordt bijvoorbeeld gebruikt in de code van de functie
@code{beginning-of-buffer}.

Het basisidee achter @code{if} is, dat @emph{wanneer} een test waar is,
@emph{dan} een expressie wordt geëvalueerd. Wanneer de test niet waar is,
dan wordt de expressie niet geëvalueerd. Bijvoorbeeld zou je een
beslissingen kunnen maken zoals ``als het warm en zonnig is, dan ga ik naar
het strand!''. 

@menu
* if in meer detail::        if in meer detail
* type-dier in detail::      Voorbeeld van een @code{if} expressie.
@end menu

@ifnottex
@node if in meer detail
@unnumberedsubsec @code{if} in meer detail
@end ifnottex

@cindex @samp{wanneer-deel} gedefinieerd
@cindex @samp{dan-deel} gedefinieerd
Een @code{if}-expressie geschreven in Lisp gebruikt het woord ``then'' niet,
de test en de actie zijn de tweede en derde elementen van de lijst wiens
eerste element @code{if} is. Echter, het test-gedeelte van de lijst wordt
vaak het @code{wanneer}-gedeelte en het tweede argument het
@code{dan}-gedeelte genoemd.

Bij het schrijven van een @code{if}-expressie is het gebruikelijk de
waar-of-onwaar-test op dezelfde regel te zetten als het symbool @code{if},
maar de uit te voeren actie wanneer de test waar is, het dan-deel, op de
tweede en verdere regels. Dit maakt de @code{if}-expressie makkelijker te
lezen.

@smallexample
@group
(if @var{waar-of-onwaar-test}
    @var{actie-uit-te-voeren-als-de-test-waar-is})
@end group
@end smallexample

@noindent
De waar-of-onwaar-test is een expressie die door de Lisp interpreter wordt
geëvalueerd.

Hier is een voorbeeld dat je op de gebruikelijke manier kunt evalueren. De
test is of het getal 5 groter is dan het getal 4. Omdat dit zo is, wordt de
boodschap @samp{5 is groter dan 4!} getoond.

@smallexample
@group
(if (> 5 4)                             ; @r{wanneer-deel}
    (message "5 is groter dan 4!"))     ; @r{dan-deel}
@end group
@end smallexample

@noindent
(De functie @code{>} test of zijn eerste argument groter is dan zijn tweede
argument en geeft waar terug indien dat zo is.)
@findex > @r{(greater than)}

In werkelijk gebruik is de test natuurlijk niet voor altijd vastgelegd zoals
dat het geval is bij de expressie @code{(> 5 4)}. In plaats daarvan is
tenminste een van de variabelen die in de test gebruikt worden gebonden aan
een waarde die vooraf niet bekend is. (Als de waarde vooraf bekend zou zijn,
hoeven we de test niet doen!)

De waarde kan bijvoorbeeld gebonden zijn aan het argument van een
functiedefinitie. In de volgende functiedefinitie is het karakter van een
dier een waarde die wordt doorgegeven aan de functie. Wanneer de waarde
gebonden aan @code{karakteristiek} @code{woest} is, dan wordt de boodschap
@samp{Het is een tijger!} getoond. Zo niet, dan wordt @code{nil} teruggeven.

@smallexample
@group
(defun type-dier (karakteristiek)
  "Toon boodschap in echogebied afhankelijk van KARAKTERISTIEK.
Wanneer de KARAKTERISTIEK de string \"woest\" is,
dan waarschuw voor een tijger."
  (if (equal karakteristiek "woest")
      (message "Het is een tijger!")))
@end group
@end smallexample

@need 1500
@noindent
Wanneer je dit in GNU Emacs leest, dan kun je de functiedefinitie op de
gebruikelijke manier evalueren, en daarna kan je de volgende twee expressies
evalueren om de resultaten te zien:

@smallexample
@group
(type-dier "woest")

(type-dier "gestreept")

@end group
@end smallexample

@c Following sentences rewritten to prevent overfull hbox.
@noindent
Wanneer je @code{(type-dier "woest")} evalueert, zie je de volgende
boodschap in het echogebied: @code{"Het is een tijger!"} en wanneer je
@code{(type-dier "gestreept")} evalueert dan zie je @code{nil} in het
echogebied.

@node type-dier in detail
@subsection De @code{type-dier}-functie in detail

Laten we kijken naar de @code{type-dier}-functie in detail

De functiedefinitie van @code{type-dier} is geschreven door de slots van
twee sjablonen in te vullen, een voor de functiedefinitie in zijn geheel, en
een tweede voor een @code{if}-expressie.

@need 1250
Het sjabloon voor elke functie die niet interactief is, is:

@smallexample
@group
(defun @var{naam-van-de-functie} (@var{argument-list})
  "@var{documentatie}@dots{}"
  @var{body}@dots{})
@end group
@end smallexample

@need 800
De delen van de functie die overeenkomen met het sjabloon zien er zo uit:

@smallexample
@group
(defun type-dier  (karakteristiek)
  "Toon boodschap in echogebied afhankelijk van KARAKTERISTIEK.
Wanneer de KARAKTERISTIEK de string \"woest\" is,
dan waarschuw voor een tijger."
  @var{body: de} @code{if} @var{expressie})
@end group
@end smallexample

De naam van de functie is @code{type-dier}, het krijgt de waarde van één
argument doorgegeven. De argumentlijst wordt gevolgd door een meerregelige
documentatiestring. De documentatiestring is in dit voorbeeld opgenomen
omdat het een goede gewoonte is voor elke functiedefinitie een
documentatiestring te schrijven. De body van de functiedefinitie bestaat uit
de @code{if}-expressie.

@need 800
Het sjabloon voor een @code{if}-expressie ziet er zo uit: 

@smallexample
@group
(if @var{waar-of-onwaar-test}
    @var{uit-te-voeren-actie-wanneer-de-waar-of-onwaar-test-waar-teruggeeft})
@end group
@end smallexample

@need 1250
In de @code{type-dier}-functie, ziet de code voor de @code{if} er zo uit:

@smallexample
@group
  (if (equal karakteristiek "woest")
      (message "Het is een tijger!"))
@end group
@end smallexample

@need 800
Hier is de waar-of-onwaar-test de expressie:

@smallexample
(equal karakteristiek "woest")
@end smallexample

@noindent
In Lisp is @code{equal} een functie die vaststelt of zijn eerste argument
gelijk is aan zijn tweede argument. Het tweede argument is de string
@code{"woest"} en het eerste argument is de waarde van het symbool
@code{karakteristiek}---met andere woorden, het argument doorgegeven aan
deze functie.

In de eerste oefening van @code{type-dier} is het argument @code{"woest"}
doorgegeven naar @code{type-dier}. Omdat @code{"woest"} gelijk is aan
@code{"woest"} geeft de expressie @code{(equal karakteristiek "woest")} de
waarde waar terug. Wanneer dit gebeurt, evalueert de @code{if} het tweede
argument oftewel het dan-deel van de @code{if}: @code{(message "Het is een
tijger!")}.

Daarnaast is in de tweede oefening van @code{type-dier} het argument
@code{"gestreept"} doorgegeven naar @code{type-dier}. @code{"gestreept"} is
niet gelijk aan @code{"woest"} en daarom is het dan-deel niet geëvalueerd en
is @code{nil} teruggeven door de @code{if}-expressie.

@node else
@section If--then--else expressies
@cindex Else

Een @code{if}-expressie kan optioneel een derde argument hebben, het
@dfn{anders-deel}. voor het geval de waar-of-onwaar-test onwaar
teruggeeft. Wanneer dit gebeurt wordt het tweede argument, het dan-deel van
de @code{if}-expressie @emph{niet} geëvalueerd, maar wordt het derde deel,
het anders-deel, @emph{wel} geëvalueerd. Je kunt dit zien als het bewolkte
dag alternatief voor de beslissing ``als het warm en zonnig is, ga dan naar
het strand, anders lees een boek!''.

In de Lisp-code wordt het woord ``else'' niet geschreven, het anders-deel
van een @code{if}-expressie komt na het dan-gedeelte. In Lisp staat het
anders-deel gebruikelijk op zichzelf op een nieuwe regel en minder
ingesprongen dan het dan-deel:

@smallexample
@group
(if @var{waar-of-onwaar-test}
    @var{uit-te-voeren-actie-wanneer-de-waar-of-onwaar-test-waar-teruggeeft}
  @var{uit-te-voeren-actie-wanneer-de-waar-of-onwaar-test-onwaar-teruggeeft}))
@end group
@end smallexample

De volgende @code{if}-expressie bijvoorbeeld toont de boodschap @samp{4 is
niet groter dan 5!} wanneer je het op de gebruikelijke manier evalueert:

@smallexample
@group
(if (> 4 5)                               ; @r{if-deel}
    (message "4 valselijk groter dan 5!") ; @r{dan-deel}
  (message "4 is niet groter dan 5!"))    ; @r{anders-deel}
@end group
@end smallexample

@noindent
Merk op dat de verschillende niveaus van inspringen het makkelijk maken het
dan-deel te onderscheiden van het anders-deel. (GNU Emacs heeft
verschillende commando's die automatisch @code{if}-expressies correct laat
inspringen. @xref{Typen van lijsten, , GNU Emacs helpt je om lijsten te
typen}.) 

We kunnen de @code{type-dier}-functie uitbreiden met een anders-deel door
eenvoudig een aanvullend deel in de @code{if}-expressie in te voegen.

@need 1500
Je kunt de consequenties hiervan zien wanneer je de volgende versie van de
@code{type-dier} functiedefinitie installeert en daarna de twee volgende
expressies evalueert om de verschillende argumenten aan de functie door te
geven.

@smallexample
@group
(defun type-dier (karakteristiek)
  "Toon boodschap in echogebied afhankelijk van KARAKTERISTIEK.
Wanneer de KARAKTERISTIEK de string \"woest\" is,
dan waarschuw voor een tijger."
  (if (equal karakteristiek "woest")
      (message "Het is een tijger!")
    (message "Het is niet woest!")))
@end group
@end smallexample
@sp 1

@smallexample
@group
(type-dier "woest")

(type-dier "gestreept")

@end group
@end smallexample

@c Following sentence rewritten to prevent overfull hbox.
@noindent
Wanneer je @code{(type-dier "woest")} evalueert, zie je de volgende
boodschap in het echogebied: @code{"Het is een tijger!"}, maar wanneer je
@code{(type-dier "gestreept")} evalueert zie je @code{"Het is niet woest!"}.

(Wanneer de @var{karakteristiek} @code{"zeer woest"} is, dan wordt de
boodschap @code{"Het is niet woest!"} getoond, en dat is
misleidend!. Wanneer je code schrijft, moet je rekening houden met de
mogelijkheid dat een dergelijk argument wordt getest door de code en je
programma overeenkomstig schrijven.)

@node Waar en onwaarheid
@section Waar en onwaarheid in Emacs Lisp
@cindex Waar en onwaarheid in Emacs Lisp
@cindex Onwaarheid en waar in Emacs Lisp
@findex nil

Er is een belangrijk aspect aan de waarheidstest in een
@code{if}-expressie. Tot nu toe hebben we gesproken over ``waar'' en
``onwaar'' als waarden van predicaten alsof het nieuwe soorten van Emacs
Lisp objecten zijn. Feitelijk is ``onwaar'' onze oude vriend
@code{nil}. Alles wat anders is---wat dan ook--- is ``waar''.

De expressie die de test op waar wordt geïnterpreteerd als @dfn{waar}
wanneer het resultaat van de evaluatie een waarde ongelijk aan @code{nil}
is. Met andere woorden, het resultaat van de test wordt geacht waar te zijn
wanneer de teruggegeven waarde een getal is zoals 47, een string zoals
@code{"hallo"} of een symbool (anders dan @code{nil}), zoals @code{bloemen},
of een lijst (zolang die niet leeg is) of zelfs een buffer!

@menu
* nil uitgelegd::            @code{nil} heeft twee betekenissen.
@end menu

@ifnottex
@node nil uitgelegd
@unnumberedsubsec Een uitleg van @code{nil}
@end ifnottex

Voordat we de test op waar illustreren, hebben we eerst een uitleg van
@code{nil} nodig.

In Emacs Lisp heeft het symbool @code{nil} twee betekenissen. De eerste
betekenis is de lege lijst. De tweede betekenis is onwaar en is de waarde
wordt teruggegeven wanneer de waar-of-onwaar-test onwaar test. @code{nil}
kan worden geschreven als de lege lijst, @code{()}, of als @code{nil}. Voor
wat de Lisp interpreter betreft zijn @code{()} en @code{nil} gelijk. Mensen
echter gebruiken meestal @code{nil} voor onwaar en @code{()} voor de lege
lijst,

In Emacs Lisp wordt elke waarde die niet @code{nil} is---niet de lege lijst
is--- beschouwd als waar. Dit betekent dat wanneer een evaluatie iets
teruggeeft dat geen lege lijst is, een @code{if}-expressie het als waar
test. Wanneer bijvoorbeeld een getal in het slot voor de test gestopt
wordt. wordt het geëvalueerd en zal het zichzelf teruggeven, omdat dat is
wat getallen doen wanneer ze worden geëvalueerd. De expressie test als
onwaar uitsluitend wanneer @code{nil}, een lege lijst, wordt teruggegeven
door de expressie te evalueren.

Je kunt dit zien door het evalueren van de twee expressies in de volgende
voorbeelden.

In het eerste voorbeeld wordt het getal 4 geëvalueerd als de test in de
@code{if}-expressie en geeft zichzelf terug. Als gevolg wordt het dan-deel
van de expressie geëvalueerd en teruggegeven: @samp{waar} verschijnt in het
echogebied. In het tweede voorbeeld, de @code{nil} geeft onwaar aan, als
gevold wordt het anders-deel van de expressie geëvalueerd en teruggegeven:
@samp{onwaar} verschijnt in het echogebied.

@smallexample
@group
(if 4
    'waar
  'onwaar)
@end group

@group
(if nil
    'waar
  'onwaar)
@end group
@end smallexample

@need 1250
Overigens wanneer een zinnige waarde niet beschikbaar is voor een test die
waar teruggeeft, dan geeft de Lisp interpreter het symbool @code{t} voor
waar. Bijvoorbeeld evaluatie van de expressie @code{(> 5 4)} geeft @code{t}
terug, zoals je op de gebruikelijke manier kunt zien.

@smallexample
(> 5 4)
@end smallexample

@need 1250
@noindent
Anderzijds, deze functie geeft @code{nil} terug, wanneer het als onwaar
test.

@smallexample
(> 4 5)
@end smallexample

@node save-excursion
@section @code{save-excursion}
@findex save-excursion
@cindex Region, wat is het
@cindex Point en buffer behouden
@cindex Point en buffer behouden
@findex point
@findex mark

De functie @code{save-excursion} is de laatste speciale vorm die we in dit
hoofdstuk bespreken.

In Emacs Lisp programma's voor editing is de functie @code{save-excursion}
heel gebruikelijk. Het bewaart de locatie van point, voert de body van de
functie uit en herstelt point naar zijn vorige positie indien zijn lokatie
is gewijzigd. Het primaire doel is te voorkomen dat de gebruiker verrast en
verstoord wordt door onverwachte verplaatsing van point.

@menu
* Point en mark::            Een overzicht van verschillende locaties.
* Template voor save-excursion::  Template voor save-excursion
@end menu

@ifnottex
@node Point en mark
@unnumberedsubsec Point and Mark
@end ifnottex

Voordat we @code{save-excursion} bespreken is het echter zinvol eerst te
bekijken wat in GNU Emacs point en mark zijn. @dfn{Point} is de huidige
lokatie van de cursor. Waar de cursor ook is, dat is point. Preciezer
gezegd, in terminals waar de cursor bovenop een karakter verschijnt, is
point direct voor dat karakter. In Emacs Lisp is point een integer (geheel
getal). Het eerste karakter in een buffer is nummer één, het tweede is
nummer twee, enzovoorts. De functie @code{point} geeft de huidige positie
van de cursor als getal terug. Elk buffer heeft zijn eigen waarde voor
point.

De @dfn{mark} is een andere positie in het buffer. De waarde kan ingesteld
worden met een commando zoals @kbd{C-@key{SPC}}
(@code{set-mark-command}). Wanneer een mark is ingesteld, laat je met het
commando @kbd{C-x C-x} (@code{exchange-point-and-mark}) de cursor naar mark
springen en de mark instellen op de vorige positie van point. Verder, als je
een andere mark instelt wordt de positie van de vorige mark bewaard in de
mark-ring. Veel mark-posities kunnen zo bewaard worden. Je laat de cursor
naar een bewaarde mark springen door een of meer keer @kbd{C-u C-@key{SPC}}
te typen.

De deel van het buffer tussen point en mark heet de @dfn{region}. Talrijke
commando's werken op de region, inclusief @code{center-region},
@code{count-words-region}, @code{kill-region} en @code{print-region}.

De speciale vorm @code{save-excursion} bewaart de lokatie van point en
herstelt de positie nadat de code in de body van de speciale vorm is
geëvalueerd door de Lisp interpreter. Als point dus aan het begin van een
stuk tekst staat en bepaalde code heeft point naar het eind van het buffer
verplaatst, plaatst @code{save-excursion} point terug naar de locatie waar
het eerder was, nadat de expressies in de body van de functie zijn
geëvalueerd.

In Emacs verplaatsen functies regelmatig point als onderdeel van de interne
werking daarvan, alhoewel de gebruiker dat niet zou verwachten. Om te
voorkomen dat de gebruiker lastig gevallen wordt door springen die zowel
onverwacht als (vanuit het gezichtspunt van de gebruiker) onnodig zijn,
wordt @code{save-excursion} vaak gebruikt om point op de plek te houden waar
de gebruiker die verwacht. Het gebruik van @code{save-excursion} vormt een
goede huishouding.

Om zeker te stellen dat het huis schoon blijft, herstelt
@code{save-excursion} de waarde van point zelfs wanneer iets fout gaat in de
code (of, meer preciezer en in het juiste jargon, ``in geval van een
abnormale exit''). Deze eigenschap is erg behulpzaam.

Naast het registreren van de waarde van point houdt @code{save-excursion}
bij wat de huidige buffer is en herstelt die ook. Dit betekent dat je code
kunt schrijven die van buffer wisselt en je @code{save-excursion} laat
terugschakelen naar de originele buffer. Dit is hoe @code{save-excursion}
gebruikt wordt in @code{append-to-buffer}. (@xref{append-to-buffer, , De
definitie van @code{append-to-buffer}}.)

@node Template voor save-excursion
@subsection Sjabloon voor een @code{save-excursion} expressie

@need 800
Het sjabloon voor code die @code{save-excursion} gebruikt is simpel:

@smallexample
@group
(save-excursion
  @var{body}@dots{})
@end group
@end smallexample

@noindent
De body van de functie bestaat uit een of meer expressies die de Lisp
interpreter opeenvolgend evalueert. Wanneer de body meer dan een expressie
bevat, wordt de waarde van de laatste teruggegeven als waarde van de
@code{save-excursion}-functie. De andere expressies in de body worden
uitsluitend geëvalueerd voor hun zij-effecten en @code{save-excursion} zelf
wordt alleen gebruikt voor zijn zij-effect (het herstellen van de positie
van point).

@need 1250
Meer gedetailleerd ziet het sjabloon voor een
@code{save-excursion}-expressie er zo uit: 

@smallexample
@group
(save-excursion
  @var{eerste-expressie-in-body}
  @var{tweede-expressie-in-body}
  @var{derde-expressie-in-body}
   @dots{}
  @var{laatste-expressie-in-body})
@end group
@end smallexample

@noindent
Een expressie kan uiteraard zelf een symbool zijn, of een lijst.

In Emacs Lisp code komt een @code{save-excursion} vaak voor binnen de body
van een @code{let}-expressie. Dit ziet er zo uit:

@smallexample
@group
(let @var{varlist}
  (save-excursion
    @var{body}@dots{}))
@end group
@end smallexample

@node Terugblik
@section Terugblik

In de laatste hoofdstukken introduceerden we een macro en een flink aantal
functies en speciale vormen. Deze bespreken we hier in het kort, samen met
enkele vergelijkbare functies die we nog niet behandeld hebben.

@table @code
@item eval-last-sexp
Evalueer de laatste symbolische expressie voor de huidige lokatie van
point. De waarde wordt getoond in het echogebied tenzij de functie met een
argument is aangeroepen. In dat geval wordt de output in het huidige buffer
getoond. Dit commando is gewoonlijk gebonden aan @kbd{C-x C-e}.

@item defun
Definieer functie. Deze macro heeft maximaal vijf onderdelen: de naam, een
sjabloon voor de argumenten die aan de functie doorgegeven worden,
documentatie, een optionele interactieve declaratie en de body van de
definitie.

@need 1250
In Emacs is de functiedefinitie van bijvoorbeeld
@code{dired-unmark-all-marks} als volgt:

@smallexample
@group
(defun dired-unmark-all-marks ()
  "Remove all marks from all files in the Dired buffer."
  (interactive)
  (dired-unmark-all-files ?\r))
@end group
@end smallexample

@item interactive
Verklaar de interpreter dat de functie interactief gebruikt kan worden. Deze
speciale vorm kan worden gevolgd door een string met een of meer delen die
op volgorde informatie aan de argumenten van de functie doorgeven. Deze
delen kunnen de interactief ook om informatie vragen. Delen van de string
zijn gescheiden door nieuwe regels, @samp{\n}.

@need 1000
Gebruikelijke code karakters zijn:

@table @code
@item b
De naam van een bestaand buffer

@item f
De naam van een bestaand bestand

@item p
Het numerieke prefix-argument. (Merk op dat dit de kleine letter @code{p}
is)

@item r
Point en mark als twee numerieke argumenten, de kleinste eerst. Dit is de
enige letter die twee opvolgende argumenten specificeert, in plaats van een.
@end table

@xref{Interactive Codes, , Code Characters for @samp{interactive}, elisp,
The GNU Emacs Lisp Reference Manual}, voor een complete lijst van code
karakters.

@item let
Verklaar dat een lijst van variabelen wordt gebruikt binnen de body van de
@code{let} en geef ze een initiële waarde, hetzij @code{nil} of een
gespecificeerde waarde. Evalueer daarna de rest van de expressies in de body
van de @code{let} en geef de waarde van de laatste terug. Binnen de body van
de @code{let} ziet de Lisp interpreter de waarden niet van variabelen met
dezelfde naam die gebonden zijn buiten de @code{let}.

@need 1250
Bijvoorbeeld,

@smallexample
@group
(let ((foo (buffer-name))
      (bar (buffer-size)))
  (message
   "Dit buffer is %s en heeft %d karakters."
   foo bar))
@end group
@end smallexample

@item save-excursion
Registreer de waarde van point en het huidige buffer voor het evalueren van
de body van deze speciale vorm. Herstel achteraf de waarde van point en
buffer.

@need 1250
Bijvoorbeeld,

@smallexample
@group
(message "We zijn %d karakters in dit buffer."
         (- (point)
            (save-excursion
              (goto-char (point-min)) (point))))
@end group
@end smallexample

@item if
Evalueer het eerste argument van de functie. Wanneer het waar is, evalueer
het tweede argument, anders evalueer het derde argument, mits die er is.

De speciale vorm @code{if} heet een @dfn{conditional}. Er zijn andere
conditionals in Emacs Lisp, maar @code{if} is waarschijnlijk de meest
gebruikte.

@need 1250
Bijvoorbeeld,

@smallexample
@group
(if (= 22 emacs-major-version)
    (message "Dit is versie 22 Emacs")
  (message "Dit is niet versie 22 Emacs"))
@end group
@end smallexample

@need 1250
@item <
@itemx >
@itemx <=
@itemx >=
De functie @code{<} test of het eerste argument kleiner is dan het tweede
argument. Een corresponderende functie, @code{>} test of het eerste argument
groter is dan het tweede. Vergelijkbaar test @code{<=} of het eerste
argument kleiner of gelijk is aan het tweede en @code{>=} test of het eerste
argument groter of gelijk is aan het tweede. In alle gevallen moeten beide
argumenten getallen zijn of markers (markers geven de positie in buffers
aan).

@need 800
@item =
De functie @code{=} test of twee argumenten, beide nummers of markers,
gelijk zijn.

@need 1250
@item equal
@itemx eq
Test of twee objecten hetzelfde zijn. @code{equal} gebruikt een betekenis
van ``hetzelfde'' en @code{eq} gebruikt een andere. @code{equal} geeft waar
terug wanneer de twee objecten dezelfde structuur en inhoud hebben, zoals
twee exemplaren van hetzelfde boek. Daarnaast geeft @code{eq} waar terug
indien beide argumenten daadwerkelijk hetzelfde object zijn.
@findex equal
@findex eq

@need 1250
@item string<
@itemx string-lessp
@itemx string=
@itemx string-equal
De functie @code{string-lessp} test of het eerste argument kleiner is dan
het tweede. Een kortere alternatieve naam voor dezelfde functie (een
@code{defalias}) is @code{string<}.

De argumenten van @code{string-lessp} moeten strings of symbolen zijn, de
volgorde is lexicografish, dus hoofd- of kleine letters is van belang. Het
toont de namen van symbolen die worden gebruikt in plaats van de symbolen
zelf.

@cindex @samp{lege string} gedefinieerd
Een lege string, @samp{""}, is een string zonder karakters er in, en is
kleiner dan elke andere string van karakters.

@code{string-equal} verschaft de corresponderende test voor gelijkheid. De
kortere alternatieve naam is @code{string=}. Recente versies van Emacs
bevatten @code{string-greaterp}, met @code{string>} als korter
alternatief. Er zijn geen string test- functies die corresponderen met
@code{>=} of @code{<=}.

@item message
Toon een boodschap in het echogebied. Het eerste argument is een string die
@samp{%s}, @samp{%d} of @samp{%c} kan bevatten om de waarde van argumenten
te tonen die volgen op de string. Het voor @samp{%s} gebruikte argument moet
een string of een symbool zijn, het voor @samp{%d} gebruikte argument moet
een getal zijn. Het voor @samp{%c} gebruikte argument moet een @sc{ascii}
codenummer zijn, het wordt getoond als het karakter met die
@sc{ascii}-code. (Verschillende andere %-sequences zijn niet genoemd.) 

@item setq
@itemx set
De speciale vorm @code{setq} stelt de waarde van zijn eerste argument in op
de waarde van het tweede argument. Het eerste argument wordt automatisch
gequote door @code{setq}. Het doet hetzelfde voor opvolgende argumentparen.

@item buffer-name
Zonder een argument, geeft de waarde van het buffer terug als een string.

@item buffer-file-name
Zonder een argument, geeft de naam van het bestand terug dat het buffer
bezoekt.

@item current-buffer
Geeft het buffer waar Emacs actief is terug. Het is misschien niet het
buffer dat zichtbaar op het scherm is.

@item other-buffer
Geeft het meest recent geselecteerde buffer (anders dan het buffer
doorgegeven aan @code{other-buffer} als een argument en anders dan het
huidige buffer).

@item switch-to-buffer
Selecteert een buffer voor Emacs om actief in te zijn en toon het in het
huidige venster zodat de gebruiker het kan zien. Gebruikelijk gebonden aan
@kbd{C-x b}.

@item set-buffer
Schakelt de aandacht van Emacs naar een buffer waarop programma's gaan
draaien. Verandert niet wat het venster toont.

@item buffer-size
Geeft het aantal karakters in het huidige buffer.

@item point
Geeft de waarde van de huidige positie van de cursor, als een integer, telt
het aantal karakters vanaf het begin van het buffer.

@item point-min
Geeft de minimaal toegestane waarde van point in het huidige buffer. Dit is
1, behalve wanneer narrowing van toepassing is.

@item point-max
Geef de maximaal toegestane waarde van point in het huidige buffer. Dit is
het einde van het buffer, tenzij narrowing van toepassing is.
@end table

@need 1500
@node defun oefeningen
@section Oefeningen

@itemize @bullet
@item
Schrijf een niet-interactieve functie die de waarde van zijn argument, een
getal, verdubbelt. Maak die functie interactief.

@item
Schrijf een functie die test of de huidige waarde van  @code{fill-column}
groter is dan het argument dat wordt doorgegeven aan de functie, en zo ja,
toon het als een passende boodschap.
@end itemize

@node Buffer rondleiding
@chapter Enkele buffer gerelateerde functies

In dit hoofdstuk bestuderen we in detail verschillende in GNU Emacs
gebruikte functies. We noemen dit een ``rondleiding''. Deze functies worden
gebruikt als voorbeelden van Lisp code maar zijn geen denkbeeldige
voorbeelden. Met de uitzondering van de eerste versimpelde functiedefinitie
tonen deze functies de werkelijke code van GNU Emacs. Je kunt veel van deze
definities leren. De hier beschreven functies zijn alle gerelateerd aan
bufers. Later kijken we naar andere functies.

@menu
* Meer vinden::              Hoe meer informatie te vinden
* versimpelde-beginning-of-buffer::  Toon @code{goto-char}, @code{point-min} 
                                       en @code{push-mark}.
* mark-whole-buffer::        Bijna hetzelde als @code{beginning-of-buffer}.
* append-to-buffer::         Gebruikt @code{save-excursion} en 
                               @code{insert-buffer-substring}.
* Buffer gerelateerde terugblik::  Terugblik.
* Buffer oefeningen::        Buffer oefeningen
@end menu

@node Meer vinden
@section Meer informatie vinden

@findex describe-function@r{, geïntroduceerd}
@cindex Vind functiedocumentatie
In deze rondleiding beschrijf ik elke nieuwe functie die we behandelen. Soms
in detail en soms kort. Wanneer je geïnteresseerd bent vraag je op elk
moment de volledige documentatie op van elke Emacs Lisp functie door
@kbd{C-h f} te typen, en daarna de naam van de functie (gevolg met
@key{RET}). Je kunt op ook de volledige documentatie van een variabele
opvragen met het typen van @kbd{C-h v}, en daarna de naam van de variabele
(gevolg met @key{RET}).

@cindex De source van een functie vinden
@c In version 22, tells location both of C and of Emacs Lisp
@code{describe-function} vertelt je ook de locatie van de functie.

Plaats point in de naam van het bestand dat de functie bevat en druk op de
@key{RET}-toets. In dit geval betekent @key{RET} @code{push-button} in
plaats van ``return'' of ``enter''. Emacs neemt je meteen naar de
functiedefinitie.

@ignore
Not In version 22

If you move point over the file name and press
the @key{RET} key, which in this case means @code{help-follow} rather
than ``return'' or ``enter'', Emacs will take you directly to the function
definition.
@end ignore

Meer in het algemeen, wanneer je de functie in het originele bronbestand
wilt zien, spring je met de functie @code{xref-find-definitions} er
heen. @code{xref-find-definitions} werkt met een brede variëteit van talen,
niet alleen Lisp en C, en het werkt ook met non-programming
tekst. @code{xref-find-definitions} springt bijvoorbeeld naar de
verschillende nodes in de Texinfo broncode van dit document (onder
voorwaarde dat je het @command{etags}-hulpprogramma alle nodes van alle
handleidingen de met Emacs komen hebt laten registeren @pxref{Create Tags
Table,,, emacs, The GNU Emacs Manual}).

Type @kbd{M-.} (dus druk op de punt-toet terwijl je de @key{META}-toets
ingedrukt houdt, of typ anders de @key{ESC} gevold door de punt-toets) om
het commando @code{xref-find-definitions} te gebruiken, en vervolgens, na de
prompt, de naam van de functie wiens broncode je wilt zien, zoals
@code{mark-whole-buffer} en typ daarna @key{RET}. (Wanneer het commando geen
prompt geeft, roep het dan met een argument: @kbd{C-u
M-.}). @pxref{Interactieve opties}.) Emacs schakelt buffers en toont de
broncode van de functie op je scherm@footnote{Wanneer Emacs, in plaats van
het tonen van de broncode voor een Lisp functie, je vraagt welke tags tabel
te openen, roep dan @kbd{M-.} aan vanuit een buffer wiens major mode Emacs
Lisp of Lisp Interaction is. } Om naar je buffer terug te keren type je type
@kbd{M-,} of @kbd{C-x b @key{RET}}. (Op sommige toetsenborden, heeft de
@key{META}-toets het label @key{ALT}.)

@cindex Bibliotheek als term voor ``bestand''
Overigens worden de bestanden die Lisp code bevatten gewoonlijk
@dfn{bibliotheken} genoemd. De metafoor is afgeleid van een gespecialiseerde
bibliotheek, zoals een juridische bibliotheek of een technische bibliotheek,
in plaats van een algemene bibliotheek. Elke bibliotheek, of bestand, bevat
functies die aan bepaald onderwerp of activiteit gerelatieerd zijn, zoals
@file{abbrev.el} voor het afhandelen van afkortingen en andere
snelkoppelingen voor het typen, en @file{help.el} for hulp. (Soms
verschaffen verschillende bestanden code voor een enkele activiteit, zoals
de diverse @file{rmail@dots{}} bestanden code voor het lezen van e-mail
verschaffen.) In @cite{The GNU Emacs Manual} zie je zinnen zoals ``het
@kbd{C-h p} commando laat je de standaard Emacs lisp bibliotheken doorzoeken
op onderwerp sleutelwoorden.''

@node versimpelde-beginning-of-buffer
@section Een versimpelde @code{beginning-of-buffer} definitie
@findex versimpelde-beginning-of-buffer

De @code{beginning-of-buffer} is een goede functie om mee te starten omdat
je er waarschijnlijk al bekend mee bent en makkelijk te begrijpen
is. Gebruikt als een interactief commando verplaatst
@code{beginning-of-buffer} de cursor naar het begin van het buffer, en zet
de mark op de vorige positie. Het is gewoonlijk gebonden aan @kbd{M-<}.

In deze sectie bespreken we een verkorte versie van de functie die laat zien
hoe het meestal gebruikt wordt. De verkorte functie werkt, maar heeft geen
code voor een complexe optie. In een andere sectie zullen we de volledige
code bespreken. (@xref{beginning-of-buffer, , Complete definitie van
@code{beginning-of-buffer}}.) 

Voordat we naar de code kijken staan we stil bij wat de functiedefinitie
moet bevatten: het moet een expressie bevatten die de functie interactief
maakt zodat het kan worden aangeroepen met typen van @kbd{M-x
beginning-of-buffer} of door het typen van een toetscombinatie zoals
@kbd{M-<}. Het moet code bevatten om de mark op de originele positie te
plaatsen en het moet code bevatten om de cursor naar het begin van het
buffer te verplaatsen. 

@need 1250
Hier is de complete text van de verkorte versie van de functie:

@smallexample
@group
(defun versimpelde-beginning-of-buffer ()
  "Verplaats point naar begin van het buffer;
plaats mark op de vorige positie."
  (interactive)
  (push-mark)
  (goto-char (point-min)))
@end group
@end smallexample

Zoals alle functiedefinities heeft deze definitie de vijf delen volgens de
macro @code{defun}: 

@enumerate
@item
De naam: in dit voorbeeld @code{versimpelde-beginning-of-buffer}.

@item
Een lijst met argumenten, in dit voorbeeld een lege lijst, @code{()}.

@item
De documentatiestring

@item
De interactive expressie

@item
De body
@end enumerate

@noindent
In deze functiedefinitie is de argumentlijst leeg, dit betekent dat de
functie geen argumenten vereist. (Wanneer we naar de definitie van de
complete functie kijken zien we dat deze een optioneel argument kan
krijgen.)

De interactive expressie vertelt Emacs dat de functie bedoeld is voor
interactief gebruik. In dit voorbeeld heeft @code{interactive} geen
argumenten omdat @code{versimpelde-beginning-of-buffer} die niet nodig
heeft.

@need 800
De body van de functie bestaat uit twee regels:

@smallexample
@group
(push-mark)
(goto-char (point-min))
@end group
@end smallexample

De eerste van de twee regels is de expressie @code{(push-mark)}. Wanneer de
Lisp interpreter deze expressie evalueert stelt het de mark op de huidige
positie van de cursor in, wat die ook is. De positie van deze mark wordt
bewaard in de mark-ring.

De volgende regel is @code{(goto-char (point-min))}. Deze expressie springt
de cursor naar het minimum punt in het buffer, dat is het begin van de
buffer (of het begin van het bereikbare deel van de buffer wanneer is het
versmald. @xref{Versmallen en verbreden, , Versmallen en verbreden}.)

Het @code{push-mark} commando zet de mark op de plaats waar de cursor was
voordat het door de @code{(goto-char (point-min))} expressie naar het begin
van de buffer werd verplaatst. Daardoor kan je, als je dat wilt, terug gaan
naar de plek waar je oorspronkelijk was door @kbd{C-x C-x} te typen.

Dat is alles wat er is voor deze functiedefinitie!

@findex describe-function
Wanneer je code zoals deze leest en een onbekende functie tegenkomt zoals
@code{goto-char}, kan je met het @code{describe-function} commando ontdekken
wat die doet. Typ @kbd{C-h f} gevold door de naam van de functie en toets
daarna @key{RET} om dit commando te gebruiken. Het @code{describe-function}
commando toont de documentatiestring van de functie in een
@file{*Help*}-venster. Bijvoorbeeld de documentatie voor @code{goto-char}
is: 

@smallexample
@group
Set point to POSITION, a number or marker.
Beginning of buffer is position (point-min), end is (point-max).
@end group
@end smallexample

@noindent
Het enige argument van de functie is de gewenste positie.

@noindent
De prompt voor @code{describe-function} stelt je het symbool onder of
voorafgaand aan de cursor voor, zodat je minder hoeft te typen door de
cursor boven of meteen achter de functie te plaatsen en dan @kbd{C-h f
@key{RET}} te typen.)

De functiedefinitie van @code{end-of-buffer} is op dezelfde manier
geschreven als de @code{beginning-of-buffer}-definitie, belalve dat de body
van de functie de expressie @code{(goto-char (point-max))} bevat in plaats
van @code{(goto-char (point-min))}.

@node mark-whole-buffer
@section De definitie van @code{mark-whole-buffer}
@findex mark-whole-buffer

De functie @code{mark-whole-buffer} is niet lastiger te begrijpen dan de
@code{versimpelde-beginning-of-buffer}-functie. In dit geval kijken we
echter naar de complete functie en niet naar een verkorte versie.

De functie @code{mark-whole-buffer} wordt minder vaak gebruikt dan de
functie @code{beginning-of-buffer}, maar is toch zinvol: het markeert de
hele buffer als region door de point aan het begin en de mark aan het einde
van de buffer te plaatsen. Het is gebruikelijk gebonden aan @kbd{C-x h}.

@menu
* mark-whole-buffer overzicht::  mark-whole-buffer overzicht
* Body van mark-whole-buffer::  Slechts drie regels met code
@end menu

@ifnottex
@node mark-whole-buffer overzicht
@unnumberedsubsec Een overzicht van @code{mark-whole-buffer}
@end ifnottex

@need 1250
In GNU Emacs 22 ziet de code voor de gehele functie er zo uit:

@smallexample
@group
(defun mark-whole-buffer ()
  "Put point at beginning and mark at end of buffer.
You probably should not use this function in Lisp programs;
it is usually a mistake for a Lisp function to use any subroutine
that uses or sets the mark."
  (interactive)
  (push-mark (point))
  (push-mark (point-max) nil t)
  (goto-char (point-min)))
@end group
@end smallexample

@need 1250
Zoals alle andere functie past de functie @code{mark-whole-buffer} in het
sjabloon voor de functiedefinitie. Het sjabloon is als volgt: 

@smallexample
@group
(defun @var{naam-van-de-functie} (@var{argument-list})
  "@var{documentatie}@dots{}"
  (@var{interactive-expression}@dots{})
  @var{body}@dots{})
@end group
@end smallexample

Dit is hoe de functie werkt: de naam van de functie is
@code{mark-whole-buffer}, gevold door een lege argumentlijst @samp{()}, wat
inhoudt dat de functie geen argumenten vereist. De documentatie komt daarna.

De volgende regel is de @code{(interactive)}-expressie die Emacs vertelt dat
de functie interactief gebruikt gaat worden. Deze details zijn vergelijkbaar
met de in de vorige sectie beschreven functie
@code{versimpelde-beginning-of-buffer}.

@need 1250
@node Body van mark-whole-buffer
@subsection Body van @code{mark-whole-buffer}

De body van de functie @code{mark-whole-buffer} bestaat uit drie regels
code:

@c GNU Emacs 22
@smallexample
@group
(push-mark (point))
(push-mark (point-max) nil t)
(goto-char (point-min))
@end group
@end smallexample

De eerste van deze regels is de expressie @code{(push-mark (point))}.

Deze regel doet precies hetzelfde als de eerste regel in de body van de
functie @code{versimpelde-beginning-of-buffer}, waar @code{(push-mark)}
staat. In beide gevallen zet de Lisp interpreter de mark op de huidige
positie van de cursor.

Ik weet niet waarom @code{(push-mark (point))} in @code{mark-whole-buffer}
staat en @code{(push-mark)} in de expressie @code{beginning-of-buffer}
. Misschien wist wie de code schreef niet dat de argumenten van
@code{push-mark} optioneel zijn en dat wanneer geen argument aan
@code{push-mark} wordt doorgegeven, de functie automatisch standaard de
locatie van de cursor gebruikt. Of misschien was de expressie zo geschreven
dat die parallel aan de structuur van de volgende regel is. In elk geval
zorgt de regel dat Emacs de positie van point vaststelt en de mark daar zet.

De volgende regel van @code{mark-whole-buffer} was in een eerdere versie van
GNU Emacs @code{(push-mark (point-max))}. Deze expressie zet de mark op het
punt met het hoogste getal in het buffer. Deze is aan het eind van het
buffer (of, wanneer het buffer versmald is, aan het eind van het bereikbare
deel van de buffer, @xref{Versmallen en verbreden, , Versmallen en
verbreden}.) Nadat de mark is ingesteld, is de vorige mark, die op point was
gezet, niet meer ingesteld, maar Emacs herinnert zijn positie, net als het
alle recente marks altijd herinnert. Dit betekent dat, als je het wilt, je
naar de positie terugkeert met het twee keer typen van @kbd{C-u
C-@key{SPC}}.

@need 1250
In GNU Emacs 22 is @code{(point-max)} iets meer gecompliceerd. De regel is:

@smallexample
(push-mark (point-max) nil t)
@end smallexample

@noindent
De expressie werkt bijna hetzelfde als hiervoor. Het stelt de mark in op de
hoogst mogelijk  genummerde plaats in het buffer. Echter in deze versie
heeft @code{push-mark} twee aanvullende argumenten. Het tweede argument voor
@code{push-mark} is @code{nil}. Dit vertelt de functie dat het de boodschap
``Mark set'' @emph{moet} tonen wanneer het de mark pusht. Het derde argument
is  @code{t}. Dit vertelt @code{push-mark} om de mark te activeren wanneer
Transient Mark mode aan staat. Transient Mark mode highlight de huidige
actieve region. Het staat vaak uit.

De laatste regel van de functie is tenslotte @code{(goto-char
(point-min)))}. Dit is op precies dezelfde manier geschreven als in
@code{beginning-of-buffer}. De expressie verplaatst de cursor naar het
minimale punt in het buffer, dat is het begin van het buffer (of het begin
van het bereikbare deel van het buffer). Het resultaat is dat point aan het
begin van het buffer en de mark aan het eind van het buffer staan. Het hele
buffer is daardoor de region.

@node append-to-buffer
@section De definitie van @code{append-to-buffer}
@findex append-to-buffer

Het @code{append-to-buffer} commando is complexer dan het
@code{mark-whole-buffer} commando. Wat het doet is de region (dat is het
deel van het buffer tussen point en mark) van het huidige buffer kopiëren
naar een specifiek buffer.

@menu
* append-to-buffer overzicht::  append-to-buffer overzicht
* append interactief::       Een tweedelige interactieve expressie.
* append-to-buffer body::    Bevat een @code{let} expressie.
* append save-excursion::    Hoe de @code{save-excursion} werkt.
@end menu

@ifnottex
@node append-to-buffer overzicht
@unnumberedsubsec Een overzicht van @code{append-to-buffer}
@end ifnottex

@findex insert-buffer-substring
Het @code{append-to-buffer} commando gebruikt de functie
@code{insert-buffer-substring} om de region te
kopiëren. @code{insert-buffer-substring} doet wat de naam zegt: het neemt
een substring van een buffer en voegt die in een andere buffer in.

Het grootste deel van @code{append-to-buffer} houdt zich bezig met het
voorbereiden van de condities voor het werk van
@code{insert-buffer-substring}: de code specificeert het buffer waar de
tekst heen gaat, het venster waar het vandaan komt en naar toe gaat en de
region die gekopieerd wordt.

@need 1250
Hier is een mogelijke implementatie van de functie:

@c GNU Emacs 22
@smallexample
@group
(defun append-to-buffer (buffer start end)
  "Voeg tekst van de region toe aan het gespecificeerde buffer.
Het wordt voor de point in dat buffer ingevoegd.
@end group

@group
Geef bij het aanroepen vanuit een programma drie argumenten:
BUFFER (of buffernaam), START en END.
START en END specificeren het te kopiëren deel van het huidige buffer."
  (interactive
   (list (read-buffer "Append to buffer: " (other-buffer
                                            (current-buffer) t))
         (region-beginning) (region-end)))
@end group
@group
  (let ((oldbuf (current-buffer)))
    (save-excursion
      (let* ((append-to (get-buffer-create buffer))
             (windows (get-buffer-window-list append-to t t))
             point)
        (set-buffer append-to)
        (setq point (point))
        (barf-if-buffer-read-only)
        (insert-buffer-substring oldbuf start end)
        (dolist (window windows)
          (when (= (window-point window) point)
            (set-window-point window (point))))))))
@end group
@end smallexample

De functie kan begrepen worden door het te bekijken als een serie ingevulde
sjablonen.

Het buitenste sjabloon is voor de functiedefinitie. In deze functie ziet het
er zo uit (met verschillende ingevulde slots):

@smallexample
@group
(defun append-to-buffer (buffer start end)
  "@var{documentatie}@dots{}"
  (interactive @dots{})
  @var{body}@dots{})
@end group
@end smallexample

De eerste regel van de functie bevat de naam en drie argumenten. De
argumenten zijn de @code{buffer} waar het de tekst naar toe kopieert, en de
@code{start} en @code{end} van de te kopiëren region in het huidige buffer.

Het volgende deel is de documentatie die helder en compleet is. De drie
argumenten zijn, volgens de conventie, in hoofdletters geschreven, zodat je
ze makkelijk kunt opmerken. Nog beter is dat ze in dezelfde volgorde staan
als in de argumentlijst.

Merk op de dat de documentatie de buffer en zijn naam onderscheidt. (De
functie kan met beide overweg.)

@node append interactief
@subsection De @code{append-to-buffer} interactieve expressie

Omdat de @code{append-to-buffer} functie interactief gebruikt gaat worden,
moet de functie een @code{interactive} expressie hebben. (Voor een terugblik
op @code{interactive}, zie @ref{Interactief, , Een functie interactief
maken}. 

De exressie is als volgt:

@smallexample
@group
 (list (read-buffer
        "Append to buffer: "
        (other-buffer (current-buffer) t))
       (region-beginning)
       (region-end)))
@end group
@end smallexample

@noindent
Deze expressie is er niet een met letters die voor de delen staan, zoals
eerder beschreven. In plaats daarvan begint het met een lijst met deze
delen:

Het eerste deel van de lijst is een expressie die de naam van het buffer
leest en als een string teruggeeft. Dat is @code{read-buffer}. De functie
vereist een prompt as het eerste argument, @samp{"Append to buffer: "}. Het
tweede argument vertelt het commando welke waarde te verschaffen wanneer je
er geen specificeert.

In dit geval is het tweede argument een expressie bestaand uit de functie
@code{other-buffer}, een utizondering en een @samp{t}, dat voor waar staat.

Het eerste argument voor @code{other-buffer}, de uitzondering, is opnieuw
een functie, @code{current-buffer}. Die wordt niet teruggegeven. Het tweede
argument is het symbool voor waar, @code{t}. Deze vertelt
@code{other-buffer} dat het zichtbare buffers mag tonen (behalve dat het in
dit geval niet het huidige buffer toont, wat logisch is).

@need 1250
De expressie ziet er zo uit:

@smallexample
(other-buffer (current-buffer) t)
@end smallexample

Het tweede en derde argument in de @code{lijst} expressies zijn
@code{(region-beginning)} en @code{(region-end)}. Deze twee functies
specificeren het begin en einde van de toe te voegen tekst.

@need 1250
Oorspronkelijk gebruikte het commando de letters @samp{B} en @samp{r}. De
gehele @code{interactive} expressie zag er zo uit:

@smallexample
(interactive "BAppend to buffer:@: \nr")
@end smallexample

@noindent
Maar toen dat gereed was, bleek de standaard waarde van het buffer waar naar
toe geschakeld was onzichtbaar. Dat was niet gewenst.

(De prompt werd gescheiden van het tweede argument met een nieuwe regel,
@samp{\n}. Het werd gevolgd door een @samp{r} die Emacs vertelde om de twee
argumenten die volgen op het symbool @code{buffer} in de argumentlijst van
de functie (te weten, @code{start} en @code{end}) aan de waarden van point
en mark te binden. Dat argument werkte prima.)

@node append-to-buffer body
@subsection De body van @code{append-to-buffer}

De body van de functie @code{append-to-buffer} begint met @code{let}.

Zoals we eerder zagen (@pxref{let, , @code{let}}), is het doel van een
@code{let} expressie om een of meer variabelen die uitsluitend worden
gebruikt binnen de body van de @code{let} te creëeren en een initiële waarde
te geven. Dit betekent dat zo'n variabele niet verward wordt met een
variabele met dezelfde naam buiten de @code{let} expressie.

We kunnen zien hoe de @code{let}-expressie past in de functie als geheel,
door een overzicht van het sjabloon te tonen voor de @code{append-to-buffer}
met de @code{let}-expressie.

@smallexample
@group
(defun append-to-buffer (buffer start end)
  "@var{documentatie}@dots{}"
  (interactive @dots{})
  (let ((@var{variable} @var{value}))
        @var{body}@dots{}))
@end group
@end smallexample

De @code{let}-expressie heeft drie elementen:

@enumerate
@item
Het symbool @code{let};

@item
Een varlist die, in dit geval, een enkele lijst met twee elementen bevat,
@code{(@var{variable} @var{value})};

@item
De body van de @code{let}-expressie.
@end enumerate

@need 800
In de functie @code{append-to-buffer} ziet de varlist er zo uit:

@smallexample
(oldbuf (current-buffer))
@end smallexample

@noindent
In dit deel van de @code{let} de ene variabele, @code{oldbuf}, is gebonden
aan de waarde die de @code{(current-buffer)} expressie teruggeeft. De
variabele, @code{oldbuf} wordt gebruikt om het buffer bij te houden in welk
je werkt en vanwaar je kopieert.

Het element of de elementen van een varlist zijn omgeven door een paar
haakjes, zodat de Lisp interpreter de varlist kan onderscheiden van de body
van de @code{let}. Als gevolg hiervan is de lijst met twee elementen binnen
de varlist omgeven door een omtrekkende paar haakjes. De regel ziet er zo
uit:

@smallexample
@group
(let ((oldbuf (current-buffer)))
  @dots{} )
@end group
@end smallexample

@noindent
De twee haakjes voor @code{oldbuf} kunnen je verrassen wanneer je je niet
realseerde dat het eerste haakje voorafgaand aan @code{oldbuf} de grens van
de varlist markeert en het tweede haakje het begin van de lijst met twee
elementen, @code{(oldbuf (current-buffer))}.markeert. 

@node append save-excursion
@subsection @code{save-excursion} in @code{append-to-buffer}

De body van de @code{let} expressie in @code{append-to-buffer} bestaat uit
een @code{save-excursion} expressie.

De functie @code{save-excursion} bewaart de lokatie van point en herstelt
point naar die positie na afloop van de uitvoering van de expressies in de
body van @code{save-excursion}. Verder houdt @code{save-excursion} bij wat
het oorspronkelijke buffer is en herstelt die. Dit is hoe
@code{save-excursion} wordt gebruikt in @code{append-to-buffer}.

@need 1500
@cindex Indentie voor formatteren
@cindex Formattering conventie
Overigens is het waardevol hier op te merken dat een Lisp functie normaal zo
geformatteerd is dat alles wat over meerdere regels verspreid is, meer
inspringt dan het eerste symbool. In deze functiedefinitie springt de
@code{let} meer in dan de @code{defun} en de @code{save-excursion} springt
meer in dan de @code{let}, zoals dit:

@smallexample
@group
(defun @dots{}
  @dots{}
  @dots{}
  (let@dots{}
    (save-excursion
      @dots{}
@end group
@end smallexample

@need 1500
@noindent
De formattering-conventie maakt het makkelijk te zien dat de regels in de
body van @code{save-excursion} zijn ingesloten in de haakjes geassocieerd
met @code{save-excursion}, net zoals de @code{save-excursion} ingesloten is
in de haakjes geassocieerd met de @code{let}:

@smallexample
@group
(let ((oldbuf (current-buffer)))
  (save-excursion
    @dots{}
    (set-buffer @dots{})
    (insert-buffer-substring oldbuf start end)
    @dots{}))
@end group
@end smallexample

@need 1200
Het gebruik van de functie @code{save-excursion} kan beschouwd worden als
een proces om de slots in het sjabloon in te vullen:

@smallexample
@group
(save-excursion
  @var{eerste-expressie-in-body}
  @var{tweede-expressie-in-body}
   @dots{}
  @var{laatste-expressie-in-body})
@end group
@end smallexample

@need 1200
@noindent
@anchor{let* geïntroduceerd}
@findex let*
In deze functie bevat de body van @code{save-excursion} slechts één
expressie, de @code{let*} expressie. Je kent de @code{let}-functie. de
functie @code{let*} is anders. Het maakt Emacs mogelijk om elke variabele in
de varlist op volgorde in te stellen, de een na de ander. zo dat de
variabelen in een later gedeelte van de varlist gebruik kunnen maken van
waarden die Emacs eerder in de varlist instelde.

Kijkend naar de @code{let*} expressie in @code{append-to-buffer}:

@smallexample
@group
(let* ((append-to (get-buffer-create buffer))
       (windows (get-buffer-window-list append-to t t))
       point)
  BODY...)
@end group
@end smallexample

@noindent
zien we dat @code{append-to} gebonden is aan de waarde teruggegeven door
@w{@code{(get-buffer-create buffer)}}. Op de volgende regel is
@code{append-to} gebruikt als argument voor
@code{get-buffer-window-list}. Dit zou niet mogelijk geweest zijn met de
@code{let}-expressie. Merk op dat @code{point} automatisch is gebonden aan
@code{nil}, net zo als dat zou zijn gebeurd in de @code{let}-statement.

Laten we ons nu focussen op de functies @code{set-buffer} en
@code{insert-buffer-substring} in de body van de @code{let*} expressie.

@need 1250
In het verleden was de @code{set-buffer}-expressie eenvoudigweg:

@smallexample
(set-buffer (get-buffer-create buffer))
@end smallexample

@need 1250
@noindent
maar nu is het

@smallexample
(set-buffer append-to)
@end smallexample

@noindent
Dit is omdat @code{append-to} gebonden was aan @code{(get-buffer-create
buffer)} eerder in de @code{let*}-expressie.

De @code{append-to-buffer} functiedefinitie voegt tekst in van het buffer
waar je nu in bent naar een genoemd buffer. Toevallig doet
@code{insert-buffer-substring} precies het omgekeerde---het kopieert tekst
van een ander buffer naar het huidige buffer---en dat is waarom de
@code{append-to-buffer} definitie begint met de @code{let} dat het lokale
symbool @code{oldbuf} bindt aan de door @code{current-buffer} teruggegeven
waarde.

@need 1250
De @code{insert-buffer-substring} expressie ziet er zo uit:

@smallexample
(insert-buffer-substring oldbuf start end)
@end smallexample

@noindent
De functie @code{insert-buffer-substring} kopieert een string @emph{van} het
buffer gespecificeerd als eerste argument en voegt de string in het huidige
buffer. In de geval is het argument van @code{insert-buffer-substring} de
waarde van de variabele die de @code{let} creëerde en bond, namelijk de
waarde van @code{oldbuf}, wat het huidige buffer was toen je het
@code{append-to-buffer} commando gaf.

Nadat @code{insert-buffer-substring} zijn werk gedaan heeft, herstelt
@code{save-excursion} de actie naar het originele buffer en heeft
@code{append-to-buffer} zijn werk gedaan.

@need 800
Hoog over bekeken ziet de werking van de body er zo uit:

@smallexample
@group
(let (@var{bind-}@code{oldbuf}@var{-to-value-of-}@code{current-buffer})
  (save-excursion                       ; @r{Bijhouden van het buffer.}
    @var{change-buffer}
    @var{insert-substring-from-}@code{oldbuf}@var{-into-buffer})

  @var{schakel-terug-naar-oorspronkelijke-buffer-indien-gereed}
@var{laat-de-lokale-betekenis-van-}@code{oldbuf}@var{-verdwijnen-indien-gereed}
@end group
@end smallexample

Samengevat werkt @code{append-to-buffer} als volgt: het bewaart de waarde
van het huidige buffer in de variabele met de naam @code{oldbuf}. Het krijgt
de nieuwe buffer (en maakt er zo nodig een aan) en schakelt de aandacht van
Emacs daar naar toe. Met de waarde van @code{oldbuf} voegt het de tekst van
de region van het oude buffer in het nieuwe in. Daarna brengt het je met
@code{save-excursion} terug naar je oorspronkelijke buffer.

Met het kijken naar @code{append-to-buffer}, heb je een behoorlijk complexe
functie verkend. Het toont het gebruik van @code{let} en
@code{save-excursion} en hoe naar een ander buffer te schakelen en terug te
komen. Veel functiedefinities gebruiken @code{let}, @code{save-excursion} en
@code{set-buffer} op deze manier.

@node Buffer gerelateerde terugblik
@section Terugblik

Hier is een korte samenvatting van de verschillende in dit hoofdstuk
besproken functies.

@table @code
@item describe-function
@itemx describe-variable
Toon de documentatie voor een functie of variabele. Gewoonlijk gebonden
aan@kbd{C-h f} en @kbd{C-h v}.

@item xref-find-definitions
Vindt het bestand dat de broncode voor een functie of variabele bevat en
schakel buffers daar naar toe en plaats point aan het begin van dat
item. Gewoonlijk gebonden aan @kbd{M-.} (dat is een punt volgend op de
@key{META} toets).

@item save-excursion
Bewaar de lokatie van point en herstel zijn waarde nadat de argumenten van
@code{save-excursion} zijn geëvalueerd. Onthoud ook het huidige buffer en
keer daar naar terug.

@item push-mark
Stel mark in op een lokatie en bewaarde waarde van voorgaande mark op de
mark-ring. De mark is een lokatie in het buffer dat zijn relatieve positie
behoudt, zelfs wanneer in het buffer tekst is toegevoegd of verwijderd.

@item goto-char
Zet point op de lokatie gespecificeerd door de waarde van het argument, dat
een getal kan zijn, een marker, of een expressie die ene getal of een
positie teruggeeft, zoals @code{(point-min)}.

@item insert-buffer-substring
Kopieer een region met tekst van een buffer dat als argument is doorgegeven
aan de functie en voeg de region in het huidige buffer in.

@item mark-whole-buffer
Markeer het gehele buffer als region. Normaal gebonden aan  @kbd{C-x h}.

@item let*
Declareer een lijst met variabelen en geef die een initiële waarde. Evalueer
de rest van de expressies in de body van @code{let*}. De waarden van de
variabelen kunnen gebruikt worden om daaropvolgende variabelen in de lijst
te binden.

@item set-buffer
Richt de aandacht van Emacs op een ander buffer, maar wijzig het getoonde
venster niet. Wordt gebruikt wanneer een programma in plaats van een mens op
een ander buffer werkt.

@item get-buffer-create
@itemx get-buffer
Vindt een genoemd buffer of maak er een wanneer een buffer met die naam nog
niet bestaat. De functie @code{get-buffer} geeft @code{nil} terug wanneer
het genoemde buffer niet bestaat.
@end table

@need 1500
@node Buffer oefeningen
@section Oefeningen

@itemize @bullet
@item
Schrijf je eigen @code{versimpelde-beginning-of-buffer}
functiedefinitie. Test daarna om te kijken of het werkt.

@item
Gebruik @code{if} en @code{get-buffer} om een functie te schrijven die een
boodschap toon die aangeeft of een buffer wel of niet bestaat.

@item
Zoek met @code{xref-find-definitions} de bron voor de functie
@code{copy-to-buffer}.
@end itemize

@node Meer complex
@chapter Enkele meer complexe functies

In dit hoofdstuk bouwen we voort op wat in de vorige hoofdstukken hebben
geleerd door naar meer complexe functies te kijken. De functie
@code{copy-to-buffer} illustreert het gebruik van twee @code{save-excursion}
expressies in één definitie, terwijl de @code{insert-buffer} het gebruik van
een ster in een @code{interactive} expressie, het gebruik van @code{or}, en
het belangrijke onderscheid tussen een naam en het object waar die aan
refereert illustreert.

@menu
* copy-to-buffer::           Met @code{set-buffer} en 
                               @code{get-buffer-create}.
* insert-buffer::            Read-only en met @code{or}
* beginning-of-buffer::      Toon @code{goto-char}, @code{point-min} en 
                               @code{push-mark}.
* Tweede buffer gerelateerde terugblik::  Tweede buffer gerelateerde 
                                            terugblik
* optionele oefening::       optionele oefening
@end menu

@node copy-to-buffer
@section De definitie van @code{copy-to-buffer}
@findex copy-to-buffer

Wanneer je begrijpt hoe @code{append-to-buffer} werkt, is het eenvoudig
@code{copy-to-buffer} te begrijpen. Deze functie kopieert tekst naar een
buffer, maar in plaats van het aan het tweede buffer toe te voegen vervangt
het alle voorgaande tekst in het tweede buffer.

@need 800
De body van @code{copy-to-buffer} ziet er zo uit.

@smallexample
@group
@dots{}
(interactive "BCopy to buffer: \nr")
(let ((oldbuf (current-buffer)))
  (with-current-buffer (get-buffer-create buffer)
    (barf-if-buffer-read-only)
    (erase-buffer)
    (save-excursion
      (insert-buffer-substring oldbuf start end)))))
@end group
@end smallexample

De functie @code{copy-to-buffer} heeft een simpeler @code{interactive}
expressie dan @code{append-to-buffer}.

@need 800
De definitie zegt daarna:

@smallexample
(with-current-buffer (get-buffer-create buffer) @dots{}
@end smallexample

Kijk ten eerste naar de vroegste binnenste expressie, die wordt het eerste
geëvalueerd. De expressie start met @code{get-buffer-create buffer}. De
functie vertelt de computer het buffer te gebruiken met de naam
gespecificeerd als diegene waarnaar je wilt kopiëren, of die aan te maken
als die niet bestaat. Daarna evalueert de functie @code{with-current-
buffer} zijn body met dat als tijdelijk huidige buffer, waarna het
terugschakelt naar de buffer waar wij nu zijn@footnote{Dit is vergelijkbaar
met @w{@code{(save- excursion (set-buffer @dots{}) @dots{})}} in één keer
aanroepen, maar het is een beetje anders gedefinieerd, wat de
geïnteresseerde lezer met @code{describe-function} kan ontdekken.}.

(Dit demonstreert een andere manier om de aandacht van de computer maar niet
die van de gebruiker te schakelen. De functie @code{append-to-buffer} toonde
dit te doen met @code{save-excursion} and
@code{set-buffer}. @code{with-current-buffer} is een nieuwer en misschien
zelfs makkelijker mechanisme.)

De functie @code{barf-if-buffer-read-only} stuurt je een foutmelding die
zegt dat het buffer read-only is wanneer je het niet mag wijzigen.

De volgende regel heeft de functie @code{erase-buffer} als enige inhoud. Het
wist het buffer.

De laatste twee regels tenslotte bevatten de @code{save-excursion} expressie
met @code{insert-buffer-substring} als body. De
@code{insert-buffer-substring} expressie kopieert de tekst van het buffer
waar je nu in bent (en je hebt niet gezien dat de computer zijn aandacht
verplaatst heeft, waardoor je niet weet dat dit buffer nu @code{oldbuf}
heet.)

Overigens is dit wat bedoeld wordt met ``vervanging''. Om tekst te vervangen
wist Emacs de vorige tekst en voegt daarna de nieuwe tekst in.

@need 1250
In hoofdlijnen ziet de body van @code{copy-to-buffer} er zo uit:

@smallexample
@group
(let (@var{bind-}@code{oldbuf}@var{-aan-de-waarde-van-}@code{current-buffer})
    (@var{met-het-buffer-waarheen-je-kopieert}
      (@var{maar-wis-of-kopieer-niet-naar-een-read-only-buffer})
      (erase-buffer)
      (save-excursion
        @var{insert-substring-van-}@code{oldbuf}@var{-in-buffer})))
@end group
@end smallexample

@node insert-buffer
@section De definitie van @code{insert-buffer}
@findex insert-buffer

@code{insert-buffer} is weer een andere buffer-gerelateerde functie. Het
commando kopieert een ander buffer @emph{naar} het huidige buffer. Het is
het omgekeerde van @code{append-to-buffer} of @code{copy-to-buffer}, deze
kopiëren immers tekst @emph{van} het huidige buffer naar een ander buffer.

Hier is een bespreking gebaseerd op de originele code. De code is
vereenvoudigd in 2003 en is moeilijker te begrijpen.

(@xref{Nieuwe insert-buffer, , Nieuwe body voor @code{insert-buffer}}, voor
een bespreking van de nieuwe body.

Daarnaast illustreert deze code het gebruik van @code{interactive} met een
buffer dat @dfn{read-only} zou kunnen zijn en het belangrijke onderscheid
tussen de naam van een object en het object waar daadwerkelijk aan
gerefereerd wordt. 

@menu
* insert-buffer code::       insert-buffer code
* insert-buffer interactief::  Wanneer je kan lezen maar niet schrijven.
* insert-buffer body::       The body heeft een @code{or} en een @code{let}.
* if en or::                 Gebruik een @code{if} in plaats van een 
                               @code{or}.
* Voeg or in::               Hoe de @code{or} expressie werkt.
* Voeg let in::              Twee @code{save-excursion} expressies.
* Nieuwe insert-buffer::     Nieuwe insert-buffer
@end menu

@ifnottex
@node insert-buffer code
@unnumberedsubsec De code voor @code{insert-buffer}
@end ifnottex

@need 800
Hier is de eerdere code:

@smallexample
@group
(defun insert-buffer (buffer)
  "Insert after point the contents of BUFFER.
Puts mark after the inserted text.
BUFFER may be a buffer or a buffer name."
  (interactive "*bInsert buffer:@: ")
@end group
@group
  (or (bufferp buffer)
      (setq buffer (get-buffer buffer)))
  (let (start end newmark)
    (save-excursion
      (save-excursion
        (set-buffer buffer)
        (setq start (point-min) end (point-max)))
@end group
@group
      (insert-buffer-substring buffer start end)
      (setq newmark (point)))
    (push-mark newmark)))
@end group
@end smallexample

@need 1200
Net als met andere functiedefinities kun je een sjabloon gebruiken voor een
overzicht van de functie.

@smallexample
@group
(defun insert-buffer (buffer)
  "@var{documentatie}@dots{}"
  (interactive "*bInsert buffer:@: ")
  @var{body}@dots{})
@end group
@end smallexample

@node insert-buffer interactief
@subsection De interactieve expressie in @code{insert-buffer}
@findex interactive@r{, voorbeeld gebruik van}

In @code{insert-buffer} heeft het argument van de @code{interactive}
declaratie twee onderdelen, een sterretje, @samp{*} en @samp{bInsert
buffer:@: }.

@menu
* Read-only buffer::         Wanneer een buffer niet gewijzigd kan worden.
* b for interactief::        Een bestaand buffer of anders zijn naam.
@end menu

@node Read-only buffer
@unnumberedsubsubsec Een read-only buffer
@cindex Read-only buffer
@cindex Sterretje voor een read-only buffer
@findex * @r{voor read-only buffer}

Het sterretje is voor de situatie dat het huidige buffer een read-only
buffer is---een buffer dat niet kan worden gewijzigd. Wanneer
@code{insert-buffer} wordt aangeroepen terwijl het huidige buffer read-only
is, wordt een boodschap hiervan in het echogebied getoond en de terminal kan
piepen of knipperen, het is niet toegestaan iets in het huidige buffer in te
voegen. Het sterretje hoeft niet opgevolgd te worden met een nieuwe regel om
het van het volgende argument te scheiden.

@node b for interactief
@unnumberedsubsubsec @samp{b} in een interactive expressie

Het volgende argument in de interactive-expressie begint met een kleine
letter @samp{b}. (Dit is verschillend met de code voor @code{append-to-
buffer}, die gebruikt een hoofdletter @samp{B}.) De kleine letter @samp{b}
vertelt de Lisp interpreter dat het argument voor @code{insert-buffer} een
bestaand buffer moet zijn, of de naam daarvan. (De optie hoofdletter
@samp{B} is voor de mogelijkheid dat het buffer nog niet bestaat.) Emacs
vraagt je naar de naam van het buffer en biedt een standaard buffer aan met
ingeschakelde completie voor de naam. Wanneer het buffer niet bestaat, krijg
je een boodschap ``No match'', en de terminal kan daarbij ook piepen.

De nieuwe en vereenvoudigde code genereert een lijst voor
@code{interactive}. Het gebruikt de functies @code{barf-if-buffer-read-only}
en @code{read-buffer}, waar we al vertrouwd mee zijn en de speciale vorm
@code{progn} waarmee we dat nog niet zijn. (Die wordt later beschreven.)

@node insert-buffer body
@subsection De body van de @code{insert-buffer} functie

De body van de functie @code{insert-buffer} heeft twee belangrijke delen:
een @code{or} expressie en een @code{let} expressie. Het doel van de
@code{or} is zeker te stellen dat het argument van @code{buffer} gebonden is
aan een buffer en niet slechts aan de naam van een buffer. De body van de
@code{let} expressie bevat de code die het andere buffer in het huidige
kopieert.

@need 1250
Globaal passen de twee expressies als volgt in de functie
@code{insert-buffer}: 

@smallexample
@group
(defun insert-buffer (buffer)
  "@var{documentatie}@dots{}"
  (interactive "*bInsert buffer:@: ")
  (or @dots{}
      @dots{}
@end group
@group
  (let (@var{varlist})
      @var{body-of-}@code{let}@dots{} )
@end group
@end smallexample

Om te begrijpen hoe de @code{or} zeker stelt dat het argument van
@code{buffer} gebonden is aan een buffer en niet aan de naam van een buffer,
is het eerst nodig de functie @code{or} te begrijpen.

Laat mij eerst, voor dat we dat doen, dit deel van de functie met @code{if}
herschrijven, zodat je kunt zien wat er gebeurt op een manier die vertrouwd
is.

@node if en or
@subsection @code{insert-buffer} met een @code{if} in plaats van een @code{or}

De taak die gedaan moet worden is zorgen dat de waarde van @code{buffer}
echt een buffer en niet de naam van een buffer. Wanneer de waarde de naam
is, dan moet het buffer zelf worden verkregen.

Stel je voor dat je op een conferentie bent en de ceremoniemeester loopt
rond met een lijst waar je naam op staat en is op zoek naar je: de
ceremoniemeester is gebonden aan je naam, niet aan jou, maar wanneer die je
vindt en je bij je arm neemt, raakt de ceremoniemeester gebonden aan jou.

@need 800
In Lisp kan je deze situatie als volgt beschrijven:

@smallexample
@group
(if (not (gast-vasthouden))
    (vind-en-neem-gast-bij-de arm))
@end group
@end smallexample

Wij willen hetzelfde doen met een buffer---wanneer we niet het buffer zelf
hebben, willen we het krijgen.

@need 1200
Met een predicate met de naam @code{bufferp} die ons vertelt of we een
buffer (in plaats van een naam) hebben schrijven we de code als volgt:

@smallexample
@group
(if (not (bufferp buffer))              ; @r{if-deel}
    (setq buffer (get-buffer buffer)))  ; @r{dan-deel}
@end group
@end smallexample

@noindent
De waar-of-onwaar-test van de @code{if} expresse is hier @w{@code{(not
(bufferp buffer))}} en het dan-deel is de expressie @w{@code{(setq buffer
(get-buffer buffer))}}.

In de test geeft de functie @code{bufferp} waar terug wanneer het argument
een buffer is---maar onwaar wanneer het argument de naam van een buffer
is. (Het laatste karakter van de functienaam @code{bufferp} is het karakter
@samp{p}, zoals we eerder zagen is het gebruik van @samp{p} een conventie
die aangeeft dat de functie een predicate is, wat een term is die betekent
dat de vaststelt of een bepaalde eigenschap waar of onwaar
is. @xref{Verkeerde type argument, , Het verkeerde object type als argument
gebruiken}.)

@need 1200
De functie @code{not} gaat vooraf aan de expressie @code{(bufferp buffer)},
waardoor de waar-of-onwaar-test er zo uitziet:

@smallexample
(not (bufferp buffer))
@end smallexample

@noindent
@code{not} is een functie die waar teruggeeft wanneer zijn argument onwaar
is en onwaar als zijn argument waar is. Dus wanneer @code{(bufferp buffer)}
waar teruggeeft, geeft de @code{not} onwaar terug, en omgekeerd.

Met deze test werkt de @code{if} expressie als volgt: wanneer de waarde van
de variabele @code{buffer} inderdaad een buffer is in plaats van zijn naam,
geeft de waar-of-onwaar-test onwaar terug en evalueert de @code{if}
expressie het dan-deel niet. Dat is prima, omdat we niets hoeven te doen met
de variabele @code{buffer} wanneer die werkelijk een buffer is.

Aan de andere kant, wanneer de waarde van @code{buffer} geen buffer is, maar
de naam van een buffer, geeft de waar-of-onwaar-test waar terug en wordt het
dan-deel geëvalueerd. In dit geval is het dan-deel @code{(setq buffer
(get-buffer buffer))}. Deze expressie gebruikt de functie @code{get-buffer}
om op basis van de naam het buffer zelf terug te geven. De @code{setq} stelt
vervolgens de variabele @code{buffer} in op de waarde van het buffer zelf en
vervangt zo de waarde (die de naam van het buffer was).

@node Voeg or in
@subsection De @code{or} in de body

Het doel van de @code{or} expressie in de functie @code{insert-buffer} is
zeker te stellen dat het argument van @code{buffer} gebonden is aan een
buffer en niet slechts aan de naam van een buffer. De vorige sectie liet
zien hoe deze taak met een @code{if} expressie gedaan kan worden. Echter, de
functie @code{insert-buffer} gebruikt @code{or}. Om dit te begrijpen, is het
nodig te begrijpen hoe @code{or} werkt.

@findex or
Een @code{or} functie kan allerlei argumenten hebben. Het evalueert elk
argument op zijn beurt en geeft de waarde terug van het eerste van de
argumenten dat niet @code{nil} is. Dus, en dit is een cruciale eigenschap
van @code{or}, evalueert het geen verdere argumenten na het teruggeven van
de eerste non-@code{nil} waarde.

@need 800
De @code{or} expressie ziet er zo uit:

@smallexample
@group
(or (bufferp buffer)
    (setq buffer (get-buffer buffer)))
@end group
@end smallexample

@noindent
Het eerste argument voor @code{or} is de expressie @code{(bufferp
buffer)}. Deze expressie geeft waar terug (een non-@code{nil} waarde)
wanneer het buffer inderdaad een buffer is en niet slechts de naam van een
buffer. De @code{or} expressie, wanneer dit het geval is, geeft deze waar
waarde terug en evalueert de volgende expressie niet---en dat is prima voor
ons, omdat we niets anders willen dan de waarde van @code{buffer} wanneer
die echt een buffer is.

Anderzijds, als de waarde van @code{(bufferp buffer)} @code{nil} is, wat het
is wanneer de waarde van @code{buffer} de naam van buffer is, evalueert de
Lisp interpreter het volgende element van de @code{or} expressie. Dit is de
expressie @code{(setq buffer (get-buffer buffer))}. Deze expressie geeft een
non-@code{nil} waarde terug, wat de waarde is waarop het de variabele
@code{buffer} instelt---en deze waarde is het buffer zelf, niet de naam.

Het resultaat van dit alles is dat het symbool @code{buffer} altijd gebonden
is aan een buffer in plaats van aan de naam van een buffer. Dit is allemaal
noodzakelijk omdat de functie @code{set-buffer} op een volgende regel alleen
werkt met een buffer, niet met de naam van een buffer.

@need 1250
Overigens, met @code{or} is de situatie met de ceremoniemeester als volgt:

@smallexample
(or (heeft-arm-van-gast) (vind-en-neem-de-arm-van-de-gast))
@end smallexample

@node Voeg let in
@subsection De @code{let} expresse in @code{insert-buffer}

Na zeker stelling dat de variabele @code{buffer} naar een buffer en niet
slechts naar de naam van een buffer refereert, gaat de functie
@code{insert-buffer} verder met de @code{let} expressie. Deze specificeert
drie lokale variabelen, @code{start}, @code{end} en @code{newmark} en bindt
ze aan de initiele waarde @code{nil}. Deze variabelen worden binnen de rest
van de @code{let} gebruikt en verbergen tijdelijk elke andere variabele met
eenzelfde naam in Emacs tot het einde van de @code{let}. 

@need 1200
De body van de @code{let} bevat twee @code{save-excursion} expressies. Eerst
kijken we in detail naar de binnenste @code{save-excursion} expressie. De
expressie ziet er zo uit:

@smallexample
@group
(save-excursion
  (set-buffer buffer)
  (setq start (point-min) end (point-max)))
@end group
@end smallexample

@noindent
De expressie @code{(set-buffer buffer)} schakelt de aandacht van Emacs van
het huidige buffer naar een waarvan de tekst gekopieerd zal worden. In dat
buffer zijn met het gebruik van de commando's @code{point-min} en
@code{point-max} de variabelen @code{start} en @code{end} ingesteld op het
begin en het eind van het buffer. Merk op dat we hier zien hoe @code{setq}
twee variabelen in een enkele expressie kan instellen. Het eerste argument
van @code{setq} is ingesteld op de waarde van de tweede, en het derde
argument op de waarde van de vierde.

Nadat de body van de binnenste @code{save-excursion} is geëvalueerd herstelt
@code{save-excursion} het oorspronkelijke buffer, maar @code{start} en
@code{eind} blijven ingesteld op de waarden van het begin en eind van het
buffer van waar de tekst gekopieerd wordt.

@need 1250
De buitenste @code{save-excursion} expressie ziet er zo uit:

@smallexample
@group
(save-excursion
  (@var{binnenste-}@code{save-excursion}@var{-expressie}
     (@var{ga-naar-nieuw-buffer-en-zet-}@code{start}@var{-en-}@code{end})
  (insert-buffer-substring buffer start end)
  (setq newmark (point)))
@end group
@end smallexample

@noindent
De functie @code{insert-buffer-substring} kopieert de tekst @emph{in} het
huidige buffer @emph{van} de region aangeduid met @code{start} en
@code{eind} in @code{buffer}. Omdat het geheel van het tweede buffer tussen
@code{start} en @code{eind} ligt, wordt het geheel van het tweede buffer
gekopieerd naar het buffer dat je aan het editen bent. Vervolgens wordt de
waarde van point, die aan het eind van de ingevoegde tekst is, vastgelegd in
de variabele @code{newmark}.

Nadat de body van de buitenste @code{save-excursion} is geëvalueerd, wordt
point naar zijn oorspronkelijke plek teruggeplaatst.

Het is echter handig om de mark aan het eind van de nieuw ingevoegde tekst
te plaatsen en point aan het begin. De variabele @code{newmark} registreert
het eind van de ingevoegde tekst. In de laatste regel van de @code{let}
expressie zet de @code{(push-mark newmark)} expressie op deze lokatie. (De
vorige plek van de mark is nog steeds bereikbaar: het is opgeslagen in de
mark-ring en je kunt teruggaan met @kbd{C-u C-@key{SPC}}.) Ondertussen staat
point aan het begin van de ingevoegde tekst, waar deze was voordat je de
insert-functie aanriep, die plek was bewaarde met de eerste
@code{save-excursion}.

@need 1250
De hele @code{let} ziet er zo uit:

@smallexample
@group
(let (start end newmark)
  (save-excursion
    (save-excursion
      (set-buffer buffer)
      (setq start (point-min) end (point-max)))
    (insert-buffer-substring buffer start end)
    (setq newmark (point)))
  (push-mark newmark))
@end group
@end smallexample

De functie @code{insert-buffer} gebruikt, net als de functie
@code{append-to-buffer}, @code{let}, @code{save-excursion} en
@code{set-buffer}. Daarnaast illustreert de functie een manier om @code{or}
te gebruiken. Al deze functies zijn bouwblokken die we keer op keer zullen
gebruiken.

@node Nieuwe insert-buffer
@subsection Nieuwe body voor @code{insert-buffer}
@findex insert-buffer@r{, nieuwe versie body}
@cindex nieuwe versie body voor @code{insert-buffer}

De body in de GNU Emacs 22 versie is meer verwarrend dan het orgineel.

@need 1250
Het bestaat uit twee expressies

@smallexample
@group
  (push-mark
   (save-excursion
     (insert-buffer-substring (get-buffer buffer))
     (point)))

   nil
@end group
@end smallexample

@noindent
behalve, en dit is wat veel beginners in de war brengt, wordt veel werk
verricht in de @code{push-mark} expressie.

De functie @code{get-buffer} geeft een buffer met de opgegeven naam
terug. Merk op dat de functie @emph{niet} @code{get-buffer-create} heet, het
maakt geen buffer wanneer er geen bestaat. De buffer die @code{get-buffer}
teruggeeft, een bestaand buffer, wordt doorgegeven aan
@code{insert-buffer-substring}, de het gehele buffer invoegt (omdat je niets
anders opgaf).

De plek waar het buffer is ingevoegd is vastgelegd door
@code{push-mark}. Daarna geeft de functie @code{nil} terug, de waarde van
het laatste commando. Anders gezegd, de functie @code{insert-buffer} bestaat
alleen om een zij-effect te produceren, invoegen in een ander buffer en niet
om enige waarde terug te geven.

@node beginning-of-buffer
@section Complete definitie van @code{beginning-of-buffer}
@findex beginning-of-buffer

De basisstructuur van de functie @code{beginning-of-buffer} hebben we eerder
besproken. (@xref{versimpelde-beginning-of-buffer, , Een versimpelde
@code{beginning-of-buffer} definitie}.) Deze sectie beschrijft het complexe
deel van de definitie.

Wanneer @code{beginning-of-buffer} zonder argument wordt aangeroepen plaatst
het, zoals eerder beschreven, de cursor naar het begin van het buffer
(eerlijk gezegd, het begin van het bereikbare deel van het buffer), en laat
de mark op de voorgaande positie. Echter, wanneer het commando wordt
aangeroepen met een getal tussen één en tien, dan beschouwt de functie dat
getal als een fractie van de lengte van het buffer, gemeten in tienden, en
verplaatst Emacs de cursor die fractie vanaf het begin van het buffer. Dus
je kunt de functie aanroepen met het commando @kbd{M-<}, wat de cursor naar
het begin van het buffer verplaatst, of met een toets commando zoals
@kbd{C-u 7 M-<} wat de cursor op een punt 70% in het buffer plaatst. Bij
gebruik van een getal groter dan tien als argument gaat het naar het einde
van het buffer.

De functie @code{beginning-of-buffer} kan met of zonder argument worden
aangeroepen. Het gebruik van een argument is optioneel.

@menu
* Optionele argumenten::     Optionele argumenten
* beginning-of-buffer opt arg::  Voorbeeld met optioneel argument.
* beginning-of-buffer compleet::  beginning-of-buffer compleet
@end menu

@node Optionele argumenten
@subsection Optionele argumenten

Tenzij anders verteld verwacht Lisp dat een functie met een argument in zijn
functiedefinitie wordt aangeroepen met een waarde voor dat argument. Wanneer
dat niet gebeurt, dan krijg je een fout en de boodschap @samp{Wrong number
of arguments}.

@cindex Optionele argumenten
@cindex Sleutelwoord
@findex optionall
Optionele argumenten zijn echter een eigenschap van Lisp: een specifiek
@dfn{sleutelwoord} wordt gebruikt om aan de Lisp interpreter te vertellen
dat een argument optioneel is. Het sleutelwoord is @code{&optional}. (De
@samp{&} aan de voorkant van @samp{optional} is onderdeel van het
sleutelwoord.) Wanneer een argument in een functiedefinitie volgt op het
sleutelwoord @code{&optional} dan behoeft geen waarde aan het argument te
worden doorgegeven bij het aanroepen van de functie.

@need 1200
De eerste regel van de functiedefinitie van @code{beginning-of-buffer} ziet
er daardoor als volgt uit:

@smallexample
(defun beginning-of-buffer (&optional arg)
@end smallexample

@need 1250
Globaal ziet de hele functie er zo uit:

@smallexample
@group
(defun beginning-of-buffer (&optional arg)
  "@var{documentatie}@dots{}"
  (interactive "P")
  (or (@var{is-het-argument-een-cons-cel} arg)
      (and @var{zijn-zowel-transient-mark-mode-als-mark-active-waar})
      (push-mark))
  (let (@var{stel-grootte-vast-en-stel-in})
    (goto-char
      (@var{als-er-een-argument-is}
          @var{zoek-uit-waar-heen-te-gaan}
        @var{anders-ga-naar}
        (point-min))))
  @var{wees-beleefd}
@end group
@end smallexample

De functie is vergelijkbaar met de @code{versimpelde-beginning-of-buffer}
functie, behalve dat de @code{interactive} expressie als argument @code{"P"}
heeft en de functie @code{goto-char} gevolgd wordt door een if-then-else
expressie die uitzoekt waar de cursor geplaatst moet worden wanneer er een
argument is dat geen cons-cel is.

(Omdat ik een cons-cel pas een aantal hoofdstukken verderop uitleg, negeer
alsjeblieft de functie @code{consp}. @xref{Implementatie van lijsten, , Hoe
lijsten zijn geïmplementeerd}, en @ref{Cons Cell Type, , Cons Cell and List
Types, elisp, The GNU Emacs Lisp Reference Manual}.)

De @code{"P"} in de @code{interactive} expressie vertelt Emacs om een
prefix-argument, wanneer die er is, ongewijzigd aan de functie door te
geven. Een prefix-argument maak je het typen van de @key{META}-toets,
gevolgd door een getal, of door @kbd{C-u} te typen en dan een getal. (Als je
geen getal typt, dan leidt @kbd{C-u} standaard naar een cons-cel met een
4). De kleine letter @code{"p"} in de @code{interactive} expressie laat de
functie de prefix naar een getal converteren.

De waar-of-onwaar-test in de @code{if}-expressie ziet er gecompliceerd uit,
maar is het niet: het controleert of @code{arg} een waarde heeft die niet
@code{nil} is en of het wel of niet een cons-cel is. (Dat is wat
@code{consp} doet, het controleert of zijn argument een cons-cel is.)
Wanneer @code{arg} een waarde heeft die ongelijk aan @code{nil} is (en ook
geen cons-cel is), wat het geval is wanneer @code{beginning-of-buffer} wordt
aangeroepen met een numeriek argument, dan geeft deze waar-of-onwaar-test
waar terug en wordt het dan-deel van de @code{if}-expressie
geëvalueerd. Anderzijds, wanneer @code{beginning-of-buffer} niet met een
argument is aangeroepen, heeft @code{arg} de waarde @code{nil} en wordt het
anders-deel van de @code{if}-expressie geëvalueerd. Dit anders-deel is
eenvoudigweg @code{point-min}, en wanneer dit de uitkomst is, dan is de
gehele @code{goto-char}-expressie @code{(goto-char (point-min))}, wat
overeenkomt met hoe we de functie @code{beginning-of-buffer} zagen in de
vereenvoudigde vorm.

@node beginning-of-buffer opt arg
@subsection @code{beginning-of-buffer} met een argument

Wanneer @code{beginning-of-buffer} wordt aangeroepen met een argument, dan
wordt een expressie geëvalueerd die de waarde berekent om aan
@code{goto-char} door te geven. Deze expressie is op het eerste gezicht
nogal complex. Het bevat een binnenliggende @code{if} en flink wat
rekenkunde. Het ziet er zo uit:

@smallexample
@group
(if (> (buffer-size) 10000)
    ;; @r{Avoid overflow for large buffer sizes!}
    (* (prefix-numeric-value arg)
       (/ size 10))
  (/
   (+ 10
      (* size
         (prefix-numeric-value arg)))
   10))
@end group
@end smallexample

@menu
* Ontrafelen beginning-of-buffer::  Ontrafelen beginning-of-buffer
* In geval van een groot buffer::  In geval van een groot buffer
* In geval van een klein buffer::  In geval van een klein buffer
@end menu

@ifnottex
@node Ontrafelen beginning-of-buffer
@unnumberedsubsubsec Ontrafelen @code{beginning-of-buffer}
@end ifnottex

Net als andere expressies die er complex uitzien, kan de conditionele
expressie in @code{beginning-of-buffer} worden ontrafeld door het te
bekijken als delen van een sjabloon, in dit geval het sjabloon voor een
if-then-else-expressie. Globaal ziet de expressie er zo uit:

@smallexample
@group
(if (@var{buffer-is-groot}
    @var{deel-buffer-grootte-door-10-en-vermenigvuldig-met-arg}
  @var{anders-gebruik-alternatieve-berekening}
@end group
@end smallexample

De waar-of-onwaar-test van de binnenliggende @code{if}-expressie controleert
de grootte van het buffer. De reden hiervoor is, is dat de oude versie 18
van Emacs met getallen werkte die niet hoger kunnen zijn dan ongeveer acht
miljoen en in de berekening die volgt, de programmeur bang was dat Emacs zou
proberen te grote getallen te gebruiken wanneer de buffers groot zijn. De
term ``overflow'' die in het commentaar genoemd wordt betekent dat getallen
te groot zijn. Meer recente versies van Emacs gebruiken grotere getallen,
maar de code is niet gewijzigd, al is het alleen maar omdat mensen nu met
buffers werken die vele malen groter zijn dan ooit.

Er zijn twee gevallen: wanneer de buffer groot is, en wanneer niet.

@node In geval van een groot buffer
@unnumberedsubsubsec Wat in een groot buffer gebeurt

In In @code{beginning-of-buffer} test de binnenliggende @code{if}-expressie
of de grootte van het buffer groter is dan 10.000 karakters. Om dit te doen
gebruikt het de functie @code{>} en de berekening van @code{size} die van de
let-expressie komt.

Oorspronkelijk werd de functie @code{buffer-size} gebruikt. Niet alleen werd
die functie meerdere keren aangeroepen, het gaf de grootte van het gehele
buffer, niet het bereikbare deel. De berekening is veel logischer wanneer
het alleen het bereikbare deel gebruikt. (@xref{Versmallen en verbreden, ,
Versmallen en verbreden}, voor meer informatie over het richten van de
aandacht op een bereikbaar deel.)

@need 800
De regel ziet er zo uit:

@smallexample
(if (> size 10000)
@end smallexample

@need 1200
@noindent
Wanneer het buffer groot is, dan wordt het dan-deel van de
@code{if}-expressie geëvalueerd. Dit staat er (na het formatteren voor
makkelijk lezen):

@smallexample
@group
(*
  (prefix-numeric-value arg)
  (/ size 10))
@end group
@end smallexample

@noindent
Deze expressie is een vermenigvuldiging met twee argumenten voor de functie
@code{*}.

Het eerste argument is @code{(prefix-numeric-value arg)}. Wanneer @code{"P"}
wordt gebruik als argument voor @code{interactive}, is de waarde die als
argument wordt doorgegeven een @dfn{ongewijzigd prefix-argument}, en niet
een getal. (Het is een getal in een list.) Om de berekening uit te voeren is
een conversie nodig, en @code{prefix-numeric-value} doet dat.

@findex / @r{(deling)}
@cindex Deling
Het tweede argument is @code{(/ size 10)}. Deze expressie deelt het getal
door tien---de numerieke waarde van de grootte van het bereikbare deel van
de buffer. Dit produceert een getal dat vertelt hoeveel karakters een tiende
van de buffergrootte vormen. (In Lisp wordt @code{/} gebruikt voor deling,
net als @code{*} wordt gebruikt voor vermenigvuldiging.)

@need 1200
In de complete vermenigvuldiging expressie wordt dit getal vermenigvuldigd
met de waarde van het prefix-argument---de vermenigvuldiging ziet er zo uit:

@smallexample
@group
(* @var{numerieke-waarde-van-het-prefix-arg}
   @var{aantal-karakters-in-een-tiende-van-het-bereikbare-buffer})
@end group
@end smallexample

@noindent
Als bijvoorbeeld het prefix-argument @samp{7} is, wordt de een-tiende waarde
vermenigvuldigd met 7, om op een positie van 70% uit te komen.

@need 1200
Het resultaat van dit alles is dat wanneer het bereikbare deel van het
buffer groot is, de @code{goto-char} als volgt is:

@smallexample
@group
(goto-char (* (prefix-numeric-value arg)
              (/ size 10)))
@end group
@end smallexample

Dit plaatst de cursor waar wij die willen hebben.

@node In geval van een klein buffer
@unnumberedsubsubsec Wat in een klein buffer gebeurt

Wanneer het buffer minder dan 10.000 karakters bevat wordt een iets andere
berekening uitgevoerd. Je zou kunnen denken dat dit niet nodig is, omdat de
eerste berekening dat zou kunnen doen. Maar in een klein buffer zou de
eerste methode de cursor niet precies op de gewenste regel kunnen
plaatsen. De tweede methode doet dat beter.

@need 800
De code ziet er zo uit:

@c Keep this on one line.
@smallexample
(/ (+ 10 (* size (prefix-numeric-value arg))) 10)
@end smallexample

@need 1200
@noindent
Dit is de code waarin je uitzoekt wat er gebeurt door te ontdekken hoe de
functies tussen de haakjes zijn ingebed. Het wordt makkelijker te lezen
wanneer je het zo formatteert dat elke expressie dieper inspringt dan zijn
omsluitende expressie:

@smallexample
@group
  (/
   (+ 10
      (*
       size
       (prefix-numeric-value arg)))
   10)
@end group
@end smallexample

@need 1200
@noindent
Naar de haakjes kijkend zien we dat de meest binnenste bewerking
@code{(prefix-numeric-value arg)} is, die het ongewijzigde argument naar een
getal converteert. In de volgende expressie wordt dit getal vermenigvuldigd
met de grootte van het bereikbare deel van het buffer:

@smallexample
(* size (prefix-numeric-value arg))
@end smallexample

@noindent
Deze vermenigvuldiging creëert een getal dat groter zou kunnen zijn dan de
grootte van het buffer---zeven keer groter als het argument 7 is,
bijvoorbeeld. Hierna wordt tien bij dit getal opgeteld en uiteindelijk wordt
het grote getal gedeeld door tien om een waarde te geven die één karakter
groter is dan de procentuele positie in het buffer.

Het getal dat de uitkomst is van dit alles wordt doorgegeven aan
@code{goto-char} en de cursor wordt naar dat punt verplaatst.

@need 1500
@node beginning-of-buffer compleet
@subsection De complete @code{beginning-of-buffer}

@need 1000
Hiet is de complete tekst van de functie @code{beginning-of-buffer}:
@sp 1

@c In GNU Emacs 22
@smallexample
@group
(defun beginning-of-buffer (&optional arg)
  "Move point to the beginning of the buffer;
leave mark at previous position.
With \\[universal-argument] prefix,
do not set mark at previous position.
With numeric arg N,
put point N/10 of the way from the beginning.

If the buffer is narrowed,
this command uses the beginning and size
of the accessible part of the buffer.
@end group

@group
Don't use this command in Lisp programs!
\(goto-char (point-min)) is faster
and avoids clobbering the mark."
  (interactive "P")
  (or (consp arg)
      (and transient-mark-mode mark-active)
      (push-mark))
@end group
@group
  (let ((size (- (point-max) (point-min))))
    (goto-char (if (and arg (not (consp arg)))
                   (+ (point-min)
                      (if (> size 10000)
                          ;; Avoid overflow for large buffer sizes!
                          (* (prefix-numeric-value arg)
                             (/ size 10))
                        (/ (+ 10 (* size (prefix-numeric-value arg)))
                           10)))
                 (point-min))))
  (if (and arg (not (consp arg))) (forward-line 1)))
@end group
@end smallexample

@ignore
From before GNU Emacs 22
@smallexample
@group
(defun beginning-of-buffer (&optional arg)
  "Move point to the beginning of the buffer;
leave mark at previous position.
With arg N, put point N/10 of the way
from the true beginning.
@end group
@group
Don't use this in Lisp programs!
\(goto-char (point-min)) is faster
and does not set the mark."
  (interactive "P")
  (push-mark)
@end group
@group
  (goto-char
   (if arg
       (if (> (buffer-size) 10000)
           ;; @r{Avoid overflow for large buffer sizes!}
           (* (prefix-numeric-value arg)
              (/ (buffer-size) 10))
@end group
@group
         (/ (+ 10 (* (buffer-size)
                     (prefix-numeric-value arg)))
            10))
     (point-min)))
  (if arg (forward-line 1)))
@end group
@end smallexample
@end ignore

@noindent
Afgezien van twee kleine punten toont de voorgaande bespreking hoe deze
functie werkt. Het eerste punt betreft een detail in de documentatiestring
en het tweede punt betreft de laatste regel van de functie.

@need 800
In de documentatiestring is een referencie naar een expressie:

@smallexample
\\[universal-argument]
@end smallexample

@noindent
Een @samp{\\} wordt gebruikt voor de eerste vierkante haak in deze
expressie. Deze @samp{\\} vertelt de Lisp interpreter de toets te vervangen
door wat dan ook thans gebonden is aan de @samp{[@dots{}]}. In het geval van
het universele argument, die meestal gebonden is aan @kbd{C-u}, maar dit kan
anders zijn (@xref{Documentation Tips, , Tips for Documentation Strings,
elisp, The GNU Emacs Lisp Reference Manual}, for more information.)

@need 1200
Tenslotte zegt de laatste regel van het @code{beginning-of-buffer} commando
de point te verplaatsten naar het begin van de volgende regel wanneer het
commando met een argument is aangeroepen:

@smallexample
(if (and arg (not (consp arg))) (forward-line 1))
@end smallexample

@noindent
Dit plaatst de cursor aan het begin van de eerste regel na de juiste tiende
deel positie in het buffer. Deze elegantie zorgt dat de cursor altijd
@emph{tenminste} het aantal gewenste tienden in het buffer is geplaatst, wat
een misschien onnodige verfraaiing is, die, als dat niet zou gebeuren
ongetwijfeld tot klachten zou leiden. (Het @code{(not (consp arg))} deel is
zo dat wanneer je het commando met @kbd{C-u} maar zonder getal aanroept, wat
inhoudt dat het prefix-argument eenvoudig een cons-cel is, het commando je
niet aan het begin van de tweede regel plaatst.)

@node Tweede buffer gerelateerde terugblik
@section Terugblik

Hier is een korte samenvatting van enkele van de onderwerpen in dit
hoofdstuk.

@table @code
@item or
Evalueer elk argument op volgorde, en geef de waarde van het eerste argument
dat niet @code{nil} is. Wanneer niet een van hen een waarde ongelijk aan
@code{nil} teruggeeft, geef dan @code{nil} terug. In het kort, geef de
eerste waarde van de argumenten die waar is terug, geef een waarde waar
terug wanneer een @emph{of} meer van de andere waar zijn.

@item and
Evalueer elk argument op volgorde, en als er een @code{nil} is, geef dan
@code{nil} terug. Als niet een van hen @code{nil} is, geef dan de waarde van
het laatste argument terug. In het kort, geef een waarde waar terug
uitsluitend wanneer alle argumenten waar zijn, geef een waarde waar terug
wanneer een @emph{en} alle andere waar zijn.

@item &optional
Een sleutelwoord dat aangeeft dat een argument van een functiedefinitie
optioneel is, dit betekent dat de functie desgewenst zonder dit argument kan
worden geëvalueerd,

@item prefix-numeric-value
Converteer het ongewijzigde prefix-numeric-value geproduceerd door
@code{(interactive "P")} naar een numerieke waarde.

@item forward-line
Verplaats point voorwaarts naar het begin van de volgende regel, of wanneer
het argument groter is dan één, dat aantal regels voorwaarts. Wanneer het
niet zo ver voorwaarts kan als het bedoeld is, gaat @code{forward-line} zo
ver mogelijk voorwaarts en geeft vervolgens het aantal terug van de extra
regels die het bedoeld was te verplaatsen maar dat niet kon.

@item erase-buffer
Verwijder de gehele inhoud van het huidige buffer.

@item bufferp
Geef @code{t} terug wanneer het argument een buffer is, zo niet geef
@code{nil} terug.
@end table

@node optionele oefening
@section @code{optioneel} argument oefening

Schrijf een interactieve functie met een optioneel argument dat test of het
argument, een getal, groter of gelijk is aan, dan wel kleiner is dan de
waarde van @code{fill-column}, en je in een boodschap vertelt welke het
geval is. Wanneer je echter geen argument aan de functie doorgeeft, gebruik
dan 56 als standaard waarde.

@node Versmallen en verbreden
@chapter Versmallen en verbreden
@cindex Aandacht richten (versmallen)
@cindex Versmallen
@cindex Verbreden

Versmallen is een eigenschap van Emacs die het mogelijk maakt je aandacht te
richten op een specifiek deel van een buffer, en te werken zonder dat je per
ongeluk iets in de andere delen wijzigt. Versmallen is normaal gesproken
uitgeschakeld omdat het verwarrend is voor beginners.

@menu
* Voordelen van versmallen::  De voordelen van versmallen
* save-restriction::         De @code{save-restriction} speciale vorm.
* what-line::                Het regelnummer waarop de point is.
* versmal oefening::         versmal oefening
@end menu

@ifnottex
@node Voordelen van versmallen
@unnumberedsec De voordelen van versmallen
@end ifnottex

Met versmallen is de rest van het buffer onzichtbaar, alsof het er niet
is. Dit is een voordeel wanneer je bijvoorbeeld een woord in een deel van
het buffer wilt vervangen, maar niet in een ander deel: je versmalt naar het
deel dat je wilt en de vervanging wordt alleen in dat deel uitgevoerd en
niet in de rest van het buffer. Zoeken werkt ook binnen een versmald gebied,
niet daarbuiten, zodat als je een deel van een document aan het verbeteren
bent, je jezelf beschermt tegen per ongeluk vinden van delen die je niet
wilt verbeteren door te versmallen naar precies dat gebied dat je wilt. (De
toetscombinatie voor @code{narrow-to-region} is @kbd{C-x n n}.)

Versmallen maakt echter de rest van het buffer onzichtbaar, wat mensen bang
kan maken die onbedoeld versmalling aanroepen en denken dat ze een deel van
het buffer verwijderd hebben. Verder zet het @code{undo} commando (wat
normaal gebonden is aan @kbd{C-x u}) het versmallen niet uit (en moet dat
ook niet doen), wat mensen wanhopig kan maken wanneer zij niet weten dat ze
de zichtbaarheid van de rest van het buffer kunnen herstellen met het
@code{widen} commando. (De toetscombinatie voor @code{widen} is @kbd{C-x n
w}.)

Versmallen is net zo zinvol voor de Lisp interpreter als voor mensen. Vaak
is een Emacs Lisp functie ontworpen om op slechts een deel van een buffer te
werken, of omgekeerd, een Emacs Lisp functie moet werken op het gehele
buffer dat is versmald. De functie @code{what-line} bijvoorbeeld, haalt de
versmalling van een buffer als die versmald is en wanneer het zijn taak
gedaan heeft, herstelt de versmalling naar wat het was. Anderzijds gebruikt
de functie @code{count-lines} versmalling om zichzelf te beperken tot dat
deel van het buffer waarin het geïnteresseerd is en herstelt daarna de
vorige situatie.

@node save-restriction
@section De speciale vorm @code{save-restriction}
@findex save-restriction

In Emacs Lisp gebruik je de speciale vorm @code{save-restriction} om bij te
houden welke versmalling van toepassing is. Wanneer de Lisp interpreter
@code{save-restriction} tegenkomt, voert het de code in de body van de
@code{save-restriction} expressie uit en maakt de eventuele wijzigingen die
het in de versmalling heeft aangebracht ongedaan. Wanneer bijvoorbeeld het
buffer versmald is en de code die volgt op @code{save-restriction} de
versmalling weghaalt, herstelt @code{save-restriction} na afloop het buffer
naar zijn versmalde region. In het @code{what-line} commando wordt de
versmalling die het buffer mogelijk heeft ongedaan gemaakt met het
@code{widen} commando, dat onmiddellijk volgt op het
@code{save-restriction}. De eventuele oorspronkelijke versmalling wordt
hersteld vlak voor het beëindigen van de functie.

@need 1250
Het sjabloon voor een @code{save-restriction} expressie is eenvoudig:

@smallexample
@group
(save-restriction
  @var{body}@dots{} )
@end group
@end smallexample

@noindent
De body van de @code{save-restriction} bestaat uit een of meer expressies
die de Lisp interpreter  op volgorde evalueert.

Tenslotte, een punt om op te merken: wanneer je zowel @code{save-excursion}
en @code{save-restriction} gebruikt, de een na de ander, dan moet je
@code{save-excursion} als de buitenste gebruiken. Wanneer je ze in
omgekeerde volgorde schrijft, kan het bijhouden van de versmalling in het
buffer waar Emacs naar toe schakelt na het aanroepen van
@code{save-excursion} fout gaan. Wanneer je daarom samen gebruikt, schrijf
je  @code{save-excursion} en @code{save-restriction} als volgt:

@smallexample
@group
(save-excursion
  (save-restriction
    @var{body}@dots{}))
@end group
@end smallexample

In andere omstandigheden, waar ze niet samen gebruikt worden, schrijf je de
speciale vormen @code{save-excursion} en @code{save-restriction} in de
volgorde die past bij de functie.

@need 1250
Bijvoorbeeld,

@smallexample
@group
  (save-restriction
    (widen)
    (save-excursion
    @var{body}@dots{}))
@end group
@end smallexample

@ignore
Emacs 22
/usr/local/src/emacs/lisp/simple.el

(defun what-line ()
  "Print the current buffer line number and narrowed line number of point."
  (interactive)
  (let ((start (point-min))
        (n (line-number-at-pos)))
    (if (= start 1)
        (message "Line %d" n)
      (save-excursion
        (save-restriction
          (widen)
          (message "line %d (narrowed line %d)"
                   (+ n (line-number-at-pos start) -1) n))))))

(defun line-number-at-pos (&optional pos)
  "Return (narrowed) buffer line number at position POS.
If POS is nil, use current buffer location.
Counting starts at (point-min), so the value refers
to the contents of the accessible portion of the buffer."
  (let ((opoint (or pos (point))) start)
    (save-excursion
      (goto-char (point-min))
      (setq start (point))
      (goto-char opoint)
      (forward-line 0)
      (1+ (count-lines start (point))))))

(defun count-lines (start end)
  "Return number of lines between START and END.
This is usually the number of newlines between them,
but can be one more if START is not equal to END
and the greater of them is not at the start of a line."
  (save-excursion
    (save-restriction
      (narrow-to-region start end)
      (goto-char (point-min))
      (if (eq selective-display t)
          (save-match-data
            (let ((done 0))
              (while (re-search-forward "[\n\C-m]" nil t 40)
                (setq done (+ 40 done)))
              (while (re-search-forward "[\n\C-m]" nil t 1)
                (setq done (+ 1 done)))
              (goto-char (point-max))
              (if (and (/= start end)
                       (not (bolp)))
                  (1+ done)
                done)))
        (- (buffer-size) (forward-line (buffer-size)))))))
@end ignore

@node what-line
@section @code{what-line}
@findex what-line
@cindex Verbreden, voorbeeld van

Het @code{what-line} commando vertelt het je het regelnummer waarop de
cursor staat. De functie illustreert het gebruik van de
@code{save-excursion} en @code{save-restriction} commando's. Hier is de
oorspronkelijke tekst van de functie.

@smallexample
@group
(defun what-line ()
  "Print the current line number (in the buffer) of point."
  (interactive)
  (save-restriction
    (widen)
    (save-excursion
      (beginning-of-line)
      (message "Line %d"
               (1+ (count-lines 1 (point)))))))
@end group
@end smallexample

(In moderne versies van GNU Emacs is de functie @code{what-line} uitgebreid
zodat het zowel het regelnummer in het versmalde buffer als het regelnummer
in het verbrede buffer vertelt. De moderne versie is complexer dan de versie
die we hier laten zien. Wanneer je een avontuurlijke bui hebt, kan je er
naar kijken nadat je uitgezocht hebt hoe deze versie werkt. Je hebt daar
waarschijnlijk @kbd{C-h f} (@code{describe-function}) bij nodig.) De
nieuwere versie gebruikt een conditional om vast te stellen of het buffer is
versmald.

Verder maakt de moderne versie van @code{what-line} gebruik van
@code{line-number-at-pos}, die net als andere eenvoudige expressies, zoals
@code{(goto-char (point-min))}, @code{(forward-line 0)} in plaats van
@code{beginning-of-line} gebruikt om point naar het begin van de huidige
regel te verplaatsen.

De functie @code{what-line} zoals hier getoond heeft zoals je zou verwachten
een documentatieregel en is interactief. De volgende twee regels gebruiken
de functies @code{save-restriction} en @code{widen}.

De speciale vorm @code{save-restriction} noteert eventuele versmalling die
van kracht is in het huidige buffer en herstelt de versmalling nadat de code
in de body van @code{save-restriction} is geëvalueerd.

De speciale vorm @code{save-restriction} wordt gevolgd door
@code{widen}. Deze functie maakt eventuele versmalling in het huidige buffer
ongedaan voor zover die er was toen @code{what-line} werd aangeroepen. (De
versmalling die daar was is de versmalling die @code{save-restriction}
onthoudt.) Deze verbreding maakt het voor de commando's die de regels tellen
mogelijk om vanaf het begin van het buffer te tellen. Anders zouden ze
beperkt zijn tot het tellen binnen het bereikbare gebied. Eventuele
oorspronkelijke versmalling wordt hersteld vlak voor de voltooiing van de
functie door de speciale vorm @code{save-restriction}.

De aanroep van @code{widen} wordt gevolgd door @code{save-excursion} die de
locatie van de cursor (dus van point) bewaart, en herstelt die nadat de code
in de body van de @code{save-excursion} de functie @code{beginning-of-line}
gebruikt om point te verplaatsen.

(Merk op dat de @code{(widen)} expressie tussen de speciale vormen
@code{save-restriction} en de @code{save-excursion} staat. Wanneer je de
twee @code{save- @dots{}} expressies opeenvolgend schrijft, zet je
@code{save-excursion} als buitenste.)

@need 1200
De laatste twee regels van de functie @code{what-line} zijn functies die het
aantal regels in het buffer tellen en daarna dat aantal in het echogebied
tonen.

@smallexample
@group
(message "Line %d"
         (1+ (count-lines 1 (point)))))))
@end group
@end smallexample

De functie @code{message} toont een eenregelige boodschap onderaan het Emacs
scherm. Het eerste argument staat tussen aanhalingstekens en wordt getoond
als een string karakters. Het mag echter een  @samp{%d} expressie bevatten
om het volgende argument te tonen. @samp{%d} toont het argument als een
decimaal getal, zodat de boodschap iets als @samp{Line 243} zegt.

@need 1200
Het getal dat getoond wordt op de plek van de @samp{%d} wordt berekend door
de laatste regel van de functie:

@smallexample
(1+ (count-lines 1 (point)))
@end smallexample

@ignore
GNU Emacs 22

(defun count-lines (start end)
  "Return number of lines between START and END.
This is usually the number of newlines between them,
but can be one more if START is not equal to END
and the greater of them is not at the start of a line."
  (save-excursion
    (save-restriction
      (narrow-to-region start end)
      (goto-char (point-min))
      (if (eq selective-display t)
          (save-match-data
            (let ((done 0))
              (while (re-search-forward "[\n\C-m]" nil t 40)
                (setq done (+ 40 done)))
              (while (re-search-forward "[\n\C-m]" nil t 1)
                (setq done (+ 1 done)))
              (goto-char (point-max))
              (if (and (/= start end)
                       (not (bolp)))
                  (1+ done)
                done)))
        (- (buffer-size) (forward-line (buffer-size)))))))
@end ignore

@noindent
Wat dit doet is het tellen van de regels vanaf de eerste positie van het
buffer, aangegeven door de @code{1}, tot de @code{(point)} en telt daar
vervolgens één bij op. (De functie @code{1+} telt één bij zijn argument op.)
We tellen één er bij op omdat regel 2 maar één regel voor zich heeft, en
@code{count-lines} alleen de regels @emph{voor} de huidige regel telt.

Nadat @code{count-lines} zijn werk heeft gedaan en de boodschap in het
echogebied is getoond, herstelt @code{save-excursion} point naar zijn
oorspronkelijke positie en herstelt @code{save-restriction} de eventuele
oorspronkelijke versmalling.

@node versmal oefening
@section Oefening met versmalling

Schrijf een functie dat de eerste 60 karakters van het huidige buffer toont,
zelfs wanneer je het buffer hebt versmald naar zijn tweede helft zodat de
eerste regel onbereikbaar is. Herstel point, mark en de versmalling. Gebruik
voor deze oefening de gehele potpourri van functies, inclusief
@code{save-restriction}, @code{widen}, @code{goto-char}, @code{point-min},
@code{message} en @code{buffer-substring}.

@cindex Eigenschappen, vermelding van @code{buffer-substring-no-properties}
(@code{buffer-substring} is een eerder ongenoemde functie die je zelf moet
onderzoeken, of misschien moet je gebruik maken van
. @code{buffer-substring-no-properties} of @code{filter-buffer-substring}
@dots{}, nog meer andere functies. Teksteigenschappen zijn een eigenschap
die overigens hier niet besproken wordt. @xref{Text Properties, , Text
Properties, elisp, The GNU Emacs Lisp Reference Manual}.)

Daarnaast, heb je @code{goto-char} of @code{point-min} echt nodig? Of kan je
de functie zonder hen schrijven?

@node car cdr en cons
@chapter @code{car}, @code{cdr}, @code{cons}: Fundamentele functies
@findex car@r{, introduced}
@findex cdr@r{, introduced}

@code{car}, @code{cdr} en @code{cons} zijn fundamentele functies in Lisp. De
functie @code{cons} wordt gebruikt om lijsten te construeren, en de functies
@code{car} en @code{cdr} worden gebruikt om ze uit elkaar te halen.

In de rondleiding door de functie @code{copy-region-as-kill} kijken we naar
@code{cons} en naar twee varianten van @code{cdr}, namelijk @code{setcdr} en
@code{nthcdr}.

@menu
* Vreemde namen::            Een historische terzijde: waarom de vreemde 
                               namen?
* car en cdr::               Functies om een deel van een lijst te 
                               extraheren.
* cons::                     Een lijst construeren.
* nthcdr::                   @code{cdr} herhaaldelijk aanroepen.
* nth::                      nth
* setcar::                   Het eerste element van een lijst veranderen.
* setcdr::                   De rest van de lijst veranderen.
* cons oefening::            cons oefening
@end menu

@ifnottex
@node Vreemde namen
@unnumberedsec Vreemde namen
@end ifnottex

De naam van de functie @code{cons} is niet onredelijk, het is een afkorting
van het woord ``construct''. De herkomst van de name voor @code{car} en
@code{cdr} aan de andere kant zijn esoterisch: @code{car} is een acroniem
van de zin ``Contents of the Address part of the Register'', en @code{cdr}
(uitgesproken als ``coeld-er'') is een acroniem van de zin ``Contents of the
Decrement part of the Register''. Deze zinnen refereren aan de IBM 704
computer waarop de oorspronkelijke Lisp werd ontwikkeld.

De IBM 704 is een voetnoot in de geschiedenis, maar deze namen zijn nu
geliefde tradities van Lisp.

@node car en cdr
@section @code{car} en @code{cdr}

De @sc{car} van een lijst is, vrij eenvoudig, het eerste item in de
lijst. Dus de @sc{car} van de lijst @code{(roos viool madelief boterbloem)}
is @code{roos}.

@need 1200
Wanneer je dit in Info in GNU Emacs leest kan je dit door het volgende te
evalueren:

@smallexample
(car '(roos viool madelief boterbloem))
@end smallexample

@noindent
Na het evalueren van de expressie verschijnt @code{roos} in het echogebied.

@code{car} verwijdert het eerste element van de lijst niet, het vertelt
alleen wat het is. Nadat @code{car} op een lijst is toegepast is de lijst
nog steeds hetzelfde. @code{car} is ``niet-destructief'', in het
jargon. Deze eigenschap blijkt belangrijk te zijn.

De @sc{cdr} van een lijst is de rest van de lijst, dat wil zeggen dat de
@sc{cdr} het deel van de lijst dat volgt op het eerste item. Dus terwijl de
@sc{car} van de lijst @code{'(roos viool madelief boterbloem)} @code{roos}
is, is de rest van de, de waarde die de functie @code{cdr} teruggeeft, is
@code{(viool madelief boterbloem)}.

@need 800
Je ziet door het volgende op de gebruikelijke manier te evalueren:

@smallexample
(cdr '(roos viool madelief boterbloem))
@end smallexample

@noindent
Wanneer je dit evalueert, verschijnt @code{(viool madelief boterbloem)} in
het echogebied.

Net als @code{car} verwijdert @code{cdr} geen elementen uit de lijst---het
vertelt aleen wat het de tweede en volgende elementen zijn.

Overigens in het voorbeeld is de lijst met bloemen gequote. Wanneer dat niet
zo was zou de Lisp interpreter de lijst proberen te evalueren door
@code{roos} als een functie aan te roepen. In dit voorbeeld willen we dat
niet.

Voor het werken met lijsten zouden de namen @code{first} en @code{rest}
logischer zijn dan de namen @code{car} en @code{cdr}. Sommige programmers
definieren inderdaad @code{first} en @code{rest} als aliassen voor
@code{car} en @code{cdr} en gebruiken daarna @code{first} en @code{rest} in
de rest van hun code.

Lijsten in Lisp worden echter gebouwd met een onderliggende structuur bekend
als ``cons cells'' (@pxref{Implementatie van lijsten}), waarin niet zo iets
als ``eerste'' of ``rest'' bestaat, en de @sc{car} en de @sc{cdr}
symmetrisch zijn. Lisp probeert niet het bestaan van cons cellen te
verstoppen en programma's gebruiken ze ook voor andere dingen dan
lijsten. Om deze reden helpen de namen de programmers te herinneren dat
@code{car} en @code{cdr} symmetrisch zijn, ondanks de asymmetrische manier
waarop ze in lijsten gebruikt worden.

@ignore
Clearly, a more reasonable name for @code{cdr} would be @code{rest}.

(There is a lesson here: when you name new functions, consider very
carefully what you are doing, since you may be stuck with the names
for far longer than you expect.  The reason this document perpetuates
these names is that the Emacs Lisp source code uses them, and if I did
not use them, you would have a hard time reading the code; but do,
please, try to avoid using these terms yourself.  The people who come
after you will be grateful to you.)
@end ignore

Wanneer @code{car} en @code{cdr} worden toegepast op lijsten van symbolen,
zoals de lijst @code{(den spar eik esdoorn)}, is het element van de lijst
dat de functie @code{car} teruggeeft het symbool @code{den}, zonder haakjes
er omheen. @code{den} is het eerste symbool in de lijst. De @sc{cdr} van de
lijst is echter een list op zichzelf, @code{(spar eik esdoorn)}, zoals je
ziet door de volgende expressie op de gebruikelijke manier te evalueren:

@smallexample
@group
(car '(den spar eik esdoorn))

(cdr '(den spar eik esdoorn))
@end group
@end smallexample

Anderzijds is in een lijst van lijsten het eerste element op zichzelf een
lijst. @code{car} geeft het eerste element als lijst terug. De volgende
lijst bijvoorbeeld bevat drie sublijsten, een lijst van carnivoren, een
lijst van herbivoren en een lijst van zeezoogdieren:

@smallexample
@group
(car '((leeuw tijger cheeta)
       (gazelle antiloop zebra)
       (walvis dolfijn zeehond)))
@end group
@end smallexample

@noindent
In dit voorbeeld is het eerste element of de @sc{car} van de lijst de lijst
met carnivoren, @code{(leeuw tijger cheeta)} en is de rest van de lijst
@code{(gazelle antiloop zebra) (walvis dolfijn zeehond)}.

@smallexample
@group
(cdr '((leeuw tijger cheeta)
       (gazelle antiloop zebra)
       (walvis dolfijn zeehond)))
@end group
@end smallexample

Het is het waard nog een keer te zeggen dat @code{car} en @code{cdr}
niet-destructief zijn, zij wijzigen de lijsten waarop worden toegepast
niet. Dit is erg belangrijk voor hoe ze worden gebruikt.

Daarnaast zei ik bij de bespreking van atomen in het eerste hoofdstuk dat in
Lisp sommige soorten atomen, zoals een array, in delen gescheiden kunnen
worden maar dat het mechanisme om dit te doen afwijkt van het mechanisme om
een lijst te splijten. Voor zover het Lisp aangaat, zijn de atomen van
lijsten onsplijtbaar. (@xref{Lisp atomen}.) De functies @code{car} en
@code{cdr} worden gebruikt om lijsten te splijten en worden als fundamenteel
voor Lisp beschouwd. Aangezien zij een array niet kunnen splijten of toegang
krijgen tot de delen van een array, wordt een array beschouwd als een
atoom. Omgekeerd kan de andere fundamentele functie @code{cons} gebruikt
worden om een lijst samen te stellen, maar niet een array. (Arrays worden
behandeld met array-specifieke functies  @xref{Arrays, , Arrays, elisp, The
GNU Emacs Lisp Reference Manual}.)

@node cons
@section @code{cons}
@findex cons@r{, geïntroduceerd}

De @code{cons} functie construeert lijsten. Het is de inverse van @code{car}
en @code{cdr}. @code{cons} kan bijvoorbeeld gebruikt worden om de lijst van
vier elementen te maken van een lijst met drie elementen, bijvoorbeeld
@code{(spar eik esdoorn)}:

@smallexample
(cons 'den '(spar eik esdoorn))
@end smallexample

@need 800
@noindent
Na evaluatie van de lijst zie je

@smallexample
(den spar eik esdoorn)
@end smallexample

@noindent
in het echogebied verschijnen. @code{cons} veroorzaakt de creatie van een
nieuwe lijst waarin het element wordt gevolgd door de elementen van de
oorspronkelijke lijst.

We zeggen vaak dat @code{cons} een nieuw element aan het begin van de lijst
plaatst, of dat het een element aan de lijst vastmaakt of pusht, maar deze
formulering is misleidend, omdat @code{cons} geen bestaande lijst verandert,
maar een nieuwe maakt.

Like @code{car} and @code{cdr}, @code{cons} is non-destructive.

@menu
* Bouw een lijst::           Bouw een lijst
* length::                   Hoe de lengte van een lijst te vinden.
@end menu

@ifnottex
@node Bouw een lijst
@unnumberedsubsec Bouw een lijst
@end ifnottex

@code{cons} moet een lijst hebben om aan vast te maken@footnote{Eigenlijk
kan je met @code{cons} een element aan een atoom consen om een dotted pair
te maken. Dotted pairs worden hier niet behandeld. Zie @ref{Dotted Pair
Notation, , Dotted Pair Notation, elisp, The GNU Emacs Lisp Reference
Manual}.} Je kunt niet van absoluut niets beginnen. Wanneer je een lijst
bouwt, dan moet je tenminste een lege lijst als begin geven. Hier is een
serie van @code{cons} expressies die een lijst van bloemen opbouwen. Wanneer
je dit in Info in GNU Emacs leest, kan je elk van expressies op de
gebruikelijke manier evalueren. De waarde wordt in deze tekst getoond na
@samp{@result{}}, wat je kunt zien als ``evalueert naar''.

@smallexample
@group
(cons 'boterbloem ())
     @result{} (boterbloem)
@end group

@group
(cons 'madelief '(boterbloem))
     @result{} (madelief boterbloem)
@end group

@group
(cons 'viool '(madelief boterbloem))
     @result{} (violet madelief boterbloem)
@end group

@group
(cons 'roos '(viool madelief boterbloem))
     @result{} (roos viool madelief boterbloem)
@end group
@end smallexample

@noindent
In het eerste voorbeeld wordt de lege lijst getoond als @code{()} en wordt
lijst geconstrueerd van @code{boterbloem} gevold door de lege lijst. Zoals
je ziet wordt de lege lijst niet getoond in de geconstrueerde lijst. Het
enige wat je ziet is @code{(boterbloem)}. De lege lijst telt niet als een
element van de lijst omdat er niets is in een lege lijst. Over het algemeen
is een lege lijst onzichtbaar.

Het tweede voorbeeld, @code{(cons 'madelief '(boterbloem))} construeert een
nieuwe lijst met twee elementen door @code{madelief} voor @code{boterbloem}
te plaatsen, en het derde voorbeeld construeert een lijst met drie elementen
door @code{viool} voor @code{madelief} en @code{boterbloem} te plaatsen.

@node length
@subsection Achterhaal de lengte van een lijst: @code{length}
@findex length

Je achterhaalt hoeveel elementen in een lijst zijn met de Lisp functie
@code{length}, zoals in de volgende voorbeelden:

@smallexample
@group
(length '(boterbloem))
     @result{} 1
@end group

@group
(length '(madelief boterbloem))
     @result{} 2
@end group

@group
(length (cons 'viool '(madelief boterbloem)))
     @result{} 3
@end group
@end smallexample

@noindent
In het derde voorbeeld is de functie @code{cons} gebruikt om een lijst met
drie elementen te construeren die daarna als argument wordt doorgegeven aan
de functie @code{length}.

@need 1200
We kunnen @code{length} ook gebruiken om het aantal elementen in een lege
lijst te tellen:

@smallexample
@group
(length ())
     @result{} 0
@end group
@end smallexample

@noindent
Zoals je zou verwachten is het aantal elementen van een lege lijst nul.

Een interessant experiment is te ontdekken wat gebeurt wanneer je probeert
de lengte van totaal geen lijst te achterhalen, dus als je probeert
@code{length} zonder enig argument aan te roepen, zelfs geen lege lijst.

@smallexample
(length )
@end smallexample

@need 800
@noindent
Wat je ziet als je dit evalueert is de foutmelding

@smallexample
Lisp error: (wrong-number-of-arguments length 0)
@end smallexample

@noindent
Dit betekent dat de functie een verkeerd aantal argumenten krijgt, nul,
terwijl het een ander aantal argumenten verwacht. In dit geval wordt één
argument verwacht, een argument dat een lijst is wiens lengte de functie
moet meten. (Merk op dat @emph{één} lijst @emph{één} argument is, zelfs als
de lijst veel elementen in zich heeft.)

Het deel van de foutmelding dat @samp{length} zegt, is de naam van de
functie.

@ignore
@code{length} is still a subroutine, but you need C-h f to discover that.

In an earlier version:
    This is written with a special notation, @samp{#<subr},
    that indicates that the function @code{length} is one of the primitive
    functions written in C rather than in Emacs Lisp.  (@samp{subr} is an
    abbreviation for ``subroutine''.)  @xref{What Is a Function, , What Is a
    Function?, elisp , The GNU Emacs Lisp Reference Manual}, for more
    about subroutines.
@end ignore

@node nthcdr
@section @code{nthcdr}
@findex nthcdr

De functie @code{nthcdr} is geassocieerd met de functie @code{cdr}. Wat het
doet is dat het herhaaldelijk de @sc{cdr} van een lijst neemt.

Wanneer je de @sc{cdr} van de lijst @code{(den spar eik esdoorn)} neemt,
krijg je de lijst @code{(spar eik esdoorn)}. Wanneer je dit herhaalt op wat
je terugkreeg, krijg je de lijst @code{(eik esdoorn)} terug. (Als je
herhaaldelijk de @sc{cdr} van de originele lijst neemt, dan krijg je
natuurlijk de originele @sc{cdr} terug, omdat deze functie de lijst niet
verandert. Je moet de @sc{cdr} van de @sc{cdr} nemen, enzovoort.) Wanneer je
hiermee doorgaat, dan krijg je uiteindelijk de lege lijst terug, welke in
dit geval in plaats van @code{()} getoond wordt als @code{nil}.

@need 1200
Ter beoordeling is hier een lijst van herhaaldelijke @sc{cdr}'s, de tekst
volgend op @samp{@result{}} toont wat wordt teruggegeven.

@smallexample
@group
(cdr '(den spar eik esdoorn))
     @result{} (spar eik esdoorn)
@end group

@group
(cdr '(spar eik esdoorn))
     @result{} (eik esdoorn)
@end group

@group
(cdr '(eik esdoorn))
     @result{} (esdoorn)
@end group

@group
(cdr '(esdoorn))
     @result{} nil
@end group

@group
(cdr 'nil)
     @result{} nil
@end group

@group
(cdr ())
     @result{} nil
@end group
@end smallexample

@need 1200
Het is ook mogelijk meerdere @sc{cdr}'s te doen zonder de waarden er tussen
te tonen.

@smallexample
@group
(cdr (cdr '(den spar eik esdoorn)))
     @result{} (eik esdoorn)
@end group
@end smallexample

@noindent
in dit voorbeeld evalueert de Lisp interpreter eerst de binnenste lijst. De
binnenste lijst is gequote, en geeft dus de lijst zoals die is door aan de
binnenste @code{cdr}. Deze @code{cdr} geeft de lijst, bestaande uit het
tweede en volgende elementen van de lijst door aan de buitenste @code{cdr},
die de lijst produceert die bestaat uit het derde en volgende elementen van
de oorspronkelijke lijst. In dit voorbeeld wordt de @code{cdr} herhaald en
geeft een lijst terug die bestaat uit de oorspronkelijke lijst zonder de
eerste twee elementen.

De functie @code{nthcdr} doet hetzelfde als een herhaalde aanroep van
@code{cdr}. In het volgende voorbeeld wordt het argument 2 doorgegeven aan
de functie @code{nthcdr}, samen met de lijst, en de teruggegeven waarde is
de lijst zonder de eerste twee elementen, wat exact hetzelfde is als twee
keer @code{cdr} herhalen op de lijst.

@smallexample
@group
(nthcdr 2 '(den spar eik esdoorn))
     @result{} (eik esdoorn)
@end group
@end smallexample

@need 1200
Je kunt met de oorspronkelijke lijst van vier elementen zien wat gebeurt
wanneer je verschillende numerieke argumenten doorgeeft aan @code{nthcdr},
waaronder 0, 1 en 5:

@smallexample
@group
;; @r{Houd de lijst zoals die was.}
(nthcdr 0 '(den spar eik esdoorn))
     @result{} (den spar eik esdoorn)
@end group

@group
;; @r{Geef een exemplaar terug zonder eerste element.}
(nthcdr 1 '(den spar eik esdoorn))
     @result{} (spar eik esdoorn)
@end group

@group
;; @r{Geef een exemplaar terug zonder drie elementen.}
(nthcdr 3 '(den spar eik esdoorn))
     @result{} (esdoorn)
@end group

@group
;; @r{Geef een exemplaar terug waar alle vier elementen ontbreken.}
(nthcdr 4 '(den spar eik esdoorn))
     @result{} nil
@end group

@group
;; @r{Geef een exemplaar terug zonder alle elementen.}
(nthcdr 5 '(den spar eik esdoorn))
     @result{} nil
@end group
@end smallexample

@node nth
@section @code{nth}
@findex nth

De functie @code{nthcdr} neemt herhaaldelijk de @sc{cdr} van een lijst. De
functie @code{nth} neemt de @sc{car} van het resultaat dat door
@code{nthcdr} wordt teruggegeven. Het geeft het N-de element van de lijst
terug.

@need 1500
Dus, als het, in verband met de snelheid, niet in C zou zijn gedefinieerd
zou dit de definitie van @code{nth} zijn:

@smallexample
@group
(defun nth (n list)
  "Returns the Nth element of LIST.
N counts from zero.  If LIST is not that long, nil is returned."
  (car (nthcdr n list)))
@end group
@end smallexample

@noindent
(Oorspronkelijk was @code{nth} gedefinieerd in Emacs Lisp in @file{subr.el},
maar de definitie was in de jaren tachtig opnieuw gedaan in C.)

De functie @code{nth} geeft een enkel element van een lijst terug. Dit kan
erg handig zijn.

Merk op de de elementen vanaf nul zijn genummerd, niet een. Dat wil zeggen
dat het eerste element van een lijst, zijn @sc{car}, is het nulde
element. Deze nul-gebaseerde telling is lastig voor mensen die gewend zijn
die gewend zijn dat het eerste element in een lijst nummer een is, wat
een-gebaseerd is.

@need 1250
Bijvoorbeeld:

@smallexample
@group
(nth 0 '("een" "twee" "drie"))
    @result{} "een"

(nth 1 '("een" "twee" "drie"))
    @result{} "twee"
@end group
@end smallexample

Het is waardevol op te merken dat @code{nth}, net als @code{nthcdr} en
@code{cdr}, de oorspronkelijke lijst niet verandert---de functie is
niet-destructief. Dit is in scherp contrast met de functies @code{setcar} en
@code{setcdr}.

@node setcar
@section @code{setcar}
@findex setcar

Zoals je wellicht door hun namen vermoedt, stellen de functies @code{setcar}
en @code{setcdr} de @sc{car} of de @sc{cdr} van een lijst in op een nieuwe
waarde. Zij wijzigen echt de oorspronkelijke lijst, in tegenstelling tot
@code{car} en @code{cdr} die de oorspronkelijke lijst laten zoals die
was. Een manier om te ontdekken hoe dit werkt is door te proberen. Wij
beginnen met de functie @code{setcar}.

@need 1200
Eerst maken we een lijst en stellen die met de speciale vorm @code{setq} als
de waarde in van een variabele. Omdat we van plan zijn @code{setcar} te
gebruiken om de lijst te wijzigen, moet deze @code{setq} geen gebruik van de
gequote vorm @code{'(antiloop giraf leeuw tijger)} maken, omdat dit een
lijst oplevert die onderdeel van het programma is en slechte dingen zouden
kunnen gebeuren wanneer we proberen een deel van het programma te wijzigen
terwijl dat loopt. In het algemeen moeten de componenten van een Emacs Lisp
programma constant zijn (of ongewijzigd) terwijl het programma loopt. In
plaats daarvan construeren we daarom als volgt een lijst met de functie
@code{list}:

@smallexample
(setq dieren (list 'antiloop 'giraf 'leeuw 'tijger))
@end smallexample

@noindent
Wanneer je dit in Info binnen GNU Emacs leest kan je deze expressie op de
gebruikelijke manier evalueren, door de cursor achter de expressie te
plaatsen en @kbd{C-x C-e} te typen. (Ik doe dat meteen hier terwijl ik dit
schrijft. Dat is een van de voordelen van een in je computer omgeving
ingebouwde interpreter Overigen, wanneer is niets op de regel na het laatste
haakje staat, zoals commentaar, kan point ook de volgende regel staan. Dus
als point op de eerste kolom van de regel staat, hoef je die niet te
verplaatsten. Emacs staat zelfs een willekeurige hoeveelheid witte ruimte
achter het laaste haakje toe.)

@need 1200
Wanneer we de variabele @code{dieren} evalueren dan zien we dat die gebonden
is aan de lijst @code{(antiloop giraf leeuw tijger)}:

@smallexample
@group
dieren
     @result{} (antiloop giraf leeuw tijger)
@end group
@end smallexample

@noindent
Anders gezegd, de variabele @code{dieren} wijst naar de lijst
@code{(antiloop giraf leeuw tijger)}.

Vervolgens evalueren we de functie @code{setcar} terwijl we daar twee
argumenten aan doorgeven, de variabele @code{dieren} en het geqoute symbool
@code{nijlpaard}. Dit doen we door de lijst van drie elementen @code{(setcar
dieren 'nijlpaard)} te schrijven en die dan op de gebruikelijke manier te
evalueren.

@smallexample
(setcar dieren 'nijlpaard)
@end smallexample

@need 1200
@noindent
Na het evalueren van deze expressie, evalueer je de variabele @code{dieren}
nogmaals. Je zult zien dat de lijst gewijzigd is:

@smallexample
@group
dieren
     @result{} (nijlpaard giraf leeuw tijger)
@end group
@end smallexample

@noindent
Het eerste element van de lijst, @code{antiloop} is vervangen met
@code{nijlpaard}.

We zien dus dat @code{setcar} geen nieuw element aan de lijst heeft
toegevoegd, wat @code{cons} gedaan zou hebben, maar het verving
@code{antiloop} met @code{nijlpaard}. Het @emph{wijzigde} de lijst.

@node setcdr
@section @code{setcdr}
@findex setcdr

De functie @code{setcdr} is vergelijkbaar met de functie @code{setcar},
behalve dat de functie de tweede en volgende elementen van een lijst
vervangt in plaats van het eerste element.

(Kijk vooruit naar @ref{kill-new functie, , De @code{kill-new} functie} om
te zien hoe het laatste element van een list te wijzigen. De @code{kill-new}
functie gebruikt de @code{nthcdr} en de @code{setcdr} functies.)

@need 1200
Om de zien hoe dit werkt stel je waarde van de variabele in op een lijst van
gedomesticeerde dieren door de volgende expressie te evalueren:

@smallexample
(setq gedomesticeerde-dieren (list 'paard 'koe 'schaap 'gijt))
@end smallexample

@need 1200
@noindent
Wanneer je nu de lijst evalueert, krijg je de lijst @code{(paard koe schaap
gijt)} terug.

@smallexample
@group
gedomesticeerde-dieren
     @result{} (paard koe schaap gijt)
@end group
@end smallexample

@need 1200
Evalueer vervolgens @code{setcdr} met twee argumenten, de naam van de
variabele die een lijst als waarde heeft, en de lijst waarop we de @sc{cdr}
van de eerste lijst willen instellen:

@smallexample
(setcdr gedomesticeerde-dieren '(kat hond))
@end smallexample

@noindent
Wanneer je deze expressie evalueert verschijnt de lijst @code{(kat hond)} in
het echogebied. Dit is de waarde die de functie teruggaf. Het resultaat waar
wij in geïnteresseerd zijn is in het zij-effect, wat we kunnen zien wanneer
we de variabele @code{gedomesticeerde-dieren} evalueren:

@smallexample
@group
gedomesticeerde-dieren
     @result{} (paard kat hond)
@end group
@end smallexample

@noindent
Inderdaad is de lijst gewijzigd van @code{(paard koe schaap gijt)} naar
@code{(paard kat hond)}. De @sc{cdr} van de lijst is gewijzigd van
@code{(koe schaap gijt)} naar @code{(kat hond)}.

@node cons oefening
@section Oefening

Construeer een lijst met vier vogels door verschillende expressies met
@code{cons} te evalueren. Ontdek wat gebeurt wanneer je een lijst met
zichzelf @code{const}-t. Vervang het eerste element van de lijst met vier
vogels met een vis. Vervang de rest van de lijst met een lijst van andere
vissen.

@node Knippen en opslaan van tekst
@chapter Tekst knippen en opslaan
@cindex Tekst knippen en opslaan
@cindex Tekst opslaan en knippen
@cindex Tekst killen
@cindex Text clippen
@cindex Tekst wissen
@cindex Tekst deleten

Steeds als je in GNU Emacs tekst uit een buffer snijdt op clipt met een
@dfn{kill} commando, wordt het bewaard in een lijst en kan je het terughalen
met een @dfn{yank} commando.

(Het gebruik van het woord ``kill'' in Emacs voor processen die @emph{niet}
specifiek de waarden van de entiteiten vernietigen), is een ongelukkig
historisch ongeluk. Een veel beter word zou ``clip'' zijn, omdat dat is wat
kill commando's doen. Zij clippen tekst uit het buffer en bergen dat in een
opslagplaats op van waar het teruggebracht kan worden. Ik ben vaak in de
verleiding gekomen om overal waar ``kill'' voorkomt in de Emacs broncode dat
met ``clip'' te vervangen en overal waar ``killed'' voorkomt met
``clipped''.)

@menu
* Tekst opslaan::            Tekst wordt opgeslagen in een lijst.
* zap-to-char::              Tekst tot aan een karakter knippen.
* kill-region::              Tekst uit een gebied knippen.
* copy-region-as-kill::      Een definitie van tekst kopiëren.
* Uitwijding naar C::        Kleine opmerking over C programmeertaal macros.
* defvar::                   Hoe een variabele een initiële waarde te geven.
* cons en search-fwd terugblik::  cons en search-fwd terugblik
* zoek oefening::            zoek oefening
@end menu

@ifnottex
@node Tekst opslaan
@unnumberedsec Tekst in een lijst opslaan
@end ifnottex

Wanneer tekst uit een buffer wordt gesneden, wordt het in een lijst
opgeslagen. Opvolgende stukken tekst worden in de lijst opeenvolgend
opgeslagen, zodat de lijst er zo uit kan zien:

@smallexample
("een stuk tekst" "vorig stuk")
@end smallexample

@need 1200
@noindent
De functie @code{cons} kan gebruikt worden om een nieuwe lijst te maken van
een stuk tekst (een ``atoom'', om het jargon te gebruiken) en een bestaande
lijst, zoals hier:

@smallexample
@group
(cons "nog een stuk"
      '("een stuk tekst" "vorig stuk"))
@end group
@end smallexample

@need 1200
@noindent
Wanneer je deze expressie evalueert, verschijnt een lijst met drie elementen
in het echogebied:

@smallexample
("nog een stuk" "een stuk tekst" "vorig stuk")
@end smallexample

Met de functies @code{car} en @code{nthcdr} haal je een willekeurig stuk
tekst naar keuze op. Bijvoorbeeld, in de volgende code geeft @code{nthcdr 1
@dots{}} de lijst met eerste element verwijderd terug, en de @code{car}
geeft het eerst element van de rest terug---het tweede element van de
oorspronkelijke lijst:

@smallexample
@group
(car (nthcdr 1 '("nog een stuk"
                  "een stuk tekst"
                  "vorig stuk")))
      @result{} "een stuk tekst"
@end group
@end smallexample

De echte functies in Emacs zijn natuurlijk meer complex dan dit. De code
voor het snijden en terughalen van tekst moet zo zijn geschreven dat Emacs
kan uitzoeken welk element in de lijst je wilt---eerste, tweede, derde, of
welke dan ook. Verder, wanneer je aan het einde van lijst komt, moet Emacs
je het eerste element van de lijst geven, in plaats van helemaal niets.

De lijst die de stukken tekst bevat het de @dfn{killring}. Dit hoofdstuk
werkt naar een beschijving van de killring toe en hoe die gebruikt wordt
door eerst te volgen hoe de functie @code{zap-to-char} werkt. Deze functie
roept een functie aan die een functie start die de killring
manipuleert. Dus, voordat we de bergen bereiken, beklimmen we eerst de
voetheuvels.

Een volgend hoofdstuk beschrijft hoe tekst dat uit het buffer is gesneden
wordt teruggehaald. @xref{Yanking, , Tekst terug yanken}.

@node zap-to-char
@section @code{zap-to-char}
@findex zap-to-char

Laten we naar de interactieve functie @code{zap-to-char} kijken.

@menu
* Complete zap-to-char::     De complete implementatie.
* zap-to-char interactief::  Een driedelige iteractive expressie.
* zap-to-char body::         Een kort overzicht.
* search-forward::           Hoe naar een string te zoeken.
* progn::                    De @code{progn} speciale vorm.
* Samenvatting zap-to-char::  Gebruik @code{point} en @code{search-forward}.
@end menu

@ifnottex
@node Complete zap-to-char
@unnumberedsubsec De complete @code{zap-to-char} implementatie
@end ifnottex

De functie @code{zap-to-char} verwijdert de tekst in de region tussen de
lokatie van de cursor (dus van point) tot en met waar het gespecificeerde
karakter verschijnt. De tekst die @code{zap-to-char} verwijdert wordt in de
killring gestopt en het kan uit de killring worden opgehaald door @kbd{C-y}
(@code{yank}) te typen.

Wanneer het gespecificeerde karakter niet gevonden is, zegt
@code{zap-to-char} ``Search failed'', en welk karakter je typte, en
verwijdert geen tekst.

Om vast te stellen hoeveel tekst te verwijderen, gebruikt @code{zap-to-char}
een zoekfunctie. Zoeken wordt extensief gebruikt in code die tekst
manipuleert, en wij zullen aandacht aan ze besteden, net als aan de delete
commando's.

@ignore
@c GNU Emacs version 19
(defun zap-to-char (arg char)  ; version 19 implementation
  "Kill up to and including ARG'th occurrence of CHAR.
Goes backward if ARG is negative; error if CHAR not found."
  (interactive "*p\ncZap to char: ")
  (kill-region (point)
               (progn
                 (search-forward
                  (char-to-string char) nil nil arg)
                 (point))))
@end ignore

@need 1250
Hier is de complete tekst van de vesie 22 implementatie van de functie:

@c GNU Emacs 22
@smallexample
@group
(defun zap-to-char (arg char)
  "Kill up to and including ARG'th occurrence of CHAR.
Case is ignored if `case-fold-search' is non-nil in the current buffer.
Goes backward if ARG is negative; error if CHAR not found."
  (interactive "p\ncZap to char: ")
  (if (char-table-p translation-table-for-input)
      (setq char (or (aref translation-table-for-input char) char)))
  (kill-region (point) (progn
                         (search-forward (char-to-string char)
                                         nil nil arg)
                         (point))))
@end group
@end smallexample

De documentatie is grondig. Je moet weten wat in het jargon het woord
``kill'' betekent.

@cindex gebogen aanhalingstekens
@cindex gebogen aanhalingstekens
The version 22 documentation string for @code{zap-to-char} uses ASCII grave
accent and apostrophe to quote a symbol, so it appears as
@t{`case-fold-search'}.  This quoting style was inspired by 1970s-era
displays in which grave accent and apostrophe were often mirror images
suitable for use as quotes.  On most modern displays this is no longer true,
and when these two ASCII characters appear in documentation strings or
diagnostic message formats, Emacs typically transliterates them to
@dfn{curved quotes} (left and right single quotation marks), so that the
abovequoted symbol appears as @t{‘case-fold-search’}.  Source-code strings
can also simply use curved quotes directly.

@node zap-to-char interactief
@subsection De @code{interactive} expressie

@need 800
De interactive expressie in het @code{zap-to-char} commando ziet er zo uit:

@smallexample
(interactive "p\ncZap to char: ")
@end smallexample

Het gedeelte tussen de aanhalingstekens, @code{"p\ncZap to char:@: "},
specificeert twee verschillende dingen. Het eerste en meest eenvoudige is de
@samp{p}. Dit deel is met een nieuwe regelteken @samp{\n} gescheiden van het
volgende deel. Het @samp{p} betekent dat het eerste argument van de functie
de waarde van een @dfn{processed prefix} doorgeeft. Het prefix-argument
wordt doorgegeven door @kbd{C-u} en een getal te typen, of @kbd{M-} en een
cijfer. Wanneer een functie interactief wordt aangeroepen zonder een prefix,
dan wordt 1 als argument doorgegeven.

Het tweede deel van @code{"p\ncZap to char:@: "} is @samp{cZap to char:@:
}. In dit deel geeft de kleine letter @samp{c} aan dat @code{interactive}
een prompt verwacht en dat het argument een karakter is. De prompt volgt op
de @samp{c} en is de string @samp{Zap to char:@: } (met een spatie achter de
dubbele punt zodat het er goed uitziet.)

Dit alles bereidt de argumenten van @code{zap-to-char} voor, zodat die van
het juiste type zijn en de gebruiker een prompt geven.

In een read-only buffer kopieert de functie @code{zap-to-char} de tekst naar
de killring, maar verwijdert die niet. Het echogebied toont een boodschap
dat het buffer read-only is. Ook kan de terminal piepen of knipperen.

@node zap-to-char body
@subsection De body van @code{zap-to-char}

De body van de functie @code{zap-to-char} bevat code die de tekst in de
region van de huidige cursorpositie tot en met het gespecificeerde karakter
killt (dat wil zeggen, verwijdert).

Het eerste deel van de code ziet er zo uit:

@smallexample
(if (char-table-p translation-table-for-input)
    (setq char (or (aref translation-table-for-input char) char)))
(kill-region (point) (progn
                       (search-forward (char-to-string char) nil nil arg)
                       (point)))
@end smallexample

@noindent
@code{char-table-p} functie zien we voor het eerst. Het stelt vast of het
argument een karakter-tabel is. Wanneer dat het geval is, dan stelt die het
karakter was aan @code{zap-to-char} wordt doorgegeven aan een van hen
in. (Dit is belangrijk voor bepaalde karakters in niet-Europese talen. De
functie @code{aref} extraheert een element uit een array. Het is een
array-specifieke functie die we in dit document niet
bespreken. @xref{Arrays, , Arrays, elisp, The GNU Emacs Lisp Reference
Manual}.)

@noindent
@code{(point)} is de huidige cursorpositie.

Het volgende deel van de code is een expressie met @code{progn}. De body van
de @code{progn} bestaat uit aanroepen van @code{search-forward} en
@code{point}.

Het is eenvoudiger te begrijpen hoe @code{progn} werkt nadat we
@code{search-forward} bestudeerd hebben, dus we kijken eerst naar
@code{search-forward} en dan naar @code{progn}.

@node search-forward
@subsection De functie @code{search-forward}
@findex search-forward

De functie @code{search-forward} wordt @code{zap-to-char} gebruikt het
zapped-for-karakter te vinden. Wanneer het zoeken succesvol is, zet
@code{search-forward} point onmiddellijk achter het laatste karakter in de
doelstring. (In @code{zap-to-char} is de doelstring slechts één karakter
lang. @code{zap-to-char} gebruikt de functie @code{char-to-string} om zeker
te stellen dat de computer het karakter als string behandelt.) Wanneer het
zoeken achterwaarts is dan zet @code{search-forward} point onmiddellijk voor
het eerste karakter in het doel. Ook geeft @code{search-forward} @code{t}
terug, voor waar. (Het verplaatsen van point is daarom een zij-effect.)

@need 1250
In @code{zap-to-char} ziet de functie @code{search-forward} er zo uit:

@smallexample
(search-forward (char-to-string char) nil nil arg)
@end smallexample

De functie @code{search-forward} heeft vier argumenten:

@enumerate
@item
Het eerste argument is het doel, waar naar gezocht wordt. Dit moet een
string zijn, zoals @samp{"z"}.

Het argument dat aan @code{zap-to-char} wordt doorgegeven is een enkel
karakter. Door de manier waarop computers zijn gebouwd kan de Lisp
interpreter een enkel karakter anders behandelen dan een string met
karakters. Binnen de computer heeft een enkel karakter een ander
elektronisch formaat dan een string van één karakter. (Een enkel karakter
kan vaak worden opgeslagen als precies één byte, maar een string kan langer
zijn en de computer moet daarop voorbereid zijn.) Omdat de functie
@code{search-forward} naar een string zoekt, moet het karakter dat de
functie @code{zap-to-char} ontvangt in de computer worden geconverteerd van
het ene formaat in het andere, anders faalt de functie
@code{search-forward}. Deze conversie wordt met de functie
@code{char-to-string} gemaakt.

@item
Het tweede argument begrenst het zoeken, het is gespecificeerd als een
positie in het buffer. In dit geval kan het zoeken tot het einde van het
buffer doorgaan, daarom is geen grens bepaald en is het tweede argument
@code{nil}.

@item
Het derde argument vertelt de functie wat het moet doen indien het zoeken
faailt---het kan een fout signaleren (en een boodschap tonen) of het kan
@code{nil} teruggeven. Een @code{nil} als derde argument zorgt dat de
functie een fout signaleert wanneer het zoeken faalt.

@item
Het vierde argument van @code{search-forward} is het aantal te
herhalen---naar hoe veel herhalingen van de string te zoeken. Dit argument
is optioneel en wanneer de functie is aangeroepen zonder dit aantal, wordt
een argument met de waarde 1 doorgegeven. Wanneer dit argument negatief is,
vindt het zoeken achterwaarts plaats.
@end enumerate

@need 800
In slaboonvorm ziet een @code{search-forward} expressie er zo uit:

@smallexample
@group
(search-forward "@var{doel-string}"
                @var{zoeklimiet}
                @var{wat-te-doen-als-zoeken-faalt}
                @var{aantal-herhalingen})
@end group
@end smallexample

We kijken nu naar @code{progn}.

@node progn
@subsection De speciale vorm @code{progn}
@findex progn

De speciale vorm @code{progn} laat elk van zijn argumenten achtereenvolgens
evalueren en geeft daarna de waarde van de laatste terug. De voorgaande
expressies worden uitsluitend geëvalueerd voor de zij-effecten die zij
uitvoeren. De waarden die zij produceren worden weggegooid.

@need 800
Het sjabloon voor een @code{progn} expressie is erg eenvoudig:

@smallexample
@group
(progn
  @var{body}@dots{})
@end group
@end smallexample

In @code{zap-to-char} moet de @code{progn} expressie twee dingen doen: zet
point exact op de juiste positie en geef de locatie van point zodat
@code{kill-region} weet hoe ver het moet killen.

Het eerste argument van de @code{progn} is @code{search-forward}. Wanneer
@code{search-forward} de string vindt, zet het point onmiddellijk achter het
laatste karakter in de doelstring. (In dit geval is de doelstring slechts
één karakter lang.) Wanneer het achterwaarts zoekt zet @code{search-forward}
point onmiddellijk voor het eerste karakter van het doel. Het verplaatsen
van point is een zij-effect.

Het tweede en laatste argument van @code{progn} is de expressie
@code{(point)}. Deze expressie geeft de waarde van point, wat in dit geval
de lokatie is waar het naar verplaatst is door @code{search-forward}. (In de
broncode is een regel die de functie vertelt om naar het voorgaande karakter
te gaan wanneer het voorwaarts gaat, die in 1999 uitgecomment is. Ik kan me
niet herinneren of die eigenschap of onjuiste eigenschap ooit een deel van
de gedistribueerde broncode was.) De waarde van @code{point} wordt
teruggeven door de @code{progn} expressie en wordt doorgegeven aan
@code{kill-region} als het tweede argument van @code{kill-region}.

@node Samenvatting zap-to-char
@subsection @code{zap-to-char} samengevat

Nu dat we hebben gezien hoe @code{search-forward} en @code{progn} werken,
kunnen we zien hoe de functie @code{zap-to-char} als geheel werkt.

Het eerste argument voor @code{kill-region} is de cursorpositie op het
moment dat het @code{zap-to-char} commando werd gegeven. Binnen @code{progn}
verplaatst de zoekfunctie vervolgens point naar onmiddellijk achter het
zapped-to-character en @code{point} geeft de waarde van deze lokatie
terug. De @code{kill-region} voegt deze twee waarden van point, het eerste
als het begin van de region en en de tweede als einde van de region, en
verwijdert de region.

De speciale vorm @code{progn} is noodzakelijk omdat het @code{kill-region}
twee argumenten verwacht, en het zou falen wanneer de @code{search-forward}
en @code{point} expressies als twee opeenvolgende argumenten geschreven
zouden worden. De @code{progn} expressie is een enkel argument voor
@code{kill-region} en geeft de ene waarde terug die @code{kill-region} nodig
heeft als tweede argument.

@node kill-region
@section @code{kill-region}
@findex kill-region

De functie @code{zap-to-char} gebruikt de @code{kill-region}. Deze functie
clipt de tekst van een region en kopieert die tekst naar de killring, van
waar het kan worden opgehaald.

@ignore
GNU Emacs 22:

(defun kill-region (beg end &optional yank-handler)
  "Kill (\"cut\") text between point and mark.
This deletes the text from the buffer and saves it in the kill ring.
The command \\[yank] can retrieve it from there.
\(If you want to kill and then yank immediately, use \\[kill-ring-save].)

If you want to append the killed region to the last killed text,
use \\[append-next-kill] before \\[kill-region].

If the buffer is read-only, Emacs will beep and refrain from deleting
the text, but put the text in the kill ring anyway.  This means that
you can use the killing commands to copy text from a read-only buffer.

This is the primitive for programs to kill text (as opposed to deleting it).
Supply two arguments, character positions indicating the stretch of text
 to be killed.
Any command that calls this function is a \"kill command\".
If the previous command was also a kill command,
the text killed this time appends to the text killed last time
to make one entry in the kill ring.

In Lisp code, optional third arg YANK-HANDLER, if non-nil,
specifies the yank-handler text property to be set on the killed
text.  See `insert-for-yank'."
  ;; Pass point first, then mark, because the order matters
  ;; when calling kill-append.
  (interactive (list (point) (mark)))
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))
  (condition-case nil
      (let ((string (filter-buffer-substring beg end t)))
        (when string                        ;STRING is nil if BEG = END
          ;; Add that string to the kill ring, one way or another.
          (if (eq last-command 'kill-region)
              (kill-append string (< end beg) yank-handler)
            (kill-new string nil yank-handler)))
        (when (or string (eq last-command 'kill-region))
          (setq this-command 'kill-region))
        nil)
    ((buffer-read-only text-read-only)
     ;; The code above failed because the buffer, or some of the characters
     ;; in the region, are read-only.
     ;; We should beep, in case the user just isn't aware of this.
     ;; However, there's no harm in putting
     ;; the region's text in the kill ring, anyway.
     (copy-region-as-kill beg end)
     ;; Set this-command now, so it will be set even if we get an error.
     (setq this-command 'kill-region)
     ;; This should barf, if appropriate, and give us the correct error.
     (if kill-read-only-ok
         (progn (message "Read only text copied to kill ring") nil)
       ;; Signal an error if the buffer is read-only.
       (barf-if-buffer-read-only)
       ;; If the buffer isn't read-only, the text is.
       (signal 'text-read-only (list (current-buffer)))))))
@end ignore

De Emacs 22 versie van die functie gebruikt @code{condition-case} en
@code{copy-region-as-kill} die wij beide uitleggen. @code{condition-case} is
een belangrijke speciale vorm.

De functie @code{kill-region} in essentie roept @code{condition-case} aan,
die drie argumenten verwacht. Het eerste argument deze functie doet
niets. Het tweede argument bevat de code die het werk doet als alles goed
gaat. Het derde argument bevat de code die aangeroepen wordt in het geval
van een fout.

@menu
* Complete kill-region::     De functiedefinitie.
* condition-case::           Met een probleem omgaan
* Lisp macro::               Lisp macro
@end menu

@ifnottex
@node Complete kill-region
@unnumberedsubsec De complete @code{kill-region} definitie
@end ifnottex

@need 1200
We gaan zo meteen door de code van @code{condition-case}. Laten we eerst
naar de definitie van @code{kill-region} kijken, met toegevoegd commentaar:

@c GNU Emacs 22:
@smallexample
@group
(defun kill-region (beg end)
  "Kill (\"cut\") text between point and mark.
This deletes the text from the buffer and saves it in the kill ring.
The command \\[yank] can retrieve it from there. @dots{} "
@end group

@group
  ;; @bullet{} Omdat volgorde belangrijk is, geeft eerst point door.
  (interactive (list (point) (mark)))
  ;; @bullet{} En vertel ons wanneer we geen tekst kunnen snijden.
  ;; 'unless' is een 'if' zonder een dan-deel.
  (unless (and beg end)
    (error "The mark is not set now, so there is no region"))
@end group

@group
  ;; @bullet{} 'condition-case' verwacht drie argumenten.
  ;;    Wanneer het eerste argument nil is, zoals hier,
  ;;    wordt information over het fout signaal niet
  ;;    bewaard voor gebruik in een andere functie.
  (condition-case nil
@end group

@group
      ;; @bullet{} Het tweede argument van 'condition-case' vertelt de
      ;;    Lisp interpreter wat te doen als alles goed gaat.
@end group

@group
      ;;    Het start met een 'let' functie die de string extraheert
      ;;    en test of die bestaat. Zo ja (dat is wat de
      ;;    'when' checkt), roept het een 'if' functie aan die vaststelt
      ;;    of het vorige commando een andere aanroep was van
      ;;    'kill-region'; zo ja, wordt de nieuwe tekst achter de
      ;;    vorige tekst geplakt; zo niet dan wordt een andere functie,
      ;;    'kill-new', aangeroepen.
@end group

@group
      ;;    De 'kill-append' functie plakken de nieuwe string en
      ;;    de oude aan elkaar. De 'kill-new' functie voegt tekst in als een
      ;;    nieuw item in de killring.
@end group

@group
      ;;    'when' is een 'if' zonder een dan-deel.  De tweede 'when'
      ;;    controleert opnieuw of de bestaande string bestaat;
      ;;    daarnaast, controleert het of het vorige commando een
      ;;    andere aanroep van 'kill-region' was.  Wanneer een van beide
      ;;    condities waar zijn, dan stelt het het huidige commando in
      ;;    op 'kill-region'.
@end group
@group
      (let ((string (filter-buffer-substring beg end t)))
        (when string                    ;STRING is nil if BEG = END
          ;; Voeg die string op of andere manier aan de killring toe.
          (if (eq last-command 'kill-region)
@end group
@group
              ;;    @minus{} 'yank-handler' is een optional argument van
              ;;    'kill-region' dat aan de functies 'kill-append' en
              ;;    'kill-new' hoe om te gaan met eigenschappen toegevoegd
              ;;    aan de tekst, zoals 'bold' of 'italics'.
              (kill-append string (< end beg) yank-handler)
            (kill-new string nil yank-handler)))
        (when (or string (eq last-command 'kill-region))
          (setq this-command 'kill-region))
        nil)
@end group

@group
    ;;  @bullet{} Het derde argument van 'condition-case' vertelt de interpreter
    ;;    hoe om te gaan met een fout.
@end group
@group
    ;;    Het derde argument heeft een condities deel en een body deel.
    ;;    Wanneer aan de condities is voldaan (in dit geval,
    ;;             wanneer tekst of buffer read-only zijn)
    ;;    dan wordt de body uitgevoerd.
@end group
@group
    ;;    The first part of the third argument is the following:
    ((buffer-read-only text-read-only) ;; the if-part
     ;; @dots{}  the then-part
     (copy-region-as-kill beg end)
@end group
@group
     ;;    Vervolgens, dus als deel van het dan-deel, zet this-command, zodat
     ;;    het wordt gebruikt in geval van een fout
     (setq this-command 'kill-region)
     ;;    Tenslotte, in het dan-deel, stuur een boodschap wanneer je de
     ;;    tekst niet naar de the killring kan kopiëren zonder een fout te signaleren
     ;;    maar doe dat niet als je het niet mag.
@end group
@group
     (if kill-read-only-ok
         (progn (message "Read only text copied to kill ring") nil)
       (barf-if-buffer-read-only)
       ;; Als het buffer niet read-only is, is de tekst.
       (signal 'text-read-only (list (current-buffer)))))))
@end group
@end smallexample

@ignore
@c v 21
@smallexample
@group
(defun kill-region (beg end)
  "Kill between point and mark.
The text is deleted but saved in the kill ring."
  (interactive "r")
@end group

@group
  ;; 1. 'condition-case' verwacht drie argumenten.
  ;;    Als het eerste argument nil is, zoals hier,
  ;;    wordt informatie over het foutsignaal niet
  ;;    opgeslagen ter gebruik door een andere functie.
  (condition-case nil
@end group

@group
      ;; 2. The tweede argument voor 'condition-case'
      ;;    vertelt de Lisp interpreter wat te doen als alles goed gaat.
@end group

@group
      ;;    De functie 'delete-and-extract-region' doet meestal het werk.      ;;    Wanneer het begin en eind van de region hetzelfde zijn,      ;;    dan is de variable 'string' leeg of nil
      (let ((string (delete-and-extract-region beg end)))
@end group

@group
        ;; 'when' is an 'if' clause that cannot take an 'else-part'.
        ;; Emacs normally sets the value of 'last-command' to the
        ;; previous command.
@end group
@group
        ;; 'kill-append' plakt de nieuwe en de oude string aan elkaar.
        ;; 'kill-new' voegt tekst in in een item in de killring.
        (when string
          (if (eq last-command 'kill-region)
              ;; wanneer waar, append string
              (kill-append string (< end beg))
            (kill-new string)))
        (setq this-command 'kill-region))
@end group

@group
    ;; 3. Het derde argument van 'condition-case' vertelt de interpreter
    ;;    hoe met een fout om te gaan.
@end group
@group
    ;;    Het derde argument heeft een condities deel en een body deel.
    ;;    Wanneer aan de condities is voldaan (in dit geval,
    ;;             wanneer tekst of buffer read-only zijn)
    ;;    dan wordt de body uitgevoerd.
@end group
@group
    ((buffer-read-only text-read-only) ;; dit is het if-deel
     ;; then...
     (copy-region-as-kill beg end)
@end group
@group
     (if kill-read-only-ok            ;; deze variabele is meestal nil
         (message "Read only text copied to kill ring")
       ;; anders, signaleer een fout als het buffer read-only is;
       (barf-if-buffer-read-only)
       ;; en, in ieder geval, signaleer dat de text read-only is.
       (signal 'text-read-only (list (current-buffer)))))))
@end group
@end smallexample
@end ignore

@node condition-case
@subsection @code{condition-case}
@findex condition-case

Wanneer de Emacs Lisp interpreter problemen heeft met het evalueren van een
expressie dat geeft het je hulp, zoals we eerder gezien hebben
(@pxref{Fouten maken, , Een foutboodschap genereren}). In het jargon heet
dit ``een fout signaleren''. Meestal stopt de computer het programma en
toont je een boodschap.

Sommige programma's voeren echter gecompliceerde acties uit. Zij moeten bij
een fout niet stoppen. In de functie @code{kill-region} is de meest voor de
hand liggende fout dat je probeert tekst te killen die read-only is en niet
kan worden verwijderd. De functie @code{kill-region} bevat daarom code om
met deze situatie om te gaan. Deze code in de body van de functie
@code{kill-region} bevindt zich in een speciale vorm @code{condition-case}.

@need 800
Het sjabloon voor @code{condition-case} ziet er zo uit:

@smallexample
@group
(condition-case
  @var{var}
  @var{bodyform}
  @var{error-handler}@dots{})
@end group
@end smallexample

Het tweede argument, @var{bodyform} is eenvoudig. De speciale vorm
@code{condition-case} laat de Lisp interpreter de code in @var{bodyform}
evalueren.

Kort gezegd, het @var{bodyform}-deel van een @code{condition-case} expressie
bepaalt wat moet gebeuren wanneer alles correct werkt.

Echter, wanneer een fout optreedt, definieert de functie, die naast zijn
andere activiteiten het foutsignaal genereert, een of meer conditienamen.

Een error-handler is het derde argument van @code{condition-case}. Een
error-handler heeft twee delen, een @var{conditienaam} en een
@var{body}. Wanneer het @var{conditienaam}-deel van de error-handler
overeenkomt met de conditienaam gegeneerd door een fout, dan wordt het
@var{body}-deel van de error-handler uitgevoerd.

Zoals je zou verwachten kan het @var{conditienaam}-deel van de error-handler
een enkele conditienaam zijn of een lijst met conditienamen.

Een complete @code{condition-case} expressie kan dus meer dan één
error-handler bevatten. Wanneer een fout optreedt, wordt de eerst toepasbare
handler uitgevoerd.

Tenslotte, het eerste argument van de @code{condition-case} expressie, het
@var{var} argument is soms gebonden aan een variabele die informatie over de
fout bevat. Wanneer dat argument echter @code{nil} is, zoals dat bij
@code{kill-region} het geval is, wordt die informatie genegeerd.

@need 1200
In het kort, in de functie @code{kill-region} werkt de code
@code{condition-case} als volgt:

@smallexample
@group
@var{If geen errors}, @var{voer alleen deze code uit}
    @var{maar}, @var{if errors}, @var{voer deze andere code uit}.
@end group
@end smallexample

@ignore
2006 Oct 24
In Emacs 22,
copy-region-as-kill is short, 12 lines, and uses
filter-buffer-substring, which is longer, 39 lines
and has delete-and-extract-region in it.
delete-and-extract-region is written in C.

see Initializing a Variable with @code{defvar}
this is line 8054
Initializing a Variable with @code{defvar} includes line 8350
@end ignore

@node Lisp macro
@subsection Lisp macro
@cindex Macro, lisp
@cindex Lisp macro

Het deel van de @code{condition-case} expressie die wordt geëvalueerd in de
verwachting dat alles goed gaat heeft een @code{when}. De code stelt met
@code{when} of de variabele @code{string} naar bestaande tekst wijst.

Een @code{when}-expressie maakt het de programmeur makkelijker. Het is als
een @code{if}, zonder de mogelijkheid van een anders-clausule. In je
gedachten kun je @code{when} met @code{if} vervangen om te begrijpen wat er
gebeurt. Dat is wat de Lisp interpreter doet.

Technisch gesproken is @code{when} een Lisp macro. Een Lisp macro stelt je
in staat nieuwe control-constructies en andere taaleigenschappen te
definieren. Het vertelt de interpreter hoe het een andere Lisp expressie te
berekenen die op zijn beurt de waarde berekend. In dit geval is de andere
expressie een @code{if} expressie.

De @code{kill-region} functiedefinitie heeft ook een @code{unless}
macro. Dit is het tegenovergestelde van @code{when}. De @code{unless} macro
is net als @code{if}, behalve dat het geen dan-clausule heeft, en het
verstrekt daarvoor een impliciete @code{nil}.

Voor meer over Lisp macro's, zie @ref{Macros, , Macros, elisp, The GNU Emacs
Lisp Reference Manual}. De programmeertaal C vertrekt ook macro's. Deze zijn
anders, maar ook nuttig.

@ignore
We will briefly look at C macros in
@ref{Digression into C}.
@end ignore

@need 1200
Ten aanzien van de @code{when} macro, wanneer de string in de
@code{condition-case} expressie een inhoud heeft, dat wordt een andere
conditionele expressie uitgevoerd. Dit is een @code{if} met zowel een
dan-deel en een anders-deel. 

@smallexample
@group
(if (eq last-command 'kill-region)
    (kill-append string (< end beg) yank-handler)
  (kill-new string nil yank-handler))
@end group
@end smallexample

Het dan-deel wordt geëvalueerd wanneer het voorgaande commando een andere
aanroep van @code{kill-region} was. Zo niet, dan wordt het anders-deel
geëvalueerd.

@code{yank-handler} is een optioneel argument voor @code{kill-region} dat
aan de functies @code{kill-append} en @code{kill-new} vertelt hoe het met de
eigenschappen moet omgaan die aan de tekst zijn gekoppeld, zoals bold of
italics.

@code{last-command} is een variabele in Emacs die we nog niet eerder gezien
hebben. Steeds wanneer een functie wordt uitgevoerd, stelt Emacs Normaal
gesproken de waarde van @code{last-command} in op het voorgaande commando.

@need 1200
In dit segment van de definitie controleert de @code{if} expressie of het
voorgaande commando @code{kill-region} was. Zo ja, plakt

@smallexample
(kill-append string (< end beg) yank-handler)
@end smallexample

@noindent
een kopie van de nieuw geclipte tekst aan de voorgaande zojuist geclipte
tekst in de killring.

@node copy-region-as-kill
@section @code{copy-region-as-kill}
@findex copy-region-as-kill
@findex nthcdr

De functie @code{copy-region-as-kill} kopieert een region met tekst van een
buffer en (via hetzij @code{kill-append} of @code{kill-new}) bewaart het in
de @code{kill-ring}.

Wanneer je @code{copy-region-as-kill} meteen na een @code{kill-region}
commando aanroept, plakt Emacs de nieuw gekopieerde tekst aan de voorgaande
gekopieerde tekst. Dit betekent dat als je de tekst terug-yankt, je alles
krijgt, van zowel deze als de voorgaande operatie. Anderzijds, wanneer een
ander commando aan de @code{copy-region-as-kill} voorafging, dan kopieert de
functie de tekst in een separaat item in de killring.

@menu
* Complete copy-region-as-kill::  De complete functiedefinitie.
* copy-region-as-kill body::  De body van @code{copy-region-as-kill}.
@end menu

@ifnottex
@node Complete copy-region-as-kill
@unnumberedsubsec De complete @code{copy-region-as-kill} functiedefinitie
@end ifnottex

@need 1200
Hier is de complete tekst van de versie 22 @code{copy-region-as-kill}
functie.

@smallexample
@group
(defun copy-region-as-kill (beg end)
  "Save the region as if killed, but don't kill it.
In Transient Mark mode, deactivate the mark.
If `interprogram-cut-function' is non-nil, also save the text for a window
system cut and paste."
  (interactive "r")
@end group
@group
  (if (eq last-command 'kill-region)
      (kill-append (filter-buffer-substring beg end) (< end beg))
    (kill-new (filter-buffer-substring beg end)))
@end group
@group
  (if transient-mark-mode
      (setq deactivate-mark t))
  nil)
@end group
@end smallexample

@need 800
Zoals gebruikelijk kan deze functie worden gedeeld in componenten:

@smallexample
@group
(defun copy-region-as-kill (@var{argument-list})
  "@var{documentatie}@dots{}"
  (interactive "r")
  @var{body}@dots{})
@end group
@end smallexample

De argumenten zijn @code{beg} en @code{end} en de functie is interactief met
@code{"r"}, dus de twee argumenten moeten refereren aan het begin en eind
van de region. Wanneer je dit document van het begin hebt gelezen, dan is
het begrijpen van deze delen van een functie al bijna routine.

De documentatie is ietwat verwarrend tenzij je herinnert dat het woord
``kill'' een andere betekenis dan gebruikelijk heeft. De Transient Mark en
@code{interprogram-cut-function} commentaren verhelderen bepaalde
zij-effecten.

Nadat je ooit een mark hebt gezet, bevat een buffer altijd een
region. Wanneer je dat wilt, kan je met Transient Mark de region tijdelijk
highlighten. (Niemand wil de region voortdurend gehighlight hebben, dus
Transient Mark mode highlight het alleen op passende momenten. Veel mensen
zetten Transient Mark mode uit, waardoor de region nooit wordt gehighlight.)

Ook kun je in windowing systemen tussen verschillende programma's kopiëren,
snijden en plakken. In het X windowing system bijvoorbeeld is de functie
@code{interprogram-cut-function} @code{x-select-text}, die met het
equivalent voor de Emacs killring van het windowing systeem werkt.

The body of the @code{copy-region-as-kill} function starts with an @code{if}
clause.  What this clause does is distinguish between two different
situations: whether or not this command is executed immediately after a
previous @code{kill-region} command.  In the first case, the new region is
appended to the previously copied text.  Otherwise, it is inserted into the
beginning of the kill ring as a separate piece of text from the previous
piece.

De laatste twee regels van de functie voorkomen highighting van de region
wanneer Transient Mark mode aan staat.

De body van @code{copy-region-as-kill} is bespreking in detail waard.

@node copy-region-as-kill body
@subsection De body van @code{copy-region-as-kill}

De functie @code{copy-region-as-kill} werkt op een vergelijkbare manier als
de functie @code{kill-region}. Beide zijn zo geschreven dat twee of meer
kills op een rij de tekst in een enkele entry combineren. Wanneer je de
tekst van de killring terugyankt, dan krijg alles in een stuk. Bovendien,
kills die voorwaarts vanaf de huidige cursorpositie bewegen worden
toegevoegd aan het einde van de vorige gekopieerde tekst, en commando's die
tekst achterwaarts kopiëren worden aan het begin van de vorige gekopieerde
tekst toegevoegd. Op deze manier blijven de woorden in tekst op de juiste
volgorde.

Net als @code{kill-region}, maakt de functie @code{copy-region-as-kill}
gebruik van de variabele @code{last-command} die het vorige Emacs commando
bijhoudt.

@menu
* last-command en this-command::  last-command en this-command
* kill-append functie::      kill-append functie
* kill-new functie::         kill-new functie
@end menu

@ifnottex
@node last-command en this-command
@unnumberedsubsubsec @code{last-command} en @code{this-command}
@end ifnottex

Wanneer een functie wordt uitgevoerd, stelt Emacs normaalgesproken de waarde
van @code{this-command} in op de functie die wordt uitgevoerd (wat in dit
geval @code{copy-region-as-kill} zou zijn). Tegelijkertijd stelt Emacs de
waarde van @code{last-command} in op de vorige waarde van
@code{this-command}.

In het eerste deel van de body van de functie @code{copy-region-as-kill}
stelt een @code{if} expressie vast of @code{kill-region} de waarde van
@code{last-command} is. Zo ja, dan wordt het dan-deel van de @code{if}
expressie geëvalueerd. Het gebruikt de functie @code{kill-append} om de
tekst die bij deze aanroep gekopieerd is te plakken aan de tekst die al in
het eerste element (the @sc{car}) van de killring staat. Anders, wanneer de
waarde van de @code{last-command} niet @code{kill-region} is, dan voegt de
functie @code{copy-region-as-kill} met functie @code{kill-new} een nieuw
element aan de killring toe.

@need 1250
De @code{if} expressie is als volgt, met @code{eq}:

@smallexample
@group
  (if (eq last-command 'kill-region)
      ;; @r{dan-deel}
      (kill-append  (filter-buffer-substring beg end) (< end beg))
    ;; @r{anders-deel}
    (kill-new  (filter-buffer-substring beg end)))
@end group
@end smallexample

@findex filter-buffer-substring
(De functie @code{filter-buffer-substring} geeft een gefilterde substring
van het buffer, wanneer die er is. Optioneel---de argumenten zijn hier niet,
dus geen enkele wordt uitgevoerd---kan de functie de initiële tekst deleten
of de tekst zonder eigenschappen teruggeven. Deze functie is een vervanging
voor de oudere functie @code{buffer-substring} die al bestond voordat
tekst-eigenschappen werden geïmplementeerd.)

@findex eq @r{(voorbeeld van gebruik)}
@noindent
De functie @code{eq} test of het eerste argument hetzelfde Lisp object is
als het tweede argument. De functie @code{eq} test net als de functie
@code{equal} voor gelijkheid, met het verschil dat deze vaststelt of twee
representaties daadwerkelijk hetzelfde object in de computer zijn, maar met
verschillende namen. @code{equal} stelt vast of de structuur en inhoud van
twee expressies hetzelfde zijn.

Wanneer @code{kill-region} het voorgaande commando was, dan roept de Emacs
Lisp interpreter de functie @code{kill-append} aan.

@node kill-append functie
@unnumberedsubsubsec De functie @code{kill-append}
@findex kill-append

@need 800
De functie @code{kill-append} ziet er zo uit:

@c in GNU Emacs 22
@smallexample
@group
(defun kill-append (string before-p &optional yank-handler)
  "Append STRING to the end of the latest kill in the kill ring.
If BEFORE-P is non-nil, prepend STRING to the kill.
@dots{} "
  (let* ((cur (car kill-ring)))
    (kill-new (if before-p (concat string cur) (concat cur string))
              (or (= (length cur) 0)
                  (equal yank-handler
                         (get-text-property 0 'yank-handler cur)))
              yank-handler)))
@end group
@end smallexample

@ignore
was:
(defun kill-append (string before-p)
  "Append STRING to the end of the latest kill in the kill ring.
If BEFORE-P is non-nil, prepend STRING to the kill.
If `interprogram-cut-function' is set, pass the resulting kill to
it."
  (kill-new (if before-p
                (concat string (car kill-ring))
              (concat (car kill-ring) string))
            t))
@end ignore

@noindent
De functie @code{kill-append} is redelijk eenvoudig. Het gebruikt de functie
@code{kill-new}, zie we straks in meer detail bespreken.

(De functie verschaft ook een optioneel argument die @code{yank-handler}
heet. wanneer aangeroepen vertelt dit argument de functie hoe het met
eigenschappen van de tekst moet omgaan, zoals bold of italics.)

@c !!! bug in GNU Emacs 22 version of  kill-append ?
Het heeft een functie @code{let*} om de waarde van het eerste element van de
killring in te stellen op @code{cur}. (Ik weet niet waarom de functie in
plaats hiervan geen @code{let} gebruikt, slechts één waarde wordt in de
expressie ingesteld. Misschien dat dit een bug is die geen problemen
veroorzaakt?)

Bekijk de conditional die een van de twee argumenten van @code{kill-new}
is. Het gebruikt @code{concat} om de nieuwe tekst aan de @sc{car} van de
kill ring te plakken. Of het vooraan of achteraan de tekst plakt hangt af
van het resultaat van een @code{if} expressie:

@smallexample
@group
(if before-p                            ; @r{if-deel}
    (concat string cur)                 ; @r{dan-deel}
  (concat cur string))                  ; @r{anders-deel}
@end group
@end smallexample

@noindent
Wanneer de region die gekilled wordt vooraf gaat aan de region die in het
vorige commando was gekilled, dan moet het vooraan het materiaal dat in de
vorige kill was bewaard komen en, omgekeerd, wanneer de gekillde tekst volgt
op wat zojuist was gekilled, dan moet het achter die voorgaande tekst
komen. De @code{if} expressie is afhankelijk van het predikaat
@code{before-p} om te bepalen of het de nieuwe bewaarde tekst voor of achter
de voorgaande bewaarde tekst moet plaatsen.

Het symbool @code{before-p} is de naam van een van de argumenten van
@code{kill-append}. Het evalueren van de functie @code{kill-append} bindt
die aan de waarde teruggegeven door de evaluatie van het argument. In dit
geval de expressie @code{(< end beg)}. Deze expressie stelt niet direct vast
of de gekillde tekst voor of na de kill-tekst van het vorige commando
staat. Het stelt vast of de waarde van de variabele @code{end} kleiner is
dan de waarde van de variabele @code{beg}. Wanneer dat zo is, betekent dit
dat de gebruiker hoogstwaarschijnlijk richting het begin van het buffer
beweegt. Het resultaat van het evalueren van de predikaat-expressie,
@code{(< end beg)}, is daardoor waar, en de tekst wordt voor de voorgaande
tekst geplakt. Wanneer anderzijds de waarde van de variabele @code{end}
groter is dan de waarde van de variabele @code{beg}, wordt de tekst aan het
eind van de voorgaande tekst geplakt.

@need 800
Wanneer de nieuw opgeslagen tekst aan de voorzijde komt, wordt de string met
de nieuwe tekst voor de oude tekst geplakt.

@smallexample
(concat string cur)
@end smallexample

@need 1200
@noindent
Maar als de tekst aan de achterzijde komt, wordt de string achter de oude
tekst geplakt.

@smallexample
(concat cur string))
@end smallexample

Om te begrijpen hoe dit werkt, moeten we eerst de functie @code{concat}
bekijken. De functie @code{concat} knoopt twee strings aan elkaar of
verenigt die. Het resultaat is een string. Bijvoorbeeld:

@smallexample
@group
(concat "abc" "def")
     @result{} "abcdef"
@end group

@group
(concat "nieuw "
        (car '("eerste element" "tweede element")))
     @result{} "nieuw eerste element"

(concat (car
        '("eerste element" "tweede element")) " aangepast")
     @result{} "eerste element aangepast"
@end group
@end smallexample

We begrijpen nu @code{kill-append}: het past de inhoud van de killring
aan. De killring is een lijst, elk element daarvan is opgeslagen tekst. De
functie @code{kill-append} gebruikt de functie @code{kill-new} die op zijn
beurt de functie @code{setcar} gebruikt.

@node kill-new functie
@unnumberedsubsubsec De functie @code{kill-new}
@findex kill-new

@need 1200
In versie 22 ziet de functie @code{kill-new} er zo uit:

@smallexample
@group
(defun kill-new (string &optional replace yank-handler)
  "Make STRING the latest kill in the kill ring.
Set `kill-ring-yank-pointer' to point to it.
If `interprogram-cut-function' is non-nil, apply it to STRING.
Optional second argument REPLACE non-nil means that STRING will replace
the front of the kill ring, rather than being added to the list.
@dots{}"
@end group
@group
  (if (> (length string) 0)
      (if yank-handler
          (put-text-property 0 (length string)
                             'yank-handler yank-handler string))
    (if yank-handler
        (signal 'args-out-of-range
                (list string "yank-handler specified for empty string"))))
@end group
@group
  (if (fboundp 'menu-bar-update-yank-menu)
      (menu-bar-update-yank-menu string (and replace (car kill-ring))))
@end group
@group
  (if (and replace kill-ring)
      (setcar kill-ring string)
    (push string kill-ring)
    (if (> (length kill-ring) kill-ring-max)
        (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))
@end group
@group
  (setq kill-ring-yank-pointer kill-ring)
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))
@end group
@end smallexample
@ignore
was:
(defun kill-new (string &optional replace)
  "Make STRING the latest kill in the kill ring.
Set the kill-ring-yank pointer to point to it.
If `interprogram-cut-function' is non-nil, apply it to STRING.
Optional second argument REPLACE non-nil means that STRING will replace
the front of the kill ring, rather than being added to the list."
  (and (fboundp 'menu-bar-update-yank-menu)
       (menu-bar-update-yank-menu string (and replace (car kill-ring))))
  (if (and replace kill-ring)
      (setcar kill-ring string)
    (setq kill-ring (cons string kill-ring))
    (if (> (length kill-ring) kill-ring-max)
        (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))
  (setq kill-ring-yank-pointer kill-ring)
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))
@end ignore

(Merk op dat de functie niet interactief is.)

Zoals gebruikelijk kijken we naar de functie in delen.

De functiedefinitie heeft een optioneel argument @code{yank-handler}, dat
wanneer het aangeroepen wordt vertelt hoe het met de eigenschappen van de
tekst moet omgaan, zoals bold of italics. Dit slaan we over.

@need 1200
De eerste regel van de documentatie is logisch:

@smallexample
Make STRING the latest kill in the kill ring.
@end smallexample

@noindent
Laten voor dit moment de rest van de documentatie overslaan.

@noindent
Laten we ook de initiële @code{if} expressie overslaan en die regels code
met betrekking tot @code{menu-bar-update-yank-menu}. Die leggen we hieronder
uit.

@need 1200
De kritische regels zijn deze:

@smallexample
@group
  (if (and replace kill-ring)
      ;; @r{dan}
      (setcar kill-ring string)
@end group
@group
    ;; @r{anders}
    (push string kill-ring)
@end group
@group
    (if (> (length kill-ring) kill-ring-max)
        ;; @r{voorkom een te lange kill ring}
        (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil)))
@end group
@group
  (setq kill-ring-yank-pointer kill-ring)
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))
@end group
@end smallexample

De conditionele test is @w{@code{(and replace kill-ring)}}. Deze is waar
wanneer twee condities voldoen: de killring bevast iets en de variabele
@code{replace} variable is waar.

@need 1250
Wanneer de functie @code{kill-append} @code{kill-append} op waar instelt en
wanneer de killring tenminste een element bevat, wordt de @code{setcar}
expressie uitgevoerd:

@smallexample
(setcar kill-ring string)
@end smallexample

De functie @code{setcar} wijzigt daadwerkelijk het eerste element van de
@code{kill-ring} lijst in de waarde van @code{string}. Het vervangt het
eerste element.

@need 1250
Aan de andere kant, wanneer de killring leeg, of replace onwaar is, wordt
het anders-deel van de conditie uitgevoerd:

@smallexample
(push string kill-ring)
@end smallexample

@noindent
@need 1250
@code{push} plaatst het eerste argument op het tweede. Het is vergelijkbaar
met het oudere

@smallexample
(setq kill-ring (cons string kill-ring))
@end smallexample

@noindent
@need 1250
of het nieuwere

@smallexample
(add-to-list kill-ring string)
@end smallexample

@noindent
Wanneer het onwaar is, construeert de expressie eerst een nieuwe versie van
de killring door @code{string} vooraan als nieuw element aan de bestaande
killring te plaatsen (dat is wat de @code{push} doet.) Daarna voert het een
tweede @code{if}-clausule uit. Deze tweede @code{if}-clausule voorkomt dat
de killring te groot groeit.

Laten we  in volgorde naar deze twee expressies kijken.

De @code{push} regel in het anders-deel stelt de nieuwe waarde van de kill
ring in op wat het resultaat is van het aan de oude killring toevoegen van
de gekillde string.

We zijn hoe dit werkt aan de hand van een voorbeeld.

@need 800
Eerst

@smallexample
(setq voorbeeldlijst '("hier is een clausule" "andere clausule"))
@end smallexample

@need 1200
@noindent
Na het evalueren van deze expressie met @kbd{C-x C-e}, evalueer je
@code{voorbeeldlijst} en kijk naar wat die teruggeeft.

@smallexample
@group
voorbeeldlijst
     @result{} ("hier is een clausule" "andere clausule")
@end group
@end smallexample

@need 1200
@noindent
We voegen nu een nieuw element toe aan deze lijst door de volgende expressie
te evalueren:
@findex push@r{, voorbeeld}

@smallexample
(push "een derde clausule" voorbeeldlijst)
@end smallexample

@need 800
@noindent
Wanneer we @code{voorbeeldlijst} evalueren, ontdekken we dat zijn waarde is:

@smallexample
@group
voorbeeldlijst
     @result{} ("een derde clausule" "hier is een clausule" "andere clausule")
@end group
@end smallexample

@noindent
De derde clausule is dus door @code{push} toegevoegd aan de lijst.

@need 1200
Nu het tweede deel van de @code{if} clausule. Deze expressie voorkomt dat de
killring te groot groeit. Het ziet er zo uit:

@smallexample
@group
(if (> (length kill-ring) kill-ring-max)
    (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))
@end group
@end smallexample

De code controleert of de lengte va de killring groter is dan de maximum
toegestane lengte. Dit is de waarde van @code{kill-ring-max} (die standaard
120 is). Wanneer de lengte van de kill ring te groot is, dan stelt deze code
het laatste element van de killring in op @code{nil}. Het doet dit met twee
functies, @code{nthcdr} and @code{setcdr}.

We keken eerder naar @code{setcdr}, (@pxref{setcdr, , @code{setcdr}}). Het
zet de @sc{cdr} van een lijst, net als @code{setcar} de @sc{car} van de
lijst zet. In dit geval echter zet @code{setcdr} niet de de @sc{cdr} van de
gehele killring, de functie @code{nthcdr} zorgt dat het de @sc{cdr} van het
een-na-laatste element van de killring zet---dit betekent dat omdat de
@sc{cdr} van het een-na-laatste element het laatste element van de killring
is, het het laatste element van de killring zal zetten.

@findex nthcdr@r{, voorbeeld}
De functie @code{nthcdr} werkt door herhaaldelijk de @sc{cdr} van een lijst
te nemen---het neemt de @sc{cdr} van de @sc{cdr} van de @sc{cdr} @dots{} Het
doet dit @var{N} keer en geeft dan het resultaat terug. (@xref{nthcdr, ,
@code{nthcdr}}.)

@findex setcdr@r{, voorbeeld}
Dus als we een lijst met vier elementen hebben die drie elementen lang
behoort te zijn, kunnen we de @sc{cdr} van het een-na-laatste element op
@code{nil} zetten en daardoor de lijst korter maken. (Wanneer je het laatste
element op iets anders dan @code{nil} zet, wat je kunt doen, dan zou je
lijst niet korter gemaakt hebben. @xref{setcdr, , @code{setcdr}}.)

Je kan dit inkorten zien door de volgende drie expressies beurtelings te
evalueren. Eerst zet je de waarde van @code{bomen} op @code{esdoorn eik spar
berk}, daarna zet je de @sc{cdr} van zijn tweede @sc{cdr} op @code{nil} en
vindt de waarde van @code{bomen}.

@smallexample
@group
(setq bomen (list 'esdoorn 'eik 'spar 'berk))
      @result{} (esdoorn eik spar berk)
@end group

@group
(setcdr (nthcdr 2 bomen) nil)
     @result{} nil

bomen
      @result{} (esdoorn eik spar)
@end group
@end smallexample

@noindent
(De waarde teruggeven door de @code{setcdr} expressie is @code{nil} omdat
dat is waarop de @sc{cdr} is gezet.)

Nogmaals, in @code{kill-new}, neemt de functie @code{nthcdr} een aantal keer
de @sc{cdr}, één minder dan de maximaal toegestane grootte van de killring
en de @code{setcdr} zet de @sc{cdr} van dat element (wat de rest van de
elementen in de killring is) op @code{nil}. Dit voorkomt dat de killring te
groot groeit.

@need 800
De een-na-laatste expressie in de kill ring is

@smallexample
(setq kill-ring-yank-pointer kill-ring)
@end smallexample

De @code{kill-ring-yank-pointer} is een globale variabele die is ingesteld
om de @code{kill-ring} te zijn.

Ondanks dat de @code{kill-ring-yank-pointer} een @code{pointer} heet, is het
een variabele net als de killring. De naam is echter gekozen om mensen te
helpen begrijpen hoe de variabele wordt gebruikt.

@need 1200
Nu gaan we terug naar een expressie in het begin van de body van de functie:

@smallexample
@group
  (if (fboundp 'menu-bar-update-yank-menu)
       (menu-bar-update-yank-menu string (and replace (car kill-ring))))
@end group
@end smallexample

@noindent
Het begint met een @code{if} expressie

In dit geval test de expressie eerst of de functie
@code{menu-bar-update-yank-menu} bestaat en zo ja, roept die aan. De functie
@code{fboundp} geeft waar terug wanneer het symbool dat het test een
functiedefinitie heeft die niet leeg is. Wanneer de functiedefinitie van het
symbool leeg is, krijgen we een foutmelding, zoals we die kregen toen we
expres fouten maakten (@pxref{Fouten maken, , Een foutboodschap genereren}).

@noindent
Het dan-deel bevat een expressie wiens eerste argument de functie @code{and}
is.

@findex and
De speciale vorm @code{and} evalueert elk van zijn argumenten totdat een van
de argumenten de waarde @code{nil} teruggeeft, in welk geval de @code{and}
expressie @code{nil} teruggeeft. Wanneer echter geen van de argumenten een
waarde @code{nil} teruggeven, dan wordt de waarde afkomstig van de evaluatie
van het laatste argument teruggegeven. (Omdat zo'n waarde niet @code{nil}
is, wordt het in Emacs Lisp beschouwd als waar.) Met andere woorden, een
@code{and} expressie geeft alleen waar terug als al zijn argumenten waar
zijn. (@xref{Tweede buffer gerelateerde terugblik}.)

De expressie stelt vast of het tweede argument van
@code{'menu-bar-update-yank-menu} waar is of niet.
@ignore
    ;; If we're supposed to be extending an existing string, and that
    ;; string really is at the front of the menu, then update it in place.
@end ignore

@code{menu-bar-update-yank-menu} is een van de functies die het mogelijk
maken om het ``Select and Paste'' menu in het Edit-item in de menubar te
gebruiken. Met de muis kan je zien elke verschillende stukken tekst je hebt
opgeslagen en een stuk selecteren om te pasten.

De laatste expressie in de functie @code{kill-new} voegt de nieuw
gekopieerde string toe aan wat voor faciliteit dan ook bestaat voor het
kopiëren en plakken tussen de verschillende programma's die in het windowing
systeem draaien. In het X windowing systeem bijvoorbeeld, pakt de functie
@code{x-select-text} de string op en bewaart die in het geheugen dat X@
bewerkt. Je kan de string in een andere programma pasten, zoals een Xterm.

@need 1200
De expressie ziet er zo uit:

@smallexample
@group
  (if interprogram-cut-function
      (funcall interprogram-cut-function string (not replace))))
@end group
@end smallexample

Wanneer een @code{interprogram-cut-function} bestaat, dan voert Emacs
@code{funcall} uit, die op zijn beurt het eerste argument als een functie
aanroept en de resterende argumenten daar aan doorgeeft. (Overigens, voor
zover ik het kan zien, kan de @code{if}-expressie vervangen worden door een
@code{and} expressie vergelijkbaar met die in het eerste deel van de
functie.)

We bepreken verder geen windowing systems en andere programma's, maar merken
slechts op dat dit een mechanisme is dat het GNU Emacs mogelijk maakt om
makkelijk en goed met andere programma's samen te werken.

De code voor het plaatsen van de tekst in de killring, hetzij geplakt aan
een bestaand element hetzij als een nieuw element, leidt ons naar de code om
de verwijderde tekst terug te halen---het yank commando. Voordat we het yank
commando gaan bespreken, is het echter beter te ontdekken hoe lijsten in de
computer zijn geïmplementeerd. Dit verheldert mysteries zoals het gebruik
van de term ``pointer''. Maar voor we dat doen, weiden we uit naar C.

@ignore
@c is this true in Emacs 22?   Does not seems to be

  (If the @w{@code{(< end beg))}}
expression is true, @code{kill-append} prepends the string to the just
previously clipped text.  For a detailed discussion, see
@ref{kill-append function, , The @code{kill-append} function}.)

If you then yank back the text, i.e., paste it, you get both
pieces of text at once.  That way, if you delete two words in a row,
and then yank them back, you get both words, in their proper order,
with one yank.  (The @w{@code{(< end beg))}} expression makes sure the
order is correct.)

On the other hand, if the previous command is not @code{kill-region},
then the @code{kill-new} function is called, which adds the text to
the kill ring as the latest item, and sets the
@code{kill-ring-yank-pointer} variable to point to it.
@end ignore
@ignore

@c Evidently, changed for Emacs 22. The zap-to-char command does not
@c use the delete-and-extract-region function

2006 Oct 26, the Digression into C is now OK but should come after
copy-region-as-kill and filter-buffer-substring

2006 Oct 24
In Emacs 22,
copy-region-as-kill is short, 12 lines, and uses
filter-buffer-substring, which is longer, 39 lines
and has delete-and-extract-region in it.
delete-and-extract-region is written in C.

see Initializing a Variable with @code{defvar}
@end ignore

@node Uitwijding naar C
@section Uitwijding naar C
@findex delete-and-extract-region
@cindex C, een uitweiding naar
@cindex Uitwijding naar C

De functie @code{copy-region-as-kill} function (@pxref{copy-region-as-kill,
, @code{copy-region-as-kill}}) gebruikt de functie
@code{filter-buffer-substring}, die op zijn beurt de functie
@code{delete-and-extract-region} gebruikt. Het verwijdert de inhoud van een
region en die kun je niet terugkrijgen.

In tegenstelling tot andere code die we hier besproken hebben, is de functie
@code{delete-and-extract-region} niet in Emacs Lisp geschreven, het is
geschreven in C en is een van de primitieven van het GNU Emacs
systeem. Omdat het erg eenvoudig is, dwaal ik even af van Lisp en beschrijf
het hier.

@need 1500
Net als veel van de andere Emacs primitieven, is
@code{delete-and-extract-region} geschreven als een C macro, een macro die
een sjabloon voor code is. De complete macro ziet er zo uit:

@c This is a copy of editfns.c's DEFUN for delete-and-extract-region.
@smallexample
@group
DEFUN ("delete-and-extract-region", Fdelete_and_extract_region,
       Sdelete_and_extract_region, 2, 2, 0,
       doc: /* Delete the text between START and END and return it.  */)
  (Lisp_Object start, Lisp_Object end)
@{
  validate_region (&start, &end);
  if (XFIXNUM (start) == XFIXNUM (end))
    return empty_unibyte_string;
  return del_range_1 (XFIXNUM (start), XFIXNUM (end), 1, 1);
@}
@end group
@end smallexample

Zonder verder op de details van het schrijven van macro's in te gaan, wil ik
er op wijzen dat de macro start met het woord @code{DEFUN}. Het woord
@code{DEFUN} was gekozen omdat de code hetzelfde doel dient als @code{defun}
in Lisp. (De C macro @code{DEFUN} is gedefinieerd in
@file{emacs/src/lisp.h}.)

Het woord @code{DEFUN} wordt gevolgd door zeven delen binnen haakjes:

@itemize @bullet
@item
Het eerste deel is de naam die de functie in Lisp krijgt,
@code{delete-and-extract-region}.

@item
Het tweede deel is de naam van de functie in C,
@code{Fdelete_and_extract_region}. Volgens de conventie begint die met een
@samp{F}. Omdat C geen streepjes in namen gebruikt, zijn in plaats daarvan
underscores gebruikt.

@item
Het derde deel is de naam van de C constant structure die informatie over de
deze functie opslaat voor intern gebruik. Het is de naam van de functie in C
maar begint met een @samp{S} in plaats van een @samp{F}.

@item
Het vierde en vijfde deel specificeren het minimum en maximum aantal
argumenten dat de functie kan krijgen. Deze functie vereist precies 2
argumenten.

@item
Het zesde deel is bijna hetzelfde als het argument dat volgt op de
@code{interactive} declaratie in een functie geschreven in Lisp: een letter,
misschien gevold door een prompt. Het enige verschil met Lisp is wanneer de
macro zonder argumenten wordt aangeroepen. Dan schrijf je een @code{0} (wat
een null-string is) zoals in deze macro.

Wanneer je argumenten specificeert, dan zet je die tussen
aanhalingstekens. De C macro voor @code{goto-char} bevat @code{"NGoto char:
"} op deze plek om aan te gevne dat de functie een raw prefix verwacht, in
dit geval een numerieke lokatie in het buffer, en een prompt verschaft.

@item
Het zevende deel is een documentatiestring, net zoals voor een functie
geschreven in Emacs Lisp. Dit is geschreven als C commentaar. (Wanneer je
Emacs bouwt extraheert het programma @command{lib-src/make-docfile} deze
commentaren en gebruikt die om de documentatie te maken.)
@end itemize

@need 1200
In een C macro komen de formele parameters daarna, met een statement over
het soort object dat ze zijn, gevolgd door de body van de macro. Voor
@code{delete-and-extract-region} bestaat de body uit de volgende vier
regels:

@smallexample
@group
validate_region (&start, &end);
if (XFIXNUM (start) == XFIXNUM (end))
  return empty_unibyte_string;
return del_range_1 (XFIXNUM (start), XFIXNUM (end), 1, 1);
@end group
@end smallexample

De functie @code{validate_region} controleert of de waarden die als begin en
eind zijn doorgegeven, van het juiste type en binnen de range zijn.

De functie @code{del_range_1} verwijdert daadwerkelijk de tekst. Het is een
complexe functie waar we niet naar kijken. Het update het buffer en doet
andere dingen. Echter het is het waard te kijken naar de twee argumenten die
doorgeven worden aan @code{del_range_1}. Dit zijn @w{@code{XFIXNUM (start)}}
en @w{@code{XFIXNUM (end)}}.

Wat de C-taal betreft, zijn @code{start} en @code{end} twee vage waarden die
het begin en eind van de te verwijderen region markeren. Meer precies, en
met meer expertise genodigd om te begrijpen, zijn de twee waarden van het
type @code{Lisp_Object}, wat een C-pointer kan zijn, of een C-integer, of
een C-@code{struct}. Het kan de C code normaalgesproken niet schelen hoe
@code{Lisp_Object} is geïmplementeerd.

De breedte van @code{Lisp_Object} hangt af van de machine, en is typisch 32
of 64 bits. Enkele van de bits worden gebruikt om het type informatie te
specificeren, de resterende bits voor de inhoud.

@samp{XFIXNUM} is een C macro die de relevante integer uit de langere
collectie bits extraheert. De type-bits worden genegeerd.

@need 800
Het commando in @code{delete-and-extract-region} ziet het zo uit:

@smallexample
del_range_1 (XFIXNUM (start), XFIXNUM (end), 1, 1);
@end smallexample

@noindent
Het verwijdert de region tussen de beginpostitie, @code{start}, en de
eindpositie, @code{end}.

Vanuit het gezichtspunt van de persoon die Lisp schrijft, is Emacs heel
eenvoudig, maar eronder is een grote hoeveelheid compliciteit verborgen die
het allemaal laat werken.

@node defvar
@section Initialiseer een variabele met @code{defvar}
@findex defvar
@cindex Een variabele initialiseren
@cindex Variabele initialisatie

@ignore
2006 Oct 24
In Emacs 22,
copy-region-as-kill is short, 12 lines, and uses
filter-buffer-substring, which is longer, 39 lines
and has delete-and-extract-region in it.
delete-and-extract-region is written in C.

see Initializing a Variable with @code{defvar}

@end ignore

De functie @code{copy-region-as-kill} is in Emacs Lisp geschreven. Twee
functies in het, @code{kill-append} en @code{kill-new}, kopiëren een region
in een buffer en bewaren het in een variabele met de naam
@code{kill-ring}. Deze sectie beschijft hoe de @code{kill-ring} met de
speciale vorm @code{defvar} is gecreëerd en geïnitialiseerd.

(Opnieuw merken we op dat de term @code{kill-ring} een misleidende naam
is. De tekst die uit het buffer is geknipt kan teruggehaald worden. Het is
niet een ring van lijken, maar een ring van herleefbare tekst.)

In Emacs Lisp wordt een variabele zoals @code{kill-ring} met de speciale
vorm gecreëerd en van een initiële waarde voorzien. De naam komt van
``define variable''.

De speciale vorm @code{defvar} stelt de waarde van een variabele in, net als
@code{setq}. Het verschilt van @code{setq} op drie manieren: ten eerste
markeert het de variabele als ``speciaal'' zodat het altijd dynamisch
gebonden is, zelfs wanneer @code{lexcial-binding} @code{t} is (@pxref{Hoe
let variabelen bindt, , Variabelen}). Ten tweede, het stelt alleen de waarde
van de variabele in wanneer de variabele nog geen waarde heeft. Wanneer de
variabele al een waarde heeft, overschrijft @code{defvar} de bestaande
waarde niet. Ten derde, @code{defvar} heeft een documentatiestring. 

(Er is een gerelateerde macro, @code{defcustom}, gemaakt voor variabelen die
mensen customizen. Het heeft meer eigenschappen dan
@code{defvar}. (@xref{defcustom, , Variabelen specificeren met
@code{defcustom}}.)

@menu
* Inzien huidige variabele waarde::  Inzien huidige variabele waarde
* defvar en asterisk::       defvar en asterisk
@end menu

@ifnottex
@node Inzien huidige variabele waarde
@unnumberedsubsec De huidige waarde van een variabele zien
@end ifnottex

Je kunt de huidige waarde van een variabele, elke variabele, zien met de
functie @code{describe-variable}, die meestal wordt aangeroepen met @kbd{C-h
v}. Wanneer je @kbd{C-h v} typt, en na de prompt @code{kill-ring} (gevolgd
door @key{RET}), krijg je de huidige inhoud van je killring te zien---dit
kan best veel zijn! Omgekeerd, wanneer je in deze Emacs sessie niets anders
gedaan hebt dan dit document lezen, kan er helemaal niets in zijn. Ook krijg
je de documentatie voor @code{kill-ring} te zien.

@smallexample
@group
Documentation:
List of killed text sequences.
Since the kill ring is supposed to interact nicely with cut-and-paste
facilities offered by window systems, use of this variable should
@end group
@group
interact nicely with `interprogram-cut-function' and
`interprogram-paste-function'.  The functions `kill-new',
`kill-append', and `current-kill' are supposed to implement this
interaction; you may want to use them instead of manipulating the kill
ring directly.
@end group
@end smallexample

@need 800
De killring is gedefinieerd door een @code{defvar} op de volgende manier: 

@smallexample
@group
(defvar kill-ring nil
  "List of killed text sequences.
@dots{}")
@end group
@end smallexample

@noindent
In deze variabele definitie krijgt de variabele de initiële waarde
@code{nil}, wat logisch is, omdat je nog niets hebt bewaard, wil je niets
terughalen met een @code{yank} commando. De documentatiestring schrijf je op
dezelfde manier als de documentatiestring van een @code{defun}. Net als bij
de documentatiestring van de @code{defun}, moet de eerste regel van de
documentatie ene volledige zin zijn omdat sommige commando's, zoals
@code{apropos} alleen de eerste documentatieregel tonen. Opvolgende regels
moeten niet ingesprongen worden, anders zien ze er raar uit als je @kbd{C-h
v} (@code{describe-variable}) gebruikt.

@node defvar en asterisk
@subsection @code{defvar} en een sterretje
@findex defvar @r{voor een user-customizable variabele}
@findex defvar @r{met een sterretje}

In het verleden gebruikte Emacs de speciale vorm @code{defvar} voor zowel
interne variabelen waarvan je niet verwacht dat een gebruiker die aanpast,
als voor variabelen waarvan je wel verwacht dat een gebruiker die
aanpast. Hoewel je nog steeds @code{defvar} voor door de gebruiker aan te
passen variabelen kunt gebruiken, gebruik je alsjeblieft @code{defcustom}
omdat dit een pad biedt naar de Customization commando's. (@xref{defcustom,
, Variabelen specificeren met @code{defcustom}}.)

Wanneer je een variabele met de speciale vorm @code{defvar} gespecificeerd
hebt, kon je onderscheid maken tussen een variabele die de gebruiker mag
veranderen en de andere, door het typen van een sterretje, @samp{*}, in de
eerste kolom van de documentatiestring. Bijvoorbeeld: 

@smallexample
@group
(defvar shell-command-default-error-buffer nil
  "*Buffer name for `shell-command' @dots{} error output.
@dots{} ")
@end group
@end smallexample

@findex set-variable
@noindent
Je kon (en kan nog steeds) het commando @code{set-variable} gebruiken om de
waarde van @code{shell-command-default-error-buffer} tijdelijk te
wijzigen. Echter, opties gezet met @code{set-variable} zijn alleen voor de
duur van je editing-sessie gezet. De nieuwe waarden worden tussen sessies
niet bewaard. Steeds wanneer Emacs start, leest het de oorspronkelijke
waarde, tenzij je de waarde in je @file{.emacs} bestand aanpast, door het
handmatig te zetten of met gebruik van @code{customize}. @xref{Initialisatie
van Emacs, , Jouw @file{.emacs} bestand}.

Het belangrijkste gebruik van het commando @code{set-variable} voor mij is
om variabelen voor te stellen die ik in mijn @file{.emacs} bestand zou
willen zetten. Er zijn nu meer dan 700 van dat soort variabelen, veel te
veel om makkelijk te herinneren. Gelukkig kan je de @key{TAB} toets
gebruiken na het commando @code{M-x set-variable} om een lijst met
variabelen te zien. (@xref{Examining, , Examining and Setting Variables,
emacs, The GNU Emacs Manual}.)

@need 1250
@node cons en search-fwd terugblik
@section Terugblik

Hier is een korte samenvatting van sommige recent geïntroduceerde functies.

@table @code
@item car
@itemx cdr
@code{car} geeft het eerste element van een lijst terug. @code{cdr} geeft
het tweede en volgende elementen van de lijst terug.

@need 1250
Bijvoorbeeld:

@smallexample
@group
(car '(1 2 3 4 5 6 7))
     @result{} 1
(cdr '(1 2 3 4 5 6 7))
     @result{} (2 3 4 5 6 7)
@end group
@end smallexample

@item cons
@code{cons} construeer een lijst door het eerste element voor het tweede te
zetten.

@need 1250
Bijvoorbeeld:

@smallexample
@group
(cons 1 '(2 3 4))
     @result{} (1 2 3 4)
@end group
@end smallexample

@item funcall
@code{funcall} evalueert het eerste argument als functie. Het geeft de
resterende argumenten door aan het eerste argument.

@item nthcdr
Geeft het resultaat van @var{n} keer @sc{cdr} nemen van een lijst.
@iftex
De
@tex
$n^{th}$
@end tex
@code{cdr} 
@end iftex
De ``rest van de rest'' als het ware.

@need 1250
Bijvoorbeeld:

@smallexample
@group
(nthcdr 3 '(1 2 3 4 5 6 7))
     @result{} (4 5 6 7)
@end group
@end smallexample

@item setcar
@itemx setcdr
@code{setcar} wijzigt het eerste element van een lijst, @code{setcdr}
wijzigt het tweede en volgende elementen van een lijst.

@need 1250
Bijvoorbeeld:

@smallexample
@group
(setq triple (list 1 2 3))

(setcar triple '37)

triple
     @result{} (37 2 3)
(setcdr triple '("foo" "bar"))

triple
     @result{} (37 "foo" "bar")
@end group
@end smallexample

@item progn
Evalueer achtereenvolgens elk argument en geef de waarde van de laatste
terug.

@need 1250
Bijvoorbeeld:

@smallexample
@group
(progn 1 2 3 4)
     @result{} 4
@end group
@end smallexample

@item save-restriction
Bewaar de versmalling die eventueel actief is in het huidige buffer en
herstel die versmalling na het evalueren van de argumenten.

@item search-forward
Zoek voor een string, en wanneer die string gevonden is, verplaats
point. Met een reguliere expressie gebruik de vergelijkbare
@code{re-search-forward}. (@xref{Regexp zoeken, , Reguliere expressie
zoekopdrachten}, voor een uitleg van reguliere expressies patronen en
zoekopdrachten.)

@need 1250
@noindent
@code{search-forward} en @code{re-search-forward} hebben vier argumenten:

@enumerate
@item
De string of reguliere expressie om naar te zoeken.

@item
Optioneel, de limiet van de zoekopdracht.

@item
Optioneel, wat te doen als de zoekopdracht mislukt, geef @code{nil} terug of
een fout.

@item
Optioneel, hoeveel keer de zoekopdracht te herhalen. Wanneer negatief, zoek
achterwaarts.
@end enumerate

@item kill-region
@itemx delete-and-extract-region
@itemx copy-region-as-kill

@code{kill-region} verwijdert de tekst tussen point en mark uit het buffer
en bewaart die tekst in de killring, zodat je die met yanken terug kunt
krijgen.

@code{copy-region-as-kill} kopieert de tekst tussen point en mark naar de
killring, van waar je het met yanken terug kunt krijgen. De functie
verwijdert de tekst niet uit het buffer.
@end table

@code{delete-and-extract-region} verwijdert de tekst tussen point en mark
uit het buffer en gooit het weg. Je kunt het niet terug krijgen. (Dit is
geen interactief commando).

@need 1500
@node zoek oefening
@section Zoek-oefeningen

@itemize @bullet
@item
Schrijf een interactieve functie die naar een string zoekt. Wanneer de
string gevonden is, plaats point er achter en toon een boodschap die zegt
``Gevonden!''. (Maak geen gebruik van @code{search-forward} als naam van
deze functie, wanneer je dat doet overschrijf je de bestaande versie van
@code{search-forward} die bij Emacs hoort. Gebruik in plaats daarvan een
naam zoals @code{test-zoeken}.)

@item
Schrijf een functie die het derde element van de killring toont in het
echogebied als dat element er is. Wanneer de killring geen derde element
heeft, toon dat een passende boodschap.
@end itemize

@node Implementatie van lijsten
@chapter Hoe lijsten zijn geïmplementeerd
@cindex Lijsten in een computer

In Lisp worden atomen op een eenvoudige manier vastgelegd. Zelfs als de
implementatie niet eenvoudig is, dan is de theorie toch eenvoudig. Het atoom
@samp{roos} bijvoorbeeld is vastgelegd als vier aaneengesloten letters,
@samp{r}, @samp{o}, @samp{o} en @samp{s}. Een lijst, anderzijds, wordt
anders bewaard. Het mechanisme is net zo eenvoudig, maar het kost even tijd
om aan het idee gewend te raken. Een lijst wordt bewaard met een reeks paren
van pointers. In de reeks wijst de eerste pointer van elk paar pointers naar
een atoom of naar een andere lijst, en de tweede pointer in elk paar
pointers wijst naar het volgende paar, of naar het symbool @code{nil}, wat
het eind van de lijst markeert.

Een pointer zelf is heel eenvoudig het elektronische adres van datgene, waar
het naar toe wijst. Een lijst wordt dus bewaard als een reeks elektronische
adressen.

@menu
* Lijsten uitgetekend::      Lijsten uitgetekend
* Symbolen als ladekast::    Een krachtige metafoor verkennen.
* Lijst oefening::           Lijst oefening
@end menu

@ifnottex
@node Lijsten uitgetekend
@unnumberedsec Lijsten uitgetekend
@end ifnottex

Bijvoorbeeld de lijst @code{(roos, viool, boterbloem)} heeft drie elementen,
@samp{roos}, @samp{viool} en @samp{boterbloem}. In de computer wordt het
elektronische adres van @samp{roos} bewaard in een segment van het
computergeheugen dat een @samp{cons-cel} heet (omdat dat is wat de functie
@code{cons} werkelijk creëert). Deze cons-cel bevat ook het adres van een
tweede cons-cel, wiens @sc{car} het atoom @samp{viool} is, en dat adres
(degene die vertelt waar @samp{viool} is bewaard) samen met het adres van
een derde cons-cel, die het adres voor het atoom @samp{boterbloem} bevat.

@need 1200
@c !!! cons-cell-diagram #1
Dit klinkt gecompliceerder dan het is en is makkelijker te zien in een
diagram:
@sp 1
@center @image{cons-1-nl}
@sp 1

@noindent
Elk vakje in het diagram representeert een computergeheugen woord dat een
Lisp object bevat, meestal in de vorm van een geheugenadres. De vakjes,
oftewel de adressen, zijn paren. Elke pijl wijst naar wat het adres een
adres van is, hetzij een atoom of een ander paar adressen. Het eerste vakje
is het elektronische adres van @samp{roos} en de pijl wijst naar
@samp{roos}. Het tweede vakje is het adres van het volgende paar vakjes,
waarvan het eerste deel het adres van @samp{viool} is en waarvan het tweede
deel het adres van het volgende paar is. Het allerlaatste vakje wijst naar
het symbool @code{nil}, dat het einde van de lijst markeert.

@need 1200
Wanneer een variabele met een operatie zoals @code{setq} wordt ingesteld op
een lijst, dan slaat dat het adres op van het eerste vakje. Dus, evaluatie
van de expressie

@smallexample
(setq boeket '(roos viool boterbloem))
@end smallexample

@need 1250
@noindent
@c cons-cell-diagram #2
creëert een situatie zoals dit:
@sp 1
@center @image{cons-2-nl}
@sp 1

@noindent
In dit voorbeeld bevat het symbool @code{boeket} het adres van het eerste
paar vakjes.

@need 1200
@c cons-cell-diagram #2a
Dezelfde lijst kan met een ander soort vakjes-notatie worden geïllustreerd,
zoals dit:
@sp 1
@center @image{cons-2a-nl}
@sp 1

(Symbolen bestaan uit meer dan paren van adressen, maar de structuur van een
symbool is gemaakt van adressen. Het symbool @code{boeket} bestaat inderdaad
uit een groep van adresvakjes, waarvan een het adres van het getoonde woord
@samp{boeket} is, een tweede daarvan het adres van de aan het symbool
gekoppelde functiedefinitie is, als die er is, en een derde daarvan dat het
adres van het eerste paar adresvakjes voor de lijst @code{roos viool
boterbloem} is, enzovoorts. Hier tonen we dat het derde adresvakje van het
symbool naar het eerste paar van de adresvakjes van de lijst wijst.)

Wanneer een symbool naar de @sc{cdr} van de lijst wordt gezet, verandert de
lijst zelf niet. Het symbool heeft eenvoudig een adres verderop in de
lijst. (In het jargon: @sc{car} en @sc{cdr} zijn niet-destructief). Dus de
evaluatie van de volgende expressie

@smallexample
(setq bloemen (cdr boeket))
@end smallexample

@need 800
@noindent
@c cons-cell-diagram #3
produceert dit:
@sp 1
@center @image{cons-3-nl}
@sp 1

@noindent
De waarde van @code{bloemen} is @code{(viool boterbloem)}, dat wil zeggen,
het symbool @code{bloemen} bevat het adres van het paar adresvakjes, waarvan
de eerste het adres van @code{viool} bevat en de tweede het adres van
@code{boterbloem} bevat.

@cindex dotted pair
@cindex cons-cel
Een paar adresvakjes heet een @dfn{cons-cel} of @dfn{dotted
pair}. @xref{Cons Cell Type, , Cons Cell and List Types, elisp, The GNU
Emacs Lisp Reference Manual}, en @ref{Dotted Pair Notation, , Dotted Pair
Notation, elisp, The GNU Emacs Lisp Reference Manual}, voor meer informatie
over cons-cellen en dotted pairs.

@need 1200
De functie @code{cons} voegt een nieuw paar adressen aan de voorkant van de
reeks van adressen zoals hierboven getoond. Bijvoorbeeld, het evalueren van
de expressie

@smallexample
(setq boeket (cons 'lelie boeket))
@end smallexample

@need 1500
@noindent
@c cons-cell-diagram #4
produceert:
@sp 1
@center @image{cons-4-nl}
@sp 1

@need 1200
@noindent
Dit verandert echter niet de waarde van het symbool @code{bloemen}, zoals je
kunt zien door het volgende te evalueren:

@smallexample
(eq (cdr (cdr boeket)) bloemen)
@end smallexample

@noindent
wat @code{t} voor waar teruggeeft.

Totdat het wordt gereset, heeft @code{bloemen} nog steeds de waarde
@code{(viool boterbloem)}, dat wil zeggen, het heeft het adres van de
cons-cel wiens eerste adres dat van @code{viool} is. Ook verandert dit geen
van de reeds bestaande cons-cellen, die zijn er nog steeds.

Dus om in Lisp de @sc{cdr} van een lijst te krijgen, krijg je alleen het
adres van de volgende cons-cel in de reeks. Om de @sc{car} van een lijst te
krijgen, krijg je het adres van het eerste element van de lijst. Om een
nieuw element aan een lijst te @code{cons}-en, voeg je een nieuwe cons-cel
aan de voorkant van de lijst toe. Dat is alles! De onderliggende structuur
van Lisp is briljant eenvoudig!

En waar refereert het laatste adres in een reeks van cons-cellen naar toe?
Het is het adres van de lege lijst, van @code{nil}.

Samengevat, wanneer een Lisp variabele op een waarde wordt ingesteld, dan
krijgt die het adres van de lijst waar de variabele naar refereert.

@node Symbolen als ladekast
@section Symbolen als een ladekast
@cindex Symbolen als een ladekast
@cindex Ladekast, metafoor voor een symbool
@cindex Ladekast, metafoor voor een symbool

In een eerdere sectie suggereerde ik dat je een symbool kunt voorstellen als
een ladekast. De functiedefinitie wordt in een lade gestopt, de waarde in
een andere, enzovoorts. Wat in de lade die de waarde bevat gestopt is, kan
worden gewijzigd zonder de inhoud van de waarde die de functiedefinitie
bevat te wijzigen, en andersom.

Wat eigenlijk in elke lade gestopt wordt, is het adres van de waarde of de
functiedefinitie. Het is alsof je een oude kast op de zolder gevonden hebt,
en in een van de lades een kaart vond die de route beschrijft naar waar de
begraven schat ligt.

Naast zijn naam, symbooldefinitie en variabele naam, heeft een symbool een
lade voor een @dfn{property list} die kan worden gebruikt om andere
informatie op te slaan. Property lists bespreken we hier niet, zie
@ref{Property Lists, , Property Lists, elisp, The GNU Emacs Lisp Reference
Manual}.)

@need 1500
@c chest-of-drawers diagram
Hier is een fantasierijke weergave:
@sp 1
@center @image{drawers-nl}
@sp 1

@node Lijst oefening
@section Oefening

Stel @code{bloemen} in op @code{viool} en @code{boterbloem}. Cons twee
andere bloemen aan deze lijst en zet deze lijst op @code{meer-bloemen}. Zet
de @sc{car} van bloemen op een vis. Wat bevat de lijst @code{meer-bloemen}
nu?

@node Yanking
@chapter Tekst terug yanken
@findex yank
@cindex Tekst terughalen
@cindex Tekst terughalen
@cindex Tekst plakken

Wanneer je in GNU Emacs met een kill commando tekst uit een buffer
verwijdert dan kun je die terughalen met een yank commando. De tekst die uit
het buffer verwijderd is, wordt in de killring gestopt en het yank commando
voegt de juiste inhoud van de killring terug in een buffer (niet
noodzakelijkerwijs het oorspronkelijke buffer).

Een eenvoudig @kbd{C-y} (@code{yank}) commando voegt het eerste element van
de killring in het huidige buffer. Wanneer het @kbd{C-y} commando direct
gevolg wordt door @kbd{M-y}, wordt het eerste element vervangen door het
tweede element. Herhaaldelijke @kbd{M-y} commando's vervangen het teede
element met het derde, vierde of vijfde element, enzovoorts. Wanneer het
laatste element in de killring is bereikt, wordt het vervangen door het
eerste en wordt de cyclus herhaald. (Daarom heet de killring een ``ring'' in
plaats van een ``lijst''. De werkelijke datastructuur die de tekst bevat is
echter een lijst. @xref{Killring, , De killring hanteren}, voor de details
hoe de lijst wordt gehanteerd als ring.)

@menu
* Killring overzicht::       Killring overzicht
* kill-ring-yank-pointer::   De killring is een lijst.
* yank nthcdr oefeningen::   De @code{kill-ring-yank-pointer} variabele.
@end menu

@node Killring overzicht
@section Killring overzicht
@cindex Killring overzicht

De killring is een lijst van tekstuele strings. Dit is hoe die er uit ziet:

@smallexample
("wat tekst" "een ander stuk tekst" "nog meer tekst")
@end smallexample

Wanneer dit de inhoud van mijn killring is en ik sla @kbd{C-y} aan, dan
wordt de karakterstring @samp{wat tekst} in dit buffer op de cursorlokatie
ingevoegd.

Het @code{yank} commando wordt ook gebruikt om tekst te dupliceren door het
te kopiëren. De gekopieerde tekst wordt niet uit het buffer verwijderd, maar
een kopie er van is in de killring geplaatst en onmiddellijk ingevoegd door
het terug te yanken.

Drie functies worden gebruikt om de tekst uit de killring terug te halen:
@code{yank}, dat normaalgesproken gebonden is aan
@kbd{C-y}. @code{yank-pop}, dat normaalgesproken gebonden is aan @kbd{M-y},
en @code{rotate-yank-pointer} dat door de twee andere functies gebruikt
wordt.

Deze functies refereren aan de killring via de variabele met de naam
@code{kill-ring-yank-pointer}. Inderdaad, de invoegcode van zowel de functie
@code{yank} als @code{yank-pop} is:

@smallexample
(insert (car kill-ring-yank-pointer))
@end smallexample

@noindent
(Nou, niet meer. In GNU Emacs 22 is de functie vervangen door
@code{insert-for-yank}, die herhaaldelijk @code{insert-for-yank-1} aanroept
voor elk @code{yank-handler} segment. @code{insert-for-yank-1}, op zijn
beurt, stript de tekst eigenschappen van de ingevoegde tekst in
overeenstemming met @code{yank-excluded-properties}. Anders dat dat, is het
gewoon als @code{insert}. Wij houden het bij de @code{insert}, dit is
makkelijker te begrijpen.)

Om te beginnen te begrijpen hoe @code{yank} en @code{yank-pop} werken, is
het eerst nodig naar de variabele @code{kill-ring-yank-pointer} te kijken.

@node kill-ring-yank-pointer
@section De variabele @code{kill-ring-yank-pointer}

@code{kill-ring-yank-pointer} is een variabel, net zoals @code{kill-ring}
een variabele is. Het wijst naar iets dat is gebonden aan de waarde van waar
het naar wijst, net als elke andere Lisp variabele.

@need 1000
Dus, als de waarde van de killring is:

@smallexample
("wat tekst" "een ander stuk tekst" "nog meer tekst")
@end smallexample

@need 1250
@noindent
en de @code{kill-ring-yank-pointer} wijst naar de tweede clausule, dan is de
waarde van @code{kill-ring-yank-pointer}:

@smallexample
("een ander stuk tekst" "nog meer tekst")
@end smallexample

@c cons-cell-diagram #5
Zoals in het vorige hoofdstuk (@pxref{Implementatie van lijsten}) uitgelegd,
bewaart de computer geen twee verschillende exemplaren van de tekst waar
zowel de @code{kill-ring} als de @code{kill-ring-yank-pointer} naar
wijzen. De woorden ``een ander stuk tekst'' en ``nog meer tekst'' worden
niet gedupliceerd. In plaats daarvan wijzen de twee Lisp variabelen naar
hetzelfde stuk tekst. Hier is een diagram:
@sp 1
@center @image{cons-5-nl}
@sp 1

Zowel de variabele @code{kill-ring} als de variabele
@code{kill-ring-yank-pointer} zijn pointers. Maar de killring zelf wordt
meestal beschreven alsof het is wat het van gemaakt is. De killring wordt
beschreven alsof het een lijst is in plaats van dat het naar de lijst
wijst. Omgekeerd, de @code{kill-ring-yank-pointer} is beschreven alsof het
wijst naar een lijst.

Deze twee manieren om over het zelfde ding te spreken klinken op het eerste
gezicht verwarrend maar zijn bij nader inzien logisch. De killring wordt
algemeen beschouwd als de complete structuur van data die de informatie
bevat van wat recentelijk uit de buffers is geknipt. De
@code{kill-ring-yank-pointer} anderzijds dient om aan te geven---dat wil
zeggen, te wijzen naar---dat deel van de killring waarvan het eerste element
(the @sc{car}) zal worden ingevoegd.

@ignore
In GNU Emacs 22, the @code{kill-new} function calls

@code{(setq kill-ring-yank-pointer kill-ring)}

(defun rotate-yank-pointer (arg)
  "Rotate the yanking point in the kill ring.
With argument, rotate that many kills forward (or backward, if negative)."
  (interactive "p")
  (current-kill arg))

(defun current-kill (n &optional do-not-move)
  "Rotate the yanking point by N places, and then return that kill.
If N is zero, `interprogram-paste-function' is set, and calling it
returns a string, then that string is added to the front of the
kill ring and returned as the latest kill.
If optional arg DO-NOT-MOVE is non-nil, then don't actually move the
yanking point; just return the Nth kill forward."
  (let ((interprogram-paste (and (= n 0)
                                 interprogram-paste-function
                                 (funcall interprogram-paste-function))))
    (if interprogram-paste
        (progn
          ;; Disable the interprogram cut function when we add the new
          ;; text to the kill ring, so Emacs doesn't try to own the
          ;; selection, with identical text.
          (let ((interprogram-cut-function nil))
            (kill-new interprogram-paste))
          interprogram-paste)
      (or kill-ring (error "Kill ring is empty"))
      (let ((ARGth-kill-element
             (nthcdr (mod (- n (length kill-ring-yank-pointer))
                          (length kill-ring))
                     kill-ring)))
        (or do-not-move
            (setq kill-ring-yank-pointer ARGth-kill-element))
        (car ARGth-kill-element)))))

@end ignore

@need 1500
@node yank nthcdr oefeningen
@section Oefeningen met @code{yank} en @code{nthcdr}

@itemize @bullet
@item
Kijk met @kbd{C-h v} (@code{describe-variable}) naar je killring. Voeg
verschillende items aan je killring toe en kijk opnieuw naar zijn waarde. Ga
met @kbd{M-y} (@code{yank-pop)} helemaal rond in de killring. Hoeveel items
waren in je killring? Vind de waarde van @code{kill-ring-max}. Was je
killring vol, of had je nog meer blokken tekst kunnen bewaren?

@item
Construeer met @code{nthcdr} en @code{car} een reeks expressies om het
eerste, tweede, derde en vierde element van een lijst terug te geven.
@end itemize

@node Loops en recursie
@chapter Loops en recursie
@cindex Loops en recursie
@cindex Recursie en loops
@cindex Herhaling (loops)

Emacs Lisp heeft twee primaire manieren om een expressie of een reeks van
expressies herhaaldelijk te laten evalueren: een met gebruik van een
@code{while} loop en een met gebruik van @dfn{recursie}.

Herhaling kan zeer waardevol zijn. Bijvoorbeeld om vier zinnen naar voren te
gaan, hoef je alleen een programma te schrijven dat een zin naar voren gaat,
en dat dan vier keer te herhalen. Omdat een computer niet verveeld of
vermoeid raakt, heeft zo'n herhalende actie geen schadelijke effecten dat
overdreven of verkeerde manier van herhalen op mensen kan hebben.

Men schrijft meestal Emacs Lisp functies met @code{while} loops en hun
soortgenoten. maar je kunt ook recursie gebruiken, wat een erg krachtige
manier biedt om over problemen te denken en op te lossen@footnote{Je kunt
recursieve functies schrijven die zuinig of verspillend omgaan met mentale-
of computermiddelen. Methoden die mensen makkelijk vinden---die zuinig met
mentale middelen omgaan---kunnen soms aanzienlijke computermiddelen
gebruiken. Emacs was ontworpen om op machines te draaien die we nu beperkt
vinden en de standaard instellingen zijn terughoudend. Je wilt misschien de
instelling van @code{max-lisp-eval-depth} verhogen. In mijn @file{.emacs}
bestand heb ik het op 30 keer de standaard waarde ingesteld.}

@menu
* while::                    Een stuk code zich laten herhalen.
* dolist dotimes::           dolist dotimes
* Recursie::                 Een functie zichzelf laten aanroepen.
* Looping oefening::         Looping oefening
@end menu

@node while
@section @code{while}
@cindex Loops
@findex while

De speciale vorm @code{while} test of de waarde teruggeven door het eerste
argument te evalueren waar of onwaar is. Dit is vergelijkbaar met wat de
Lisp interpreter doet met een @code{if}. Wat de interpreter daarna doet is
echter anders.

Wanneer in een @code{while} expressie de waarde teruggeven door het eerste
argument te evalueren onwaar is, slaat de Lisp interpreter de rest van de
expressie (de @dfn{body} van de expressie) over en evalueert die
niet. Wanneer echter de waarde waar is, can evalueert de Lisp interpreter de
body van de expressie en test opnieuw of het eerste argument van
@code{while} waar is of onwaar. Wanneer de waarde teruggegeven door het
eerste argument te evalueren opnieuw waar is, evalueert de Lisp interpreter
opnieuw de body van de expressie.

@need 1200
Het sjabloon voor een @code{while} expressie ziet er zo uit:

@smallexample
@group
(while @var{waar-of-onwaar-test}
  @var{body}@dots{})
@end group
@end smallexample

@menu
* Looping met while::        Herhaal zolang de test waar teruggeeft.
* Loop voorbeeld::           Een @code{while} loop die een lijst gebruikt.
* print-elements-of-list::   Gebruik @code{while}, @code{car}, @code{cdr}.
* Incrementele loop::        Een loop met een incrementele teller.
* Incrementele loop details::  Incrementele loop details
* Decrementele loop::        Een loop met een aflopende teller.
@end menu

@ifnottex
@node Looping met while
@unnumberedsubsec Looping met @code{while}
@end ifnottex

Zolang de waar-of-onwaar-test van de @code{while} expressie een waarde waar
teruggeeft wanneer die wordt geëvalueerd, wordt de body herhaaldelijk
geëvalueerd. Dit proces wordt een loop genoemd, omdat de Lisp interpreter
het zelfde ding opnieuw en opnieuw herhaalt, zoals een vliegtuig een looping
maakt. Wanneer het resultaat van het evalueren van de waar-of-onwaar-test
onwaar is, evalueert de Lisp interpreter de rest van de @code{while}
expressie niet, en verlaat die de loop.

Het is duidelijk dat wanneer het evalueren van het eerst argument van de
@code{while} altijd waar teruggeeft, de daarop volgende body wordt opnieuw,
opnieuw @dots{} en opnieuw @dots{} voor altijd herhaald. Omgekeerd, wanneer
de teruggegeven waarde nooit waar is, de expressies in de body nooit
geëvalueerd zullen worden. Het kunst van het schrijven van @code{while}
loops bestaat uit het kiezen van zo'n mechanisme dat de waar-of-onwaar-test
precies zo veel keer waar teruggeeft als je wilt dat de daaropvolgende
expressies worden geëvalueerd en daarna de test onwaar laat teruggeven.

De waarde die het evalueren van een @code{while} teruggeeft, is de waarde
van de waar-of-onwaar-test. Een interessant gevolg hiervan is dat een
@code{while} loop die zonder fouten evalueert een @code{nil} of onwaar
teruggeeft, ongeacht of het 1 of 100 keer heeft geloopt, of helemaal
nooit. Een @code{while} loop die succesvol evalueert geeft nooit een waarde
waar terug! Dit betekent dat @code{while} altijd geëvalueerd wordt voor zijn
zij-effecten, met andere woorden, de consequenties van het evalueren van de
expressies in de body van de @code{while} loop. Dat is logisch. Het is niet
slechts het loopen dat gewest is, maar de consequenties van wat gebeurt
wanneer de expressies in de loop herhaaldelijk worden geëvalueerd.

@node Loop voorbeeld
@subsection Een @code{while} loop en een lijst

Een gebruikelijke manier om een @code{while} loop te beheersen is testen of
een lijst elementen heeft. Wanneer dat zo is, wordt de loop herhaald, maar
wanneer dat niet zo is, wordt de herhaling beëindigd. Omdat dit een
belangrijke techniek is, maken we hier een klein voorbeeld om het te
illustreren.

Een simpele manier om te testen of een lijsten elementen heeft is de lijst
te evalueren: wanneer die geen elementen heeft is het een lege lijst en
geeft het een lege lijst terug, @code{()}, wat een synoniem is voor
@code{nil} of onwaar. Anderzijds geeft een lijst met elementen die elementen
terug wanneer die wordt geëvalueerd. Omdat Emacs Lisp elke waarde ongelijk
aan @code{nil} als waar beschouwt, en lijst die elementen teruggeeft zal als
waar testen in een @code{while} loop.

@need 1200
Als voorbeeld kun je de variabele @code{lege-lijst} op @code{nil} zetten met
het evalueren van de volgende @code{setq} expressie: 

@smallexample
(setq lege-lijst ())
@end smallexample

@noindent
Na het evalueren van de @code{setq} expressie, kan je de variabele
@code{lege-lijst} op de gebruikelijke manier evalueren, door de cursor
achter het symbool te plaatsen en @kbd{C-x C-e} te typen. In het echogebied
verschijnt @code{nil}.

@smallexample
lege-lijst
@end smallexample

Anderzijds, als je een variabele instelt op een lijst met elementen,
verschijnt de lijst wanneer je de variabele evalueert. Dit kan je zien door
de volgende expressies te evalueren:

@smallexample
@group
(setq dieren '(gazelle giraf leeuw tijger))

dieren
@end group
@end smallexample

Dus om een @code{while} loop te creëren die test of er elementen in de lijst
@code{dieren} zijn, is het eerste deel van de loop als volgt:

@smallexample
@group
(while dieren
       @dots{}
@end group
@end smallexample

@noindent
Wanneer de @code{while} het eerste argument test, wordt de variabele
@code{dieren} geëvalueerd. Dit geeft een lijst terug. Zo lang de lijst
elementen heeft, beschouwt de @code{while} het resultaat van de test als
waar, maar wanneer de lijst leeg is, dan beschouwt die het resultaat van de
test als onwaar.

Om te voorkomen dat de @code{while} loop voor altijd blijft lopen, is een
mechanisme nodig dat uiteindelijk een lege lijst geeft. Een vaak gebruikte
techniek is om een van de opvolgende vormen in de @code{while} expressie de
waarde van de lijst op de @sc{cdr} van de lijst te zetten. Elke keer dat de
functie @sc{cdr} wordt geëvalueerd wordt de lijst korter, totdat
uiteindelijk alleen de lege lijst overblijft. Op dit punt geeft de test in
de @code{while} loop onwaar terug, en de argumenten van de @code{while}
worden niet langer meer geëvalueerd.

De lijst van dieren bijvoorbeeld, gebonden aan de variabele @code{dieren}
kan op de @sc{cdr} van de oorspronkelijke lijst gezet worden met de volgende
expressie:

@smallexample
(setq dieren (cdr dieren))
@end smallexample

@noindent
Wanneer je de voorgaande expressies geëvalueerd hebt en vervolgens deze
expressie, dan zie je @code{(giraf leeuw tijger)} in het echogebied
verschijnen. Wanneer je de expressie nog een keer evalueert, dan verschijnt
@code{(leeuw tijger)} in het echogebied. Wanneer je het nog een keer en
daarna nog een keer evalueert, dan verschijnt @code{tijger} en daarna de
lege lijst, getoond met @code{nil}.

Een sjabloon voor de @code{wile} loop dat de functie @code{cdr}
herhaaldelijk gebruikt om de waar-of-onwaar-test uiteindelijk als onwaar te
testen, ziet er zo uit:

@smallexample
@group
(while @var{test-of-lijst-leeg-is}
  @var{body}@dots{}
  @var{zet-lijst-op-cdr-van-lijst})
@end group
@end smallexample

Deze test en het gebruik van @code{cdr} kunnen samengevoegd worden in een
functie die door een lijst gaat en elk element van de lijst op een regel op
een eigen regel toont.

@node print-elements-of-list
@subsection Een voorbeeld:  @code{toon-elementen-van-lijst}
@findex print-elements-of-list

De @code{toon-elementen-van-lijst} functie illustreert een @code{while} loop
met een lijst.

@cindex @file{*scratch*} buffer
Deze functie benodigd meerdere regels voor de output. Wanneer je dit in een
recente versie van GNU Emacs leest, kan je de volgende expressies in Info
evalueren, zoals gebruikelijk.

Wanneer je een eerdere versie van Emacs gebruikt, kan het nodig zijn eerst
de expressies te kopiëren naar je @file{*scratch*} buffer en ze daar te
evalueren. Dit is omdat het echogebied in eerdere versies meer een regel
bevat.

Je kunt de expressies kopiëren door het begin van de region te markeren met
@kbd{C-@key{SPC}} (@code{set-mark-command}), vervolgens de cursor naar het
eind van de region te verplaatsen en dan de region met @kbd{M-w}
(@code{kill-ring-save} te kopiëren (die @code{copy-region-as-kill} aanroept
en visuele feedback geeft). In het @file{*scratch*} buffer krijg je de
expressies terug door @kbd{C-y} (@code{yank}) te typen.

Nadat je de expressies in het @file{*scratch*} buffer gekopieerd hebt,
evalueer je elke expressie op zijn beurt. Zorg dat je de laatste expressie
@code{toon-elementen-van-lijst dieren} met @kbd{C-u C-x C-e} evalueert,
oftewel door een argument aan @code{eval-last-sexp} te geven. Hierdoor wordt
het resultaat van de evaluatie in het @file{*scratch*} buffer getoond, in
plaats van in het echogebied. (Anders zie je iets als dit in het echogebied:
@code{^Jgazelle^J^Jgiraf^J^Jleeuw^J^Jtijger^Jnil}, waarbij elk @samp{^J}
voor een nieuwe regel staat.)

@need 1500
Je kunt de volgende expressie direct in het Info buffer evalueren en het
echogebied groeit om de resultaten te tonen.

@smallexample
@group
(setq dieren '(gazelle giraf leeuw tijger))

(defun toon-elementen-van-lijst (lijst)
  "Toon elk element van LIJST op een eigen regel."
  (while lijst
    (print (car lijst))
    (setq lijst (cdr lijst))))
(toon-elementen-van-lijst dieren)
@end group
@end smallexample

@need 1200
@noindent
Wanneer je de drie expressies achtereenvolgens evalueert, zie je dit:

@smallexample
@group
gazelle

giraf

leeuw

tijger
nil
@end group
@end smallexample

Elk element van de lijst wordt op een eigen regel getoond (dat is wat de
functie @code{print} doet) en daarna wordt de waarde die de functie
teruggeeft getoond . Omdat de laatste expressie van de functie de
@code{while} loop is, en omdat een @code{while} loop altijd @code{nil}
teruggeeft, wordt @code{nil} getoond na het laatste element van de lijst.

@node Incrementele loop
@subsection Een loop met een incrementele teller

Een loop is niet bruikbaar tenzij die stopt wanneer dat moet. Naast het
beheersen van een loop met een lijst is een gebruikelijke manier om een loop
te stoppen door het eerste argument te schrijven als een test die onwaar
teruggeeft wanneer het juiste aantal herhalingen is uitgevoerd. Dat betekent
dat de loop een teller moet hebben---een expressie die telt hoeveel maal de
loop zichzelf herhaald heeft.

@ifnottex
@node Incrementele loop details
@unnumberedsubsec Details van een incrementele loop
@end ifnottex

De test voor een loop met een incrementele teller kan een expressie zijn
zoals @code{(< telling gewenste-aantal)} die @code{t} voor waar teruggeeft
wanneer de waarde van @code{telling} kleiner is dan het
@code{gewenste-aantal} herhalingen, en @code{nil} voor onwaar wanneer de
waarde van @code{telling} groter of gelijk is aan het
@code{gewenste-aantal}. De expressie die de telling verhoogt kan een simpele
@code{setq} zijn, zoals @code{(setq telling (1+ telling))}. waar @code{1+}
een in Emacs Lisp een ingebouwde functie is die 1 bij zijn argument
optelt. (De expressie @w{@code{(1+ telling)}} heeft hetzelfde resultaat als
@w{@code{(+ telling 1)}} maar is voor mensen makkelijker te lezen.)

@need 1250
Het sjabloon voor een @code{while} loop beheerst met een incrementele teller
ziet er zo uit:

@smallexample
@group
@var{zet-telling-op-initiele-waarde}
(while (< telling gewenste-aantal)         ; @r{waar-of-onwaar-test}
  @var{body}@dots{}
  (setq telling (1+ telling)))              ; @r{incrementer}
@end group
@end smallexample

@noindent
Merk op dat je de initiële waarde van @code{telling} moet zetten,
gebruikelijk is die op 1 te zetten.

@menu
* Incrementeel voorbeeld::   Steentjes in een driehoek tellen.
* Inc voorbeeld onderdelen::  De onderdelen van een functiedefinitie.
* inc voorbeeld samengesteld::  De functiedefinitie samenstellen.
@end menu

@node Incrementeel voorbeeld
@unnumberedsubsubsec Voorbeeld met een incrementele teller

Stel je voor dat je op het strand aan spelen bent en besluit om een driehoek
van steentjes te maken, met één steentje op de eerste rij, twee op de tweede
rij, drie op de derde rij, enzovoorts, zoals dit:

@sp 1
@c pebble diagram
@ifnottex
@smallexample
@group
               *
              * *
             * * *
            * * * *
@end group
@end smallexample
@end ifnottex
@iftex
@smallexample
@group
               @bullet{}
              @bullet{} @bullet{}
             @bullet{} @bullet{} @bullet{}
            @bullet{} @bullet{} @bullet{} @bullet{}
@end group
@end smallexample
@end iftex
@sp 1

@noindent
(Ongeveer 2500 jaar geleden ontwikkelden Pythagoras en anderen het begin van
getaltheorie door vragen zoals deze te beschouwen.)

Stel je voor dat je wilt weten hoeveel steentjes je nodig hebt om een
driehoek met 7 rijen te maken?

Het is duidelijk, wat we moeten doen is de getallen 1 tot en met 7 op te
tellen. Er zijn twee manieren om dit te doen: beginnen met het kleinste
nummer, een, en dan de lijst opvolgend optellen, 1, 2, 3, 4, enzovoorts. Of
beginnen met het grootste getal en dan de lijst aflopend optellen, 7, 6, 5,
4 enzovoorts. Omdat beide mechanismen gebruikelijke manieren om @code{while}
loops te schrijven illustreren, maken we twee voorbeelden, eentje oplopend
tellen en eentje aflopend tellen. In het eerste voorbeeld beginnen we met 1,
en tellen dan 2, 3, 4 enzovoorts op.

Wanneer je slechts een korte lijst getallen optelt, is de makkelijkste
manier daarvoor om alle getallen in een keer op te tellen. Maar wanneer je
van te voren niet weet hoeveel getallen de lijst bevat, of als je voorbereid
wilt zijn op een erg lange lijst, dan moet je de optelling zo ontwerpen dat
je een eenvoudig proces veel keren herhaalt, in plaats van het in een keer
uitvoeren van een meer complex proces.

Bijvoorbeeld in plaats van alle steentjes in een keer bij elkaar op te
tellen, kun je het aantal steentjes in de eerste rij, 1, optellen bij het
aantal in de tweede rij, 2, daarna tel je het totaal van die twee rijen op
bij de derde rij, 3. Daarna tel je het aantal van de vierde rij, 4, bij het
totaal van de eerste drie rijen, enzovoorts.

De kritieke eigenschap van het proces is dat elke terugkerende actie
eenvoudig is. In dit geval tellen we bij elke stap slechts twee getallen op,
het aantal steentjes in de rij en het totaal dat we al hadden. Dit proces
van het optellen van twee getallen wordt opnieuw herhaald en opnieuw, totdat
de laatste rij is opgeteld bij het totaal van de voorgaande rijen. In een
meer complexe loop kan de terugkerende actie minder eenvoudig zijn, maar het
is eenvoudiger dan alles in een keer doen.

@node Inc voorbeeld onderdelen
@unnumberedsubsubsec De onderdelen van de functiedefinitie

De voorgaande analyse geeft ons het skelet van onze functiedefinitie: als
eerste hebben we een variabele nodig die we @code{totaal} noemen, dat het
totaal van het aantal steentjes gaat worden. Dit is de waarde de de functie
gaat teruggeven.

Ten tweede weten we dat de functie een argument nodig heeft, dit argument
wordt het totaal aantal rijen in de driehoek. Het kan @code{aantal-rijen}
heten.

Tenslotte hebben we een variabele als teller nodig. We kunnen deze variabele
@code{teller} noemen, maar een betere naam is @code{rij-nummer}. Dat is
omdat de teller in deze functie de rijen telt, en een programma moet zo
begrijpelijk mogelijk worden geschreven.

Wanneer de Lisp interpreter voor het eerst start met het evalueren van de
expressies in de functie moet de waarde van @code{totaal} op nul staan,
omdat we er nog niets bij opgeteld hebben. Daarna moet de functie het aantal
steentjes in de eerste rij bij het totaal optellen en daarna het aantal
steentjes in de tweede rij bij het totaal optellen, en dan het aantal
steentjes in de derde rij, enzovoorts, totdat er geen rijen meer over zijn
om er bij te tellen.

@code{totaal} en @code{rij-nummer} worden beide alleen binnen de functie
gebruikt, dus kan @code{let} ze als lokale variabelen declareren en ze een
initiële waarde geven. Het is duidelijk dat de initiële waarde voor
@code{totaal} 0 moet zijn. De initiële waarde voor @code{rij-nummer} moet 1
zijn, omdat we beginnen met de eerste rij. Dit betekent dat de @code{let}
statement er zo uit ziet:

@smallexample
@group
  (let ((totaal 0)
        (rij-nummer 1))
    @var{body}@dots{})
@end group
@end smallexample

Nadat de interne variabelen zijn gedeclareerd en gebonden aan hun initiële
waarden, kunnen we met de @code{while} loop beginnen. De expressie die dient
als test moet een waarde van @code{t} voor waar teruggeven zolang het
@code{rij-nummer}  kleiner of gelijk is aan het
@code{aantal-rijen}. (Wanneer de expressie alleen waar test zolang als het
rijnummer kleiner is dan het aantal rijen in de driehoek, dan wordt de
laatste rij nooit bij het totaal aantal geteld, daarom moet het rijnummer
kleiner of gelijk aan het aantal rijen zijn.) 

@need 1500
@findex <= @r{(kleiner of gelijk)}
Lisp biedt de functie @code{<=} die waar teruggeeft indien de waarde van het
eerste argument is kleiner of gelijk aan de waarde van het tweede argument,
zo niet dan geeft het onwaar terug. De expressie die de @code{while} als
test evalueert moet er zo uitzien:

@smallexample
(<= rij-nummer aantal-rijen)
@end smallexample

Het totale aantal steentjes kan worden bepaald door herhaaldelijk het aantal
steentjes in een rij op te tellen bij het reeds getelde totaal aantal. Omdat
het aantal steentjes in een rij gelijk is aan het rij-nummer, kan het totaal
bepaald worden door het rij-nummer bij het totaal op te tellen. (In een meer
complexe situatie kan het aantal steentjes in een rij op een meer
gecompliceerde manier gerelateerd zijn aan het rij-nummer. Wanneer dat het
geval is dan zou het rij-nummer vervangen worden door een passende
expressie.)

@smallexample
(setq totaal (+ totaal rij-nummer))
@end smallexample

@noindent
Dit zet de nieuwe waarde van @code{totaal} gelijk aan de som van het aantal
steentjes in de rij en het vorige totaal.

Na het zetten van de waarde van @code{totaal} moeten de condities worden
ingesteld voor de volgende herhaling van de loop, als die er is. Dit gebeurt
door de waarde van de variabele @code{rij-nummer} te verhogen, die als
teller dient. Nadat de variabele @code{rij-nummer} is verhoogd, test de
waar-of-onwaar-test aan het begin van de @code{while} loop of de zijn waarde
nog steeds kleiner of gelijk is aan de waarde van de @code{aantal-rijen} en
als dat zo is, telt het de nieuwe waarde van de variable @code{rij-nummer}
bij de @code{totaal} van de vorige herhaling van de loop.

@need 1200
De in Emacs Lisp ingebouwde functie @code{1+} telt 1 bij een getal op, dus
de variabele @code{rij-nummer} kan met deze expressie worden verhoogd:

@smallexample
(setq rij-nummer (1+ rij-nummer))
@end smallexample

@node inc voorbeeld samengesteld
@unnumberedsubsubsec De functiedefinitie samenstellen

We hebben de onderdelen van de functiedefinitie gecreëerd, nu moeten we ze
samenstellen.

@need 800
Ten eerste de inhoud vna de @code{while} expressie: 

@smallexample
@group
(while (<= rij-nummer aantal-rijen)   ; @r{waar-of-onwaar-test}
  (setq totaal (+ total rij-nummer))
  (setq rij-nummer (1+ rij-nummer)))    ; @r{incrementer}
@end group
@end smallexample

Samen met de @code{let} expressie varlist maakt dit de body van de functie
bijna helemaal compleet. Het heeft echter nog een laatste element nodig,
waarvan de noodzaak wat subtiel is.

Het puntje op de i is om de variabele @code{totaal} na de @code{while}
expressie op een eigen regel te plaatsen. Zo niet dan is de waarde die de
hele functie terugggeeft de waarde van de laatste expressie die is
geëvalueerd in de body van de @code{let}, dat is de waarde teruggeven door
de @code{while} en die is altijd @code{nil}.

Dit kan op het eerste gezicht niet vanzelfsprekend zijn. Het lijkt bijna of
de verhogende expressie de laatste expressie van de hele functie is. Maar
die expressie is onderdeel van de body van de @code{while}. Bovendien is de
hele @code{while} loop een lijst binnen de body van de @code{let}.

@need 1250
Een overzicht van de functie ziet er zo uit:

@smallexample
@group
(defun @var{naam-van-functie} (@var{argument-lijst})
  "@var{documentatie}@dots{}"
  (let (@var{varlist})
    (while (@var{waar-of-onwaar-test})
      @var{body-van-while}@dots{} )
    @dots{} ))                    ; @r{Hier is een laatste expressie nodig.}
@end group
@end smallexample

Het resultaat van het evalueren van de @code{let} is wat de @code{defun}
gaat teruggeven, omdat de @code{let} niet ingebed is een lijst, behalve
binnen de @code{defun} als geheel. Echter, als de @code{while} het laatste
element is van de @code{let} expressie, geeft de functie altijd @code{nil}
terug. Dit is niet wat we willen! In plaats daarvan willen we dat de functie
de waarde van de variabele @code{totaal} teruggeeft. Dit wordt teruggegeven
door eenvoudig dat symbool als laatste element in de lijst te zetten die
begint met @code{let}. Het wordt geëvalueerd nadat de voorgaande elementen
van de lijst zijn geëvalueerd, wat betekent dat het wordt geëvalueerd nadat
het de correcte waarde voor het totaal heeft gekregen.

Het is eenvoudiger te zien wanneer we de lijst die begint met @code{let} in
zijn geheel op een regel tonen. Dit formaat maakt het vanzelfsprekend dat de
varlist en de @code{while} expressie het tweede en derde element van de
lijst die begint met @code{let} zijn, en dat @code{totaal} het laatste
element is.

@smallexample
@group
(let (@var{varlist}) (while (@var{waar-of-onwaar-test}) @var{body-of-while}@dots{} ) totaal)
@end group
@end smallexample

@need 1200
Als we alles samenvoegen, ziet de functie @code{driehoek} er zo uit:

@smallexample
@group
(defun driehoek (aantal-rijen)    ; @r{Versie met}
                                  ; @r{  oplopende teller.}
  "Tel het aantal steentjes in een driehoek op.
De eerste rij heeft een steentje, de tweede rij twee steentjes.
De derde rij heeft drie steentjes, enzovoorts.
Het argument is AANTAL-RIJEN."
@end group
@group
  (let ((totaal 0)
        (rij-nummer 1))
    (while (<= rij-nummer aantal-rijen)
      (setq totaal (+ totaal rij-nummer))
      (setq rij-nummer (1+ rij-nummer)))
    totaal))
@end group
@end smallexample

@need 1200
Wanneer je @code{driehoek} hebt geïnstalleerd door het evalueren van de
functie, kun je hem uitproberen. Hier zijn twee voorbeelden:

@smallexample
@group
(driehoek 4)

(driehoek 7)
@end group
@end smallexample

@noindent
De som van de eerste vier getallen is 10 en de som van de eerste zeven
getallen is 28.

@node Decrementele loop
@subsection Loop met een decrementele teller

Een andere gebruikelijke manier om een @code{while} loop te schrijven is met
een test die vaststelt of een teller groter dan nul is. Zolang de teller
groter dan nul is wordt de loop herhaald. Maar wanneer de teller kleiner of
gelijk is aan nul, wordt de loop gestopt. Om dit zo te laten werken moet de
teller groter dan nul starten en dan kleiner en kleiner gemaakt worden door
een vorm die herhaaldelijk wordt geëvalueerd.

De test is een expressie zoals @code{(> teller 0)} die @code{t} voor waar
teruggeeft wanneer de waarde van @code{teller} groter is dan nul, en
@code{nil} voor onwaar wanneer de waarde van @code{teller} kleiner of gelijk
is aan nul. De expressie die het getal kleiner en kleiner makat kan een
eenvoudige @code{setq} zijn zoals @code{(setq teller (1- teller))}, waar
@code{1-} een in Emacs Lisp ingebouwde functie die 1 van zijn argument
aftrekt.

@need 1250
Het slabloon voor een decrementele @code{while} loop ziet er zo uit:

@smallexample
@group
(while (> teller 0)                    ; @r{waar-of-onwaar-test}
  @var{body}@dots{}
  (setq teller (1- teller)))          ; @r{decrementer}
@end group
@end smallexample

@menu
* Decerementeel voorbeeld::  Meer steentjes op het strand.
* Dec voorbeeld onderdelen::  De onderdelen van een functiedefinitie.
* Dec voorbeeld samengesteld::  De functiedefinitie samenstellen.
@end menu

@node Decerementeel voorbeeld
@unnumberedsubsubsec Voorbeeld met een aflopende teller

Om een loop met een aflopende teller te laten zien, gaan we de functie
@code{driehoek} zo herschrijven dat de teller naar nul vermindert.

Dit is het omgekeerde van de eerdere versie van de functie. In dit geval om
te ontdekken hoeveel steentjes nodig zijn om een driehoek met 3 rijen te
maken, tel het aantal steentjes in de derde rij, 3, bij het aantal in de
voorgaande rij, 2, en daarna tel het totaal van die rijen bij de rij die aan
ze voorafgaat, die 1 is.

Om op dezelfde manier het aantal steentjes in een driehoek met 7 rijen te
ontdekken, tel het aantal steentjes in de zevende rij, 7, bij het aantal van
de voorgaande rij, dat 6 is, en tel dan het totaal van deze twee rijen bij
de rij die aan ze voorafgaat, dat 5 is, enzovoorts. Net als in het vorige
voorbeeld betreft elke optelling twee getallen het totaal van de rijen die
al geteld zijn en het aantal steentjes in de rij die wordt opgeteld bij het
totaal. Dit proces van twee getallen optellen wordt opnieuw en opnieuw
herhaald totdat er geen steentjes meer zijn op op te tellen.

We weten met hoeveel steentjes we moeten beginnen: het aantal steentjes in
de laatste rij is gelijk aan het aantal rijen. Wanneer de driehoek zeven
rijen heeft, dan is het aantal steentjes in de laatste rij 7. Op dezelfde
manier weten we hoeveel steentjes in de daaraan voorafgaande rij zijn: het
is een minder dan het aantal in de rij.

@node Dec voorbeeld onderdelen
@unnumberedsubsubsec De onderdelen van de functiedefinitie

We starten met drie variabelen: het totaal aantal rijen in de driehoek, het
aantal steentjes in een rij en het totaal aantal steentjes, wat we gaan
uitrekenen. Deze variabelen noemen we resp. @code{aantal-rijen},
@code{aantal-steentjes-in-rij} en @code{totaal}.

Zowel @code{totaal} als @code{aantal-steentjes-in-rij} worden alleen binnen
de functie gebruikt en worden gedeclareerd met @code{let}. De initiële
waarde van @code{totaal} moet natuurlijk nul zijn. De initiële waarde van
@code{aantal-steentjes-in-rij} moet gelijk zijn aan het aantal rijen in de
driehoek, omdat de optelling met de langste rij begint.

@need 1250
Dit betekent dat we met een @code{let} expressie beginnen die er zo uit
ziet:

@smallexample
@group
(let ((totaal 0)
      (aantal-steentjes-in-rij aantal-rijen))
  @var{body}@dots{})
@end group
@end smallexample

Het totaal aantal steentjes kan worden gevonden door herhaaldelijk het
aantal steentjes van een rij bij het totaal al gevonden op te tellen, dat
wil zeggen herhaaldelijk de volgende expressie evalueren:

@smallexample
(setq totaal (+ totaal aantal-steentjes-in-rij))
@end smallexample

@noindent
Na het optellen van @code{aantal-steentjes-in-rij} bij @code{totaal}, het
@code{aantal-steentjes-in-rij} moet met een verminderd worden, omdat de
volgende keer dat de loop herhaalt, de voorafgaande rij opgeteld wordt bij
het totaal.

Het aantal steentjes in een voorafgaande rij is een minder dan het aantal
steentjes in een rij, waardoor de in Emacs Lisp ingebouwde functie @code{1-}
kan worden gebruikt om het aantal steentjes in de voorafgaand rij te
berekenen. Dit kan met de volgende expressie:

@smallexample
@group
(setq aantal-steentjes-in-rij      (1- aantal-steentjes-in-rij))
@end group
@end smallexample

Tenslotte weten we dat @code{while} loop de herhalende optellingen moet
stoppen wanneer er geen steentjes in een rij zijn. Daarom is de test voor de
@code{while} loop eenvoudig:

@smallexample
(while (> aantal-steentjes-in-rij 0)
@end smallexample

@node Dec voorbeeld samengesteld
@unnumberedsubsubsec De functiedefinitie samenstellen

We kunnen deze expressies samenvoegen om een functiedefinitie te creëren die
werkt. Bij onderzoek blijkt echter dat een van de lokale variabelen niet
nodig is!

@need 1250
De functiedefinitie ziet er zo uit:

@smallexample
@group
;;; @r{Eerste aflopende versie.}
(defun driehoek (aantal-rijen)
  "Tel het aantal steentjes in een driehoek."
  (let ((totaal 0)
        (aantal-steentjes-in-rij aantal-rijen))
    (while (> aantal-steentjes-in-rij 0)
      (setq totaal (+ totaal aantal-steentjes-in-rij))
      (setq aantal-steentjes-in-rij
            (1- aantal-steentjes-in-rij)))
    totaal))
@end group
@end smallexample

Zoals gezegd, deze functie werkt.

Maar we hebben @code{aantal-steentjes-in-rij} niet nodig. 

@cindex Argument als lokale variabele
Wanneer de functie @code{driehoek} wordt geëvalueerd wordt het symbool
@code{aantal-rijen} gebonden aan een getal, om het een initiële waarde te
geven. Dat getal kan in de body van de functie gewijzigd worden alsof het
een lokale variabele is, zonder enige angst dat zo'n wijziging effect heeft
op de waarde van de variabele buiten de functie. Dit is een erg zinvolle
karakteristiek van Lisp, het betekent dat de variabele @code{aantal-rijen}
overal in de functie kan worden gebruikt waar @code{aantal-steentjes-in-rij}
is gebruikt.

@need 800
Hier is de tweede versie van de functie, die netter geschreven is.

@smallexample
@group
(defun driehoek (getal)                ; @r{Second version.}
  "Geef som van de getallen 1 tot en met GETAL."
  (let ((totaal 0))
    (while (> getal 0)
      (setq totaal (+ totaal getal))
      (setq getal (1- getal)))
    totaal))
@end group
@end smallexample

In het kort, een goed geschreven @code{while} loop bestaat uit drie delen:

@enumerate
@item
Een test die onwaar teruggeeft nadat de loop het juiste aantal keer zichzelf
herhaald heeft.

@item
Een expressie waarvan de evaluatie de gewenste waarde teruggeeft nadat die
herhaaldelijk geëvalueerd is.

@item
Een expressie die de waarde wijzigt die aan de waar-of-onwaar-test wordt
doorgegeven zodat de test onwaar teruggeeft nadat de loop zichzelf het
juiste aantal keren heeft herhaald.
@end enumerate

@node dolist dotimes
@section Bespaar je tijd: @code{dolist} en @code{dotimes}

Naast @code{while} bieden @code{dolist} en @code{dotimes} looping. Soms zijn
ze sneller te schrijven dan een equivalente @code{while} loop. Beide zijn
Lisp macros. (@xref{Macros, , Macros, elisp, The GNU Emacs Lisp Reference
Manual}. )

@code{dolist} werkt net als een @code{while} loop die door een lijst
@sc{cdr}t: @code{dolist} verkort elke keer dat het loopt automatisch de
lijst---neemt de @sc{cdr} van de lijst---en bindt de @sc{car} van elke
kortere versie van de lijst aan het eerste van zijn argumenten.

@code{dotimes} loopt een specifiek aantal keren: je specificeert hoeveel
keer.

@menu
* dolist::                   dolist
* dotimes::                  dotimes
@end menu

@node dolist
@unnumberedsubsec De @code{dolist} macro
@findex dolist

Stel bijvoorbeeld dat je een lijst wilt omdraaien, zodat ``eerste''
``tweede'' ``derde'' wordt ``derde'' ``tweede'' ``eerste''.

@need 1250
In de praktijk gebruik je de functie @code{reverse} zoals hier:

@smallexample
@group
(setq dieren '(gazelle giraf leeuw tijger))

(reverse dieren)
@end group
@end smallexample

@need 800
@noindent
Hier is hoe je de lijst kan omdraaien met een @code{while} loop:

@smallexample
@group
(setq dieren '(gazelle giraf leeuw tijger))

(defun reverse-lijst-met-while (lijst)
  "Met while, draai de volgorde van LIJST om."
  (let (waarde)  ; zorg dat de lijst leeg begint
    (while lijst
      (setq waarde (cons (car lijst) waarde))
      (setq lijst (cdr lijst)))
    waarde))

(reverse-lijst-met-while dieren)
@end group
@end smallexample

@need 800
@noindent
En hier is hoe je het met een @code{dolist} macro kunt doen:

@smallexample
@group
(setq dieren '(gazelle giraf leeuw tijger))

(defun reverse-lijst-met-dolist (lijst)
  "Met dolist, draai de volgorde van LIJST om."
  (let (waarde)  ; zorg dat de lijst leeg begint
    (dolist (element lijst waarde)
      (setq waarde (cons element waarde)))))

(reverse-lijst-met-dolist dieren)
@end group
@end smallexample

@need 1250
@noindent
In Info plaats je de cursor achter het haakje sluiten van elke expressie en
je typt @kbd{C-x C-e}. In beide gevallen zou je het volgende moeten zien

@smallexample
(tijger leeuw giraf gazelle)
@end smallexample

@noindent
in het echogebied

Voor dit voorbeeld is bestaande functie @code{reverse} duidelijk het
beste. De @code{while} loop is net als ons eerste voorbeeld (@pxref{Loop
voorbeeld, , Een @code{while} loop en een lijst}). De @code{while} checkt
eerst of de lijst elementen heeft. Zo ja, dan construeert het een nieuwe
lijst door het eerste element van de lijst aan de bestaande lijst toe te
voegen (die in de eerste iteratie van de loop @code{nil} is.) Omdat het
tweede element aan de voorkant het eerste element, en het derde element aan
de voorkant van het tweede element wordt ingevoegd, wordt de lijst
omgedraaid.

In de expressie met een @code{while} loop maakt de @w{@code{(setq list (cdr
list))}} de lijst korter, waardoor de @code{loop} uiteindelijk stopt. Ook
geeft die bij elke herhaling van de loop de @code{cons} expressie een nieuw
eerste element en maakt het een nieuwe en kortere lijst.

De @code{dolist} expressie doet vrijwel hetzelfde als de @code{while}
expressie, behalve dat de @code{dolist} macro wat werk voor je doet wanneer
je een @code{while} expressie schrijft.

Net als een @code{while} loop, voert een @code{dolist} loopings uit. Het
verschil is dat het automatisch de lijst korter maakt elke dat het de loop
herhaalt---het @sc{cdr}-t zelf door de lijst---en het bindt automatisch de
@sc{car} van elke kortere versie van de lijst aan zijn eerste argument.

In het voorbeeld wordt naar de @sc{car} van elke kortere versie van de lijst
verwezen met het symbool @samp{element}, de lijst zelf wordt @samp{lijst}
genoemd. De rest van de @code{dolist} expressie staat in de body.

De @code{dolist} expressie bindt de @sc{car} van elke kortere versie van de
lijst aan @code{element} en evalueert de body van de expressie, en herhaalt
de loop. Het resultaat wordt teruggeven in @code{value}.

@node dotimes
@unnumberedsubsec De @code{dotimes} macro
@findex dotimes

De @code{dotimes} macro is vergelijkbaar met @code{dolist}, behalve dat het
een specifiek aantal keer de loop uitvoert.

Het eerste argument van @code{dotimes} krijgt rondom de loop elke keer de
getallen 0, 1, 2 enzovoorts. Je moet de waarde van het tweede argument
opgeven, het aantal keer dat de macro een loop moet doen.

@need 1250
Bijvoorbeeld et volgende bindt de getallen vanaf 0 tot, maar niet tot en
met, het getal 3 aan het eerste argument, @var{getal}, en maakt dan een
lijst van de drie getallen. (Het eerste getal is 0, het tweede getal is 1 en
het derde getal is 2, dit zijn drie getallen in totaal, beginnend met 0 als
het eerste getal.)

@smallexample
@group
(let (waarde)      ; anders is waarde een void variabele
  (dotimes (getal 3)
    (setq waarde (cons getal waarde)))
  waarde)

@result{} (2 1 0)
@end group
@end smallexample

@noindent
De manier om @code{dotimes} te gebruiken is om een expressie een
@code{aantal} aantal keer uit te voeren en dan het resultaat terug te geven,
als een lijst of als een atoom.

@need 1250
Hier is een voorbeeld van een @code{defun} dat @code{dotimes} gebruikt om
het aantal steetjes in een driehoek op te tellen.

@smallexample
@group
(defun driehoek-met-dotimes (aantal-rijen)
  "Tel het aantal steentjes met `dotimes' in een driehoek op."
(let ((totaal 0))  ; anders is totaal een void variabele
  (dotimes (aantal aantal-rijen)
    (setq totaal (+ totaal (1+ aantal))))
  totaal))

(driehoek-met-dotimes 4)
@end group
@end smallexample

@node Recursie
@section Recursie
@cindex Recursie

Een recursieve functie bevat code die de Lisp interpreter vertelt een
programma aan te roepen dat exact hetzelfde als zichzelf loopt, maar met
iets verschillende argumenten. De code loopt hetzelfde omdat het dezelfde
naam heeft. Hoewel het programma dezelfde naam is, is het echter niet
dezelfde entiteit. Het is verschillend. In het jargon heet het een andere
``instantie''.

Als het programma correct geschreven is dan gaan de iets verschillende
argumenten genoeg van het eerste argument verschillen dat de laatste
instantie stopt.

@menu
* Robots bouwen::            Zelfde model, verschillend serienummer ...
* Recursive definitie onderdelen::  Loop totdat je stopt ...
* Recursie met lijst::       Een lijst gebruiken als test of je moet 
                               recursen.
* Recursieve driehoek functie::  Recursieve driehoek functie
* Recursie met cond::        Recursie met cond
* Recursieve patronen::      Veelgebruikte templates.
* Geen uitstel::             Sla geen werk op ...
* Zonder uitstel oplossing::  Zonder uitstel oplossing
@end menu

@node Robots bouwen
@subsection Robots bouwen: de metafoor uitbreiden
@cindex Robots bouwen
@cindex Robots, bouwen

Soms is het nuttig om een draaiend programma te zien als een robot die zijn
werk doet. Tijdens het uitvoeren van het werk vraagt een recursieve functie
een tweede robot om te helpen. De tweede robot is op elke manier identiek
aan de eerste, behalve dat de tweede robot de eerste helpt en dat het andere
argumenten krijgt dan de eerste.

In een recursieve functie kan een tweede robot een derde roepen, en een
derde een vierde, enzovoort. Elk van deze is een aparte entiteit, maar het
zijn allemaal klonen.

Omdat elke robot iets verschillende instructies heeft---de argumenten
verschillen van de ene robot tot de volgende---moet de laatste robot weten
wanneer te stoppen.

Laten we de metafoor van een computerprogamma als robot uitbreiden.

Een functiedefinitie bevat de blauwdruk voor de robot. Wanneer je een
functiedefinitie installeert, dat wil zeggen, wanneer je een @code{defun}
macro evalueert, installeer je de benodigde apparatuur om robots te
bouwen. Het is net alsof je in een fabriek een assemblagelijn opzet. Robots
met dezelfde naam worden volgens dezelfde blauwdruk gebouwd. Dus ze hebben
hetzelfde modelnummer, maar een verschillend serienummer.

We zeggen vaak dat een recursieve functie ``zichzelf aanroept''. Wat we
willen zeggen is dat de instructies in een recursieve functie de Lisp
interpreter een andere functie laten aanroepen, die dezelfde naam heeft en
hetzelfde werk doet als de eerste, maar met verschillende argumenten.

Het is belangrijk dat de argumenten tussen de ene instantie en de volgende
verschillend zijn, anders zal het proces nooit stoppen.

@node Recursive definitie onderdelen
@subsection De onderdelen van een recursieve definitie
@cindex Onderdelen van een recursieve definitie
@cindex Recursive definitie onderdelen

Een recursieve functie bevat typisch een conditionele expressie die drie
onderdelen heeft:

@enumerate
@item
Een waar-of-onwaar-test die vaststelt of de functie opnieuw aangeroepen is,
hier de @dfn{doe-opnieuw-test} genoemd.

@item
De naam van de functie. Wanneer de naam wordt aangeroepen, wordt een nieuwe
instantie van de functie---een nieuwe robot als het ware---gecreëerd en
verteld wat te doen.

@item
Een expressie die elke keer dat de functie word aangeroepen een andere
waarde teruggeeft, hier de @dfn{volgende-stap-expressie} genoemd. Daardoor
zal het aan de nieuwe instantie doorgeven argument (of argumenten)
verschillen van wat aan de vorige instantie was doorgegeven. Dit zorgt dat
de conditionele expressie, de @dfn{doe-opnieuw-test}, na het correcte aantal
herhalingen naar onwaar testen.
@end enumerate

Recursieve functies kunnen veel eenvoudiger zijn dan elk ander soort
functie. Inderdaad, wanneer mensen ze beginnen te gebruiken, lijken ze vaak
zo mysterieus eenvoudig dat ze onbegrijpelijk zijn Net als op een fiets
rijden, vereist het lezen van een recursieve functie een bepaalde kundigheid
die in het begin moeilijk is maar later eenvoudig lijkt.

@need 1200
Er zijn verschillende gebruikelijke recursieve patronen. Een erg eenvoudig
patroon ziet er zo uit:

@smallexample
@group
(defun @var{naam-van-recursieve-functie} (@var{argument-list})
  "@var{documentatie}@dots{}"
  (if @var{doe-opnieuw-test}
    @var{body}@dots{}
    (@var{naam-van-recursieve-functie}
         @var{volgende-stap-expressie})))
@end group
@end smallexample

Elke keer dat een recursieve functie wordt geëvalueerd worden een nieuwe
instantie er van gecreëerd en verteld wat te doen. De argumenten vertellen
de instantie wat te doen.

Een argument wordt gebonden aan de waarde van de
volgende-stap-expressie. Elke instantie draait met een andere waarde van de
volgende-stap-expressie. 

De waarde van de volgende-stap-expressie wordt gebruik in de
doe-opnieuw-test.

De waarde die de volgende-stap-expressie teruggeeft wordt doorgegeven aan de
nieuwe instantie van de functie, die het evalueert (of een transformatie er
van) om vast te stellen of het moet doorgaan of stoppen. De
volgende-stap-expressie is zo ontworpen dat de doe-opnieuw-test onwaar
teruggeeft wanneer de functie niet langer meer moet worden herhaald.

De doe-opnieuw-test wordt soms de @dfn{stop conditie} genoemd, omdat het de
herhalingen stopt wanneer het als onwaar test.

@node Recursie met lijst
@subsection Recursie met een lijst

Het voorbeeld van een @code{while} loop dat de elementen van een lijst met
getallen kan recursief geschreven worden. Hier is de code inclusief een
expressie die de waarde van de variabele @code{dieren} naar een lijst zet.

Wanneer je dit in Info in Emacs leest, kan je expressie direct in Info
evalueren. Zo dan, dan moet je het voorbeeld kopiëren in het
@file{*scratch*} buffer en het daar evalueren. Gebruik @kbd{C-u C-x C-e} om
de @code{(print-elementen-recursief dieren)} te evalueren zodat de
resultaten in het buffer getoond worden, zo niet dan probeert de Lisp
interpreter de resultaten in een enkele regel in het echogebied samen te
knijpen.

Plaats de cursor direct achter het laatste haakje sluiten van de functie
@code{print-elementen-recursief}, voor het commentaar. Anders probeert de
Lisp interpreter het commentaar te evalueren.

@findex print-elementen-recursief
@smallexample
@group
(setq dieren '(gazelle giraf leeuw tijger))

(defun print-elementen-recursief (lijst)
  "Toon elk element van LIJST op een eigen regel.
Gebruikt recursie."
  (when lijst                            ; @r{doe-opnieuw-test}
        (print (car lijst))              ; @r{body}
        (print-elementen-recursief        ; @r{recursieve aanroep}
         (cdr lijst))))                  ; @r{volgende-stap-expressie}

(print-elementen-recursief dieren)
@end group
@end smallexample

De functie @code{print-elementen-recursief} test eerst of er inhoud in de
lijst is. Wanneer dat zo is, toont de functie het eerste element van de
lijst, de @sc{car} van de lijst. Vervolgens roept de functie zichzelf aan
maar geeft zichzelf niet de hele lijst maar het tweede en volgende elementen
van de lijst, de @sc{cdr} van de lijst.

Anders gezegd, wanneer de lijst niet leeg is, start de functie een nieuwe
instantie van code die vergelijkbaar is met de initiële code, maar is een
andere uitvoerings-thread, met andere argumenten dan de eerste instantie.

Weer anders gezegd, wanneer de lijst niet leeg is, bouwt de eerste robot een
tweede robot en zegt die wat de doen. De tweede robot is een ander individu
dan de eerste, maar is het zelfde model.

Wanneer de tweede evaluatie plaatsvindt wordt de @code{when} expressie
geëvalueerd en als die waar is toont die het eerste element van de lijst die
het als zijn argument had gekregen (die het tweede element is van de
originele lijst is). Hierna roept de functie zichzelf aan met de @sc{cdr}
van de lijst waarmee het aangeroepen is wat (de tweede ronde) de @sc{cdr}
van de @sc{cdr} van de originele lijst is.

Merk op dat hoewel we zeggen dat de functie ``zichzelf aanroept'' we
bedoelen dat de Lisp interpreter een nieuwe instantie van het programma
maakt en instrueert. De nieuwe instantie is een kloon van de eerste, maar is
een separaat individu.

Elke keer dat de functie zichzelf aanroept doet het dat met een kortere
versie van de originele lijst. Het creëert een nieuwe instantie die werkt
met een kortere lijst.

Uiteindelijk roept de functie zichzelf aan met een lege lijst. Dit creëert
een nieuwe instantie wiens argument @code{nil} is. De conditionele expressie
test de waarde van @code{lijst}. Omdat de waarde van @code{nil} @code{nil}
is, test de @code{when} expressie onwaar en dus wordt het dan-deel niet
geëvalueerd. De functie als geheel geeft @code{nil} terug.

@need 1200
Wanneer je de expressie @code{(print-elementen-recursief dieren)} in het
@file{*scratch*} buffer evalueert, zie je dit resultaat:

@smallexample
@group
gazelle

giraf

leeuw

tijger
nil
@end group
@end smallexample

@need 2000
@node Recursieve driehoek functie
@subsection Recursie in plaats van een teller
@findex driehoek-recursief

@need 1200
De in een eerdere beschreven functie @code{driehoek} kan ook recursief
worden geschreven. Dit ziet er zo uit:

@smallexample
@group
(defun driehoek-recursief (aantal)
  "Geef de som van de getallen 1 tot en met AANTAL terug.
Met recursie."
  (if (= aantal 1)                    ; @r{doe-opnieuw-test}
      1                               ; @r{dan-deel}
    (+ aantal                         ; @r{anders-deel}
       (driehoek-recursief            ; @r{recursieve aanroep}
        (1- aantal)))))               ; @r{volgende-stap-expressie}

(driehoek-recursief 7)
@end group
@end smallexample

@noindent
Je kunt deze functie installeren door het te evalueren en dan uitproberen
door @code{(driehoek-recursief 7)} te evalueren. (Denk er aan de cursor
direct achter het laatste haakje sluiten van de functiedefinitie te
plaatsen, voor het commentaar.)

Om te begrijpen hoe deze functie werkt, beschouwen we wat gebeurt in de
verschillende gevallen wanneer de functie 1, 2, 3 of 4 als waarde van zijn
argument krijgt doorgegeven.

@menu
* Recursief voorbeeld arg van 1 of 2::  Recursief voorbeeld arg van 1 of 2
* Recursief voorbeeld arg van 3 of 4::  Recursief voorbeeld arg van 3 of 4
@end menu

@ifnottex
@node Recursief voorbeeld arg van 1 of 2
@unnumberedsubsubsec Een argument van 1 of 2
@end ifnottex

Ten eerste wat gebeurt als de waarde van het argument 1 is?

De functie heef een @code{if} expressie na de documentatiestring. Die test
of de waarde van @code{aantal} gelijk is aan 1. Wanneer dat zo is, evalueert
Emacs het dan-deel van de @code{if} exprissie, die 1 teruggeeft als waarde
van de functie. (Een driehoek met één rij bevat één steentje.)

Stel echter dat de waarde van het argument 2 is. In dat geval evalueert
Emacs het anders-deel van de @code{if} expressie.

@need 1200
Het anders-deel bestaat uit een optelling, de recursieve aanroep van
@code{driehoek-recursief} en een aflopende actie, en ziet er zo uit:

@smallexample
(+ aantal (driehoek-recursief (1- aantal)))
@end smallexample

Wanneer Emacs deze expressie evalueert, wordt de binnenste expressie het
eerste geëvalueerd, daarna de andere delen opvolgend. Hier zijn de stappen
in detail:

@table @i
@item Stap 1 @w{  } Evalueer de binnenste expressie

De binnenste expressie is @code{1- aantal}, dus Emacs verlaagt de waarde van
@code{aantal} van 2 naar 1.

@item Stap 2 @w{  } Evalueer de functie @code{driehoek-recursief}.

De Lisp interpreter creëert een individuele instantie van
@code{driehoek-recursief}. Het maakt niet uit dat deze functie binnen
zichzelf staat. Emacs geeft het resultaat Stap 1 als argument gebruikt door
deze instantie van de functie @code{driehoek-recursief}.

In dit geval evalueert Emacs @code{driehoek-recursief} met een argument
1. Dit betekent dat deze evaluatie van @code{driehoek-recursief} 1
teruggeeft.

@item Stap 3 @w{  } Evalueer de waarde van @code{aantal}.

De variabele @code{aantal} is het tweede element van de lijst die start met
@code{+}. De waarde is 2.

@item Stap 4 @w{  } Evalueer de @code{+} expressie.

De @code{+} expressie ontvangt twee argumenten, de eerste van het evalueren
van @code{aantal} (Stap 3) en het tweede van de evaluatie van
@code{driehoek-recursief} (Stap 2).

Het resultaat van de optelling is de som van 2 plus 1 en het getal 3 wordt
teruggegeven. dit is correct. Een driehoek met twee rijen bevat drie
steentjes.
@end table

@node Recursief voorbeeld arg van 3 of 4
@unnumberedsubsubsec Een argument van 3 of 4

Stel dat @code{driehoek-recursief} wordt aangeroepen met een argument van 3.

@table @i
@item Stap 1 @w{  } Evaluaeer de doe-opnieuw-test.

De @code{if} expressie wordt eerst geëvalueerd. Dit is de doe-opnieuw-test
en geeft onwaar terug, dus het anders-deel van de @code{if} expressie wordt
geëvalueerd. (Merk op dat in dit voorbeeld de doe-opnieuw-test zorgt dat de
functie zichzelf aanroept wanneer die onwaar test, en niet wanneer die waar
test.)

@item Stap 2 @w{  } Evalueer de binnenste expressie van het anders-deel.

De binnenste expressie van het anders-deel wordt geëvalueerd, die 3 verlaagt
naar 2. Dit is de volgende-stap-expressie.

@item Stap 3 @w{  } Evalueer de functie @code{driehoek-recursief}.

Het getal 2 is doorgegeven aan de functie @code{driehoek-recursief}.

We weten al wat gebeurt wanneer Emacs de @code{driehoek-recursief} evalueert
met een argument van 2. Nadat het door de eerder beschreven reeks acties
heen is gegaan, geeft het een waarde 3 terug. Dus dat is wat hier gebeurt.

@item Stap 4 @w{  } Evalueer de optelling.

3 wordt doorgegeven als een argument van de optelling en wordt opgeteld bij
het getal waarmee de functie was aangeroepen, dat 3 is.
@end table

@noindent
De waarde teruggeven door de functie als geheel is 6.

Nu we weten wat gebeurt wanneer @code{driehoek-recursief} wordt aangeroepen
met een argument van 3, ligt het voor de hand wat gebeurt als het wordt
aangeroepen met een argument van 4.

@quotation
@need 800
In de recursieve aanroep, geeft de evaluatie van

@smallexample
(driehoek-recursief (1- 4)
@end smallexample

@need 800
@noindent
de waarde van het evalueren van

@smallexample
(driehoek-recursief 3)
@end smallexample

@noindent
wat 6 is en deze waarde wordt opgeteld bij 4 door de optelling in de derde
regel.
@end quotation

@noindent
De waarde teruggeven door de functie als geheel is 10.

Elke keer dat @code{driehoek-recursief} wordt geëvalueerd, evalueert het een
versie van zichzelf---een andere instantie van zichzelf---met een kleiner
argument, totdat het argument klein genoeg is en het niet zichzelf
evalueert.

Merk op dat dit specifieke ontwerp voor een recursieve functie vereist dat
operaties kunnen worden uitgesteld.

Voordat @code{(driehoek-recursief 7)} een antwoord kan berekenen, moet het
@code{(driehoek-recursief 6)} aanroepen, en voordat
@code{(driehoek-recursief 6)} een antwoord kan berekenen, moet het
@code{(driehoek-recursief 5)} aanroepen, enzovoorts. Met andere woorden, de
berekening die @code{(driehoek-recursief 7)} maakt moet worden uitgesteld
totdat @code{(driehoek-recursief 6)} een berekening gemaakt heeft, en
@code{(driehoek-recursief 6)} moet worden uitgesteld totdat
@code{(driehoek-recursief 5)} klaar is, enzovoorts.

Wanneer al deze instanties van @code{driehoek-recursief} beschouwd worden
als verschillende robots, dan moet de eerste robot wachten tot de tweede
robot zijn werk gedaan heeft, en die moet weer wachten tot de derde robot
klaar is, enzovoorts.

Er is een manier om dit soort uitstel te omzeilen, die we bespreken in
@ref{Geen uitstel, , Recursie zonder uitstel}.

@node Recursie met cond
@subsection Recursie voorbeeld met @code{cond} 
@findex cond

De eerder beschreven versie van @code{driehoek-recursief} is geschreven met
de speciale vorm @code{if}. Het kan ook worden geschreven met een andere
speciale vorm met de naam @code{cond}. De naam van de speciale vorm
@code{cond} is een afkorting van het woord @code{conditioneel}.

Alhoewel de speciale vorm @code{cond} niet zo vaak in de Emacs Lisp broncode
als @code{if}, wordt het vaak genoeg gebruikt om het uit te leggen.

@need 800
Het sjabloon voor een @code{cond} expressie ziet er zo uit: 

@smallexample
@group
(cond
 @var{body}@dots{})
@end group
@end smallexample

@noindent
waar de @var{body} een reeks lijsten is.

@need 800
Meer volledig ziet het sjabloon er zo uit:

@smallexample
@group
(cond
 (@var{eerste-waar-of-onwaar-test} @var{eerste-consequentie})
 (@var{tweede-waar-of-onwaar-test} @var{tweede-consequentie})
 (@var{derde-waar-of-onwaar-test} @var{derde-consequentie})
  @dots{})
@end group
@end smallexample

Wanneer de Lisp interpreter de @code{cond} expressie evalueert, evalueert
die het eerste element (de @sc{car} van de waar-of-onwaar-test) van de
expressie in een reeks van expressies binnen de body van de @code{cond}.

Wanneer de waar-of-onwaar-test @code{nil} teruggeeft, wordt de rest van de
expressie, de consequentie, overgeslagen en wordt de volgende expressie
geëvalueerd. Wanneer een expressie gevonden wordt wiens waar-of-onwaar-test
een waarde ongelijk aan @code{nil} teruggeeft, wordt de consequentie van die
expressie geëvalueerd. De consequentie kan een of meer expressies
zijn. Wanneer de consequentie meer dan een expressie bevat worden de
expressie achtereenvolgens geëvalueerd en de waarde van de laatste wordt
teruggegeven. Wanneer de expressie geen consequentie heeft, dan wordt de
waarde van de waar-of-onwaar-test teruggegeven.

Wanneer geen van de waar-of-onwaar-tests waar test, dan geeft de @code{cond}
expressie @code{nil} terug.

@need 1250
De functie @code{driehoek} met een @code{cond} ziet er zo uit:

@smallexample
@group
(defun driehoek-met-cond (getal)
  (cond ((<= getal 0) 0)
        ((= getal 1) 1)
        ((> getal 1)
         (+ getal (driehoek-met-cond (1- getal))))))
@end group
@end smallexample

@noindent
In dit voorbeeld geeft de @code{cond} 0 terug wanneer het getal kleiner of
gelijk aan 0 is, het geeft 1 terug wanneer het getal 1 is, en het evalueert
@code{(+ getal (driehoek-met-cond (1- getal)))} wanneer het getal groter dan
1 is.

@node Recursieve patronen
@subsection Recursieve patronen
@cindex Recursieve patronen

Here are three common recursive patterns.  Each involves a list.  Recursion
does not need to involve lists, but Lisp is designed for lists and this
provides a sense of its primal capabilities.

@menu
* Elke::                     Elke
* Accumuleren::              Accumuleren
* Bewaar::                   Bewaar
@end menu

@node Elke
@unnumberedsubsubsec Recursief patroon: @emph{elke}
@cindex Elke, soort van recursief patroon
@cindex Recursive pattern - elke

In het @code{elke} recursieve patroon wordt een actie uitgevoerd op elk
element van de lijst.

@need 1500
Het basispatroon is:

@itemize @bullet
@item
Als een lijst leeg is, geef @code{nil} terug.
@item
Else, act on the beginning of the list (the @sc{car} of the list)
    @itemize @minus
    @item
    through a recursive call by the function on the rest (the @sc{cdr}) of the
list,
    @item
    and, optionally, combine the acted-on element, using @code{cons}, with the
results of acting on the rest.
    @end itemize
@end itemize

@need 1500
Hier is een voorbeeld:

@smallexample
@group
(defun kwadrateer-elke (getallen-lijst)
  "Kwadrateer elk van een GETALLEN Lijst, recursief."
  (if (not getallen-lijst)                ; doe-opnieuw-test
      nil
    (cons
     (* (car getallen-lijst) (car getallen-lijst))
     (kwadrateer-elke (cdr getallen-lijst))))) ; volgende-stap-expressie
@end group

@group
(kwadrateer-elke '(1 2 3))
    @result{} (1 4 9)
@end group
@end smallexample

@need 1200
@noindent
Wanneer @code{getallen-lijst} leeg is, doe niets. Maar als die inhoud heeft,
construeer een lijst door het kwadraat van het eerste getal te combineren
met een lijst met het resultaat van de recursieve aanroep.

(Het voorbeeld volgt exact dit patroon: @code{nil} wordt teruggeven wanneer
de getallen-lijst leeg is. In de praktijk schrijf je conditional zo dat het
de actie uitvoert wanneer de lijst met getallen niet leeg is.)

De functie @code{print-elementen-recursief} (@pxref{Recursie met lijst, ,
Recursie met een lijst}) is een ander voorbeeld van een @code{elke} patroon,
behalve vat in dit geval, in plaats van het samenbrengen van de resultaten
met @code{cons}, we elk output-element tonen.

@need 1250
De functie @code{print-elementen-recursief} ziet er zo uit:

@smallexample
@group
(setq dieren '(gazelle giraf leeuw tijger))
@end group

@group
(defun print-elementen-recursief (lijst)
  "Toon elk element van LIJST op een eigen regel.
Gebruikt recursie."
  (when lijst                            ; @r{doe-opnieuw-test}
        (print (car lijst))              ; @r{body}
        (print-elementen-recursief        ; @r{recursieve aanroep}
         (cdr lijst))))                  ; @r{volgende-stap-expressie}

(print-elementen-recursief dieren)
@end group
@end smallexample

@need 1500
Het patroon voor @code{print-elementen-recursief} is:

@itemize @bullet
@item
Wanneer de lijst leeg is, doe niets.
@item
But when the list has at least one element,
    @itemize @minus
    @item
    act on the beginning of the list (the @sc{car} of the list),
    @item
    and make a recursive call on the rest (the @sc{cdr}) of the list.
    @end itemize
@end itemize

@node Accumuleren
@unnumberedsubsubsec Recursief patroon: @emph{accumuleren}
@cindex Accumuleren, type recursief patroon
@cindex Recursief patroon - accumuleren

Een ander recursief patroon heet het @code{accumuleren} patroon. In het
@code{accumuleren} recursieve patroon wordt een actie uitgevoerd op elk
element van een lijst en het resultaat van die actie wordt geaccumuleerd met
de resultaten van het uitvoeren van die actie op de andere elementen.

Dit lijkt erg op het @code{elke} patroon met @code{cons}, behalve dat
@code{cons} niet wordt gebruikt, maar een andere combinerende functie.

@need 1500
Het patroon is:

@itemize @bullet
@item
Als een lijst leeg is, geef nul terug of een andere constante.
@item
Else, act on the beginning of the list (the @sc{car} of the list),
    @itemize @minus
    @item
    and combine that acted-on element, using @code{+} or some other combining
function, with
    @item
    a recursive call by the function on the rest (the @sc{cdr}) of the list.
    @end itemize
@end itemize

@need 1500
Hier is een voorbeeld:

@smallexample
@group
(defun sommeer-elementen (getallen-lijst)
  "Tel de elementen van GETALLEN-LIJST bij elkaar op."
  (if (not getallen-lijst)
      0
    (+ (car getallen-lijst) (sommeer-elementen (cdr getallen-lijst)))))
@end group

@group
(sommeer-elementen '(1 2 3 4))
    @result{} 10
@end group
@end smallexample

@xref{Bestandenlijst, , Een lijst met bestanden maken}, voor een uitleg van
het accumuleren patroon.

@node Bewaar
@unnumberedsubsubsec Recursieve patronen: @emph{bewaren}
@cindex Bewaren, type recursief patroon
@cindex Recursieve patronen - bewaren

Een derde recursief patroon het het @code{bewaren} patroon. In het
@code{bewaren} recursieve patroon wordt elk element van de lijst getest, het
element wordt behandeld en de resultaten worden alleen bewaard wanneer het
element aan een criterium voldoet.

Opnieuw lijkt dit erg op het @code{elke} patroon, behalve dat elementen
worden overgeslagen tenzij ze aan een criterium voldoen.

@need 1500
Het patroon heeft drie elementen:

@itemize @bullet
@item
Als een lijst leeg is, geef @code{nil} terug.
@item
Else, if the beginning of the list (the @sc{car} of the list) passes a test
    @itemize @minus
    @item
    act on that element and combine it, using @code{cons} with
    @item
    a recursive call by the function on the rest (the @sc{cdr}) of the list.
    @end itemize
@item
Otherwise, if the beginning of the list (the @sc{car} of the list) fails the
test
    @itemize @minus
    @item
    skip on that element,
    @item
    and, recursively call the function on the rest (the @sc{cdr}) of the list.
    @end itemize
@end itemize

@need 1500
Hier is een voorbeeld met @code{cond}:

@smallexample
@group
(defun bewaar-drie-letter-woorden (woorden-lijst)
  "Bewaar drie-letter woorden in WOORDEN-LIJST."
  (cond
   ;; Eerst doe-opnieuw-test: stop-conditie
   ((not woorden-lijst) nil)

   ;; Tweede doe-opnieuw-test: wanneer te behandelen
   ((eq 3 (length (symbol-name (car woorden-lijst))))
    ;; combineer behandelde elementen met recursieve aanroep op kortere lijst
    (cons (car woorden-lijst) (bewaar-drie-letter-woorden (cdr woorden-lijst))))

   ;; Derde doe-opnieuw-test: wanneer element over te slaan;
   ;;   recursief aanroepen kortere lijst met volgende-stap-expressie
   (t (bewaar-drie-letter-woorden (cdr woorden-lijst)))))
@end group

@group
(bewaar-drie-letter-woorden '(een twee drie vier vijf zes))
    @result{} (een zes)
@end group
@end smallexample

Het spreekt voor zich dat je @code{nil} als test voor wanneer te stoppen
niet hoeft te gebruiken, je kunt natuurlijk deze patronen combineren.

@node Geen uitstel
@subsection Recursie zonder uitstel
@cindex Uitstel in recursie
@cindex Recursie zonder uitstel

Laten we nog een keer de functie @code{driehoek-recursief} beschouwen. We
zullen zien dat de tussenliggende berekeningen worden uitgesteld tot ze
allemaal uitgevoerd kunnen worden.

@need 800
Hier is de functiedefinitie:

@smallexample
@group
(defun driehoek-recursief (aantal)
  "Geef de som van de getallen 1 tot en met AANTAL terug.
Met recursie."
  (if (= aantal 1)                    ; @r{doe-opnieuw-test}
      1                               ; @r{dan-deel}
    (+ aantal                         ; @r{anders-deel}
       (driehoek-recursief            ; @r{recursieve aanroep}
        (1- aantal)))))               ; @r{volgende-stap-expressie}

@end group
@end smallexample

Wat gebeurt er wanneer de deze functie met een argument van 7 aanroepen?

De eerste instantie van de functie @code{driehoek-recursief} telt het getal
7 bij de waarde die de tweede instantie van @code{driehoek-recursief}
teruggeeft, een instantie de een argument van 6 krijgt doorgestuurd. Dat wil
zeggen dat de eerste berekening is:

@smallexample
(+ 7 (driehoek-recursief 6))
@end smallexample

@noindent
De eerste instantie van @code{driehoek-recursief}---je kunt het zien als een
kleine robot---kan zijn werk niet afmaken. Het moet de berekening voor
@code{(driehoek-recursief 6)} overdragen aan een tweede instantie van het
programma, aan een tweede robot. De tweede individu is compleet verschillend
van het eerste, het is, in het jargon, een ``andere instantie''. Of, anders
gezegd, een andere robot. Die is hetzelfde model als de eerste, maar met een
verschillende serienummer.

En wat geeft @code{(driehoek-recursief 6)} terug? Het geeft het getal 6
opgeteld bij de waarde teruggeven door het evalueren van
@code{driehoek-recursief} met een argument van 5. Met het robot metafoor,
het vraagt een andere robot om hulp.

@need 800
Nu is het totaal:

@smallexample
(+ 7 6 (driehoek-recursief 5))
@end smallexample

@need 800
En wat gebeurt hierna?

@smallexample
(+ 7 6 5 (driehoek-recursief 4))
@end smallexample

Elke keer dat @code{driehoek-recursief} wordt aangeroepen, behalve de
laatste keer, maakt het een nieuwe instantie van het programma---een andere
robot---en vraagt die een berekening te maken.

@need 800
Uiteindelijk is de volledige berekening opgezet en uitgevoerd:

@smallexample
(+ 7 6 5 4 3 2 1)
@end smallexample

Dit ontwerp van de functie stelt de berekening van eerste uit tot de tweede
kan worden gedaan, dan stelt die uit tot de derde kan worden gedaan,
enzovoorts. Elk uitstel betekent dat de computer moet onthouden waarop
gewacht wordt. Dat is geen probleem wanneer er maar een stappen zijn, zoals
in dit voorbeeld. Maar het kan een probleem worden wanneer er meer stappen
zijn.

@node Zonder uitstel oplossing
@subsection Zonder uitstel oplossing
@cindex Zonder uitstel oplossing
@cindex Oplossing zonder uitstel

De oplossing van het probleem van de uitgestelde operaties is het op een
manier te schrijven die de operaties niet uitstelt@footnote{De uitdrukking
@dfn{tail-recursie} wordt gebruikt om zo'n proces te beschrijven, een die
constante ruimte gebruikt.}. Dit vereist het schrijven volgens een ander
patroon, een die vaak het schrijven van twee functiedefinities inhoudt, een
initialisatiefunctie en een hulpfunctie.

De initialisatiefunctie zet de klus op, de hulpfunctie doet het werk.

@need 1200
Hier zijn twee functiedefinities voor het optellen van getallen. Zij zijn zo
eenvoudig dat ik moeilijk vind ze te begrijpen.

@smallexample
@group
(defun driehoek-initialisatie (aantal)
  "Geef de som van de getallen 1 tot en met AANTAL.
Dit is the initialisatiecomponent van een duo van twee functies
met recursie ."
  (driehoek-recursieve-helper 0 0 aantal))
@end group
@end smallexample

@smallexample
@group
(defun driehoek-recursieve-helper (som teller aantal)
  "Geef SOM terug, met TELLER, tot en met AANTAL.
Dit is de hulpcomponent van een duo van twee functies
met recursie."
  (if (> teller aantal)
      som
    (driehoek-recursieve-helper (+ som teller) ; @r{som}
                               (1+ teller)     ; @r{teller}
                               aantal)))       ; @r{aantal}
@end group
@end smallexample

@need 1250
Installeer beide functiedefinities door ze te evalueren en roep dan
@code{driehoek-initialisatie} met twee rijen aan:

@smallexample
@group
(driehoek-initialisatie 2)
    @result{} 3
@end group
@end smallexample

De initialisatiefunctie roept de eerste instantie van de hulpfunctie met
drie argumenten aan: nul, nul, een getal dat het aantal rijen van de
driehoek is.

De eerste twee aan de hulpfunctie doorgegeven argumenten zijn
initialisatie-waarden. Deze waarden worden aangepast wanneer
@code{driehoek-recursieve-helper} nieuwe instanties aanroept.@footnote{Het
jargon is lichtelijk verwarrend: @code{driehoek-recursieve-helper} gebruikt
een proces dat iteratief is in een procedure die recursief is. Dit proces
het iteratief omdat de computer maar die waarden hoeft bij te houden:
@code{som}, @code{teller} en @code{aantal}. De procedure is recursief omdat
de functie zichzelf aanroept. Anderzijds worden beide processen en de door
@code{driehoek-recursief} gebruikte procedure recursief genoemd. Het woord
``recursief'' heeft verschillende betekenissen in de twee contexten.}

Laten we kijken wat gebeurt wanneer we een driehoek met een rij
hebben. (Deze driehoek bevat één steentje!)

@need 1200
@code{driehoek-initialisatie} roept zijn hulpfunctie aan met de argumenten
@w{@code{0 0 1}}. Die functie voert de conditionele test uit of @code{(>
teller aantal)}:

@smallexample
(> 0 1)
@end smallexample

@need 1200
@noindent
een ziet dat het resultaat onwaar is, en dus roept deze het anders-deel van
de @code{if} clausule aan:

@smallexample
@group
    (driehoek-recursieve-helper
     (+ som teller)  ; @r{som plus teller} @result{} @r{som}
     (1+ teller)     ; @r{verhoog teller} @result{} @r{teller}
     aantal)         ; @r{aantal blijft hetzelfde}
@end group
@end smallexample

@need 800
@noindent
wat eerst uitrekent:

@smallexample
@group
(driehoek-recursieve-helper (+ 0 0)  ; @r{som}
                            (1+ 0)   ; @r{teller}
                            1)       ; @r{aantal}
@exdent wat is:

driehoek-recursieve-helper 0 1 1
@end group
@end smallexample

Opnieuw wordt @code{(> teller aantal)} onwaar, en opnieuw gaat de Lisp
interpreter de @code{driehoek-recursieve-helper} evalueren, en maakt een
nieuwe instantie met nieuwe argumenten.

@need 800
Deze nieuwe instantie is:

@smallexample
@group
    (driehoek-recursieve-helper
     (+ som teller)  ; @r{som plus teller} @result{} @r{som}
     (1+ teller)     ; @r{verhoog teller} @result{} @r{teller}
     aantal)         ; @r{aantal blijft hetzelfde}

@exdent wat is:

(driehoek-recursieve-helper 1 2 1)
@end group
@end smallexample

In dit geval test de @code{(> teller aantal)} op waar! Dus geeft de
instantie de waarde van de som terug, die 1 is, zoals verwacht.

Laten we nu @code{driehoek-initialisatie} een argument van 2 geven, om te
ontdekken hoeveel steentjes een driehoek met twee rijen bevat.

Die functie roept @code{(driehoek-recursieve-helper 0 0 2)} aan.

@need 800
In stappen, zijn de aangeroepen instanties:

@smallexample
@group
(driehoek-recursieve-helper 0    1       2)

(driehoek-recursieve-helper 1    2       2)

(driehoek-recursieve-helper 3    3       2)
@end group
@end smallexample

Wanneer de laatste instantie wordt aangeroepen, test de de @code{(> teller
aantal)} op waar, dus de instantie geeft de waarde van @code{som} terug, die
3 is.

Dit soort patronen helpt wanneer je functies schrijft die veel resources in
de computer kunnen gebruiken.

@need 1500
@node Looping oefening
@section Looping oefening

@itemize @bullet
@item
Schrijf een functie vergelijkbaar met @code{driehoek} waar elke rij een
waarde heeft die het kwadraat is van het rijnummer. Gebruik een @code{while}
loop.

@item
Schrijf een functie vergelijkbaar met @code{driehoek} die de waarden
vermenigvuldigt in plaats van optelt.

@item
Herschrijf deze twee functies recursief. Herschrijf ze met gebruik van
@code{cond}.

@c comma in printed title causes problem in Info cross reference
@item
Schrijf een functie voor Texinfo mode die een index-entry creëert aan het
begin van een paragraaf voor elke @samp{@@dfn} in die paragraaf. (In een
Texinfo bestand, markeert @samp{@@dfn} een definitie. Dit boek is geschreven
in Texinfo.)

Veel van de functies die je nodig hebt zijn beschreven in twee voorgaande
hoofdstukken, @ref{Knippen en opslaan van tekst, , Knippen en opslaan van
tekst}, en @ref{Yanking, , Tekst terug yanken}. Wanneer je
@code{forward-paragraph} gebruikt om de index-entry aan het begin van de
paragraaf te plaatsten, kun je met @w{@kbd{C-h f}}
(@code{describe-function}) ontdekken hoe je het commando achterwaarts laat
werken.

Voor meer informatie, zie
@ifinfo
@ref{Indicating, , Indicating Definitions, texinfo}
@end ifinfo
@ifhtml
@ref{Indicating, , Indicating, texinfo, Texinfo Manual}, gaat naar een
Texinfo manual in de huidige directory.  Of, als je op internet bent, zie
@uref{https://www.gnu.org/software/texinfo/manual/texinfo/}
@end ifhtml
@iftex
``Indicating Definitions, Commands, etc.''@: in @cite{Texinfo, The GNU
Documentation Format}.
@end iftex
@end itemize

@node Regexp zoeken
@chapter Reguliere expressie zoekopdrachten
@cindex Zoeken, illustreren
@cindex Reguliere expressie zoekopdrachten
@cindex Patronen, zoeken naar
@cindex Bewegen per zin en paragraaf
@cindex Zinnen, bewegen per
@cindex Paragrafen, bewegen per

Zoekopdrachten met reguliere expressies worden uitgebreid gebruikt in
Emacs. De twee functies @code{forward-sentence} en @code{forward-paragraph}
illustreren deze zoekopdrachten goed. Zij gebruiken reguliere expressies om
uit te zoeken waarheen de point te verplaatsen. De uitdrukking ``reguliere
expressie'' wordt vaak geschreven als ``regexp''.

Reguliere expressie zoekopdrachten zijn beschreven in @ref{Regexp Search, ,
Regular Expression Search, emacs, The GNU Emacs Manual}, en ook in
@ref{Regular Expressions, , , elisp, The GNU Emacs Lisp Reference
Manual}. Tijdens het schrijven van dit hoofdstuk ga ik er vanuit dat je
tenminste een beetje met ze kennis gemaakt hebt. Het belangrijkste punt om
te onthouden is dat reguliere expressies je in staat stellen naar patronen
te zoeken en ook naar letterlijke karakterstrings. De code in
@code{forward-sentence} zoekt bijvoorbeeld naar patronen van mogelijke
karakters die het einde van een zin kunnen markeren, en verplaatst point
naar die plek.

Voordat we naar de code van de functie @code{forward-sentence} kijken, is
het waardevol te overwegen wat het patroon is dat het einde van een zin moet
zijn. Het patroon wordt in de volgende sectie besproken, daarop volgt een
beschrijving van de reguliere expressie zoekfunctie,
@code{re-search-forward}. De functie @code{forward-sentence} wordt in de
daaropvolgende sectie besproken. Tenslotte wordt de functie
@code{forward-paragraph} in de laatste sectie van dit hoofdstuk
beschreven. @code{forward-paragraph} is een complexe functie die
verschillende nieuwe eigenschappen introduceert.

@menu
* sentence-end::             De reguliere expressie van @code{sentence-end}.
* re-search-forward::        Erg vergelijkbaar met @code{search-forward}.
* forward-sentence::         Een eenvoudig voorbeeld van regexp 
                               zoekopdracht.
* forward-paragraph::        Een iets complexer voorbeeld.
* Regexp terugblik::         Regexp terugblik
* re-search oefeningen::     re-search oefeningen
@end menu

@node sentence-end
@section De reguliere expressie for @code{sentence-end}
@findex sentence-end

Het symbool @code{sentence-end} is gebonden aan het patroon dat het einde
van een zin markeert. Wat moet deze reguliere expressie zijn?

Het is duidelijk dat een zin kan worden beëindigd met een punt, een
vraagteken of een uitroepteken. In het Engels worden inderdaad alleen
clausules die met een van deze drie karakters eindigen beschouwd als het
eind van een zin. Dit betekent dat het patroon de volgende karakterset moet
bevatten:

@smallexample
[.?!]
@end smallexample

We willen echter niet dat @code{forward-sentence} gewoon naar een punt,
vraagteken of uitroepteken springt, omdat zo'n karakter in het midden van
een zin kan worden gebruikt. Een punt wordt bijvoorbeeld gebruikt na een
afkorting. Meer informatie is dus benodigd.

Volgens de conventie typ je in het Engels twee spaties achter elke zin, maar
alleen één spatie achter een punt, vraagteken of uitroepteken in de body van
een zin. Een een punt, vraagteken of uitroepteken gevolgd door twee spaties
is daarom een goede indicator van het einde van een zin. In een bestand
echter, kan een tab of het einde van regel in plaats van de twee spaties
staan. Dit betekent dat de reguliere expressie deze drie alternatieven moet
bevatten.

@need 800
Deze groep van alternatieven zijn er zo uit:

@smallexample
@group
\\($\\| \\|  \\)
       ^   ^^
      TAB  SPC
@end group
@end smallexample

@noindent
Hier geeft @samp{$} het einde van de regel aan, en ik heb aangegeven waar de
tab en de twee spaties zijn ingevoegd in de expressie. Beide zijn ingevoegd
door de betreffende letters in de expressie op te nemen.

Twee backslashes, @samp{\\} zijn vereist voor de haakjes en het vertikale
streepje (vertical bar): de eerste backslash quote hde volgende backslash in
Emacs, en de tweede geeft aan dat het volgende karakter, het haakje of het
vertikale streepje, speciaal is.

@need 1000
Een zin kan ook door een of meer carriage returns gevolgd worden, zoals dit:

@smallexample
@group
[
]*
@end group
@end smallexample

@noindent
Zoals tabs en spaties wordt een carriage return ingevoegd in een reguliere
expressie door het letterlijk in te voegen. De ster geeft aan dat de
@key{RET} nul of meer keer herhaald kan worden.

Maar het einde van een zin bestaat niet alleen uit een punt, vraagteken of
uitroepteken gevolgd door passende ruimte: een aanhalingsteken sluiten, of
een soort sluitend haakje kan aan de spatie voorafgaan. Een of meer van deze
tekens of haakjes kan aan de spatie voorafgaan. Dit vereist een expressie
die er zo uitziet:

@smallexample
[]\"')@}]*
@end smallexample

De eerste @samp{]} is het eerste karakter in deze expressie, het tweede
karakter is @samp{"}, die voorafgegaan wordt door een @samp{\} om Emacs te
vertellen dat de @samp{"} @emph{niet} speciaal is. De laatste drie karakters
zijn @samp{'}, @samp{)} en @samp{@}}.

Dit alles suggereert ons wat de reguliere expressie voor het markeren van
het eind van een zin zou moeten zijn. En wanneer we @code{sentence-end}
evalueren, zien we dat het inderdaad de volgende waarde teruggeeft:

@smallexample
@group
sentence-end
     @result{} "[.?!][]\"')@}]*\\($\\|     \\|  \\)[
]*"
@end group
@end smallexample

@noindent
(Nou, niet in GNU Emacs 22. Dat is omdat gestreefd is het proces simpeler te
maken en meer bijzondere karakters en talen te hanteren. Wanneer de waarde
van @code{sentence-end} @code{nil} is, gebruik dan de waarde gedefinieerd
door de functie @code{sentence-end}. (Hier is een gebruik van het verschil
tussen een waarde en een functie in Emacs Lisp.) De functie geeft de waarde
terug die geconstrueerd is met de variabelen @code{sentence-end-base},
@code{sentence-end-double-space}, @code{sentence-end-without-period}, and
@code{sentence-end-without-space}. De kritieke variabele
@code{sentence-end-base}. De globale waarde daarvan lijkt op die hierboven
beschreven maar bevat twee extra aanhalingstekens. Deze zijn op
verschillende manieren gebogen. Wanneer de variabele
@code{sentence-end-without-period} waar is, dan vertelt dat Emacs dat een
zin mag eindigen zonder punt, zoals Taise tekst.

@ignore
@noindent
(Note that here the @key{TAB}, two spaces, and  @key{RET} are shown
literally in the pattern.)

This regular expression can be deciphered as follows:

@table @code
@item [.?!]
Het eerste deel van het patroon zijn de drie karakters, een punt, een vraagteken en een uitroepteken, tussen vierkante haken. Het patroon met met een van deze karakters beginnen.
@item []\"')@}]*
Het tweede deel van het patroon is de groep van haakjes sluiten en vraagtekens, die nul of meer keer kunnen verschijnen. Deze mogen op de punt, vraagteken of uitroepteken volgen. Een backslash, @samp{\} gevold door de dubbele aanhalingstekens, @samp{"}, geven in een reguliere expressie de klasse string-quote karakters aan. Meestal is het dubbele aanhalingsteken het enige karakter in deze klasse. Het sterretje, @samp{*}, geeft aan dat de items in de voorgaande groep (de groep omgeven door de vierkante haken,@samp{[]}) nul of meer keer herhaald mag worden.
@item \\($\\|   \\|  \\)
Het derde deel van het patroon is een of meer van: of het einde van een regel, of twee spaties, of een tab. De dubbele backslashes worden gebruikt om te voorkomen dat Emacs de haakjes en het vertikale streepje @samp{} onderdeel van het zoekpatroon ziet, met de haakjes wordt de groep gemarkeerd en de vertikale streepjes geven aan dat de patronen aan weerzijden van het streepje alternatieven zijn. Het dollar-teken geeft het einde van een regel aan en zowel de twee spaties als de tab zijn ingevoegd om zich zelf aan te geven.
@item [@key{RET}]*
Het laatste deel van het patroon tenslotte geeft aan dat het einde 
van de regel of witte ruimte volgend op een punt, vraagteken of 
uitroepteken mag, maar hoeft niet, gevold worden door een of meer 
carriage returns. De carriage return wordt in het patroon patroon 
ingevoegd als een carriage return tussen vierkante haken, maar wordt 
hier getoond als @key{RET}.
@end table
@end ignore

@node re-search-forward
@section De functie @code{re-search-forward}
@findex re-search-forward

De functie @code{re-search-forward} lijkt erg op de functie
@code{search-forward}. (@xref{search-forward, , De functie
@code{search-forward}}.)

@code{re-search-forward} zoekt naar een reguliere expressie. Wanneer de
zoekopdracht geslaagd is, zet het point onmiddellijk achter het laatste
karakter in het doel. Wanneer de zoekopdracht achterwaarts is, dan zet het
point direct voor het eerste karakter in het doel. Je kunt
@code{re-search-forward} zeggen dat het @code{t} voor waar moet
teruggeven. (Verplaatsen van point is daarom een zij-effect.)

Net als @code{search-forward} heeft de functie @code{re-search-forward} vier
argumenten.

@enumerate
@item
Het eerste argument is de reguliere expressie waar de functie naar zoekt. De
reguliere expressie is een string tussen aanhalingstekens.

@item
Het optionele tweede argument begrenst tot hoever de functie zoekt, het is
een grens, die gespecificeerd wordt als een positie in het buffer.

@item
Het optionele derde argument specificeert hoe de functie reageert op falen:
@code{nil} als derde argument laat de functie een fout signaleren (en een
boodschap tonen) wanneer de zoekopdracht faalt, een andere waarde zorgt dat
die @code{nil} teruggeeft wanneer de zoekopdracht faalt en @code{t} wanneer
de zoekopdracht slaagt.

@item
Het optionele vierde argument is de aantal-herhalingen. Een negatieve
aantal-herhalingen laat @code{re-search-forward} achterwaarts zoeken.
@end enumerate

@need 800
Het slabloon voor @code{re-search-forward} ziet er zo uit:

@smallexample
@group
(re-search-forward "@var{reguliere-expressie}"
                @var{zoeklimiet}
                @var{wat-te-doen-wanneer-zoeken-faalt}
                @var{aantal-herhalingen})
@end group
@end smallexample

Het tweede, derde en vierde argument zijn optioneel. Als je echter een
waarde naar een of beide van de laatste twee argumenten wilt doorgeven, moet
je ook een waarde aan alle voorgaande argumenten doorgeven. Anders weet de
Lisp interpreter niet aan welk argument je een waarde doorgeeft.

@need 1200
In de functie @code{forward-sentence} is de reguliere expressie de waarde
van de variabele @code{sentence-end}. In een simpele vorm is die:

@smallexample
@group
"[.?!][]\"')@}]*\\($\\|  \\|  \\)[
]*"
@end group
@end smallexample

@noindent
De limiet van de zoekopdracht is het einde van de paragraaf (omdat een zin
niet voorbij een paragraaf kan gaan). Wanneer de zoekopdracht faalt, geeft
de functie @code{nil} terug en het aantal herhalingen wordt gegeven door het
argument van de functie @code{forward-sentence}.

@node forward-sentence
@section @code{forward-sentence}
@findex forward-sentence

Het commando om de cursor een zin vooruit te verplaatsen is een eenvoudig
voorbeeld van hoe zoekopdrachten met reguliere expressies in Emacs Lisp te
gebruiken. De functie ziet er langer en ingewikkelder uit dan die is, dit is
omdat de functie gemaakt is om zowel achterwaarts als voorwaarts te gaan en,
optioneel, meer dan één zin. De functie is over het algemeen gebonden aan
het toetscommando @kbd{M-e}.

@menu
* Complete forward-sentence::  Complete forward-sentence
* fwd-sentence while loops::  Twee @code{while} loops.
* fwd-sentence re-search::   Een reguliere expressie zoekopdracht.
@end menu

@ifnottex
@node Complete forward-sentence
@unnumberedsubsec Complete @code{forward-sentence} functiedefinitie
@end ifnottex

@need 1250
Hier is de code van @code{forward-sentence}:

@c in GNU Emacs 22
@smallexample
@group
(defun forward-sentence (&optional arg)
  "Move forward to next end of sentence.  With argument, repeat.
With negative argument, move backward repeatedly to start of sentence.

The variable `sentence-end' is a regular expression that matches ends of
sentences.  Also, every paragraph boundary terminates sentences as well."
@end group
@group
  (interactive "p")
  (or arg (setq arg 1))
  (let ((opoint (point))
        (sentence-end (sentence-end)))
    (while (< arg 0)
      (let ((pos (point))
            (par-beg (save-excursion (start-of-paragraph-text) (point))))
       (if (and (re-search-backward sentence-end par-beg t)
                (or (< (match-end 0) pos)
                    (re-search-backward sentence-end par-beg t)))
           (goto-char (match-end 0))
         (goto-char par-beg)))
      (setq arg (1+ arg)))
@end group
@group
    (while (> arg 0)
      (let ((par-end (save-excursion (end-of-paragraph-text) (point))))
       (if (re-search-forward sentence-end par-end t)
           (skip-chars-backward " \t\n")
         (goto-char par-end)))
      (setq arg (1- arg)))
    (constrain-to-field nil opoint t)))
@end group
@end smallexample

@ignore
GNU Emacs 21
@smallexample
@group
(defun forward-sentence (&optional arg)
  "Move forward to next sentence-end.  With argument, repeat.
With negative argument, move backward repeatedly to sentence-beginning.
Sentence ends are identified by the value of sentence-end
treated as a regular expression.  Also, every paragraph boundary
terminates sentences as well."
@end group
@group
  (interactive "p")
  (or arg (setq arg 1))
  (while (< arg 0)
    (let ((par-beg
           (save-excursion (start-of-paragraph-text) (point))))
      (if (re-search-backward
           (concat sentence-end "[^ \t\n]") par-beg t)
          (goto-char (1- (match-end 0)))
        (goto-char par-beg)))
    (setq arg (1+ arg)))
  (while (> arg 0)
    (let ((par-end
           (save-excursion (end-of-paragraph-text) (point))))
      (if (re-search-forward sentence-end par-end t)
          (skip-chars-backward " \t\n")
        (goto-char par-end)))
    (setq arg (1- arg))))
@end group
@end smallexample
@end ignore

De functie ziet er op het eerste gezicht lang uit en het is het beste om
eerst naar zijn geraamte te kijken, en daarna naar zijn spieren. De manier
om het geraamte te zien is te kijken naar de expressies die aan de meest
linkse kant beginnen:

@smallexample
@group
(defun forward-sentence (&optional arg)
  "@var{documentatie}@dots{}"
  (interactive "p")
  (or arg (setq arg 1))
  (let ((opoint (point)) (sentence-end (sentence-end)))
    (while (< arg 0)
      (let ((pos (point))
            (par-beg (save-excursion (start-of-paragraph-text) (point))))
       @var{rest-van-de-body-van-de-while-loop-bij-achterwaarts-bewegen}
    (while (> arg 0)
      (let ((par-end (save-excursion (end-of-paragraph-text) (point))))
       @var{rest-van-de-body-van-de-while-loop-bij-voorwaarts-bewegen}
    @var{hanteer-vormen-en-equivalenten}
@end group
@end smallexample

Dit ziet er veel eenvoudiger uit! De functiedefinitie bestaat uit
documentatie, een @code{interactive} expressie, een @code{or} expressie, een
@code{let} expressie en een @code{while} loop.

Laten we elk van de delen beurtelings bekijken.

We merken op dat de documentatie grondig en begrijpelijk is.

De functie heeft een @code{interactive "p"} declaratie. Dit betekent dat het
verwerkte prefix argument, als die er is, doorgegeven wordt aan de functie
als een argument. (Dit is een getal.) Wanneer de functie geen argument
krijgt doorgegeven (dit is optioneel) dan wordt het argument @code{arg}
gebonden aan 1.

Wanneer @code{forward-sentence} non-interactief zonder argument wordt
aangeroepen, wordt @code{arg} gebonden aan @code{nil}. De @code{or}
expressie handelt dit af. Wat die doet is óf de waarde van @code{arg} laten
zoals die is, maar alleen als @code{arg} aan een waarde gebonden is, óf het
zet de waarde van @code{arg} op 1, in het geval dat @code{arg} gebonden is
aan @code{nil}.

Hierna komt een @code{let}. Die specificeert de waarden van twee lokale
variabelen, @code{opoint} en @code{sentence-end}. De lokale waarde van
point, van voor de zoekopdracht, wordt gebruikt in de functie
@code{constrain-to-field}, die vormen en equivalenten afhandelt. De
variabele @code{sentence-end} wordt gezet door de functie
@code{sentence-end}.

@node fwd-sentence while loops
@unnumberedsubsec De @code{while} loops

Hierna volgen twee @code{while} loops. De eerste @code{while} heeft een
waar-of-onwaar-test dat waar test als het prefix argument voor
@code{forward-sentence} een negatief getal is. Dat is om achterwaarts te
gaan. De body van deze loop vergelijkbaar met de body van de tweede
@code{while} clausule, maar is niet exact hetzelfde. We slaan deze
@code{while} loop over en concentreren ons de tweede @code{while} loop.

@need 1500
De tweede @code{while} loop is voor het voorwaarts verplaatsen van
point. Het geraamte ziet er zo uit:

@smallexample
@group
(while (> arg 0)            ; @r{waar-of-onwaar-test}
  (let @var{varlist}
    (if (@var{waar-of-onwaar-test})
        @var{dan-deel}
      @var{anders-deel}
  (setq arg (1- arg))))     ; @code{while} @r{loop decrementer}
@end group
@end smallexample

De @code{while} loop is van het aflopende type. (@xref{Decrementele loop, ,
Loop met een decrementele teller}.) Het heeft een waar-of-onwaar-test die
waar test zolang de teller (in dit geval, de variabele @code{arg}) groter is
dan nul. En het heeft een decrementer die elke keer als de loop herhaalt 1
aftrekt van de waarde van de teller.

Wanneer geen prefix argument aan @code{forward-sentence} wordt doorgegeven,
wat de meest voorkomende manier is om dit commando te gebruiken, de
@code{while} loop draait maar een keer, omdat de waarde van @code{arg} dan 1
is.

De body van de @code{while} loop bestaat uit een @code{let} expressie, die
de lokale variabele creëert en bindt, en als body een @code{if} expressie
heeft.

@need 1250
De body van de @code{while} loop ziet er zo uit:

@smallexample
@group
(let ((par-end
       (save-excursion (end-of-paragraph-text) (point))))
  (if (re-search-forward sentence-end par-end t)
      (skip-chars-backward " \t\n")
    (goto-char par-end)))
@end group
@end smallexample

De @code{let} expressie creëert en bindt de lokale variabele
@code{par-end}. Zoals we zullen zien is deze lokale variabele gemaakt om een
grens of limiet aan de reguliere zoekopdracht te geven. Wanneer de
zoekopdracht faalt in het vinden van een einde van een zin de in de
paragraaf, stopt het bij het bereiken van het einde van de paragraaf.

Maar laten wij eerst onderzoeken hoe @code{par-end} wordt gebonden aan de
waarde van het einde van de paragraaf. Wat gebeurt is dat de @code{let} de
waarde van @code{par-end} zet op de waarde die de Lisp interpreter
teruggeeft wanneer die de expressie evalueert. 

@smallexample
@group
(save-excursion (end-of-paragraph-text) (point))
@end group
@end smallexample

@noindent
In deze expressie verplaatst @code{(end-of-paragraph-text)} point naar het
einde van de paragraaf, @code{(point)} geeft de waarde van point terug en
vervolgens herstelt @code{save-excursion} point naar zijn oorspronkelijke
positie. Dus bindt de @code{let} expressie @code{par-end} aan de waarde die
de @code{save-excursion} teruggeeft. wat de positie is van het einde van de
paragraaf. (De functie @code{end-of-paragraph-text} gebruikt
@code{forward-paragraph}, die we straks bespreken.)

@need 1200
Vervolgens evalueert Emacs de body van de @code{let}, wat een @code{if}
expressie is, die er zo uit ziet:

@smallexample
@group
(if (re-search-forward sentence-end par-end t) ; @r{if-deel}
    (skip-chars-backward " \t\n")              ; @r{dan-deel}
  (goto-char par-end)))                        ; @r{anders-deel}
@end group
@end smallexample

De @code{if} test of het eerste argument waar is en zo ja, evalueert het
dan-deel, anders evalueert de Emacs Lisp interpreter het anders-deel. De
waar-of-onwaar-test van de @code{if} expressie is de reguliere expressie
zoekopdracht.

Het mag vreemd lijken om wat er uit ziet als het echte werk van de functie
@code{forward-sentence} hier ingegraven is, maar dat is de gebruikelijke
manier waarop dit soort operaties in Lisp worden uitgevoerd.

@node fwd-sentence re-search
@unnumberedsubsec De reguliere expressie zoekopdracht

De functie @code{re-search-forward} zoekt naar het einde van de zin, dat wil
zeggen, naar het patroon dat is gedefinieerd met de reguliere expressie
@code{sentence-end}.

@enumerate
@item
De functie @code{re-search-forward} voert een zij-effect uit, dat is het
verplaatsen van point naar eind van de gevonden zin.

@item
De functie @code{re-search-forward} geeft een waarde waar terug. Dit is de
waarde die de @code{if} ontvangt, en betekent dat de zoekopdracht succesvol
was.
@end enumerate

@noindent
Het zij-effect, de verplaatsing van point, is afgerond voordat de @code{if}
de waarde krijgt overhandigd die teruggegeven is door de succesvolle
afronding van de zoekopdracht.

Wanneer de @code{if} functie de waarde waar ontvangt van een succesvolle
aanroep van @code{re-search-forward} evalueert de @code{if} het dan-deel,
dit is de expressie @code{(skip-chars-backward " \t\n")}. Deze expressie
beweegt achterwaarts over spaties, tabs of carriage returns totdat een
karakter gevonden is en zet dan point achter dat karakter. Omdat point al
verplaatst was naar het eind van het patroon dat het einde van een zin
markeert, zet deze actie point direct achter het afsluitende karakter van de
zin, wat meestal een punt is.

Anderzijds, wanneer de functie @code{re-search-forward} faalt in het vinden
van het patroon dat het einde van een zin markeert, geeft de functie onwaar
terug. Deze onwaar zorgt dat de @code{if} het derde argument evalueert, dit
is @code{(goto-char par-end)}: het verplaatst point naar het einde van de
paragraaf.

(En wanneer de tekst een vorm of equivalent is en point kan niet volledig
bewegen, dan komt de functie @code{constrain-to-field} in het spel.)

Reguliere expressie zoekopdrachten zijn uiterst nuttig en het patroon
geïllustreerd met @code{re-search-forward} waarin de zoekopdrachten de test
is van een @code{if} expressie is handig. Je ziet of schrijft vaak code dat
die patroon incorporeert.

@node forward-paragraph
@section @code{forward-paragraph}: een goudmijn van functies
@findex forward-paragraph

@ignore
@c in GNU Emacs 22
(defun forward-paragraph (&optional arg)
  "Move forward to end of paragraph.
With argument ARG, do it ARG times;
a negative argument ARG = -N means move backward N paragraphs.

A line which `paragraph-start' matches either separates paragraphs
\(if `paragraph-separate' matches it also) or is the first line of a paragraph.
A paragraph end is the beginning of a line which is not part of the paragraph
to which the end of the previous line belongs, or the end of the buffer.
Returns the count of paragraphs left to move."
  (interactive "p")
  (or arg (setq arg 1))
  (let* ((opoint (point))
         (fill-prefix-regexp
          (and fill-prefix (not (equal fill-prefix ""))
               (not paragraph-ignore-fill-prefix)
               (regexp-quote fill-prefix)))
         ;; Remove ^ from paragraph-start and paragraph-sep if they are there.
         ;; These regexps shouldn't be anchored, because we look for them
         ;; starting at the left-margin.  This allows paragraph commands to
         ;; work normally with indented text.
         ;; This hack will not find problem cases like "whatever\\|^something".
         (parstart (if (and (not (equal "" paragraph-start))
                            (equal ?^ (aref paragraph-start 0)))
                       (substring paragraph-start 1)
                     paragraph-start))
         (parsep (if (and (not (equal "" paragraph-separate))
                          (equal ?^ (aref paragraph-separate 0)))
                     (substring paragraph-separate 1)
                   paragraph-separate))
         (parsep
          (if fill-prefix-regexp
              (concat parsep "\\|"
                      fill-prefix-regexp "[ \t]*$")
            parsep))
         ;; This is used for searching.
         (sp-parstart (concat "^[ \t]*\\(?:" parstart "\\|" parsep "\\)"))
         start found-start)
    (while (and (< arg 0) (not (bobp)))
      (if (and (not (looking-at parsep))
               (re-search-backward "^\n" (max (1- (point)) (point-min)) t)
               (looking-at parsep))
          (setq arg (1+ arg))
        (setq start (point))
        ;; Move back over paragraph-separating lines.
        (forward-char -1) (beginning-of-line)
        (while (and (not (bobp))
                    (progn (move-to-left-margin)
                           (looking-at parsep)))
          (forward-line -1))
        (if (bobp)
            nil
          (setq arg (1+ arg))
          ;; Go to end of the previous (non-separating) line.
          (end-of-line)
          ;; Search back for line that starts or separates paragraphs.
          (if (if fill-prefix-regexp
                  ;; There is a fill prefix; it overrides parstart.
                  (let (multiple-lines)
                    (while (and (progn (beginning-of-line) (not (bobp)))
                                (progn (move-to-left-margin)
                                       (not (looking-at parsep)))
                                (looking-at fill-prefix-regexp))
                      (unless (= (point) start)
                        (setq multiple-lines t))
                      (forward-line -1))
                    (move-to-left-margin)
                    ;; This deleted code caused a long hanging-indent line
                    ;; not to be filled together with the following lines.
                    ;; ;; Don't move back over a line before the paragraph
                    ;; ;; which doesn't start with fill-prefix
                    ;; ;; unless that is the only line we've moved over.
                    ;; (and (not (looking-at fill-prefix-regexp))
                    ;;      multiple-lines
                    ;;      (forward-line 1))
                    (not (bobp)))
                (while (and (re-search-backward sp-parstart nil 1)
                            (setq found-start t)
                            ;; Found a candidate, but need to check if it is a
                            ;; REAL parstart.
                            (progn (setq start (point))
                                   (move-to-left-margin)
                                   (not (looking-at parsep)))
                            (not (and (looking-at parstart)
                                      (or (not use-hard-newlines)
                                          (bobp)
                                          (get-text-property
                                           (1- start) 'hard)))))
                  (setq found-start nil)
                  (goto-char start))
                found-start)
              ;; Found one.
              (progn
                ;; Move forward over paragraph separators.
                ;; We know this cannot reach the place we started
                ;; because we know we moved back over a non-separator.
                (while (and (not (eobp))
                            (progn (move-to-left-margin)
                                   (looking-at parsep)))
                  (forward-line 1))
                ;; If line before paragraph is just margin, back up to there.
                (end-of-line 0)
                (if (> (current-column) (current-left-margin))
                    (forward-char 1)
                  (skip-chars-backward " \t")
                  (if (not (bolp))
                      (forward-line 1))))
            ;; No starter or separator line => use buffer beg.
            (goto-char (point-min))))))

    (while (and (> arg 0) (not (eobp)))
      ;; Move forward over separator lines...
      (while (and (not (eobp))
                  (progn (move-to-left-margin) (not (eobp)))
                  (looking-at parsep))
        (forward-line 1))
      (unless (eobp) (setq arg (1- arg)))
      ;; ... and one more line.
      (forward-line 1)
      (if fill-prefix-regexp
          ;; There is a fill prefix; it overrides parstart.
          (while (and (not (eobp))
                      (progn (move-to-left-margin) (not (eobp)))
                      (not (looking-at parsep))
                      (looking-at fill-prefix-regexp))
            (forward-line 1))
        (while (and (re-search-forward sp-parstart nil 1)
                    (progn (setq start (match-beginning 0))
                           (goto-char start)
                           (not (eobp)))
                    (progn (move-to-left-margin)
                           (not (looking-at parsep)))
                    (or (not (looking-at parstart))
                        (and use-hard-newlines
                             (not (get-text-property (1- start) 'hard)))))
          (forward-char 1))
        (if (< (point) (point-max))
            (goto-char start))))
    (constrain-to-field nil opoint t)
    ;; Return the number of steps that could not be done.
    arg))
@end ignore

De functie @code{forward-paragraph} verplaatst point naar het einde van de
paragraaf. Die is meestal gebonden aan @kbd{M-@}} en maakt gebruik van een
aantal functies die op zichzelf belangrijk zijn, waaronder @code{let*},
@code{match-beginning} en @code{looking-at}.

De functiedefinitie van @code{forward-paragraph} is aanzienlijk langer dan
de functiedefinitie van @code{forward-sentence} omdat het met een paragraaf
werkt, waarvan elke regel met een opvul-prefix kan beginnen.

Een opvul-prefix bestaat uit een string van karakters die herhaald wordt aan
het begin van elke regel. Bijvoorbeeld in Lisp code is het een conventie om
elke regel van een paragraaf-lang commentaar te beginnen met @samp{;;; }. In
Text-mode bestaat een ander gebruikelijke opvul-prefix uit vier spaties, om
een ingesprongen paragraaf te maken. (@xref{Fill Prefix, , , emacs, The GNU
Emacs Manual}, voor meer informatie over opvul-prefixes.)

Het bestaan van een opvul-prefix betekent dat naast het kunnen vinden van
het einde van de paragraaf wiens regels helemaal links beginnen, de functie
@code{forward-paragraph} ook in staat moet zijn het einde van de paragraaf
te vinden wanneer alle of veel van de regels in het buffer met een
opvul-prefix beginnen.

Bovendien is het soms praktisch om een bestaand opvul-prefix te negeren, in
het bijzonder wanneer lege regels paragrafen scheiden. Dit is een extra
complicatie.

@menu
* forward-paragraph in het kort::  Belangrijke onderdelen van de 
                                     functiedefinitie.
* fwd-para let::             De @code{let*} expressie
* fwd-para while::           De voorwaartse beweging @code{while} loop.
@end menu

@ifnottex
@node forward-paragraph in het kort
@unnumberedsubsec Verkorte @code{forward-paragraph} functiedefinitie
@end ifnottex

In plaats van alles van de functie @code{forward-paragraph} te tonen, tonen
we alleen delen er van. Het kan ontmoedigend zijn de functie zonder
voorbereiding te lezen.

@need 800
Globaal ziet de functie er zo uit:

@smallexample
@group
(defun forward-paragraph (&optional arg)
  "@var{documentatie}@dots{}"
  (interactive "p")
  (or arg (setq arg 1))
  (let*
      @var{varlist}
    (while (and (< arg 0) (not (bobp)))     ; @r{achterwaarts-bewegende-code}
      @dots{}
    (while (and (> arg 0) (not (eobp)))     ; @r{voorwaarts-bewegende-code}
      @dots{}
@end group
@end smallexample

De eerste delen van de functie zijn routine: de argumentlist van de functie
bestaat uit een optioneel argument. Documentatie volgt daarna.

De kleine letter @samp{p} in de @code{interactive} declaratie betekent dat
het verwerkte prefix argument, als die er is, wordt doorgegeven aan de
functie. Dit is een getal, en is het aantal herhalingen van hoeveel
paragrafen point wordt verplaatst. De @code{or} expressie in de volgende
regel behandelt de gebruikelijke situatie wanneer geen argument aan de
functie wordt doorgegeven, wat gebeurt wanneer de functie wordt aangeroepen
vanuit andere code in plaats van interactief. Deze situatie is eerder
beschreven (@xref{forward-sentence, De functie @code{forward-sentence}}.) Nu
bereiken we het einde van het vertrouwde deel van deze functie.

@node fwd-para let
@unnumberedsubsec De @code{let*} expressie

@findex let*
De volgende regel van de functie @code{forward-paragraph} begint met een
@code{let*} expressie (@pxref{let* geïntroduceerd,,@code{let*}
geïntroduceerd}), waarin Emacs een totaal van zeven variabelen bindt:
@code{opoint}, @code{fill-prefix-regexp}, @code{parstart}, @code{parsep},
@code{sp-parstart}, @code{start} en @code{found-start}. Het eerste deel van
de @code{let*} expressie ziet er als volgt uit:

@smallexample
@group
(let* ((opoint (point))
       (fill-prefix-regexp
        (and fill-prefix (not (equal fill-prefix ""))
             (not paragraph-ignore-fill-prefix)
             (regexp-quote fill-prefix)))
       ;; Remove ^ from paragraph-start and paragraph-sep if they are there.
       ;; These regexps shouldn't be anchored, because we look for them
       ;; starting at the left-margin.  This allows paragraph commands to
       ;; work normally with indented text.
       ;; This hack will not find problem cases like "whatever\\|^something".
       (parstart (if (and (not (equal "" paragraph-start))
                          (equal ?^ (aref paragraph-start 0)))
                     (substring paragraph-start 1)
                   paragraph-start))
       (parsep (if (and (not (equal "" paragraph-separate))
                        (equal ?^ (aref paragraph-separate 0)))
                   (substring paragraph-separate 1)
                 paragraph-separate))
       (parsep
        (if fill-prefix-regexp
            (concat parsep "\\|"
                    fill-prefix-regexp "[ \t]*$")
          parsep))
       ;; This is used for searching.
       (sp-parstart (concat "^[ \t]*\\(?:" parstart "\\|" parsep "\\)"))
       start found-start)
  ...)
@end group
@end smallexample

De variabele @code{parsep} verschijnt twee keer, ten eerste om instanties
van @samp{^} te verwijderen en ten tweede om opvul-prefixes te behandelen.

De variabele @code{opoint} is gewoon de waarde van @code{point}. Zoals je
kunt raden wordt het gebruikt in een @code{constrain-to-field} expressie,
net als in @code{forward-sentence}.

De variabele @code{fill-prefix-regexp} wordt gezet op de waarde teruggeven
door de volgende lijst te evalueren:

@smallexample
@group
(and fill-prefix
     (not (equal fill-prefix ""))
     (not paragraph-ignore-fill-prefix)
     (regexp-quote fill-prefix))
@end group
@end smallexample

@noindent
Dit is een expressie wiens eerste element de speciale vorm @code{and} is. 

Zoals we eerder (@pxref{kill-new functie, , De @code{kill-new} functie})
leerden, evalueert de speciale vorm @code{and} elk van zijn argumenten tot
dat een van de de argumenten een waarde @code{nil} teruggeeft, in dat geval
geeft de @code{and} een waarde @code{nil} terug. Echter, wnanneer geen van
de arugmenten een waarde @code{nil} teruggeeft, wordt de waarde die het
resultaaat van het evalueren van het laatste argument teruggegeven. (Omdat
zo'n waarde niet @code{nil} is, wordt het als waar beschouwt in Lisp.) Met
andere woorden, een @code{and} expressie geeft alleen een waarde waar terug
wanneer al zijn argumenten waar zijn.
@findex and

In dit geval wordt de variabele @code{fill-prefix-regexp} uitsluitend
gebonden aan een non-@code{nil} waarde wanneer de volgende vier expressies
een waarde waar (dus non-@code{nil}) produceren wanneer zij worden
geëvalueerd. Zo niet, dan wordt @code{fill-prefix-regexp} gebonden aan
@code{nil}.

@table @code
@item fill-prefix
Wanneer deze variabele wordt geëvalueerd wordt de waarde van de fill prefix,
als die er is, teruggegeven. Wanneer er geen fill prefix is, dan geeft de
variabel @code{nil} terug.

@item (not (equal fill-prefix "")
Deze expressie kijkt of een bestaand fill prefix een lege string is, oftewel
een string zonder karakters er in. Een lege string is geen nuttige
opvul-prefix.

@item (not paragraph-ignore-fill-prefix)
Deze expressie geeft @code{nil} terug wanneer de variabele
@code{paragraph-ignore-fill-prefix} aan staat, doordat het op de waarde
waar, zoals @code{t}, is gezet.

@item (regexp-quote fill-prefix)
Dit is het laatste argument van de speciale vorm @code{and}. Wanneer al de
argumenten van de @code{and} waar zijn, wordt de waarde die resulteert uit
het evalueren van deze expressie teruggeven door de @code{and} expressie en
gebonden aan de variabele @code{fill-prefix-regexp}.
@end table

@findex regexp-quote
@noindent
Het resultaat van een succesvolle evaluatie van deze @code{and} expressie is
dat @code{fill-prefix-regexp} wordt gebonden aan de waarde van
@code{fill-prefix}, aangepast door de functie @code{regexp-quote}. Wat
@code{regexp-quote} doet is het lezen van een string en een reguliere
expressie teruggeven die exact de string matcht, en niets anders matcht. Dit
betekent dat de @code{fill-prefix-regexp} wordt gezet naar een waarde is
exact het opvul-prefix matcht als die bestaat. Zo niet, dan wordt de
variabele gezet op @code{nil}.

De volgende twee lokale variabelen in de @code{let*} expressie zijn
ontworpen om instanties van @samp{^} te verwijderen uit @code{parstart} en
@code{parsep}, de lokale variabelen die de start van de paragraaf en de
paragraaf separator aanduiden. De volgende expressie stelt @code{parsep}
opnieuw. Dit is om opvul-prefixes te behandelen.

Het is dit instellen dat vereist dat de definitie @code{let*} aanroept in
plaats van @code{let}. De waar-of-onwaar-test van de @code{if} hangt af van
of de variabele @code{fill-prefix-regexp} naar @code{nil} evalueert, of naar
een andere waarde.

Wanneer @code{fill-prefix-regexp} geen waarde heeft dan evalueert Emacs het
anders-deel van de @code{if} expressie en bindt @code{parsep} naar de lokale
waarde. (@code{parsep} is een reguliere expressie die matcht wat paragrafen
scheidt.)

Maar wanneer @code{fill-prefix-regexp} een waarde heeft, evalueert Emacs het
dan-deel van de @code{if} expressie en bindt @code{parsep} aan een reguliere
expressie die de @code{fill-prefix-regexp} als deel van het patroon bevat.

Specifiek wordt @code{parsep} gezet op de originele waarde van de paragraaf
scheidende reguliere expressie samengevoegd met een alternatieve expressie
die bestaat uit de @code{fill-prefix-regexp} gevolgd door optionele witte
ruimte als einde van de regel. (De witte ruimte is gedefinieerd met
@w{@code{"[ \t]*$"}}.) De @samp{\\|} definieert die deel van de regexp als
een alternatief van @code{parsep}.

Volgens het commentaar in de code wordt de volgende lokale variabele,
@code{sp-parstart} gebruikt om te zoeken en de laatste twee, @code{start} en
@code{found-start} worden op @code{nil} gezet.

Nu komen we bij de body van de @code{let*}. Het eerste deel van de body van
de @code{let*} behandelt het geval wanneer de functie een negatief argument
krijgt en daarom achterwaarts beweegt. We slaan dit stuk over.

@node fwd-para while
@unnumberedsubsec De voorwaarts bewegende @code{while} loop

Het tweede deel van de body van de @code{let*} behandelt de voorwaartse
beweging. Het is een @code{while} loop dit zichzelf herhaalt zolang de waard
van @code{arg} groter is dan nul. In de meest gebruikte manier van de
functie is de waarde van het argument 1, en wordt de body van de
@code{while} loop exact een keer geëvalueerd, en verplaatst de cursor een
paragraaf voorwaarts.

@ignore
(while (and (> arg 0) (not (eobp)))

  ;; Move forward over separator lines...
  (while (and (not (eobp))
              (progn (move-to-left-margin) (not (eobp)))
              (looking-at parsep))
    (forward-line 1))
  (unless (eobp) (setq arg (1- arg)))
  ;; ... and one more line.
  (forward-line 1)

  (if fill-prefix-regexp
      ;; There is a fill prefix; it overrides parstart.
      (while (and (not (eobp))
                  (progn (move-to-left-margin) (not (eobp)))
                  (not (looking-at parsep))
                  (looking-at fill-prefix-regexp))
        (forward-line 1))

    (while (and (re-search-forward sp-parstart nil 1)
                (progn (setq start (match-beginning 0))
                       (goto-char start)
                       (not (eobp)))
                (progn (move-to-left-margin)
                       (not (looking-at parsep)))
                (or (not (looking-at parstart))
                    (and use-hard-newlines
                         (not (get-text-property (1- start) 'hard)))))
      (forward-char 1))

    (if (< (point) (point-max))
        (goto-char start))))
@end ignore

Dit deel behandelt drie situaties: wanneer point tussen twee paragrafen is,
wanneer er een opvul-prefix is en wanneer er geen opvul-prefix is.

@need 800
De @code{while} loop ziet er zo uit:

@smallexample
@group
;; @r{ga voorwaarts en niet aan het eind van het buffer}
(while (and (> arg 0) (not (eobp)))

  ;; @r{tussen paragrafen}
  ;; Move forward over separator lines...
  (while (and (not (eobp))
              (progn (move-to-left-margin) (not (eobp)))
              (looking-at parsep))
    (forward-line 1))
  ;;  @r{Dit verlaagt de loop}
  (unless (eobp) (setq arg (1- arg)))
  ;; ... and one more line.
  (forward-line 1)
@end group

@group
  (if fill-prefix-regexp
      ;; There is a fill prefix; it overrides parstart;
      ;; we go forward line by line
      (while (and (not (eobp))
                  (progn (move-to-left-margin) (not (eobp)))
                  (not (looking-at parsep))
                  (looking-at fill-prefix-regexp))
        (forward-line 1))
@end group

@group
    ;; There is no fill prefix;
    ;; we go forward character by character
    (while (and (re-search-forward sp-parstart nil 1)
                (progn (setq start (match-beginning 0))
                       (goto-char start)
                       (not (eobp)))
                (progn (move-to-left-margin)
                       (not (looking-at parsep)))
                (or (not (looking-at parstart))
                    (and use-hard-newlines
                         (not (get-text-property (1- start) 'hard)))))
      (forward-char 1))
@end group

@group
    ;; and if there is no fill prefix and if we are not at the end,
    ;;     go to whatever was found in the regular expression search
    ;;     for sp-parstart
    (if (< (point) (point-max))
        (goto-char start))))
@end group
@end smallexample

@findex eobp
We kunnen zien dat dit een aflopende teller @code{while} loop is, met de
expressie @code{(setq arg (1- arg))} als de decrementer. Die expressie is
niet ver van de @code{while} loop, maar is verstopt in een andere Lisp
macro, een @code{unless} macro. Tenzij we aan het eind van het buffer
zijn---dat is wat de functie @code{eobp} vaststelt, het is een afkorting van
@samp{End Of Buffer P}---verlagen we de waarde van @code{arg} met één.

(Wanneer we aan het eind van het buffer zijn, kunnen we niet meer voorwaarts
en test de volgende loop van de @code{while} expressie onwaar omdat de test
een @code{and} met @code{(not (eobp))} is. De functie @code{not} betekent
precies wat je verwacht, het is een andere naam voor @code{null}, een
functie die waar teruggeeft wanneer zijn argument onwaar is.)

Interessant genoeg wordt de loop teller niet eerder verlaagd dan dat we de
ruimte tussen paragrafen verlaten, tenzij we aan het eind van het buffer
komen of de lokale variabele van de paragraaf separator niet meer zien.

De tweede @code{while} heeft ook een @code{(move-to-left-margin)}
expressie. De functie spreekt voor zich. Die bevindt zich binnen een
@code{progn} expressie en is niet het laatste element van de body, dus die
wordt alleen aangeroepen voor het zij-effect, het verplaatsten van point
naar de linker kantlijn op de huidige regel.

@findex looking-at
De functie @code{looking-at} spreekt ook voor zich. het geeft waar terug
wanneer de tekst achter point matcht met de reguliere expressie die als zijn
argument is doorgegeven.

De rest van de body van de loop ziet er op het eerste gezicht moeilijk uit,
maar is logisch wanneer je die begint te begrijpen.

@need 800
Bedenk eerst wat gebeurt wanneer er een opvul-prefix is:

@smallexample
@group
  (if fill-prefix-regexp
      ;; There is a fill prefix; it overrides parstart;
      ;; we go forward line by line
      (while (and (not (eobp))
                  (progn (move-to-left-margin) (not (eobp)))
                  (not (looking-at parsep))
                  (looking-at fill-prefix-regexp))
        (forward-line 1))
@end group
@end smallexample

@noindent
De expressie verplaatst point voorwaarts regel voor regel zolang vier
condities waar zijn:

@enumerate
@item
Point is niet aan het eind van het buffer.

@item
We kunnen naar de linker kantlijn van de tekst verplaatsen en zijn niet aan
het eind van het buffer.

@item
De tekst die volgt op point scheidt geen paragrafen.

@item
Het patroon volgend op point is de fill prefix reguliere expressie.
@end enumerate

De laatste conditie kan verwarrend zijn, totdat je herinnert dat point naar
het begin van de regel is verplaatst in het begin van de functie
@code{forward-paragraph}. Dat betekent dat wanneer de tekst een opvul-prefix
heeft, de functie @code{looking-at} het zal zien.

@need 1250
Bedenk wat gebeurt wanneer er geen opvul-prefix is.

@smallexample
@group
    (while (and (re-search-forward sp-parstart nil 1)
                (progn (setq start (match-beginning 0))
                       (goto-char start)
                       (not (eobp)))
                (progn (move-to-left-margin)
                       (not (looking-at parsep)))
                (or (not (looking-at parstart))
                    (and use-hard-newlines
                         (not (get-text-property (1- start) 'hard)))))
      (forward-char 1))
@end group
@end smallexample

@noindent
De @code{while} loop laat ons voorwaarts zoeken naar @code{sp-parstart}, wat
de combinatie is van mogelijke witte ruimte met de lokale waarde van de
start van een paragraaf of van een paragraaf separator.

@need 800
De twee expressies,

@smallexample
@group
(setq start (match-beginning 0))
(goto-char start)
@end group
@end smallexample

@noindent
betekenen ga naar de start van tekst gematcht door de reguliere expressie
zoekopdracht.

De @code{(match-beginning 0)} expressie is nieuw. Het geeft het getal dat de
lokatie van de start van de tekst aangeeft die was gematcht door de laatste
zoekopdracht.

De functie @code{match-beginning} wordt hier gebruikt vanwege een
karakteristiek van een voorwaartse zoekopdracht: een succesvolle
zoekopdracht, ongeacht of het een gewone zoekopdracht of een reguliere
expressie zoekopdracht is, verplaatst point naar het einde van de tekst die
is gevonden. In dit geval verplaatst een succesvolle zoekopdracht point naar
het einde van het patroon voor @code{sp-parstart}.

Wij willen echter point aan het einde van de huidige paragraaf zetten, niet
ergens anders. Omdat de zoekopdracht mogelijk de paragraaf separator bevat,
kan point bij het begin van de volgende terecht komen tenzij we een
expressie gebruiken die @code{match-beginning} bevat.

@findex match-beginning
Wanneer het een argument van 0 krijgt, geeft @code{match-beginning} de
positie terug die de start is van de tekst gematcht met de meest recente
zoekopdracht. In dit geval zoekt de meest recente zoekopdracht naar
@code{sp-parstart}. De @code{(match-beginning 0)} expressie geeft de
beginposiitie van dat patroon, in plaats van de eindpositie van dat patroon.

(Overigens, wanneer een positief getal als argument wordt doorgegeven, geeft
de functie @code{match-beginning} de lokatie van point bij die tussen
haakjes geplaatste expressie in de laatste zoekopdracht, tenzij die tussen
haakjes geplaatste expressie begint met @code{\(?:}. Ik weet niet waarom
@code{\(?:} hier verschijnt, aangezien het argument 0 is.)

@need 1250
De laatste expressie wanneer er geen opvul-prefix is

@smallexample
@group
(if (< (point) (point-max))
    (goto-char start))))
@end group
@end smallexample

@noindent
(Merk op dat dit stukje code ongewijzigd gekopieerd is van de originele
code, waardoor de twee extra haakjes sluiten horen bij de voorafgaande
@code{if} en @code{while}.)

Dit vertelt dat wanneer er geen opvul-prefix is en wanneer wij niet aan het
einde zijn, point naar het begin moet verplaatsen van wat gevonden was door
de reguliere expressie zoekopdracht naar @code{sp-parstart}.

De volledige definitie van de functie @code{forward-paragraph} bevat niet
alleen code om voorwaarts te gaan, maar ook code om achterwaarts te gaan.

Wanneer je dit in GNU Emacs leest en je de gehele functie wilt zien, dan kan
je @kbd{C-h f} (@code{describe-function}) typen, en daarna de naam van de
functie. Dit geeft je de functiedocumentatie en de naam van de library die
de broncode bevat. Plaats point op de naam van de library en druk op de
@key{RET} toets. Je brengt je direct naar de bron. (Zorg dat je de broncodes
installeert! Zonder die ben je als iemand die probeert met de ogen dicht een
auto te besturen.)

@node Regexp terugblik
@section Terugblik

Hier is een korte samenvatting van sommige recent geïntroduceerde functies.

@table @code
@item while
Evalueer herhaaldelijk de body van de expressie zolang als het eerste
element van de body waar test. Geef daarna @code{nil} terug. (De expressie
wordt uitsluitend voor de zij-effecten geëvalueerd.)

@need 1250
Bijvoorbeeld:

@smallexample
@group
(let ((foo 2))
  (while (> foo 0)
    (insert (format "foo is %d.\n" foo))
    (setq foo (1- foo))))

     @result{}      foo is 2.
             foo is 1.
             nil
@end group
@end smallexample

@noindent
(De functie @code{insert} voegt het argument bij point in. de functie
@code{format} geeft een geformatteerde string terug op dezelfde manier als
@code{message} de argumenten formatteert. @code{\n} produceert een nieuwe
regel.)

@item re-search-forward
Zoek voor een patroon, en als het patroon is gevonden, verplaats point
direct er achter.

@noindent
Verwacht vier argumenten, zoals @code{search-forward}:

@enumerate
@item
Een reguliere expressie die het zoekpatroon specificeert. (Denk er aan om
dubbele aanhalingstekens om dit argument te zetten!)

@item
Optioneel, de limiet van de zoekopdracht.

@item
Optioneel, wat te doen als de zoekopdracht mislukt, geef @code{nil} terug of
een fout.

@item
Optioneel, hoeveel keer de zoekopdracht te herhalen. Wanneer negatief, zoek
achterwaarts.
@end enumerate

@item let*
Bind sommige variabelen lokaal aan bepaalde waardes en evalueer dan de
overige argumenten en geeft de waarde van de laatste terug. Gebruik de
lokale waarden van eerder gebonden variabelen bij het binden van lokale
variabelen.

@need 1250
Bijvoorbeeld:

@smallexample
@group
(let* ((foo 7)
       (bar (* 3 foo)))
  (message "`bar' is %d." bar))
     @result{} ‘bar’ is 21.
@end group
@end smallexample

@item match-beginning
Geef de positie van de start van de tekst gevonden door de laatste reguliere
expressie.

@item looking-at
Geef @code{t} voor waar terug wanneer de tekst achter point overeenkomt met
het argument, wat een reguliere expressie moet zijn.

@item eobp
Geef @code{t} voor waar terug wanneer point aan het einde van het bereikbare
deel van een buffer is. Het einde van het bereikbare deel is het einde van
het buffer wanneer het buffer niet versmald is. Het is het einde van het
versmalde deel wanneer het buffer is versmald.
@end table

@need 1500
@node re-search oefeningen
@section Oefeningen met @code{re-search-forward}

@itemize @bullet
@item
Schrijf een functie om te zoeken met een reguliere expressie die overeenkomt
met twee of meer opeenvolgende lege regels.

@item
Schrijf een functie die zoekt naar gedupliceerde woorden, zoals ``de
de''. @xref{Regexps, , Syntax of Regular Expressions, emacs, The GNU Emacs
Manual}, voor informatie hoe je een regexp schrijft (een reguliere
expressie) om een string te matchen die uit twee identieke helften
bestaat. De functie die ik gebruik is beschreven in de appendix, samen met
verschillende regexps. @ref{de-de, , @code{de-de} Gedupliceerde woorden
functie}.
@end itemize

@node Woorden tellen
@chapter Tellen via repetitie en regexps
@cindex Repetitie voor tellen van woorden
@cindex Reguliere expressie voor tellen van woorden

Repetitie en reguliere expressie zoekopdrachten zijn krachtige instrumenten
de je vaak gebruikt wanneer je code in Emacs Lisp schrijft. Dit hoofdstuk
illustreert het gebruik van reguliere expressie zoekopdrachten bij de
constructie van woorden telling commando's, met @code{while} loops en
recursie.

@menu
* Waarom woorden tellen::    Waarom woorden tellen
* @value{TEL-WOORDEN}::      Gebruik een regexp, maar vindt een probleem.
* recursive-count-words::    Start met het geval van geen woorden in de 
                               region.
* Tellen voorbeeld::         Tellen voorbeeld
@end menu

@ifnottex
@node Waarom woorden tellen
@unnumberedsec Woorden tellen
@end ifnottex

De standaard Emacs distributie bevat functies om het aantal regels en het
het aantal woorden in een region te tellen.

Sommige soorten schrijfwerk vragen je woorden te tellen. Zoals wanneer je
een essay schrijft kan dat gelimiteerd zijn op 800 woorden. Wanneer je een
roman schrijft kan je je zelf opleggen om 1000 woorden per dag te
schrijven. Het klinkt raar, maar Emacs had heel lang geen woorden tel
commando. Misschien gebruikten mensen Emacs voornamelijk voor code of
soorten documentatie die geen woordtelling vereisen, of misschien beperkte
zij zich tot het woorden tel commando van het besturingsysteem zoals
@code{wc}. Misschien dat mensen de conventie onder uitgevers volgden en
berekenden zij de woord telling door het aantal karaktrs in een document
door vijf te delen.

Een commando om woorden te tellen kan op veel verschillende manieren
gecompleteerd worden. Hier volgen sommige voorbeelden die je wellicht wilt
vergelijken met het standaard Emacs commando @code{count-words-region}.

@node @value{TEL-WOORDEN}
@section De @code{@value{TEL-WOORDEN}} functie
@findex @value{TEL-WOORDEN}

Een woorden tel commando kan woorden tellen in een regel, paragraaf, region
of buffer. Wat zou het commando moeten doen? Je kunt een commando maken dat
het aantal woorden telt in een volledig buffer. Echter, de Emacs traditie
moedigt flexibiliteit aan---je wil misschien alleen de woorden in een sectie
tellen in plaats van het hele buffer. Het is daarom verstandiger om het
commando het aantal woorden in een region te laten tellen. Wanneer je
eenmaal een commando hebt dat woorden in een region telt, dan kan je als je
dat wilt woorden in het hele buffer tellen door het te markeren met
@w{@kbd{C-x h}} (@code{mark-whole-buffer}).

Woorden tellen is duidelijk een repeterende handeling: startend bij het
begin van de region tel je het eerste woord, dan het tweede woord, dan het
derde, enzovoorts., totdat je het einde van de region bereikt. Dit betekent
dat het tellen van woorden uitstekend geschikt is voor recursie of voor een
@code{while} loop.

@menu
* Ontwerp @value{TEL-WOORDEN}::  De definitie met @code{while} loop.
* Witte ruimte bug::         De witte ruimte bug in 
                               @code{@value{TEL-WOORDEN}}
@end menu

@ifnottex
@node Ontwerp @value{TEL-WOORDEN}
@unnumberedsubsec Ontwerp @code{@value{TEL-WOORDEN}}
@end ifnottex

Eerst gaan we een woord tel commando maken met een @code{while} loop, daarna
met recursie. Het commando is uiteraard interactief.

@need 800
Het sjabloon voor een interactieve functiedefinitie is, zoals altijd:

@smallexample
@group
(defun @var{naam-van-de-functie} (@var{argument-list})
  "@var{documentatie}@dots{}"
  (@var{interactive-expression}@dots{})
  @var{body}@dots{})
@end group
@end smallexample

Wat we moeten doen is de slots invullen.

De naam van def functie moet zelf verklarend en makkelijk te houden
zijn. @code{count-words-region} is een voor de hand liggende keuze. Maar
omdat die naam gebruikt wordt door het standaard Emacs commando om woorden
te tellen, noemen we onze implantatie @code{@value{TEL-WOORDEN}}.

De functie telt woorden in een region. Dat betekent dat de arugmentlist
symbolen moet bevatten die gebonden worden aan de twee posities, het begin
en einde van de region. Deze twee posities noemen we respectievelijk
@samp{begin} en @samp{end}. De eerste regel van de documentatie met een
enkele zin zijn, omdat dit alles wat als documentatie getoond wordt door een
commando zoals @code{apropos}. De interactieve expressie heeft de vorm
@samp{(interactive "r")}, omdat die zorgt dat Emacs het begin en einde van
de region doorgeven aan de arugmentlist van de functie. Dit is allemaal
routine.

De body van de functie moet drie taken doen: ten eerste de condities
opzetten waaronder de @code{while} loop de woorden kan tellen, ten tweede
het runnen van de @samp{while} loop, en ten derde, de gebruiker een
boodschap geven.

Wanneer een gebruiker @code{@value{TEL-WOORDEN}} aanroept kan point aan het
begin of aan het einde van de region staan. Het tel-proces moet echter bij
het begin van de region starten. Dit betekent dat we point daar willen
zetten wanneer die daar nog niet is. Het uitvoeren van @code{(goto-char
beginning)} verzekert dit. We willen natuurlijk point terug zetten op zijn
verwachte positie wanneer de functie zijn werk gedaan heeft. Om deze reden
moet de body ingevoegd zijn in een @code{save-excursion} expressie.

Het centrale deel van de body van de functie bestaat uit een @code{while}
loop waarin een expressie point voorwaarts van woord naar woord laat
springen, en een andere expressie deze sprongen telt. De waar-of-onwaar-test
van de @code{while} loop moet naar waar testen zolang point voorwaarts moet
springen, en onwaar wanneer point aan het einde van de region is.

We zouden @code{(forward-word 1)} kunnen gebruiken om point woord voor woord
voorwaarts te verplaatsen, maar het is makkelijker om te kijken wat Emacs
als ``woord'' identificeert, wanneer we een reguliere expressie zoekopdracht
gebruiken.

Een reguliere expressie zoekopdracht die het patroon vindt waarvoor het
zoekt, zet point achter het laatst gematchte karakter. Dit betekent dat
opvolgende succesvolle zoekopdrachten point woord voor woord voorwaarts
verplaatst.

In de praktijk willen we dat de reguliere expressie zoekopdracht over witte
ruimte en leestekens tussen woorden springt en ook over de woorden zelf. Een
regexp die weigert over witte ruimte tussen woorden te springen zou nooit
over een meer dan een woord springen! Dit betekent dat de regexp de witte
ruimte en leestekens volgend op een woord moet bevatten, als die er is,
zowel als het woord zelf. (Een woord kan een buffer beëindigen en kan geen
opvolgende witte ruimte of leestekens hebben, dus dat deel van de regexp
moet optioneel zijn.)

Dus wat we willen is dat regexp een patroon is dat een of meer
woord-vormende karakters, optioneel gevolgd door een or meer karakters die
niet woord-vormend zijn, definieert.

@smallexample
\w+\W*
@end smallexample

@noindent
De syntax-table van het buffer stelt vast welke karakters woord-vormend zijn
en welke niet. Voor meer informatie over syntax, @pxref{Syntax Tables, ,
Syntax Tables, elisp, The GNU Emacs Lisp Reference Manual}.

@need 800
De zoek expressie ziet er zo uit:

@smallexample
(re-search-forward "\\w+\\W*")
@end smallexample

@noindent
(Merk op dat de paren backslashes aan de @samp{w} en @samp{W}
voorafgaan. Een enkele backslash heeft een speciale betekenis voor de Emacs
Lisp interpreter. Het geeft aan dat het er op volgende karakter anders
geïnterpreteerd is dan gebruikelijk. Bijvoorbeeld staan de twee karakters
@samp{\n} voor @samp{newline} in plaats van een backslash gevolgd door
@samp{n}. Twee backslashes achter elkaar staan voor een gewone,
niet-speciale backslash, waardoor de Emacs Lisp interpreter uiteindelijk een
enkele backslash gevold door een letter ziet. Daardoor weet het dat de
letter speciaal is.)

We hebben een teller nodig die telt hoeveel woorden er zijn. Deze variabele
moet eerst op 0 gezet worden en daarna elke keer dat Emacs door de
@code{while} loop gaat verhoogd worden.

@smallexample
(setq count (1+ count))
@end smallexample

Tenslotte willen we aan de gebruiker vertellen hoeveel woorden er in de
region zijn. De functie @code{message} is bedoeld om dit soort informatie
aan de gebruiker te presenteren. De boodschap moet zo zijn geformuleerd dat
die goed is ongeacht hoeveel woorden er in de region zijn: we willen niet
zeggen ``er zijn 1 woorden in de region''. Het conflict tussen enkelvoud en
meervoud is grammaticaal onjuist. Wij lossen dit op met een conditionele
expressie die verschillende boodschappen evalueert, afhankelijk van het
aantal woorden in de region. Er zijn drie mogelijkheden: geen woorden in de
region, één woord in de region, en meer dan een woord. Dit betekent dat de
speciale vorm @code{cond} geschikt is.

@need 1500
Dit alles leidt tot de volgende functiedefinitie:

@smallexample
@group
;;; @r{Eerste versie; heeft bugs!}
(defun @value{TEL-WOORDEN} (beginning end)
  "Toon aantal woorden in de region.
Woorden worden gedefinieerd als minstens een woord-vormend
karakter gevolgd door minstens een karakter dat
niet woord-vormend is. De syntax table van het buffer
bepaald welke karakters dat zijn."
  (interactive "r")
  (message "Tel woorden in region ... ")
@end group

@group
;;; @r{1. Opzetten geschikte condities.}
  (save-excursion
    (goto-char beginning)
    (let ((count 0))
@end group

@group
;;; @r{2. Run de} while @r{loop.}
      (while (< (point) end)
        (re-search-forward "\\w+\\W*")
        (setq count (1+ count)))
@end group

@group
;;; @r{3. Toon een boodschap aan de gebruiker.}
      (cond ((zerop count)
             (message
              "De region heeft GEEN woorden."))
            ((= 1 count)
             (message
              "De region heeft 1 woord."))
            (t
             (message
              "The region heeft %d woorden." count))))))
@end group
@end smallexample

@noindent
Zo geschreven werkt de functie, maar niet in alle omstandigheden.

@node Witte ruimte bug
@subsection De witte ruimte bug in @code{@value{TEL-WOORDEN}}

Het in de vorige sectie beschreven commando @code{@value{TEL-WOORDEN}} heeft
twee bugs, of eigenlijk een bug met twee manifestaties. Ten eerste als je
een region markeert die alleen witte ruimte heeft in het midden van tekst,
zegt @code{@value{TEL-WOORDEN}} dat de region maar een woord heeft! Ten
tweede wanneer je een region markeert met alleen witte ruimte aan het einde
van het buffer of het bereikbare deel van een versmald buffer, toont het een
foutboodschap die er zo uit ziet:

@smallexample
Search failed: "\\w+\\W*"
@end smallexample

Wanneer je dit leest in Info in GNU Emacs, kan je deze bugs zelf testen.

Evalueer eerst de functie op de gebruikelijke manier om die te installeren.
@ifinfo
Hier volgt de functiedefinitie. Plaats de cursor achter het afsluitende
haakje sluiten en typ @kbd{C-x C-e} om die te installeren.

@smallexample
@group
;; @r{Eerste versie; has bugs!}
(defun @value{TEL-WOORDEN} (beginning end)
  "Toon aantal woorden in de region.
Woorden worden gedefinieerd als minstens een woord-vormend
karakter gevolgd door minstens een karakter dat
niet woord-vormend is. De syntax table van het buffer
bepaald welke karakters dat zijn."
@end group
@group
  (interactive "r")
  (message "Counting words in region ... ")
@end group

@group
;;; @r{1. Opzetten geschikte condities.}
  (save-excursion
    (goto-char beginning)
    (let ((count 0))
@end group

@group
;;; @r{2. Run de} while @r{loop.}
      (while (< (point) end)
        (re-search-forward "\\w+\\W*")
        (setq count (1+ count)))
@end group

@group
;;; @r{3. Toon een boodschap aan de gebruiker.}
      (cond ((zerop count)
             (message "De region heeft geen woorden."))
            ((= 1 count) (message "De region heeft 1 woord."))
            (t (message "De region heeft %d woorden." count))))))
@end group
@end smallexample
@end ifinfo

@need 1000
Wanneer je dat wilt, kan je ook deze key binding installeren door het te
evalueren:

@smallexample
(keymap-global-set "C-c =" '@value{TEL-WOORDEN})
@end smallexample

Om de eerste test uit te voeren zet mark en point aan begin en eind van de
volgende regel en typ dan @kbd{C-c =} (of @kbd{M-x @value{TEL-WOORDEN}}
wanneer je @w{@kbd{C-c =}} niet gebonden hebt.)

@smallexample
    een   twee  drie
@end smallexample

@noindent
Emacs toont je inderdaad dat de region drie woorden heeft.

Herhaal de test, maar plaats de mark aan het begin van de regel en plaats
point net @emph{voor} het woord @samp{een}. Typ opnieuw het commando
@kbd{C-c =} (of @kbd{M-x @value{TEL-WOORDEN}}). Emacs zou je moeten
vertellen dat de region geen woorden heeft, omdat het alleen uit witte
ruimte aan het begin van de regel bestaat. Maar in plaats daarvan vertelt
Emacs je dat de region één woord bevat!

Voor de derde test, kopieer de voorbeeldregel aan het eind van het
@file{*scratch*} buffer en typ dan meerder spaties aan het einde van de
regel. Plaats mar direct achter het woord @samp{drie} en point aan het einde
van de regel. (Het einde van de regel is het einde van het buffer.) Typ
@kbd{C-c =} (of @kbd{M-x @value{TEL-WOORDEN}}) net als je eerder
deed. Opnieuw zou Emacs je moeten zeggen dat de region geen woorden heeft,
omdat het bestaat uit witte ruimte aan het einde van de regel. In plaats
daarvan toont Emacs een foutboodschap die @samp{Search failed} zegt.

De twee bugs stammen van hetzelfde probleem.

Bekijk de eerste manifestatie van de bug, waar het commando je zegt dat de
witte ruimte aan het begin van de regel één woord bevat. Dit is wat er
gebeurt: Het commando @code{M-x @value{TEL-WOORDEN}} verplaatst point naar
het begin van de region. De @code{while} test of point kleiner is dan de
waarde van @code{end}, wat zo is. Vervolgens zoekt en vindt de reguliere
expressie zoekopdracht het eerste woord. Het zet point achter het
woord. @code{count} wordt op één gezet. De @code{while} loop herhaalt, maar
deze keer is de waarde van point groter dan de waarde van @code{end}, de
loop wordt verlaten en de functie toont een boodschap die zegt dat het
aantal woorden in de region één is. Kortom, de reguliere expressie
zoekopdracht zoekt en vindt het woord ondanks dat het buiten de gemarkeerde
region is.

In de tweede manifestatie van de bug is de region witte ruimte aan het einde
van het buffer. Emacs zegt @samp{Search failed}. Wat gebeurt is dat de
waar-of-onwaar-test in de @code{while} loop op waar test, dus de
zoekopdracht wordt uitgevoerd. Maar omdat er geen woorden meer zijn in het
buffer, faalt de zoekopdracht.

In beide manifestaties van de bug zoekt de zoekopdracht buiten de region of
probeert dat te doen.

De oplossing is om de zoekopdracht te limiteren tot de region---dat is een
vrij makkelijke actie, maar zoals je inmiddels gewend bent, is het niet zo
heel simpel als je zou denken.

Zoals we hebben gezien neemt de functie @code{re-search-forward} een
zoekpatroon als eerste argument. Maar naast die eerste, vereiste, argument,
accepteert die drie optionele argumenten. Het optionele tweede argument
begrenst de zoekopdracht. Het optionele argument, wanneer @code{t}, zorgt
dat de functie @code{nil} teruggeeft in plaats van een fout wanneer de
zoekopdracht faalt. Het optionele vierde argument is het aantal
herhalingen. (In Emacs kan je de documentatie van een functie bekijken door
het typen van @kbd{C-h f}, de naam van de functie en dan @key{RET}.)

In de @code{@value{TEL-WOORDEN}} definitie wordt de waarde van het einde van
de region bewaard in de variabele @code{end}, die doorgegeven wordt als een
argument aan de functie. We kunnen dus @code{end} als argument aan de
reguliere expressie zoekopdracht toevoegen.

@smallexample
(re-search-forward "\\w+\\W*" end)
@end smallexample

Als je echter alleen deze wijziging in de @code{@value{TEL-WOORDEN}}
definitie maakt en daarna de nieuwe versie van de definitie test op een stuk
witte ruimte, krijg je de foutboodschap die zegt @samp{Search failed}.

Wat gebeurt is het dit: de zoekopdracht is begrensd tot de region, en faalt
zoals je verwacht omdat er geen woord-vormende karakters in de region
zijn. Omdat die faalt, krijgen we een foutboodschap. Maar we willen in dit
geval geen foutboodschap krijgen, we willen de boodschap ``De region heeft
GEEN woorden'' krijgen.

De oplossing voor dit probleem is om @code{re-search-forward} een derde
argument @code{t} te geven, waardoor de functie @code{nil} teruggeeft in
plaats van een fout signaleren wanneer de zoekopdracht faalt.

Als je echter deze wijziging aanbrengt en probleert, dan zie je de boodschap
``Tel woorden in de region ...'' en @dots{} en je blijft die boodschap
@dots{} zien, totdat je @kbd{C-g} (@code{keyboard-quit}) typt.

Dit is wat er gebeurt: de zoekopdracht is begrensd tot de region, zoals
eerder, en faalt omdat er geen woord-vormende karakters in de region zijn,
zoals verwacht. Vervolgens geeft de @code{re-search-forward} expressie
@code{nil} terug. Het doet niets anders. In het bijzonder verplaatst het
point niet, wat het doet als zij-effect wanneer het een zoekdoel
vindt. Nadat de @code{re-search-forward} expressie @code{nil} teruggeeft,
wordt de volgende expressie in de @code{while} loop geëvalueerd. Deze
expressie verhoogt de teller. Daarna herhaalt de loop. De
waar-of-onwaar-test test op waar, omdat de waarde van point nog steeds
kleiner is dan end, doordat de @code{re-search-forward} point niet
verplaatst heeft. @dots{} en de cyclus herhaalt @dots{}

De @code{@value{TEL-WOORDEN}} definitie vereist nog een andere modificatie,
om de waar-of-onwaar-test van de @code{while} loop naar onwaar te laten
testen wanneer de zoekopdracht faalt. Anders gezegd, er zijn twee condities
waaraan voldoen moet worden in de waar-of-onwaar-test voordat de
woordtelling variabele wordt verhoogd: point moet nog steeds in de region
zijn en de zoek expressie moet een woord gevonden hebben om te tellen.

Omdat zowel de eerste als de tweede conditie samen waar moeten zijn, kunnen
de twee expressies, de region test en de zoekexpressie worden samengevoegd
met een speciale vorm @code{and} en ingebed in de @code{while} loop, zoals
dit:

@smallexample
(and (< (point) end) (re-search-forward "\\w+\\W*" end t))
@end smallexample

@c colon in printed section title causes problem in Info cross reference
@c also trouble with an overfull hbox
@iftex
@noindent
Voor informatie over @code{and}, zie @ref{kill-new functie, , De
@code{kill-new} functie}.)
@end iftex
@ifinfo
@noindent
(@xref{kill-new functie, , De @code{kill-new} functie}, voor informatie over
@code{and}.)
@end ifinfo

De @code{re-search-forward} expressie geeft @code{t} terug wanneer de
zoekopdracht slaagt en als zij-effect verplaatst die point. Vervolgens,
wanneer woorden worden gevonden, wordt point door de region
verplaatst. Wanneer de zoekexpressie faalt in het vinden van nog een woord,
of wanneer point het einde van de region bereikt, test de
waar-of-onwaar-test op onwaar, de @code{while} loop eindigt en de
@code{@value{TEL-WOORDEN}} functie toont een van zijn boodschappen.

Na het incorporeren van deze laatste wijzigingen, werkt
@code{@value{TEL-WOORDEN}} zonder bugs (tenminste, zonder bugs die ik heb
gevonden!). Hier is hoe die er uitziet:

@smallexample
@group
;;; @r{Finale versie:} @code{while}
(defun @value{TEL-WOORDEN} (beginning end)
  "Toon aantal woorden in de region."
  (interactive "r")
  (message "Tel woorden in region ... ")
@end group

@group
;;; @r{1. Opzetten geschikte condities.}
  (save-excursion
    (let ((count 0))
      (goto-char beginning)
@end group

@group
;;; @r{2. Run de} while @r{loop.}
      (while (and (< (point) end)
                  (re-search-forward "\\w+\\W*" end t))
        (setq count (1+ count)))
@end group

@group
;;; @r{3. Toon een boodschap aan de gebruiker.}
      (cond ((zerop count)
             (message
              "De region heeft GEEN woorden."))
            ((= 1 count)
             (message
              "De region heeft 1 woord."))
            (t
             (message
              "The region heeft %d woorden." count))))))
@end group
@end smallexample

@node recursive-count-words
@section Recursief woorden tellen
@cindex Tel woorden recursief
@cindex Recursief woorden tellen
@cindex Woorden, recursief geteld

Je kunt de functie om woorden te tellen zowel recursief als met een
@code{while} loop schrijven. Laten we zien hoe je dat doet.

Eerst moeten we herkennen dat de functie @code{@value{TEL-WOORDEN}} drie
taken heeft: het zet de geschikte condities op om de woorden die voorkomen
te tellen, het telt de woorden in de region, and het geeft de gebruiker een
boodschap die zegt hoeveel woorden er zijn.

Wanneer we een enkele recursieve functie schrijven die alles doet, krijgen
we een boodschap bij elke recursieve aanroep. Wanneer de region 13 woorden
bevat, krijgen we dertien boodschappen, de een na de ander. Dat willen we
niet! In plaats daarvan moeten we twee functies schrijven om het werk te
doen, waarvan eentje (de recursieve functie) wordt gebruikt binnen de
ander. Een functie zet de condities op en toont de boodschap, de ander geeft
de woordtelling terug.

Laten we starten met de functie die de boodschap laat zien. We blijven deze
functie @code{@value{TEL-WOORDEN}} noemen.

Dit is de functie die de gebruiker aanroept. Die is interactief. Die is
vergelijkbaar met de vorige versie van deze functie, behalve dat die
@code{recursive-count-words} aanroept om vast te stellen hoeveel woorden er
in de region zijn.

@need 1250
We kunnen gemakkelijk voor deze functie een sjabloon samenstellen, gebaseerd
op onze voorgaande versies:

@smallexample
@group
;; @r{Recursieve versie; met reguliere expressie zoekopdracht}
(defun @value{TEL-WOORDEN} (beginning end)
  "@var{documentatie}@dots{}"
  (@var{interactieve-expressie}@dots{})
@end group
@group

;;; @r{1. Opzetten geschikte condities.}
  (@var{verklarende boodschap})
  (@var{set-up functie}@dots{}
@end group
@group

;;; @r{2. Tel de woorden.}
    @var{recursieve aanroep}
@end group
@group

;;; @r{3. Toon een boodschap aan de gebruiker.}
    @var{boodschap met de woord telling}))
@end group
@end smallexample

De definitie ziet er eenvoudig uit, behalve dat we op enige manier de
telling teruggegeven door een recursieve aanroep moet worden doorgegeven aan
de boodschap die de woord telling toont. Een beetje nadenken suggereert dat
dit kan met een @code{let} expressie: we kunnen een variabele in de varlist
van een @code{let} expressie binden aan het aantal woorden in de region, die
wordt teruggegeven door de recursieve aanroep. Dan kan de @code{cond}
expressie met een binding de waarde aan de gebruiker tonen.

Vaak denkt met bij de binding binnen een @code{let} expressie als iets
ondergeschikt aan het primaire werk van een functie. Maar in dit geval wordt
dat wat je als primaire werk van de functie beschouwt, het tellen van
woorden, gedaan binnen de @code{let} expressie.

@need 1250
Met @code{let} ziet de functiedefinitie er zo uit: 

@smallexample
@group
(defun @value{TEL-WOORDEN} (beginning end)
  "Print number of words in the region."
  (interactive "r")
@end group

@group
;;; @r{1. Opzetten geschikte condities.}
  (message "Tel woorden in region ... ")
  (save-excursion
    (goto-char beginning)
@end group

@group
;;; @r{2. Tel de woorden.}
    (let ((count (recursive-count-words end)))
@end group

@group
;;; @r{3. Toon een boodschap aan de gebruiker.}
      (cond ((zerop count)
             (message
              "De region heeft GEEN woorden."))
            ((= 1 count)
             (message
              "De region heeft 1 woord."))
            (t
             (message
              "The region heeft %d woorden." count))))))
@end group
@end smallexample

Vervolgens moeten we de recursieve telfunctie schrijven.

Een recursieve functie heeft tenminste drie delen: de doe-opnieuw-test, de
volgende-stap-expressie en de recursieve aanroep.

De doe-opnieuw-test stelt vast of de functie wel of niet opnieuw aangeroepen
wordt. Omdat we woorden in een region tellen en een functie kunnen gebruiken
die voor elk woord point voorwaarts verplaatst, kan de doe-opnieuw-test
controleren of point nog steeds binnen de region is. De doe-opnieuw-test
moet de waarde van point ontdekken en vaststellen of point voor, op, of na
de waarde van het einde van de region is. We kunnen de functie @code{point}
gebruiken om point te lokaliseren. Vanzelfsprekend moeten we de waarde van
het einde van de region als argument aan de recursieve telfunctie doorgeven.

Daarnaast moet de doe-opnieuw-test testen of de zoekopdracht een woord
vindt. Wanneer die dat niet doet, moet de functie niet langer zichzelf
aanroepen.

De volgende-stap-expressie verandert een waarde zodat wanneer de recursieve
functie geacht wort te stoppen met zich zelf aan te roepen, die
stopt. Preciezer gezegd, de volgende-stap-expressie verandert een waarde
zodat op het juiste moment de doe-opnieuw-test de recursieve functie stopt
zichzelf aan te roepen. In dit geval dan de volgende-stap-expressie de
expressie zijn die point woord voor woord voorwaarts verplaatst.

Het derde deel van een resursieve functie is de recursieve aanroep.

Ook moeten we ergens een deel hebben dat het werk van de functie doet, een
deel dat de woorden telt. Een vitaal deel!

@need 1250
Maar we hebben nu al een overzicht van de recursieve telfunctie:

@smallexample
@group
(defun recursieve-tel-woorden (region-end)
  "@var{documentatie}@dots{}"
   @var{doe-opnieuw-test}
   @var{volgende-stap-expressie}
   @var{recursieve aanroep})
@end group
@end smallexample

Nu moeten de slots invullen. Laten we beginnen met de meest eenvoudige
gevallen: wanneer point aan het einde of voorbij de region is, dan kunnen er
geen woorden in de region zijn, en de functie moet nul teruggeven. Ook als
de zoekopdracht faalt zijn er geen woorden om te tellen, en moet de functie
nul teruggeven.

Anderzijds, wanneer point binnen de region is en de zoekopdracht is
succesvol, moet de functie zichzelf opnieuw aanroepen.

@need 800
Dus de doe-opnieuw-test zou er zo uit moeten zien:

@smallexample
@group
(and (< (point) region-end)
     (re-search-forward "\\w+\\W*" region-end t))
@end group
@end smallexample

Merk op dat de zoek expressie onderdeel is van de doe-opnieuw-test---de
functie geeft @code{t} terug wanneer de zoekopdracht slaagt en @code{nil}
wanneer die faalt. (@xref{Witte ruimte bug, , De witte ruimte bug in
@code{@value{TEL-WOORDEN}}}, voor een uitleg over hoe
@code{re-search-forward} werkt.)

De doe-opnieuw-test is een waar-of-onwaar-test van een @code{if}
clausule. Wanneer de doe-opnieuw-test slaagt, moet het dan-deel van de
@code{if} clausule de functie opnieuw aanroepen. Maar wanneer die faalt,
moet het anders-deel nul teruggeven, omdat of point buiten de region is, of
de zoekopdracht faalde omdat er geen woorden waren om te vinden.

Maar voordat we de recursieve aanroep bekijken, moeten we naar de
volgende-stap-expressie kijken. Wat is die? Die is interessant genoeg het
zoek-deel van de doe-opnieuw-test.

Naast @code{t} of @code{nil} voor de doe-opnieuw-test teruggeven verplaatst
@code{re-search-forward} point voorwaarts als zij-effect van een succesvolle
zoekopdracht. Dit is de actie die de waarde van point verandert, zodat de
recursieve functie stopt met zichzelf aanroepen wanneer point de beweging
door de region voltooit. De @code{re-search-forward} expressie is dus de
volgende-stap-expressie.

@need 1200
De body van @code{recursieve-tel-woorden} ziet er in overzicht zo uit:

@smallexample
@group
(if @var{doe-opnieuw-test-en-volgende-stap-expressie-gecombineerd}
    ;; @r{then}
    @var{recursieve-aanroep-die-telling-teruggeeft}
  ;; @r{else}
  @var{geef-nul-terug})
@end group
@end smallexample

Hoe het mechanisme dat telt te incorporeren?

Dit kan lastig zijn wanneer je niet gewend bent recursieve functies te
schrijven. Maar het kan en moet systematisch worden benaderd.

We weten dat het tel-mechanisme op de een of andere manier geassocieerd moet
zijn met de recursieve aanroep. Omdat de volgende-stap-expressie point een
woord voorwaarts verplaatst, en omdat de recursieve aanroep voor elk woord
plaatsvindt, moet het tel-mechanisme een expressie zijn die een optelt bij
de waarde teruggegeven door een aanroep van @code{recursive-count-words}.

@need 800
Beschouw verschillende gevallen:

@itemize @bullet
@item
Wanneer er twee woorden in de region zijn, moet de functie een waarde
teruggeven die resulteert van het optellen van één bij de waarde die wordt
teruggegeven wanneer die het eerste woord telt, plus het aantal teruggeven
wanneer het de resterende woorden in de region telt, wat in dit geval één
is.

@item
Wanneer er één woord in de region is, moet de functie een waarde teruggeven
die resulteert van het optellen van één bij de waarde teruggeven van het
tellen van dat woord, plus het aantal teruggeven wanneer het de resterende
woorden in de region telt, wat in dit geval nul is.

@item
Wanneer er geen woorden  in de region zijn moet de functie nul teruggeven.
@end itemize

Van de schets kunnen we zien dat het anders-deel van de @code{if} nul
teruggeeft in het geval er geen woorden zijn. Dat betekent dat het dan-deel
van de @code{if} een waarde moet teruggeven die resulteert van het optellen
van een bij de waarde teruggegeven door het tellen van de resterende
woorden.

@need 1200
De expressie ziet er zo uit, waarbij @code{1+} een functie is die één optelt
bij zijn argument.

@smallexample
(1+ (recursieve-tel-woorden region-end))
@end smallexample

@need 1200
De hele functie @code{recursieve-tel-woorden} ziet er dan zo uit:

@smallexample
@group
(defun recursieve-tel-woorden (region-end))
  "@var{documentatie}@dots{}"

;;; @r{1. doe-opnieuw-test}
  (if (and (< (point) region-end)
           (re-search-forward "\\w+\\W*" region-end t))
@end group

@group
;;; @r{2. dan-deel: de recursieve aanroep}
      (1+ (recursieve-tel-woorden region-end))

;;; @r{3. anders-deel}
    0))
@end group
@end smallexample

@need 1250
Laten we onderzoeken hoe dit werkt:

Wanneer er geen woorden in de region zijn, wordt het anders-deel van de
@code{if} expressie geëvalueerd en geeft de functie dus nul terug.

Wanneer er één woord in de region is, is de waarde van point kleiner dan de
waarde van @code{region-end} en de zoekopdracht slaagt. In dit geval test de
waar-of-onwaar-test van de @code{if} expressie op waar, en wordt het
dan-deel van de @code{if} expressie geëvalueerd. Deze expressie geeft een
waarde terug (die wordt opgeteld bij de waarde teruggegeven door de hele
functie) die de som is van één opgeteld bij de waarde teruggeven door een
recursieve aanroep. 

Ondertussen heeft de volgende-stap-expressie point over het eerste (in in
dit geval enige) woord laten springen. Dit betekent dat wanneer
@code{(recursieve-tel-woorden region-end)} een tweede keer wordt
geëvalueerd, als gevolg van de recursieve aanroep, de waarde van point
gelijk of groter is dan de waarde van het einde van de region. Dus deze keer
geeft @code{recursieve-tel-woorden} nul terug. De nul wordt opgeteld bij
één, en de oorspronkelijke evaluatie van @code{recursieve-tel-woorden} geeft
een plus nul terug, wat één is, het correcte aantal.

Wanneer er twee woorden in de region zijn, geeft de eerste aanroep van
@code{recursieve-tel-woorden} één opgeteld bij de waarde teruggeven door het
aanroepen van @code{recursieve-tel-woorden} op een region die de resterende
woorden bevat---wat inhoudt dat het één bij één optelt, dat twee geeft, wat
het correcte aantal is.

Op dezelfde manier, wanneer er drie woorden in de region zijn, geeft de
eerste aanroep van @code{recursieve-tel-woorden} één opgeteld bij de waarde
teruggegeven door het aanroepen van @code{recursieve-tel-woorden} op een
region die de resterende twee woorden bevat---enzovoorts.

@need 1250
@noindent
Met de volledige documentatie zien de twee functies er zo uit:

@need 1250
@noindent
De recusieve functie:

@findex recursive-count-words
@smallexample
@group
(defun recursieve-tel-woorden (region-end)
  "Aantal woorden tussen point and REGION-END."
@end group

@group
;;; @r{1. doe-opnieuw-test}
  (if (and (< (point) region-end)
           (re-search-forward "\\w+\\W*" region-end t))
@end group

@group
;;; @r{2. dan-deel: de recursieve aanroep}
      (1+ (recursieve-tel-woorden region-end))

;;; @r{3. anders-deel}
    0))
@end group
@end smallexample

@need 800
@noindent
De omliggende functie:

@smallexample
@group
;;; @r{Recursieve versie}
(defun @value{TEL-WOORDEN} (beginning end)
  "Toon aantal woorden in de region.
@end group

@group
Woorden worden gedefinieerd als minstens een woord-vormend
karakter gevolgd door minstens een karakter dat
niet woord-vormend is. De syntax table van het buffer
bepaald welke karakters dat zijn."
@end group
@group
  (interactive "r")
  (message "Tel woorden in region ... ")
  (save-excursion
    (goto-char beginning)
    (let ((count (recursieve-tel-woorden end)))
@end group
@group
      (cond ((zerop count)
             (message
              "De region heeft GEEN woorden."))
@end group
@group
            ((= 1 count)
             (message "De region heeft 1 woord."))
            (t
             (message
              "De region heeft %d woorden.." count))))))
@end group
@end smallexample

@node Tellen voorbeeld
@section Oefening: Leestekens tellen

Schrijf met een @code{while} loop een functie die het aantal leestekens in
een region telt---punt, komma, punt-komma, dubbele punt, uitroepteken en
vraagteken. Doe het nog een keer met recursie.

@node Woorden in een defun
@chapter Woorden tellen in een @code{defun}
@cindex Woorden tellen in een @code{defun}
@cindex Woorden tellen in een @code{defun}

Ons volgende project is het tellen van het aantal woorden in een
functiedefinitie. Het is duidelijk dat dit kan met een variant van
@code{@value{TEL-WOORDEN}}. @xref{Woorden tellen, , Tellen via repetitie en
regexps}. Wanneer we de woorden gaan tellen in éénn definitie, is het
makkelijk genoeg om de definitie met het commando @kbd{C-M-h}
(@code{mark-defun}) te markeren en dan @code{@value{TEL-WOORDEN}} aan te
roepen.

Ik ben echter meer ambitieus: ik wil de woorden en symbolen tellen in elke
definitie in de Emacs broncode en dan een grafiek tonen die laat zien
hoeveel functies er zijn van elke lengte: hoeveel bevatten 40 tot 49 woorden
of symbolen, hoeveel bevatten 50 tot 59 symbolen, enzovoorts. Ik ben vaak
nieuwsgierig hoe lang een typische functie is, en dit gaat het vertellen.

@menu
* Verdeel en heers::         Verdeel en heers
* Woorden en symbolen::      Wat te tellen?
* Syntax::                   Wat vormt een woord of een symbool?
* count-words-in-defun::     Erg vergelijkbaar met 
                               @code{@value{TEL-WOORDEN}}
* Enkele defuns::            Enkele defuns in een bestand tellen.
* Een bestand vinden::       Wil je naar een bestand kijken?
* lengte-lijst-bestand::     Een lijst met de lengtes van veel definities.
* Enkele bestanden::         Tellen in definities in verschillende 
                               bestanden.
* Enkele bestanden recursief::  Recursief tellen in verschillende bestanden.
* De data voorbereiden::     De data voorbereiden om in een grafiek te 
                               tonen.
@end menu

@ifnottex
@node Verdeel en heers
@unnumberedsec Verdeel en heers
@end ifnottex

In één zin beschreven lijkt dit histogram project ontmoedigend, maar
opgedeeld in talrijke kleine stappen, die we een voor een kunnen zetten
wordt dit project minder angstaanjagend. Laten we overwegen wat de stappen
moeten zijn:

@itemize @bullet
@item
Ten eerste schrijf een functie die de woorden in één definitie telt. Dit
bevat het probleem om zowel symbolen als woorden te behandelen.

@item
Ten tweede schrijf een functie die het aantal woorden in elke functie in een
bestand opsomt. Deze functie kan de functie @code{tel-woorden-in-defun}
gebruiken.

@item
Ten derde, schrijf een functie die het aantal woorden in elke functie in elk
van een aantal bestanden opsomt. Dit bevat automatisch vinden van diverse
bestanden, naar ze schakelen en de woorden in de definities in ze tellen.

@item
Ten vierde, schrijf een functie die de lijst met getallen die we in stap 3
hebben gemaakt omzet in een vorm die geschikt is om als grafiek te tonen.

@item
Ten vijfde, schrijf een functie die de resultaten als grafiek toont.
@end itemize

Dit is een behoorlijk project! Maar als we elke stap langzaam doen, is het
niet moeilijk.

@node Woorden en symbolen
@section Wat te tellen?
@cindex Woorden en symbolen in defun

Wanneer we beginnen met nadenken over hoe de woorden in een functiedefinitie
te tellen, is de eerste vraag (of zou dat moeten zijn) wat gaan we tellen?
Wanneer we over ``woorden'' spreken met betrekking tot een Lisp
functiedefinitie, dan spreken we feitelijk grotendeels over
symbolen. Bijvoorbeeld de volgende @code{vermenigvuldig-met-zeven} functie
bevat vijf de symbolen @code{defun}, @code{vermenigvuldig-met-zeven},
@code{getal}, @code{*} en @code{7}. Daarnaast bevat het in de
documentatiestring de vier woorden @samp{Vermenigvuldig}, @samp{GETAL},
@samp{met} en @samp{zeven}. Het woord @samp{getal} wordt herhaald, zodat de
definitie in totaal tien woorden en symbolen bevat.

@smallexample
@group
(defun vermenigvuldig-met-zeven (getal)
  "Vermenigvuldig GETAL met zeven."
  (* 7 getal))
@end group
@end smallexample

@noindent
Als we echter de @code{vermenigvuldig-met-zeven} definitie met @kbd{C-M-h}
(@code{mark-defun}) markeren en dan @code{@value{TEL-WOORDEN}} er op
aanroepen, dan zien we dat @code{@value{TEL-WOORDEN}} zegt dat de definitie
elf woorden bevat, niet tien! Er is duidelijk iets fout.

Het probleem is tweevoudig: @code{@value{TEL-WOORDEN}} telt niet de @samp{*}
als woord en het telt het enkele symbool @code{vermenigvuldig-met-zeven} als
drie woorden. De koppeltekens worden behandeld alsof het spaties tussen de
woorden zijn in plaats van een verbinding tussen de woorden:
@samp{vermenigvuldig-met-zeven} wordt geteld alsof er @samp{vermenigvuldig
met zeven} staat.

De oorzaak van deze verwarring is de reguliere expressie zoekopdracht in de
@code{@value{TEL-WOORDEN}} definitie die point woord voor woord voorwaarts
verpaatst. In de oorspronkelijke versie van @code{@value{TEL-WOORDEN}} is de
regexp: 

@smallexample
"\\w+\\W*"
@end smallexample

@noindent
Deze reguliere expressie is een patroon dat een of meer woord-vormende
letters mogelijk gevolgd door een of meer niet woord-vormende letters
definieert. Wat bedoeld wordt met ``woord-vormende letters'' brengt ons bij
het probleem van de syntax, wat een aparte sectie waard is.

@node Syntax
@section Wat vormt een woord of symbool?
@cindex Syntax categorieën en tabellen

Emacs behandelt verschillende karakters als behorend bij verschillende
@dfn{syntax categorieën}. De reguliere expressie @samp{\\w+} bijvoorbeeld is
ene patroon dat een of meer woord-vormende karakters
specificeert. Woord-vormende karakters zijn leden van een syntax
categorie. Andere syntax categorieën bevatten de klasse van leestekens,
zoals de punt en komma, en de klasse witte ruimte karakters zoals de spatie
en het tab-karakter. (Voor meer informatie @pxref{Syntax Tables, , Syntax
Tables, elisp, The GNU Emacs Lisp Reference Manual}.))

Syntax tabellen specificeren welke karakters tot welke categorie
behoren. Meestal is een koppelteken niet gespecificeerd als een
woord-vormend karakter. In plaats daarvan is het gespecificeerd als
onderdeel van de klasse van karakters die deel zijn van symboolnamen maar
niet woorden. Dit betekent dat de functie @code{@value{TEL-WOORDEN}} het op
dezelfde manier behandelt als het spaties tussen woorden behandelt en dat is
waarom @code{@value{TEL-WOORDEN}} @samp{vermenigvuldig-met-zeven} als drie
woorden telt.

Er zijn twee manieren die zorgen dat @samp{vermenigvuldig-met-zeven} als één
symbool telt: de syntax tabel aanpassen of de reguliere expressie aanpassen.

We kunnen een koppelteken als woord-vormend karakter herdefiniëren door de
syntax tabel aan te passen die Emacs voor elke mode bijhoudt. Deze actie zou
ons doel dienen, behalve dat een koppelteken slechts een veel gebruikt
karakter binnen symbolen is dat niet typisch een woord-vormend karakter is,
er zijn er ook andere.

We kunnen ook de regexp herdefiniëren die wordt gebruikt in de
@code{@value{TEL-WOORDEN}} zodat die ook symbolen bevat. Deze methode heeft
de waarde van duidelijkheid maar die taak is een beetje lastig.

@need 1200
Het eerste deel eenvoudig genoeg: het patroon moet minstens één karakter
matchen dat een woord of symbool vormt. Dus:

@smallexample
"\\(\\w\\|\\s_\\)+"
@end smallexample

@noindent
De @samp{\\(} is het eerste van de groeperende constructie  die de
@samp{\\w} en de @samp{\\s_} als alternatieven bevat, geschieden door de
@samp{\\|}. De @samp{\\w} matcht elk woord-vormend karakter en e @samp{\\s_}
matcht elke karakter dat onderdeel is van een symboolnaam maar geen
woord-vormend karakter is. De @samp{+} die op de groep volgt geeft aan dat
het woord- of symboolvormend karakter tenminste eenmaal moet worden
gematcht.x

Het tweede van de regexp is echter moeilijker te maken. Wat we willen is het
eerste deel op te volgen met optioneel een of meer karakters die geen woord
of symbool vormen. In eerste instantie dacht ik dat ik dit met het volgende
kon doen: 

@smallexample
"\\(\\W\\|\\S_\\)*"
@end smallexample

@noindent
De hoofdletters @samp{W} en @samp{S} matchen karakters die GEEN woord- of
symbool vormen. Helaas matcht deze expressie elke karakter dat of niet
woord-vormend of niet symbool-vormend is. Het matcht elk karakter!

Daarna merkte ik op dat elk woord of symbool in mijn test-region wordt
gevold door witte ruimte (spatie, tab of nieuwe regel). Daarom probeerde een
patroon dat een of meer spaties matcht achter het patroon voor een of meer
woord- of symboolvormende karakters te plaatsten. Dit mislukte ook. Woorden
en symbolen zijn vaak gescheiden door witte ruimte, maar in de code mogen
haakjes op symbolen volgen en leestekens op woorden. Daarom maakte
uiteindelijk ene patroon waarin woord- of symboolvormende karakters worden
gevolgd door optionele karakters die geen witten ruimte zijn en dan
optioneel gevold door witte ruimte.

@need 800
Hier is de volledige reguliere expressie:

@smallexample
"\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*"
@end smallexample

@node count-words-in-defun
@section De @code{tel-woorden-in-defun} functie
@cindex Woorden tellen in een @code{defun}

We hebben gezien dat er verschillende manieren zijn om een functie
@code{tel-woorden-region} te schrijven. Om een @code{tel-woorden-in-defun}
te schrijven, hoeven we slechts een van die versies aan te passen.

De versie die een @code{while} loop gebruikt is makkelijk te begrijpen,
daarom ga ik die aanpassen. Omdat @code{tel-woorden-in-defun} onderdeel
wordt van een meer complex programma, hoeft het niet interactief te zijn en
hoeft het geen boodschap te tonen, maar slecht de telling teruggeven. Deze
overwegingen vereenvoudigen de definitie een beetje.

Anderzijds, @code{tel-woorden-in-defun} wordt gebruikt in een buffer dat
functiedefinities bevat. Daarom is het redelijk te vragen dat de functie
vaststelt of het wordt aangeroepen met point binnen een functiedefinitie, en
zo ja, de telling voor die definitie terug te geven. Dit voegt complexiteit
toe aan de definitie, maar redt ons van de noodzaak om argumenten aan de
functie door te geven.

@need 1250
Deze overwegingen leiden ons tot het voorbereiden van het volgende sjabloon:

@smallexample
@group
(defun tel-woorden-in-defun ()
  "@var{documentatie}@dots{}"
  (@var{opzetten}@dots{}
     (@var{while loop}@dots{})
   @var{geef telling terug})
@end group
@end smallexample

@noindent
Zoals gebruikelijk is het onze taak de slots in te vullen.

Eerst het opzetten

Wij gaan er van uit dat deze functie wordt aangeroepen binnen een buffer dat
functiedefinities bevat. Point is in een functiedefinitie of niet. Om
@code{tel-woorden-in-defun} te laten werken moet point naar het begin van de
definitie verplaatsen, een teller moet bij nul beginnen en de tellende loop
moet stoppen wanneer point het einde van de definitie bereikt.

De functie @code{beginning-of-defun} zoekt achterwaarts naar een
openingsscheidingsteken zoals een @samp{(} aan het begin van de regel en
verplaatst point naar die positie of anders naar de begrenzing van de
zoekopdracht. In de praktijk betekent dit dat @code{beginning-of-defun} pint
naar het begin van een buitenliggende of voorgaande functiedefinitie
verplaatst, of anders naar het begin van het buffer. De kunnen
@code{beginning-of-defun} gebruiken om de point daar neer te zetten waar wij
willen beginnen.

De @code{while} loop vereist een teller om het aantal getelde woorden of
symbolen bij te houden. Een @code{let} expressie kan worden gebruikt om een
lokale variabele voor dit doel te maken en te binnen aan een initiële waarde
van nul.

De functie @code{end-of-defun} werkt net als de @code{beginning-of-defun}
behalve dat het point naar het einde van de definitie
verplaatst. @code{end-of-defun} kan worden gebruikt als onderdeel van een
expressie die de positie van het einde van de definitie vaststelt.

Het opzetten van de @code{tel-woorden-in-defun} begint al snel vorm te
krijgen: eerst verplaatsten we point naar het begin van de definitie,
vervolgens maken we een lokale variable die telling bewaart en tenslotte
registeren we de positie van het einde van de definitie zodat de
@code{while} loop weet wanneer te stoppen met loopen.

@need 1250
De code ziet er zo uit:

@smallexample
@group
(beginning-of-defun)
(let ((telling 0)
      (einde (save-excursion (end-of-defun) (point))))
@end group
@end smallexample

@noindent
De code is eenvoudig. De enige kleine complicatie zal waarschijnlijk
betrekking hebben op @code{einde}: het is gebonden aan de positie van het
einde van de definitie door een @code{save-excursion} expressie die de
waarde van point na @code{end-of-defun} tijdelijk verplaatst naar het einde
van de definitie.

Het tweede deel van de @code{tel-woorden-in-defun}, na het opzetten, is de
@code{while} loop.

De loop moet een expressie bevatten die point woord voor woord en symbool
voor symbool voorwaarts laat springen, en een andere expressie die de
sprongen telt. De waar-of-onwaar-test voor de @code{while} loop moet op waar
testen zolang als point voorwaarts moet springen, en op onwaar wanneer point
aan het einde van de definitie is. We hebben hiervoor al een reguliere
expressie aangepast, zodat de loop makkelijk is.

@smallexample
@group
(while (and (< (point) einde)
            (re-search-forward
             "\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*" einde t))
  (setq telling (1+ telling)))
@end group
@end smallexample

Het derde deel van de functiedefinitie geeft de telling van de woorden en
symbolen terug. Dit deel is de laatste expressie in de body van de
@code{let} en kan eenvoudigweg de lokale variabele @code{telling} zijn, die
geëvalueerd de telling teruggeeft.

@need 1250
Samengevoegd ziet de @code{tel-woorden-in-defun} er zo uit:

@findex count-words-in-defun
@smallexample
@group
(defun tel-woorden-in-defun ()
  "Geef het aantal woorden en symbolen in een defun terug."
  (beginning-of-defun)
  (let ((telling 0)
        (einde (save-excursion (end-of-defun) (point))))
@end group
@group
    (while
        (and (< (point) einde)
             (re-search-forward
              "\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*"
              einde t))
      (setq telling (1+ telling)))
    telling))
@end group
@end smallexample

Hoe dit te testen? De functie is niet interactief, maar het is makkelijk om
een wrapper om de de functie te zetten die het interactief maakt. Wij kunnen
bijna dezelfde code gebruiken als voor de recursieve versie van
@code{@value{TEL-WOORDEN}}:

@smallexample
@group
;;; @r{Interactieve versie.}
(defun tel-woorden-defun ()
  "Aantal woorden en symbolen in een functiedefinitie."
  (interactive)
  (message
   "Tel woorden en symbolen in functiedefinitie ... ")
@end group
@group
  (let ((telling (tel-woorden-in-defun)))
    (cond
     ((zerop telling)
      (message
       "The definitie heeft GEEN woorden of symbolen."))
@end group
@group
     ((= 1 telling)
      (message
       "De definitie heeft 1 woord of symbool."))
     (t
      (message
       "The definitie heeft %d woorden of symbolen." telling)))))
@end group
@end smallexample

@need 800
@noindent
Laten we @kbd{C-c =} hergebruiken als een handige keybinding:

@smallexample
(keymap-global-set "C-c =" 'tel-woorden-defun)
@end smallexample

Nu kunnen we @code{tel-woorden-defun} uitproberen: installeer zowel
@code{tel-woorden-in-defun} als @code{tel-woorden-defun} en zet de
keybinding. Kopieer dat het volgende naar een Emacs Lisp buffer (zoals
bijvoorbeeld @file{*scratch*}), plaats de cursor in de functie en gebruik
het @kbd{C-c =} commando.

@smallexample
@group
(defun vermenigvuldig-met-zeven (getal)
  "Vermenigvuldig GETAL met zeven."
  (* 7 getal))
     @result{} 10
@end group
@end smallexample

@noindent
Succes! De definitie heeft 10 woorden en symbolen.

Het volgende probleem is om het aantal woorden en symbolen in meerdere
definities in een enkel bestand te tellen.

@node Enkele defuns
@section Tel verschillende @code{defuns} in een bestand

Een bestand zoals @file{simple.el} kan honderd of meer functiedefinities
bevatten. Ons langetermijndoel is om statistieken over veel bestanden de
verzamelen, maar als eerste stap is ons huidige doel om de statistieken over
een bestand te verzamelen.

De informatie bestaat uit een reeks getallen, elk getal is de lengte van een
functiedefinitie.

We weten dat we de informatie met betrekking tot een bestand willen
incorporeren in de informatie van veel andere bestanden. Dit betekent dat de
functie voor het tellen van definitie-lengtes binnen een bestand alleen een
lijst met de lengtes hoeft terug te geven. Het hoeft geen boodschappen te
tonen en moet dat ook niet doen.

Het woord-tel commando bevat een expressie die point woord voor woord
voorwaarts laat springen en een andere die de sprongen telt. De functie die
de lengtes van de definities teruggeeft kan op een vergelijkbare manier
gemaakt worden, met een expressie die point definitie voor definitie
voorwaarts springt en een andere expressie die de lijst met lengtes
construeert.

Deze formulering van het probleem maakt het eenvoudig om de functiedefinitie
te schrijven. We beginnen de telling aan het begin van het bestand, dus het
eerste commando wordt @code{(goto-char (point-min))}. Vervolgens starten we
de @code{while} loop. De waar-of-onwaar-test van de loop kan een reguliere
expressie zijn die zoekt naar de volgende functiedefinitie---zolang de
zoekopdracht slaagt, wordt point voorwaarts verplaatst en de body van de
loop geëvalueerd. De body heeft een expressie nodig die de lijst met lengtes
maakt. @code{cons}, het lijst-constructie commando kan gebruikt worden om de
lijst te maken. Dat is bijna alles wat er te zeggen is.

@need 800
Hier is hoe dit codefragment er uit ziet:

@smallexample
@group
(goto-char (point-min))
(while (re-search-forward "^(defun" nil t)
  (setq lengtes-lijst
        (cons (count-words-in-defun) lengtes-lijst)))
@end group
@end smallexample

Wat we overgeslagen hebben is het mechanisme om het bestanden te vinden dat
de functiedefinities bevat.

In de voorgaande voorbeelden gebruikten we of dit, het Info bestand, of we
schakelden heen en weer naar een ander buffer, zoals het @file{*scratch*}
buffer.

Een bestand vinden is een nieuw proces dat we nog niet eerder besproken
hebben.

@node Een bestand vinden
@section Een bestand vinden
@cindex Een bestand vinden

Om in Emacs een bestand te vinden, gebruik je het @kbd{C-x C-f}
(@code{find-file}) commando. Dit commando is bijna, maar niet helemaal
geschikt voor het lengte probleem.

@need 1200
Laten we naar de broncode van @code{find-file} kijken:

@smallexample
@group
(defun find-file (filename)
  "Edit file FILENAME.
Switch to a buffer visiting file FILENAME,
creating one if none already exists."
  (interactive "FFind file: ")
  (switch-to-buffer (find-file-noselect filename)))
@end group
@end smallexample

@noindent
(De meest recente versie van de @code{find-file} functiedefinitie staat je
toe dat je optionele wildcards specificeert om meerder files te
bezoeken. Dat maakt de definitie meer complex en dat bespreken we hier niet,
omdat het niet relevant is. Je kunt de broncode zien met hetzij @kbd{M-.}
(@code{xref-find-definitions}) or @kbd{C-h f} (@code{describe-function}).)

@ignore
In Emacs 22
(defun find-file (filename &optional wildcards)
  "Edit file FILENAME.
Switch to a buffer visiting file FILENAME,
creating one if none already exists.
Interactively, the default if you just type @key{RET} is the current directory,
but the visited file name is available through the minibuffer history:
type M-n to pull it into the minibuffer.

Interactively, or if WILDCARDS is non-nil in a call from Lisp,
expand wildcards (if any) and visit multiple files.  You can
suppress wildcard expansion by setting `find-file-wildcards' to nil.

To visit a file without any kind of conversion and without
automatically choosing a major mode, use \\[find-file-literally]."
  (interactive (find-file-read-args "Find file: " nil))
  (let ((value (find-file-noselect filename nil nil wildcards)))
    (if (listp value)
        (mapcar 'switch-to-buffer (nreverse value))
      (switch-to-buffer value))))
@end ignore

De definitie die ik laat zien bevat een korte maar complete documentatie en
een interactieve specificatie die je naar een bestandsnaam vraagt wanneer je
het commando interactief gebruikt. De body van de definitie bevat twee
functies, @code{find-file-noselect} en @code{switch-to-buffer}.

Volgens de documentatiestring die getoond wordt met @kbd{C-h f} (het
@code{describe-function} commando), leest de functie
@code{find-file-noselect} het genoemde bestand in in een buffer en geeft het
buffer terug. (De meest recente versie bevat eveneens een optioneel
@var{wildcards} argument, naast een ander om het bestand letterlijk te lezen
en een ander om foutmeldingen te onderdrukken. Deze optionele argumenten
zijn irrelevant.)

De functie @code{find-file-noselect} selecteert echter geen buffer om het
bestand in te stoppen. Emacs schakelt zijn aandacht (of de jouwe als je met
@code{find-file-noselect}) niet naar het geselecteerde buffer. Dat is wat
@code{switch-to-buffer} doet: het schakelt het buffer naar waar Emacs
aandacht is gericht, en het schakelt het getoonde buffer in het window naar
het nieuwe buffer. We hebben schakelen van buffers eerder besproken
(@xref{Van buffer verwisselen}.)

In het histogram-project hoeven we niet elk bestand op het scherm te tonen
wanneer het programma de lengte van elke defintie er in vaststelt. In plaats
van @code{switch-to-buffer} te gebruiken kunnen we werken met
@code{set-buffer}, wat de aandacht van het computerprogramma naar een ander
buffer herleidt maar vervangt niet het scherm. Daarom moeten we in plaats
van @code{find-file} aan te roepen om het werk te doen onze expressie zelf
schrijven.

De taak is makkelijk: gebruik  @code{find-file-noselect} en
@code{set-buffer}.

@node lengte-lijst-bestand
@section @code{lengte-lijst-bestand} in detail

De kern van de functie @code{lengte-lijst-bestand} is een @code{while} loop
dat een functie bevat om point defun voor defun voorwaarts te verplaatsen en
een functie om het aantal woorden en symbolen in elke defun te tellen. Deze
kern moet worden omgeven door functie die verschillende andere taken doen,
waaronder het bestand vinden en zorgen dat point start vanaf het begin van
het bestand. De functiedefinitie ziet er zo uit:
@findex lengte-lijst-bestand

@smallexample
@group
(defun lengte-lijst-bestand (bestandsnaam)
  "Geef een lijst terug met definitielengtes in BESTANDSNAAM.
De teruggeven lijst is een lijst van getallen.
Elk getal is een het aahtal woorden of symbolen
in een functiedefinitie."
@end group
@group
  (message "Werkt aan `%s' ... " bestandsnaam)
  (save-excursion
    (let ((buffer (find-file-noselect bestandsnaam))
          (lengte-lijst))
      (set-buffer buffer)
      (setq buffer-read-only t)
      (widen)
      (goto-char (point-min))
      (while (re-search-forward "^(defun" nil t)
        (setq lengte-lijst
              (cons (tel-woorden-in-defun) lengte-lijst)))
      (kill-buffer buffer)
      lengte-lijst)))
@end group
@end smallexample

@noindent
De functie krijgt één argument doorgegeven, de naam van het bestand waarop
het gaat werken. Het heeft vier regels documentatie maar geen interactieve
specificatie. Omdat mensen bang zijn dat de computer kapot is wanneer ze
niets zien gebeuren, bevat de eerste regel van de body een boodschap.

De volgende regel bevat een @code{save-excursion} die Emacs aandacht
terugbrengt bij het huidige buffer wanneer de functie klaar is. Dit is
nuttig wanneer je de functie in een andere functie inbed, die verwacht dat
point wordt hersteld naar het oorspronkelijke buffer.

In de varlist van de @code{let} expressie vindt Emacs het bestand en bindt
de lokale variabele @code{buffer} aan het buffer dat het bestand
bevat. Tegelijkertijd maakt Emacs @code{lengte-lijst} als lokale variabele.

Vervolgens schakelt Emacs de aandacht naar het buffer.

In de volgende regel maakt Emacs het buffer read-only. In het ideale geval
is deze regel niet nodig. Geen van de functies om woorden en symbolen te
tellen zou het buffer moeten veranderen. En daarnaast wordt het buffer niet
gesaved zelf wanneer het is gewijzigd. Deze regel is geheel het gevolg van
de een grote, misschien overdreven, voorzichtigheid. De reden voor deze
voorzichtigheid is dat de functie en de functies die het aanroept werken op
de broncode van Emacs en het is ongemakkelijk wanneer die per ongeluk worden
gewijzigd. Het spreekt voor zich dat ik de noodzaak voor deze regel niet
realiseerde totdat een experiment misging en mijn Emacs broncode begon te
wijzigen @dots{}

Hierna komt de aanroep om het buffer te verbreden wanneer het is
versmald. Deze functie is meestal niet nodig---Emacs maakt een vers buffer
wanneer er niet al een bestaat, maar wanneer er al een buffer het bestand
bezoekt kan het versmald zijn en moet het worden verbreed. Wanneer we
volledig gebruikersvriendelijk willen zijn zouden we de restrictie en de
lokatie van point opslaan, maar dat doen we niet.

De @code{(goto-char (point-min))} expressie verplaatst point naar het begin
van het buffer.

Dan komt de @code{while} loop waarin het werk van de functie wordt
uitgevoerd. In de loop stelt Emacs de lengte van elke definitie vast en
construeert een lengte-lijst die de informatie bevat.

Na er doorheen gewerkt te hebben killt Emacs het buffer. Dit is om binnen
Emacs ruimte te sparen. Mijn versie van GNU Emacs 19 bevat over 300
bronbestanden die interessant zijn. GNU Emacs 22 bevat meer dan duizend
bronbestanden. Een andere functie past @code{lengte-lijst-bestand} op elk
bestand toe.

De laatste expressie in de @code{let} expressie tenslotte is de lengte-lijst
variabele, wiens waarde wordt teruggegeven als de waarde van de gehele
functie.

Dit kun je uitproberen door het op de gebruikelijke manier te
installeren. Plaats daarna de cursor achter de volgende expressie en typ
@kbd{C-x C-e} (@code{eval-last-sexp}).

@c !!! 22.1.1 lisp sources location here
@smallexample
(lengte-lijst-bestand
 "/usr/local/share/emacs/22.1/lisp/emacs-lisp/debug.el")
@end smallexample

@noindent
Misschien moet je de padnaam van het bestand aanpassen, deze hier is voor
GNU Emacs versie 22.1. Om de expressie te wijzigen, kopieer je die naar het
@file{*scratch*} buffer en wijzig het.

@need 1200
@noindent
@c We do not want to insert, so do not mention the zero prefix argument.
En om de volledige lengte van de lijst te zien, in plaats van een ingekorte
versie, moet je misschien het volgende evalueren:

@smallexample
(custom-set-variables '(eval-expression-print-length nil))
@end smallexample

@noindent
(@xref{defcustom, , Variabelen specificeren met @code{defcustom}}. Evalueer
daarna de @code{lengte-lijst-bestand
} expressie.)

@need 1200
Het maken van de lengte-lijst voor @file{debug.el} duurt minder dan een
seconde en ziet er zo uit in GNU Emacs 22:

@smallexample
(83 113 105 144 289 22 30 97 48 89 25 52 52 88 28 29 77 49 43 290 232 587)
@end smallexample

@need 1500
(Op mijn oude machine duurde het maken van de versie 19 lengte-lijst van
@file{debug.el} zeven seconden en ziet er zo uit:

@smallexample
(75 41 80 62 20 45 44 68 45 12 34 235)
@end smallexample

@noindent
De nieuwe versie van @file{debug.el} bevat meer defuns dan de eerdere, en
mijn nieuwe machine is veel sneller dan de oude.)

Merk op dat de lengte van de laatste definitie in het bestand de eerste in
de lijst is.

@node Enkele bestanden
@section Woorden tellen in  @code{defuns} in verschillende bestanden

In de vorige sectie hebben we een functie gemaakt die een lijst teruggeeft
met de lengte van elke definitie in een bestand. Nu willen we een functie
definieren de een hoofdlijst teruggeeft met de lengte van de definities in
een lijst van bestanden.

Werken op elk bestand van een bestandenlijst is een herhalende actie, dus we
kunnen een @code{while} loop of recursie gebruiken.

@menu
* lengths-list-many-files::  Een lijst met de lengte van defuns teruggeven.
* append::                   Een lijst aan een andere koppelen.
@end menu

@ifnottex
@node lengths-list-many-files
@unnumberedsubsec De lengte van @code{defuns} vaststellen
@end ifnottex

Het ontwerp met een @code{while} loop is routine. Het aan de functie
doorgegeven argument is een lijst van bestanden. Zoals we eerder zagen
(@pxref{Loop voorbeeld}), kan je een @code{while} loop zo schijven dat de
body van de loop wordt geëvalueerd zo'n lijst elementen bevat, maar de loop
verlaat wanneer de lijst leeg is. Om dit te laten werken moet de body van de
loop een expressie bevatten die elke keer dat de body wordt geëvalueerd de
lijst korter maakt, zodat uiteindelijk de lijst leeg is. De gebruikelijke
techniek is om elke keer dat de body wordt geëvalueerd de waarde van de
lijst op de waarde van de @sc{cdr} van de lijst te zetten.

@need 800
Het sjabloon ziet er zo uit:

@smallexample
@group
(while @var{test-of-lijst-leeg-is}
  @var{body}@dots{}
  @var{zet-lijst-op-cdr-van-lijst})
@end group
@end smallexample

We herinneren ons ook dat een @code{while} loop @code{nil} teruggeeft (het
resultaat van het evalueren van de waar-of-onwaar-test) en niet het
resultaat van een evaluatie in de body. (De evaluaties in de body van de
loop worden gedaan voor hun zij-effecten.) Echter de expressie die de
lengte-lijst zet is onderdeel van de body---en dat is de waarde waarvan we
willen dat de gehele functie teruggeeft. Om dit te doen plaatsen we de
@code{while} loop binnen een @code{let} expressie, en zorgen dat het laatste
element van de @code{let} expressie de waarde van de lengte-lijst
bevat. (@xref{Incrementeel voorbeeld, , Loop voorbeeld met een ophogende
teller.}.)

@findex lengths-list-many-files
@need 1250
Deze overwegingen leiden on direct naar de functie zelf:

@smallexample
@group
;;; @r{Gebruik @code{while} loop.}
(defun lengte-lijst-veel-bestanden (lijst-met-bestanden)
  "Return list of lengths of defuns in LIJST-MET-BESTANDEN."
@end group
@group
  (let (lengte-lijst)

;;; @r{waar-of-onwaar-test}
    (while lijst-met-bestanden
      (setq lengtes-lijst
            (append
             lengtes-lijst

;;; @r{Genereer een lengte-ljist.}
             (lengtes-lijst-bestand
              (expand-file-name (car lijst-met-bestanden)))))
@end group

@group
;;; @r{Maak bestandenlijst korter.}
      (setq lijst-met-bestanden (cdr lijst-met-bestanden)))

;;; @r{Geef finale waarde lengtes-lijst terug.}
    lengtes-lijst))
@end group
@end smallexample

@code{expand-file-name} is een ingebouwde functie die een bestandsnaam omzet
naar de absolute lange padnaam vorm. De functie gebruikt de naam van de
directory waarin de functie is aangeroepen.

@c !!! 22.1.1 lisp sources location here
@need 1500
Dus wanneer @code{expand-file-name} wordt aangeroepen op @code{debug.el}
terwijl Emacs de directory
@file{/usr/local/share/emacs/22.1.1/lisp/emacs-lisp/} bezoekt,

@smallexample
debug.el
@end smallexample

@need 800
@noindent
wordt

@c !!! 22.1.1 lisp sources location here
@smallexample
/usr/local/share/emacs/22.1.1/lisp/emacs-lisp/debug.el
@end smallexample

Het enige andere nieuwe element van deze functie is de tot nu toe niet
bestudeerde functie @code{append}, die op zichzelf een korte sectie waard
is.

@node append
@subsection De functie @code{append}

@need 800
De functie @code{append} maakt een lijst aan een andere vast. Dus,

@smallexample
(append '(1 2 3 4) '(5 6 7 8))
@end smallexample

@need 800
@noindent
produceert de lijst

@smallexample
(1 2 3 4 5 6 7 8)
@end smallexample

Dit is exact hoe we twee door @code{lengte-lijst-bestand} gemaakte
lengte-lijsten aan elkaar willen vastmaken. Het resultaat contrasteert met
@code{cons}, 

@smallexample
(cons '(1 2 3 4) '(5 6 7 8))
@end smallexample

@need 1250
@noindent
die een nieuwe lijst construeert waarin het eerste argument van @code{cons}
het eerste element van de nieuwe lijst wordt:

@smallexample
((1 2 3 4) 5 6 7 8)
@end smallexample

@node Enkele bestanden recursief
@section Recursief woorden tellen in verschillende bestanden

Behalve met een @code{while} loop kan je met recursie werken op elk bestand
in een lijst van bestanden. Een recursieve versie van
@code{}(lengte-lijst-veel-bestanden) is kort en simpel.

De recursieve functie heeft de gebruikelijke delen: de doe-opnieuw-test, de
volgende-stap-expressie en de recursieve aanroep. De doe-opnieuw-test stelt
vat of de functie zichzelf opnieuw moet aanroepen, wat die doet wanneer de
@code{lijst-met-bestanden} resterende elementen bevat. De
volgende-stap-expressie zet de @code{lijst-met-bestanden} op de @sc{cdr} van
zichzelf, zodat uiteindelijk de lijst leeg wordt. en de recursieve aanroep
roept zichzelf met de kortere lijst. De complete functie is korter dan deze
beschrijving!
@findex recursieve-lengte-lijst-veel-bestanden

@smallexample
@group
(defun recursieve-lengte-lijst-veel-bestanden (lijst-met-bestanden)
  "Geeft lijst met lengtes terug van elke defun in LIJST-MET-BESTANDEN."
  (if lijst-met-bestanden                     ; @r{doe-opnieuw-test}
      (append
       (lengte-lijst-bestand
        (expand-file-name (car lijst-met-bestanden)))
       (recursieve-lengte-lijst-veel-bestanden
        (cdr lijst-met-bestanden)))))
@end group
@end smallexample

@noindent
In één zin, de functie geeft de lengte-lijst terug voor de eerste van de
@code{lijst-met-bestanden} vastgemaakt aan het resultaat van zichzelf
aanroepen op de rest van de @code{lijst-met-bestanden}.

Hier is een test van @code{recursieve-lengte-lijst-veel-bestanden}, samen
met de resultaten van het draaien van @code{lengte-lijst-bestand} op elk
individueel bestand.

Installeer @code{recursieve-lengte-lijst-veel-bestanden} en indien nodig
@code{lengte-lijst-bestand} en evalueer de volgende expressies. Je moet
misschien de padnamen van bestanden aanpassen, deze werken hier wanneer dit
Infobestand and de Emacs bronbestanden op hun gebruikelijke plaats staan. Om
de expressies aan te passen kopieer je ze in het @file{*scratch*} buffer,
pas je ze aan en evalueer je ze.

De resultaten worden getoond achter de  @samp{@result{}}. (Deze resultaten
zijn voor bestanden van Emacs versie 22.1.1. Bestanden van andere versies
van Emacs kunnen andere resultaten produceren.)

@c !!! 22.1.1 lisp sources location here
@smallexample
@group
(cd "/usr/local/share/emacs/22.1.1/")

(lengte-lijst-bestand "./lisp/macros.el")
     @result{} (283 263 480 90)
@end group

@group
(lengte-lijst-bestand "./lisp/mail/mailalias.el")
     @result{} (38 32 29 95 178 180 321 218 324)
@end group

@group
(lengte-lijst-bestand "./lisp/hex-util.el")
     @result{} (82 71)
@end group

@group
  (recursieve-lengte-lijst-veel-bestanden
   '("./lisp/macros.el"
     "./lisp/mail/mailalias.el"
     "./lisp/hex-util.el"))
       @result{} (283 263 480 90 38 32 29 95 178 180 321 218 324 82 71)
@end group
@end smallexample

De functie @code{recursieve-lengte-lijst-veel-bestanden} produceert de
output die we willen.

De volgende stap is het voorbereiden van de data in de lijst om in een
grafiek te tonen.

@node De data voorbereiden
@section De data voorbereiden om in een grafiek te tonen

De functie @code{recursieve-lengte-lijst-veel-bestanden} geeft een lijst met
getallen terug. Elk getal staat voor de lengte van een functiedefinitie. Wat
we nu moeten doen is deze data omzetten in een lijst van getallen die
geschikt is om een grafiek mee te genereren. De nieuwe lijst vertelt hoeveel
functiedefinities bevatten minder dan 10 woorden en symbolen, hoeveel
bevatten tussen 10 en 19 symbolen. enzovoorts.

In het kort, we moeten door de lengte-lijst heen gaan, die de functie
@code{recursieve-lengte-lijst-veel-bestanden} heeft geproduceerd, en het
aantal defuns in elke range van lengtes tellen, en een lijst van deze
aantallen produceren.

@menu
* Data in detail te tonen::  Data in detail te tonen
* Sorteren::                 Lijsten sorteren
* Bestandenlijst::           Een lijst van bestanden maken.
* Functiedefinities tellen::  Functiedefinities tellen
@end menu

@ifnottex
@node Data in detail te tonen
@unnumberedsubsec De data om in detail te tonen
@end ifnottex

Gebaseerd op wat we eerder gedaan hebben, kunnen we makkelijk voorzien dat
het niet al te moeilijk moet zijn een functie te schrijven die @sc{crd}-t de
lengte-lijst afloopt, vaststelt in welke lengte-range die in is, en een
teller verhoogt voor die range.

Voordat we echter beginnen met het schrijven van zo'n functie, moeten we de
voordelen van het sorteren van de lengte-lijst in ogenschouw nemen, zodat de
getallen zijn gesorteerd van de kleinste tot de grootste. Ten eerste maakt
het sorteren het eenvoudiger de getallen in elke range te tellen, omdat twee
opeenvolgende getallen in dezelfde range of aangrenzende ranges zijn. Ten
tweede door de gesorteerde lijst te inspecteren kunnen we ontdekken wat het
hoogste en het laagste getal zijn, en daarmee vaststellen welke grootste en
kleinste lengte-range we nodig hebben.

@node Sorteren
@subsection Lijsten sorteren
@findex sorteren

Emacs heeft een functie om lijsten te sorteren, met de naam (zoals je kunt
raden) @code{sort}. De functie @code{sort} vereist twee argumenten, de lijst
om te sorteren, en een predicaat dat vaststelt of het eerste van twee
lijst-elementen kleiner is dan de tweede.

Zoals we eerder zagen (@pxref{Verkeerde type argument, , Gebruik van het
verkeerde objecttype als argument}), is een predicaat een functie die
vaststelt of een bepaalde eigenschap waar of onwaar is. De functie
@code{sort} herordent een lijst in overeenstemming met de eigenschap die het
predicaat gebruikt. Dit betekent dat @code{sort} kan worden gebruikt om een
niet-numerieke lijst te sorteren op niet-numerieke criteria---het kan
bijvoorbeeld een lijst op alfabetische volgorde zetten.

@need 1250
De functie @code{<} wordt gebruikt om een numerieke lijst te
sorteren. Bijvoorbeeld,

@smallexample
(sort '(4 8 21 17 33 7 21 7) '<)
@end smallexample

@need 800
@noindent
produceert dit:

@smallexample
(4 7 7 8 17 21 21 33)
@end smallexample

@noindent
(Merk op dat in dit voorbeeld beide argumenten zijn gequote zodat de
symbolen niet worden geëvalueerd voordat ze als argumenten aan de
@code{sort} worden doorgegeven.)

Het sorteren van de lijst die teruggeven is door de functie
@code{recursieve-lengte-lijst-veel-bestanden} is eenvoudig, het gebruikt de
functie @code{<}:

@smallexample
@group
(sort
 (recursieve-lengte-lijst-veel-bestanden
  '("./lisp/macros.el"
    "./lisp/mailalias.el"
    "./lisp/hex-util.el"))
 '<)
@end group
@end smallexample

@need 800
@noindent
produceert:

@smallexample
(29 32 38 71 82 90 95 178 180 218 263 283 321 324 480)
@end smallexample

@noindent
(Merk op dat in dit voorbeeld het eerste argument van @code{sort} is niet
gequote omdat de expressie moet worden geëvalueerd om de lijst te produceren
die wordt doorgegeven aan @code{sort}.)

@node Bestandenlijst
@subsection Een lijst van bestanden maken

De functie @code{recursieve-lengte-lijst-veel-bestanden} vereist een lijst
van bestanden als argument. Voor onze testvoorbeelden construeerden we
handmatig zo'n lijst, maar de Emacs brondirectory is te groot voor ons om
dat te doen. In plaats daarvan schrijven we een functie die dat werk voor
ons doet. In deze functie gebruiken we zowel een @code{while} loop en een
recursieve aanroep.

@findex directory-files
Voor oudere versies van GNU Emacs hoefden we zo'n functie niet te schrijven,
omdat zij alle @samp{.el} bestanden in één directory plaatsten. In plaats
daarvan konden we de functie @code{directory-files} gebruiken, die de namen
van de bestanden in een enkele directory vermeldt die aan een specifiek
patroon voldoen. 

Recente versies van Emacs echter plaatsen Emacs Lisp bestanden in
subdirectories van de top-level @file{lisp} directory. Deze herschikking
maakt de navigatie makkelijker. Alle mail gerelateerde bestanden
bijvoorbeeld staan in een @code{lisp} subdirectory met de naam
@file{mail}. Maar tegelijkertijd forceert deze schikking ons om een
bestandslisting functie te maken die afdaalt in de subdirectories.

@findex bestanden-in-onderliggende-directory
We kunnen deze functie met de naam
@code{bestanden-in-onderiggende-directory} maken met bekende functies zoals
@code{car}, @code{nthcdr} en @code{substring} samen met een bestaande
functie met de naam @code{directory-files-and-atributes}. Deze laatste
functie vermeldt niet alleen de bestandsnamen in een directory inclusief de
namen van de subdirectories, maar ook hun attributen.

Om ons doel opnieuw te formuleren: maak een functie die ons in staat stelt
@code{recursieve-lengte-lijst-veel-bestanden} te voeden met de bestandsnamen
als een lijst die er zo iut ziet (maar met meer elementen):

@smallexample
@group
("./lisp/macros.el"
 "./lisp/mail/rmail.el"
 "./lisp/hex-util.el")
@end group
@end smallexample

De functie @code{directory-files-and-atributes} geeft een lijst van lijsten
terug. Elk van deze lijsten in de hoofdlijst bestaat uit 13 elementen. Het
eerste element is een string die de bestandsnaam bevat---welke, in
GNU/Linux, een @dfn{dicectory file} kan zijn, met andere woorden een bestand
met de speciale attributen van een directory. Het tweede element van de
lijst is @code{t} voor een directory, een string voor een symbolische link
(de string is de naam waar naartoe gelinkt), or @code{nil}.

Bijvoorbeeld het eerste @samp{.el} bestand in de @file{lisp/} directory is
@file{abbrev.el}. Zijn naam is
@file{/usr/local/share/emacs/22.1.1/lisp/abbrev.el} en het is niet een
directory of een symbolische link.

@need 1000
Dit is hoe @code{directory-files-and-attributes} het bestand en zijn
atributen vermeldt:

@smallexample
@group
("abbrev.el"
nil
1
1000
100
@end group
@group
(20615 27034 579989 697000)
(17905 55681 0 0)
(20615 26327 734791 805000)@footnote{Wanneer @code{current-time-list} @code{nil} is,
zijn de drie timestamps respectievelijk @code{(1351051674579989697
. 1000000000)}, @code{(1173477761000000000 . 1000000000)} en
@code{(1351050967734791805 . 1000000000)}.}
13188
"-rw-r--r--"
@end group
@group
t
2971624
773)
@end group
@end smallexample

@need 1200
Anderzijds, @file{mail/} is een directory in de @file{lisp/} directory. Het
begin van de listing ziet er zo uit:

@smallexample
@group
("mail"
t
@dots{}
)
@end group
@end smallexample

(Zie de documentatie van @code{file-attributes} om meer te leren over de
verschillende atributen. Hou er rekening mee dat de functie
@code{file-attributes} de bestandsnaam niet vermeldt, zodat het eerste
element is het tweede element in @code{directory-files-and-atributes}.)

Wij willen dat onze nieuwe functie,
@code{bestanden-in-onderiggende-directory} de @samp{.el} bestanden vermeldt
in de directory die het verteld is te bekijken, en in elke daar
onderliggende directory.

Dit geeft ons een hint hoe de @code{bestanden-in-onderiggende-directory}
binnen een directory te construeren, de functie zou @samp{.el} bestandsnamen
aan een lijst moeten toevoegen. En wanneer de functie binnen een directory
op een subdirectory stuit, moet die de subdirectory ingaan en daar de acties
herhalen.

We moeten echter opmerken dat elke directory een naam die naar zichzelf
referereert bevat, @file{.} (``dot'') genaamd, en een naam die refereert
naar de bovenliggende directory, @file{..} (``dot dot'') genaamd. (In
@file{/}, de root-directory, refereert @file{..} aan zichzelf, omdat
@file{/} geen bovenliggende directory heeft.) We willen natuurlijk niet dat
onze functie @code{bestanden-in-onderiggende-directory} deze directories
ingaat, omdat die ons altijd, direct of indirect, naar de huidige directory
leiden.

Dus moet onze functie @code{bestanden-in-onderiggende-directory}
verschillende taken doen:

@itemize @bullet
@item
Controleer of het naar een bestandsnaam kijkt die eindigt in @samp{.el} en
zo ja, voeg thet aan de lijst toe.

@item
Controleer of het naar een bestandsnaam kijkt die de naam van een directory
is, en zo ja, 

@itemize @minus
@item
Controleer of het kijkt naar @file{.} of @file{..}, en zo ja, sla die over.

@item
Zo niet, ga dan in de directory en herhaal het proces.
@end itemize
@end itemize

Laten we een functiedefinitie schrijven die deze taken uitvoert. We
gebruiken een @code{while} loop om binnen de directory van de ene
bestandsnaam naar de ander te gaan en controleren wat moet worden gedaan. En
we gebruiken een recursieve aanroep om de acties in elke subdirectory te
herhalen. Het resursieve patroon is Accumuleren (@pxref{Accumuleren}), met
@code{append} als de combinerende functie.

@ignore
(directory-files "/usr/local/src/emacs/lisp/" t "\\.el$")
(shell-command "find /usr/local/src/emacs/lisp/ -name '*.el'")

(directory-files "/usr/local/share/emacs/22.1.1/lisp/" t "\\.el$")
(shell-command "find /usr/local/share/emacs/22.1.1/lisp/ -name '*.el'")
@end ignore

@c  /usr/local/share/emacs/22.1.1/lisp/

@need 800
Hier is de functie:

@smallexample
@group
(defun bestanden-in-onderiggende-directory (directory)
  "Vermeldt de .el files in DIRECTORY en onderliggende subdirectories."
  ;; Hoewel de functie niet interactief gebruikt wordt,
  ;; is het makkelijker te testen wanneer we het interactief maken.
  ;; De directory zal een naam hebben zoals
  ;;  "/usr/local/share/emacs/22.1.1/lisp/"
  (interactive "DDirectory naam: ")
@end group
@group
  (let (el-bestanden-lijst
        (huidige-directory-lijst
         (directory-files-and-attributes directory t)))
    ;; zoals we in de huidige directory zijn
    (while huidige-directory-lijst
@end group
@group
      (cond
       ;; check of de bestandsnaam eindigt met '.el'
       ;; en zo ja, voeg die toe aan de lijst.
       ((equal ".el" (substring (car (car huidige-directory-lijst)) -3))
        (setq el-bestanden-lijst
              (cons (car (car huidige-directory-lijst)) el-bestanden-lijst)))
@end group
@group
       ;; check of bestandsnaam die van een directory is
       ((eq t (car (cdr (car huidige-directory-lijst))))
        ;; beslis tussen skippen of afdalen
        (if
            (equal "."
                   (substring (car (car huidige-directory-lijst)) -1))
            ;; dan doe niets omdat de bestandnaam die is van
            ;;   huidige directory of parent, "." or ".."
            ()
@end group
@group
          ;; anders daal af in de directory en herhaalt het proces
          (setq el-bestanden-lijst
                (append
                 (bestanden-in-onderiggende-directory
                  (car (car huidige-directory-lijst)))
                 el-bestanden-lijst)))))
      ;; ga naar volgende bestandnaam in de lijst; dit verkort ook
      ;; de lijst zodat de while loop uiteindelijk aan zijn eind komt
      (setq huidige-directory-lijst (cdr huidige-directory-lijst)))
    ;; geef de bestandsnamen terug
    el-bestanden-lijst))
@end group
@end smallexample

@c (files-in-below-directory "/usr/local/src/emacs/lisp/")
@c (files-in-below-directory "/usr/local/share/emacs/22.1.1/lisp/")

De functie @code{bestanden-in-onderiggende-directory} vereist een argument,
de naam van een directory.

@need 1250
Dus, op mijn systeem,

@c (length (files-in-below-directory "/usr/local/src/emacs/lisp/"))

@c !!! 22.1.1 lisp sources location here
@smallexample
@group
(length
 (bestanden-in-onderiggende-directory "/usr/local/share/emacs/22.1.1/lisp/"))
@end group
@end smallexample

@noindent
vertelt me dat er in en onder mijn Lisp brondirectory 1031 @samp{.el}
bestanden zijn.

@code{bestanden-in-onderiggende-directory} geeft een lijst terug in
omgekeerde alfabetische volgorde. Een expressie om de lijst in alfabetische
volgorde te sorteren ziet er zo uit:

@smallexample
@group
(sort
 (bestanden-in-onderiggende-directory "/usr/local/share/emacs/22.1.1/lisp/")
 'string-lessp)
@end group
@end smallexample

@ignore
(defun test ()
  "Test how long it takes to find lengths of all sorted elisp defuns."
  (insert "\n" (current-time-string) "\n")
  (sit-for 0)
  (sort
   (recursive-lengths-list-many-files
    (files-in-below-directory "/usr/local/src/emacs/lisp/"))
   '<)
  (insert (current-time-string)))
@end ignore

@node Functiedefinities tellen
@subsection Functiedefinities tellen

Ons doel is een lijst te genereren die vertelt hoeveel functiedefinities
minder dan 10 woorden en symbolen bevatten, hoeveel tussen de 10 en 19
woorden en symbolen bevatten, hoeveel tussen de 20 en 29 woorden en
symbolen, enzovoorts.

Met een gesorteerde lijst met getallen is dit makkelijk. Tel hoeveel
elementen in de lijst kleiner dan 10 zijn, dan na voorbij de net getelde
getallen te gaan, tel hoeveel er kleiner dan 20 zijn, dan na voorbij de net
getelde getallen te gaan, hoeveel kleiner zijn dan 30, enzovoorts. Elk van
de getallen 10, 20, 30, 40 en dergelijke is een groter dan de hoogste van
die range. We kunnen de lijst met zulke getallen de
@code{hoogste-van-ranges} lijst noemen.

@need 1200
Als we dat willen kunnen we zo'n lijst automatisch genereren, maar het is
simpeler de lijst handmatig te schrijven. Hier is die:
@vindex hoogste-van-ranges

@smallexample
@group
(defvar hoogste-van-ranges
 '(10  20  30  40  50
   60  70  80  90 100
  110 120 130 140 150
  160 170 180 190 200
  210 220 230 240 250
  260 270 280 290 300)
 "Lijst met ranges for `defuns-hoogste-per-range'.")
@end group
@end smallexample

Om de ranges aan te passen, kunnen we deze lijst wijzigen.

Vervolgens moeten we een functie schrijven die een lijst maakt van de
getallen van de definities binnen een range. Deze functie moet
@code{gesorteerde-lengtes} en @code{hoogste-van-ranges} als argument
gebruiken.

De functie @code{defuns-per-range} moet twee dingen steeds opnieuw doen: het
moet het nummer van definities binnen een range tellen, gespecificeerd door
de huidge @code{hoogste-van-ranges} waarde en het moet naar de eerstvolgende
hogere waarde n de @code{hoogste-van-ranges} lijst opschuiven nadat het de
definities in de huidige range geteld heeft. Omdat deze acties repeterend
zijn, kunnen we een @code{while} loop voor de taak gebruiken. Een loop telt
het aantal definities in de range gespecificeerd door de huidge
hoogste-van-ranges waarde, en de andere loop selecteert elk van de
hoogste-van-ranges op hun beurt.

Verschillende entries van de @code{gesorteerde-lengtes} lijst worden geteld
voor elke range. Dit betekent dat de loop voor de @code{gesorteerde-lengtes}
lijst binnen de loop voor de @code{hoogste-van-ranges} lijst staat, zoals
een klein tandwiel in een groot tandwiel.

De binnenste loop telt het aantal definities binnen een range. Het is een
eenvoudige tellende loop van het type zoals we eerder
zagen. (@xref{Incrementele loop, , Een loop met een incrementele teller}.)
De waar-of-onwaar-test van de loop test of de waarde van de
@code{gesorteerde-lengtes} lijst kleiner is dan de huidige waarde van de
hoogste-van-ranges. Indien dat zo is, dan verhoogt de functie de teller en
test de volgende waarde van de @code{gesorteerde-lengtes} lijst.

@need 1250
De binnenste loop ziet er zo uit:

@smallexample
@group
(while @var{lengte-element-kleiner-dan-hoogste-van-range}
  (setq getal-in-range (1+ getal-in-range))
  (setq gesorteerde-lengtes (cdr gesorteerde-lengtes)))
@end group
@end smallexample

De buitenste loop moet starten met de laagste waarde in de
@code{hoogste-van-ranges} lijst en daarna per keer steeds op de opvolgende
hogere waarde gezet worden. Dit kan met een loop zoals deze:

@smallexample
@group
(while hoogste-van-ranges
  @var{body-van-loop}@dots{}
  (setq hoogste-van-ranges (cdr hoogste-van-ranges)))
@end group
@end smallexample

@need 1200
Samengevoegd zien de twee loops er zo uit:

@smallexample
@group
(while hoogste-van-ranges

  ;; @r{Tel het aantal elementen binnen de huidige range.}
  (while @var{lengte-element-kleiner-dan-hoogste-van-range}
    (setq getal-in-range (1+ getal-in-range))
    (setq gesorteerde-lengtes (cdr gesorteerde-lengtes)))

  ;; @r{Ga naar volgende range.}
  (setq hoogste-van-ranges (cdr hoogste-van-ranges)))
@end group
@end smallexample

Daarnaast moet Emacs in elk circuit van de buitenste loop het aantal
definities binnen die range (de waarde van @code{getal-in-range}) in een
lijst vastleggen. We kunnen @code{cons} voor dit doel
gebruiken. (@xref{cons, , @code{cons}}.)

De functie @code{cons} werkt prima, behalve dat de lijst die het maakt het
aantal definities voor de hoogste range aan het begin en het aantal
definities voor de laagste range aan het einde bevat. Dit komt omdat
@code{cons} nieuwe elementen aan het begin van de lijst vastmaakt en omdat
de twee loops hun werk door de lengtes-lijst van laag tot hoog doen, zal
@code{defuns-per-range-list} eindigen met het grootste getal aan het
begin. Maar wij willen onze grafiek tonen met eerst de kleinste waarden en
de grotere daarna. We kunnen dit doen met de functie @code{nreverse} die de
volgorde van een lijst omdraait.
@findex nreverse

@need 800
Bijvoorbeeld,

@smallexample
(nreverse '(1 2 3 4))
@end smallexample

@need 800
@noindent
produceert:

@smallexample
(4 3 2 1)
@end smallexample

Merk op dat de functie @code{nreverse} destructief is---dat wil zeggen, het
verandert de lijst waarop het wordt toegepast. Dit contrasteert met de
functies @code{car} en @code{cdr}, die niet-destructief zijn. In dit geval
willen we de originele @code{defuns-per-range-lijst} niet, dus het maakt
niet uit dat de lijst wordt vernietigd. (De functie @code{reverse} maakt een
omgedraaide kopie van een lijst, en laat de originele lijst intact.)
@findex reverse

@need 1250
Alles bij elkaar ziet de @code{defuns-per-range} er zo uit:

@smallexample
@group
(defun defuns-per-range (gesorteerde-lengtes hoogste-van-ranges)
  "GESORTEERDE-LENGTES defuns in elke HOOGSTE-VAN-RANGES range."
  (let ((hoogste-van-range (car hoogste-van-ranges))
        (getal-in-range 0)
        defuns-per-range-lijst)
@end group

@group
    ;; @r{Buitenste loop.}
    (while hoogste-van-ranges
@end group

@group
      ;; @r{Binnenste loop.}
      (while (and
              ;; @r{Getal nodig voor numerieke test.}
              (car gesorteerde-lengtes)
              (< (car gesorteerde-lengtes) hoogste-van-range))

@end group

@group
        ;; @r{Tel aantal definities in huidige range.}
        (setq getal-in-range (1+ getal-in-range))
        (setq gesorteerde-lengtes (cdr gesorteerde-lengtes)))

      ;; @r{Verlaat binnenste loop maar blijf in buitenste loop.}

@end group

@group
      (setq defuns-per-range-lijst
            (cons getal-in-range defuns-per-range-lijst))
      (setq getal-in-range 0)      ; @r{Reset telling op nul.}
@end group

@group
      ;; @r{Ga naar volgende range.}
      (setq hoogste-van-ranges (cdr hoogste-van-ranges))
      ;; @r{Specify next top of range value.}
      (setq hoogste-van-range (car hoogste-van-ranges)))
@end group

@group
    ;; @r{Verlaat buitenste loop en tel het aantal defuns groter dan}
    ;; @r{  de grootste top-of-range value.}
    (setq defuns-per-range-lijst
          (cons
           (length gesorteerde-lengtes)
           defuns-per-range-lijst))

@end group

@group
    ;; @r{Geef een lijst terug met het aantal definities in elke range,}
    ;; @r{  van klein naar groot.}
    (nreverse defuns-per-range-lijst)))
@end group
@end smallexample

@need 1200
@noindent
De functie is eenvoudig behalve een subtiele eigenschap. De
waar-of-onwaar-test van de binnenste loop ziet er zo uit:

@smallexample
@group
(and (car gesorteerde-lengtes)
     (< (car gesorteerde-lengtes) hogste-van-range))
@end group
@end smallexample

@need 800
@noindent
in plaats van dit:

@smallexample
(< (car gesorteerde-lengtes) hoogste-van-range)
@end smallexample

Het doel van deze test is vast te stellen of het eerste item in de
@code{gesorteerde-lengtes} lijst kleiner is dan de waarde van de hoogste van
de range.

De simpele versie van de tekst werkt prima tenzij de
@code{gesorteerde-lengtes} lijst een waarde @code{nil} heeft. In dat geval
geeft de @code{(car gesorteerde-lengtes)} expressie @code{nil} terug. De
functie @code{<} kan geen getal vergelijken met @code{nil}, wat een lege
lijst is, zodat Emacs een fout signaleert en de verdere uitvoering van de
functie stopt.

De @code{gesorteerde-lengtes} lijst wordt altijd @code{nil} wanneer de
teller het einde van de lijst bereikt. Dit betekent dat elke poging om de
functie @code{defuns-per-range} met de simpele versie te gebruiken zal
falen.

Wij lossen het probleem op met de @code{(car gesorteerde-lengtes)} expressie
in combinatie met de @code{and} expressie. De @code{(car
gesorteerde-lengtes)} expressie geeft een niet-@code{nil} waarde zolang de
lijst tenminste een getal bevat, maar geeft @code{nil} terug als de lijst
leeg is. De @code{and} expressie evalueert eerst de @code{(car
gesorteerde-lengtes)} expressie, and als die @code{nil} is, geeft die onwaar
terug @emph{zonder} de @code{<} expressie te evalueren. Maar wanneer de
@code{(car gesorteerde-lengtes)} expressie een non-@code{nil} waarde
teruggeeft, evalueert de @code{and} expressie de @code{<} expressie en geeft
die waarde terug als de waarde van de @code{and} expressie.

@c colon in printed section title causes problem in Info cross reference
Op deze manier voorkomen we een fout.

@iftex
@noindent
Voor informatie over @code{and}, zie @ref{kill-new functie, , De
@code{kill-new} functie}.)
@end iftex
@ifinfo
@noindent
(@xref{kill-new functie, , De @code{kill-new} functie}, voor informatie over
@code{and}.)
@end ifinfo

Hier is een korte test van de functie @code{defuns-per-range}. Evalueer de
expressie die een (verkorte) @code{hoogste-van-ranges} lijst bindt aan de
lijst van waardes, en evalueer dan de expressie om de
@code{gesorteerde-lengtes} lijst te binden, en evalueer daarna de functie
@code{defuns-per-range}.

@smallexample
@group
;; @r{(Kortere lijst dan we later gaan gebruiken.)}
(setq hoogste-van-ranges
 '(110 120 130 140 150
   160 170 180 190 200))

(setq gesorteerde-lengtes
      '(85 86 110 116 122 129 154 176 179 200 265 300 300))

(defuns-per-range gesorteerde-lengtes hoogste-van-ranges)
@end group
@end smallexample

@need 800
@noindent
De teruggeven lijst ziet er zo uit:

@smallexample
(2 2 2 0 0 1 0 2 0 0 4)
@end smallexample

@noindent
Er zijn inderdaad twee elementen van de @code{gesorteerde-lengtes} lijst
kleiner dan 110, twee elemten tussen 110 en 119, twee elementen tussen 120
en 129, enzovoorts. Er zijn vier elementen met een waarde van 200 of groter.

@c The next step is to turn this numbers' list into a graph.
@node Een grafiek voorbereiden
@chapter Een grafiek voorbereiden
@cindex Een grafiek voorbereiden
@cindex Grafiek prototype
@cindex Prototype grafiek
@cindex Body van grafiek

Ons doel is een grafiek te construeren die de getallen toont van de
functiedefinities van diverse lengtes in de Emacs lisp bronbestanden.

Als je in de praktijk een grafiek zou maken, zou je daarvoor waarschijnlijk
een programma zoals @code{gnuplot} gebruiken. (@code{gnuplot} is mooi
geïntegreerd en GNU Emacs.) In dit geval echter maken we er een helemaal
zelf en in het proces maken wij ons weer vertrouwd met sommige dingen die we
eerder geleerd hebben en meer leren.

In dit hoofdstuk schrijven we eerste een simpele functie om een grafiek te
tonen. Deze eerste definitie wordt een @dfn{prototype}, een snel geschreven
functie om het onbekende terrein van grafiek maken te verkennen. We
ontdekken draken of ontdekken dat ze een mythe zijn. Na het terrein verkend
te hebben voelen we ons meer zelfverzekerd en breiden de functie uit met
automatische labeling van de assen.

@menu
* Kolommen van een grafiek::  Kolommen van een grafiek
* graph-body-print::         Hoe de body van een grafiek af te drukken.
* recursive-graph-body-print::  recursive-graph-body-print
* Afgedrukte assen::         Afgedrukte assen
* Lijngrafiek oefening::     Lijngrafiek oefening
@end menu

@ifnottex
@node Kolommen van een grafiek
@unnumberedsec De kolommen van een grafiek tonen
@end ifnottex

Omdat Emacs gemaakt is om flexibel te zijn en met allerlei soorten terminals
te werken, waaronder alleen-tekst terminals, moet de grafiek gemaakt worden
met een typemachine-symbool. Een sterretje is goed genoeg. Wanneer we de
functie om de grafiek te tonen uitbreiden, kunnen we van de keuze van het
symbool een gebruikersoptie maken.

We kunnen deze functie @code{grafiek-body-tonen} noemen, het neemt de
@code{numbers-list} als enige argument. Op dit moment geven we nog geen
labels aan de grafiek, maar tonen alleen de body.

De functie @code{grafiek-body-tonen} voegt een verticale kolom van
sterretjes in voor elk element van de @code{getallen-lijst}. De hoogte van
elke lijn wordt bepaald door de waarde van dat element in de
@code{getallen-lijst}.

Kolommen invoegen is een reperterende actie wat betekent dat deze functie
met een @code{while} loop dan wel recursief geschreven kan worden.

Onze eerste uitdaging is om te ontdekken hoe een kolom van sterretjes te
tonen. Meestal tonen we in Emacs horizontaal karakters op het scherm, regel
voor regel, door te typen. We kunnen twee routes volgen: we schrijven onze
eigen kolom-invoeg-functie of ontdekken of er al een in Emacs bestaat.

Om te ontdekken of er al een in Emacs is, gebruiken we het commando @kbd{M-x
apropos}. Dit commando is vergelijkbaar met het commando @kbd{C-h a}
(@code{command-apropos}), behalve dat de laatste alleen functies vindt dat
commando's zijn. Het commando @kbd{M-x apropos} vermeldt alle symbolen die
een reguliere expressie matchen, inclusief functies die niet interactief
zijn.
@findex apropos

Waar we naar zoeken is een commando dat kolommen toont of invoegt. Zeer
waarschijnlijk bevat de naam van de functie het woord ``print'', het woord
``insert'' of het woord 11column''. Daarom kunnen we eenvoudigweg @kbd{M-x
apropos @key{RET} print\|insert\|column @key{RET}} typen en naar het
resultaat kijken. Op mijn systeem kostte dit commando ooit behoorlijk wat
tijd en produceerde een lijst met 79 functies en variabelen. Nu kost het
amper tijd en produceert een lijst met 211 functies en variabelen. Bij het
bekijken van de lijst is de enige functie die lijkt alsof die het werk kan
doen is @code{insert-rectangle}.

@need 1200
Inderdaad, dit is de functie die we willen, de documentatie zegt:

@smallexample
@group
insert-rectangle:
Insert text of RECTANGLE with upper left corner at point.
RECTANGLE's first line is inserted at point,
its second line is inserted at a point vertically under point, etc.
RECTANGLE should be a list of strings.
After this command, the mark is at the upper left corner
and point is at the lower right corner.
@end group
@end smallexample

We can run a quick test, to make sure it does what we expect of it.

Here is the result of placing the cursor after the @code{insert-rectangle}
expression and typing @kbd{C-u C-x C-e} (@code{eval-last-sexp}).  The
function inserts the strings @samp{"first"}, @samp{"second"}, and
@samp{"third"} at and below point.  Also the function returns @code{nil}.

@smallexample
@group
(insert-rectangle '("first" "second" "third"))first
                                              second
                                              thirdnil
@end group
@end smallexample

@noindent
Of course, we won't be inserting the text of the @code{insert-rectangle}
expression itself into the buffer in which we are making the graph, but will
call the function from our program.  We shall, however, have to make sure
that point is in the buffer at the place where the @code{insert-rectangle}
function will insert its column of strings.

If you are reading this in Info, you can see how this works by switching to
another buffer, such as the @file{*scratch*} buffer, placing point somewhere
in the buffer, typing @kbd{M-:}, typing the @code{insert-rectangle}
expression into the minibuffer at the prompt, and then typing @key{RET}.
This causes Emacs to evaluate the expression in the minibuffer, but to use
as the value of point the position of point in the @file{*scratch*} buffer.
(@kbd{M-:} is the key binding for @code{eval-expression}.  Also, @code{nil}
does not appear in the @file{*scratch*} buffer since the expression is
evaluated in the minibuffer.)

We find when we do this that point ends up at the end of the last inserted
line---that is to say, this function moves point as a side-effect.  If we
were to repeat the command, with point at this position, the next insertion
would be below and to the right of the previous insertion.  We don't want
this! If we are going to make a bar graph, the columns need to be beside
each other.

So we discover that each cycle of the column-inserting @code{while} loop
must reposition point to the place we want it, and that place will be at the
top, not the bottom, of the column.  Moreover, we remember that when we
print a graph, we do not expect all the columns to be the same height.  This
means that the top of each column may be at a different height from the
previous one.  We cannot simply reposition point to the same line each time,
but moved over to the right---or perhaps we can@dots{}

We are planning to make the columns of the bar graph out of asterisks.  The
number of asterisks in the column is the number specified by the current
element of the @code{numbers-list}.  We need to construct a list of
asterisks of the right length for each call to @code{insert-rectangle}.  If
this list consists solely of the requisite number of asterisks, then we will
have to position point the right number of lines above the base for the
graph to print correctly.  This could be difficult.

Alternatively, if we can figure out some way to pass @code{insert-rectangle}
a list of the same length each time, then we can place point on the same
line each time, but move it over one column to the right for each new
column.  If we do this, however, some of the entries in the list passed to
@code{insert-rectangle} must be blanks rather than asterisks.  For example,
if the maximum height of the graph is 5, but the height of the column is 3,
then @code{insert-rectangle} requires an argument that looks like this:

@smallexample
(" " " " "*" "*" "*")
@end smallexample

This last proposal is not so difficult, so long as we can determine the
column height.  There are two ways for us to specify the column height: we
can arbitrarily state what it will be, which would work fine for graphs of
that height; or we can search through the list of numbers and use the
maximum height of the list as the maximum height of the graph.  If the
latter operation were difficult, then the former procedure would be easiest,
but there is a function built into Emacs that determines the maximum of its
arguments.  We can use that function.  The function is called @code{max} and
it returns the largest of all its arguments, which must be numbers.  Thus,
for example,

@smallexample
(max  3 4 6 5 7 3)
@end smallexample

@noindent
returns 7.  (A corresponding function called @code{min} returns the smallest
of all its arguments.)
@findex max
@findex min

However, we cannot simply call @code{max} on the @code{numbers-list}; the
@code{max} function expects numbers as its argument, not a list of numbers.
Thus, the following expression,

@smallexample
(max  '(3 4 6 5 7 3))
@end smallexample

@need 800
@noindent
produces the following error message;

@smallexample
Wrong type of argument:  number-or-marker-p, (3 4 6 5 7 3)
@end smallexample

@findex apply
We need a function that passes a list of arguments to a function.  This
function is @code{apply}.  This function applies its first argument (a
function) to its remaining arguments, the last of which may be a list.

@need 1250
Bijvoorbeeld,

@smallexample
(apply 'max 3 4 7 3 '(4 8 5))
@end smallexample

@noindent
returns 8.

(Incidentally, I don't know how you would learn of this function without a
book such as this.  It is possible to discover other functions, like
@code{search-forward} or @code{insert-rectangle}, by guessing at a part of
their names and then using @code{apropos}.  Even though its base in metaphor
is clear---apply its first argument to the rest---I doubt a novice would
come up with that particular word when using @code{apropos} or other aid.
Of course, I could be wrong; after all, the function was first named by
someone who had to invent it.)

The second and subsequent arguments to @code{apply} are optional, so we can
use @code{apply} to call a function and pass the elements of a list to it,
like this, which also returns 8:

@smallexample
(apply 'max '(4 8 5))
@end smallexample

This latter way is how we will use @code{apply}.  The
@code{recursive-lengths-list-many-files} function returns a numbers' list to
which we can apply @code{max} (we could also apply @code{max} to the sorted
numbers' list; it does not matter whether the list is sorted or not.)

@need 800
Hence, the operation for finding the maximum height of the graph is this:

@smallexample
(setq max-graph-height (apply 'max numbers-list))
@end smallexample

Now we can return to the question of how to create a list of strings for a
column of the graph.  Told the maximum height of the graph and the number of
asterisks that should appear in the column, the function should return a
list of strings for the @code{insert-rectangle} command to insert.

Each column is made up of asterisks or blanks.  Since the function is passed
the value of the height of the column and the number of asterisks in the
column, the number of blanks can be found by subtracting the number of
asterisks from the height of the column.  Given the number of blanks and the
number of asterisks, two @code{while} loops can be used to construct the
list:

@smallexample
@group
;;; @r{First version.}
(defun column-of-graph (max-graph-height actual-height)
  "Return list of strings that is one column of a graph."
  (let ((insert-list nil)
        (number-of-top-blanks
         (- max-graph-height actual-height)))
@end group

@group
    ;; @r{Fill in asterisks.}
    (while (> actual-height 0)
      (setq insert-list (cons "*" insert-list))
      (setq actual-height (1- actual-height)))
@end group

@group
    ;; @r{Fill in blanks.}
    (while (> number-of-top-blanks 0)
      (setq insert-list (cons " " insert-list))
      (setq number-of-top-blanks
            (1- number-of-top-blanks)))
@end group

@group
    ;; @r{Return whole list.}
    insert-list))
@end group
@end smallexample

If you install this function and then evaluate the following expression you
will see that it returns the list as desired:

@smallexample
(column-of-graph 5 3)
@end smallexample

@need 800
@noindent
returns

@smallexample
(" " " " "*" "*" "*")
@end smallexample

As written, @code{column-of-graph} contains a major flaw: the symbols used
for the blank and for the marked entries in the column are hard-coded as a
space and asterisk.  This is fine for a prototype, but you, or another user,
may wish to use other symbols.  For example, in testing the graph function,
you may want to use a period in place of the space, to make sure the point
is being repositioned properly each time the @code{insert-rectangle}
function is called; or you might want to substitute a @samp{+} sign or other
symbol for the asterisk.  You might even want to make a graph-column that is
more than one display column wide.  The program should be more flexible.
The way to do that is to replace the blank and the asterisk with two
variables that we can call @code{graph-blank} and @code{graph-symbol} and
define those variables separately.

Also, the documentation is not well written.  These considerations lead us
to the second version of the function:

@smallexample
@group
(defvar graph-symbol "*"
  "String used as symbol in graph, usually an asterisk.")
@end group

@group
(defvar graph-blank " "
  "String used as blank in graph, usually a blank space.
graph-blank must be the same number of columns wide
as graph-symbol.")
@end group
@end smallexample

@noindent
(For an explanation of @code{defvar}, see @ref{defvar, , Initializing a
Variable with @code{defvar}}.)

@smallexample
@group
;;; @r{Second version.}
(defun column-of-graph (max-graph-height actual-height)
  "Return MAX-GRAPH-HEIGHT strings; ACTUAL-HEIGHT are graph-symbols.

@end group
@group
The graph-symbols are contiguous entries at the end
of the list.
The list will be inserted as one column of a graph.
The strings are either graph-blank or graph-symbol."
@end group

@group
  (let ((insert-list nil)
        (number-of-top-blanks
         (- max-graph-height actual-height)))
@end group

@group
    ;; @r{Fill in @code{graph-symbols}.}
    (while (> actual-height 0)
      (setq insert-list (cons graph-symbol insert-list))
      (setq actual-height (1- actual-height)))
@end group

@group
    ;; @r{Fill in @code{graph-blanks}.}
    (while (> number-of-top-blanks 0)
      (setq insert-list (cons graph-blank insert-list))
      (setq number-of-top-blanks
            (1- number-of-top-blanks)))

    ;; @r{Return whole list.}
    insert-list))
@end group
@end smallexample

If we wished, we could rewrite @code{column-of-graph} a third time to
provide optionally for a line graph as well as for a bar graph.  This would
not be hard to do.  One way to think of a line graph is that it is no more
than a bar graph in which the part of each bar that is below the top is
blank.  To construct a column for a line graph, the function first
constructs a list of blanks that is one shorter than the value, then it uses
@code{cons} to attach a graph symbol to the list; then it uses @code{cons}
again to attach the top blanks to the list.

It is easy to see how to write such a function, but since we don't need it,
we will not do it.  But the job could be done, and if it were done, it would
be done with @code{column-of-graph}.  Even more important, it is worth
noting that few changes would have to be made anywhere else.  The
enhancement, if we ever wish to make it, is simple.

Now, finally, we come to our first actual graph printing function.  This
prints the body of a graph, not the labels for the vertical and horizontal
axes, so we can call this @code{graph-body-print}.

@node graph-body-print
@section The @code{graph-body-print} Function
@findex graph-body-print

After our preparation in the preceding section, the @code{graph-body-print}
function is straightforward.  The function will print column after column of
asterisks and blanks, using the elements of a numbers' list to specify the
number of asterisks in each column.  This is a repetitive act, which means
we can use a decrementing @code{while} loop or recursive function for the
job.  In this section, we will write the definition using a @code{while}
loop.

The @code{column-of-graph} function requires the height of the graph as an
argument, so we should determine and record that as a local variable.

This leads us to the following template for the @code{while} loop version of
this function:

@smallexample
@group
(defun graph-body-print (numbers-list)
  "@var{documentation}@dots{}"
  (let ((height  @dots{}
         @dots{}))
@end group

@group
    (while numbers-list
      @var{insert-columns-and-reposition-point}
      (setq numbers-list (cdr numbers-list)))))
@end group
@end smallexample

@noindent
We need to fill in the slots of the template.

Clearly, we can use the @code{(apply 'max numbers-list)} expression to
determine the height of the graph.

The @code{while} loop will cycle through the @code{numbers-list} one element
at a time.  As it is shortened by the @code{(setq numbers-list (cdr
numbers-list))} expression, the @sc{car} of each instance of the list is the
value of the argument for @code{column-of-graph}.

At each cycle of the @code{while} loop, the @code{insert-rectangle} function
inserts the list returned by @code{column-of-graph}.  Since the
@code{insert-rectangle} function moves point to the lower right of the
inserted rectangle, we need to save the location of point at the time the
rectangle is inserted, move back to that position after the rectangle is
inserted, and then move horizontally to the next place from which
@code{insert-rectangle} is called.

If the inserted columns are one character wide, as they will be if single
blanks and asterisks are used, the repositioning command is simply
@code{(forward-char 1)}; however, the width of a column may be greater than
one.  This means that the repositioning command should be written
@code{(forward-char symbol-width)}.  The @code{symbol-width} itself is the
length of a @code{graph-blank} and can be found using the expression
@code{(length graph-blank)}.  The best place to bind the @code{symbol-width}
variable to the value of the width of graph column is in the varlist of the
@code{let} expression.

@need 1250
These considerations lead to the following function definition:

@smallexample
@group
(defun graph-body-print (numbers-list)
  "Print a bar graph of the NUMBERS-LIST.
The numbers-list consists of the Y-axis values."

  (let ((height (apply 'max numbers-list))
        (symbol-width (length graph-blank))
        from-position)
@end group

@group
    (while numbers-list
      (setq from-position (point))
      (insert-rectangle
       (column-of-graph height (car numbers-list)))
      (goto-char from-position)
      (forward-char symbol-width)
@end group
@group
      ;; @r{Draw graph column by column.}
      (sit-for 0)
      (setq numbers-list (cdr numbers-list)))
@end group
@group
    ;; @r{Place point for X axis labels.}
    (forward-line height)
    (insert "\n")
))
@end group
@end smallexample

@noindent
The one unexpected expression in this function is the @w{@code{(sit-for 0)}}
expression in the @code{while} loop.  This expression makes the graph
printing operation more interesting to watch than it would be otherwise.
The expression causes Emacs to @dfn{sit} or do nothing for a zero length of
time and then redraw the screen.  Placed here, it causes Emacs to redraw the
screen column by column.  Without it, Emacs would not redraw the screen
until the function exits.

We can test @code{graph-body-print} with a short list of numbers.

@enumerate
@item
Install @code{graph-symbol}, @code{graph-blank}, @code{column-of-graph},
which are in
@iftex
@ref{Readying a Graph, , Readying a Graph},
@end iftex
@ifnottex
@ref{Columns of a graph},
@end ifnottex
and @code{graph-body-print}.

@need 800
@item
Copy the following expression:

@smallexample
(graph-body-print '(1 2 3 4 6 4 3 5 7 6 5 2 3))
@end smallexample

@item
Switch to the @file{*scratch*} buffer and place the cursor where you want
the graph to start.

@item
Type @kbd{M-:} (@code{eval-expression}).

@item
Yank the @code{graph-body-print} expression into the minibuffer with
@kbd{C-y} (@code{yank)}.

@item
Press @key{RET} to evaluate the @code{graph-body-print} expression.
@end enumerate

@need 800
Emacs will print a graph like this:

@smallexample
@group
                    *
                *   **
                *  ****
               *** ****
              ********* *
             ************
            *************
@end group
@end smallexample

@node recursive-graph-body-print
@section The @code{recursive-graph-body-print} Function
@findex recursive-graph-body-print

The @code{graph-body-print} function may also be written recursively.  The
recursive solution is divided into two parts: an outside wrapper that uses a
@code{let} expression to determine the values of several variables that need
only be found once, such as the maximum height of the graph, and an inside
function that is called recursively to print the graph.

@need 1250
The wrapper is uncomplicated:

@smallexample
@group
(defun recursive-graph-body-print (numbers-list)
  "Print a bar graph of the NUMBERS-LIST.
The numbers-list consists of the Y-axis values."
  (let ((height (apply 'max numbers-list))
        (symbol-width (length graph-blank))
        from-position)
    (recursive-graph-body-print-internal
     numbers-list
     height
     symbol-width)))
@end group
@end smallexample

The recursive function is a little more difficult.  It has four parts: the
do-again-test, the printing code, the recursive call, and the
next-step-expression.  The do-again-test is a @code{when} expression that
determines whether the @code{numbers-list} contains any remaining elements;
if it does, the function prints one column of the graph using the printing
code and calls itself again.  The function calls itself again according to
the value produced by the next-step-expression which causes the call to act
on a shorter version of the @code{numbers-list}.

@smallexample
@group
(defun recursive-graph-body-print-internal
  (numbers-list height symbol-width)
  "Print a bar graph.
Used within recursive-graph-body-print function."
@end group

@group
  (when numbers-list
        (setq from-position (point))
        (insert-rectangle
         (column-of-graph height (car numbers-list)))
@end group
@group
        (goto-char from-position)
        (forward-char symbol-width)
        (sit-for 0)     ; @r{Draw graph column by column.}
        (recursive-graph-body-print-internal
         (cdr numbers-list) height symbol-width)))
@end group
@end smallexample

@need 1250
After installation, this expression can be tested; here is a sample:

@smallexample
(recursive-graph-body-print '(3 2 5 6 7 5 3 4 6 4 3 2 1))
@end smallexample

@need 800
Here is what @code{recursive-graph-body-print} produces:

@smallexample
@group
                *
               **   *
              ****  *
              **** ***
            * *********
            ************
            *************
@end group
@end smallexample

Either of these two functions, @code{graph-body-print} or
@code{recursive-graph-body-print}, create the body of a graph.

@node Afgedrukte assen
@section Need for Printed Axes

A graph needs printed axes, so you can orient yourself.  For a do-once
project, it may be reasonable to draw the axes by hand using Emacs's Picture
mode; but a graph drawing function may be used more than once.

For this reason, I have written enhancements to the basic
@code{print-graph-body} function that automatically print labels for the
horizontal and vertical axes.  Since the label printing functions do not
contain much new material, I have placed their description in an appendix.
@xref{Full Graph, , A Graph with Labeled Axes}.

@node Lijngrafiek oefening
@section Oefening

Write a line graph version of the graph printing functions.

@node Initialisatie van Emacs
@chapter Jouw @file{.emacs} bestand
@cindex @file{.emacs} file
@cindex Customizing your @file{.emacs} file
@cindex Initialization file

``You don't have to like Emacs to like it''---this seemingly paradoxical
statement is the secret of GNU Emacs.  The plain, out-of-the-box Emacs is a
generic tool.  Most people who use it customize it to suit themselves.

GNU Emacs is mostly written in Emacs Lisp; this means that by writing
expressions in Emacs Lisp you can change or extend Emacs.

@menu
* Default configuratie::     Default configuratie
* Site-wide init::           Je kunt systeem-brede init bestanden schrijven.
* defcustom::                Emacs schrijft de code voor je.
* Een init bestand beginnen::  Hoe een @file{.emacs} init bestand te 
                                 schrijven.
* Tekst en auto-fill::       Automatisch regels afbreken.
* Mail aliasen::             Gebruik afkortingen voor e-mailadressen.
* Indent Tabs Mode::         Gebruik geen tabs met @TeX{}
* Key bindings::             Enkele persoonlijke key bindings maken.
* Keymaps::                  Meer over key binding.
* Bestanden laden::          Automatisch bestanden laden (en dus evalueren).
* Autoload::                 Functies beschikbaar maken.
* Eenvoudige uitbreiding::   Definieer een functie, bind het aan een toets.
* X11 kleuren::              Kleuren in X.
* Diverse::                  Diverse
* Mode line::                Hoe je mode line aan te passen
@end menu

@ifnottex
@node Default configuratie
@unnumberedsec Emacs's Default Configuration
@end ifnottex

There are those who appreciate Emacs's default configuration.  After all,
Emacs starts you in C mode when you edit a C file, starts you in Fortran
mode when you edit a Fortran file, and starts you in Fundamental mode when
you edit an unadorned file.  This all makes sense, if you do not know who is
going to use Emacs.  Who knows what a person hopes to do with an unadorned
file? Fundamental mode is the right default for such a file, just as C mode
is the right default for editing C code.  (Enough programming languages have
syntaxes that enable them to share or nearly share features, so C mode is
now provided by CC mode, the C Collection.)

But when you do know who is going to use Emacs---you, yourself---then it
makes sense to customize Emacs.

For example, I seldom want Fundamental mode when I edit an otherwise
undistinguished file; I want Text mode.  This is why I customize Emacs: so
it suits me.

You can customize and extend Emacs by writing or adapting a @file{~/.emacs}
file.  This is your personal initialization file; its contents, written in
Emacs Lisp, tell Emacs what to do.@footnote{You may also add @file{.el} to
@file{~/.emacs} and call it a @file{~/.emacs.el} file.  In the past, you
were forbidden to type the extra keystrokes that the name @file{~/.emacs.el}
requires, but now you may.  The new format is consistent with the Emacs Lisp
file naming conventions; the old format saves typing.}

A @file{~/.emacs} file contains Emacs Lisp code.  You can write this code
yourself; or you can use Emacs's @code{customize} feature to write the code
for you.  You can combine your own expressions and auto-written Customize
expressions in your @file{.emacs} file.

(I myself prefer to write my own expressions, except for those, particularly
fonts, that I find easier to manipulate using the @code{customize} command.
I combine the two methods.)

Most of this chapter is about writing expressions yourself.  It describes a
simple @file{.emacs} file; for more information, see @ref{Init File, , The
Init File, emacs, The GNU Emacs Manual}, and @ref{Init File, , The Init
File, elisp, The GNU Emacs Lisp Reference Manual}.

@node Site-wide init
@section Site-wide Initialization Files

@cindex @file{default.el} init file
@cindex @file{site-init.el} init file
@cindex @file{site-load.el} init file
In addition to your personal initialization file, Emacs automatically loads
various site-wide initialization files, if they exist.  These have the same
form as your @file{.emacs} file, but are loaded by everyone.

Two site-wide initialization files, @file{site-load.el} and
@file{site-init.el}, are loaded into Emacs and then dumped if a dumped
version of Emacs is created, as is most common.  (Dumped copies of Emacs
load more quickly.  However, once a file is loaded and dumped, a change to
it does not lead to a change in Emacs unless you load it yourself or re-dump
Emacs.  @xref{Building Emacs, , Building Emacs, elisp, The GNU Emacs Lisp
Reference Manual}, and the @file{INSTALL} file.)

Three other site-wide initialization files are loaded automatically each
time you start Emacs, if they exist.  These are @file{site-start.el}, which
is loaded @emph{before} your @file{.emacs} file, and @file{default.el}, and
the terminal type file, which are both loaded @emph{after} your
@file{.emacs} file.

Settings and definitions in your @file{.emacs} file will overwrite
conflicting settings and definitions in a @file{site-start.el} file, if it
exists; but the settings and definitions in a @file{default.el} or terminal
type file will overwrite those in your @file{.emacs} file.  (You can prevent
interference from a terminal type file by setting @code{term-file-prefix} to
@code{nil}.  @xref{Simple Extension, , A Simple Extension}.)

@c Rewritten to avoid overfull hbox.
The @file{INSTALL} file that comes in the distribution contains descriptions
of the @file{site-init.el} and @file{site-load.el} files.

The @file{loadup.el}, @file{startup.el}, and @file{loaddefs.el} files
control loading.  These files are in the @file{lisp} directory of the Emacs
distribution and are worth perusing.

The @file{loaddefs.el} file contains a good many suggestions as to what to
put into your own @file{.emacs} file, or into a site-wide initialization
file.

@node defcustom
@section Variabelen specificeren met @code{defcustom}
@findex defcustom

You can specify variables using @code{defcustom} so that you and others can
then use Emacs's @code{customize} feature to set their values.  (You cannot
use @code{customize} to write function definitions; but you can write
@code{defuns} in your @file{.emacs} file.  Indeed, you can write any Lisp
expression in your @file{.emacs} file.)

The @code{customize} feature depends on the @code{defcustom} macro.
Although you can use @code{defvar} or @code{setq} for variables that users
set, the @code{defcustom} macro is designed for the job.

You can use your knowledge of @code{defvar} for writing the first three
arguments for @code{defcustom}.  The first argument to @code{defcustom} is
the name of the variable.  The second argument is the variable's initial
value, if any; and this value is set only if the value has not already been
set.  The third argument is the documentation.

The fourth and subsequent arguments to @code{defcustom} specify types and
options; these are not featured in @code{defvar}.  (These arguments are
optional.)

Each of these arguments consists of a keyword followed by a value.  Each
keyword starts with the colon character @samp{:}.

@need 1250
For example, the customizable user option variable @code{text-mode-hook}
looks like this:

@smallexample
@group
(defcustom text-mode-hook nil
  "Normal hook run when entering Text mode and many related modes."
  :type 'hook
  :options '(turn-on-auto-fill flyspell-mode)
  :group 'wp)
@end group
@end smallexample

@noindent
The name of the variable is @code{text-mode-hook}; it has no default value;
and its documentation string tells you what it does.

The @code{:type} keyword tells Emacs the kind of data to which
@code{text-mode-hook} should be set and how to display the value in a
Customization buffer.

The @code{:options} keyword specifies a suggested list of values for the
variable.  Usually, @code{:options} applies to a hook.  The list is only a
suggestion; it is not exclusive; a person who sets the variable may set it
to other values; the list shown following the @code{:options} keyword is
intended to offer convenient choices to a user.

Finally, the @code{:group} keyword tells the Emacs Customization command in
which group the variable is located.  This tells where to find it.

The @code{defcustom} macro recognizes more than a dozen keywords.  For more
information, see @ref{Customization, , Writing Customization Definitions,
elisp, The GNU Emacs Lisp Reference Manual}.

Consider @code{text-mode-hook} as an example.

There are two ways to customize this variable.  You can use the
customization command or write the appropriate expressions yourself.

@need 800
Using the customization command, you can type:

@smallexample
M-x customize
@end smallexample

@noindent
and find that the group for editing files of text is called ``Text''.  Enter
that group.  Text Mode Hook is the first member.  You can click on its
various options, such as @code{turn-on-auto-fill}, to set the values.  After
you click on the button to

@smallexample
Save for Future Sessions
@end smallexample

@noindent
Emacs will write an expression into your @file{.emacs} file.  It will look
like this:

@smallexample
@group
(custom-set-variables
  ;; custom-set-variables was added by Custom.
  ;; If you edit it by hand, you could mess it up, so be careful.
  ;; Your init file should contain only one such instance.
  ;; If there is more than one, they won't work right.
 '(text-mode-hook '(turn-on-auto-fill text-mode-hook-identify)))
@end group
@end smallexample

@noindent
(The @code{text-mode-hook-identify} function tells
@code{toggle-text-mode-auto-fill} which buffers are in Text mode.  It comes
on automatically.)

The @code{custom-set-variables} function works somewhat differently than a
@code{setq}.  While I have never learned the differences, I modify the
@code{custom-set-variables} expressions in my @file{.emacs} file by hand: I
make the changes in what appears to me to be a reasonable manner and have
not had any problems.  Others prefer to use the Customization command and
let Emacs do the work for them.

Another @code{custom-set-@dots{}} function is @code{custom-set-faces}.  This
function sets the various font faces.  Over time, I have set a considerable
number of faces.  Some of the time, I re-set them using @code{customize};
other times, I simply edit the @code{custom-set-faces} expression in my
@file{.emacs} file itself.

The second way to customize your @code{text-mode-hook} is to set it yourself
in your @file{.emacs} file using code that has nothing to do with the
@code{custom-set-@dots{}} functions.

@need 800
When you do this, and later use @code{customize}, you will see a message
that says

@smallexample
CHANGED outside Customize; operating on it here may be unreliable.
@end smallexample

@need 800
This message is only a warning.  If you click on the button to

@smallexample
Save for Future Sessions
@end smallexample

@noindent
Emacs will write a @code{custom-set-@dots{}} expression near the end of your
@file{.emacs} file that will be evaluated after your hand-written
expression.  It will, therefore, overrule your hand-written expression.  No
harm will be done.  When you do this, however, be careful to remember which
expression is active; if you forget, you may confuse yourself.

So long as you remember where the values are set, you will have no trouble.
In any event, the values are always set in your initialization file, which
is usually called @file{.emacs}.

I myself use @code{customize} for hardly anything.  Mostly, I write
expressions myself.

@findex defsubst
@findex defconst
Incidentally, to be more complete concerning defines: @code{defsubst}
defines an inline function.  The syntax is just like that of @code{defun}.
@code{defconst} defines a symbol as a constant.  The intent is that neither
programs nor users should ever change a value set by @code{defconst}.  (You
can change it; the value set is a variable; but please do not.)

@node Een init bestand beginnen
@section Starten met een @file{.emacs} bestand
@cindex @file{.emacs} file, beginning of

When you start Emacs, it loads your @file{.emacs} file unless you tell it
not to by specifying @samp{-q} on the command line.  (The @code{emacs -q}
command gives you a plain, out-of-the-box Emacs.)

A @file{.emacs} file contains Lisp expressions.  Often, these are no more
than expressions to set values; sometimes they are function definitions.

@xref{Init File, , The Init File @file{~/.emacs}, emacs, The GNU Emacs
Manual}, for a short description of initialization files.

This chapter goes over some of the same ground, but is a walk among extracts
from a complete, long-used @file{.emacs} file---my own.

The first part of the file consists of comments: reminders to myself.  By
now, of course, I remember these things, but when I started, I did not.

@need 1200
@smallexample
@group
;;;; Bob's .emacs file
; Robert J. Chassell
; 26 September 1985
@end group
@end smallexample

@noindent
Look at that date! I started this file a long time ago.  I have been adding
to it ever since.

@smallexample
@group
; Each section in this file is introduced by a
; line beginning with four semicolons; and each
; entry is introduced by a line beginning with
; three semicolons.
@end group
@end smallexample

@noindent
This describes the usual conventions for comments in Emacs Lisp.  Everything
on a line that follows a semicolon is a comment.  Two, three, and four
semicolons are used as subsection and section markers.  (@xref{Comments, ,,
elisp, The GNU Emacs Lisp Reference Manual}, for more about comments.)

@smallexample
@group
;;;; The Help Key
; Control-h is the help key;
; after typing control-h, type a letter to
; indicate the subject about which you want help.
; For an explanation of the help facility,
; type control-h two times in a row.
@end group
@end smallexample

@noindent
Just remember: type @kbd{C-h} two times for help.

@smallexample
@group
; To find out about any mode, type control-h m
; while in that mode.  For example, to find out
; about mail mode, enter mail mode and then type
; control-h m.
@end group
@end smallexample

@noindent
``Mode help'', as I call this, is very helpful.  Usually, it tells you all
you need to know.

Of course, you don't need to include comments like these in your
@file{.emacs} file.  I included them in mine because I kept forgetting about
Mode help or the conventions for comments---but I was able to remember to
look here to remind myself.

@node Tekst en auto-fill
@section Text and Auto Fill Mode

Now we come to the part that turns on Text mode and Auto Fill mode@footnote{
This section suggests settings that are more suitable for writers.  For
programmers, the default mode will be set to the corresponding prog-mode
automatically based on the type of the file.  And it's perfectly fine if you
want to keep the fundamental mode as the default mode.  }.

@smallexample
@group
;;; Text mode and Auto Fill mode
;; The next two lines put Emacs into Text mode
;; and Auto Fill mode, and are for writers who
;; want to start writing prose rather than code.
(setq-default major-mode 'text-mode)
(add-hook 'text-mode-hook 'turn-on-auto-fill)
@end group
@end smallexample

Here is the first part of this @file{.emacs} file that does something
besides remind a forgetful human!

The first of the two lines in parentheses tells Emacs to turn on Text mode
when you find a file, @emph{unless} that file should go into some other
mode, such as C mode.

@cindex Per-buffer, local variables list
@cindex Local variables list, per-buffer,
@cindex Automatic mode selection
@cindex Mode selection, automatic
When Emacs reads a file, it looks at the extension to the file name, if
any.  (The extension is the part that comes after a @samp{.}.)  If the file
ends with a @samp{.c} or @samp{.h} extension then Emacs turns on C mode.
Also, Emacs looks at first nonblank line of the file; if the line says
@w{@samp{-*- C -*-}}, Emacs turns on C mode.  Emacs possesses a list of
extensions and specifications that it uses automatically.  In addition,
Emacs looks near the last page for a per-buffer, local variables list, if
any.

@ifinfo
@xref{Choosing Modes, , How Major Modes are Chosen, emacs, The GNU Emacs
Manual}.

@xref{File Variables, , Local Variables in Files, emacs, The GNU Emacs
Manual}.
@end ifinfo
@iftex
See sections ``How Major Modes are Chosen'' and ``Local Variables in Files''
in @cite{The GNU Emacs Manual}.
@end iftex

Now, back to the @file{.emacs} file.

@need 800
Here is the line again; how does it work?

@cindex Text Mode turned on
@smallexample
(setq-default major-mode 'text-mode)
@end smallexample

@noindent
This line is a short, but complete Emacs Lisp expression.

We are already familiar with @code{setq}.  We use a similar macro
@code{setq-default} to set the following variable,
@code{major-mode}@footnote{ We use @code{setq-default} here because
@code{text-mode} is buffer-local.  If we use @code{setq}, it will only apply
to the current buffer, whereas using @code{setq-default} will also apply to
newly created buffers.  This is not recommended for programmers.  }, to the
subsequent value, which is @code{text-mode}.  The single-quote before
@code{text-mode} tells Emacs to deal directly with the @code{text-mode}
symbol, not with whatever it might stand for.  @xref{setq, , Setting the
Value of a Variable}, for a reminder of how @code{setq} works.  The main
point is that there is no difference between the procedure you use to set a
value in your @file{.emacs} file and the procedure you use anywhere else in
Emacs.

@need 800
Here is the next line:

@cindex Auto Fill mode turned on
@findex add-hook
@smallexample
(add-hook 'text-mode-hook 'turn-on-auto-fill)
@end smallexample

@noindent
In this line, the @code{add-hook} command adds @code{turn-on-auto-fill} to
the variable.

@code{turn-on-auto-fill} is the name of a program, that, you guessed it!,
turns on Auto Fill mode.

Every time Emacs turns on Text mode, Emacs runs the commands hooked onto
Text mode.  So every time Emacs turns on Text mode, Emacs also turns on Auto
Fill mode.

In brief, the first line causes Emacs to enter Text mode when you edit a
file, unless the file name extension, a first non-blank line, or local
variables to tell Emacs otherwise.

Text mode among other actions, sets the syntax table to work conveniently
for writers.  In Text mode, Emacs considers an apostrophe as part of a word
like a letter; but Emacs does not consider a period or a space as part of a
word.  Thus, @kbd{M-f} moves you over @samp{it's}.  On the other hand, in C
mode, @kbd{M-f} stops just after the @samp{t} of @samp{it's}.

The second line causes Emacs to turn on Auto Fill mode when it turns on Text
mode.  In Auto Fill mode, Emacs automatically breaks a line that is too wide
and brings the excessively wide part of the line down to the next line.
Emacs breaks lines between words, not within them.

When Auto Fill mode is turned off, lines continue to the right as you type
them.  Depending on how you set the value of @code{truncate-lines}, the
words you type either disappear off the right side of the screen, or else
are shown, in a rather ugly and unreadable manner, as a continuation line on
the screen.

@need 1250
In addition, in this part of my @file{.emacs} file, I tell the Emacs fill
commands to insert two spaces after a colon:

@smallexample
(setq colon-double-space t)
@end smallexample

@node Mail aliasen
@section Mail aliasen

Here is a @code{setq} that turns on mail aliases, along with more reminders.

@smallexample
@group
;;; Message mode
; To enter message mode, type 'C-x m'
; To enter RMAIL (for reading mail),
; type 'M-x rmail'
(setq mail-aliases t)
@end group
@end smallexample

@cindex Mail aliases
@noindent
This @code{setq} sets the value of the variable @code{mail-aliases} to
@code{t}.  Since @code{t} means true, the line says, in effect, ``Yes, use
mail aliases.''

Mail aliases are convenient short names for long email addresses or for
lists of email addresses.  The file where you keep your aliases is
@file{~/.mailrc}.  You write an alias like this:

@smallexample
alias geo george@@foobar.wiz.edu
@end smallexample

@noindent
When you write a message to George, address it to @samp{geo}; the mailer
will automatically expand @samp{geo} to the full address.

@node Indent Tabs Mode
@section Indent Tabs Mode
@cindex Tabs, preventing
@findex indent-tabs-mode

By default, Emacs inserts tabs in place of multiple spaces when it formats a
region.  (For example, you might indent many lines of text all at once with
the @code{indent-region} command.)  Tabs look fine on a terminal or with
ordinary printing, but they produce badly indented output when you use
@TeX{} or Texinfo since @TeX{} ignores tabs.

@need 1250
The following turns off Indent Tabs mode:

@smallexample
@group
;;; Prevent Extraneous Tabs
(setq-default indent-tabs-mode nil)
@end group
@end smallexample

Note that this line uses @code{setq-default} rather than the @code{setq}
that we have seen before; @code{setq-default} sets values only in buffers
that do not have their own local values for the variable.

@ifinfo
@xref{Just Spaces, , Tabs vs.@: Spaces, emacs, The GNU Emacs Manual}.

@xref{File Variables, , Local Variables in Files, emacs, The GNU Emacs
Manual}.
@end ifinfo
@iftex
See sections ``Tabs vs.@: Spaces'' and ``Local Variables in Files'' in
@cite{The GNU Emacs Manual}.
@end iftex

@need 1700
@node Key bindings
@section Some Key Bindings

Now for some personal key bindings:

@smallexample
@group
;;; Compare windows
(keymap-global-set "C-c w" 'compare-windows)
@end group
@end smallexample

@findex compare-windows
@code{compare-windows} is a nifty command that compares the text in your
current window with text in the next window.  It makes the comparison by
starting at point in each window, moving over text in each window as far as
they match.  I use this command all the time.

This also shows how to set a key globally, for all modes.

@cindex Setting a key globally
@cindex Keymap global set
@cindex Key setting globally
@findex keymap-global-set
The key setting command is @code{keymap-global-set}.  It is followed by the
key binding.  In a @file{.emacs} file, the keybinding is written as shown:
@code{C-c} stands for Control-C, which means to press the control key and
the @kbd{c} key at the same time.  The @code{w} means to press the @kbd{w}
key.  The key binding is surrounded by double quotation marks.  (If you were
binding a @key{META} key, rather than a @key{CTRL} key, you would write
@w{@code{M-c}} in your @file{.emacs} file.  @xref{Init Rebinding, ,
Rebinding Keys in Your Init File, emacs, The GNU Emacs Manual}, for
details.)

The command invoked by the keys is @code{compare-windows}.  Note that
@code{compare-windows} is preceded by a single-quote; otherwise, Emacs would
first try to evaluate the symbol to determine its value.

These three things, the double quotation marks, the backslash before the
@samp{C}, and the single-quote are necessary parts of key binding that I
tend to forget.  Fortunately, I have come to remember that I should look at
my existing @file{.emacs} file, and adapt what is there.

As for the key binding itself: @kbd{C-c w}.  This combines the prefix key,
@kbd{C-c}, with a single character, in this case, @kbd{w}.  This set of
keys, @kbd{C-c} followed by a single character, is strictly reserved for
individuals' own use.  (I call these @dfn{own} keys, since these are for my
own use.)  You should always be able to create such a key binding for your
own use without stomping on someone else's key binding.  If you ever write
an extension to Emacs, please avoid taking any of these keys for public
use.  Create a key like @kbd{C-c C-w} instead.  Otherwise, we will run out
of own keys.

@need 1250
Here is another key binding, with a comment:

@smallexample
@group
;;; Key binding for 'occur'
; I use occur a lot, so let's bind it to a key:
(keymap-global-set "C-c o" 'occur)
@end group
@end smallexample

@findex occur
The @code{occur} command shows all the lines in the current buffer that
contain a match for a regular expression.  When the region is active,
@code{occur} restricts matches to such region.  Otherwise it uses the entire
buffer.  Matching lines are shown in a buffer called @file{*Occur*}.  That
buffer serves as a menu to jump to occurrences.

@findex keymap-global-unset
@cindex Unbinding key
@cindex Key unbinding
@need 1250
Here is how to unbind a key, so it does not work:

@smallexample
@group
;;; Unbind 'C-x f'
(keymap-global-unset "C-x f")
@end group
@end smallexample

There is a reason for this unbinding: I found I inadvertently typed
@w{@kbd{C-x f}} when I meant to type @kbd{C-x C-f}.  Rather than find a
file, as I intended, I accidentally set the width for filled text, almost
always to a width I did not want.  Since I hardly ever reset my default
width, I simply unbound the key.

@findex list-buffers@r{, rebound}
@findex buffer-menu@r{, bound to key}
@need 1250
The following rebinds an existing key:

@smallexample
@group
;;; Rebind 'C-x C-b' for 'buffer-menu'
(keymap-global-set "C-x C-b" 'buffer-menu)
@end group
@end smallexample

By default, @kbd{C-x C-b} runs the @code{list-buffers} command.  This
command lists your buffers in @emph{another} window.  Since I almost always
want to do something in that window, I prefer the @code{buffer-menu}
command, which not only lists the buffers, but moves point into that window.

@subsection Legacy Global Key Binding Commands

@findex global-set-key
@cindex Global set key
Historically, keys are bound globally using a lower-level function,
@code{global-set-key}, which is now considered legacy.  While you are
encouraged to use @code{keymap-global-set}, you likely would encounter
@code{global-set-key} in various places.  The first example in this section
can be rewritten using @code{global-set-key} as:

@smallexample
@group
(global-set-key "\C-cw" 'compare-windows)
@end group
@end smallexample

It is very similar to @code{keymap-global-set}, with the keybinding
following a slightly different format.  Control-C is represented by
@code{\C-c}, instead of @code{C-c}.  There is no space between key strokes,
like @code{\C-c} and @code{w} in this example.  Despite the difference, in
documentation, this is still written as @w{@kbd{C-c w}} for readability.

@findex global-unset-key
Historically, keys are unbound globally using a lower-function,
@code{global-unset-key}, which is now considered legacy.  Its key binding
format follows that of @code{global-set-key}.  The key unbinding example in
this section can be rewritten as:

@smallexample
@group
;;; Unbind 'C-x f'
(global-unset-key "\C-xf")
@end group
@end smallexample

@node Keymaps
@section Keymaps
@cindex Keymaps
@cindex Rebinding keys

Emacs uses @dfn{keymaps} to record which keys call which commands.  When you
use @code{keymap-global-set} to set the key binding for a single command in
all parts of Emacs, you are specifying the key binding in
@code{current-global-map}.

Specific modes, such as C mode or Text mode, have their own keymaps; the
mode-specific keymaps override the global map that is shared by all buffers.

The @code{keymap-global-set} function binds, or rebinds, the global keymap.
For example, the following binds the key @kbd{C-x C-b} to the function
@code{buffer-menu}:

@smallexample
(keymap-global-set "C-x C-b" 'buffer-menu)
@end smallexample

Mode-specific keymaps are bound using the @code{keymap-set} function, which
takes a specific keymap as an argument, as well as the key and the command.
For example, the following expression binds the
@code{texinfo-insert-@@group} command to @kbd{C-c C-c g}:

@smallexample
@group
(keymap-set texinfo-mode-map "C-c C-c g" 'texinfo-insert-@@group)
@end group
@end smallexample

Historically, keymaps are bound using a lower-level function,
@code{define-key}, which is now considered legacy.  While you are encouraged
to use @code{keymap-set}, you likely would encounter @code{define-key} in
various places.  The above key binding can be rewritten using
@code{define-key} as:

@smallexample
@group
(define-key texinfo-mode-map "\C-c\C-cg" 'texinfo-insert-@@group)
@end group
@end smallexample

@noindent
The @code{texinfo-insert-@@group} function itself is a little extension to
Texinfo mode that inserts @samp{@@group} into a Texinfo file.  I use this
command all the time and prefer to type the three strokes @kbd{C-c C-c g}
rather than the six strokes @kbd{@@ g r o u p}.  (@samp{@@group} and its
matching @samp{@@end group} are commands that keep all enclosed text
together on one page; many multi-line examples in this book are surrounded
by @samp{@@group @dots{} @@end group}.)

@need 1250
Here is the @code{texinfo-insert-@@group} function definition:

@smallexample
@group
(defun texinfo-insert-@@group ()
  "Insert the string @@group in a Texinfo buffer."
  (interactive)
  (beginning-of-line)
  (insert "@@group\n"))
@end group
@end smallexample

(Of course, I could have used Abbrev mode to save typing, rather than write
a function to insert a word; but I prefer key strokes consistent with other
Texinfo mode key bindings.)

You will see numerous @code{keymap-set} and @code{define-key} expressions in
@file{loaddefs.el} as well as in the various mode libraries, such as
@file{cc-mode.el} and @file{lisp-mode.el}.

@xref{Key Bindings, , Customizing Key Bindings, emacs, The GNU Emacs
Manual}, and @ref{Keymaps, , Keymaps, elisp, The GNU Emacs Lisp Reference
Manual}, for more information about keymaps.

@node Bestanden laden
@section Bestanden laden
@cindex Loading files
@c findex load

Many people in the GNU Emacs community have written extensions to Emacs.  As
time goes by, these extensions are often included in new releases.  For
example, the Calendar and Diary packages are now part of the standard GNU
Emacs, as is Calc.

You can use a @code{load} command to evaluate a complete file and thereby
install all the functions and variables in the file into Emacs.  For
example:

@c (auto-compression-mode t)

@smallexample
(load "~/emacs/slowsplit")
@end smallexample

This evaluates, i.e., loads, the @file{slowsplit.el} file or if it exists,
the faster, byte compiled @file{slowsplit.elc} file from the @file{emacs}
sub-directory of your home directory.  The file contains the function
@code{split-window-quietly}, which John Robinson wrote in 1989.

The @code{split-window-quietly} function splits a window with the minimum of
redisplay.  I installed it in 1989 because it worked well with the slow 1200
baud terminals I was then using.  Nowadays, I only occasionally come across
such a slow connection, but I continue to use the function because I like
the way it leaves the bottom half of a buffer in the lower of the new
windows and the top half in the upper window.

@need 1250
To replace the key binding for the default @code{split-window-vertically},
you must bind the keys to @code{split-window-quietly}, like this:

@smallexample
@group
(keymap-global-set "C-x 2" 'split-window-quietly)
@end group
@end smallexample

@vindex load-path
If you load many extensions, as I do, then instead of specifying the exact
location of the extension file, as shown above, you can specify that
directory as part of Emacs's @code{load-path}.  Then, when Emacs loads a
file, it will search that directory as well as its default list of
directories.  (The default list is specified in @file{epaths.h} when Emacs
is built.)

@need 1250
The following command adds your @file{~/emacs} directory to the existing
load path:

@smallexample
@group
;;; Emacs Load Path
(setq load-path (cons "~/emacs" load-path))
@end group
@end smallexample

Incidentally, @code{load-library} is an interactive interface to the
@code{load} function.  The complete function looks like this:

@findex load-library
@smallexample
@group
(defun load-library (library)
  "Load the Emacs Lisp library named LIBRARY.
This is an interface to the function `load'.  LIBRARY is searched
for in `load-path', both with and without `load-suffixes' (as
well as `load-file-rep-suffixes').

See Info node `(emacs)Lisp Libraries' for more details.
See `load-file' for a different interface to `load'."
  (interactive
   (list (completing-read "Load library: "
                          (apply-partially 'locate-file-completion-table
                                           load-path
                                           (get-load-suffixes)))))
  (load library))
@end group
@end smallexample

The name of the function, @code{load-library}, comes from the use of
``library'' as a conventional synonym for ``file''.  The source for the
@code{load-library} command is in the @file{files.el} library.

Another interactive command that does a slightly different job is
@code{load-file}.  @xref{Lisp Libraries, , Libraries of Lisp Code for Emacs,
emacs, The GNU Emacs Manual}, for information on the distinction between
@code{load-library} and this command.

@node Autoload
@section Autoloading
@findex autoload

Instead of installing a function by loading the file that contains it, or by
evaluating the function definition, you can make the function available but
not actually install it until it is first called.  This is called
@dfn{autoloading}.

When you execute an autoloaded function, Emacs automatically evaluates the
file that contains the definition, and then calls the function.

Emacs starts quicker with autoloaded functions, since their libraries are
not loaded right away; but you need to wait a moment when you first use such
a function, while its containing file is evaluated.

Rarely used functions are frequently autoloaded.  The @file{loaddefs.el}
library contains thousands of autoloaded functions, from @code{5x5} to
@code{zone}.  Of course, you may come to use a rare function frequently.
When you do, you should load that function's file with a @code{load}
expression in your @file{.emacs} file.

In my @file{.emacs} file, I load 14 libraries that contain functions that
would otherwise be autoloaded.  (Actually, it would have been better to
include these files in my dumped Emacs, but I forgot.  @xref{Building Emacs,
, Building Emacs, elisp, The GNU Emacs Lisp Reference Manual}, and the
@file{INSTALL} file for more about dumping.)

You may also want to include autoloaded expressions in your @file{.emacs}
file.  @code{autoload} is a built-in function that takes up to five
arguments, the final three of which are optional.  The first argument is the
name of the function to be autoloaded; the second is the name of the file to
be loaded.  The third argument is documentation for the function, and the
fourth tells whether the function can be called interactively.  The fifth
argument tells what type of object---@code{autoload} can handle a keymap or
macro as well as a function (the default is a function).

@need 800
Here is a typical example:

@smallexample
@group
(autoload 'html-helper-mode
  "html-helper-mode" "Edit HTML documents" t)
@end group
@end smallexample

@noindent
(@code{html-helper-mode} is an older alternative to @code{html-mode}, which
is a standard part of the distribution.)

@noindent
This expression autoloads the @code{html-helper-mode} function.  It takes it
from the @file{html-helper-mode.el} file (or from the byte compiled version
@file{html-helper-mode.elc}, if that exists.)  The file must be located in a
directory specified by @code{load-path}.  The documentation says that this
is a mode to help you edit documents written in the HyperText Markup
Language.  You can call this mode interactively by typing @kbd{M-x
html-helper-mode}.  (You need to duplicate the function's regular
documentation in the autoload expression because the regular function is not
yet loaded, so its documentation is not available.)

@xref{Autoload, , Autoload, elisp, The GNU Emacs Lisp Reference Manual}, for
more information.

@node Eenvoudige uitbreiding
@section A Simple Extension: @code{line-to-top-of-window}
@findex line-to-top-of-window
@cindex Simple extension in @file{.emacs} file

Here is a simple extension to Emacs that moves the line that point is on to
the top of the window.  I use this all the time, to make text easier to
read.

You can put the following code into a separate file and then load it from
your @file{.emacs} file, or you can include it within your @file{.emacs}
file.

@need 1250
Here is the definition:

@smallexample
@group
;;; Line to top of window;
;;; replace three keystroke sequence  C-u 0 C-l
(defun line-to-top-of-window ()
  "Move the line that point is on to top of window."
  (interactive)
  (recenter 0))
@end group
@end smallexample

@need 1250
Now for the key binding.

Function keys as well as mouse button events and non-@sc{ascii} characters
are written within square brackets, without quotation marks.

I bind @code{line-to-top-of-window} to my @key{F6} function key like this:

@smallexample
(keymap-global-set "<f6>" 'line-to-top-of-window)
@end smallexample

For more information, see @ref{Init Rebinding, , Rebinding Keys in Your Init
File, emacs, The GNU Emacs Manual}.

@cindex Conditional 'twixt two versions of Emacs
@cindex Version of Emacs, choosing
@cindex Emacs version, choosing
If you run two versions of GNU Emacs, such as versions 27 and 28, and use
one @file{.emacs} file, you can select which code to evaluate with the
following conditional:

@smallexample
@group
(cond
 ((= 27 emacs-major-version)
  ;; evaluate version 27 code
  ( @dots{} ))
 ((= 28 emacs-major-version)
  ;; evaluate version 28 code
  ( @dots{} )))
@end group
@end smallexample

Recente versies laten bijvoorbeeld de cursor standaard knipperen. Ik haat
dat knipperen net zoals sommige andere features, daarom plaats ik het
volgende in mijn @file{.emacs} bestand@footnote{Wanneer ik instanties van
Emacs start die mijn @file{.emacs} of elk ander site-bestand niet laden zet
ik ook het knipperen uit:
 @smallexample
emacs -q --no-site-file -eval '(blink-cursor-mode nil)'
 @exdent Of tegenwoordig met gebruik van een meer gesofisticeerde
verzameling opties emacs -Q -D
@end smallexample
}: 

@smallexample
@group
(when (>= emacs-major-version 21)
  (blink-cursor-mode 0)
  ;; Insert newline when you press 'C-n' (next-line)
  ;; at the end of the buffer
  (setq next-line-add-newlines t)
@end group
@group
  ;; Turn on image viewing
  (auto-image-file-mode t)
@end group
@group
  ;; Turn on menu bar (this bar has text)
  ;; (Use numeric argument to turn on)
  (menu-bar-mode 1)
@end group
@group
  ;; Turn off tool bar (this bar has icons)
  ;; (Use numeric argument to turn on)
  (tool-bar-mode nil)
@end group
@group
  ;; Turn off tooltip mode for tool bar
  ;; (This mode causes icon explanations to pop up)
  ;; (Use numeric argument to turn on)
  (tooltip-mode nil)
  ;; If tooltips turned on, make tips appear promptly
  (setq tooltip-delay 0.1)  ; default is 0.7 second
   )
@end group
@end smallexample

@node X11 kleuren
@section X11 kleuren

You can specify colors when you use Emacs with the MIT X Windowing system.

I dislike the default colors and specify my own.

@need 1250
Here are the expressions in my @file{.emacs} file that set values:

@smallexample
@group
;; Set cursor color
(set-cursor-color "white")

;; Set mouse color
(set-mouse-color "white")

;; Set foreground and background
(set-foreground-color "white")
(set-background-color "darkblue")
@end group

@group
;;; Set highlighting colors for isearch and drag
(set-face-foreground 'highlight "white")
(set-face-background 'highlight "blue")
@end group

@group
(set-face-foreground 'region "cyan")
(set-face-background 'region "blue")
@end group

@group
(set-face-foreground 'secondary-selection "skyblue")
(set-face-background 'secondary-selection "darkblue")
@end group

@group
;; Set calendar highlighting colors
(with-eval-after-load 'calendar
  (set-face-foreground 'diary   "skyblue")
  (set-face-background 'holiday "slate blue")
  (set-face-foreground 'holiday "white"))
@end group
@end smallexample

The various shades of blue soothe my eye and prevent me from seeing the
screen flicker.

Alternatively, I could have set my specifications in various X
initialization files.  For example, I could set the foreground, background,
cursor, and pointer (i.e., mouse) colors in my @file{~/.Xresources} file
like this:

@smallexample
@group
Emacs*foreground:   white
Emacs*background:   darkblue
Emacs*cursorColor:  white
Emacs*pointerColor: white
@end group
@end smallexample

In any event, since it is not part of Emacs, I set the root color of my X
window in my @file{~/.xinitrc} file, like this@footnote{I also run more
modern window managers, such as Enlightenment, Gnome, or KDE; in those
cases, I often specify an image rather than a plain color.}:

@smallexample
xsetroot -solid Navy -fg white &
@end smallexample

@need 1700
@node Diverse
@section Miscellaneous Settings for a @file{.emacs} File

@need 1250
Here are a few miscellaneous settings:
@sp 1

@itemize @minus
@item
Set the shape and color of the mouse cursor:

@smallexample
@group
; Cursor shapes are defined in
; '/usr/include/X11/cursorfont.h';
; for example, the 'target' cursor is number 128;
; the 'top_left_arrow' cursor is number 132.
@end group

@group
(let ((mpointer (x-get-resource "*mpointer"
                                "*emacs*mpointer")))
  ;; If you have not set your mouse pointer
  ;;     then set it, otherwise leave as is:
  (if (eq mpointer nil)
      (setq mpointer "132")) ; top_left_arrow
@end group
@group
  (setq x-pointer-shape (string-to-number mpointer))
  (set-mouse-color "white"))
@end group
@end smallexample

@item
Or you can set the values of a variety of features in an alist, like this:

@smallexample
@group
(setq-default
 default-frame-alist
 '((cursor-color . "white")
   (mouse-color . "white")
   (foreground-color . "white")
   (background-color . "DodgerBlue4")
   ;; (cursor-type . bar)
   (cursor-type . box)
@end group
@group
   (tool-bar-lines . 0)
   (menu-bar-lines . 1)
   (width . 80)
   (height . 58)
   (font .
         "-Misc-Fixed-Medium-R-Normal--20-200-75-75-C-100-ISO8859-1")
   ))
@end group
@end smallexample

@item
Convert @kbd{@key{CTRL}-h} into @key{DEL} and @key{DEL} into
@kbd{@key{CTRL}-h}.@* (Some older keyboards needed this, although I have not
seen the problem recently.)

@smallexample
@group
;; Translate 'C-h' to <DEL>.
; (key-translate "C-h" "C-?")

;; Translate <DEL> to 'C-h'.
(key-translate "C-?" "C-h")
@end group
@end smallexample

@item Turn off a blinking cursor!

@smallexample
@group
(if (fboundp 'blink-cursor-mode)
    (blink-cursor-mode -1))
@end group
@end smallexample

@noindent
or start GNU Emacs with the command @code{emacs -nbc}.

@need 1250
@item When using @command{grep}@*
@samp{-i}@w{ } Ignore case distinctions@* @samp{-n}@w{ } Prefix each line of
output with line number@* @samp{-H}@w{ } Print the filename for each
match.@* @samp{-e}@w{ } Protect patterns beginning with a hyphen character,
@samp{-}

@smallexample
(setq grep-command "grep -i -nH -e ")
@end smallexample

@item Find an existing buffer, even if it has a different name@*
This avoids problems with symbolic links.

@smallexample
(setq find-file-existing-other-name t)
@end smallexample

@item Set your language environment and default input method

@smallexample
@group
(set-language-environment "latin-1")
;; Remember you can enable or disable multilingual text input
;; with the @code{toggle-input-method'} (@kbd{C-\}) command
(setq default-input-method "latin-1-prefix")
@end group
@end smallexample

If you want to write with Chinese GB characters, set this instead:

@smallexample
@group
(set-language-environment "Chinese-GB")
(setq default-input-method "chinese-tonepy")
@end group
@end smallexample
@end itemize

@subsubheading Fixing Unpleasant Key Bindings
@cindex Key bindings, fixing
@cindex Bindings, key, fixing unpleasant

Some systems bind keys unpleasantly.  Sometimes, for example, the @key{CTRL}
key appears in an awkward spot rather than at the far left of the home row.

Usually, when people fix these sorts of key bindings, they do not change
their @file{~/.emacs} file.  Instead, they bind the proper keys on their
consoles with the @code{loadkeys} or @code{install-keymap} commands in their
boot script and then include @code{xmodmap} commands in their
@file{.xinitrc} or @file{.Xsession} file for X Windows.

@need 1250
@noindent
For a boot script:

@smallexample
@group
loadkeys /usr/share/keymaps/i386/qwerty/emacs2.kmap.gz
@exdent or
install-keymap emacs2
@end group
@end smallexample

@need 1250
@noindent
For a @file{.xinitrc} or @file{.Xsession} file when the @key{Caps Lock} key
is at the far left of the home row:

@smallexample
@group
# Bind the key labeled 'Caps Lock' to 'Control'
# (Such a broken user interface suggests that keyboard manufacturers
# think that computers are typewriters from 1885.)

xmodmap -e "clear Lock"
xmodmap -e "add Control = Caps_Lock"
@end group
@end smallexample

@need 1250
@noindent
In a @file{.xinitrc} or @file{.Xsession} file, to convert an @key{ALT} key
to a @key{META} key:

@smallexample
@group
# Some ill designed keyboards have a key labeled ALT and no Meta
xmodmap -e "keysym Alt_L = Meta_L Alt_L"
@end group
@end smallexample

@need 1700
@node Mode line
@section A Modified Mode Line
@vindex mode-line-format
@cindex Mode line format

Finally, a feature I really like: a modified mode line.

When I work over a network, I forget which machine I am using.  Also, I tend
to lose track of where I am, and which line point is on.

So I reset my mode line to look like this:

@smallexample
-:-- foo.texi   rattlesnake:/home/bob/  Line 1  (Texinfo Fill) Top
@end smallexample

I am visiting a file called @file{foo.texi}, on my machine
@file{rattlesnake} in my @file{/home/bob} buffer.  I am on line 1, in
Texinfo mode, and am at the top of the buffer.

@need 1200
My @file{.emacs} file has a section that looks like this:

@smallexample
@group
;; Set a Mode Line that tells me which machine, which directory,
;; and which line I am on, plus the other customary information.
(setq-default mode-line-format
 (quote
  (#("-" 0 1
     (help-echo
      "mouse-1: select window, mouse-2: delete others ..."))
   mode-line-mule-info
   mode-line-modified
   mode-line-frame-identification
   "    "
@end group
@group
   mode-line-buffer-identification
   "    "
   (:eval (substring
           (system-name) 0 (string-match "\\..+" (system-name))))
   ":"
   default-directory
   #(" " 0 1
     (help-echo
      "mouse-1: select window, mouse-2: delete others ..."))
   (line-number-mode " Line %l ")
   global-mode-string
@end group
@group
   #("   %[(" 0 6
     (help-echo
      "mouse-1: select window, mouse-2: delete others ..."))
   (:eval (format-time-string "%F"))
   mode-line-process
   minor-mode-alist
   #("%n" 0 2 (help-echo "mouse-2: widen" local-map (keymap ...)))
   ")%] "
   (-3 . "%P")
   ;;   "-%-"
   )))
@end group
@end smallexample

@noindent
Here, I redefine the default mode line.  Most of the parts are from the
original; but I make a few changes.  I set the @emph{default} mode line
format so as to permit various modes, such as Info, to override it.

Many elements in the list are self-explanatory: @code{mode-line-modified} is
a variable that tells whether the buffer has been modified, @code{mode-name}
tells the name of the mode, and so on.  However, the format looks
complicated because of two features we have not discussed.

@cindex Properties, in mode line example
The first string in the mode line is a dash or hyphen, @samp{-}.  In the old
days, it would have been specified simply as @code{"-"}.  But nowadays,
Emacs can add properties to a string, such as highlighting or, as in this
case, a help feature.  If you place your mouse cursor over the hyphen, some
help information appears (By default, you must wait seven-tenths of a second
before the information appears.  You can change that timing by changing the
value of @code{tooltip-delay}.)

@need 1000
The new string format has a special syntax:

@smallexample
#("-" 0 1 (help-echo "mouse-1: select window, ..."))
@end smallexample

@noindent
The @code{#(} begins a list.  The first element of the list is the string
itself, just one @samp{-}.  The second and third elements specify the range
over which the fourth element applies.  A range starts @emph{after} a
character, so a zero means the range starts just before the first character;
a 1 means that the range ends just after the first character.  The third
element is the property for the range.  It consists of a property list, a
property name, in this case, @samp{help-echo}, followed by a value, in this
case, a string.  The second, third, and fourth elements of this new string
format can be repeated.

@xref{Text Properties, , Text Properties, elisp, The GNU Emacs Lisp
Reference Manual}, and see @ref{Mode Line Format, , Mode Line Format, elisp,
The GNU Emacs Lisp Reference Manual}, for more information.

@code{mode-line-buffer-identification} displays the current buffer name.  It
is a list beginning @code{(#("%12b" 0 4 @dots{}}.  The @code{#(} begins the
list.

The @samp{"%12b"} displays the current buffer name, using the
@code{buffer-name} function with which we are familiar; the @samp{12}
specifies the maximum number of characters that will be displayed.  When a
name has fewer characters, whitespace is added to fill out to this number.
(Buffer names can and often should be longer than 12 characters; this length
works well in a typical 80 column wide window.)

@code{:eval} says to evaluate the following form and use the result as a
string to display.  In this case, the expression displays the first
component of the full system name.  The end of the first component is a
@samp{.} (period), so I use the @code{string-match} function to tell me the
length of the first component.  The substring from the zeroth character to
that length is the name of the machine.

@need 1250
This is the expression:

@smallexample
@group
(:eval (substring
        (system-name) 0 (string-match "\\..+" (system-name))))
@end group
@end smallexample

@samp{%[} and @samp{%]} cause a pair of square brackets to appear for each
recursive editing level.  @samp{%n} says ``Narrow'' when narrowing is in
effect.  @samp{%P} tells you the percentage of the buffer that is above the
bottom of the window, or ``Top'', ``Bottom'', or ``All''.  (A lower case
@samp{p} tell you the percentage above the @emph{top} of the window.)
@samp{%-} inserts enough dashes to fill out the line.

Remember, you don't have to like Emacs to like it---your own Emacs can have
different colors, different commands, and different keys than a default
Emacs.

On the other hand, if you want to bring up a plain out-of-the-box Emacs,
with no customization, type:

@smallexample
emacs -q
@end smallexample

@noindent
This will start an Emacs that does @emph{not} load your @file{~/.emacs}
initialization file.  A plain, default Emacs.  Nothing more.

@node Debuggen.
@chapter Debuggen.
@cindex debugging

GNU Emacs has two debuggers, @code{debug} and @code{edebug}.  The first is
built into the internals of Emacs and is always with you; the second
requires that you instrument a function before you can use it.

Both debuggers are described extensively in @ref{Debugging, , Debugging Lisp
Programs, elisp, The GNU Emacs Lisp Reference Manual}.  In this chapter, I
will walk through a short example of each.

@menu
* debug::                    Hoe de ingebouwde debugger te gebruiken.
* debug-on-entry::           Start debugen wanneer je een functie aanroept.
* debug-on-quit::            Start debuggen wanneer je quit met @kbd{C-g}.
* edebug::                   Hoe je Edebug gebruikt, een source level 
                               debugger.
* Debuggen oefeningen::      Debuggen oefeningen
@end menu

@node debug
@section @code{debug}
@findex debug

@c xref{Decrementing Loop,, Loop with a Decrementing Counter}, for a discussion.)
Suppose you have written a function definition that is intended to return
the sum of the numbers 1 through a given number.  (This is the
@code{triangle} function discussed earlier.  @xref{Decrementing Example, ,
Example with Decrementing Counter}, for a discussion.)

However, your function definition has a bug.  You have mistyped @samp{1=}
for @samp{1-}.  Here is the broken definition:

@findex triangle-bugged
@smallexample
@group
(defun triangle-bugged (number)
  "Return sum of numbers 1 through NUMBER inclusive."
  (let ((total 0))
    (while (> number 0)
      (setq total (+ total number))
      (setq number (1= number)))      ; @r{Error here.}
    total))
@end group
@end smallexample

If you are reading this in Info, you can evaluate this definition in the
normal fashion.  You will see @code{triangle-bugged} appear in the echo
area.

@need 1250
Now evaluate the @code{triangle-bugged} function with an argument of 4:

@smallexample
(triangle-bugged 4)
@end smallexample

@noindent
This will create and enter a @file{*Backtrace*} buffer that says:

@noindent
@smallexample
@group
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function 1=)
  (1= number)
  (setq number (1= number))
  (while (> number 0) (setq total (+ total number))
        (setq number (1= number)))
  (let ((total 0)) (while (> number 0) (setq total ...)
    (setq number ...)) total)
  triangle-bugged(4)
@end group
@group
  eval((triangle-bugged 4) nil)
  eval-expression((triangle-bugged 4) nil nil 127)
  funcall-interactively(eval-expression (triangle-bugged 4) nil nil 127)
  call-interactively(eval-expression nil nil)
  command-execute(eval-expression)
---------- Buffer: *Backtrace* ----------
@end group
@end smallexample

@noindent
(I have reformatted this example slightly; the debugger does not fold long
lines.  As usual, you can quit the debugger by typing @kbd{q} in the
@file{*Backtrace*} buffer.)

In practice, for a bug as simple as this, the Lisp error line will tell you
what you need to know to correct the definition.  The function @code{1=} is
void.

However, suppose you are not quite certain what is going on? You can read
the complete backtrace.

Emacs automatically starts the debugger that puts you in the
@file{*Backtrace*} buffer.  You can also start the debugger manually as
described below.

Read the @file{*Backtrace*} buffer from the bottom up; it tells you what
Emacs did that led to the error.  Emacs made an interactive call to @kbd{C-x
C-e} (@code{eval-last-sexp}), which led to the evaluation of the
@code{triangle-bugged} expression.  Each line above tells you what the Lisp
interpreter evaluated next.

@need 1250
The third line from the top of the buffer is

@smallexample
(setq number (1= number))
@end smallexample

@noindent
Emacs tried to evaluate this expression; in order to do so, it tried to
evaluate the inner expression shown on the second line from the top:

@smallexample
(1= number)
@end smallexample

@need 1250
@noindent
This is where the error occurred; as the top line says:

@smallexample
Debugger entered--Lisp error: (void-function 1=)
@end smallexample

@noindent
You can correct the mistake, re-evaluate the function definition, and then
run your test again.

@node debug-on-entry
@section @code{debug-on-entry}
@findex debug-on-entry

Emacs starts the debugger automatically when your function has an error.

Incidentally, you can start the debugger manually for all versions of Emacs;
the advantage is that the debugger runs even if you do not have a bug in
your code.  Sometimes your code will be free of bugs!

You can enter the debugger when you call the function by calling
@code{debug-on-entry}.

@need 1250
@noindent
Type:

@smallexample
M-x debug-on-entry @key{RET} triangle-bugged @key{RET}
@end smallexample

@need 1250
@noindent
Now, evaluate the following:

@smallexample
(triangle-bugged 5)
@end smallexample

@noindent
All versions of Emacs will create a @file{*Backtrace*} buffer and tell you
that it is beginning to evaluate the @code{triangle-bugged} function:

@smallexample
@group
---------- Buffer: *Backtrace* ----------
Debugger entered--entering a function:
* triangle-bugged(5)
  eval((triangle-bugged 5) nil)
@end group
@group
  eval-expression((triangle-bugged 5) nil nil 127)
  funcall-interactively(eval-expression (triangle-bugged 5) nil nil 127)
  call-interactively(eval-expression nil nil)
  command-execute(eval-expression)
---------- Buffer: *Backtrace* ----------
@end group
@end smallexample

In the @file{*Backtrace*} buffer, type @kbd{d}.  Emacs will evaluate the
first expression in @code{triangle-bugged}; the buffer will look like this:

@smallexample
@group
---------- Buffer: *Backtrace* ----------
Debugger entered--beginning evaluation of function call form:
* (let ((total 0)) (while (> number 0) (setq total ...)
        (setq number ...)) total)
* triangle-bugged(5)
  eval((triangle-bugged 5))
@end group
@group
  eval((triangle-bugged 5) nil)
  eval-expression((triangle-bugged 5) nil nil 127)
  funcall-interactively(eval-expression (triangle-bugged 5) nil nil 127)
  call-interactively(eval-expression nil nil)
  command-execute(eval-expression)
---------- Buffer: *Backtrace* ----------
@end group
@end smallexample

@noindent
Now, type @kbd{d} again, eight times, slowly.  Each time you type @kbd{d},
Emacs will evaluate another expression in the function definition.

@need 1750
Eventually, the buffer will look like this:

@smallexample
@group
---------- Buffer: *Backtrace* ----------
Debugger entered--beginning evaluation of function call form:
* (setq number (1= number))
* (while (> number 0) (setq total (+ total number))
        (setq number (1= number)))
@group
@end group
* (let ((total 0)) (while (> number 0) (setq total ...)
        (setq number ...)) total)
* triangle-bugged(5)
  eval((triangle-bugged 5) nil)
@group
@end group
  eval-expression((triangle-bugged 5) nil nil 127)
  funcall-interactively(eval-expression (triangle-bugged 5) nil nil 127)
  call-interactively(eval-expression nil nil)
  command-execute(eval-expression)
---------- Buffer: *Backtrace* ----------
@end group
@end smallexample

@need 1500
@noindent
Finally, after you type @kbd{d} two more times, Emacs will reach the error,
and the top two lines of the @file{*Backtrace*} buffer will look like this:

@smallexample
@group
---------- Buffer: *Backtrace* ----------
Debugger entered--Lisp error: (void-function 1=)
* (1= number)
@dots{}
---------- Buffer: *Backtrace* ----------
@end group
@end smallexample

By typing @kbd{d}, you were able to step through the function.

You can quit a @file{*Backtrace*} buffer by typing @kbd{q} in it; this quits
the trace, but does not cancel @code{debug-on-entry}.

@findex cancel-debug-on-entry
To cancel the effect of @code{debug-on-entry}, call
@code{cancel-debug-on-entry} and the name of the function, like this:

@smallexample
M-x cancel-debug-on-entry @key{RET} triangle-bugged @key{RET}
@end smallexample

@noindent
(If you are reading this in Info, cancel @code{debug-on-entry} now.)

@node debug-on-quit
@section @code{debug-on-quit} and @code{(debug)}

In addition to setting @code{debug-on-error} or calling
@code{debug-on-entry}, there are two other ways to start @code{debug}.

@findex debug-on-quit
You can start @code{debug} whenever you type @kbd{C-g}
(@code{keyboard-quit}) by setting the variable @code{debug-on-quit} to
@code{t}.  This is useful for debugging infinite loops.

@need 1500
@cindex @code{(debug)} in code
Or, you can insert a line that says @code{(debug)} into your code where you
want the debugger to start, like this:

@smallexample
@group
(defun triangle-bugged (number)
  "Return sum of numbers 1 through NUMBER inclusive."
  (let ((total 0))
    (while (> number 0)
      (setq total (+ total number))
      (debug)                         ; @r{Start debugger.}
      (setq number (1= number)))      ; @r{Error here.}
    total))
@end group
@end smallexample

The @code{debug} function is described in detail in @ref{Debugger, , The
Lisp Debugger, elisp, The GNU Emacs Lisp Reference Manual}.

@node edebug
@section The @code{edebug} Source Level Debugger
@cindex Source level debugger
@findex edebug

Edebug is a source level debugger.  Edebug normally displays the source of
the code you are debugging, with an arrow at the left that shows which line
you are currently executing.

You can walk through the execution of a function, line by line, or run
quickly until reaching a @dfn{breakpoint} where execution stops.

Edebug is described in @ref{Edebug, , , elisp, The GNU Emacs Lisp Reference
Manual}.

@need 1250
Here is a bugged function definition for @code{triangle-recursively}.
@xref{Recursive triangle function, , Recursion in place of a counter}, for a
review of it.

@smallexample
@group
(defun triangle-recursively-bugged (number)
  "Return sum of numbers 1 through NUMBER inclusive.
Uses recursion."
  (if (= number 1)
      1
    (+ number
       (triangle-recursively-bugged
        (1= number)))))               ; @r{Error here.}
@end group
@end smallexample

@noindent
Normally, you would install this definition by positioning your cursor after
the function's closing parenthesis and typing @kbd{C-x C-e}
(@code{eval-last-sexp}) or else by positioning your cursor within the
definition and typing @kbd{C-M-x} (@code{eval-defun}).  (By default, the
@code{eval-defun} command works only in Emacs Lisp mode or in Lisp
Interaction mode.)

@need 1500
However, to prepare this function definition for Edebug, you must first
@dfn{instrument} the code using a different command.  You can do this by
positioning your cursor within or just after the definition and typing

@smallexample
M-x edebug-defun @key{RET}
@end smallexample

@noindent
This will cause Emacs to load Edebug automatically if it is not already
loaded, and properly instrument the function.

After instrumenting the function, place your cursor after the following
expression and type @kbd{C-x C-e} (@code{eval-last-sexp}):

@smallexample
(triangle-recursively-bugged 3)
@end smallexample

@noindent
You will be jumped back to the source for @code{triangle-recursively-bugged}
and the cursor positioned at the beginning of the @code{if} line of the
function.  Also, you will see an arrowhead at the left hand side of that
line.  The arrowhead marks the line where the function is executing.  (In
the following examples, we show the arrowhead with @samp{=>}; in a windowing
system, you may see the arrowhead as a solid triangle in the window fringe.)

@smallexample
=>@point{}(if (= number 1)
@end smallexample

@noindent
@iftex
In the example, the location of point is displayed with a star,
@samp{@point{}} (in Info, it is displayed as @samp{-!-}).
@end iftex
@ifnottex
In the example, the location of point is displayed as @samp{@point{}} (in a
printed book, it is displayed with a five pointed star).
@end ifnottex

If you now press @key{SPC}, point will move to the next expression to be
executed; the line will look like this:

@smallexample
=>(if @point{}(= number 1)
@end smallexample

@noindent
As you continue to press @key{SPC}, point will move from expression to
expression.  At the same time, whenever an expression returns a value, that
value will be displayed in the echo area.  For example, after you move point
past @code{number}, you will see the following:

@smallexample
Result: 3 (#o3, #x3, ?\C-c)
@end smallexample

@noindent
This means the value of @code{number} is 3, which is octal three,
hexadecimal three, and @sc{ascii} Control-C (the third letter of the
alphabet, in case you need to know this information).

You can continue moving through the code until you reach the line with the
error.  Before evaluation, that line looks like this:

@smallexample
=>        @point{}(1= number)))))               ; @r{Error here.}
@end smallexample

@need 1250
@noindent
When you press @key{SPC} once again, you will produce an error message that
says:

@smallexample
Symbol's function definition is void:@: 1=
@end smallexample

@noindent
This is the bug.

Press @kbd{q} to quit Edebug.

To remove instrumentation from a function definition, simply re-evaluate it
with a command that does not instrument it.  For example, you could place
your cursor after the definition's closing parenthesis and type @kbd{C-x
C-e}.

Edebug does a great deal more than walk with you through a function.  You
can set it so it races through on its own, stopping only at an error or at
specified stopping points; you can cause it to display the changing values
of various expressions; you can find out how many times a function is
called, and more.

Edebug is described in @ref{Edebug, , , elisp, The GNU Emacs Lisp Reference
Manual}.

@need 1500
@node Debuggen oefeningen
@section Debuggen oefeningen

@itemize @bullet
@item
Install the @code{@value{COUNT-WORDS}} function and then cause it to enter
the built-in debugger when you call it.  Run the command on a region
containing two words.  You will need to press @kbd{d} a remarkable number of
times.  On your system, is a hook called after the command finishes? (For
information on hooks, see @ref{Command Overview, , Command Loop Overview,
elisp, The GNU Emacs Lisp Reference Manual}.)

@item
Copy @code{@value{COUNT-WORDS}} into the @file{*scratch*} buffer, instrument
the function for Edebug, and walk through its execution.  The function does
not need to have a bug, although you can introduce one if you wish.  If the
function lacks a bug, the walk-through completes without problems.

@item
While running Edebug, type @kbd{?} to see a list of all the Edebug
commands.  (The @code{global-edebug-prefix} is usually @kbd{C-x X}, i.e.,
@kbd{@key{CTRL}-x} followed by an upper case @kbd{X}; use this prefix for
commands made outside of the Edebug debugging buffer.)

@item
In the Edebug debugging buffer, use the @kbd{p} (@code{edebug-bounce-point})
command to see where in the region the @code{@value{COUNT-WORDS}} is
working.

@item
Move point to some spot further down the function and then type the @kbd{h}
(@code{edebug-goto-here}) command to jump to that location.

@item
Use the @kbd{t} (@code{edebug-trace-mode}) command to cause Edebug to walk
through the function on its own; use an upper case @kbd{T} for
@code{edebug-Trace-fast-mode}.

@item
Set a breakpoint, then run Edebug in Trace mode until it reaches the
stopping point.
@end itemize

@node Conclusie
@chapter Conclusie

We have now reached the end of this Introduction.  You have now learned
enough about programming in Emacs Lisp to set values, to write simple
@file{.emacs} files for yourself and your friends, and write simple
customizations and extensions to Emacs.

This is a place to stop.  Or, if you wish, you can now go onward, and teach
yourself.

You have learned some of the basic nuts and bolts of programming.  But only
some.  There are a great many more brackets and hinges that are easy to use
that we have not touched.

A path you can follow right now lies among the sources to GNU Emacs and in
@ifnotinfo
@cite{The GNU Emacs Lisp Reference Manual}.
@end ifnotinfo
@ifinfo
@ref{Top, , The GNU Emacs Lisp Reference Manual, elisp, The GNU Emacs Lisp
Reference Manual}.
@end ifinfo

The Emacs Lisp sources are an adventure.  When you read the sources and come
across a function or expression that is unfamiliar, you need to figure out
or find out what it does.

Go to the Reference Manual.  It is a thorough, complete, and fairly
easy-to-read description of Emacs Lisp.  It is written not only for experts,
but for people who know what you know.  (The @cite{Reference Manual} comes
with the standard GNU Emacs distribution.  Like this introduction, it comes
as a Texinfo source file, so you can read it on your computer and as a
typeset, printed book.)

Go to the other built-in help that is part of GNU Emacs: the built-in
documentation for all functions and variables, and
@code{xref-find-definitions}, the program that takes you to sources.

Here is an example of how I explore the sources.  Because of its name,
@file{simple.el} is the file I looked at first, a long time ago.  As it
happens some of the functions in @file{simple.el} are complicated, or at
least look complicated at first sight.  The @code{open-line} function, for
example, looks complicated.

You may want to walk through this function slowly, as we did with the
@code{forward-sentence} function.  (@xref{forward-sentence, The
@code{forward-sentence} function}.)  Or you may want to skip that function
and look at another, such as @code{split-line}.  You don't need to read all
the functions.  According to @code{count-words-in-defun}, the
@code{split-line} function contains 102 words and symbols.

Even though it is short, @code{split-line} contains expressions we have not
studied: @code{skip-chars-forward}, @code{indent-to}, @code{current-column}
and @code{insert-and-inherit}.

Consider the @code{skip-chars-forward} function.  In GNU Emacs, you can find
out more about @code{skip-chars-forward} by typing @kbd{C-h f}
(@code{describe-function}) and the name of the function.  This gives you the
function documentation.

You may be able to guess what is done by a well named function such as
@code{indent-to}; or you can look it up, too.  Incidentally, the
@code{describe-function} function itself is in @file{help.el}; it is one of
those long, but decipherable functions.  You can look up
@code{describe-function} using the @kbd{C-h f} command!

In this instance, since the code is Lisp, the @file{*Help*} buffer contains
the name of the library containing the function's source.  You can put point
over the name of the library and press the @key{RET} key, which in this
situation is bound to @code{help-follow}, and be taken directly to the
source, in the same way as @kbd{M-.} (@code{xref-find-definitions}).

The definition for @code{describe-function} illustrates how to customize the
@code{interactive} expression without using the standard character codes;
and it shows how to create a temporary buffer.

(The @code{indent-to} function is written in C rather than Emacs Lisp; it is
a built-in function.  @code{help-follow} takes you to its source as does
@code{xref-find-definitions}, when properly set up.)

You can look at a function's source using @code{xref-find-definitions},
which is bound to @kbd{M-.} Finally, you can find out what the Reference
Manual has to say by visiting the manual in Info, and typing @kbd{i}
(@code{Info-index}) and the name of the function, or by looking up the
function in the index to a printed copy of the manual.

Similarly, you can find out what is meant by @code{insert-and-inherit}.

Other interesting source files include @file{paragraphs.el},
@file{loaddefs.el}, and @file{loadup.el}.  The @file{paragraphs.el} file
includes short, easily understood functions as well as longer ones.  The
@file{loaddefs.el} file contains the many standard autoloads and many
keymaps.  I have never looked at it all; only at parts.  @file{loadup.el} is
the file that loads the standard parts of Emacs; it tells you a great deal
about how Emacs is built.  (@xref{Building Emacs, , Building Emacs, elisp,
The GNU Emacs Lisp Reference Manual}, for more about building.)

As I said, you have learned some nuts and bolts; however, and very
importantly, we have hardly touched major aspects of programming; I have
said nothing about how to sort information, except to use the predefined
@code{sort} function; I have said nothing about how to store information,
except to use variables and lists; I have said nothing about how to write
programs that write programs.  These are topics for another, and different
kind of book, a different kind of learning.

What you have done is learn enough for much practical work with GNU Emacs.
What you have done is get started.  This is the end of a beginning.

@c ================ Appendix ================

@node de-de
@appendix The @code{the-the} Function
@findex de-de
@cindex Duplicated words function
@cindex Words, duplicated

Sometimes when you you write text, you duplicate words---as with ``you you''
near the beginning of this sentence.  I find that most frequently, I
duplicate ``the''; hence, I call the function for detecting duplicated
words, @code{the-the}.

@need 1250
As a first step, you could use the following regular expression to search
for duplicates:

@smallexample
\\(\\w+[ \t\n]+\\)\\1
@end smallexample

@noindent
This regexp matches one or more word-constituent characters followed by one
or more spaces, tabs, or newlines.  However, it does not detect duplicated
words on different lines, since the ending of the first word, the end of the
line, is different from the ending of the second word, a space.  (For more
information about regular expressions, see @ref{Regexp Search, , Regular
Expression Searches}, as well as @ref{Regexps, , Syntax of Regular
Expressions, emacs, The GNU Emacs Manual}, and @ref{Regular Expressions, ,
Regular Expressions, elisp, The GNU Emacs Lisp Reference Manual}.)

You might try searching just for duplicated word-constituent characters but
that does not work since the pattern detects doubles such as the two
occurrences of ``th'' in ``with the''.

Another possible regexp searches for word-constituent characters followed by
non-word-constituent characters, reduplicated.  Here, @w{@samp{\\w+}}
matches one or more word-constituent characters and @w{@samp{\\W*}} matches
zero or more non-word-constituent characters.

@smallexample
\\(\\(\\w+\\)\\W*\\)\\1
@end smallexample

@noindent
Again, not useful.

Here is the pattern that I use.  It is not perfect, but good enough.
@w{@samp{\\b}} matches the empty string, provided it is at the beginning or
end of a word; @w{@samp{[^@@ \n\t]+}} matches one or more occurrences of any
characters that are @emph{not} an @@-sign, space, newline, or tab.

@smallexample
\\b\\([^@@ \n\t]+\\)[ \n\t]+\\1\\b
@end smallexample

One can write more complicated expressions, but I found that this expression
is good enough, so I use it.

Here is the @code{the-the} function, as I include it in my @file{.emacs}
file, along with a handy global key binding:

@smallexample
@group
(defun the-the ()
  "Search forward for for a duplicated word."
  (interactive)
  (message "Searching for for duplicated words ...")
  (push-mark)
@end group
@group
  ;; This regexp is not perfect
  ;; but is fairly good over all:
  (if (re-search-forward
       "\\b\\([^@@ \n\t]+\\)[ \n\t]+\\1\\b" nil 'move)
      (message "Found duplicated word.")
    (message "End of buffer")))
@end group

@group
;; Bind 'the-the' to  C-c \
(keymap-global-set "C-c \\" 'the-the)
@end group
@end smallexample

@sp 1
Here is test text:

@smallexample
@group
one two two three four five
five six seven
@end group
@end smallexample

You can substitute the other regular expressions shown above in the function
definition and try each of them on this list.

@node Killring
@appendix De killring hanteren
@cindex Kill ring handling
@cindex Handling the kill ring
@cindex Ring, making a list like a

The kill ring is a list that is transformed into a ring by the workings of
the @code{current-kill} function.  The @code{yank} and @code{yank-pop}
commands use the @code{current-kill} function.

This appendix describes the @code{current-kill} function as well as both the
@code{yank} and the @code{yank-pop} commands, but first, consider the
workings of the kill ring.

@menu
* Wat de killring doet::     Wat de killring doet
* current-kill::             current-kill
* yank::                     Plak een kopie van een afgeknipt element
* yank-pop::                 Element waar naar verwezen wordt invoegen.
* ring bestand::             ring bestand
@end menu

@ifnottex
@node Wat de killring doet
@unnumberedsec Wat de killring doet
@end ifnottex

@need 1250
The kill ring has a default maximum length of sixty items; this number is
too large for an explanation.  Instead, set it to four.  Please evaluate the
following:

@smallexample
@group
(setq old-kill-ring-max kill-ring-max)
(setq kill-ring-max 4)
@end group
@end smallexample

@noindent
Then, please copy each line of the following indented example into the kill
ring.  You may kill each line with @kbd{C-k} or mark it and copy it with
@kbd{M-w}.

@noindent
(In a read-only buffer, such as the @file{*info*} buffer, the kill command,
@kbd{C-k} (@code{kill-line}), will not remove the text, merely copy it to
the kill ring.  However, your machine may beep at you.  Alternatively, for
silence, you may copy the region of each line with the @kbd{M-w}
(@code{kill-ring-save}) command.  You must mark each line for this command
to succeed, but it does not matter at which end you put point or mark.)

@need 1250
@noindent
Please invoke the calls in order, so that five elements attempt to fill the
kill ring:

@smallexample
@group
first some text
second piece of text
third line
fourth line of text
fifth bit of text
@end group
@end smallexample

@need 1250
@noindent
Then find the value of @code{kill-ring} by evaluating

@smallexample
kill-ring
@end smallexample

@need 800
@noindent
It is:

@smallexample
@group
("fifth bit of text" "fourth line of text"
"third line" "second piece of text")
@end group
@end smallexample

@noindent
The first element, @samp{first some text}, was dropped.

@need 1250
To return to the old value for the length of the kill ring, evaluate:

@smallexample
(setq kill-ring-max old-kill-ring-max)
@end smallexample

@node current-kill
@appendixsec De @code{current-kill} functie
@findex current-kill

The @code{current-kill} function changes the element in the kill ring to
which @code{kill-ring-yank-pointer} points.  (Also, the @code{kill-new}
function sets @code{kill-ring-yank-pointer} to point to the latest element
of the kill ring.  The @code{kill-new} function is used directly or
indirectly by @code{kill-append}, @code{copy-region-as-kill},
@code{kill-ring-save}, @code{kill-line}, and @code{kill-region}.)

@menu
* Code voor current-kill::   Code voor current-kill
* current-kill begrijpen::   current-kill begrijpen
@end menu

@ifnottex
@node Code voor current-kill
@unnumberedsubsec The code for @code{current-kill}
@end ifnottex


@need 1500
The @code{current-kill} function is used by @code{yank} and by
@code{yank-pop}.  Here is the code for @code{current-kill}:

@smallexample
@group
(defun current-kill (n &optional do-not-move)
  "Rotate the yanking point by N places, and then return that kill.
If N is zero and `interprogram-paste-function' is set to a
function that returns a string or a list of strings, and if that
function doesn't return nil, then that string (or list) is added
to the front of the kill ring and the string (or first string in
the list) is returned as the latest kill.
@end group
@group
If N is not zero, and if `yank-pop-change-selection' is
non-nil, use `interprogram-cut-function' to transfer the
kill at the new yank point into the window system selection.
@end group
@group
If optional arg DO-NOT-MOVE is non-nil, then don't actually
move the yanking point; just return the Nth kill forward."

  (let ((interprogram-paste (and (= n 0)
                                 interprogram-paste-function
                                 (funcall interprogram-paste-function))))
@end group
@group
    (if interprogram-paste
        (progn
          ;; Disable the interprogram cut function when we add the new
          ;; text to the kill ring, so Emacs doesn't try to own the
          ;; selection, with identical text.
          (let ((interprogram-cut-function nil))
            (if (listp interprogram-paste)
              (mapc 'kill-new (nreverse interprogram-paste))
              (kill-new interprogram-paste)))
          (car kill-ring))
@end group
@group
      (or kill-ring (error "Kill ring is empty"))
      (let ((ARGth-kill-element
             (nthcdr (mod (- n (length kill-ring-yank-pointer))
                          (length kill-ring))
                     kill-ring)))
        (unless do-not-move
          (setq kill-ring-yank-pointer ARGth-kill-element)
          (when (and yank-pop-change-selection
                     (> n 0)
                     interprogram-cut-function)
            (funcall interprogram-cut-function (car ARGth-kill-element))))
        (car ARGth-kill-element)))))
@end group
@end smallexample

Remember also that the @code{kill-new} function sets
@code{kill-ring-yank-pointer} to the latest element of the kill ring, which
means that all the functions that call it set the value indirectly:
@code{kill-append}, @code{copy-region-as-kill}, @code{kill-ring-save},
@code{kill-line}, and @code{kill-region}.

@need 1500
Here is the line in @code{kill-new}, which is explained in @ref{kill-new
function, , The @code{kill-new} function}.

@smallexample
(setq kill-ring-yank-pointer kill-ring)
@end smallexample

@ifnottex
@node current-kill begrijpen
@unnumberedsubsec Overzicht @code{current-kill}
@end ifnottex

The @code{current-kill} function looks complex, but as usual, it can be
understood by taking it apart piece by piece.  First look at it in skeletal
form:

@smallexample
@group
(defun current-kill (n &optional do-not-move)
  "Rotate the yanking point by N places, and then return that kill."
  (let @var{varlist}
    @var{body}@dots{})
@end group
@end smallexample

This function takes two arguments, one of which is optional.  It has a
documentation string.  It is @emph{not} interactive.

@menu
* Body van current-kill::    Body van current-kill
* Uitwijding over fout::     Hoe mensen te misleiden, maar niet computers.
* Het element vaststellen::  Het element vaststellen
@end menu

@ifnottex
@node Body van current-kill
@unnumberedsubsubsec The Body of @code{current-kill}
@end ifnottex

The body of the function definition is a @code{let} expression, which itself
has a body as well as a @var{varlist}.

The @code{let} expression declares a variable that will be only usable
within the bounds of this function.  This variable is called
@code{interprogram-paste} and is for copying to another program.  It is not
for copying within this instance of GNU Emacs.  Most window systems provide
a facility for interprogram pasting.  Sadly, that facility usually provides
only for the last element.  Most windowing systems have not adopted a ring
of many possibilities, even though Emacs has provided it for decades.

The @code{if} expression has two parts, one if there exists
@code{interprogram-paste} and one if not.

@need 2000
Laat ons het else-gedeelte van de @code{current-kill} functie
beschouwen. (Het then-gedeelte gebruikt de @code{kill-new} functie, die we
al eerder hebben beschreven. @xref{kill-new functie, , De @code{kill-new}
functie}.)

@smallexample
@group
(or kill-ring (error "Kill ring is empty"))
(let ((ARGth-kill-element
       (nthcdr (mod (- n (length kill-ring-yank-pointer))
                    (length kill-ring))
               kill-ring)))
  (or do-not-move
      (setq kill-ring-yank-pointer ARGth-kill-element))
  (car ARGth-kill-element))
@end group
@end smallexample

@noindent
The code first checks whether the kill ring has content; otherwise it
signals an error.

@need 1000
Note that the @code{or} expression is very similar to testing length with an
@code{if}:

@findex zerop
@findex error
@smallexample
@group
(if (zerop (length kill-ring))          ; @r{if-part}
    (error "Kill ring is empty"))       ; @r{then-part}
  ;; No else-part
@end group
@end smallexample

@noindent
If there is not anything in the kill ring, its length must be zero and an
error message sent to the user: @samp{Kill ring is empty}.  The
@code{current-kill} function uses an @code{or} expression which is simpler.
But an @code{if} expression reminds us what goes on.

This @code{if} expression uses the function @code{zerop} which returns true
if the value it is testing is zero.  When @code{zerop} tests true, the
then-part of the @code{if} is evaluated.  The then-part is a list starting
with the function @code{error}, which is a function that is similar to the
@code{message} function (@pxref{message, , The @code{message} Function}) in
that it prints a one-line message in the echo area.  However, in addition to
printing a message, @code{error} also stops evaluation of the function
within which it is embedded.  This means that the rest of the function will
not be evaluated if the length of the kill ring is zero.

Then the @code{current-kill} function selects the element to return.  The
selection depends on the number of places that @code{current-kill} rotates
and on where @code{kill-ring-yank-pointer} points.

Next, either the optional @code{do-not-move} argument is true or the current
value of @code{kill-ring-yank-pointer} is set to point to the list.
Finally, another expression returns the first element of the list even if
the @code{do-not-move} argument is true.

@ifnottex
@node Uitwijding over fout
@unnumberedsubsubsec Digression about the word ``error''
@end ifnottex

In my opinion, it is slightly misleading, at least to humans, to use the
term ``error'' as the name of the @code{error} function.  A better term
would be ``cancel''.  Strictly speaking, of course, you cannot point to,
much less rotate a pointer to a list that has no length, so from the point
of view of the computer, the word ``error'' is correct.  But a human expects
to attempt this sort of thing, if only to find out whether the kill ring is
full or empty.  This is an act of exploration.

From the human point of view, the act of exploration and discovery is not
necessarily an error, and therefore should not be labeled as one, even in
the bowels of a computer.  As it is, the code in Emacs implies that a human
who is acting virtuously, by exploring his or her environment, is making an
error.  This is bad.  Even though the computer takes the same steps as it
does when there is an error, a term such as ``cancel'' would have a clearer
connotation.

@ifnottex
@node Het element vaststellen
@unnumberedsubsubsec Het element vaststellen
@end ifnottex

Among other actions, the else-part of the @code{if} expression sets the
value of @code{kill-ring-yank-pointer} to @code{ARGth-kill-element} when the
kill ring has something in it and the value of @code{do-not-move} is
@code{nil}.

@need 800
De code ziet er zo uit:

@smallexample
@group
(nthcdr (mod (- n (length kill-ring-yank-pointer))
             (length kill-ring))
        kill-ring)))
@end group
@end smallexample

This needs some examination.  Unless it is not supposed to move the pointer,
the @code{current-kill} function changes where @code{kill-ring-yank-pointer}
points.  That is what the @w{@code{(setq kill-ring-yank-pointer
ARGth-kill-element))}} expression does.  Also, clearly,
@code{ARGth-kill-element} is being set to be equal to some @sc{cdr} of the
kill ring, using the @code{nthcdr} function that is described in an earlier
section.  (@xref{copy-region-as-kill}.)  How does it do this?

As we have seen before (@pxref{nthcdr}), the @code{nthcdr} function works by
repeatedly taking the @sc{cdr} of a list---it takes the @sc{cdr} of the
@sc{cdr} of the @sc{cdr} @dots{}

@need 800
The two following expressions produce the same result:

@smallexample
@group
(setq kill-ring-yank-pointer (cdr kill-ring))

(setq kill-ring-yank-pointer (nthcdr 1 kill-ring))
@end group
@end smallexample

However, the @code{nthcdr} expression is more complicated.  It uses the
@code{mod} function to determine which @sc{cdr} to select.

(You will remember to look at inner functions first; indeed, we will have to
go inside the @code{mod}.)

The @code{mod} function returns the value of its first argument modulo the
second; that is to say, it returns the remainder after dividing the first
argument by the second.  The value returned has the same sign as the second
argument.

@need 800
Thus,

@smallexample
@group
(mod 12 4)
  @result{} 0  ;; @r{because there is no remainder}
(mod 13 4)
  @result{} 1
@end group
@end smallexample

@need 1250
In this case, the first argument is often smaller than the second.  That is
fine.

@smallexample
@group
(mod 0 4)
  @result{} 0
(mod 1 4)
  @result{} 1
@end group
@end smallexample

We can guess what the @code{-} function does.  It is like @code{+} but
subtracts instead of adds; the @code{-} function subtracts its second
argument from its first.  Also, we already know what the @code{length}
function does (@pxref{length}).  It returns the length of a list.

And @code{n} is the name of the required argument to the @code{current-kill}
function.

@need 1250
So when the first argument to @code{nthcdr} is zero, the @code{nthcdr}
expression returns the whole list, as you can see by evaluating the
following:

@smallexample
@group
;; kill-ring-yank-pointer @r{and} kill-ring @r{have a length of four}
;; @r{and} (mod (- 0 4) 4) @result{} 0
(nthcdr (mod (- 0 4) 4)
        '("fourth line of text"
          "third line"
          "second piece of text"
          "first some text"))
@end group
@end smallexample

@need 1250
When the first argument to the @code{current-kill} function is one, the
@code{nthcdr} expression returns the list without its first element.

@smallexample
@group
(nthcdr (mod (- 1 4) 4)
        '("fourth line of text"
          "third line"
          "second piece of text"
          "first some text"))
@end group
@end smallexample

@cindex @samp{global variable} defined
@cindex @samp{variable, global}, defined
Incidentally, both @code{kill-ring} and @code{kill-ring-yank-pointer} are
@dfn{global variables}.  That means that any expression in Emacs Lisp can
access them.  They are not like the local variables set by @code{let} or
like the symbols in an argument list.  Local variables can only be accessed
within the @code{let} that defines them or the function that specifies them
in an argument list (and within expressions called by them).

@c texi2dvi fails when the name of the section is within ifnottex ...
@ifnottex
(@xref{Prevent confusion, , @code{let} Prevents Confusion}, and
@end ifnottex
@iftex
(@xref{Permanent Installation, , @code{let} Prevents Confusion}, and
@end iftex
@ref{defun, , The @code{defun} Macro}.)

@node yank
@appendixsec @code{yank}
@findex yank

After learning about @code{current-kill}, the code for the @code{yank}
function is almost easy.

The @code{yank} function does not use the @code{kill-ring-yank-pointer}
variable directly.  It calls @code{insert-for-yank} which calls
@code{current-kill} which sets the @code{kill-ring-yank-pointer} variable.

@need 1250
De code ziet er zo uit:

@c in GNU Emacs 22
@smallexample
@group
(defun yank (&optional arg)
  "Reinsert (\"paste\") the last stretch of killed text.
More precisely, reinsert the stretch of killed text most recently
killed OR yanked.  Put point at end, and set mark at beginning.
With just \\[universal-argument] as argument, same but put point at beginning (and mark at end).
With argument N, reinsert the Nth most recently killed stretch of killed
text.

When this command inserts killed text into the buffer, it honors
`yank-excluded-properties' and `yank-handler' as described in the
doc string for `insert-for-yank-1', which see.

See also the command `yank-pop' (\\[yank-pop])."
@end group
@group
  (interactive "*P")
  (setq yank-window-start (window-start))
  ;; If we don't get all the way thru, make last-command indicate that
  ;; for the following command.
  (setq this-command t)
  (push-mark (point))
@end group
@group
  (insert-for-yank (current-kill (cond
                                  ((listp arg) 0)
                                  ((eq arg '-) -2)
                                  (t (1- arg)))))
  (if (consp arg)
      ;; This is like exchange-point-and-mark, but doesn't activate the mark.
      ;; It is cleaner to avoid activation, even though the command
      ;; loop would deactivate the mark because we inserted text.
      (goto-char (prog1 (mark t)
                   (set-marker (mark-marker) (point) (current-buffer)))))
@end group
@group
  ;; If we do get all the way thru, make this-command indicate that.
  (if (eq this-command t)
      (setq this-command 'yank))
  nil)
@end group
@end smallexample

The key expression is @code{insert-for-yank}, which inserts the string
returned by @code{current-kill}, but removes some text properties from it.

However, before getting to that expression, the function sets the value of
@code{yank-window-start} to the position returned by the
@code{(window-start)} expression, the position at which the display
currently starts.  The @code{yank} function also sets @code{this-command}
and pushes the mark.

After it yanks the appropriate element, if the optional argument is a
@sc{cons} rather than a number or nothing, it puts point at beginning of the
yanked text and mark at its end.

(The @code{prog1} function is like @code{progn} but returns the value of its
first argument rather than the value of its last argument.  Its first
argument is forced to return the buffer's mark as an integer.  You can see
the documentation for these functions by placing point over them in this
buffer and then typing @kbd{C-h f} (@code{describe-function}) followed by a
@kbd{RET}; the default is the function.)

The last part of the function tells what to do when it succeeds.

@node yank-pop
@appendixsec @code{yank-pop}
@findex yank-pop

After understanding @code{yank} and @code{current-kill}, you know how to
approach the @code{yank-pop} function.  Leaving out the documentation to
save space, it looks like this:

@c GNU Emacs 22
@smallexample
@group
(defun yank-pop (&optional arg)
  "@dots{}"
  (interactive "*p")
  (if (not (eq last-command 'yank))
      (error "Previous command was not a yank"))
@end group
@group
  (setq this-command 'yank)
  (unless arg (setq arg 1))
  (let ((inhibit-read-only t)
        (before (< (point) (mark t))))
@end group
@group
    (if before
        (funcall (or yank-undo-function 'delete-region) (point) (mark t))
      (funcall (or yank-undo-function 'delete-region) (mark t) (point)))
    (setq yank-undo-function nil)
@end group
@group
    (set-marker (mark-marker) (point) (current-buffer))
    (insert-for-yank (current-kill arg))
    ;; Set the window start back where it was in the yank command,
    ;; if possible.
    (set-window-start (selected-window) yank-window-start t)
@end group
@group
    (if before
        ;; This is like exchange-point-and-mark,
        ;;     but doesn't activate the mark.
        ;; It is cleaner to avoid activation, even though the command
        ;; loop would deactivate the mark because we inserted text.
        (goto-char (prog1 (mark t)
                     (set-marker (mark-marker)
                                 (point)
                                 (current-buffer))))))
  nil)
@end group
@end smallexample

The function is interactive with a small @samp{p} so the prefix argument is
processed and passed to the function.  The command can only be used after a
previous yank; otherwise an error message is sent.  This check uses the
variable @code{last-command} which is set by @code{yank} and is discussed
elsewhere.  (@xref{copy-region-as-kill}.)

The @code{let} clause sets the variable @code{before} to true or false
depending whether point is before or after mark and then the region between
point and mark is deleted.  This is the region that was just inserted by the
previous yank and it is this text that will be replaced.

@code{funcall} calls its first argument as a function, passing remaining
arguments to it.  The first argument is whatever the @code{or} expression
returns.  The two remaining arguments are the positions of point and mark
set by the preceding @code{yank} command.

There is more, but that is the hardest part.

@node ring bestand
@appendixsec The @file{ring.el} File
@cindex @file{ring.el} file

Interestingly, GNU Emacs possesses a file called @file{ring.el} that
provides many of the features we just discussed.  But functions such as
@code{kill-ring-yank-pointer} do not use this library, possibly because they
were written earlier.

@node Volledige grafiek
@appendix Een grafiek met labels op de assen

Printed axes help you understand a graph.  They convey scale.  In an earlier
chapter (@pxref{Readying a Graph, , Readying a Graph}), we wrote the code to
print the body of a graph.  Here we write the code for printing and labeling
vertical and horizontal axes, along with the body itself.

@menu
* Gelabeld voorbeeld::       Gelabeld voorbeeld
* print-graph varlist::      @code{let} expressie in @code{print-graph}
* print-Y-axis::             Print een label voor de verticale as
* print-X-axis::             Print een horizontaal label
* De gehele grafiek afdrukken::  De functie om een hele grafiek te printen.
@end menu

@ifnottex
@node Gelabeld voorbeeld
@unnumberedsec Labeled Example Graph
@end ifnottex

Since insertions fill a buffer to the right and below point, the new graph
printing function should first print the Y or vertical axis, then the body
of the graph, and finally the X or horizontal axis.  This sequence lays out
for us the contents of the function:

@enumerate
@item
Set up code.

@item
Print Y axis.

@item
Print body of graph.

@item
Print X axis.
@end enumerate

@need 800
Here is an example of how a finished graph should look:

@smallexample
@group
    10 -
                  *
                  *  *
                  *  **
                  *  ***
     5 -      *   *******
            * *** *******
            *************
          ***************
     1 - ****************
         |   |    |    |
         1   5   10   15
@end group
@end smallexample

@noindent
In this graph, both the vertical and the horizontal axes are labeled with
numbers.  However, in some graphs, the horizontal axis is time and would be
better labeled with months, like this:

@smallexample
@group
     5 -      *
            * ** *
            *******
          ********** **
     1 - **************
         |    ^      |
         Jan  June   Jan
@end group
@end smallexample

Indeed, with a little thought, we can easily come up with a variety of
vertical and horizontal labeling schemes.  Our task could become
complicated.  But complications breed confusion.  Rather than permit this,
it is better choose a simple labeling scheme for our first effort, and to
modify or replace it later.

@need 1200
These considerations suggest the following outline for the
@code{print-graph} function:

@smallexample
@group
(defun print-graph (numbers-list)
  "@var{documentation}@dots{}"
  (let ((height  @dots{}
        @dots{}))
@end group
@group
    (print-Y-axis height @dots{} )
    (graph-body-print numbers-list)
    (print-X-axis @dots{} )))
@end group
@end smallexample

We can work on each part of the @code{print-graph} function definition in
turn.

@node print-graph varlist
@appendixsec The @code{print-graph} Varlist
@cindex @code{print-graph} varlist

In writing the @code{print-graph} function, the first task is to write the
varlist in the @code{let} expression.  (We will leave aside for the moment
any thoughts about making the function interactive or about the contents of
its documentation string.)

The varlist should set several values.  Clearly, the top of the label for
the vertical axis must be at least the height of the graph, which means that
we must obtain this information here.  Note that the @code{print-graph-body}
function also requires this information.  There is no reason to calculate
the height of the graph in two different places, so we should change
@code{print-graph-body} from the way we defined it earlier to take advantage
of the calculation.

Similarly, both the function for printing the X axis labels and the
@code{print-graph-body} function need to learn the value of the width of
each symbol.  We can perform the calculation here and change the definition
for @code{print-graph-body} from the way we defined it in the previous
chapter.

The length of the label for the horizontal axis must be at least as long as
the graph.  However, this information is used only in the function that
prints the horizontal axis, so it does not need to be calculated here.

These thoughts lead us directly to the following form for the varlist in the
@code{let} for @code{print-graph}:

@smallexample
@group
(let ((height (apply 'max numbers-list)) ; @r{First version.}
      (symbol-width (length graph-blank)))
@end group
@end smallexample

@noindent
As we shall see, this expression is not quite right.

@need 2000
@node print-Y-axis
@appendixsec De @code{print-Y-axis} functie
@cindex Axis, print vertical
@cindex Y axis printing
@cindex Vertical axis printing
@cindex Print vertical axis

The job of the @code{print-Y-axis} function is to print a label for the
vertical axis that looks like this:

@smallexample
@group
    10 -




     5 -



     1 -
@end group
@end smallexample

@noindent
The function should be passed the height of the graph, and then should
construct and insert the appropriate numbers and marks.

@menu
* print-Y-axis in detail::   print-Y-axis in detail
* Hoogte van label::         Welke hoogte voor de Y-as?
* Bereken het restant::      Hoe het restant van een deling te berekenen.
* Y-as element::             Een lijn voor de y-as construeren.
* Y-axis-column::            Een lijst van y-as labels genereren.
* print-Y-axis enalaatste::  Nog niet finale versie
@end menu

@ifnottex
@node print-Y-axis in detail
@unnumberedsubsec The @code{print-Y-axis} Function in Detail
@end ifnottex

It is easy enough to see in the figure what the Y axis label should look
like; but to say in words, and then to write a function definition to do the
job is another matter.  It is not quite true to say that we want a number
and a tic every five lines: there are only three lines between the @samp{1}
and the @samp{5} (lines 2, 3, and 4), but four lines between the @samp{5}
and the @samp{10} (lines 6, 7, 8, and 9).  It is better to say that we want
a number and a tic mark on the base line (number 1) and then that we want a
number and a tic on the fifth line from the bottom and on every line that is
a multiple of five.

@ifnottex
@node Hoogte van label
@unnumberedsubsec What height should the label be?
@end ifnottex

The next issue is what height the label should be? Suppose the maximum
height of tallest column of the graph is seven.  Should the highest label on
the Y axis be @samp{5 -}, and should the graph stick up above the label? Or
should the highest label be @samp{7 -}, and mark the peak of the graph? Or
should the highest label be @code{10 -}, which is a multiple of five, and be
higher than the topmost value of the graph?

The latter form is preferred.  Most graphs are drawn within rectangles whose
sides are an integral number of steps long---5, 10, 15, and so on for a step
distance of five.  But as soon as we decide to use a step height for the
vertical axis, we discover that the simple expression in the varlist for
computing the height is wrong.  The expression is @code{(apply 'max
numbers-list)}.  This returns the precise height, not the maximum height
plus whatever is necessary to round up to the nearest multiple of five.  A
more complex expression is required.

As usual in cases like this, a complex problem becomes simpler if it is
divided into several smaller problems.

First, consider the case when the highest value of the graph is an integral
multiple of five---when it is 5, 10, 15, or some higher multiple of five.
We can use this value as the Y axis height.

A fairly simply way to determine whether a number is a multiple of five is
to divide it by five and see if the division results in a remainder.  If
there is no remainder, the number is a multiple of five.  Thus, seven
divided by five has a remainder of two, and seven is not an integral
multiple of five.  Put in slightly different language, more reminiscent of
the classroom, five goes into seven once, with a remainder of two.  However,
five goes into ten twice, with no remainder: ten is an integral multiple of
five.

@node Bereken het restant
@appendixsubsec Side Trip: Compute a Remainder

@findex % @r{(remainder function)}
@cindex Remainder function, @code{%}
In Lisp, the function for computing a remainder is @code{%}.  The function
returns the remainder of its first argument divided by its second argument.
As it happens, @code{%} is a function in Emacs Lisp that you cannot discover
using @code{apropos}: you find nothing if you type @kbd{M-x apropos
@key{RET} remainder @key{RET}}.  The only way to learn of the existence of
@code{%} is to read about it in a book such as this or in the Emacs Lisp
sources.

You can try the @code{%} function by evaluating the following two
expressions:

@smallexample
@group
(% 7 5)

(% 10 5)
@end group
@end smallexample

@noindent
The first expression returns 2 and the second expression returns 0.

To test whether the returned value is zero or some other number, we can use
the @code{zerop} function.  This function returns @code{t} if its argument,
which must be a number, is zero.

@smallexample
@group
(zerop (% 7 5))
     @result{} nil

(zerop (% 10 5))
     @result{} t
@end group
@end smallexample

Thus, the following expression will return @code{t} if the height of the
graph is evenly divisible by five:

@smallexample
(zerop (% height 5))
@end smallexample

@noindent
(The value of @code{height}, of course, can be found from @code{(apply 'max
numbers-list)}.)

On the other hand, if the value of @code{height} is not a multiple of five,
we want to reset the value to the next higher multiple of five.  This is
straightforward arithmetic using functions with which we are already
familiar.  First, we divide the value of @code{height} by five to determine
how many times five goes into the number.  Thus, five goes into twelve
twice.  If we add one to this quotient and multiply by five, we will obtain
the value of the next multiple of five that is larger than the height.  Five
goes into twelve twice.  Add one to two, and multiply by five; the result is
fifteen, which is the next multiple of five that is higher than twelve.  The
Lisp expression for this is:

@smallexample
(* (1+ (/ height 5)) 5)
@end smallexample

@noindent
For example, if you evaluate the following, the result is 15:

@smallexample
(* (1+ (/ 12 5)) 5)
@end smallexample

All through this discussion, we have been using 5 as the value for spacing
labels on the Y axis; but we may want to use some other value.  For
generality, we should replace 5 with a variable to which we can assign a
value.  The best name I can think of for this variable is
@code{Y-axis-label-spacing}.

@need 1250
Using this term, and an @code{if} expression, we produce the following:

@smallexample
@group
(if (zerop (% height Y-axis-label-spacing))
    height
  ;; @r{else}
  (* (1+ (/ height Y-axis-label-spacing))
     Y-axis-label-spacing))
@end group
@end smallexample

@noindent
This expression returns the value of @code{height} itself if the height is
an even multiple of the value of the @code{Y-axis-label-spacing} or else it
computes and returns a value of @code{height} that is equal to the next
higher multiple of the value of the @code{Y-axis-label-spacing}.

We can now include this expression in the @code{let} expression of the
@code{print-graph} function (after first setting the value of
@code{Y-axis-label-spacing}):
@vindex Y-axis-label-spacing

@smallexample
@group
(defvar Y-axis-label-spacing 5
  "Number of lines from one Y axis label to next.")
@end group

@group
@dots{}
(let* ((height (apply 'max numbers-list))
       (height-of-top-line
        (if (zerop (% height Y-axis-label-spacing))
            height
@end group
@group
          ;; @r{else}
          (* (1+ (/ height Y-axis-label-spacing))
             Y-axis-label-spacing)))
       (symbol-width (length graph-blank))))
@dots{}
@end group
@end smallexample

@noindent
(Note use of the @code{let*} function: the initial value of height is
computed once by the @code{(apply 'max numbers-list)} expression and then
the resulting value of @code{height} is used to compute its final value.
@xref{fwd-para let, , The @code{let*} expression}, for more about
@code{let*}.)

@node Y-as element
@appendixsubsec Construct a Y Axis Element

When we print the vertical axis, we want to insert strings such as
@w{@samp{5 -}} and @w{@samp{10 - }} every five lines.  Moreover, we want the
numbers and dashes to line up, so shorter numbers must be padded with
leading spaces.  If some of the strings use two digit numbers, the strings
with single digit numbers must include a leading blank space before the
number.

@findex number-to-string
To figure out the length of the number, the @code{length} function is used.
But the @code{length} function works only with a string, not with a number.
So the number has to be converted from being a number to being a string.
This is done with the @code{number-to-string} function.  For example,

@smallexample
@group
(length (number-to-string 35))
     @result{} 2

(length (number-to-string 100))
     @result{} 3
@end group
@end smallexample

@noindent
(@code{number-to-string} is also called @code{int-to-string}; you will see
this alternative name in various sources.)

In addition, in each label, each number is followed by a string such as
@w{@samp{ - }}, which we will call the @code{Y-axis-tic} marker.  This
variable is defined with @code{defvar}:

@vindex Y-axis-tic
@smallexample
@group
(defvar Y-axis-tic " - "
   "String that follows number in a Y axis label.")
@end group
@end smallexample

The length of the Y label is the sum of the length of the Y axis tic mark
and the length of the number of the top of the graph.

@smallexample
(length (concat (number-to-string height) Y-axis-tic)))
@end smallexample

This value will be calculated by the @code{print-graph} function in its
varlist as @code{full-Y-label-width} and passed on.  (Note that we did not
think to include this in the varlist when we first proposed it.)

To make a complete vertical axis label, a tic mark is concatenated with a
number; and the two together may be preceded by one or more spaces depending
on how long the number is.  The label consists of three parts: the
(optional) leading spaces, the number, and the tic mark.  The function is
passed the value of the number for the specific row, and the value of the
width of the top line, which is calculated (just once) by
@code{print-graph}.

@smallexample
@group
(defun Y-axis-element (number full-Y-label-width)
  "Construct a NUMBERed label element.
A numbered element looks like this `  5 - ',
and is padded as needed so all line up with
the element for the largest number."
@end group
@group
  (let* ((leading-spaces
         (- full-Y-label-width
            (length
             (concat (number-to-string number)
                     Y-axis-tic)))))
@end group
@group
    (concat
     (make-string leading-spaces ? )
     (number-to-string number)
     Y-axis-tic)))
@end group
@end smallexample

The @code{Y-axis-element} function concatenates together the leading spaces,
if any; the number, as a string; and the tic mark.

To figure out how many leading spaces the label will need, the function
subtracts the actual length of the label---the length of the number plus the
length of the tic mark---from the desired label width.

@findex make-string
Blank spaces are inserted using the @code{make-string} function.  This
function takes two arguments: the first tells it how long the string will be
and the second is a symbol for the character to insert, in a special
format.  The format is a question mark followed by a blank space, like this,
@samp{? }.  @xref{Character Type, , Character Type, elisp, The GNU Emacs
Lisp Reference Manual}, for a description of the syntax for characters.  (Of
course, you might want to replace the blank space by some other character
@dots{} You know what to do.)

The @code{number-to-string} function is used in the concatenation
expression, to convert the number to a string that is concatenated with the
leading spaces and the tic mark.

@node Y-axis-column
@appendixsubsec Create a Y Axis Column

The preceding functions provide all the tools needed to construct a function
that generates a list of numbered and blank strings to insert as the label
for the vertical axis:

@findex Y-axis-column
@smallexample
@group
(defun Y-axis-column (height width-of-label)
  "Construct list of Y axis labels and blank strings.
For HEIGHT of line above base and WIDTH-OF-LABEL."
  (let (Y-axis)
@group
@end group
    (while (> height 1)
      (if (zerop (% height Y-axis-label-spacing))
          ;; @r{Insert label.}
          (setq Y-axis
                (cons
                 (Y-axis-element height width-of-label)
                 Y-axis))
@group
@end group
        ;; @r{Else, insert blanks.}
        (setq Y-axis
              (cons
               (make-string width-of-label ? )
               Y-axis)))
      (setq height (1- height)))
    ;; @r{Insert base line.}
    (setq Y-axis
          (cons (Y-axis-element 1 width-of-label) Y-axis))
    (nreverse Y-axis)))
@end group
@end smallexample

In this function, we start with the value of @code{height} and repetitively
subtract one from its value.  After each subtraction, we test to see whether
the value is an integral multiple of the @code{Y-axis-label-spacing}.  If it
is, we construct a numbered label using the @code{Y-axis-element} function;
if not, we construct a blank label using the @code{make-string} function.
The base line consists of the number one followed by a tic mark.

@need 2000
@node print-Y-axis enalaatste
@appendixsubsec The Not Quite Final Version of @code{print-Y-axis}

The list constructed by the @code{Y-axis-column} function is passed to the
@code{print-Y-axis} function, which inserts the list as a column.

@findex print-Y-axis
@smallexample
@group
(defun print-Y-axis (height full-Y-label-width)
  "Insert Y axis using HEIGHT and FULL-Y-LABEL-WIDTH.
Height must be the maximum height of the graph.
Full width is the width of the highest label element."
;; Value of height and full-Y-label-width
;; are passed by print-graph.
@end group
@group
  (let ((start (point)))
    (insert-rectangle
     (Y-axis-column height full-Y-label-width))
    ;; @r{Place point ready for inserting graph.}
    (goto-char start)
    ;; @r{Move point forward by value of} full-Y-label-width
    (forward-char full-Y-label-width)))
@end group
@end smallexample

The @code{print-Y-axis} uses the @code{insert-rectangle} function to insert
the Y axis labels created by the @code{Y-axis-column} function.  In
addition, it places point at the correct position for printing the body of
the graph.

You can test @code{print-Y-axis}:

@enumerate
@item
Installeer

@smallexample
@group
Y-axis-label-spacing
Y-axis-tic
Y-axis-element
Y-axis-column
print-Y-axis
@end group
@end smallexample

@item
Copy the following expression:

@smallexample
(print-Y-axis 12 5)
@end smallexample

@item
Switch to the @file{*scratch*} buffer and place the cursor where you want
the axis labels to start.

@item
Type @kbd{M-:} (@code{eval-expression}).

@item
Yank the @code{graph-body-print} expression into the minibuffer with
@kbd{C-y} (@code{yank)}.

@item
Press @key{RET} to evaluate the expression.
@end enumerate

Emacs will print labels vertically, the top one being @w{@samp{10 -@w{ }}}.
(The @code{print-graph} function will pass the value of
@code{height-of-top-line}, which in this case will end up as 15, thereby
getting rid of what might appear as a bug.)

@need 2000
@node print-X-axis
@appendixsec De @code{print-X-axis} functie
@cindex Axis, print horizontal
@cindex X axis printing
@cindex Print horizontal axis
@cindex Horizontal axis printing

X axis labels are much like Y axis labels, except that the ticks are on a
line above the numbers.  Labels should look like this:

@smallexample
@group
    |   |    |    |
    1   5   10   15
@end group
@end smallexample

The first tic is under the first column of the graph and is preceded by
several blank spaces.  These spaces provide room in rows above for the Y
axis labels.  The second, third, fourth, and subsequent ticks are all spaced
equally, according to the value of @code{X-axis-label-spacing}.

The second row of the X axis consists of numbers, preceded by several blank
spaces and also separated according to the value of the variable
@code{X-axis-label-spacing}.

The value of the variable @code{X-axis-label-spacing} should itself be
measured in units of @code{symbol-width}, since you may want to change the
width of the symbols that you are using to print the body of the graph
without changing the ways the graph is labeled.

@menu
* Overeenkomsten verschillen::  Grotendeels als @code{print-Y-axis}, maar 
                                  niet helemaal gelijk.
* X-as tic marks::           Maak tic marks voor de horizontale as.
@end menu

@ifnottex
@node Overeenkomsten verschillen
@unnumberedsubsec Similarities and differences
@end ifnottex

The @code{print-X-axis} function is constructed in more or less the same
fashion as the @code{print-Y-axis} function except that it has two lines:
the line of tic marks and the numbers.  We will write a separate function to
print each line and then combine them within the @code{print-X-axis}
function.

This is a three step process:

@enumerate
@item
Write a function to print the X axis tic marks,
@code{print-X-axis-tic-line}.

@item
Write a function to print the X numbers, @code{print-X-axis-numbered-line}.

@item
Write a function to print both lines, the @code{print-X-axis} function,
using @code{print-X-axis-tic-line} and @code{print-X-axis-numbered-line}.
@end enumerate

@node X-as tic marks
@appendixsubsec X-as tic marks

The first function should print the X axis tic marks.  We must specify the
tic marks themselves and their spacing:

@smallexample
@group
(defvar X-axis-label-spacing
  (if (boundp 'graph-blank)
      (* 5 (length graph-blank)) 5)
  "Number of units from one X axis label to next.")
@end group
@end smallexample

@noindent
(Note that the value of @code{graph-blank} is set by another @code{defvar}.
The @code{boundp} predicate checks whether it has already been set;
@code{boundp} returns @code{nil} if it has not.  If @code{graph-blank} were
unbound and we did not use this conditional construction, we would enter the
debugger and see an error message saying @samp{@w{Debugger entered--Lisp
error:} @w{(void-variable graph-blank)}}.)

@need 1200
Here is the @code{defvar} for @code{X-axis-tic-symbol}:

@smallexample
@group
(defvar X-axis-tic-symbol "|"
  "String to insert to point to a column in X axis.")
@end group
@end smallexample

@need 1250
The goal is to make a line that looks like this:

@smallexample
       |   |    |    |
@end smallexample

The first tic is indented so that it is under the first column, which is
indented to provide space for the Y axis labels.

A tic element consists of the blank spaces that stretch from one tic to the
next plus a tic symbol.  The number of blanks is determined by the width of
the tic symbol and the @code{X-axis-label-spacing}.

@need 1250
De code ziet er zo uit:

@smallexample
@group
;;; X-axis-tic-element
@dots{}
(concat
 (make-string
  ;; @r{Make a string of blanks.}
  (-  (* symbol-width X-axis-label-spacing)
      (length X-axis-tic-symbol))
  ? )
 ;; @r{Concatenate blanks with tic symbol.}
 X-axis-tic-symbol)
@dots{}
@end group
@end smallexample

Next, we determine how many blanks are needed to indent the first tic mark
to the first column of the graph.  This uses the value of
@code{full-Y-label-width} passed it by the @code{print-graph} function.

@need 1250
The code to make @code{X-axis-leading-spaces} looks like this:

@smallexample
@group
;; X-axis-leading-spaces
@dots{}
(make-string full-Y-label-width ? )
@dots{}
@end group
@end smallexample

We also need to determine the length of the horizontal axis, which is the
length of the numbers list, and the number of ticks in the horizontal axis:

@smallexample
@group
;; X-length
@dots{}
(length numbers-list)
@end group

@group
;; tic-width
@dots{}
(* symbol-width X-axis-label-spacing)
@end group

@group
;; number-of-X-ticks
(if (zerop (% (X-length tic-width)))
    (/ (X-length tic-width))
  (1+ (/ (X-length tic-width))))
@end group
@end smallexample

@need 1250
All this leads us directly to the function for printing the X axis tic line:

@findex print-X-axis-tic-line
@smallexample
@group
(defun print-X-axis-tic-line
  (number-of-X-tics X-axis-leading-spaces X-axis-tic-element)
  "Print ticks for X axis."
    (insert X-axis-leading-spaces)
    (insert X-axis-tic-symbol)  ; @r{Under first column.}
@end group
@group
    ;; @r{Insert second tic in the right spot.}
    (insert (concat
             (make-string
              (-  (* symbol-width X-axis-label-spacing)
                  ;; @r{Insert white space up to second tic symbol.}
                  (* 2 (length X-axis-tic-symbol)))
              ? )
             X-axis-tic-symbol))
@end group
@group
    ;; @r{Insert remaining ticks.}
    (while (> number-of-X-tics 1)
      (insert X-axis-tic-element)
      (setq number-of-X-tics (1- number-of-X-tics))))
@end group
@end smallexample

The line of numbers is equally straightforward:

@need 1250
First, we create a numbered element with blank spaces before each number:

@findex X-axis-element
@smallexample
@group
(defun X-axis-element (number)
  "Construct a numbered X axis element."
  (let ((leading-spaces
         (-  (* symbol-width X-axis-label-spacing)
             (length (number-to-string number)))))
    (concat (make-string leading-spaces ? )
            (number-to-string number))))
@end group
@end smallexample

Next, we create the function to print the numbered line, starting with the
number 1 under the first column:

@findex print-X-axis-numbered-line
@smallexample
@group
(defun print-X-axis-numbered-line
  (number-of-X-tics X-axis-leading-spaces)
  "Print line of X-axis numbers"
  (let ((number X-axis-label-spacing))
    (insert X-axis-leading-spaces)
    (insert "1")
@end group
@group
    (insert (concat
             (make-string
              ;; @r{Insert white space up to next number.}
              (-  (* symbol-width X-axis-label-spacing) 2)
              ? )
             (number-to-string number)))
@end group
@group
    ;; @r{Insert remaining numbers.}
    (setq number (+ number X-axis-label-spacing))
    (while (> number-of-X-tics 1)
      (insert (X-axis-element number))
      (setq number (+ number X-axis-label-spacing))
      (setq number-of-X-tics (1- number-of-X-tics)))))
@end group
@end smallexample

Finally, we need to write the @code{print-X-axis} that uses
@code{print-X-axis-tic-line} and @code{print-X-axis-numbered-line}.

The function must determine the local values of the variables used by both
@code{print-X-axis-tic-line} and @code{print-X-axis-numbered-line}, and then
it must call them.  Also, it must print the carriage return that separates
the two lines.

The function consists of a varlist that specifies five local variables, and
calls to each of the two line printing functions:

@findex print-X-axis
@smallexample
@group
(defun print-X-axis (numbers-list)
  "Print X axis labels to length of NUMBERS-LIST."
  (let* ((leading-spaces
          (make-string full-Y-label-width ? ))
@end group
@group
       ;; symbol-width @r{is provided by} graph-body-print
       (tic-width (* symbol-width X-axis-label-spacing))
       (X-length (length numbers-list))
@end group
@group
       (X-tic
        (concat
         (make-string
@end group
@group
          ;; @r{Make a string of blanks.}
          (-  (* symbol-width X-axis-label-spacing)
              (length X-axis-tic-symbol))
          ? )
@end group
@group
         ;; @r{Concatenate blanks with tic symbol.}
         X-axis-tic-symbol))
@end group
@group
       (tic-number
        (if (zerop (% X-length tic-width))
            (/ X-length tic-width)
          (1+ (/ X-length tic-width)))))
@end group
@group
    (print-X-axis-tic-line tic-number leading-spaces X-tic)
    (insert "\n")
    (print-X-axis-numbered-line tic-number leading-spaces)))
@end group
@end smallexample

@need 1250
You can test @code{print-X-axis}:

@enumerate
@item
Install @code{X-axis-tic-symbol}, @code{X-axis-label-spacing},
@code{print-X-axis-tic-line}, as well as @code{X-axis-element},
@code{print-X-axis-numbered-line}, and @code{print-X-axis}.

@item
Copy the following expression:

@smallexample
@group
(progn
 (let ((full-Y-label-width 5)
       (symbol-width 1))
   (print-X-axis
    '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16))))
@end group
@end smallexample

@item
Switch to the @file{*scratch*} buffer and place the cursor where you want
the axis labels to start.

@item
Type @kbd{M-:} (@code{eval-expression}).

@item
Yank the test expression into the minibuffer with @kbd{C-y} (@code{yank)}.

@item
Press @key{RET} to evaluate the expression.
@end enumerate

@need 1250
Emacs will print the horizontal axis like this:
@sp 1

@smallexample
@group
     |   |    |    |    |
     1   5   10   15   20
@end group
@end smallexample

@node De gehele grafiek afdrukken
@appendixsec De hele grafiek afdrukken
@cindex Printing the whole graph
@cindex Whole graph printing
@cindex Graph, printing all

Now we are nearly ready to print the whole graph.

The function to print the graph with the proper labels follows the outline
we created earlier (@pxref{Full Graph, , A Graph with Labeled Axes}), but
with additions.

@need 1250
Here is the outline:

@smallexample
@group
(defun print-graph (numbers-list)
  "@var{documentation}@dots{}"
  (let ((height  @dots{}
        @dots{}))
@end group
@group
    (print-Y-axis height @dots{} )
    (graph-body-print numbers-list)
    (print-X-axis @dots{} )))
@end group
@end smallexample

@menu
* De finale versie::         Enkele veranderingen.
* Test print-graph::         Een korte test draaien.
* Woorden in defuns grafisch weergeven::  De finale code uitvoeren.
* lambda::                   Hoe een anonyme functie te schrijven
* mapcar::                   Een functie toepassen op de elementen van een 
                               lijst.
* Een andere bug::           Weer een andere bug @dots{} erg verraderlijk.
* Finale afgedrukte grafiek::  De grafiek zelf
@end menu

@ifnottex
@node De finale versie
@unnumberedsubsec Changes for the Final Version
@end ifnottex

The final version is different from what we planned in two ways: first, it
contains additional values calculated once in the varlist; second, it
carries an option to specify the labels' increment per row.  This latter
feature turns out to be essential; otherwise, a graph may have more rows
than fit on a display or on a sheet of paper.

@need 1500
This new feature requires a change to the @code{Y-axis-column} function, to
add @code{vertical-step} to it.  The function looks like this:

@findex Y-axis-column @r{Final version.}
@smallexample
@group
;;; @r{Final version.}
(defun Y-axis-column
  (height width-of-label &optional vertical-step)
  "Construct list of labels for Y axis.
HEIGHT is maximum height of graph.
WIDTH-OF-LABEL is maximum width of label.
VERTICAL-STEP, an option, is a positive integer
that specifies how much a Y axis label increments
for each line.  For example, a step of 5 means
that each line is five units of the graph."
@end group
@group
  (let (Y-axis
        (number-per-line (or vertical-step 1)))
    (while (> height 1)
      (if (zerop (% height Y-axis-label-spacing))
@end group
@group
          ;; @r{Insert label.}
          (setq Y-axis
                (cons
                 (Y-axis-element
                  (* height number-per-line)
                  width-of-label)
                 Y-axis))
@end group
@group
        ;; @r{Else, insert blanks.}
        (setq Y-axis
              (cons
               (make-string width-of-label ? )
               Y-axis)))
      (setq height (1- height)))
@end group
@group
    ;; @r{Insert base line.}
    (setq Y-axis (cons (Y-axis-element
                        (or vertical-step 1)
                        width-of-label)
                       Y-axis))
    (nreverse Y-axis)))
@end group
@end smallexample

The values for the maximum height of graph and the width of a symbol are
computed by @code{print-graph} in its @code{let} expression; so
@code{graph-body-print} must be changed to accept them.

@findex graph-body-print @r{Final version.}
@smallexample
@group
;;; @r{Final version.}
(defun graph-body-print (numbers-list height symbol-width)
  "Print a bar graph of the NUMBERS-LIST.
The numbers-list consists of the Y-axis values.
HEIGHT is maximum height of graph.
SYMBOL-WIDTH is number of each column."
@end group
@group
  (let (from-position)
    (while numbers-list
      (setq from-position (point))
      (insert-rectangle
       (column-of-graph height (car numbers-list)))
      (goto-char from-position)
      (forward-char symbol-width)
@end group
@group
      ;; @r{Draw graph column by column.}
      (sit-for 0)
      (setq numbers-list (cdr numbers-list)))
    ;; @r{Place point for X axis labels.}
    (forward-line height)
    (insert "\n")))
@end group
@end smallexample

@need 1250
Finally, the code for the @code{print-graph} function:

@findex print-graph @r{Final version.}
@smallexample
@group
;;; @r{Final version.}
(defun print-graph
  (numbers-list &optional vertical-step)
  "Print labeled bar graph of the NUMBERS-LIST.
The numbers-list consists of the Y-axis values.
@end group

@group
Optionally, VERTICAL-STEP, a positive integer,
specifies how much a Y axis label increments for
each line.  For example, a step of 5 means that
each row is five units."
@end group
@group
  (let* ((symbol-width (length graph-blank))
         ;; @code{height} @r{is both the largest number}
         ;; @r{and the number with the most digits.}
         (height (apply 'max numbers-list))
@end group
@group
         (height-of-top-line
          (if (zerop (% height Y-axis-label-spacing))
              height
            ;; @r{else}
            (* (1+ (/ height Y-axis-label-spacing))
               Y-axis-label-spacing)))
@end group
@group
         (vertical-step (or vertical-step 1))
         (full-Y-label-width
          (length
@end group
@group
           (concat
            (number-to-string
             (* height-of-top-line vertical-step))
            Y-axis-tic))))
@end group

@group
    (print-Y-axis
     height-of-top-line full-Y-label-width vertical-step)
@end group
@group
    (graph-body-print
     numbers-list height-of-top-line symbol-width)
    (print-X-axis numbers-list)))
@end group
@end smallexample

@node Test print-graph
@appendixsubsec Testing @code{print-graph}

@need 1250
We can test the @code{print-graph} function with a short list of numbers:

@enumerate
@item
Install the final versions of @code{Y-axis-column}, @code{graph-body-print},
and @code{print-graph} (in addition to the rest of the code.)

@item
Copy the following expression:

@smallexample
(print-graph '(3 2 5 6 7 5 3 4 6 4 3 2 1))
@end smallexample

@item
Switch to the @file{*scratch*} buffer and place the cursor where you want
the axis labels to start.

@item
Type @kbd{M-:} (@code{eval-expression}).

@item
Yank the test expression into the minibuffer with @kbd{C-y} (@code{yank)}.

@item
Press @key{RET} to evaluate the expression.
@end enumerate

@need 1250
Emacs will print a graph that looks like this:

@smallexample
@group
10 -


         *
        **   *
 5 -   ****  *
       **** ***
     * *********
     ************
 1 - *************

     |   |    |    |
     1   5   10   15
@end group
@end smallexample

@need 1200
On the other hand, if you pass @code{print-graph} a @code{vertical-step}
value of 2, by evaluating this expression:

@smallexample
(print-graph '(3 2 5 6 7 5 3 4 6 4 3 2 1) 2)
@end smallexample

@need 1250
@noindent
The graph looks like this:

@smallexample
@group
20 -


         *
        **   *
10 -   ****  *
       **** ***
     * *********
     ************
 2 - *************

     |   |    |    |
     1   5   10   15
@end group
@end smallexample

@noindent
(A question: is the @samp{2} on the bottom of the vertical axis a bug or a
feature? If you think it is a bug, and should be a @samp{1} instead, (or
even a @samp{0}), you can modify the sources.)

@node Woorden in defuns grafisch weergeven
@appendixsubsec Graphing Numbers of Words and Symbols

Now for the graph for which all this code was written: a graph that shows
how many function definitions contain fewer than 10 words and symbols, how
many contain between 10 and 19 words and symbols, how many contain between
20 and 29 words and symbols, and so on.

This is a multi-step process.  First make sure you have loaded all the
requisite code.

@need 1500
It is a good idea to reset the value of @code{top-of-ranges} in case you
have set it to some different value.  You can evaluate the following:

@smallexample
@group
(setq top-of-ranges
 '(10  20  30  40  50
   60  70  80  90 100
  110 120 130 140 150
  160 170 180 190 200
  210 220 230 240 250
  260 270 280 290 300)
@end group
@end smallexample

@noindent
Next create a list of the number of words and symbols in each range.

@need 1500
@noindent
Evaluate the following:

@smallexample
@group
(setq list-for-graph
       (defuns-per-range
         (sort
          (recursive-lengths-list-many-files
           (directory-files "/usr/local/emacs/lisp"
                            t ".+el$"))
          '<)
         top-of-ranges))
@end group
@end smallexample

@noindent
On my old machine, this took about an hour.  It looked though 303 Lisp files
in my copy of Emacs version 19.23.  After all that computing, the
@code{list-for-graph} had this value:

@smallexample
@group
(537 1027 955 785 594 483 349 292 224 199 166 120 116 99
90 80 67 48 52 45 41 33 28 26 25 20 12 28 11 13 220)
@end group
@end smallexample

@noindent
This means that my copy of Emacs had 537 function definitions with fewer
than 10 words or symbols in them, 1,027 function definitions with 10 to 19
words or symbols in them, 955 function definitions with 20 to 29 words or
symbols in them, and so on.

Clearly, just by looking at this list we can see that most function
definitions contain ten to thirty words and symbols.

Now for printing.  We do @emph{not} want to print a graph that is 1,030
lines high @dots{} Instead, we should print a graph that is fewer than
twenty-five lines high.  A graph that height can be displayed on almost any
monitor, and easily printed on a sheet of paper.

This means that each value in @code{list-for-graph} must be reduced to
one-fiftieth its present value.

Here is a short function to do just that, using two functions we have not
yet seen, @code{mapcar} and @code{lambda}.

@smallexample
@group
(defun one-fiftieth (full-range)
  "Return list, each number one-fiftieth of previous."
 (mapcar (lambda (arg) (/ arg 50)) full-range))
@end group
@end smallexample

@node lambda
@appendixsubsec A @code{lambda} Expression: Useful Anonymity
@cindex Anonymous function
@findex lambda

@code{lambda} is the symbol for an anonymous function, a function without a
name.  Every time you use an anonymous function, you need to include its
whole body.

@need 1250
@noindent
Thus,

@smallexample
(lambda (arg) (/ arg 50))
@end smallexample

@noindent
is a function that returns the value resulting from dividing whatever is
passed to it as @code{arg} by 50.

@need 1200
Earlier, for example, we had a function @code{multiply-by-seven}; it
multiplied its argument by 7.  This function is similar, except it divides
its argument by 50; and, it has no name.  The anonymous equivalent of
@code{multiply-by-seven} is:

@smallexample
(lambda (number) (* 7 number))
@end smallexample

@noindent
(@xref{defun, , The @code{defun} Macro}.)

@need 1250
@noindent
@c lambda example diagram #1
If we want to multiply 3 by 7, we can write:
@sp 1
@center @image{lambda-1}
@sp 1

@noindent
This expression returns 21.

@need 1250
@noindent
@c lambda example diagram #2
Similarly, we can write:
@sp 1
@center @image{lambda-2}
@sp 1

@need 1250
@noindent
@c lambda example diagram #3
If we want to divide 100 by 50, we can write:
@sp 1
@center @image{lambda-3}
@sp 1

@noindent
This expression returns 2.  The 100 is passed to the function, which divides
that number by 50.

@xref{Lambda Expressions, , Lambda Expressions, elisp, The GNU Emacs Lisp
Reference Manual}, for more about @code{lambda}.  Lisp and lambda
expressions derive from the Lambda Calculus.

@node mapcar
@appendixsubsec The @code{mapcar} Function
@findex mapcar

@code{mapcar} is a function that calls its first argument with each element
of its second argument, in turn.  The second argument must be a sequence.

The @samp{map} part of the name comes from the mathematical phrase,
``mapping over a domain'', meaning to apply a function to each of the
elements in a domain.  The mathematical phrase is based on the metaphor of a
surveyor walking, one step at a time, over an area he is mapping.  And
@samp{car}, of course, comes from the Lisp notion of the first of a list.

@need 1250
@noindent
Bijvoorbeeld,

@smallexample
@group
(mapcar '1+ '(2 4 6))
     @result{} (3 5 7)
@end group
@end smallexample

@noindent
The function @code{1+} which adds one to its argument, is executed on
@emph{each} element of the list, and a new list is returned.

Contrast this with @code{apply}, which applies its first argument to all the
remaining.  (@xref{Readying a Graph, , Readying a Graph}, for an explanation
of @code{apply}.)

@need 1250
In the definition of @code{one-fiftieth}, the first argument is the
anonymous function:

@smallexample
(lambda (arg) (/ arg 50))
@end smallexample

@noindent
and the second argument is @code{full-range}, which will be bound to
@code{list-for-graph}.

@need 1250
The whole expression looks like this:

@smallexample
(mapcar (lambda (arg) (/ arg 50)) full-range))
@end smallexample

@xref{Mapping Functions, , Mapping Functions, elisp, The GNU Emacs Lisp
Reference Manual}, for more about @code{mapcar}.

Using the @code{one-fiftieth} function, we can generate a list in which each
element is one-fiftieth the size of the corresponding element in
@code{list-for-graph}.

@smallexample
@group
(setq fiftieth-list-for-graph
      (one-fiftieth list-for-graph))
@end group
@end smallexample

@need 1250
The resulting list looks like this:

@smallexample
@group
(10 20 19 15 11 9 6 5 4 3 3 2 2
1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 4)
@end group
@end smallexample

@noindent
This, we are almost ready to print! (We also notice the loss of information:
many of the higher ranges are 0, meaning that fewer than 50 defuns had that
many words or symbols---but not necessarily meaning that none had that many
words or symbols.)

@node Een andere bug
@appendixsubsec Another Bug @dots{} Most Insidious
@cindex Bug, most insidious type
@cindex Insidious type of bug

I said ``almost ready to print''! Of course, there is a bug in the
@code{print-graph} function @dots{} It has a @code{vertical-step} option,
but not a @code{horizontal-step} option.  The @code{top-of-range} scale goes
from 10 to 300 by tens.  But the @code{print-graph} function will print only
by ones.

This is a classic example of what some consider the most insidious type of
bug, the bug of omission.  This is not the kind of bug you can find by
studying the code, for it is not in the code; it is an omitted feature.
Your best actions are to try your program early and often; and try to
arrange, as much as you can, to write code that is easy to understand and
easy to change.  Try to be aware, whenever you can, that whatever you have
written, @emph{will} be rewritten, if not soon, eventually.  A hard maxim to
follow.

It is the @code{print-X-axis-numbered-line} function that needs the work;
and then the @code{print-X-axis} and the @code{print-graph} functions need
to be adapted.  Not much needs to be done; there is one nicety: the numbers
ought to line up under the tic marks.  This takes a little thought.

@need 1250
Here is the corrected @code{print-X-axis-numbered-line}:

@smallexample
@group
(defun print-X-axis-numbered-line
  (number-of-X-tics X-axis-leading-spaces
   &optional horizontal-step)
  "Print line of X-axis numbers"
  (let ((number X-axis-label-spacing)
        (horizontal-step (or horizontal-step 1)))
@end group
@group
    (insert X-axis-leading-spaces)
    ;; @r{Delete extra leading spaces.}
    (delete-char
     (- (1-
         (length (number-to-string horizontal-step)))))
    (insert (concat
             (make-string
@end group
@group
              ;; @r{Insert white space.}
              (-  (* symbol-width
                     X-axis-label-spacing)
                  (1-
                   (length
                    (number-to-string horizontal-step)))
                  2)
              ? )
             (number-to-string
              (* number horizontal-step))))
@end group
@group
    ;; @r{Insert remaining numbers.}
    (setq number (+ number X-axis-label-spacing))
    (while (> number-of-X-tics 1)
      (insert (X-axis-element
               (* number horizontal-step)))
      (setq number (+ number X-axis-label-spacing))
      (setq number-of-X-tics (1- number-of-X-tics)))))
@end group
@end smallexample

@need 1500
If you are reading this in Info, you can see the new versions of
@code{print-X-axis} @code{print-graph} and evaluate them.  If you are
reading this in a printed book, you can see the changed lines here (the full
text is too much to print).

@iftex
@smallexample
@group
(defun print-X-axis (numbers-list horizontal-step)
  @dots{}
    (print-X-axis-numbered-line
     tic-number leading-spaces horizontal-step))
@end group
@end smallexample

@smallexample
@group
(defun print-graph
  (numbers-list
   &optional vertical-step horizontal-step)
  @dots{}
    (print-X-axis numbers-list horizontal-step))
@end group
@end smallexample
@end iftex

@ifnottex
@smallexample
@group
(defun print-X-axis (numbers-list horizontal-step)
  "Print X axis labels to length of NUMBERS-LIST.
Optionally, HORIZONTAL-STEP, a positive integer,
specifies how much an X  axis label increments for
each column."
@end group
@group
;; Value of symbol-width and full-Y-label-width
;; are passed by print-graph.
  (let* ((leading-spaces
          (make-string full-Y-label-width ? ))
       ;; symbol-width @r{is provided by} graph-body-print
       (tic-width (* symbol-width X-axis-label-spacing))
       (X-length (length numbers-list))
@end group
@group
       (X-tic
        (concat
         (make-string
          ;; @r{Make a string of blanks.}
          (-  (* symbol-width X-axis-label-spacing)
              (length X-axis-tic-symbol))
          ? )
@end group
@group
         ;; @r{Concatenate blanks with tic symbol.}
         X-axis-tic-symbol))
       (tic-number
        (if (zerop (% X-length tic-width))
            (/ X-length tic-width)
          (1+ (/ X-length tic-width)))))
@end group

@group
    (print-X-axis-tic-line
     tic-number leading-spaces X-tic)
    (insert "\n")
    (print-X-axis-numbered-line
     tic-number leading-spaces horizontal-step)))
@end group
@end smallexample

@smallexample
@group
(defun print-graph
  (numbers-list &optional vertical-step horizontal-step)
  "Print labeled bar graph of the NUMBERS-LIST.
The numbers-list consists of the Y-axis values.
@end group

@group
Optionally, VERTICAL-STEP, a positive integer,
specifies how much a Y axis label increments for
each line.  For example, a step of 5 means that
each row is five units.
@end group

@group
Optionally, HORIZONTAL-STEP, a positive integer,
specifies how much an X  axis label increments for
each column."
  (let* ((symbol-width (length graph-blank))
         ;; @code{height} @r{is both the largest number}
         ;; @r{and the number with the most digits.}
         (height (apply 'max numbers-list))
@end group
@group
         (height-of-top-line
          (if (zerop (% height Y-axis-label-spacing))
              height
            ;; @r{else}
            (* (1+ (/ height Y-axis-label-spacing))
               Y-axis-label-spacing)))
@end group
@group
         (vertical-step (or vertical-step 1))
         (full-Y-label-width
          (length
           (concat
            (number-to-string
             (* height-of-top-line vertical-step))
            Y-axis-tic))))
@end group
@group
    (print-Y-axis
     height-of-top-line full-Y-label-width vertical-step)
    (graph-body-print
        numbers-list height-of-top-line symbol-width)
    (print-X-axis numbers-list horizontal-step)))
@end group
@end smallexample
@end ifnottex

@c qqq
@ignore
Graphing Definitions Re-listed

@need 1250
Here are all the graphing definitions in their final form:

@smallexample
@group
(defvar top-of-ranges
 '(10  20  30  40  50
   60  70  80  90 100
  110 120 130 140 150
  160 170 180 190 200
  210 220 230 240 250)
 "List specifying ranges for `defuns-per-range'.")
@end group

@group
(defvar graph-symbol "*"
  "String used as symbol in graph, usually an asterisk.")
@end group

@group
(defvar graph-blank " "
  "String used as blank in graph, usually a blank space.
graph-blank must be the same number of columns wide
as graph-symbol.")
@end group

@group
(defvar Y-axis-tic " - "
   "String that follows number in a Y axis label.")
@end group

@group
(defvar Y-axis-label-spacing 5
  "Number of lines from one Y axis label to next.")
@end group

@group
(defvar X-axis-tic-symbol "|"
  "String to insert to point to a column in X axis.")
@end group

@group
(defvar X-axis-label-spacing
  (if (boundp 'graph-blank)
      (* 5 (length graph-blank)) 5)
  "Number of units from one X axis label to next.")
@end group
@end smallexample

@smallexample
@group
(defun tel-woorden-in-defun ()
  "Geef het aantal woorden en symbolen in een defun terug."
  (beginning-of-defun)
  (let ((telling 0)
        (einde (save-excursion (end-of-defun) (point))))
@end group

@group
    (while
        (and (< (point) einde)
             (re-search-forward
              "\\(\\w\\|\\s_\\)+[^ \t\n]*[ \t\n]*"
              einde t))
      (setq telling (1+ telling)))
    telling))
@end group
@end smallexample

@smallexample
@group
(defun lengte-lijst-bestand (bestandsnaam)
  "Geef een lijst terug met definitielengtes in BESTANDSNAAM.
De teruggeven lijst is een lijst van getallen.
Elk getal is een het aahtal woorden of symbolen
in een functiedefinitie."
@end group

@group
  (message "Working on `%s' ... " filename)
  (save-excursion
    (let ((buffer (find-file-noselect filename))
          (lengths-list))
      (set-buffer buffer)
      (setq buffer-read-only t)
      (widen)
      (goto-char (point-min))
@end group

@group
      (while (re-search-forward "^(defun" nil t)
        (setq lengths-list
              (cons (count-words-in-defun) lengths-list)))
      (kill-buffer buffer)
      lengths-list)))
@end group
@end smallexample

@smallexample
@group
(defun lengths-list-many-files (list-of-files)
  "Return list of lengths of defuns in LIST-OF-FILES."
  (let (lengths-list)
;;; @r{true-or-false-test}
    (while list-of-files
      (setq lengths-list
            (append
             lengths-list
@end group
@group
;;; @r{Generate a lengths' list.}
             (lengths-list-file
              (expand-file-name (car list-of-files)))))
;;; @r{Make files' list shorter.}
      (setq list-of-files (cdr list-of-files)))
;;; @r{Return final value of lengths' list.}
    lengths-list))
@end group
@end smallexample

@smallexample
@group
(defun defuns-per-range (gesorteerde-lengtes hoogste-van-ranges)
  "GESORTEERDE-LENGTES defuns in elke HOOGSTE-VAN-RANGES range."
  (let ((hoogste-van-range (car hoogste-van-ranges))
        (getal-in-range 0)
        defuns-per-range-lijst)
@end group

@group
    ;; @r{Outer loop.}
    (while top-of-ranges

      ;; @r{Inner loop.}
      (while (and
              ;; @r{Need number for numeric test.}
              (car sorted-lengths)
              (< (car sorted-lengths) top-of-range))

        ;; @r{Tel aantal definities in huidige range.}
        (setq getal-in-range (1+ getal-in-range))
        (setq gesorteerde-lengtes (cdr gesorteerde-lengtes)))
@end group

@group
      ;; @r{Verlaat binnenste loop maar blijf in buitenste loop.}

      (setq defuns-per-range-lijst
            (cons getal-in-range defuns-per-range-list))
      (setq getal-in-range 0)      ; @r{Reset telling op nul.}
      ;; @r{Ga naar volgende range.}
      (setq hoogste-van-ranges (cdr hoogste-van-ranges))
      ;; @r{Specify next top of range value.}
      (setq hoogste-van-range (car hoogste-van-ranges)))
@end group

@group
    ;; @r{Verlaat buitenste loop en tel het aantal defuns groter dan}
    ;; @r{  de grootste top-of-range value.}
    (setq defuns-per-range-lijst
          (cons
           (length gesorteerde-lengtes)
           defuns-per-range-lijst))

    ;; @r{Geef een lijst terug met het aantal definities in elke range,}
    ;; @r{  van klein naar groot.}
    (nreverse defuns-per-range-lijst)))
@end group
@end smallexample

@smallexample
@group
(defun column-of-graph (max-graph-height actual-height)
  "Return list of MAX-GRAPH-HEIGHT strings;
ACTUAL-HEIGHT are graph-symbols.
The graph-symbols are contiguous entries at the end
of the list.
The list will be inserted as one column of a graph.
The strings are either graph-blank or graph-symbol."
@end group

@group
  (let ((insert-list nil)
        (number-of-top-blanks
         (- max-graph-height actual-height)))

    ;; @r{Fill in @code{graph-symbols}.}
    (while (> actual-height 0)
      (setq insert-list (cons graph-symbol insert-list))
      (setq actual-height (1- actual-height)))
@end group

@group
    ;; @r{Fill in @code{graph-blanks}.}
    (while (> number-of-top-blanks 0)
      (setq insert-list (cons graph-blank insert-list))
      (setq number-of-top-blanks
            (1- number-of-top-blanks)))

    ;; @r{Return whole list.}
    insert-list))
@end group
@end smallexample

@smallexample
@group
(defun Y-axis-element (number full-Y-label-width)
  "Construct a NUMBERed label element.
A numbered element looks like this `  5 - ',
and is padded as needed so all line up with
the element for the largest number."
@end group
@group
  (let* ((leading-spaces
         (- full-Y-label-width
            (length
             (concat (number-to-string number)
                     Y-axis-tic)))))
@end group
@group
    (concat
     (make-string leading-spaces ? )
     (number-to-string number)
     Y-axis-tic)))
@end group
@end smallexample

@smallexample
@group
(defun print-Y-axis
  (height full-Y-label-width &optional vertical-step)
  "Insert Y axis by HEIGHT and FULL-Y-LABEL-WIDTH.
Height must be the  maximum height of the graph.
Full width is the width of the highest label element.
Optionally, print according to VERTICAL-STEP."
@end group
@group
;; Value of height and full-Y-label-width
;; are passed by 'print-graph'.
  (let ((start (point)))
    (insert-rectangle
     (Y-axis-column height full-Y-label-width vertical-step))
@end group
@group
    ;; @r{Place point ready for inserting graph.}
    (goto-char start)
    ;; @r{Move point forward by value of} full-Y-label-width
    (forward-char full-Y-label-width)))
@end group
@end smallexample

@smallexample
@group
(defun print-X-axis-tic-line
  (number-of-X-tics X-axis-leading-spaces X-axis-tic-element)
  "Print ticks for X axis."
    (insert X-axis-leading-spaces)
    (insert X-axis-tic-symbol)  ; @r{Under first column.}
@end group
@group
    ;; @r{Insert second tic in the right spot.}
    (insert (concat
             (make-string
              (-  (* symbol-width X-axis-label-spacing)
                  ;; @r{Insert white space up to second tic symbol.}
                  (* 2 (length X-axis-tic-symbol)))
              ? )
             X-axis-tic-symbol))
@end group
@group
    ;; @r{Insert remaining ticks.}
    (while (> number-of-X-tics 1)
      (insert X-axis-tic-element)
      (setq number-of-X-tics (1- number-of-X-tics))))
@end group
@end smallexample

@smallexample
@group
(defun X-axis-element (number)
  "Construct a numbered X axis element."
  (let ((leading-spaces
         (-  (* symbol-width X-axis-label-spacing)
             (length (number-to-string number)))))
    (concat (make-string leading-spaces ? )
            (number-to-string number))))
@end group
@end smallexample

@smallexample
@group
(defun graph-body-print (numbers-list height symbol-width)
  "Print a bar graph of the NUMBERS-LIST.
The numbers-list consists of the Y-axis values.
HEIGHT is maximum height of graph.
SYMBOL-WIDTH is number of each column."
@end group
@group
  (let (from-position)
    (while numbers-list
      (setq from-position (point))
      (insert-rectangle
       (column-of-graph height (car numbers-list)))
      (goto-char from-position)
      (forward-char symbol-width)
@end group
@group
      ;; @r{Draw graph column by column.}
      (sit-for 0)
      (setq numbers-list (cdr numbers-list)))
    ;; @r{Place point for X axis labels.}
    (forward-line height)
    (insert "\n")))
@end group
@end smallexample

@smallexample
@group
(defun Y-axis-column
  (height width-of-label &optional vertical-step)
  "Construct list of labels for Y axis.
HEIGHT is maximum height of graph.
WIDTH-OF-LABEL is maximum width of label.
@end group
@group
VERTICAL-STEP, an option, is a positive integer
that specifies how much a Y axis label increments
for each line.  For example, a step of 5 means
that each line is five units of the graph."
  (let (Y-axis
        (number-per-line (or vertical-step 1)))
@end group
@group
    (while (> height 1)
      (if (zerop (% height Y-axis-label-spacing))
          ;; @r{Insert label.}
          (setq Y-axis
                (cons
                 (Y-axis-element
                  (* height number-per-line)
                  width-of-label)
                 Y-axis))
@end group
@group
        ;; @r{Else, insert blanks.}
        (setq Y-axis
              (cons
               (make-string width-of-label ? )
               Y-axis)))
      (setq height (1- height)))
@end group
@group
    ;; @r{Insert base line.}
    (setq Y-axis (cons (Y-axis-element
                        (or vertical-step 1)
                        width-of-label)
                       Y-axis))
    (nreverse Y-axis)))
@end group
@end smallexample

@smallexample
@group
(defun print-X-axis-numbered-line
  (number-of-X-tics X-axis-leading-spaces
   &optional horizontal-step)
  "Print line of X-axis numbers"
  (let ((number X-axis-label-spacing)
        (horizontal-step (or horizontal-step 1)))
@end group
@group
    (insert X-axis-leading-spaces)
    ;; line up number
    (delete-char (- (1- (length (number-to-string horizontal-step)))))
    (insert (concat
             (make-string
              ;; @r{Insert white space up to next number.}
              (-  (* symbol-width X-axis-label-spacing)
                  (1- (length (number-to-string horizontal-step)))
                  2)
              ? )
             (number-to-string (* number horizontal-step))))
@end group
@group
    ;; @r{Insert remaining numbers.}
    (setq number (+ number X-axis-label-spacing))
    (while (> number-of-X-tics 1)
      (insert (X-axis-element (* number horizontal-step)))
      (setq number (+ number X-axis-label-spacing))
      (setq number-of-X-tics (1- number-of-X-tics)))))
@end group
@end smallexample

@smallexample
@group
(defun print-X-axis (numbers-list horizontal-step)
  "Print X axis labels to length of NUMBERS-LIST.
Optionally, HORIZONTAL-STEP, a positive integer,
specifies how much an X  axis label increments for
each column."
@end group
@group
;; Value of symbol-width and full-Y-label-width
;; are passed by 'print-graph'.
  (let* ((leading-spaces
          (make-string full-Y-label-width ? ))
       ;; symbol-width @r{is provided by} graph-body-print
       (tic-width (* symbol-width X-axis-label-spacing))
       (X-length (length numbers-list))
@end group
@group
       (X-tic
        (concat
         (make-string
          ;; @r{Make a string of blanks.}
          (-  (* symbol-width X-axis-label-spacing)
              (length X-axis-tic-symbol))
          ? )
@end group
@group
         ;; @r{Concatenate blanks with tic symbol.}
         X-axis-tic-symbol))
       (tic-number
        (if (zerop (% X-length tic-width))
            (/ X-length tic-width)
          (1+ (/ X-length tic-width)))))
@end group

@group
    (print-X-axis-tic-line
     tic-number leading-spaces X-tic)
    (insert "\n")
    (print-X-axis-numbered-line
     tic-number leading-spaces horizontal-step)))
@end group
@end smallexample

@smallexample
@group
(defun one-fiftieth (full-range)
  "Return list, each number of which is 1/50th previous."
 (mapcar (lambda (arg) (/ arg 50)) full-range))
@end group
@end smallexample

@smallexample
@group
(defun print-graph
  (numbers-list &optional vertical-step horizontal-step)
  "Print labeled bar graph of the NUMBERS-LIST.
The numbers-list consists of the Y-axis values.
@end group

@group
Optionally, VERTICAL-STEP, a positive integer,
specifies how much a Y axis label increments for
each line.  For example, a step of 5 means that
each row is five units.
@end group

@group
Optionally, HORIZONTAL-STEP, a positive integer,
specifies how much an X  axis label increments for
each column."
  (let* ((symbol-width (length graph-blank))
         ;; @code{height} @r{is both the largest number}
         ;; @r{and the number with the most digits.}
         (height (apply 'max numbers-list))
@end group
@group
         (height-of-top-line
          (if (zerop (% height Y-axis-label-spacing))
              height
            ;; @r{else}
            (* (1+ (/ height Y-axis-label-spacing))
               Y-axis-label-spacing)))
@end group
@group
         (vertical-step (or vertical-step 1))
         (full-Y-label-width
          (length
           (concat
            (number-to-string
             (* height-of-top-line vertical-step))
            Y-axis-tic))))
@end group
@group

    (print-Y-axis
     height-of-top-line full-Y-label-width vertical-step)
    (graph-body-print
        numbers-list height-of-top-line symbol-width)
    (print-X-axis numbers-list horizontal-step)))
@end group
@end smallexample
@c qqq
@end ignore

@page
@node Finale afgedrukte grafiek
@appendixsubsec The Printed Graph

When made and installed, you can call the @code{print-graph} command like
this:
@sp 1

@smallexample
@group
(print-graph fiftieth-list-for-graph 50 10)
@end group
@end smallexample
@sp 1

@noindent
Here is the graph:
@sp 2

@smallexample
@group
1000 -  *
        **
        **
        **
        **
 750 -  ***
        ***
        ***
        ***
        ****
 500 - *****
       ******
       ******
       ******
       *******
 250 - ********
       *********                     *
       ***********                   *
       *************                 *
  50 - ***************** *           *
       |   |    |    |    |    |    |    |
      10  50  100  150  200  250  300  350
@end group
@end smallexample

@sp 2

@noindent
The largest group of functions contain 10--19 words and symbols each.

@node Vrije software en vrije handleidingen
@appendix Vrije software en vrije handleidingen

@strong{by Richard M. Stallman}
@sp 1

The biggest deficiency in free operating systems is not in the software---it
is the lack of good free manuals that we can include in these systems.  Many
of our most important programs do not come with full manuals.  Documentation
is an essential part of any software package; when an important free
software package does not come with a free manual, that is a major gap.  We
have many such gaps today.

Once upon a time, many years ago, I thought I would learn Perl.  I got a
copy of a free manual, but I found it hard to read.  When I asked Perl users
about alternatives, they told me that there were better introductory
manuals---but those were not free.

Why was this? The authors of the good manuals had written them for O'Reilly
Associates, which published them with restrictive terms---no copying, no
modification, source files not available---which exclude them from the free
software community.

That wasn't the first time this sort of thing has happened, and (to our
community's great loss) it was far from the last.  Proprietary manual
publishers have enticed a great many authors to restrict their manuals since
then.  Many times I have heard a GNU user eagerly tell me about a manual
that he is writing, with which he expects to help the GNU project---and then
had my hopes dashed, as he proceeded to explain that he had signed a
contract with a publisher that would restrict it so that we cannot use it.

Given that writing good English is a rare skill among programmers, we can
ill afford to lose manuals this way.

Free documentation, like free software, is a matter of freedom, not price.
The problem with these manuals was not that O'Reilly Associates charged a
price for printed copies---that in itself is fine.  The Free Software
Foundation @uref{https://shop.fsf.org, sells printed copies} of free
@uref{https://www.gnu.org/doc/doc.html, GNU manuals}, too.  But GNU manuals
are available in source code form, while these manuals are available only on
paper.  GNU manuals come with permission to copy and modify; the Perl
manuals do not.  These restrictions are the problems.

The criterion for a free manual is pretty much the same as for free
software: it is a matter of giving all users certain freedoms.
Redistribution (including commercial redistribution) must be permitted, so
that the manual can accompany every copy of the program, on-line or on
paper.  Permission for modification is crucial too.

As a general rule, I don't believe that it is essential for people to have
permission to modify all sorts of articles and books.  The issues for
writings are not necessarily the same as those for software.  For example, I
don't think you or I are obliged to give permission to modify articles like
this one, which describe our actions and our views.

But there is a particular reason why the freedom to modify is crucial for
documentation for free software.  When people exercise their right to modify
the software, and add or change its features, if they are conscientious they
will change the manual too---so they can provide accurate and usable
documentation with the modified program.  A manual which forbids programmers
to be conscientious and finish the job, or more precisely requires them to
write a new manual from scratch if they change the program, does not fill
our community's needs.

While a blanket prohibition on modification is unacceptable, some kinds of
limits on the method of modification pose no problem.  For example,
requirements to preserve the original author's copyright notice, the
distribution terms, or the list of authors, are ok.  It is also no problem
to require modified versions to include notice that they were modified, even
to have entire sections that may not be deleted or changed, as long as these
sections deal with nontechnical topics.  (Some GNU manuals have them.)

These kinds of restrictions are not a problem because, as a practical
matter, they don't stop the conscientious programmer from adapting the
manual to fit the modified program.  In other words, they don't block the
free software community from making full use of the manual.

However, it must be possible to modify all the technical content of the
manual, and then distribute the result in all the usual media, through all
the usual channels; otherwise, the restrictions do block the community, the
manual is not free, and so we need another manual.

Unfortunately, it is often hard to find someone to write another manual when
a proprietary manual exists.  The obstacle is that many users think that a
proprietary manual is good enough---so they don't see the need to write a
free manual.  They do not see that the free operating system has a gap that
needs filling.

Why do users think that proprietary manuals are good enough? Some have not
considered the issue.  I hope this article will do something to change that.

Other users consider proprietary manuals acceptable for the same reason so
many people consider proprietary software acceptable: they judge in purely
practical terms, not using freedom as a criterion.  These people are
entitled to their opinions, but since those opinions spring from values
which do not include freedom, they are no guide for those of us who do value
freedom.

Please spread the word about this issue.  We continue to lose manuals to
proprietary publishing.  If we spread the word that proprietary manuals are
not sufficient, perhaps the next person who wants to help GNU by writing
documentation will realize, before it is too late, that he must above all
make it free.

We can also encourage commercial publishers to sell free, copylefted manuals
instead of proprietary ones.  One way you can help this is to check the
distribution terms of a manual before you buy it, and prefer copylefted
manuals to non-copylefted ones.

@sp 2
@noindent
Opmerking: De Free Software Foundation onderhoudt een pagina op hun website
met een lijst van boeken die vrij beschikbaar zijn bij andere uitgevers:@*
@uref{https://www.gnu.org/doc/other-free-books.html}

@node GNU Free Documentation License
@appendix GNU Free Documentation License

@cindex FDL, GNU Free Documentation License
@include doclicense.texi

@node Index
@unnumbered Index

@ignore
MENU ENTRY: NODE NAME.
@end ignore

@printindex cp

@iftex
@c Place biographical information on right-hand (verso) page

@tex
\par\vfill\supereject
\ifodd\pageno
    \global\evenheadline={\hfil} \global\evenfootline={\hfil}
    \global\oddheadline={\hfil} \global\oddfootline={\hfil}
    %\page\hbox{}\page
\else
%    \par\vfill\supereject
    \global\evenheadline={\hfil} \global\evenfootline={\hfil}
    \global\oddheadline={\hfil} \global\oddfootline={\hfil}
    %\page\hbox{}%\page
    %\page\hbox{}%\page
\fi
@end tex

@c page
@w{ }

@c ================ Biographical information ================

@w{ }
@sp 8
@center Over de auteur
@sp 1
@end iftex

@ifnottex
@node Over de auteur
@unnumbered Over de auteur
@end ifnottex

@quotation
Robert J. Chassell (1946--2017) begon te werken met GNU Emacs in 1985. Hij
schreef en bewerte tekst, gaf les in Emacs en Emacs Lisp en sprak over de
hele wereld over software vrijheid. Chassel was oprichtend directeur en
penningmeester van de Free Software Foundation, Inc. He was co-auteur van de
@cite{Texinfo} handleiding, en bewerkte meer dan een dozijn andere
boeken. Hij studeerde af aan de universiteit van Cambridge in Engeland. Hij
had een blijvende interesse in sociale en economische geshiedenis en vloog
zijn eigen vliegtuig.

@uref{https://www.fsf.org/blogs/community/goodbye-to-bob-chassell, "Goodbye
to Bob Chassell"}
@end quotation

@c @page
@c @w{ }
@c
@c @c Prevent page number on blank verso, so eject it first.
@c @tex
@c \par\vfill\supereject
@c @end tex

@c @iftex
@c @headings off
@c @evenheading @thispage @| @| @thistitle
@c @oddheading            @| @| @thispage
@c @end iftex

@bye
