mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Support cycle/previous-focus

Browse source 
Define a `cycle/previous-focus` function that returns the item that was
previously "focused" in the cycle. This is helpful for toggling back-and-forth
between buffers and EXWM workspaces for example without needing to define ad-hoc
variables to support it.

Also: Adds tests to cycle.el.

Also: Prefers `struct/set!` instead of `setf`. See the previous commit's message
for more information about that preference.
This commit is contained in:
William Carroll 2020-01-09 13:41:44 +00:00
parent ef881e059b
commit b52d210b9b
1 changed files with 55 additions and 19 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
configs/shared/.emacs.d/wpc/cycle.el
View file

@ -7,8 +7,13 @@
;;; Code:
(require 'struct)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Dependencies
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'prelude)
(require 'math)
(require 'maybe)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Wish list
@ -24,16 +29,21 @@
;; `current-index' tracks the current index
;; `xs' is the original list
(cl-defstruct cycle current-index xs)
(cl-defstruct cycle current-index previous-index xs)
(defconst cycle/enable-tests? t
"When t, run the tests defined herein.")
(defun cycle/new (&rest xs)
"Create an empty cycle."
(make-cycle :current-index 0
:previous-index nil
:xs xs))
(defun cycle/from-list (xs)
"Create a cycle from a list of `XS'."
(make-cycle :current-index 0
:previous-index nil
:xs xs))
(defun cycle/to-list (xs)
@ -58,19 +68,28 @@
lo
(+ 1 x)))
(defun cycle/prev (cycle)
"Return the previous value in `CYCLE' and update `current-index'."
(let* ((current-index (cycle-current-index cycle))
(next-index (next-index<- 0 (cycle/count cycle) current-index)))
(setf (cycle-current-index cycle) next-index)
(nth next-index (cycle-xs cycle))))
(defun cycle/previous-focus (cycle)
"Return the previously focused entry in CYCLE."
(let ((i (cycle-previous-index cycle)))
(if (maybe/some? i)
(nth i (cycle-xs cycle))
nil)))
(defun cycle/next (cycle)
"Return the next value in `CYCLE' and update `current-index'."
(let* ((current-index (cycle-current-index cycle))
(next-index (next-index-> 0 (cycle/count cycle) current-index)))
(setf (cycle-current-index cycle) next-index)
(nth next-index (cycle-xs cycle))))
(defun cycle/next (xs)
"Return the next value in `XS' and update `current-index'."
(let* ((current-index (cycle-current-index xs))
(next-index (next-index-> 0 (cycle/count xs) current-index)))
(struct/set! cycle previous-index current-index xs)
(struct/set! cycle current-index next-index xs)
(nth next-index (cycle-xs xs))))
(defun cycle/prev (xs)
"Return the previous value in `XS' and update `current-index'."
(let* ((current-index (cycle-current-index xs))
(next-index (next-index<- 0 (cycle/count xs) current-index)))
(struct/set! cycle previous-index current-index xs)
(struct/set! cycle current-index next-index xs)
(nth next-index (cycle-xs xs))))
(defun cycle/current (cycle)
"Return the current value in `CYCLE'."
@ -80,11 +99,13 @@
"Return the length of `xs' in `CYCLE'."
(length (cycle-xs cycle)))
(defun cycle/jump (i cycle)
"Jump to the I index of CYCLE."
(setf (cycle-current-index cycle)
(math/mod i (cycle/count cycle)))
cycle)
(defun cycle/jump (i xs)
"Jump to the I index of XS."
(let ((current-index (cycle-current-index xs))
(next-index (math/mod i (cycle/count xs))))
(struct/set! cycle previous-index current-index xs)
(struct/set! cycle current-index next-index xs))
xs)
(defun cycle/focus (p cycle)
"Focus the element in CYCLE for which predicate, P, is t."
@ -101,5 +122,20 @@
cycle-xs
(list/contains? x)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Tests
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(when cycle/enable-tests?
(let ((xs (cycle/new 1 2 3)))
(prelude/assert (maybe/nil? (cycle/previous-focus xs)))
(prelude/assert (= 1 (cycle/current xs)))
(prelude/assert (= 2 (cycle/next xs)))
(prelude/assert (= 1 (cycle/previous-focus xs)))
(prelude/assert (= 1 (->> xs (cycle/jump 0) cycle/current)))
(prelude/assert (= 2 (->> xs (cycle/jump 1) cycle/current)))
(prelude/assert (= 3 (->> xs (cycle/jump 2) cycle/current)))
(prelude/assert (= 2 (cycle/previous-focus xs)))))
(provide 'cycle)
;;; cycle.el ends here