Emacs Lisp Functions

(setq variable-name 100)
(setq v1 1
      v2 2
      v3 3)

(let (a b)
  ...)

(let ((a 1)
      (b 2)
      (c (generate-some-value)))
  ... body ...)

(let* ((a 1)
       (b (+ a 2))
       (c (/ b 3)))
  ... body ...)

(list 1 2 3 4)         ;; (1 2 3 4)
'(1 2 3 4)             ;; (1 2 3 4)

(number-sequence 3)      ;; (3)
(number-sequence 2 5)    ;; (2 3 4 5)
(number-sequence 0 9 2)  ;; (0 2 4 6 8)

(car '("a" "b" "c"))            ;; "a"
(first '("a" "b" "c"))          ;; "a"
(nth 3 '("a" "b" "c" "d" "e"))  ;; "d"
(last '("a" "b" "c"))           ;; ("c")
(car (last '("a" "b" "c")))     ;; "c"

(cdr '(1 2 3 4))       ;; (2 3 4)
(rest '(1 2 3 4))      ;; (2 3 4)
(butlast '(1 2 3 4))   ;; (1 2 3)
(nthcdr 2 '(1 2 3 4))  ;; (3 4)

(cons "a" '("b" "c"))           ;; ("a" "b" "c")
(cons '("a" "b") '("c" "d"))    ;; (("a" "b") "c" "d")
(append '("a" "b") '("c" "d"))  ;; ("a" "b" "c" "d")

(let ((some-list '(1 2 3)))
  (nconc some-list '(4))
  some-list)
;; => (1 2 3 4)

(let ((lst '("b" "c")))
  (push "a" lst)
  ;; lst -> ("a" "b" "c")
  (pop lst)  ;; -> "a"
  ;; lst -> ("b" "c")
  )

(length "abcd")

(concat "hello" " " "world!")
;; -> "hello world!"

(substring "abcde" 2 4)  ;; -> "cd"

(string-trim "  blah blah ")
;; -> "blah blah"

(format "I am %d age %s" 19 "old")
;; -> "I am 19 age old"

(string-remove-prefix "aaa" "aaabbbccc")
;; -> "bbbccc"
(string-remove-suffix "ccc" "aaabbbccc")
;; -> "aaabbb"

(string-match "bbb" "aaabbbccc")
;; -> 3

(replace-match "BBB" nil nil "aaabbbccc")
;; -> aaaBBBccc

(number-to-string 3)

(split-string "my name is conrad" " ")
;; -> ("my" "name" "is" "conrad")

(string-join '("my" "name" "is" "conrad") " ")
;; -> "my name is conrad"

(if (condition)
    (then-statement)
  (else-statement))

(if (condition)
    (progn
      (statement 1)
      (statement 2))
  (progn
    (statement 3)
    (statement 4)))

(and cond1 cond2 ...)
(or cond1 cond2 ...)
(not (condition))

(when (condition)
  (statement1)
  (statement2))

(unless (false-condition)
  (statement1)
  (statement2))

(equal 10 10)              ;; -> t
(equal "str" "STR")        ;; -> nil
(equal '(1 2 3) '(1 2 3))  ;; -> t
(equal 'symb 'symb)        ;; -> t
(> 10 1)                   ;; -> t
(string= "abc" "ABC")      ;; -> nil

(integerp 10)  ;; -> t
(floatp 3.14)  ;; -> t

(while (condition)
  (statement1)
  (statement2)
  ...)

(defun make-double (x)
  (+ x x))

(mapcar #'make-double '(1 2 3 4 5))
;; -> (2, 4, 6, 8, 10)

(mapcar
 (lambda (x)
   (+ x x))
 '(1 2 3 4 5))
;; -> (2, 4, 6, 8, 10)

(mapc
 (lambda (x)
   (+ x x))
 '(1 2 3 4 5))

;; => (1 2 3 4 5)

(mapconcat #'identity '("hello" "world" "!") " ")
;; -> "hello world !"

(require 'seq)
(seq-filter
 (lambda (x)
   (= 0 (% x 2)))
 '(1 2 3 4 5 6))

;; => (2 4 6)

(defun function-name (param1 param2 ...)
  "documentation"
  ... body ...)

(defun function-name (...)
  "documentation"
  (interactive)   ;; <----
  ... body ...)

(defun function-name (a b &optional c d)
  ;; ...
  )

(char-after 1)

(goto-char (point-min))  ;; start of buffer
(goto-char (point-max))  ;; end of buffer

(insert "text")

(generate-new-buffer "buffer-name")

(switch-to-buffer (generate-new-buffer "some-buffer"))

(with-current-buffer some-buffer
  (insert "sample text"))

(with-temp-buffer
  (insert-file-contents "readme.txt")
  (insert "hello world!")
  (write-file "helloworld.txt"))

(goto-char (region-beginning))
(goto-char (regin-end))

(expand-file-name "~/test.txt")
;; -> ex: /user/home/directory/test.txt

(file-relative-name "/foo/bar/name" "./")

(file-name-nondirectory "/foo/bar/name.ext")
;; -> "name.ext"

(file-name-directory "/foo/bar/sample.txt")
;; -> "/foo/bar/"

(file-name-sans-extension "sample.txt")
;; -> "sample"

(file-name-as-directory "/foo/bar")
;; -> "/foo/bar/"

(file-expand-wildcards "~/foo/bar/*.org")

(when (file-exists-p "/foo/bar/file/name")
  (message "file exists!"))

(md5 "some-string")