Web Expert

Xah Lee · I prefer to learn from reference manuals. I “dive into” each paragraph, and “come up for air” between paragraphs.

$ ./configure
$ make
$ sudo make install

$ pkg-config --cflags gumbo         # print compiler flags
$ pkg-config --libs gumbo           # print linker flags
$ pkg-config --cflags --libs gumbo  # print both

$ gcc my_program.c `pkg-config --cflags --libs gumbo`

$ unzip gtest-1.6.0.zip
$ cd gumbo-*
$ ln -s ../gtest-1.6.0 gtest
$ make check

#include "gumbo.h"

int main(int argc, char** argv) {
  GumboOutput* output = gumbo_parse(argv[1]);
  // Do stuff with output->root
  gumbo_destroy_output(&kGumboDefaultOptions, output);
}

     GNU Press,                        http://www.fsf.org/campaigns/gnu-press/
     a division of the                 email: sales@fsf.org
     Free Software Foundation, Inc.    Tel: +1 (617) 542-5942
     51 Franklin Street, Fifth Floor   Fax: +1 (617) 542-2652
     Boston, MA 02110-1301 USA

     '(rose
       violet
       daisy
       buttercup)

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

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

     '(this list
        looks like this)

     '(this list looks like this)

     (+ 2 2)

     '(this is a quoted list)

     (this is an unquoted list)

     ---------- Buffer: *Backtrace* ----------
     Debugger entered--Lisp error: (void-function this)
       (this is an unquoted list)
       eval((this is an unquoted list))
       eval-last-sexp-1(nil)
       eval-last-sexp(nil)
       call-interactively(eval-last-sexp)
     ---------- Buffer: *Backtrace* ----------

     q

     Debugger entered--Lisp error: (void-function this)

     Symbol's function definition is void: this

     (+ 2 (+ 3 3))

     (+ 2 (+ 3 3))

     fill-column

     (fill-column)

     ---------- Buffer: *Backtrace* ----------
     Debugger entered--Lisp error: (void-function fill-column)
       (fill-column)
       eval((fill-column))
       eval-last-sexp-1(nil)
       eval-last-sexp(nil)
       call-interactively(eval-last-sexp)
     ---------- Buffer: *Backtrace* ----------

     (+ 2 2)

     ---------- Buffer: *Backtrace* ----------
     Debugger entered--Lisp error: (void-variable +)
       eval(+)
       eval-last-sexp-1(nil)
       eval-last-sexp(nil)
       call-interactively(eval-last-sexp)
     ---------- Buffer: *Backtrace* ----------

     (+ 2 2)

     (concat "abc" "def")

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

     (+ 2 fill-column)

     (concat "The " (number-to-string (+ 2 fill-column)) " red foxes.")

     (+)       ⇒ 0

     (*)       ⇒ 1

     (+ 3)     ⇒ 3

     (* 3)     ⇒ 3

     (+ 3 4 5) ⇒ 12

     (* 3 4 5) ⇒ 60

     (+ 2 'hello)

     ---------- Buffer: *Backtrace* ----------
     Debugger entered--Lisp error:
              (wrong-type-argument number-or-marker-p hello)
       +(2 hello)
       eval((+ 2 (quote hello)))
       eval-last-sexp-1(nil)
       eval-last-sexp(nil)
       call-interactively(eval-last-sexp)
     ---------- Buffer: *Backtrace* ----------

     (message "This message appears in the echo area!")

     (message "The name of this buffer is: %s." (buffer-name))

     (message "The value of fill-column is %d." fill-column)

     (message "There are %d %s in the office!"
              (- fill-column 14) "pink elephants")

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

     (set 'flowers '(rose violet daisy buttercup))

     flowers

     'flowers

     (setq carnivores '(lion tiger leopard))

     (set 'carnivores '(lion tiger leopard))

     (setq trees '(pine fir oak maple)
           herbivores '(gazelle antelope zebra))

     (setq counter 0)                ; Let's call this the initializer.

     (setq counter (+ counter 1))    ; This is the incrementer.

     counter                         ; This is the counter.

     (buffer-name)

     (buffer-file-name)

     (buffer-name)"*scratch*"

     (current-buffer)

     (other-buffer)

     (switch-to-buffer (other-buffer))

     (buffer-size)

     (point)

     (point)

     (defun function-name (arguments...)
       "optional-documentation..."
       (interactive argument-passing-info)     ; optional
       body...)

     (defun multiply-by-seven (number)
       "Multiply NUMBER by seven."
       (* 7 number))

     (multiply-by-seven 3)

     (defun multiply-by-seven (number)
       "Multiply NUMBER by seven."
       (* 7 number))

     (multiply-by-seven 3)

     multiply-by-seven is a Lisp function.
     (multiply-by-seven NUMBER)

     Multiply NUMBER by seven.

     (defun multiply-by-seven (number)       ; Second version.
       "Multiply NUMBER by seven."
       (+ number number number number number number number))

     (defun multiply-by-seven (number)       ; Interactive version.
       "Multiply NUMBER by seven."
       (interactive "p")
       (message "The result is %d" (* 7 number)))

     (defun multiply-by-seven (number)       ; Interactive version.
       "Multiply NUMBER by seven."
       (interactive "p")
       (message "The result is %d" (* 7 number)))

     (message "The result is %d" (* 7 number))

     (message "The result is %d" (* 7 5))

     (interactive "p\ncZap to char: ")

     (defun name-of-function (arg char)
       "documentation..."
       (interactive "p\ncZap to char: ")
       body-of-function...)

     (let varlist body...)

     (let ((variable value)
           (variable value)
           ...)
       body...)

     (let ((zebra 'stripes)
           (tiger 'fierce))
       (message "One kind of animal has %s and another is %s."
                zebra tiger))

     "One kind of animal has stripes and another is fierce."

     (let ((birch 3)
           pine
           fir
           (oak 'some))
       (message
        "Here are %d variables with %s, %s, and %s value."
        birch pine fir oak))

     "Here are 3 variables with nil, nil, and some value."

     (if true-or-false-test
         action-to-carry-out-if-test-is-true)

     (if (> 5 4)                             ; if-part
         (message "5 is greater than 4!"))   ; then-part

     (defun type-of-animal (characteristic)
       "Print message in echo area depending on CHARACTERISTIC.
     If the CHARACTERISTIC is the symbol `fierce',
     then warn of a tiger."
       (if (equal characteristic 'fierce)
           (message "It's a tiger!")))

     (type-of-animal 'fierce)

     (type-of-animal 'zebra)

     (defun name-of-function (argument-list)
       "documentation..."
       body...)

     (defun type-of-animal (characteristic)
       "Print message in echo area depending on CHARACTERISTIC.
     If the CHARACTERISTIC is the symbol `fierce',
     then warn of a tiger."
       body: the if expression)

     (if true-or-false-test
         action-to-carry-out-if-the-test-returns-true)

     (if (equal characteristic 'fierce)
         (message "It's a tiger!")))

     (equal characteristic 'fierce)

     (if true-or-false-test
         action-to-carry-out-if-the-test-returns-true
       action-to-carry-out-if-the-test-returns-false)

     (if (> 4 5)                               ; if-part
         (message "4 falsely greater than 5!") ; then-part
       (message "4 is not greater than 5!"))   ; else-part

     (defun type-of-animal (characteristic)  ; Second version.
       "Print message in echo area depending on CHARACTERISTIC.
     If the CHARACTERISTIC is the symbol `fierce',
     then warn of a tiger;
     else say it's not fierce."
       (if (equal characteristic 'fierce)
           (message "It's a tiger!")
         (message "It's not fierce!")))

     (type-of-animal 'fierce)

     (type-of-animal 'zebra)

     (if 4
         'true
       'false)

     (if nil
         'true
       'false)

     (> 5 4)

     (> 4 5)

     (save-excursion
       body...)

     (save-excursion
       first-expression-in-body
       second-expression-in-body
       third-expression-in-body
        ...
       last-expression-in-body)

     (let varlist
       (save-excursion
         body...))

          (defun back-to-indentation ()
            "Move point to first visible character on line."
            (interactive)
            (beginning-of-line 1)
            (skip-chars-forward " \t"))

          (let ((foo (buffer-name))
                (bar (buffer-size)))
            (message
             "This buffer is %s and has %d characters."
             foo bar))

          (message "We are %d characters into this buffer."
                   (- (point)
                      (save-excursion
                        (goto-char (point-min)) (point))))

          (if (= 22 emacs-major-version)
              (message "This is version 22 Emacs")
            (message "This is not version 22 Emacs"))

     M-x compile RET etags *.el RET

     (defun simplified-beginning-of-buffer ()
       "Move point to the beginning of the buffer;
     leave mark at previous position."
       (interactive)
       (push-mark)
       (goto-char (point-min)))

     (push-mark)
     (goto-char (point-min))

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

     (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)))

     (defun name-of-function (argument-list)
       "documentation..."
       (interactive-expression...)
       body...)

     (push-mark (point))
     (push-mark (point-max) nil t)
     (goto-char (point-min))

     (push-mark (point-max) nil t)

     (defun append-to-buffer (buffer start end)
       "Append to specified buffer the text of the region.
     It is inserted into that buffer before its point.

     When calling from a program, give three arguments:
     BUFFER (or buffer name), START and END.
     START and END specify the portion of the current buffer to be copied."
       (interactive
        (list (read-buffer "Append to buffer: " (other-buffer
                                                 (current-buffer) t))
              (region-beginning) (region-end)))
       (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))))))))

     (defun append-to-buffer (buffer start end)
       "documentation..."
       (interactive ...)
       body...)

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

     (other-buffer (current-buffer) t)

     (interactive "BAppend to buffer: \nr")

     (defun append-to-buffer (buffer start end)
       "documentation..."
       (interactive ...)
       (let ((variable value))
             body...)

     (oldbuf (current-buffer))

     (let ((oldbuf (current-buffer)))
       ... )

     (defun ...
       ...
       ...
       (let...
         (save-excursion
           ...

     (let ((oldbuf (current-buffer)))
       (save-excursion
         ...
         (set-buffer ...)
         (insert-buffer-substring oldbuf start end)
         ...))

     (save-excursion
       first-expression-in-body
       second-expression-in-body
        ...
       last-expression-in-body)

     (set-buffer (get-buffer-create buffer))

     (set-buffer append-to)

     (insert-buffer-substring oldbuf start end)

     (let (bind-oldbuf-to-value-of-current-buffer)
       (save-excursion                       ; Keep track of buffer.
         change-buffer
         insert-substring-from-oldbuf-into-buffer)

       change-back-to-original-buffer-when-finished
     let-the-local-meaning-of-oldbuf-disappear-when-finished

     ...
     (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)))))

     (with-current-buffer (get-buffer-create buffer) ...

     (let (bind-oldbuf-to-value-of-current-buffer)
         (with-the-buffer-you-are-copying-to
           (but-do-not-erase-or-copy-to-a-read-only-buffer)
           (erase-buffer)
           (save-excursion
             insert-substring-from-oldbuf-into-buffer)))

     (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: ")
       (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)))
           (insert-buffer-substring buffer start end)
           (setq newmark (point)))
         (push-mark newmark)))

     (defun insert-buffer (buffer)
       "documentation..."
       (interactive "*bInsert buffer: ")
       body...)

     (defun insert-buffer (buffer)
       "documentation..."
       (interactive "*bInsert buffer: ")
       (or ...
           ...
       (let (varlist)
           body-of-let... )

     (if (not (holding-on-to-guest))
         (find-and-take-arm-of-guest))

     (if (not (bufferp buffer))              ; if-part
         (setq buffer (get-buffer buffer)))  ; then-part

     (not (bufferp buffer))

     (or (bufferp buffer)
         (setq buffer (get-buffer buffer)))

     (or (holding-on-to-guest) (find-and-take-arm-of-guest))

     (save-excursion
       (set-buffer buffer)
       (setq start (point-min) end (point-max)))

     (save-excursion
       (inner-save-excursion-expression
          (go-to-new-buffer-and-set-start-and-end)
       (insert-buffer-substring buffer start end)
       (setq newmark (point)))

     (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))

       (push-mark
        (save-excursion
          (insert-buffer-substring (get-buffer buffer))
          (point)))

        nil

     (defun beginning-of-buffer (&optional arg)

     (defun beginning-of-buffer (&optional arg)
       "documentation..."
       (interactive "P")
       (or (is-the-argument-a-cons-cell arg)
           (and are-both-transient-mark-mode-and-mark-active-true)
           (push-mark))
       (let (determine-size-and-set-it)
       (goto-char
         (if-there-is-an-argument
             figure-out-where-to-go
           else-go-to
           (point-min))))
        do-nicety

     (if (> (buffer-size) 10000)
         ;; Avoid overflow for large buffer sizes!
                               (* (prefix-numeric-value arg)
                                  (/ size 10))
       (/
        (+ 10
           (*
            size (prefix-numeric-value arg))) 10)))

     (if (buffer-is-large
         divide-buffer-size-by-10-and-multiply-by-arg
       else-use-alternate-calculation

     (if (> size 10000)

     (*
       (prefix-numeric-value arg)
       (/ size 10))

     (* numeric-value-of-prefix-arg
        number-of-characters-in-one-tenth-of-the-accessible-buffer)

     (goto-char (* (prefix-numeric-value arg)
                   (/ size 10)))

     (/ (+ 10 (* size (prefix-numeric-value arg))) 10))

       (/
        (+ 10
           (*
            size
            (prefix-numeric-value arg)))
        10))

     (* size (prefix-numeric-value arg))

     (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.

     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))
       (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 arg (forward-line 1)))

     \\[universal-argument]

     (if arg (forward-line 1)))

     (save-restriction
       body... )

     (save-excursion
       (save-restriction
         body...))

       (save-restriction
         (widen)
         (save-excursion
         body...))

     (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)))))))

     (message "Line %d"
              (1+ (count-lines 1 (point)))))))

     (1+ (count-lines 1 (point)))

     (car '(rose violet daisy buttercup))

     (cdr '(rose violet daisy buttercup))

     (car '(pine fir oak maple))

     (cdr '(pine fir oak maple))

     (car '((lion tiger cheetah)
            (gazelle antelope zebra)
            (whale dolphin seal)))

     (cdr '((lion tiger cheetah)
            (gazelle antelope zebra)
            (whale dolphin seal)))

     (cons 'pine '(fir oak maple))

     (pine fir oak maple)

     (cons 'buttercup ())
          ⇒ (buttercup)

     (cons 'daisy '(buttercup))
          ⇒ (daisy buttercup)

     (cons 'violet '(daisy buttercup))
          ⇒ (violet daisy buttercup)

     (cons 'rose '(violet daisy buttercup))
          ⇒ (rose violet daisy buttercup)

     (length '(buttercup))
          ⇒ 1

     (length '(daisy buttercup))
          ⇒ 2

     (length (cons 'violet '(daisy buttercup)))
          ⇒ 3

     (length ())
          ⇒ 0

     (length )

     Lisp error: (wrong-number-of-arguments length 0)

     (cdr '(pine fir oak maple))
          ⇒(fir oak maple)

     (cdr '(fir oak maple))
          ⇒ (oak maple)

     (cdr '(oak maple))
          ⇒(maple)

     (cdr '(maple))
          ⇒ nil

     (cdr 'nil)
          ⇒ nil

     (cdr ())
          ⇒ nil

     (cdr (cdr '(pine fir oak maple)))
          ⇒ (oak maple)

     (nthcdr 2 '(pine fir oak maple))
          ⇒ (oak maple)

     ;; Leave the list as it was.
     (nthcdr 0 '(pine fir oak maple))
          ⇒ (pine fir oak maple)

     ;; Return a copy without the first element.
     (nthcdr 1 '(pine fir oak maple))
          ⇒ (fir oak maple)

     ;; Return a copy of the list without three elements.
     (nthcdr 3 '(pine fir oak maple))
          ⇒ (maple)

     ;; Return a copy lacking all four elements.
     (nthcdr 4 '(pine fir oak maple))
          ⇒ nil

     ;; Return a copy lacking all elements.
     (nthcdr 5 '(pine fir oak maple))
          ⇒ nil

     (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)))

     (nth 0 '("one" "two" "three"))
         ⇒ "one"

     (nth 1 '("one" "two" "three"))
         ⇒ "two"

     (setq animals '(antelope giraffe lion tiger))

     animals
          ⇒ (antelope giraffe lion tiger)

     (setcar animals 'hippopotamus)

     animals
          ⇒ (hippopotamus giraffe lion tiger)

     (setq domesticated-animals '(horse cow sheep goat))

     domesticated-animals
          ⇒ (horse cow sheep goat)

     (setcdr domesticated-animals '(cat dog))

     domesticated-animals
          ⇒ (horse cat dog)

     ("a piece of text" "previous piece")

     (cons "another piece"
           '("a piece of text" "previous piece"))

     ("another piece" "a piece of text" "previous piece")

     (car (nthcdr 1 '("another piece"
                      "a piece of text"
                      "previous piece")))
          ⇒ "a piece of text"

     (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))))

     (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)))

     (search-forward (char-to-string char) nil nil arg)

     (search-forward "target-string"
                     limit-of-search
                     what-to-do-if-search-fails
                     repeat-count)

     (progn
       body...)

     (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. ... "

       ;; • Since order matters, pass point first.
       (interactive (list (point) (mark)))
       ;; • And tell us if we cannot cut the text.
       ;; `unless' is an `if' without a then-part.
       (unless (and beg end)
         (error "The mark is not set now, so there is no region"))

       ;; • `condition-case' takes three arguments.
       ;;    If the first argument is nil, as it is here,
       ;;    information about the error signal is not
       ;;    stored for use by another function.
       (condition-case nil

           ;; • The second argument to `condition-case' tells the
           ;;    Lisp interpreter what to do when all goes well.

           ;;    It starts with a `let' function that extracts the string
           ;;    and tests whether it exists.  If so (that is what the
           ;;    `when' checks), it calls an `if' function that determines
           ;;    whether the previous command was another call to
           ;;    `kill-region'; if it was, then the new text is appended to
           ;;    the previous text; if not, then a different function,
           ;;    `kill-new', is called.

           ;;    The `kill-append' function concatenates the new string and
           ;;    the old.  The `kill-new' function inserts text into a new
           ;;    item in the kill ring.

           ;;    `when' is an `if' without an else-part.  The second `when'
           ;;    again checks whether the current string exists; in
           ;;    addition, it checks whether the previous command was
           ;;    another call to `kill-region'.  If one or the other
           ;;    condition is true, then it sets the current command to
           ;;    be `kill-region'.
           (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)
                   ;;    − `yank-handler' is an optional argument to
                   ;;    `kill-region' that tells the `kill-append' and
                   ;;    `kill-new' functions how deal with properties
                   ;;    added to the text, such as `bold' or `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)

         ;;  • The third argument to `condition-case' tells the interpreter
         ;;    what to do with an error.
         ;;    The third argument has a conditions part and a body part.
         ;;    If the conditions are met (in this case,
         ;;             if text or buffer are read-only)
         ;;    then the body is executed.
         ;;    The first part of the third argument is the following:
         ((buffer-read-only text-read-only) ;; the if-part
          ;; ...  the then-part
          (copy-region-as-kill beg end)
          ;;    Next, also as part of the then-part, set this-command, so
          ;;    it will be set in an error
          (setq this-command 'kill-region)
          ;;    Finally, in the then-part, send a message if you may copy
          ;;    the text to the kill ring without signaling an error, but
          ;;    don't if you may not.
          (if kill-read-only-ok
              (progn (message "Read only text copied to kill ring") nil)
            (barf-if-buffer-read-only)
            ;; If the buffer isn't read-only, the text is.
            (signal 'text-read-only (list (current-buffer)))))

     (condition-case
       var
       bodyform
       error-handler...)

     If no errors, run only this code
         but, if errors, run this other code.

     (if (eq last-command 'kill-region)
         (kill-append string (< end beg) yank-handler)
       (kill-new string nil yank-handler))

     (kill-append string (< end beg) yank-handler)

     (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")
       (if (eq last-command 'kill-region)
           (kill-append (filter-buffer-substring beg end) (< end beg))
         (kill-new (filter-buffer-substring beg end)))
       (if transient-mark-mode
           (setq deactivate-mark t))
       nil)

     (defun copy-region-as-kill (argument-list)
       "documentation..."
       (interactive "r")
       body...)

       (if (eq last-command 'kill-region)
           ;; then-part
           (kill-append  (filter-buffer-substring beg end) (< end beg))
         ;; else-part
         (kill-new  (filter-buffer-substring beg end)))

     (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.
     ... "
       (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)))

     (if before-p                            ; if-part
         (concat string cur)                 ; then-part
       (concat cur string))                  ; else-part

     (concat string cur)

     (concat cur string))

     (concat "abc" "def")
          ⇒ "abcdef"

     (concat "new "
             (car '("first element" "second element")))
          ⇒ "new first element"

     (concat (car
             '("first element" "second element")) " modified")
          ⇒ "first element modified"

     (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.
     ..."
       (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"))))
       (if (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)
         (push 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))))

     Make STRING the latest kill in the kill ring.

       (if (and replace kill-ring)
           ;; then
           (setcar kill-ring string)
         ;; else
       (push string kill-ring)
         (setq kill-ring (cons string kill-ring))
         (if (> (length kill-ring) kill-ring-max)
             ;; avoid overly long kill ring
             (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))))

     (setcar kill-ring string)

     (push string kill-ring)

     (setq kill-ring (cons string kill-ring))

     (add-to-list kill-ring string)

     (setq example-list '("here is a clause" "another clause"))

     example-list
          ⇒ ("here is a clause" "another clause")

     (push "a third clause" example-list)

     example-list
          ⇒ ("a third clause" "here is a clause" "another clause")

     (if (> (length kill-ring) kill-ring-max)
         (setcdr (nthcdr (1- kill-ring-max) kill-ring) nil))

     (setq trees '(maple oak pine birch))
          ⇒ (maple oak pine birch)

     (setcdr (nthcdr 2 trees) nil)
          ⇒ nil

     trees
          ⇒ (maple oak pine)

     (setq kill-ring-yank-pointer kill-ring)

       (if (fboundp 'menu-bar-update-yank-menu)
            (menu-bar-update-yank-menu string (and replace (car kill-ring))))

       (if interprogram-cut-function
           (funcall interprogram-cut-function string (not replace))))

     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 (XINT (start) == XINT (end))
         return empty_unibyte_string;
       return del_range_1 (XINT (start), XINT (end), 1, 1);
     }

     validate_region (&start, &end);
     if (XINT (start) == XINT (end))
       return empty_unibyte_string;
     return del_range_1 (XINT (start), XINT (end), 1, 1);

     del_range_1 (XINT (start), XINT (end), 1, 1);

     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
     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.

     (defvar kill-ring nil
       "List of killed text sequences.
     ...")

     (defvar shell-command-default-error-buffer nil
       "*Buffer name for `shell-command' ... error output.
     ... ")

          (car '(1 2 3 4 5 6 7))
               ⇒ 1
          (cdr '(1 2 3 4 5 6 7))
               ⇒ (2 3 4 5 6 7)

          (cons 1 '(2 3 4))
               ⇒ (1 2 3 4)

          (nthcdr 3 '(1 2 3 4 5 6 7))
               ⇒ (4 5 6 7)

          (setq triple '(1 2 3))

          (setcar triple '37)

          triple
               ⇒ (37 2 3)

          (setcdr triple '("foo" "bar"))

          triple
               ⇒ (37 "foo" "bar")

          (progn 1 2 3 4)
               ⇒ 4

         ___ ___      ___ ___      ___ ___
        |___|___|--> |___|___|--> |___|___|--> nil
          |            |            |
          |            |            |
           --> rose     --> violet   --> buttercup

     (setq bouquet '(rose violet buttercup))

     bouquet
          |
          |     ___ ___      ___ ___      ___ ___
           --> |___|___|--> |___|___|--> |___|___|--> nil
                 |            |            |
                 |            |            |
                  --> rose     --> violet   --> buttercup

     bouquet
      |
      |    --------------       ---------------       ----------------
      |   | car   | cdr  |     | car    | cdr  |     | car     | cdr  |
       -->| rose  |   o------->| violet |   o------->| butter- |  nil |
          |       |      |     |        |      |     | cup     |      |
           --------------       ---------------       ----------------

     (setq flowers (cdr bouquet))

     bouquet        flowers
       |              |
       |     ___ ___  |     ___ ___      ___ ___
        --> |   |   |  --> |   |   |    |   |   |
            |___|___|----> |___|___|--> |___|___|--> nil
              |              |            |
              |              |            |
               --> rose       --> violet   --> buttercup

     (setq bouquet (cons 'lily bouquet))

     bouquet                       flowers
       |                             |
       |     ___ ___        ___ ___  |     ___ ___       ___ ___
        --> |   |   |      |   |   |  --> |   |   |     |   |   |
            |___|___|----> |___|___|----> |___|___|---->|___|___|--> nil
              |              |              |             |
              |              |              |             |
               --> lily      --> rose       --> violet    --> buttercup

     (eq (cdr (cdr bouquet)) flowers)

                 Chest of Drawers            Contents of Drawers

                 __   o0O0o   __
               /                 \
              ---------------------
             |    directions to    |            [map to]
             |     symbol name     |             bouquet
             |                     |
             +---------------------+
             |    directions to    |
             |  symbol definition  |             [none]
             |                     |
             +---------------------+
             |    directions to    |            [map to]
             |    variable value   |             (rose violet buttercup)
             |                     |
             +---------------------+
             |    directions to    |
             |    property list    |             [not described here]
             |                     |
             +---------------------+
             |/                   \|

     ("some text" "a different piece of text" "yet more text")

     (insert (car kill-ring-yank-pointer))

     ("some text" "a different piece of text" "yet more text")

     ("a different piece of text" "yet more text")

     kill-ring     kill-ring-yank-pointer
         |               |
         |      ___ ___  |     ___ ___      ___ ___
          ---> |   |   |  --> |   |   |    |   |   |
               |___|___|----> |___|___|--> |___|___|--> nil
                 |              |            |
                 |              |            |
                 |              |             --> "yet more text"
                 |              |
                 |               --> "a different piece of text"
                 |
                  --> "some text"

     (while true-or-false-test
       body...)

     (setq empty-list ())

     empty-list

     (setq animals '(gazelle giraffe lion tiger))

     animals

     (while animals
            ...

     (setq animals (cdr animals))

     (while test-whether-list-is-empty
       body...
       set-list-to-cdr-of-list)

     (setq animals '(gazelle giraffe lion tiger))

     (defun print-elements-of-list (list)
       "Print each element of LIST on a line of its own."
       (while list
         (print (car list))
         (setq list (cdr list))))

     (print-elements-of-list animals)

     gazelle

     giraffe

     lion

     tiger
     nil

     set-count-to-initial-value
     (while (< count desired-number)         ; true-or-false-test
       body...
       (setq count (1+ count)))              ; incrementer

                    *
                   * *
                  * * *
                 * * * *

       (let ((total 0)
             (row-number 1))
         body...)

     (<= row-number number-of-rows)

     (setq total (+ total row-number))

     (setq row-number (1+ row-number))

     (while (<= row-number number-of-rows)   ; true-or-false-test
       (setq total (+ total row-number))
       (setq row-number (1+ row-number)))    ; incrementer

     (defun name-of-function (argument-list)
       "documentation..."
       (let (varlist)
         (while (true-or-false-test)
           body-of-while... )
         ... ))                    ; Need final expression here.

     (let (varlist) (while (true-or-false-test) body-of-while... ) total)

     (defun triangle (number-of-rows)    ; Version with
                                         ;   incrementing counter.
       "Add up the number of pebbles in a triangle.
     The first row has one pebble, the second row two pebbles,
     the third row three pebbles, and so on.
     The argument is NUMBER-OF-ROWS."
       (let ((total 0)
             (row-number 1))
         (while (<= row-number number-of-rows)
           (setq total (+ total row-number))
           (setq row-number (1+ row-number)))
         total))

     (triangle 4)

     (triangle 7)

     (while (> counter 0)                    ; true-or-false-test
       body...
       (setq counter (1- counter)))          ; decrementer

     (let ((total 0)
           (number-of-pebbles-in-row number-of-rows))
       body...)

     (setq total (+ total number-of-pebbles-in-row))

     (setq number-of-pebbles-in-row
           (1- number-of-pebbles-in-row))

     (while (> number-of-pebbles-in-row 0)

     ;;; First subtractive version.
     (defun triangle (number-of-rows)
       "Add up the number of pebbles in a triangle."
       (let ((total 0)
             (number-of-pebbles-in-row number-of-rows))
         (while (> number-of-pebbles-in-row 0)
           (setq total (+ total number-of-pebbles-in-row))
           (setq number-of-pebbles-in-row
                 (1- number-of-pebbles-in-row)))
         total))

     (defun triangle (number)                ; Second version.
       "Return sum of numbers 1 through NUMBER inclusive."
       (let ((total 0))
         (while (> number 0)
           (setq total (+ total number))
           (setq number (1- number)))
         total))

from text.blob import TextBlob

text = '''
The titular threat of The Blob has always struck me as the ultimate movie
monster: an insatiably hungry, amoeba-like mass able to penetrate
virtually any safeguard, capable of--as a doomed doctor chillingly
describes it--"assimilating flesh on contact.
Snide comparisons to gelatin be damned, it's a concept with the most
devastating of potential consequences, not unlike the grey goo scenario
proposed by technological theorists fearful of
artificial intelligence run rampant.
'''

blob = TextBlob(text)
blob.tags           # [(u'The', u'DT'), (u'titular', u'JJ'),
                    #  (u'threat', u'NN'), (u'of', u'IN'), ...]

blob.noun_phrases   # WordList(['titular threat', 'blob',
                    #            'ultimate movie monster',
                    #            'amoeba-like mass', ...])

for sentence in blob.sentences:
    print(sentence.sentiment)  # returns (polarity, subjectivity)
# (0.060, 0.605)
# (-0.341, 0.767)

blob.translate(to="es")  # 'La amenaza titular de The Blob...' 

$ pip install -U textblob
$ curl https://raw.github.com/sloria/TextBlob/master/download_corpora.py | python
module Lambda where

open import Data.Nat using (ℕ; zero; suc; _+_; _≤?_; _≥_)
open import Data.Fin using (Fin; zero; suc; toℕ)
open import Data.List using (List; []; _∷_; length)
open import Data.Vec using (Vec; []; _∷_; lookup)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong; cong₂)
open import Relation.Nullary using (Dec; yes; no)
open import Function using (_∘_; _$_)
open import Data.Product
data Dec (P : Set) : Set where
  yes : ( p :   P) → Dec P
  no  : (¬p : ¬ P) → Dec P
infixr 30 _⇒_
data Type : Set where
  nat : Type
  _⇒_ : Type → Type → Type
infixl 80 _·_
data Syntax : Set where
  -- A variable, the ℕ being a de Bruijn index.
  var : ℕ → Syntax
  -- A number literal.
  lit : ℕ → Syntax
  -- Addition.
  _⊕_ : Syntax → Syntax → Syntax
  -- Function application.
  _·_ : Syntax → Syntax → Syntax
  -- Lambda abstraction, the type indicates the type of the argument: no
  -- type inference here.
  lam : Type → Syntax → Syntax
Ctx : ℕ → Set
Ctx = Vec Type
data Term {n} (Γ : Ctx n) : Type → Set where
  var : ∀ {τ} (v : Fin n) → τ ≡ lookup v Γ → Term Γ τ
  lit : ℕ → Term Γ nat
  _⊕_ : Term Γ nat → Term Γ nat → Term Γ nat
  _·_ : ∀ {σ τ} → Term Γ (σ ⇒ τ) → Term Γ σ → Term Γ τ
  lam : ∀ σ {τ} → Term (σ ∷ Γ) τ → Term Γ (σ ⇒ τ)
var : (v : Fin n) → Term Γ (lookup v Γ)
lookup : ∀ {n} {A : Set} → Fin n → Vec A n → A
Closed : Type → Set
Closed = Term []
double : Closed (nat ⇒ nat)
double = lam nat (var zero refl ⊕ var zero refl)
erase : ∀ {n} {Γ : Ctx n} {τ} → Term Γ τ → Syntax
erase (var v _) = var (toℕ v)
erase (lit n)   = lit n
erase (t ⊕ u)   = erase t ⊕ erase u
erase (t · u)   = erase t · erase u
erase (lam σ t) = lam σ (erase t)
≡⇒₁ : ∀ {σ σ′ τ τ′} → σ ⇒ τ ≡ σ′ ⇒ τ′ → σ ≡ σ′
≡⇒₁ refl = refl
≡⇒₂ : ∀ {σ σ′ τ τ′} → σ ⇒ τ ≡ σ′ ⇒ τ′ → τ ≡ τ′
≡⇒₂ refl = refl
_≟_ : (τ σ : Type) → Dec (τ ≡ σ)
nat   ≟ nat   = yes refl
nat   ≟ _ ⇒ _ = no λ()
_ ⇒ _ ≟ nat   = no λ()
σ ⇒ τ ≟ σ′ ⇒ τ′ with σ ≟ σ′ | τ ≟ τ′
σ ⇒ τ ≟ .σ ⇒ .τ | yes refl | yes refl = yes refl
σ ⇒ τ ≟ σ′ ⇒ τ′ | no  σ≢σ′ | _        = no (σ≢σ′ ∘ ≡⇒₁)
σ ⇒ τ ≟ σ′ ⇒ τ′ | _        | no τ≢τ′  = no (τ≢τ′ ∘ ≡⇒₂)
data Fromℕ (n : ℕ) : ℕ → Set where
  yes : (m : Fin n) → Fromℕ n (toℕ m)
  no  : (m : ℕ)     → Fromℕ n (n + m)
fromℕ : ∀ n m → Fromℕ n m
fromℕ zero    m    = no m
fromℕ (suc n) zero = yes zero
fromℕ (suc n) (suc m) with fromℕ n m
fromℕ (suc n) (suc .(toℕ m)) | yes m = yes (suc m)
fromℕ (suc n) (suc .(n + m)) | no  m = no m
data Check {n} (Γ : Ctx n) : Syntax → Set where
  yes : (τ : Type) (t : Term Γ τ) → Check Γ (erase t)
  no  : {e : Syntax} → Check Γ e
check : ∀ {n} (Γ : Ctx n) (t : Syntax) → Check Γ t
check {n} Γ (var v) with fromℕ n v
check {n} Γ (var .(toℕ v)) | yes v = yes (lookup v Γ) (var v refl)
check {n} Γ (var .(n + m)) | no  m = no
check Γ (lit n) = yes nat (lit n)
check Γ (t ⊕ u) with check Γ t | check Γ u
check Γ (.(erase t) ⊕ .(erase u)) | yes nat t | yes nat u = yes nat (t ⊕ u)
check Γ (_ ⊕ _)                   | _         | _         = no
check Γ (t ⊕ u) with check Γ t | check Γ u
check Γ (t ⊕ u) | p1 | p2 = {!!}
check Γ (.(erase t) ⊕ u) | yes τ t | p2 = {!!}
check Γ (.(erase t) ⊕ .(erase u)) | yes nat t | yes nat u = {!!}
Check Γ (erase t ⊕ erase u)
check Γ (t · u) with check Γ t | check Γ u
check Γ (.(erase t) · .(erase u)) | yes (σ ⇒ τ) t | yes σ′ u with σ ≟ σ′
check Γ (.(erase t) · .(erase u)) | yes (σ ⇒ τ) t | yes .σ u | yes refl = yes τ (t · u)
check Γ (.(erase t) · .(erase u)) | yes (σ ⇒ τ) t | yes σ′ u | no  _    = no
check Γ (t · u)                   | _             | _       = no
check Γ (lam σ t) with check (σ ∷ Γ) t
check Γ (lam σ .(erase t)) | yes τ t = yes (σ ⇒ τ) (lam σ t)
check Γ (lam σ t)          | no      = no
> C-c C-n check [] (lam nat (var 0 ⊕ var 0))
yes (nat ⇒ nat) (lam nat (var zero refl ⊕ var zero refl))
> C-c C-n check [] (lam nat (var 0 · var 0))
no

> C-c C-n check [] (lam (nat ⇒ nat) (var 0 ⊕ var 0))
no
⟦_⟧ : Type → Set
⟦ nat   ⟧ = ℕ
⟦ σ ⇒ τ ⟧ = ⟦ σ ⟧ → ⟦ τ ⟧
infixr 5 _∷_
data Env : ∀ {n} → Ctx n → Set where
  []  : Env []
  _∷_ : ∀ {n} {Γ : Ctx n} {τ} → ⟦ τ ⟧ → Env Γ → Env (τ ∷ Γ)
lookupEnv : ∀ {n} {Γ : Ctx n} (m : Fin n) → Env Γ → ⟦ lookup m Γ ⟧
lookupEnv zero    (x ∷ _)   = x
lookupEnv (suc n) (_ ∷ env) = lookupEnv n env
_[_] : ∀ {n} {Γ : Ctx n} {τ} → Env Γ → Term Γ τ → ⟦ τ ⟧
env [ var v refl ] = lookupEnv v env
env [ lit n      ] = n
env [ t ⊕ u      ] = env [ t ] + env [ u ]
env [ t · u      ] = (env [ t ]) (env [ u ])
env [ lam _ t    ] = λ x → (x ∷ env) [ t ]
double′ : ⟦ nat ⇒ nat ⟧
double′ = [] [ double ] -- A closed term, in an empty environment

doubleTest : double′ 3 ≡ 6
doubleTest = refl
record Optimised {n} {Γ : Ctx n} {σ} (t : Term Γ σ) : Set where
  constructor opt
  field
    optimised : Term Γ σ
    sound     : ∀ {env} → env [ t ] ≡ env [ optimised ]
postulate ext : ∀ {A B : Set} {f g : A → B} → ({x : A} → f x ≡ g x) → f ≡ g
lit 3 ⊕ lit 7
lit 10
cfold : ∀ {n} {Γ : Ctx n} {τ} (t : Term Γ τ) → Optimised t
cfold (var v p) = opt (var v p) refl
cfold (lit x)   = opt (lit x)   refl
cong₂ : {A B C : Set} (f : A → B → C) {x y u v} → x ≡ y → u ≡ v → f x u ≡ f y v
_$_   : ∀ {A : Set} {B : A → Set} → ((x : A) → B x) → ((x : A) → B x)
cong₂ _$_ : {A B : Set} {f g : A → B} {x y : A} → f ≡ g → x ≡ y → (f $ x) ≡ (g $ y)
cfold (t · u) with cfold t | cfold u
... | opt t′ p | opt u′ q = opt (t′ · u′) (cong₂ _$_ p q)
cfold (lam σ t) with cfold t
... | opt t′ p = opt (lam σ t′) (ext p)
cfold (t ⊕ u) with cfold t | cfold u
... | opt (lit n) p | opt (lit m) q = opt (lit (n + m)) (cong₂ _+_ p q)
... | opt t′      p | opt u′      q = opt (t′ ⊕ u′) (cong₂ _+_ p q)
fac n = if n == 0 
           then 1
           else n * fac (n-1)

fac = (\(n) ->
        (if ((==) n 0)
            then 1
            else ((*) n (fac ((-) n 1)))))

fac  0    =  1
fac (n+1) = (n+1) * fac n

fac 0 = 1
fac n = n * fac (n-1)

fac n = foldr (*) 1 [1..n]

fac n = foldl (*) 1 [1..n]

-- using foldr to simulate foldl

fac n = foldr (\x g n -> g (x*n)) id [1..n] 1

facs = scanl (*) 1 [1..]

fac n = facs !! n

fac = foldr (*) 1 . enumFromTo 1

fac n = result (for init next done)
        where init = (0,1)
              next   (i,m) = (i+1, m * (i+1))
              done   (i,_) = i==n
              result (_,m) = m

for i n d = until d n i

fac n = snd (until ((>n) . fst) (\(i,m) -> (i+1, i*m)) (1,1))

facAcc a 0 = a
facAcc a n = facAcc (n*a) (n-1)

fac = facAcc 1

facCps k 0 = k 1
facCps k n = facCps (k . (n *)) (n-1)

fac = facCps id

y f = f (y f)

fac = y (\f n -> if (n==0) then 1 else n * f (n-1))

s f g x = f x (g x)

k x y   = x

b f g x = f (g x)

c f g x = f x g

y f     = f (y f)

cond p f g x = if p x then f x else g x

fac  = y (b (cond ((==) 0) (k 1)) (b (s (*)) (c b pred)))

arb = ()    -- "undefined" is also a good RHS, as is "arb" :)

listenc n = replicate n arb
listprj f = length . f . listenc

listprod xs ys = [ i (x,y) | x<-xs, y<-ys ]
                 where i _ = arb

facl []         = listenc  1
facl n@(_:pred) = listprod n (facl pred)

fac = listprj facl

-- a dynamically-typed term language

data Term = Occ Var
          | Use Prim
          | Lit Integer
          | App Term Term
          | Abs Var  Term
          | Rec Var  Term

type Var  = String
type Prim = String

-- a domain of values, including functions

data Value = Num  Integer
           | Bool Bool
           | Fun (Value -> Value)

instance Show Value where
  show (Num  n) = show n
  show (Bool b) = show b
  show (Fun  _) = ""

prjFun (Fun f) = f
prjFun  _      = error "bad function value"

prjNum (Num n) = n
prjNum  _      = error "bad numeric value"

prjBool (Bool b) = b
prjBool  _       = error "bad boolean value"

binOp inj f = Fun (\i -> (Fun (\j -> inj (f (prjNum i) (prjNum j)))))

-- environments mapping variables to values

type Env = [(Var, Value)]

getval x env =  case lookup x env of
                  Just v  -> v
                  Nothing -> error ("no value for " ++ x)

-- an environment-based evaluation function

eval env (Occ x) = getval x env
eval env (Use c) = getval c prims
eval env (Lit k) = Num k
eval env (App m n) = prjFun (eval env m) (eval env n)
eval env (Abs x m) = Fun  (\v -> eval ((x,v) : env) m)
eval env (Rec x m) = f where f = eval ((x,f) : env) m

-- a (fixed) "environment" of language primitives

times = binOp Num  (*)
minus = binOp Num  (-)
equal = binOp Bool (==)
cond  = Fun (\b -> Fun (\x -> Fun (\y -> if (prjBool b) then x else y)))

prims = [ ("*", times), ("-", minus), ("==", equal), ("if", cond) ]

-- a term representing factorial and a "wrapper" for evaluation

facTerm = Rec "f" (Abs "n" 
              (App (App (App (Use "if")
                   (App (App (Use "==") (Occ "n")) (Lit 0))) (Lit 1))
                   (App (App (Use "*")  (Occ "n"))
                        (App (Occ "f")  
                             (App (App (Use "-") (Occ "n")) (Lit 1))))))

fac n = prjNum (eval [] (App facTerm (Lit n)))

-- static Peano constructors and numerals

data Zero
data Succ n

type One   = Succ Zero
type Two   = Succ One
type Three = Succ Two
type Four  = Succ Three

-- dynamic representatives for static Peanos

zero  = undefined :: Zero
one   = undefined :: One
two   = undefined :: Two
three = undefined :: Three
four  = undefined :: Four

-- addition, a la Prolog

class Add a b c | a b -> c where
  add :: a -> b -> c

instance              Add  Zero    b  b
instance Add a b c => Add (Succ a) b (Succ c)

-- multiplication, a la Prolog

class Mul a b c | a b -> c where
  mul :: a -> b -> c

instance                           Mul  Zero    b Zero
instance (Mul a b c, Add b c d) => Mul (Succ a) b d

-- factorial, a la Prolog

class Fac a b | a -> b where
  fac :: a -> b

instance                                Fac  Zero    One
instance (Fac n k, Mul (Succ n) k m) => Fac (Succ n) m

-- try, for "instance" (sorry):
-- 
--     :t fac four

-- the natural numbers, a la Peano

data Nat = Zero | Succ Nat

-- iteration and some applications

iter z s  Zero    = z
iter z s (Succ n) = s (iter z s n)

plus n = iter n     Succ
mult n = iter Zero (plus n)

-- primitive recursion

primrec z s  Zero    = z
primrec z s (Succ n) = s n (primrec z s n)

-- two versions of factorial

fac  = snd . iter (one, one) (\(a,b) -> (Succ a, mult a b))
fac' = primrec one (mult . Succ)

-- for convenience and testing (try e.g. "fac five")

int = iter 0 (1+)

instance Show Nat where
  show = show . int

(zero : one : two : three : four : five : _) = iterate Succ Zero

-- (curried, list) fold and an application

fold c n []     = n
fold c n (x:xs) = c x (fold c n xs)

prod = fold (*) 1

-- (curried, boolean-based, list) unfold and an application

unfold p f g x = 
  if p x 
     then [] 
     else f x : unfold p f g (g x)

downfrom = unfold (==0) id pred

-- hylomorphisms, as-is or "unfolded" (ouch! sorry ...)

refold  c n p f g   = fold c n . unfold p f g

refold' c n p f g x = 
  if p x 
     then n 
     else c (f x) (refold' c n p f g (g x))

-- several versions of factorial, all (extensionally) equivalent

fac   = prod . downfrom
fac'  = refold  (*) 1 (==0) id pred
fac'' = refold' (*) 1 (==0) id pred

-- (product-based, list) catamorphisms and an application

cata (n,c) []     = n
cata (n,c) (x:xs) = c (x, cata (n,c) xs)

mult = uncurry (*)
prod = cata (1, mult)

-- (co-product-based, list) anamorphisms and an application

ana f = either (const []) (cons . pair (id, ana f)) . f

cons = uncurry (:)

downfrom = ana uncount

uncount 0 = Left  ()
uncount n = Right (n, n-1)

-- two variations on list hylomorphisms

hylo  f  g    = cata g . ana f

hylo' f (n,c) = either (const n) (c . pair (id, hylo' f (c,n))) . f

pair (f,g) (x,y) = (f x, g y)

-- several versions of factorial, all (extensionally) equivalent

fac   = prod . downfrom
fac'  = hylo  uncount (1, mult)
fac'' = hylo' uncount (1, mult)

-- explicit type recursion based on functors

newtype Mu f = Mu (f (Mu f))  deriving Show

in      x  = Mu x
out (Mu x) = x

-- cata- and ana-morphisms, now for *arbitrary* (regular) base functors

cata phi = phi . fmap (cata phi) . out
ana  psi = in  . fmap (ana  psi) . psi

-- base functor and data type for natural numbers,
-- using a curried elimination operator

data N b = Zero | Succ b  deriving Show

instance Functor N where
  fmap f = nelim Zero (Succ . f)

nelim z s  Zero    = z
nelim z s (Succ n) = s n

type Nat = Mu N

-- conversion to internal numbers, conveniences and applications

int = cata (nelim 0 (1+))

instance Show Nat where
  show = show . int

zero = in   Zero
suck = in . Succ       -- pardon my "French" (Prelude conflict)

plus n = cata (nelim n     suck   )
mult n = cata (nelim zero (plus n))

-- base functor and data type for lists

data L a b = Nil | Cons a b  deriving Show

instance Functor (L a) where
  fmap f = lelim Nil (\a b -> Cons a (f b))

lelim n c  Nil       = n
lelim n c (Cons a b) = c a b

type List a = Mu (L a)

-- conversion to internal lists, conveniences and applications

list = cata (lelim [] (:))

instance Show a => Show (List a) where
  show = show . list

prod = cata (lelim (suck zero) mult)

upto = ana (nelim Nil (diag (Cons . suck)) . out)

diag f x = f x x

fac = prod . upto

-- explicit type recursion with functors and catamorphisms

newtype Mu f = In (f (Mu f))

unIn (In x) = x

cata phi = phi . fmap (cata phi) . unIn

-- base functor and data type for natural numbers,
-- using locally-defined "eliminators"

data N c = Z | S c

instance Functor N where
  fmap g  Z    = Z
  fmap g (S x) = S (g x)

type Nat = Mu N

zero   = In  Z
suck n = In (S n)

add m = cata phi where
  phi  Z    = m
  phi (S f) = suck f

mult m = cata phi where
  phi  Z    = zero
  phi (S f) = add m f

-- explicit products and their functorial action

data Prod e c = Pair c e

outl (Pair x y) = x
outr (Pair x y) = y

fork f g x = Pair (f x) (g x)

instance Functor (Prod e) where
  fmap g = fork (g . outl) outr

-- comonads, the categorical "opposite" of monads

class Functor n => Comonad n where
  extr :: n a -> a
  dupl :: n a -> n (n a)

instance Comonad (Prod e) where
  extr = outl
  dupl = fork id outr

-- generalized catamorphisms, zygomorphisms and paramorphisms

gcata :: (Functor f, Comonad n) =>
           (forall a. f (n a) -> n (f a))
             -> (f (n c) -> c) -> Mu f -> c

gcata dist phi = extr . cata (fmap phi . dist . fmap dupl)

zygo chi = gcata (fork (fmap outl) (chi . fmap outr))

para :: Functor f => (f (Prod (Mu f) c) -> c) -> Mu f -> c
para = zygo In

-- factorial, the *hard* way!

fac = para phi where
  phi  Z             = suck zero
  phi (S (Pair f n)) = mult f (suck n)

-- for convenience and testing

int = cata phi where
  phi  Z    = 0
  phi (S f) = 1 + f

instance Show (Mu N) where
  show = show . int

fac n = product [1..n]

package main
import "fmt"
func main() {
            fmt.Println("Hello, World!")
}

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

Named	de Bruijn
`λx → x`	`λ 1`
`λx → λy → x`	`λ λ 2`
`λx → λy → λz → x z (y z)`	`λ λ λ 3 1 (2 1)`

Operating system	Architectures	Notes
FreeBSD 7 or later	amd64, 386	Debian GNU/kFreeBSD not supported
Linux 2.6.23 or later with glibc	amd64, 386, arm	CentOS/RHEL 5.x not supported; no binary distribution for ARM yet
Mac OS X 10.6/10.7	amd64, 386	use the gcc† that comes with Xcode
Windows 2000 or later	amd64, 386	use mingw gcc†; cygwin or msys is not needed

build	compile packages and dependencies
clean	remove object files
doc	run godoc on package sources
env	print Go environment information
fix	run go tool fix on packages
fmt	run gofmt on package sources
get	download and install packages and dependencies
install	compile and install packages and dependencies
list	list packages
run	compile and run Go program
test	test packages
tool	run specified go tool
version	print Go version
vet	run go tool vet on packages

List Processing
Lisp Lists	What are lists?
Run a Program	Any list in Lisp is a program ready to run.
Making Errors	Generating an error message.
Names & Definitions	Names of symbols and function definitions.
Lisp Interpreter	What the Lisp interpreter does.
Evaluation	Running a program.
Variables	Returning a value from a variable.
Arguments	Passing information to a function.
set & setq	Setting the value of a variable.
Summary	The major points.
Error Message Exercises
Lisp Lists
Numbers Lists	List have numbers, other lists, in them.
Lisp Atoms	Elemental entities.
Whitespace in Lists	Formatting lists to be readable.
Typing Lists	How GNU Emacs helps you type lists.
The Lisp Interpreter
Complications	Variables, Special forms, Lists within.
Byte Compiling	Specially processing code for speed.
Evaluation
How the Interpreter Acts	Returns and Side Effects...
Evaluating Inner Lists	Lists within lists...
Variables
fill-column Example
Void Function	The error message for a symbol without a function.
Void Variable	The error message for a symbol without a value.
Arguments
Data types	Types of data passed to a function.
Args as Variable or List	An argument can be the value of a variable or list.
Variable Number of Arguments	Some functions may take a variable number of arguments.
Wrong Type of Argument	Passing an argument of the wrong type to a function.
message	A useful function for sending messages.
Setting the Value of a Variable
Using set	Setting values.
Using setq	Setting a quoted value.
Counting	Using `setq` to count.
Practicing Evaluation
How to Evaluate	Typing editing commands or `C-x C-e` causes evaluation.
Buffer Names	Buffers and files are different.
Getting Buffers	Getting a buffer itself, not merely its name.
Switching Buffers	How to change to another buffer.
Buffer Size & Locations	Where point is located and the size of the buffer.
Evaluation Exercise
How To Write Function Definitions
Primitive Functions
defun	The `defun` special form.
Install	Install a function definition.
Interactive	Making a function interactive.
Interactive Options	Different options for `interactive`.
Permanent Installation	Installing code permanently.
let	Creating and initializing local variables.
if	What if?
else	If--then--else expressions.
Truth & Falsehood	What Lisp considers false and true.
save-excursion	Keeping track of point, mark, and buffer.
Review
defun Exercises
Install a Function Definition
Effect of installation
Change a defun	How to change a function definition.
Make a Function Interactive
Interactive multiply-by-seven	An overview.
multiply-by-seven in detail	The interactive version.
`let`
Prevent confusion
Parts of let Expression
Sample let Expression
Uninitialized let Variables
The `if` Special Form
if in more detail
type-of-animal in detail	An example of an `if` expression.
Truth and Falsehood in Emacs Lisp
nil explained	`nil` has two meanings.
`save-excursion`
Point and mark	A review of various locations.
Template for save-excursion
A Few Buffer--Related Functions
Finding More	How to find more information.
simplified-beginning-of-buffer	Shows `goto-char`, `point-min`, and `push-mark`.
mark-whole-buffer	Almost the same as `beginning-of-buffer`.
append-to-buffer	Uses `save-excursion` and `insert-buffer-substring`.
Buffer Related Review	Review.
Buffer Exercises
The Definition of `mark-whole-buffer`
mark-whole-buffer overview
Body of mark-whole-buffer	Only three lines of code.
The Definition of `append-to-buffer`
append-to-buffer overview
append interactive	A two part interactive expression.
append-to-buffer body	Incorporates a `let` expression.
append save-excursion	How the `save-excursion` works.
A Few More Complex Functions
copy-to-buffer	With `set-buffer`, `get-buffer-create`.
insert-buffer	Read-only, and with `or`.
beginning-of-buffer	Shows `goto-char`, `point-min`, and `push-mark`.
Second Buffer Related Review
optional Exercise
The Definition of `insert-buffer`
insert-buffer code
insert-buffer interactive	When you can read, but not write.
insert-buffer body	The body has an `or` and a `let`.
if & or	Using an `if` instead of an `or`.
Insert or	How the `or` expression works.
Insert let	Two `save-excursion` expressions.
New insert-buffer
The Interactive Expression in `insert-buffer`
Read-only buffer	When a buffer cannot be modified.
b for interactive	An existing buffer or else its name.
Complete Definition of `beginning-of-buffer`
Optional Arguments
beginning-of-buffer opt arg	Example with optional argument.
beginning-of-buffer complete
`beginning-of-buffer` with an Argument
Disentangle beginning-of-buffer
Large buffer case
Small buffer case
Narrowing and Widening
Narrowing advantages	The advantages of narrowing
save-restriction	The `save-restriction` special form.
what-line	The number of the line that point is on.
narrow Exercise
`car`, `cdr`, `cons`: Fundamental Functions
Strange Names	An historical aside: why the strange names?
car & cdr	Functions for extracting part of a list.
cons	Constructing a list.
nthcdr	Calling `cdr` repeatedly.
nth
setcar	Changing the first element of a list.
setcdr	Changing the rest of a list.
cons Exercise
`cons`
Build a list
length	How to find the length of a list.
Cutting and Storing Text
Storing Text	Text is stored in a list.
zap-to-char	Cutting out text up to a character.
kill-region	Cutting text out of a region.
copy-region-as-kill	A definition for copying text.
Digression into C	Minor note on C programming language macros.
defvar	How to give a variable an initial value.
cons & search-fwd Review
search Exercises
`zap-to-char`
Complete zap-to-char	The complete implementation.
zap-to-char interactive	A three part interactive expression.
zap-to-char body	A short overview.
search-forward	How to search for a string.
progn	The `progn` special form.
Summing up zap-to-char	Using `point` and `search-forward`.
`kill-region`
Complete kill-region	The function definition.
condition-case	Dealing with a problem.
Lisp macro
`copy-region-as-kill`
Complete copy-region-as-kill	The complete function definition.
copy-region-as-kill body	The body of `copy-region-as-kill`.
The Body of `copy-region-as-kill`
last-command & this-command
kill-append function
kill-new function
Initializing a Variable with `defvar`
See variable current value
defvar and asterisk
How Lists are Implemented
Lists diagrammed
Symbols as Chest	Exploring a powerful metaphor.
List Exercise
Yanking Text Back
Kill Ring Overview
kill-ring-yank-pointer	The kill ring is a list.
yank nthcdr Exercises	The `kill-ring-yank-pointer` variable.
Loops and Recursion
while	Causing a stretch of code to repeat.
dolist dotimes
Recursion	Causing a function to call itself.
Looping exercise
`while`
Looping with while	Repeat so long as test returns true.
Loop Example	A `while` loop that uses a list.
print-elements-of-list	Uses `while`, `car`, `cdr`.
Incrementing Loop	A loop with an incrementing counter.
Incrementing Loop Details
Decrementing Loop	A loop with a decrementing counter.
Details of an Incrementing Loop
Incrementing Example	Counting pebbles in a triangle.
Inc Example parts	The parts of the function definition.
Inc Example altogether	Putting the function definition together.
Loop with a Decrementing Counter
Decrementing Example	More pebbles on the beach.
Dec Example parts	The parts of the function definition.
Dec Example altogether	Putting the function definition together.
Save your time: `dolist` and `dotimes`
dolist
dotimes
Recursion
Building Robots	Same model, different serial number ...
Recursive Definition Parts	Walk until you stop ...
Recursion with list	Using a list as the test whether to recurse.
Recursive triangle function
Recursion with cond
Recursive Patterns	Often used templates.
No Deferment	Don't store up work ...
No deferment solution
Recursion in Place of a Counter
Recursive Example arg of 1 or 2
Recursive Example arg of 3 or 4
Recursive Patterns
Every
Accumulate
Keep
Regular Expression Searches
sentence-end	The regular expression for `sentence-end`.
re-search-forward	Very similar to `search-forward`.
forward-sentence	A straightforward example of regexp search.
forward-paragraph	A somewhat complex example.
etags	How to create your own `TAGS` table.
Regexp Review
re-search Exercises
`forward-sentence`
Complete forward-sentence
fwd-sentence while loops	Two `while` loops.
fwd-sentence re-search	A regular expression search.
`forward-paragraph`: a Goldmine of Functions
forward-paragraph in brief	Key parts of the function definition.
fwd-para let	The `let*` expression.
fwd-para while	The forward motion `while` loop.
Counting: Repetition and Regexps
Why Count Words
count-words-example	Use a regexp, but find a problem.
recursive-count-words	Start with case of no words in region.
Counting Exercise
The `count-words-example` Function
Design count-words-example	The definition using a `while` loop.
Whitespace Bug	The Whitespace Bug in `count-words-example`.
Counting Words in a `defun`
Divide and Conquer
Words and Symbols	What to count?
Syntax	What constitutes a word or symbol?
count-words-in-defun	Very like `count-words-example`.
Several defuns	Counting several defuns in a file.
Find a File	Do you want to look at a file?
lengths-list-file	A list of the lengths of many definitions.
Several files	Counting in definitions in different files.
Several files recursively	Recursively counting in different files.
Prepare the data	Prepare the data for display in a graph.
Count Words in `defuns` in Different Files
lengths-list-many-files	Return a list of the lengths of defuns.
append	Attach one list to another.
Prepare the Data for Display in a Graph
Data for Display in Detail
Sorting	Sorting lists.
Files List	Making a list of files.
Counting function definitions
Readying a Graph
Columns of a graph
graph-body-print	How to print the body of a graph.
recursive-graph-body-print
Printed Axes
Line Graph Exercise
Your `.emacs` File
Default Configuration
Site-wide Init	You can write site-wide init files.
defcustom	Emacs will write code for you.
Beginning a .emacs File	How to write a `.emacs file`.
Text and Auto-fill	Automatically wrap lines.
Mail Aliases	Use abbreviations for email addresses.
Indent Tabs Mode	Don't use tabs with TeX
Keybindings	Create some personal keybindings.
Keymaps	More about key binding.
Loading Files	Load (i.e., evaluate) files automatically.
Autoload	Make functions available.
Simple Extension	Define a function; bind it to a key.
X11 Colors	Colors in X.
Miscellaneous
Mode Line	How to customize your mode line.
Debugging
debug	How to use the built-in debugger.
debug-on-entry	Start debugging when you call a function.
debug-on-quit	Start debugging when you quit with `C-g`.
edebug	How to use Edebug, a source level debugger.
Debugging Exercises
Handling the Kill Ring
What the Kill Ring Does
current-kill
yank	Paste a copy of a clipped element.
yank-pop	Insert element pointed to.
ring file
The `current-kill` Function
Code for current-kill
Understanding current-kill
`current-kill` in Outline
Body of current-kill
Digression concerning error	How to mislead humans, but not computers.
Determining the Element
A Graph with Labeled Axes
Labeled Example
print-graph Varlist	`let` expression in `print-graph`.
print-Y-axis	Print a label for the vertical axis.
print-X-axis	Print a horizontal label.
Print Whole Graph	The function to print a complete graph.
The `print-Y-axis` Function
print-Y-axis in Detail
Height of label	What height for the Y axis?
Compute a Remainder	How to compute the remainder of a division.
Y Axis Element	Construct a line for the Y axis.
Y-axis-column	Generate a list of Y axis labels.
print-Y-axis Penultimate	A not quite final version.
The `print-X-axis` Function
Similarities differences	Much like `print-Y-axis`, but not exactly.
X Axis Tic Marks	Create tic marks for the horizontal axis.
Printing the Whole Graph
The final version	A few changes.
Test print-graph	Run a short test.
Graphing words in defuns	Executing the final code.
lambda	How to write an anonymous function.
mapcar	Apply a function to elements of a list.
Another Bug	Yet another bug ... most insidious.
Final printed graph	The graph itself!

Web Expert

Gumbo - A pure-C HTML5 parser

Installation

Basic Usage

A note on API/ABI compatibility

Python usage

An Introduction to Programming in Emacs Lisp

Detailed Node Listing

Preface

Why Study Emacs Lisp?

On Reading this Text

For Whom This is Written

Lisp History

A Note for Novices

Thank You

1 List Processing

1.1 Lisp Lists

Numbers, Lists inside of Lists

1.1.1 Lisp Atoms

1.1.2 Whitespace in Lists

1.1.3 GNU Emacs Helps You Type Lists

1.2 Run a Program

1.3 Generate an Error Message

1.4 Symbol Names and Function Definitions

1.5 The Lisp Interpreter

Complications

1.5.1 Byte Compiling

1.6 Evaluation

How the Lisp Interpreter Acts

1.6.1 Evaluating Inner Lists

1.7 Variables

fill-column, an Example Variable

1.7.1 Error Message for a Symbol Without a Function

1.7.2 Error Message for a Symbol Without a Value

1.8 Arguments

1.8.1 Arguments' Data Types

1.8.2 An Argument as the Value of a Variable or List

1.8.3 Variable Number of Arguments

1.8.4 Using the Wrong Type Object as an Argument

1.8.5 The message Function

1.9 Setting the Value of a Variable

1.9.1 Using set

1.9.2 Using setq

1.9.3 Counting

1.10 Summary

1.11 Exercises

2 Practicing Evaluation

How to Evaluate

2.1 Buffer Names

2.2 Getting Buffers

2.3 Switching Buffers

2.4 Buffer Size and the Location of Point

2.5 Exercise

3 How To Write Function Definitions

An Aside about Primitive Functions

3.1 The defun Special Form

3.2 Install a Function Definition

The effect of installation

3.2.1 Change a Function Definition

3.3 Make a Function Interactive

An Interactive multiply-by-seven, An Overview

3.3.1 An Interactive multiply-by-seven

3.4 Different Options for interactive

3.5 Install Code Permanently

3.6 let

let Prevents Confusion

3.6.1 The Parts of a let Expression

3.6.2 Sample let Expression

3.6.3 Uninitialized Variables in a let Statement

3.7 The if Special Form

if in more detail

3.7.1 The type-of-animal Function in Detail

3.8 If–then–else Expressions

3.9 Truth and Falsehood in Emacs Lisp

An explanation of nil

3.10 save-excursion

Point and Mark

3.10.1 Template for a save-excursion Expression

3.11 Review

3.12 Exercises

`fill-column`, an Example Variable

1.8.5 The `message` Function

1.9.1 Using `set`

1.9.2 Using `setq`

3.1 The `defun` Special Form

An Interactive `multiply-by-seven`, An Overview

3.3.1 An Interactive `multiply-by-seven`

3.4 Different Options for `interactive`

3.6 `let`

`let` Prevents Confusion

3.6.1 The Parts of a `let` Expression

3.6.2 Sample `let` Expression

3.6.3 Uninitialized Variables in a `let` Statement

3.7 The `if` Special Form

`if` in more detail

3.7.1 The `type-of-animal` Function in Detail

An explanation of `nil`

3.10 `save-excursion`

3.10.1 Template for a `save-excursion` Expression

4.2 A Simplified `beginning-of-buffer` Definition

4.3 The Definition of `mark-whole-buffer`

An overview of `mark-whole-buffer`

4.3.1 Body of `mark-whole-buffer`

4.4 The Definition of `append-to-buffer`

An Overview of `append-to-buffer`

4.4.1 The `append-to-buffer` Interactive Expression

4.4.2 The Body of `append-to-buffer`

4.4.3 `save-excursion` in `append-to-buffer`

5.1 The Definition of `copy-to-buffer`

5.2 The Definition of `insert-buffer`

The Code for `insert-buffer`

5.2.1 The Interactive Expression in `insert-buffer`

‘`b`’ in an Interactive Expression

5.2.2 The Body of the `insert-buffer` Function

5.2.3 `insert-buffer` With an `if` Instead of an `or`

5.2.4 The `or` in the Body

5.2.5 The `let` Expression in `insert-buffer`

5.2.6 New Body for `insert-buffer`

5.3 Complete Definition of `beginning-of-buffer`

5.3.2 `beginning-of-buffer` with an Argument

Disentangle `beginning-of-buffer`

5.3.3 The Complete `beginning-of-buffer`

5.5 `optional` Argument Exercise

6.1 The `save-restriction` Special Form

6.2 `what-line`

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

7.1 `car` and `cdr`

7.2 `cons`

7.2.1 Find the Length of a List: `length`

7.3 `nthcdr`

7.4 `nth`

7.5 `setcar`

7.6 `setcdr`

8.1 `zap-to-char`

The Complete `zap-to-char` Implementation

8.1.1 The `interactive` Expression

8.1.2 The Body of `zap-to-char`

8.1.3 The `search-forward` Function

8.1.4 The `progn` Special Form

8.1.5 Summing up `zap-to-char`

8.2 `kill-region`

The Complete `kill-region` Definition

8.2.1 `condition-case`

8.3 `copy-region-as-kill`

The complete `copy-region-as-kill` function definition

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

`last-command` and `this-command`

The `kill-append` function

The `kill-new` function