maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

More Elisp linting

Browse source 
This should cover most of the remaining linting errors. After this, I expect
fewer than ten linting errors.
This commit is contained in:
William Carroll 2020-09-01 10:17:43 +01:00
parent a638e15c0d
commit fb5ec068dd
47 changed files with 1049 additions and 989 deletions
Download patch file Download diff file Expand all files Collapse all files

120
emacs/.emacs.d/wpc/alist.el
View file

@ -1,5 +1,9 @@
;;; alist.el --- Interface for working with associative lists -*- lexical-binding: t -*-
;; Author: William Carroll <wpcarro@gmail.com>
;; Version: 0.0.1
;; URL: https://git.wpcarro.dev/wpcarro/briefcase
;; Package-Requires: ((emacs "25.1"))
;;; Commentary:
;; Firstly, a rant:
@ -89,7 +93,7 @@
;; Constants
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defconst alist/enable-tests? t
(defconst alist-enable-tests? t
"When t, run the test suite.")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@ -97,21 +101,21 @@
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; TODO: Support a variadic version of this to easily construct alists.
(defun alist/new ()
(defun alist-new ()
"Return a new, empty alist."
'())
;; Create
;; TODO: See if this mutates.
(defun alist/set (k v xs)
(defun alist-set (k v xs)
"Set K to V in XS."
(if (alist/has-key? k xs)
(if (alist-has-key? k xs)
(progn
(setf (alist-get k xs) v)
xs)
(list/cons `(,k . ,v) xs)))
(list-cons `(,k . ,v) xs)))
(defun alist/set! (k v xs)
(defun alist-set! (k v xs)
"Set K to V in XS mutatively.
Note that this doesn't append to the alist in the way that most alists handle
writing. If the k already exists in XS, it is overwritten."
@ -119,113 +123,113 @@ Note that this doesn't append to the alist in the way that most alists handle
(map-put xs k v))
;; Read
(defun alist/get (k xs)
(defun alist-get (k xs)
"Return the value at K in XS; otherwise, return nil.
Returns the first occurrence of K in XS since alists support multiple entries."
(cdr (assoc k xs)))
(defun alist/get-entry (k xs)
(defun alist-get-entry (k xs)
"Return the first key-value pair at K in XS."
(assoc k xs))
;; Update
;; TODO: Add warning about only the first occurrence being updated in the
;; documentation.
(defun alist/update (k f xs)
(defun alist-update (k f xs)
"Apply F to the value stored at K in XS.
If `K' is not in `XS', this function errors. Use `alist/upsert' if you're
If `K' is not in `XS', this function errors. Use `alist-upsert' if you're
interested in inserting a value when a key doesn't already exist."
(if (maybe-nil? (alist/get k xs))
(if (maybe-nil? (alist-get k xs))
(error "Refusing to update: key does not exist in alist")
(alist/set k (funcall f (alist/get k xs)) xs)))
(alist-set k (funcall f (alist-get k xs)) xs)))
(defun alist/update! (k f xs)
(defun alist-update! (k f xs)
"Call F on the entry at K in XS.
Mutative variant of `alist/update'."
(alist/set! k (funcall f (alist/get k xs))xs))
Mutative variant of `alist-update'."
(alist-set! k (funcall f (alist-get k xs))xs))
;; TODO: Support this.
(defun alist/upsert (k v f xs)
(defun alist-upsert (k v f xs)
"If K exists in `XS' call `F' on the value otherwise insert `V'."
(if (alist/get k xs)
(alist/update k f xs)
(alist/set k v xs)))
(if (alist-get k xs)
(alist-update k f xs)
(alist-set k v xs)))
;; Delete
;; TODO: Make sure `delete' and `remove' behave as advertised in the Elisp docs.
(defun alist/delete (k xs)
(defun alist-delete (k xs)
"Deletes the entry of K from XS.
This only removes the first occurrence of K, since alists support multiple
key-value entries. See `alist/delete-all' and `alist/dedupe'."
key-value entries. See `alist-delete-all' and `alist-dedupe'."
(remove (assoc k xs) xs))
(defun alist/delete! (k xs)
(defun alist-delete! (k xs)
"Delete the entry of K from XS.
Mutative variant of `alist/delete'."
Mutative variant of `alist-delete'."
(delete (assoc k xs) xs))
;; Additions to the CRUD API
;; TODO: Implement this function.
(defun alist/dedupe-keys (xs)
(defun alist-dedupe-keys (xs)
"Remove the entries in XS where the keys are `equal'.")
(defun alist/dedupe-entries (xs)
(defun alist-dedupe-entries (xs)
"Remove the entries in XS where the key-value pair are `equal'."
(delete-dups xs))
(defun alist/keys (xs)
(defun alist-keys (xs)
"Return a list of the keys in XS."
(mapcar 'car xs))
(defun alist/values (xs)
(defun alist-values (xs)
"Return a list of the values in XS."
(mapcar 'cdr xs))
(defun alist/has-key? (k xs)
(defun alist-has-key? (k xs)
"Return t if XS has a key `equal' to K."
(maybe-some? (assoc k xs)))
(defun alist/has-value? (v xs)
(defun alist-has-value? (v xs)
"Return t if XS has a value of V."
(maybe-some? (rassoc v xs)))
(defun alist/count (xs)
(defun alist-count (xs)
"Return the number of entries in XS."
(length xs))
;; TODO: Should I support `alist/find-key' and `alist/find-value' variants?
(defun alist/find (p xs)
;; TODO: Should I support `alist-find-key' and `alist-find-value' variants?
(defun alist-find (p xs)
"Apply a predicate fn, P, to each key and value in XS and return the key of
the first element that returns t."
(let ((result (list/find (lambda (x) (funcall p (car x) (cdr x))) xs)))
(let ((result (list-find (lambda (x) (funcall p (car x) (cdr x))) xs)))
(if result
(car result)
nil)))
(defun alist/map-keys (f xs)
(defun alist-map-keys (f xs)
"Call F on the values in XS, returning a new alist."
(list/map (lambda (x)
(list-map (lambda (x)
`(,(funcall f (car x)) . ,(cdr x)))
xs))
(defun alist/map-values (f xs)
(defun alist-map-values (f xs)
"Call F on the values in XS, returning a new alist."
(list/map (lambda (x)
(list-map (lambda (x)
`(,(car x) . ,(funcall f (cdr x))))
xs))
(defun alist/reduce (acc f xs)
(defun alist-reduce (acc f xs)
"Return a new alist by calling F on k v and ACC from XS.
F should return a tuple. See tuple.el for more information."
(->> (alist/keys xs)
(list/reduce acc
(->> (alist-keys xs)
(list-reduce acc
(lambda (k acc)
(funcall f k (alist/get k xs) acc)))))
(funcall f k (alist-get k xs) acc)))))
(defun alist/merge (a b)
(defun alist-merge (a b)
"Return a new alist with a merge of alists, A and B.
In this case, the last writer wins, which is B."
(alist/reduce a #'alist/set b))
(alist-reduce a #'alist-set b))
;; TODO: Support `-all' variants like:
;; - get-all
@ -239,34 +243,34 @@ In this case, the last writer wins, which is B."
(first-name . "William")
(last-name . "Carroll")
(last-name . "Another")))
(alist/set 'last-name "Van Gogh" person)
(alist/get 'last-name person)
(alist/update 'last-name (lambda (x) "whoops") person)
(alist/delete 'first-name person)
(alist/keys person)
(alist/values person)
(alist/count person)
(alist/has-key? 'first-name person)
(alist/has-value? "William" person)
;; (alist/dedupe-keys person)
(alist/dedupe-entries person)
(alist/count person)))
(alist-set 'last-name "Van Gogh" person)
(alist-get 'last-name person)
(alist-update 'last-name (lambda (x) "whoops") person)
(alist-delete 'first-name person)
(alist-keys person)
(alist-values person)
(alist-count person)
(alist-has-key? 'first-name person)
(alist-has-value? "William" person)
;; (alist-dedupe-keys person)
(alist-dedupe-entries person)
(alist-count person)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Tests
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(when alist/enable-tests?
(when alist-enable-tests?
(prelude-assert
(equal '((2 . one)
(3 . two))
(alist/map-keys #'1+
(alist-map-keys #'1+
'((1 . one)
(2 . two)))))
(prelude-assert
(equal '((one . 2)
(two . 3))
(alist/map-values #'1+
(alist-map-values #'1+
'((one . 1)
(two . 2))))))