Emacs Lisp for Experienced Developers

;; Function call: (function-name arg1 arg2 ...)
(+ 2 3)  ; => 5

;; Compare to other languages:
;; Python:     2 + 3
;; JavaScript: 2 + 3
;; Java:       2 + 3

;; Local variable (lexically scoped)
(let ((name "Alice")
      (age 30))
  (message "Name: %s, Age: %d" name age))

;; Global variable
(defvar my-global-var 42
  "A global variable with documentation.")

;; Custom variable (user-configurable)
(defcustom my-custom-var 100
  "A customizable variable."
  :type 'integer
  :group 'my-package)

;; Set a variable
(setq my-var 10)

;; Set multiple variables
(setq x 1
      y 2
      z 3)

# Python
name = "Alice"
age = 30

// JavaScript
let name = "Alice";
let age = 30;

(let ((i 0))
  (while (< i 5)
    (message "i = %d" i)
    (setq i (1+ i))))

# Python
i = 0
while i < 5:
    print(f"i = {i}")
    i += 1

;; Loop from 0 to 4
(dotimes (i 5)
  (message "i = %d" i))

;; With result value
(dotimes (i 5 "done")
  (message "i = %d" i))

# Python
for i in range(5):
    print(f"i = {i}")

// JavaScript
for (let i = 0; i < 5; i++) {
    console.log(`i = ${i}`);
}

(dolist (item '(apple banana cherry))
  (message "Fruit: %s" item))

;; With index using cl-loop
(require 'cl-lib)
(cl-loop for item in '(apple banana cherry)
         for i from 0
         do (message "%d: %s" i item))

# Python
for item in ['apple', 'banana', 'cherry']:
    print(f"Fruit: {item}")

for i, item in enumerate(['apple', 'banana', 'cherry']):
    print(f"{i}: {item}")

// JavaScript
['apple', 'banana', 'cherry'].forEach(item => {
    console.log(`Fruit: ${item}`);
});

['apple', 'banana', 'cherry'].forEach((item, i) => {
    console.log(`${i}: ${item}`);
});

(require 'cl-lib)

;; Collect squares
(cl-loop for i from 1 to 5
         collect (* i i))
;; => (1 4 9 16 25)

;; Sum numbers
(cl-loop for i from 1 to 10
         sum i)
;; => 55

;; Filter and transform
(cl-loop for i from 1 to 10
         when (cl-evenp i)
         collect (* i 2))
;; => (4 8 12 16 20)

;; Iterate over lists
(cl-loop for item in '(1 2 3 4 5)
         when (> item 2)
         collect item)
;; => (3 4 5)

;; Square each number
(mapcar (lambda (x) (* x x)) '(1 2 3 4 5))
;; => (1 4 9 16 25)

;; Convert to strings
(mapcar #'number-to-string '(1 2 3))
;; => ("1" "2" "3")

# Python
list(map(lambda x: x * x, [1, 2, 3, 4, 5]))
# or
[x * x for x in [1, 2, 3, 4, 5]]

// JavaScript
[1, 2, 3, 4, 5].map(x => x * x);

(require 'seq)

;; Filter even numbers
(seq-filter (lambda (x) (= (mod x 2) 0)) '(1 2 3 4 5 6))
;; => (2 4 6)

;; Using cl-lib
(require 'cl-lib)
(cl-remove-if-not #'cl-evenp '(1 2 3 4 5 6))
;; => (2 4 6)

# Python
list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5, 6]))
# or
[x for x in [1, 2, 3, 4, 5, 6] if x % 2 == 0]

# Python - NO tail-call optimization
# This will cause a stack overflow with large n
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)  # NOT tail-recursive (multiplication happens after)

// JavaScript - NO tail-call optimization in most engines
// (ES6 spec includes it, but most browsers don't implement it)
function factorial(n, acc = 1) {
    if (n <= 1) return acc;
    return factorial(n - 1, n * acc);  // tail-recursive, but not optimized
}

;; Factorial
(defun factorial (n)
  "Calculate factorial of N."
  (if (<= n 1)
      1
    (* n (factorial (1- n)))))

(factorial 5)  ; => 120

;; Fibonacci
(defun fibonacci (n)
  "Calculate the Nth Fibonacci number."
  (cond
   ((<= n 0) 0)
   ((= n 1) 1)
   (t (+ (fibonacci (1- n))
         (fibonacci (- n 2))))))

(fibonacci 10)  ; => 55

(require 'cl-lib)

;; Tail-recursive factorial
(defun factorial-tail (n)
  "Calculate factorial using tail recursion."
  (cl-labels ((fact-helper (n acc)
                (if (<= n 1)
                    acc
                  (fact-helper (1- n) (* n acc)))))
    (fact-helper n 1)))

(factorial-tail 5)  ; => 120

;; Sum a list recursively
(defun sum-list (lst)
  "Sum all numbers in LST."
  (if (null lst)
      0
    (+ (car lst) (sum-list (cdr lst)))))

(sum-list '(1 2 3 4 5))  ; => 15

;; Reverse a list
(defun my-reverse (lst)
  "Reverse LST recursively."
  (if (null lst)
      nil
    (append (my-reverse (cdr lst)) (list (car lst)))))

(my-reverse '(1 2 3 4 5))  ; => (5 4 3 2 1)

;; Flatten a nested list
(defun flatten (lst)
  "Flatten a nested list LST."
  (cond
   ((null lst) nil)
   ((listp (car lst))
    (append (flatten (car lst))
            (flatten (cdr lst))))
   (t (cons (car lst)
            (flatten (cdr lst))))))

(flatten '(1 (2 3) ((4) 5) 6))  ; => (1 2 3 4 5 6)

;; Basic function
(defun greet (name)
  "Greet NAME with a message."
  (message "Hello, %s!" name))

;; Function with multiple parameters
(defun add-numbers (a b)
  "Add A and B and return the result."
  (+ a b))

;; Function with optional parameters
(defun greet-optional (name &optional title)
  "Greet NAME with optional TITLE."
  (if title
      (message "Hello, %s %s!" title name)
    (message "Hello, %s!" name)))

(greet-optional "Alice")          ; "Hello, Alice!"
(greet-optional "Alice" "Dr.")    ; "Hello, Dr. Alice!"

;; Function with rest parameters
(defun sum-all (&rest numbers)
  "Sum all NUMBERS."
  (apply #'+ numbers))

(sum-all 1 2 3 4 5)  ; => 15

;; Lambda function
(lambda (x) (* x x))

;; Using lambda with funcall
(funcall (lambda (x) (* x x)) 5)  ; => 25

;; Using lambda with mapcar
(mapcar (lambda (x) (* x 2)) '(1 2 3 4 5))
;; => (2 4 6 8 10)

;; Storing lambda in a variable
(setq square (lambda (x) (* x x)))
(funcall square 5)  ; => 25

# Python
square = lambda x: x * x
square(5)  # => 25

list(map(lambda x: x * 2, [1, 2, 3, 4, 5]))

// JavaScript
const square = x => x * x;
square(5);  // => 25

[1, 2, 3, 4, 5].map(x => x * 2);

(defun insert-current-date ()
  "Insert the current date at point."
  (interactive)
  (insert (format-time-string "%Y-%m-%d")))

;; With prefix argument
(defun insert-date (arg)
  "Insert date. With ARG, include time."
  (interactive "P")
  (insert (format-time-string
           (if arg "%Y-%m-%d %H:%M:%S" "%Y-%m-%d"))))

;; Reading from minibuffer
(defun greet-user (name)
  "Greet user by NAME."
  (interactive "sEnter your name: ")
  (message "Hello, %s!" name))

;; Creating lists
(setq my-list '(1 2 3 4 5))
(setq my-list (list 1 2 3 4 5))

;; Accessing elements
(car my-list)     ; First element => 1
(cdr my-list)     ; Rest of list => (2 3 4 5)
(nth 2 my-list)   ; Third element (0-indexed) => 3

;; Adding elements
(cons 0 my-list)              ; Add to front => (0 1 2 3 4 5)
(append my-list '(6 7))       ; Concatenate => (1 2 3 4 5 6 7)
(push 0 my-list)              ; Modify my-list, add to front

;; Length
(length my-list)              ; => 5

;; Checking membership
(member 3 my-list)            ; => (3 4 5)
(memq 'a '(a b c))            ; => (a b c)

;; Creating an alist
(setq person '((name . "Alice")
               (age . 30)
               (city . "New York")))

;; Accessing values
(alist-get 'name person)           ; => "Alice"
(cdr (assq 'age person))           ; => 30
(assoc-default 'city person)       ; => "New York"

;; Adding/updating entries
(push '(job . "Engineer") person)
(setf (alist-get 'age person) 31)

;; Creating a hash table
(setq my-table (make-hash-table :test 'equal))

;; Adding values
(puthash "name" "Alice" my-table)
(puthash "age" 30 my-table)

;; Getting values
(gethash "name" my-table)          ; => "Alice"
(gethash "job" my-table "Unknown") ; => "Unknown" (default)

;; Checking if key exists
(gethash "age" my-table)           ; => 30

;; Iterating
(maphash (lambda (key value)
           (message "%s: %s" key value))
         my-table)

;; Number of entries
(hash-table-count my-table)        ; => 2

;; Creating vectors
(setq my-vector [1 2 3 4 5])
(setq my-vector (vector 1 2 3 4 5))

;; Accessing elements
(aref my-vector 0)                 ; => 1
(elt my-vector 2)                  ; => 3

;; Setting elements
(aset my-vector 0 10)

;; Length
(length my-vector)                 ; => 5

;; Converting between lists and vectors
(vconcat '(1 2 3))                ; => [1 2 3]
(append [1 2 3] nil)              ; => (1 2 3)

(eq nil '())        ; => t
(not nil)           ; => t
(not '())           ; => t

(if 0 "true" "false")       ; => "true" (0 is not nil)
(if "" "true" "false")      ; => "true" (empty string is not nil)
(if '() "true" "false")     ; => "false" (empty list is nil)

(setq x 10)                          ; Set x globally
(let ((x 20)) x)                     ; x is 20 in this scope
x                                    ; x is still 10 outside

(setq alist '((a . 1) (b . 2)))
(setf (alist-get 'a alist) 99)      ; Modify alist entry

(setq x 10)

'(x is x)                           ; => (x is x)
`(x is ,x)                          ; => (x is 10)
`(list of ,x and ,(+ x 5))          ; => (list of 10 and 15)

(require 'rx)

;; Instead of: "\\([0-9]+\\)-\\([0-9]+\\)-\\([0-9]+\\)"
(rx (group (one-or-more digit)) "-"
    (group (one-or-more digit)) "-"
    (group (one-or-more digit)))