(Lisp)

# macOS (Homebrew)
brew install sbcl

# Ubuntu / Debian
sudo apt install sbcl

# Windows — download the installer from sbcl.org
# or use WSL with the Linux instructions above

# Start the interactive REPL
sbcl

; Form: (function arg1 arg2 ...)

(+ 3 4)          ; → 7  (addition)
(- 10 3)         ; → 7  (subtraction)
(* 6 7)          ; → 42 (multiplication)
(/ 10 2)         ; → 5  (division)

; Nesting: innermost evaluates first
(+ (* 2 3) (- 10 4))   ; → 12  (2×3=6, 10-4=6, 6+6=12)

; Arithmetic on many numbers at once
(+ 1 2 3 4 5)    ; → 15
(max 3 7 2 9)    ; → 9

(+ 1 2)           ; Evaluates → 3
'(+ 1 2)          ; Quoted   → (+ 1 2)  (the list itself)

'hello           ; A quoted symbol → HELLO
'(cat dog bird)  ; A list of symbols

; Long form — identical result:
(quote (a b c))  ; → (A B C)

(integerp 42)      ; → T
(stringp  "hi")   ; → T
(listp    '(1 2)) ; → T
(null     nil)    ; → T  (NIL is the empty list)
(numberp  "x")    ; → NIL

; typep for general type checking
(typep 3.14 'float)    ; → T
(type-of "hello")     ; → (SIMPLE-ARRAY CHARACTER (5))

;; defvar — only sets the value if unbound
(defvar *player-name* "Alice")

;; defparameter — always resets the value
(defparameter *max-lives* 3)
(defparameter *pi-approx* 3.14159)

;; Mutate with setf
(setf *max-lives* 5)   ; *max-lives* is now 5

;; Constants
(defconstant +speed-of-light+ 299792458)

;; let — bindings are evaluated in parallel
(let ((x 10)
      (y 20))
  (+ x y))   ; → 30

;; let* — bindings evaluated sequentially (each can see previous)
(let* ((base  5)
       (area  (* base base)))
  (format t "Area: ~a~%" area))
; Prints: Area: 25

;; Basic function definition
(defun greet (name)
  (format t "Hello, ~a!~%" name))

(greet "World")   ; Prints: Hello, World!

;; Returning a value (last expression is the return value)
(defun square (n)
  (* n n))

(square 7)       ; → 49

;; Multiple parameters
(defun hypotenuse (a b)
  (sqrt (+ (square a)
           (square b))))

(hypotenuse 3 4)  ; → 5.0

;; &optional — has a default value if not supplied
(defun power (base &optional (exp 2))
  (expt base exp))

(power 3)       ; → 9   (3²)
(power 2 10)    ; → 1024 (2¹⁰)

;; &key — named arguments (order doesn't matter)
(defun describe-person (&key name (age 0))
  (format t "~a is ~a years old.~%" name age))

(describe-person :name "Bob" :age 30)
; → Bob is 30 years old.

;; Create a function without naming it
(lambda (x) (* x x))

;; Call it immediately
((lambda (x) (* x x)) 5)   ; → 25

;; Store it in a variable with #' (function operator)
(let ((double (lambda (x) (* 2 x))))
  (funcall double 7))     ; → 14

;; if: (if test then-expr else-expr)
(if (> 5 3)
    "five is greater"
    "three is greater")
; → "five is greater"

;; when: runs only if test is true; can have multiple body forms
(when (> *max-lives* 0)
  (format t "Player is alive!~%"))

;; unless: runs only if test is NIL (false)
(unless (zerop *max-lives*)
  (decf *max-lives*))    ; decrement by 1

;; cond: like an if/else-if chain
(defun classify-temp (c)
  (cond
    ((< c  0)  "freezing")
    ((< c 15)  "cold")
    ((< c 25)  "comfortable")
    (t         "hot")))   ; t = default (else)

(classify-temp 22)   ; → "comfortable"

;; dotimes — repeat N times (i goes 0 to N-1)
(dotimes (i 5)
  (format t "~a " i))
; Prints: 0 1 2 3 4

;; dolist — iterate over a list
(dolist (fruit '(apple banana cherry))
  (format t "I like ~a~%" fruit))

;; loop macro — powerful iteration
(loop for i from 1 to 5
      collect (* i i))
; → (1 4 9 16 25)  (list of squares)

;; loop with filtering
(loop for i from 1 to 20
      when (evenp i)
      collect i)
; → (2 4 6 8 10 12 14 16 18 20)

;; loop with accumulation
(loop for i from 1 to 100 sum i)
; → 5050  (sum of 1 to 100)

;; Factorial: n! = n × (n-1)!
(defun factorial (n)
  (if (<= n 1)
      1
      (* n (factorial (- n 1)))))

(factorial 10)  ; → 3628800

;; Fibonacci sequence
(defun fib (n)
  (cond
    ((= n 0) 0)
    ((= n 1) 1)
    (t       (+ (fib (- n 1))
                (fib (- n 2))))))

(fib 10)  ; → 55

;; Recursive list sum
(defun list-sum (lst)
  (if (null lst)
      0
      (+ (car lst)
         (list-sum (cdr lst)))))

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

(defparameter *nums* '(10 20 30 40))

(car  *nums*)          ; → 10       (first element)
(cdr  *nums*)          ; → (20 30 40) (rest of list)
(cadr *nums*)          ; → 20       (second — car of cdr)
(caddr *nums*)         ; → 30       (third)
(last *nums*)          ; → (40)     (last cons cell)

;; Building lists
(cons 5 '(6 7))         ; → (5 6 7)  (prepend)
(list 1 2 3)            ; → (1 2 3)
(append '(1 2) '(3 4)) ; → (1 2 3 4)

;; Inspection
(length *nums*)         ; → 4
(reverse *nums*)        ; → (40 30 20 10)
(member 20 *nums*)      ; → (20 30 40) — tail from match
(nth 2 *nums*)          ; → 30       (0-indexed)
(sort '(3 1 4 1 5) #'<)  ; → (1 1 3 4 5)

;; mapcar — apply a function to every element
(mapcar #'square '(1 2 3 4))
; → (1 4 9 16)

(mapcar (lambda (x) (* x 10)) '(1 2 3))
; → (10 20 30)

;; remove-if — filter out matching elements
(remove-if #'evenp '(1 2 3 4 5 6))
; → (1 3 5)   (removed even numbers)

(remove-if-not #'evenp '(1 2 3 4 5 6))
; → (2 4 6)   (keep only evens)

;; reduce — fold a list into a single value
(reduce #'+ '(1 2 3 4 5))      ; → 15
(reduce #'* '(1 2 3 4 5))      ; → 120
(reduce #'max '(3 9 1 7))     ; → 9

;; Combining them — pipeline style
(reduce #'+
        (mapcar #'square
                (remove-if #'evenp '(1 2 3 4 5))))
; Sum of squares of odd numbers: 1+9+25 = 35

;; A simple macro: swap two variables
(defmacro swap! (a b)
  `(let ((tmp ,a))
     (setf ,a ,b)
     (setf ,b tmp)))

(let ((x 1) (y 2))
  (swap! x y)
  (list x y))  ; → (2 1)

;; A macro: my-when (like built-in when)
(defmacro my-when (test &body body)
  `(if ,test
       (progn ,@body)))

;; Check what code a macro expands to:
(macroexpand-1 '(my-when t (print "hi")))
; → (IF T (PROGN (PRINT "hi")))

(defun fizzbuzz (n)
  (loop for i from 1 to n do
    (format t "~a~%"
      (cond
        ((zerop (mod i 15)) "FizzBuzz")
        ((zerop (mod i  3)) "Fizz")
        ((zerop (mod i  5)) "Buzz")
        (t                 i)))))

(fizzbuzz 15)

(defun flatten (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 7 (8)))))
; → (1 2 3 4 5 6 7 8)

(defun word-frequencies (words)
  (let ((freq (make-hash-table :test #'equal)))
    (dolist (word words)
      (incf (gethash word freq 0)))
    freq))

(let ((counts (word-frequencies
                 '(the cat sat on the mat the cat))))
  (format t "the: ~a~%" (gethash 'the counts))
  (format t "cat: ~a~%" (gethash 'cat counts)))
; the: 3
; cat: 2