M-x occur RET defun RET

• M-s o

(mapc 'print calendar-holidays)

• 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.
• (`) and (,) used instead of (') to make exception in quoting and for better looking
• (`) and (,) used in macro definition for the same reason

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

;; (')
    (defmacro my-macro-1 (arg1 arg2)
      (list 'setq arg1 (list 'cons arg2 arg1)))
;; (`) and (,)
    (defmacro my-macro-2 (arg1 arg2)
      `(setq ,arg1 ,`(cons ,arg2 ,arg1)))

Comma-splice (`)(,@)

• This is particularly useful when writing macros with an &rest specifier.

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

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

;;(`) (,)
    (let ((list '(a b c d)))
      `(elt1 ,list elt2))
        => (elt1 (a b c d) elt2)
;;(`) (,@)
    (let ((list '(a b c d)))
      `(elt1 ,@list elt2))
        => (elt1 a b c d elt2)

Quote-comma (`)(',) - insert sexp as a string without evaluation

(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, object is a piece of data used and manipulated by Lisp programs

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

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?

each object belongs to one and only one primitive type

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

types of types:

• Lisp programming types
• editing - unique to Emacs Lisp

sequence

• list - not a single primitive object; it is made of cons cells, one cell per element
• array: vector, string, char-table, bool-vector - fixed-length object with a slot for each of its elements.

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:

As said in https://stackoverflow.com/questions/48363798/how-are-arguments-passed-into-functions-in-elisp Passed by assignment, new variables created just like assignment works. Symbol of variable is evaluated first and then assignment to new symbol. (We do

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

Mutability defines ability of functions to have side effect to argument.

If there is exist a function in Emacs Lisp that may modify type of argument then this argument may be considered as may be affected by side effect.

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

• (`) backquoted comment

• ;; - for full line
• ; - for after line

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

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

(seq-let (managed-major-mode project class contact language-id) (car args) ... )

• 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"))

Passed by assignment, new reference created at argument.

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

Mutability defines ability of functions to have side effect to argument.

If there is exist a function that may modify object then it may be considered as may be affected by side effect.

https://www.gnu.org/software/emacs/manual/html_node/elisp/Calling-Functions.html

• identity argument -> argument
• ignore &rest arguments -> nil
• always &rest arguments -> t

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:] ]"

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

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
• name of program as a prefix with ‘-’ separator
  • exceptions: ‘list-prefix’, ‘define-…-prefix-…’
  • you may use two or three alternative common prefixes

functions:

• “xxx-p” - check if true
• Constructs that define a function or variable should be macros, not functions, and their names should start with ‘define-’.
• Use lambdas for local bindings and function calls, not for hooks or global variables.
• https://www.gnu.org/software/emacs/manual/html_node/elisp/Coding-Conventions.html
• https://www.gnu.org/software/emacs/manual/html_node/elisp/Tips.html
• https://github.com/bbatsov/emacs-lisp-style-guide

naming variables:

• if the purpose of a variable is to store a single function, give it a name that ends in ‘-function’
• https://www.gnu.org/software/emacs/manual/html_node/elisp/Tips-for-Defining.html

major mode: https://www.gnu.org/software/emacs/manual/html_node/elisp/Major-Mode-Conventions.html

minor mode: https://www.gnu.org/software/emacs/manual/html_node/elisp/Minor-Mode-Conventions.html

Look at apply, all after FUNCTION is arguments that FUNCTION should handle. r = &rest args

• :around (lambda (&rest r) (apply FUNCTION OLDFUN r))
• :before (lambda (&rest r) (apply FUNCTION r) (apply OLDFUN r))
• :after (lambda (&rest r) (prog1 (apply OLDFUN r) (apply FUNCTION r)))
• :override (lambda (&rest r) (apply FUNCTION r))
• :after-until (lambda (&rest r) (or (apply OLDFUN r) (apply FUNCTION r)))
• :after-while (lambda (&rest r) (and (apply OLDFUN r) (apply FUNCTION r)))
• :before-until (lambda (&rest r) (or (apply FUNCTION r) (apply OLDFUN r)))
• :before-while (lambda (&rest r) (and (apply FUNCTION r) (apply OLDFUN r)))
• :filter-args (lambda (&rest r) (apply OLDFUN (funcall FUNCTION r)))
• :filter-return (lambda (&rest r) (funcall FUNCTION (apply OLDFUN r)))

:around

• (orig-fun &rest args)

:override

• (&rest args)

Transducers https://codeberg.org/fosskers/transducers.el

• change calls

cl-lib, dash - alternatives

elpa stream - orthogonal

seq/generics

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

M-x package-install package-lint

usage: package-lint-current-buffer

M-x byte-compile-file

• signal and error - exception. Errors can be signaled only by Lisp primitives (including signal and error functions)
• cleanup expressions - catch for exception
• error symbol - describes what kind of error it is, and which describes also a list of condition name. Each error symbol has a set of parent error conditions that is a list of symbols: error symbol itself and the symbol error.
  • error symbol may and may not "error conditions".

unwind-protect - expressions to be evaluated in case of error.

condition-case - error handlers to recover control in case of error.

• ignore-errors

CONDITION-NAME - in condition-case part of handlers

(define-error

Properties:

• error-conditions
• error-message

Main errors:

• error - also condition for almost all errors.
• quit - don't have error condition
• minibuffer-quit - don't have error condition

some errors:

• args-out-of-range
• wrong-type-argument
• wrong-number-of-arguments
• void-variable
• void-function
• user-error

• (error STRING &rest ARGS) - make error with 'error symbol.
• (signal ERROR-SYMBOL DATA) - An error symbol is a symbol with DATA.
• (user-error FORMAT &rest ARGS) - like error but use symbol 'user-error ‘error-conditions’ property that is a list of condition names.

(condition-case VAR BODYFORM &rest HANDLERS) - Regain control when an error is signaled. When a handler handles an error, control returns to the ‘condition-case’ and it executes the handler’s BODY… with VAR bound to (ERROR-SYMBOL . SIGNAL-DATA) from the error.

• protected-form - body
• handlers - (CONDITION-NAME BODY…) or (:success BODY…)
  • condition - condition name of t matches any condition.

(define-error 'new-error "A new error")
(condition-case e
  (signal 'wrong-type-argument "wtf")
  ('out-of-range (print "aa"))
  ;; ('error (print "tf"))
  ('wrong-type-argument (print "cc"))
)
(print (get 'wrong-type-argument 'error-conditions))
(print (get 'wrong-type-argument 'error-message))

"cc"

(wrong-type-argument error)

"Wrong type argument"

;; catching any error and return nil if an error occurs:
;; handl erros that was thrown for ex. with ~(error "On last item")~
(condition-case nil
    (load "asd")
  (error nil))

;; catch error and print
(condition-case nil
    (load "asd")
  (error (print "error!")))

;; debug and any error:
(condition-case nil
    (load "asd")
  ((debug error) nil))

(ignore-errors  (load "asd"))

"error!"

entirely separate! from errors and conditions.

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

(unwind-protect BODYFORM UNWINDFORMS…)

• executes body-form with a guarantee that the cleanup-forms will be evaluated if control leaves
• it permits you to make the data consistent again in the event of an error or throw.

Open Warnings buffer and output error there: #+begin_src elisp :results output :exports both :eval no (condition-case err (eval '(car) t) (error (display-warning (format "Error: %s\n" err) :error) nil))

• 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

symbol hello, not a number:

(condition-case a
    (+ 2 nil)
  (error (print a)))

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

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

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

Debugger entered--Lisp error: (wrong-type-argument number-or-marker-p nil)
* ediff-recenter-one-window(B)

Error is actually in defsubst inside of this function, it is like a bug because of inline function.

• Emacs Terminology Description
• Point Cursor position, number of characters from beggining of the buffer to current cursor position.
• Mark Beginning of the selected area.
• Region Selected area/ text
• Buffer Place where the user edit something. Not all buffers are bound to a file.
• Frame The current window of emacs. Windows are grouped into frames. Each frame contains at least one window.
• Windows Each frame can be split in sections that Emacs documentation calls windows. subdivide a frame into multiple, non-overlapping 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)
• (current-column) - get position from begining of line
• (current-indentation) - get position from begining of line where text exist (not white spaces)

(count-lines ? ?)

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

The idea is that a marker positioned between two characters remains between those two characters despite insertion and deletion elsewhere in the buffer. Marker:

the marker position

position in buffer at the begining - Insertion and deletion of text in the buffer relocate the marker.

the marker buffer

.

the insertion type

define behavion when text was inserter right at marker position.

• (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.
• (buffer-name BUFFER) - Return the name of BUFFER, as a string.
• (buffer-live-p b) - Return t if OBJECT is a buffer which has not been killed.

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

• (window-prev-buffers) - Return buffers previously shown in WINDOW.
• window tree - Windows on the same frame
• root window - The root node of a window tree.
• live window - leaf nodes, acutally showing buffer. returned by (window-list)
• selected window - one of leaf nodes that is active.
• internal window - organizing the relationships between live windows
• minibuffer window - not part of its frame’s window tree, but is sibling window of the frame’s root window
• Window Parameters - associated additional information with window.
• window-point/pos - saved state of (point) in window, by default used by window-in-direction as reference.
• reference position - used as a source to decide a target in direction.
• main-window - used to distinguish window from windows marked as window-side/slot, returned by (window-main-window). is either a “normal” live window or specifies the area containing all the normal windows.
• display-start or just start - buffer position that specifies where in the buffer display should start to display text at screen.

https://elpa.gnu.org/packages/posframe.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))

unwind-protect executes body-form with a guarantee that the cleanup-forms will be evaluated if control leaves body-form,

(let ((buffer (get-buffer-create " *temp*")))
  (with-current-buffer buffer
    (unwind-protect
        (insert "asd") ; body-frm
      (kill-buffer buffer) ; cleanup-form
      )))

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

(current-time) Elisp is a way to represent the number of seconds since the epoch (January 1, 1970, 00:00:00 UTC)

• HIGH: This represents the upper bits of the timestamp, typically the higher 16 bits of a 32-bit integer.
• LOW: This represents the lower bits of the timestamp, typically the lower 16 bits of a 32-bit integer.
• USEC: This represents the microseconds (millionths of a second) since the epoch.
• PSEC: This represents the picoseconds (trillionths of a second) since the epoch.

To show epoch in seconds:

(print (time-convert (current-time) 'integer))

To show saved Timer (run-at-time) in epoch:

(print (time-convert '(26277 20928) 'integer))

To show saved Timer as readable string:

(print (current-time-string (time-convert '(26277 20928) 'integer)))

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

• seq.el
• map.el