• F1 i or M-x info RET (open the info browser)
• d m elisp RET (open the elisp manual)
• I # RET (list the entries for # in the index)

Backquote (`) and comma (,)

• (`) character signals that in the expression that follows, every subexpression not preceded by a comma is to be quoted, and every subexpression preceded by a comma is to be evaluated.

(setq v1 2)
(setq e 2)
(setq v2 2)
(print `(progn (setq v1 ,@e) (setq ,v2 ,e)))
;;^ backquote   ^   ^         ^   ^ commas

(print '(
              progn (setq v1 e) `(setq ,v2 ,e)
                    ))

(progn (setq v1 . 2) (setq 2 2))

(progn (setq v1 e) `(setq ,v2 ,e))

Comma-splice (,@)

(setq v  '("oh boy"))
(print `(zap ,@v ,v))

(zap "oh boy" ("oh boy"))

Quote-comma (')

(defmacro explain-exp (exp)
  `(format "%s = %s" ',exp ,exp))
  ;;                 ^^

(print (explain-exp (+ 2 3)))

"(+ 2 3) = 5"

and

see Combining Conditions catch

see Catch and Throw cond

see Conditionals condition-case

see Handling Errors defconst

see Defining Variables defvar

see Defining Variables function

see Anonymous Functions if

see Conditionals interactive

see Interactive Call lambda

see Lambda Expressions let let*

see Local Variables 2 or

see Combining Conditions prog1 prog2 progn

see Sequencing quote

see Quoting save-current-buffer

see Current Buffer save-excursion

see Excursions save-restriction

see Narrowing setq

see Setting Variables setq-default

see Creating Buffer-Local unwind-protect

see Nonlocal Exits while

see Iteration

https://www.gnu.org/software/emacs/manual/html_node/cl/Porting-Common-Lisp.html

• Case-insensitivity for symbols
  • Common LISP expressions are case-insensitive - cos 45 or COS 45 are same
  • Emacs lisp - case-sensitive

everything atom or list

object - instance of type

Linked lists - one of Lisp's major data structures

s-expression or sexp - for code and data structure : (x y z) stands for (x . (y . (z . NIL)))

Constants:

• Numbers
• The letter t, that stands for logical true.
• The value nil, that stands for logical false, as well as an empty list.

atom - is a number or symbol or string in double quotation marks.

symbol - string of contiguous character - can consist of any number of alphanumeric characters other than whitespace, open and closing parentheses, double and single quotes, backslash, comma, colon, semicolon and vertical bar. To use these characters in a name, you need to use escape character (\).

• hello-from-tutorials-point
• 123008907
• hello
• Block#221
• abc123
• +1
• FOO ; A symbol named ‘FOO’, different from ‘foo’ for Emacs Lisp

list is a Linked lists is a sequence of atoms and/or other lists enclosed in parentheses.

• Lists in Lisp are not a primitive data type they are built up from "cons cells"
• "cons cells" - ordered pair - (CAR CDR)
• each cell refers to the next one: CARs of the cons cells hold the elements of the list, and the CDRs are used to chain the list
• CDR of the last cons cell in a list is ‘nil’

(setq bouquet '(rose violet buttercup))

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

A string is a group of characters enclosed in double quotation marks. "Hello world!"

primitive types:

• integer
• float
• cons
• symbol
• string
• vector
• hash-table
• subr
• byte-code function
• record
• plus several special types, such as buffer, that are related to editing

single inheritance?

single quote: (write '(* 2 3)) - atoms or lists literally and don't want them evaluated or treated as function calls.

• Quoting - '123, (quote (+ 1 2))
• Self-Evaluating Forms - evaluate to themselves '123 => 123 (eval '123) => 123

(alist-get key alist &optional default remove testfn)

• cons construct
• car return first element of list
• cdr return all elements of list except of first
• list wrap to list ()
• length/seq-length - get length
• nthcdr n without first n elements
• nth n get n element, starting from 0
• last last element of list
• reverse seq
• append, nconc add elements to list
• member, memq - check if there is memeber with equal or eq
• push add element existing list
• (setf (alist-get <key> <alist>) <value>)- replace element of list
• copy-sequence/tree - make copy
• reverse/nreverse - non destructive and destructive
• seq-elt get element at index 0 - (len-1)
• seq-drop [n:]
• seq-take [:n]

is literal (not evaluated).

• (symbolp sym) - Test if variable sym is a symbol
• (symbol-name 'sym) - ;; Get symbol as string

Get value from a symbol

• (symbol-value 'sym)
• (symbol-function 'sym)
• (symbol-plist 'sym)

Test if function is an elisp primitive

(subrp (symbol-function 'goto-char))

; Convert a symbol to string
(print (symbol-name 'wombat))
; Convert a String to Symbol
(print (intern "wombat"))

• symbol nil has three separate meanings:
  • it is a symbol with the name ‘nil’;
  • it is the logical truth value false;
  • it is the empty list—the list of zero elements.
• When used as a variable, nil always has the value nil.
• we write () when we wish to emphasize that it means the empty list, and we write nil when we wish to emphasize that it means the truth value false.
  • (cons 'foo ()) ; Emphasize the empty list
  • (setq foo-flag nil) ; Emphasize the truth value false
• non-nil value is considered to be true
• t is the preferred way to represent the truth value true
• The symbol t always has the value t.

;;; Everything that is not "nil" is true:

(print (mapconcat 'identity '("aaa" "bbb" "ccc") ","))
(print (split-string "aaa,bbb,ccc" ","))
(print (string-match "ce" "central park"))
(print (make-string 5 ?x))
; S-expression from String
(print (read-from-string
            "(
               (POINT1  (X  10.2323)  (Y   20.2323))
               (POINT2  (x  0.2)          (Y 923.23))
               (POINT3  (x -10.5)       (Y 78,23))
             )"))

(setq raw "(:x 10 :y 20 :z 30 :w \"hello world\")")
(print (read raw))
(print (plist-get (read raw) :x))

; Serialize a s-expression
(setq sexp '(:x 10 :y 20 :z 30 :w "hello world"))
(print (prin1-to-string sexp))

"aaa,bbb,ccc"

("aaa" "bbb" "ccc")

0

"xxxxx"

(((POINT1 (X 10.2323) (Y 20.2323)) (POINT2 (x 0.2) (Y 923.23)) (POINT3 (x -10.5) (Y 78 (\, 23)))) . 174)

(:x 10 :y 20 :z 30 :w "hello world")

10

"(:x 10 :y 20 :z 30 :w \"hello world\")"

a symbol with a value or a function definition attached to it. variable is a symbol that has a value, not function. use of a symbol as a variable is independent of its use as a function name.

scoping rule - default dynamic scoping - current binding as the innermost local binding, or the global binding if there is no local binding.

• lexical scoping - .all Emacs Lisp source files and the scratch buffer use lexical scoping. ( can be enabled on a per-buffer basis. buffer-local variable ‘lexical-binding’ to a non-nil value. or ;; -- lexical-binding: t -- in library)

local

• function arguments
• local bindings

Generalized Variables - special places that accept assignment with setf. (setf (car a) b)

• (makunbound 'x) ; Void the local binding.

(print (let ((x 1) (y 10)) (+ (* 4 x) (* 5 y)) ))
;; (print x) ;; Symbol's value as variable is void: x
;; (print y)

Problem of dynamic scoping, that lexical scoping is fixing:

(defun getx ()
  x)            ; x is used free in this function.

(let ((x 1))    ; x is lexically bound.
  (getx)) ;; error→ Symbol's value as variable is void: x

setf [place form] …

aref

Return the element of ARRAY at index IDX. ARRAY: vector, a string, a char-table, a bool-vector, a record,

or a byte-code object.

car

first element of list

caar

(car (car

cadr

(car (cdr

cdr

second and left of list

cdar

(cdr (car

cddr

(cdr (cdr

elt

Return element of SEQUENCE at index N.

get

Return the value of SYMBOL’s PROPNAME property.

gethash

Look up KEY in TABLE and return its associated value.

nth

Return the Nth element of LIST.

nthcdr

Take cdr N times on LIST, return the result.

symbol-function

Return SYMBOL’s function definition, or nil if that is void.

symbol-plist

.

symbol-value

.

z is bound to the old value of y, which is 2, not the new value of y, which is 1.

(setq y 2)
(let ((y 1) ;; define y
      (z y)) ;; define z
  (list y z)) ;; evaluate
(list y z) ;; error z is not defined

(let (aaa) (setq aaa 2) (list aaa))

• cond (cond (test1 action1) (test2 action2) (condition body-forms…) … )
  • (condition body-forms…)
• when (when (test-clause) (action1) (action2) … ) - alternative to if without else and requirement for (progn
• if (if (test-clause) (then-action1) (else-action2))
• case (case (keyform) ((key1) (action1 action2 …) ((key2) (action1 action2 …) ) … )
• (not),
• (and), If no arg yields nil, return the last arg’s value.
• (or), (xor)
• (unless cond - (when nil

(cl-loop for n from 2 below 9 by 1
      do (print n))

2

3

4

5

6

7

8

(dolist (h (number-sequence 4 6))
        (print h)
)

4

5

6

(dolist (h '(a b c))
  (print h))

;; (dolist (h string("abc"))
;;   (print h))
(print (string-to-char "asd"))

(dotimes (i 3) (print i))

(do (variable-definition*)
    (end-test-form result-form*)
  statement*)

• (progn BODY…) - Eval BODY forms sequentially and return value of last one.
• prog1 for instance evaluates all expressions and returns the value of the first
• prog2 evaluates all expressions and returns the value of the second

• defines the symbol name as a function with argument list args
• Neither name nor args should be quoted.
• The return value of defun is undefined.
• Careful! defun redefines even primitive functions such as car without any hesitation or notification.
• fmakunbound - undefine

(defun function-name (a &optional b &rest c) "optional-documentation…" (interactive argument-passing-info) (indent indent-spec) ; declare Form body…)

arguments can have clauses or markers: (required-vars… [&optional [optional-vars…]] [&rest rest-var])

• &optional
• &rest - list of arguemnts

(defun a (&optional v)
       (print v)
)
(a)

nil

https://www.gnu.org/software/emacs/manual/html_node/elisp/Argument-List.html

• funcall (function &rest arguments)
• apply (function &rest arguments) - last arg as list of args
• https://www.gnu.org/software/emacs/manual/html_node/elisp/Argument-List.html
• funcall-interactively

(print (funcall 'list '(1 2 3)))
(print (apply 'list '(1 2 3)))

((1 2 3))

(1 2 3)

(defun a (&optional v foo  c d &rest e)
       (interactive)
       (print (list v foo c d e)))
(a 1 2 3 4 5)
(defun b (&rest e)
       "function proxy"
       (interactive)
       (if (interactive-p)
           ;; (funcall-interactively 'a e)
           ;; (call-interactively 'a)
           (apply 'funcall-interactively 'a e)
         ;;else
         (apply 'a e))
  ;; (print e)
)
(print (vector (list 1 2 3 4) (list 1 2 3 4)))
(call-interactively 'a)
(call-interactively 'b)
(b 1 2 3 4 5)
(print "----")
(funcall-interactively 'a 1 2 3 4 5)
(funcall-interactively 'b 1 2 3 4 5)

(1 2 3 4 (5))

[(1 2 3 4) (1 2 3 4)]

(nil nil nil nil nil)

(nil nil nil nil nil)

(1 2 3 4 (5))

"----"

(1 2 3 4 (5))

(1 2 3 4 (5))

(defun averagenum (n1 n2 n3 n4)
  (/ ( + n1 n2 n3 n4) 4)
  )
(averagenum 2 3 4 10 )
;; 4


(setq f 'list)
;;     ⇒ list

(funcall f 'x 'y 'z)
  ;;   ⇒ (x y z)

(defun bar (n) (+ n 2))
(symbol-function 'bar)
;;     ⇒ (lambda (n) (+ n 2))

(fset 'baz 'bar)
  ;;   ⇒ bar

(symbol-function 'baz)
    ;; ⇒ bar

To be able to supply arguments by name, we need to

• declare them with &key <name>
• we set them with :name <value>

Default values to key parameters:

• &key (<name> <value>)

(defun hello (name &key happy)())
(hello "me" :happy t)

(defun hello (&optional name &key happy)())
(hello "me" :happy t)

• A lambda expression, by itself, has no name; it is an anonymous function.
• result is a closure object
• they are more commonly associated with symbols to make named functions
• A lambda form cannot be evaluated and it must appear only where LISP expects to find a function.

Macro: lambda args [doc] [interactive] body…

(lambda (x) (* x x)) ⇒ (lambda (x) (* x x))

A closure is a function that also carries a record of the lexical environment that existed when the function was defined. When it is invoked, any lexical variable references within its definition use the retained lexical environment.

Lambda macro or the function special form or the #' syntax (see Anonymous Functions), is automatically converted into a closure When lexical binding is enabled.

• A Lisp function becomes a command when its body contains, at top level, a form that calls the special form `(interactive…)’.
• This special form does nothing when executed, but its presence in the function definition indicates that interactive calling is permitted.
• Its argument controls the reading of the function arguments in an interactive call.
• In interactive function all arguments should be after &optional or &rest to be called with (call-interactively

(interactive &optional arg-descriptor &rest modes)

• arg-descriptor: a string, sequence of elements separated by newlines
  • P - raw prefix
  • p - numeric prefix

(call-interactive mode) - will switch off mode if mode is on.

• (lambda (a b c) (+ a b c)) - 3 arguments
• keyword &optional before the optional arguments
• To specify a list of zero or more extra arguments, include the keyword &rest before one final argument.
• (a b &optional c d &rest e) - here c and d optional and e is a list

(info "(elisp) Nonlocal Exits").

• Throw
• block (info "(cl) Blocks and Exits")
• cl-defun
• defun*

(defun my-func ()
  "Simplistic `catch'/`throw' example."
  (catch 'my-early-return
    (when t
      (throw 'my-early-return "this is the short-circuit result of catch"))
    "this is the fallback result of catch"))

function’s definition is expanded into the caller

defsubst name args [doc] [declare] [interactive] body…

inline it as a compiler macro - more efficient.

define-inline name args [doc] [declare] body… ¶

• (inline-quote expression) -
• inline-letevals (bindings…) body… - This provides a convenient way to ensure that the arguments to an inlined function are evaluated exactly once, as well as to create local variables.
• inline-const-p expression - Return non-nil if the value of expression is already known.
• inline-const-val expression - Return the value of expression.
• inline-error format &rest args - Signal an error, formatting args according to format.

(define-inline myaccessor (obj)
  (inline-letevals (obj)
    (inline-quote (if (foo-p ,obj) (aref (cdr ,obj) 3) (aref ,obj 2)))))

;; equal to:
(defsubst myaccessor (obj)
  (if (foo-p obj) (aref (cdr obj) 3) (aref obj 2)))

• special
• ordinary

normal escaping \[, for lisp: "\\[", also:"\n", "[ [:space:] ]"

• (looking-back "\n\\** ?" 2) - before point matches regular
• (looking-at "" ) - after point matches regular
• (rx …

(print (rx bol
  (zero-or-more blank)
  (one-or-more digit)
  ":"))

"^[[:blank:]]*[[:digit:]]+:"

• . any character (but newline)
• * previous character or group, repeated 0 or more time
• + previous character or group, repeated 1 or more time
• ? previous character or group, repeated 0 or 1 time
• *?, +?, and ?? are non-greedy versions of *, +, and ?
• ^ start of line
• $ end of line
• […] any character between brackets
• [^..] any character not in the brackets
• [a-z] any character between a and z
• \ prevents interpretation of following special char
• \| or
• \w word constituent
• \b word boundary
• \sc character with c syntax (e.g. \s- for whitespace char)
• \( \) start/end of group
• \&lt; \&gt; start/end of word (faulty rendering: backslash + less-than and backslash + greater-than)
• \_< \_> start/end of symbol
• \` \' start/end of buffer/string
• \1 string matched by the first group
• \n string matched by the nth group
• \{3\} previous character or group, repeated 3 times
• \{3,\} previous character or group, repeated 3 or more times
• \{3,6\} previous character or group, repeated 3 to 6 times
• \= match succeeds if it is located at point

C-u C-x = to display the category of the character under the cursor.

• \ca ascii character
• \Ca non-ascii character (newline included)
• \cl latin character
• \cg greek character
• [:digit:] a digit, same as [0-9]
• [:alpha:] a letter (an alphabetic character)
• [:alnum:] a letter or a digit (an alphanumeric character)
• [:upper:] a letter in uppercase
• [:lower:] a letter in lowercase
• [:graph:] a visible character
• [:print:] a visible character plus the space character
• [:space:] a whitespace character, as defined by the syntax table, but typically [ \t\r\n\v\f ], which includes the newline character
• [:blank:] a space or tab character
• [:xdigit:] an hexadecimal digit
• [:cntrl:] a control character
• [:ascii:] an ascii character
• [:nonascii:] any non ascii character
• \s- whitespace character
• \sw word constituent
• \s_ symbol constituent
• \s. punctuation character
• \s( open delimiter character
• \s) close delimiter character
• \s" string quote character
• \s\ escape character
• \s/ character quote character
• \s$ paired delimiter
• \s' expression prefix
• \s< comment starter
• \s> comment ender
• \s! generic comment delimiter
• \s| generic string delimiter
• \W, \B, and \Sc match any character that does not match \w, \b, and \sc.

;; (print (string-match-p "^[:print:]+" "fsd"))
(print (string-match-p "^[[:print:]]$" "f"))
;; (print (string-match-p "^a+" "fsd"))

0

• https://www.emacswiki.org/emacs/RegularExpression
• https://www.gnu.org/software/emacs/manual/html_node/emacs/Regexps.html

‘…-hook’ The variable is a normal hook (*note Hooks::).

‘…-function’ The value is a function.

‘…-functions’ The value is a list of functions.

‘…-form’ The value is a form (an expression).

‘…-forms’ The value is a list of forms (expressions).

‘…-predicate’ The value is a predicate—a function of one argument that returns non-‘nil’ for success and ‘nil’ for failure.

‘…-flag’ The value is significant only as to whether it is ‘nil’ or not. Since such variables often end up acquiring more values over time, this convention is not strongly recommended.

‘…-program’ The value is a program name.

‘…-command’ The value is a whole shell command.

‘…-switches’ The value specifies options for a command.

‘PREFIX–…’ The variable is intended for internal use and is defined in the file ‘PREFIX.el’. (Emacs code contributed before 2018 may follow other conventions, which are being phased out.)

‘…-internal’ The variable is intended for internal use and is defined in C code. (Emacs code contributed before 2018 may follow other conventions, which are being phased out.)

• (;) - comment on the same line
• (;;) - comment on the new line

• All the variables should be let-bound; otherwise, you're altering global values.
• Code is not indented and hard to read. Normally, sexp indentation in Emacs is aggressive enough that it takes effort to make code look like this, rather than to make it right.
• Use when instead of if, progn.
• https://www.gnu.org/software/emacs/manual/html_node/elisp/Tips.html
• https://github.com/bbatsov/emacs-lisp-style-guide
• C mostly https://www.gnu.org/prep/standards/standards.html
• https://www.math.utah.edu/docs/info/elisp_38.html

Save to .org file

(mapc (lambda (student)
        (let ((name (car student))
              (math (nth 1 student))
              (english (nth 2 student))
              (science (nth 3 student)))
        (with-temp-buffer
          (insert (concat "Name: " name "\n"))
          (insert (concat "Math: " math "\nEnglish: " english "\nScience: " science "\n"))
          (write-region (point-min) (point-max) (concat name ".org"))
          ;; Export PDF
          ;; (find-file (concat name ".org"))
          ;; (org-latex-export-to-pdf)
          )))
      students)
(print "Operation finished.")

"Operation finished."

Wrote /home/u/tmp/Alice.org
Wrote /home/u/tmp/Bob.org
Wrote /home/u/tmp/Charlie.org

• get help:
  • F1 f
  • F1 S - descrybe symbol

• <TAB> Indent line
• M-C-\ Indent region
• M-; Comment
• C-x ; Set comment column
• <ESC> <TAB> Completion for Symbol Names

Info:

• C-h S Info documentation for symbol
• M-x woman or man for operation system command, library function or system call.
• C-h f Emacs Lisp functions
• c-h v Emacs Lisp variable
• C-x C-e eval-last-sexp - Evaluate the expression to the left of cursor.

• C-M-x (eval-defun)
• M-: (eval-expression)

(defun suppress-messages (old-fun &rest args) (cl-flet ((silence (&rest args1) (ignore))) (advice-add 'message :around #'silence) (unwind-protect (apply old-fun args) (advice-remove 'message #'silence)))) (advice-add 'server-execute :around #'suppress-messages)

https://www.eigenbahn.com/2020/01/19/painless-emacs-shell-commands

right way to set it in .emacs:

• (setopt global-subword-mode t) if you have emacs 29 or later Wed
• or (customize-set-variable global-subword-mode t)

(defcustom text-mode-hook nil
  "Normal hook run when entering Text mode and many related modes."
  :type 'hook ;; tells Emacs the kind of data to which text-mode-hook should be set and how to display the value in a Customization buffer.
  :options '(turn-on-auto-fill flyspell-mode) ;; keyword specifies a suggested list of values for the variable
  :group 'wp) ;;  in which group the variable is located.

# Emacs automaically manage this with M-x customize
(custom-set-variables  '(text-mode-hook '(turn-on-auto-fill text-mode-hook-identify)))

src/fns.c

(mapc FUNCTION SEQUENCE) Apply FUNCTION to each element of SEQUENCE for side effects only.

(mapcar FUNCTION SEQUENCE) Apply FUNCTION to each element of SEQUENCE, and make a list of the results.

(setq full-range '(1 2 3 4))
(setq re (mapcar (lambda (arg) (/ arg 2)) full-range))
(print re)

(0 1 1 2)

• buffer-string - get buffer text as string with properties
• (buffer-substring-no-properties (point-min) (point-max)
• (buffer-name)

cl-macs.el

(cl-loop for handler in some_list until (condition-case …

comments:

• ; - used at the end of line
• ;; - used in code as separate line
• ;;; We use them for comments that should be considered a heading by Outline minor mode.
• on’t end headings with a colon : or any other punctuation.

naming:

• Prefix unused local (lexically scoped) variables with _. (lambda (x _y) x)
• – to denote private top-level definitions . projectile--private-fun
• lowercas with - separator: some-var

functions:

• Use =lambda=s for local bindings and function calls, not for hooks or global variables.
• https://www.gnu.org/software/emacs/manual/html_node/elisp/Tips.html
• https://github.com/bbatsov/emacs-lisp-style-guide

• http://github.com/purcell/package-lint

M-x package-install package-lint

usage: package-lint-current-buffer

M-x byte-compile-file

condition-case var protected-form handlers

• protected-form - body
• handlers - (conditions body…) (conditions body…)
  • condition - condition name of t matches any condition.

(condition-case nil
    (load "asd")
  (error nil))

(condition-case nil
    (load "asd")
  ((debug error) nil))

(ignore-errors  (load "asd"))

• catch tag body
• throw tag value, value is used as the value to return from that catch.

(defun foo-outer ()
  (catch 'foo
    (foo-inner)
    )
)

(defun foo-inner ()
  (throw 'foo t))
(foo-outer)

• https://www.gnu.org/software/emacs/manual/html_node/elisp/Errors.html
• https://www.gnu.org/software/emacs/manual/html_node/elisp/Standard-Errors.html

(wrong-type-argument number-or-marker-p hello)

(+ 2 'hello)

symbol hello, not a number

Wrong type argument: listp, notmuch-show-save-part

https://www.gnu.org/software/emacs/manual/html_node/eintr/Wrong-Type-of-Argument.html

• Emacs Terminology Description
• Point Cursor position, number of characters from beggining of the buffer to current cursor position.
• Buffer Place where the user edit something. Not all buffers are bound to a file.
• Mark Beginning of the selected area.
• Region Selected area/ text
• Frame The current window of emacs
• Windows Each frame can be split in sections that Emacs documentation calls windows
• Fill Word Wrap
• Yank Copy
• Kill Region Cut
• Kill Ring Clipboard
• Kill Buffer Close Buffer
• Mode Line Status Bar
• Font Locking Syntax Coloring

• (point) - current position
• (goto-char position)
• (line-beginning-position &optional N) scan forward N - 1 lines first.
• (beginning-of-line) - move cursor
• (forward-line)
• (next-line)

(count-lines ? ?)

http://xahlee.info/emacs/emacs/elisp_all_about_lines.html

• (current-buffer)
• (with-current-buffer BUFFER-OR-NAME &rest BODY) ;; Temporarily make a buffer current.
• (set-buffer BUFFER-OR-NAME) - Make a buffer current. (but does not make it visible.) Return that buffer object. switch-to-buffer or pop-to-buffer.
• (save-current-buffer &rest BODY) - Execute BODY, then restore the current buffer that is before this function call.
• (with-temp-buffer &rest BODY) - Create a temporary buffer, and evaluate BODY, return the last expression.

http://xahlee.info/emacs/emacs/elisp_buffer_file_functions.html

• (make-temp-file) - This function creates a temporary file or directory and returns its name, and may insert text in it.
• org-babel-temp-file - Create a temporary file
• org-babel-process-file-name - Prepare NAME to be used in an external process and return new name
• org-babel-eval-read-file - Return the contents of FILE as a string.
• with-temp-file file body - evaluates the BODY forms with a temporary buffer as the current buffer; then, at the end, it writes the buffer contents into file FILE.
• append-to-file - This function appends the contents of the region delimited by START and END in the current buffer to the end of file FILENAME.
• write-region - This function writes the region delimited by START and END in the current buffer into the file specified by FILENAME. or write string.

Notes

• ‘append-to-file’ and ‘write-region’ - Don’t use these functions to write to files that are being visited

(count-lines (point-min) (point-max))

(let ((buffer (get-buffer-create " *temp*")))
  (with-current-buffer buffer
    (unwind-protect
        (insert "asd")
      (kill-buffer buffer))))

https://www.gnu.org/software/emacs/manual/html_node/elisp/Cleanups.html

variables:

• mode-name - name of current major mode: "Help"
• major-mode - name of current major mode: help-mode
• mode-line-buffer-identification

minor mode is buffer-local or global:

(local-variable-if-set-p 'show-paren-mode)

there's nothing stopping you giving a global mode a buffer-local value(to check really global):

(with-temp-buffer
  (local-variable-if-set-p 'show-paren-mode))

• http://www.blogbyben.com/2011/04/10-concepts-emacs-newbie-should-master.html

• seq.el
• map.el