(defmacro alist-map-cons (&rest args)
  (let* ((last (- (length args) 1))
         (head (car args))
         (tail (cdr args)))
    `(cl-loop for item in ,head
              if (consp item)
              ,@tail)))

(defun alist-repr (alist)
  (format "(%s)" (alist-map-cons alist concat (format "%S" item))))
;; (alist-repr '((a . 1) (b . 2) c)) => "((a . 1)(b . 2))"

(defun alist-print (alist)
  (message (string-join (split-string (alist-repr alist) ")(") ")\n  (")))
;; (alist-print '((a . 1) (b . 2) c)) => "((a . 1)
;;                                         (b . 2))"

(defun alist-len (alist)
  (alist-map-cons alist sum 1))
;; (alist-len '((a . 1) (b . 2) c)) => 2

(defun alist-items (alist)
  (alist-map-cons alist collect item))
;; (alist-items '((a . 1) (b . 2) (c . 3))) => ((a . 1) (b . 2) (c . 3))
;; (alist-items '((a . 1) (b . 2) c)) => ((a . 1) (b . 2))

(defun alist-keys (alist)
  (alist-map-cons alist collect (car item)))
;; (alist-keys '((a . 1) (b . 2) (c . 3))) => (a b c)
;; (alist-keys '((a . 1) (b . 2) c)) => (a b)

(defun alist-values (alist)
  (alist-map-cons alist collect (cdr item)))
;; (alist-values '((a . 1) (b . 2) (c . 3))) => (1 2 3)
;; (alist-values '((a . 1) (b . 2) c)) => (1 2)

(defun alist-remove (alist key)
  (alist-map-cons alist
                  if (not (equal key (car item)))
                  collect item))
;; (alist-remove '((a . 1) (b . 2) (c . 3)) 'b) => ((a . 1) (c . 3))
;; (alist-remove '((a . 1) (b . 2) c) 'b) => ((a . 1))

(defun alist-set (alist key val)
  (let* ((found nil)
         (alist (alist-map-cons alist
                                if (equal key (car item))
                                collect (cons key val)
                                and do (setq found t)
                                else
                                collect item end)))
    (if found alist
      (append alist (list (cons key val))))))
;; (alist-set '((a . 1) (b . 2)) 'c 3) => ((a . 1) (b . 2) (c . 3))
;; (alist-set '((a . 1) (b . 2)) 'b 3) => ((a . 1) (b . 3))

(defun alist-pop (alist key)
  (let* ((result)
         (alist (alist-map-cons alist
                                if (equal key (car item))
                                do (setq result (cdr item))
                                else
                                collect item)))
    (cons alist result)))
;; (alist-pop '((a . 1) (b . 2) (c . 3)) 'b) => (((a . 1) (c . 3)) . 2)
;; (alist-pop '((a . 1) (b . 2) c) 'c) => (((a . 1) (b . 2)))


(defun alist-merge (a b)
  (if (not b) a
    (-let* ((((key . value) . b) b)
            (a (alist-set a key value)))
      (alist-merge a b))))
;; (alist-merge '((a . 1) (c . 3)) '((b . 2))) => ((a . 1) (c . 3) (b . 2))
;; (alist-merge '((a . 1) c) '((b . 2))) => ((a . 1) (b . 2))