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

134
emacs/.emacs.d/wpc/set.el
View file

@ -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