(delete "." '("."))
 nil ;; makes sense. 'delete removes the element "." and returns the new list

(delete ".." '(".."))
 nil ;; this also makes sense

(setq hi '("." "..")) ;; define list hi
 ("." "..")

(delete "." hi) ;; removes "." from hi
 ("..")

(delete ".." hi) ;; removes ".." from hi?
 (".") 

 (setq hi (cdr (cdr hi))) 

(setq my-list (delete "." my-list))

 (setq hi (delete "." hi)) 

 (delete "." hi) 

(setq ha '(1 2 3))
(1 2 3)

(delete 1 ha)
(2 3)

ha
(1 2 3) ;; ha is not updated

(delete 2 ha)
(1 3)

ha
(1 3) ;; ha IS updated

(delete 3 ha)
(1)

ha
(1) ;; ha is updated again

(delete 1 ha)
nil

ha
(1) ;; ha is still not updated

(setq ha (cons 0 ha))
(0 1)

(delete 1 ha)
(0)

ha
(0) ;; ha is updated again, likely because 1 was no longer the first element

(global-set-key (kbd "[") "(")
(global-set-key (kbd "]") ")")

(done . "CLOSING NOTE %t")

(setf (cdr list) nil)

a = 1
b = 2
r = { a, b }
x = f(r)
y = r.x + r.y

(*sip*)

(add-hook 'pdf-view-mode-hook 'pdf-view-themed-minor-mode)
(add-hook 'pdf-view-mode-hook 'pdf-view-fit-height-to-window)

     (clojure :variables
              clojure-enable-linters '(clj-kondo)
              clojure-backend 'cider
              clojure-enable-clj-refactor t
              clojure-enable-fancify-symbols t
              cider-enrich-classpath t
              cider-enable-nrepl-jvmti-agent t
              )

(general-create-definer my/leader-keys
    :states '(normal insert visual emacs)
    ; :keymaps 'override
    :prefix "SPC"
    :global-prefix "M-SPC"
)

(my/leader-keys
    "b" '(:ignore t :wk "buffer")
    "b k" '(kill-this-buffer :wk "kill buffer")
)

Symbol's value as variable is void: tramp-remote-path "tramp"

tramp-remote-path is a variable defined in ‘tramp.el’.

Its value is
(tramp-default-remote-path "/bin" "/usr/bin" "/sbin" "/usr/sbin"
                           "/usr/local/bin" "/usr/local/sbin"
                           "/local/bin" "/local/freeware/bin"
                           "/local/gnu/bin" "/usr/freeware/bin"
                           "/usr/pkg/bin" "/usr/contrib/bin"
                           "/opt/bin" "/opt/sbin" "/opt/local/bin"
                           "/opt/homebrew/bin" "/opt/homebrew/sbin")

(add-to-list 'tramp-remote-path 'tramp-own-remote-path)

  (add-to-list 'default-frame-alist
               '(font . "-GOOG-Noto Mono-normal-normal-normal-*-18-*-*-*-m-0-iso10646-1"))

* (if nil t)
NIL

(file-union "my-scripts"
  (list
    (list
      "bin/foo.sh"
      (local-file
        (string-append (getenv "HOME") "/Source/foo.sh")
        #:recursive? #t))
    (list
      "bin/bar"
      (local-file
        (string-append (getenv "HOME") "/Source/perl/bar.pl")
        #:recursive? #t))))

(setq org-agenda-custom-commands
      '(("n" "Next View"
         ((agenda "" ((org-agenda-span 'month)
                      (org-super-agenda-groups
                       '((:name "Today"
                                :time-grid t
                                :todo "TODAY"
                                :scheduled today
                                :order 0)
                         (:habit t)
                         (:name "Due Today"
                                :deadline today
                                :order 2)
                         (:name "Due Soon"
                                :deadline future
                                :order 8)
                         (:name "Overdue"
                                :deadline past
                                :order 7)
                         ))))
          (todo "" ((org-agenda-overriding-header "")
                    (org-super-agenda-groups
                     '((:name "Inbox"
                              :file-path "inbox"
                              :order 0
                              )
                       (:discard (:todo "TODO"))
                       (:auto-category t
                                       :order 9)
                       ))))))
        ("t" "Todo View"
         (
          (todo "" ((org-agenda-overriding-header "")
                    (org-super-agenda-groups
                     '((:name "Inbox"
                              :file-path "inbox"
                              :order 0
                              )
                       (:auto-category t
                                       :order 9)
                       ))))))
        ))

(org-super-agenda-mode)

(define (srfi-name? stx)
    (syntax-case stx (srfi)
      ((srfi n rest ...)
       (and (and-map sym? #'(rest ...))
            (or (n? #'n)
                (colon-n? #'n))))
      (_ #f)))

(define (make-srfi-n context n)
    (datum->syntax
     context
     (string->symbol
      (string-append
       "srfi-"
       (let ((n (syntax->datum n)))
         (if (symbol? n)
             (substring (symbol->string n) 1)
             (number->string n)))))))

((sets . 3) (vectors . 4) (signatures . 5))

define-record-type

(scheme ephemeron)

(setq package-enable-at-startup nil)
(setq use-package-ensure-function 'ignore)
(setq package-archives nil)

(setq org-agenda-span 'month)
;; month
(setq org-agenda-start-day (format-time-string "%Y-%m-01"))
;; "2025-01-01"

(define (compile node)
  (match node
    [('let a b)
     (put "~a = ~a;" (compile a) (compile b))]
    [(a 'int)
     (put "int ~a" (compile a))]
    [('lambda name params type body ...)
     (put "~a ~a(~{~a~^, ~}) { ~{~a~^ ~} }" type name (map compile params) (map compile body))]
    [('call name params ...)
     (put "~a(~{~a~^, ~})" name (map compile params))]
    [('+ a b)
     (put "~a + ~a" (compile a) (compile b))]
    [('return a)
     (put "return ~a;" (compile a))]
    ...

(map compile

 '((lambda square ((x int)) int
     (return (* x x)))

   (lambda main () int
     (let (a int) 4)
     (let (b int) (+ (call square a) (call square a)))
     (end (call printf "%d\n" b))
     (return 0))))

M-x prot-mode

(defun testFunc (input) (let ((myvariable input))
                       (if myvariable  (format nil "ONE"))
                       (if(not myvariable) (format nil "TWO") )
                       ))

(testFunc NIL)

(testFunc T)

(defun testFunc (input) (let ((myvariable input))
                       (if myvariable  (format nil "ONE") (format nil "TWO"))))

(format nil "ONE")

(defun testFunc (input) (let ((myvariable input))
                          (if myvariable (format t "ONE"))
                          (if (not myvariable) (format t "TWO"))))

(setq dired-dwim-target t)

(defun isDivisibleByThree (input) (= 0 (mod input 3)))
(defun isDivisibleByFive (input) (= 0 (mod input 5)))

(defun range (start end) (let ((i start)
                               (rangeList '()))
                           (loop while (<= i end)
                                 do (progn
                                     (setq rangeList (append rangeList (list i)))

                                     (setq i (+ 1 i))))
                           rangeList))


(defun fizzBuzzOnce (input) (let ((isDivByThree (isDivisibleByThree input))
                                  (isDivByFive (isDivisibleByFive input)))

                              (if (and isDivByThree isDivByFive) (format t "FizzBuzz"))
                              (if (and isDivByThree (not isDivByFive)) (format t "Fizz"))
                              (if (and isDivByFive (not isDivByThree)) (format t "Buzz"))))

(defun fizzBuzz () (loop for x in (range 1 100)
                         do (fizzBuzzOnce x)))

(fizzBuzz)

(defun fizzBuzzOnce (input)
  (let ((isDivByThree (isDivisibleByThree input))
        (isDivByFive (isDivisibleByFive input)))
    ;(format t "~a" isDivByFive)
    (if (and isDivByThree isDivByFive) (format t "FizzBuzz"))
    (if (and isDivByThree (not isDivByFive)) (format t "Fizz"))
    (if (and isDivByFive (not isDivByThree)) (format t "Buzz"))))

(setq org-agenda-start-day "-1w")
;; (setq org-agenda-span 45)

(define (f x)
  (values
    x
    (format #t "ok~%")))

> (f 2)
ok
2

(define-syntax prog1
  (syntax-rules ()
    [(_ first rest ...)
     (let ([return first])
       rest ... return)]))