Превратить список с парной количеством элементов в ассоциативной список

(defun mk-asso (lst &optional (n 1))
  (cond ((null lst) nil)
        (t (cons (cons (car lst) n) (mk-asso (cdr lst) (+ n 1))))))
 
==> mk-asso
 
(mk-asso '(a b c d e f))
 
==> ((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6))

(defun ASSO (l l2)
    (if l
        (cons (cons (car l) (car l2)) (ASSO (cdr l) (cdr l2)))
        nil))
 
(ASSO '(a b c d e) '(1 2 3 4 5))
 
==> ((a . 1) (b . 2) (c . 3) (d . 4) (e . 5))
 
 
 
 
(defun ASSO (l l2)
    (mapcar 'cons l l2))
 
(ASSO '(a b c d e) '(1 2 3 4 5))
 
==> ((a . 1) (b . 2) (c . 3) (d . 4) (e . 5))

(defun cons-n (w &optional (n 1))
  (when  w (cons (cons (car w) n) (cons-n (cdr w) (1+ n)))))
 
> (cons-n '(11 12 13 14))
((11 . 1) (12 . 2) (13 . 3) (14 . 4))

(defun F (ls)
  (let ((n 0))
    (mapcar #'(lambda (x) (cons x (incf n))) ls)))
 
> (F '(a b c d e))
((a . 1) (b . 2) (c . 3) (d . 4) (e . 5))

(defun f (xs)
  (iter (for i from 1)
        (for x in xs)
        (collect (cons x i))))

(defun cons-n (w)
  (loop for a in w
        for b upfrom 1
        collect (cons a b)))
 
> (cons-n '(11 12 13 14))
((11 . 1) (12 . 2) (13 . 3) (14 . 4))

(defun cons-n (w)
  (loop for a in w
        for b from 1
        collect (cons a b)))
 
> (cons-n '(11 12 13 14))
((11 . 1) (12 . 2) (13 . 3) (14 . 4))

(defun task (lst)
  (mapcar 'cons lst (range 1 (length lst))))
 
==> task
 
(task '(a b c d e f))
 
==> ((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6))

(defun with-pairs (f w)
    (when w 
        (cons 
            (funcall f (car w) (cadr w)) 
            (with-pairs f (cddr w))
        )
    )
)
WITH-PAIRS
 
CL-USER 2 > 
(with-pairs #'list '(a b c d e f g h))
((A B) (C D) (E F) (G H))

CL-USER 3 > 
(defun pairs-alist (xs)
  (mapcar #'(lambda (x)
              (cons (first x) (second x)))
          xs))
PAIRS-ALIST
 
CL-USER 4 > 
(pairs-alist '((A B) (B C) (E F) (G H))) 
((A . B) (B . C) (E . F) (G . H))

(defun with-pairs (f w)
    (when w 
        (cons 
            (funcall f (car w) (cadr w)) 
            (with-pairs f (cddr w)))))
 
(defun pairs-alist (xs)
  (mapcar #'(lambda (x)
              (cons (first x) (second x)))
          xs))
 
(defun cons-pairs (f w)
  (pairs-alist (with-pairs f w)))
 
> (cons-pairs #'list '(a b c d e f g h))
((A . B) (C . D) (E . F) (G . H))

(defun composition(f w)
 (pairs-alist  (with-pairs f w)))

(in-package :cl-user)
 
(let ((modules (list :alexandria :iterate)))
  (mapc #'require     modules)
  (mapc #'use-package modules))
 
(defun with-pairs (f xs)
  (iter (for (x1 x2) on xs by #'cddr)
        (collect (funcall f x1 x2))))
 
(defun pairs-alist (xs)
  (iter (for (x1 x2) in xs)
        (collect (cons x1 x2))))
 
(pairs-alist (with-pairs #'list (list 1 2 3 4)))
 
(let ((f (compose #'pairs-alist
                  (curry #'with-pairs #'list))))
  (funcall f (list 1 2 3 4 5 6)))