More Elisp linting

This should cover most of the remaining linting errors. After this, I expect
fewer than ten linting errors.

1 files changed, 69 insertions, 65 deletions

diff --git a/emacs/.emacs.d/wpc/set.el b/emacs/.emacs.d/wpc/set.el
index c24fbbd574..2eb8964515 100644
--- a/emacs/.emacs.d/wpc/set.el
+++ b/emacs/.emacs.d/wpc/set.el
@@ -1,5 +1,9 @@
 ;;; set.el --- Working with mathematical sets -*- lexical-binding: t -*-
+
 ;; Author: William Carroll <wpcarro@gmail.com>
+;; Version: 0.0.1
+;; URL: https://git.wpcarro.dev/wpcarro/briefcase
+;; Package-Requires: ((emacs "24.3"))
 
 ;;; Commentary:
 ;; The set data structure is a collection that deduplicates its elements.
@@ -24,26 +28,26 @@
 
 (cl-defstruct set xs)
 
-(defconst set/enable-testing? t
+(defconst set-enable-testing? t
   "Run tests when t.")
 
-(defun set/from-list (xs)
+(defun set-from-list (xs)
   "Create a new set from the list XS."
   (make-set :xs (->> xs
-                     (list/map #'dotted/new)
+                     (list-map #'dotted-new)
                      ht-from-alist)))
 
-(defun set/new (&rest args)
+(defun set-new (&rest args)
   "Create a new set from ARGS."
-  (set/from-list args))
+  (set-from-list args))
 
-(defun set/to-list (xs)
+(defun set-to-list (xs)
   "Map set XS into a list."
   (->> xs
        set-xs
        ht-keys))
 
-(defun set/add (x xs)
+(defun set-add (x xs)
   "Add X to set XS."
   (struct-update set
                  xs
@@ -54,22 +58,22 @@
                  xs))
 
 ;; TODO: Ensure all `*/reduce' functions share the same API.
-(defun set/reduce (acc f xs)
+(defun set-reduce (acc f xs)
   "Return a new set by calling F on each element of XS and ACC."
   (->> xs
-       set/to-list
-       (list/reduce acc f)))
+       set-to-list
+       (list-reduce acc f)))
 
-(defun set/intersection (a b)
+(defun set-intersection (a b)
   "Return the set intersection between sets A and B."
-  (set/reduce (set/new)
+  (set-reduce (set-new)
               (lambda (x acc)
-                (if (set/contains? x b)
-                    (set/add x acc)
+                (if (set-contains? x b)
+                    (set-add x acc)
                   acc))
               a))
 
-(defun set/count (xs)
+(defun set-count (xs)
   "Return the number of elements in XS."
   (->> xs
        set-xs
@@ -79,93 +83,93 @@
 ;; Predicates
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(defun set/empty? (xs)
+(defun set-empty? (xs)
   "Return t if XS has no elements in it."
-  (= 0 (set/count xs)))
+  (= 0 (set-count xs)))
 
-(defun set/contains? (x xs)
+(defun set-contains? (x xs)
   "Return t if set XS has X."
   (ht-contains? (set-xs xs) x))
 
 ;; TODO: Prefer using `ht.el' functions for this.
-(defun set/equal? (a b)
+(defun set-equal? (a b)
   "Return t if A and B share the name members."
   (ht-equal? (set-xs a)
              (set-xs b)))
 
-(defun set/distinct? (a b)
+(defun set-distinct? (a b)
   "Return t if sets A and B have no shared members."
-  (set/empty? (set/intersection a b)))
+  (set-empty? (set-intersection a b)))
 
-(defun set/superset? (a b)
+(defun set-superset? (a b)
   "Return t if set A contains all of the members of set B."
   (->> b
-       set/to-list
-       (list/all? (lambda (x) (set/contains? x a)))))
+       set-to-list
+       (list-all? (lambda (x) (set-contains? x a)))))
 
-(defun set/subset? (a b)
+(defun set-subset? (a b)
   "Return t if each member of set A is present in set B."
-  (set/superset? b a))
+  (set-superset? b a))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Tests
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(when set/enable-testing?
-  ;; set/distinct?
+(when set-enable-testing?
+  ;; set-distinct?
   (prelude-assert
-   (set/distinct? (set/new 'one 'two 'three)
-                  (set/new 'a 'b 'c)))
+   (set-distinct? (set-new 'one 'two 'three)
+                  (set-new 'a 'b 'c)))
   (prelude-refute
-   (set/distinct? (set/new 1 2 3)
-                  (set/new 3 4 5)))
+   (set-distinct? (set-new 1 2 3)
+                  (set-new 3 4 5)))
   (prelude-refute
-   (set/distinct? (set/new 1 2 3)
-                  (set/new 1 2 3)))
-  ;; set/equal?
+   (set-distinct? (set-new 1 2 3)
+                  (set-new 1 2 3)))
+  ;; set-equal?
   (prelude-refute
-   (set/equal? (set/new 'a 'b 'c)
-               (set/new 'x 'y 'z)))
+   (set-equal? (set-new 'a 'b 'c)
+               (set-new 'x 'y 'z)))
   (prelude-refute
-   (set/equal? (set/new 'a 'b 'c)
-               (set/new 'a 'b)))
+   (set-equal? (set-new 'a 'b 'c)
+               (set-new 'a 'b)))
   (prelude-assert
-   (set/equal? (set/new 'a 'b 'c)
-               (set/new 'a 'b 'c)))
-  ;; set/intersection
+   (set-equal? (set-new 'a 'b 'c)
+               (set-new 'a 'b 'c)))
+  ;; set-intersection
   (prelude-assert
-   (set/equal? (set/new 2 3)
-               (set/intersection (set/new 1 2 3)
-                                 (set/new 2 3 4))))
-  ;; set/{from,to}-list
+   (set-equal? (set-new 2 3)
+               (set-intersection (set-new 1 2 3)
+                                 (set-new 2 3 4))))
+  ;; set-{from,to}-list
   (prelude-assert (equal '(1 2 3)
                          (->> '(1 1 2 2 3 3)
-                              set/from-list
-                              set/to-list)))
-  (let ((primary-colors (set/new "red" "green" "blue")))
-    ;; set/subset?
+                              set-from-list
+                              set-to-list)))
+  (let ((primary-colors (set-new "red" "green" "blue")))
+    ;; set-subset?
     (prelude-refute
-     (set/subset? (set/new "black" "grey")
+     (set-subset? (set-new "black" "grey")
                   primary-colors))
     (prelude-assert
-     (set/subset? (set/new "red")
+     (set-subset? (set-new "red")
                   primary-colors))
-    ;; set/superset?
+    ;; set-superset?
     (prelude-refute
-     (set/superset? primary-colors
-                    (set/new "black" "grey")))
+     (set-superset? primary-colors
+                    (set-new "black" "grey")))
     (prelude-assert
-     (set/superset? primary-colors
-                    (set/new "red" "green" "blue")))
+     (set-superset? primary-colors
+                    (set-new "red" "green" "blue")))
     (prelude-assert
-     (set/superset? primary-colors
-                    (set/new "red" "blue"))))
-  ;; set/empty?
-  (prelude-assert (set/empty? (set/new)))
-  (prelude-refute (set/empty? (set/new 1 2 3)))
-  ;; set/count
-  (prelude-assert (= 0 (set/count (set/new))))
-  (prelude-assert (= 2 (set/count (set/new 1 1 2 2)))))
+     (set-superset? primary-colors
+                    (set-new "red" "blue"))))
+  ;; set-empty?
+  (prelude-assert (set-empty? (set-new)))
+  (prelude-refute (set-empty? (set-new 1 2 3)))
+  ;; set-count
+  (prelude-assert (= 0 (set-count (set-new))))
+  (prelude-assert (= 2 (set-count (set-new 1 1 2 2)))))
 
 (provide 'set)
 ;;; set.el ends here