The input I may be a character, or a single-letter string.

Cribbed from `org-id-b36-to-int-one-digit'."

  (and (stringp i) (setq i (string-to-char i)))

  (cond ((and (>= i ?0) (<= i ?9)) (- i ?0))

        ((and (>= i ?A) (<= i ?Z)) (+ (- i ?A) 10))

        (t (error "Invalid b36 character"))))

(defun wg-int-to-b36 (i &optional length)

  "Return a base 36 string from I."

  (let ((base 36) b36)

    (cl-labels ((add-digit () (push (wg-int-to-b36-one-digit (mod i base)) b36)

                         (setq i (/ i base))))

      (add-digit)

      (while (> i 0) (add-digit))

      (setq b36 (cl-map 'string 'identity b36))

      (if (not length) b36

        (concat (make-string (max 0 (- length (length b36))) ?0) b36)))))

(defun wg-b36-to-int (str)

  "Convert STR, a base-36 string, into the corresponding integer.

Cribbed from `org-id-b36-to-int'."

  (let ((result 0))

    (mapc (lambda (i)

            (setq result (+ (* result 36)

                            (wg-b36-to-int-one-digit i))))

          str)

    result))

;;; lists

(defmacro wg-removef-p (item seq-place &rest keys)

  "If ITEM is a `member*' of SEQ-PLACE, remove it from SEQ-PLACE and return t.

Otherwise return nil.  KEYS can be any keywords accepted by `remove*'."

  `(> (length ,seq-place)

      (length (setf ,seq-place (cl-remove ,item ,seq-place ,@keys)))))

(defmacro wg-pushnew-p (item seq-place &rest keys)

  "If ITEM is not a `member' of SEQ-PLACE, push it to SEQ-PLACE and return t.

Otherwise return nil.  KEYS can be any keyword args accepted by `pushnew'."

  `(< (length ,seq-place)

      (length (cl-pushnew ,item ,seq-place ,@keys))))

(defun wg-take (list n)

  "Return a list of the first N elts in LIST."

  (butlast list (- (length list) n)))

(defun wg-rnth (n list)

  "Return the Nth element of LIST, counting from the end."

  (nth (- (length list) n 1) list))

(defun wg-take-until-fail (pred list)

  "Take elements from LIST up to the first element on which PRED fails."

  (let (taken)

    (catch 'result

      (dolist (elt list (nreverse taken))

        (if (funcall pred elt) (push elt taken)

          (throw 'result (nreverse taken)))))))

(defun wg-range (start end)

  "Return a list of integers from START up to but not including END."

  (let (accum)

    (dotimes (i (- end start) (nreverse accum))

      (push (+ start i) accum))))

(defun wg-rotate-list (list &optional offset)

  "Rotate LIST by OFFSET.  Positive OFFSET rotates left, negative right."

  (when list

    (let ((split (mod (or offset 1) (length list))))

      (append (nthcdr split list) (wg-take list split)))))

(defun wg-center-rotate-list (list)

  "Rotate LIST so it's first elt is in the center.  When LIST's

length is even, the first elt is left nearer the front."

  (wg-rotate-list list (- (/ (1- (length list)) 2))))

(defun wg-insert-after (elt list index)

  "Insert ELT into LIST after INDEX."

  (let ((new-list (cl-copy-list list)))

    (push elt (cdr (nthcdr index new-list)))

    new-list))

(defun wg-insert-before (elt list index)

  "Insert ELT into LIST before INDEX."

  (if (zerop index) (cons elt list)

    (wg-insert-after elt list (1- index))))

(defun wg-move-elt (elt list index &rest keys)

  "Move ELT before INDEX in LIST.

KEYS is passed to `remove*'."

  (wg-insert-before elt (apply 'cl-remove elt list keys) index))

(defun wg-cyclic-nth (list n)

  "Return the Nth element of LIST, modded by the length of list."

  (nth (mod n (length list)) list))