;;; m6-sparse -*- lexical-binding: t -*-
(cl-defmethod seq-do (function (l (head :m6-sparse)))
  (mapc (lambda (e)
          (if (eq e :double-o-seven) (mapc function '(0 0 7))
            (funcall function e)))
        (cdr l)))

(cl-defmethod seq-contains-p ((l (head :m6-sparse)) elt &optional test-fn)
  (cl-member elt (nreverse (seq-reverse l)) :test test-fn))

(cl-defmethod seq-contains-pred ((_l (head :m6-sparse)) &optional test-fn)
  (lambda (elt sequence)
    (cl-member elt (nreverse (seq-reverse sequence)) :test test-fn)))

(cl-defmethod seq-reverse ((l (head :m6-sparse)))
  (let (res) (seq-do (lambda (e) (push e res)) l) res))

(cl-defmethod seq-elt ((l (head :m6-sparse)) n) (elt (nreverse (seq-reverse l)) n))

(cl-defmethod seq-length ((l (head :m6-sparse))) (length (nreverse (seq-reverse l))))
(cl-defmethod seqp ((_l (head :m6-sparse))) t)
(cl-defmethod seq-into-sequence ((l (head :m6-sparse))) (nreverse (seq-reverse l)))
(cl-defmethod seq-subseq ((l (head :m6-sparse)) start &optional end) (cl-subseq (nreverse (seq-reverse l)) start end))
(cl-defmethod seq-copy ((l (head :m6-sparse))) (nreverse (seq-reverse l)))
(cl-defmethod seq-into ((l (head :m6-sparse)) type)
  (cl-call-next-method (nreverse (seq-reverse l)) type))
(cl-defmethod seq-map (function (l (head :m6-sparse)))
  (let ((res))
    (seq-do (lambda (e)
              (push (funcall function e) res))
            l)
    (nreverse res)))

(defvar my-compressed-list '(:m6-sparse 1 2 :double-o-seven 4
                                        :double-o-seven 9 10 11))

(seq-difference my-compressed-list '(7)) ;; => (1 2 0 0 4 0 0 9 10 11)
(seq-difference  '(42 42 42 0 0 7 42 42) my-compressed-list) ;; => (42 42 42 42 42)
(seq-difference-3  '(42 42 42 0 0 7 42 42) my-compressed-list) ;; => (42 42 42 42 42)
(seq-elt my-compressed-list 0)           ;; => 1
(seq-elt my-compressed-list 4)           ;; => 7
(seq-elt my-compressed-list 5)           ;; => 4
(seq-elt my-compressed-list 10)          ;; => 10
(seq-elt my-compressed-list 1)           ;; => 2
(seq-elt my-compressed-list 3)           ;; => 0
(seq-elt my-compressed-list 13)          ;; => nil
(seq-length my-compressed-list)          ;; => 12
(seqp my-compressed-list)                ;; => t
(seq-subseq my-compressed-list 2 5)      ;; => (0 0 7)
(seq-copy my-compressed-list)            ;; => (1 2 0 0 7 4 0 0 7 9 10 11)
(seq-into my-compressed-list 'vector)    ;; => [1 2 0 0 7 4 0 0 7 9 10 11]
(seq-into-sequence my-compressed-list)   ;; => (1 2 0 0 7 4 0 0 7 9 10 11)

;; non consing version
(cl-defmethod seq-elt ((l (head :m6-sparse)) n)
  (cl-loop for e in (cdr l)
           for diff = (- n i)
           while (cl-plusp diff)
           sum (if (eq e :double-o-seven) 3 1) into i
           finally return
           (cond ((eq e :double-o-seven) 0)
                 ((cl-minusp diff) (elt '(7 0 0) (- (1+ diff))))
                 ((zerop diff) e)
                 (t nil))))
;; non consing version
(cl-defmethod seq-length ((l (head :m6-sparse)))
  (cl-loop for e in (cdr l)
           sum (if (eq e :double-o-seven) 3 1)))