From 8fd9b91d2938bc68b4ed7d1a2dac3f753d3fa31e Mon Sep 17 00:00:00 2001 From: William Carroll Date: Thu, 24 Nov 2022 22:41:47 -0800 Subject: chore(wpcarro/emacs): Delete unused packages Elisp liposuction Change-Id: Id1940977afb33ae893264cfa388fd05c60b0ec9c Reviewed-on: https://cl.tvl.fyi/c/depot/+/7399 Reviewed-by: tazjin Tested-by: BuildkiteCI Reviewed-by: wpcarro --- users/wpcarro/emacs/.emacs.d/wpc/cache.el | 88 --------------- users/wpcarro/emacs/.emacs.d/wpc/dotted.el | 57 ---------- users/wpcarro/emacs/.emacs.d/wpc/keyboard.el | 28 +++-- users/wpcarro/emacs/.emacs.d/wpc/number.el | 142 ------------------------- users/wpcarro/emacs/.emacs.d/wpc/random.el | 80 -------------- users/wpcarro/emacs/.emacs.d/wpc/scope.el | 106 ------------------ users/wpcarro/emacs/.emacs.d/wpc/sequence.el | 108 ------------------- users/wpcarro/emacs/.emacs.d/wpc/series.el | 92 ---------------- users/wpcarro/emacs/.emacs.d/wpc/stack.el | 101 ------------------ users/wpcarro/emacs/.emacs.d/wpc/timestring.el | 77 -------------- users/wpcarro/emacs/.emacs.d/wpc/window.el | 40 ------- 11 files changed, 13 insertions(+), 906 deletions(-) delete mode 100644 users/wpcarro/emacs/.emacs.d/wpc/cache.el delete mode 100644 users/wpcarro/emacs/.emacs.d/wpc/dotted.el delete mode 100644 users/wpcarro/emacs/.emacs.d/wpc/number.el delete mode 100644 users/wpcarro/emacs/.emacs.d/wpc/random.el delete mode 100644 users/wpcarro/emacs/.emacs.d/wpc/scope.el delete mode 100644 users/wpcarro/emacs/.emacs.d/wpc/sequence.el delete mode 100644 users/wpcarro/emacs/.emacs.d/wpc/series.el delete mode 100644 users/wpcarro/emacs/.emacs.d/wpc/stack.el delete mode 100644 users/wpcarro/emacs/.emacs.d/wpc/timestring.el delete mode 100644 users/wpcarro/emacs/.emacs.d/wpc/window.el diff --git a/users/wpcarro/emacs/.emacs.d/wpc/cache.el b/users/wpcarro/emacs/.emacs.d/wpc/cache.el deleted file mode 100644 index 70ebdb71ef..0000000000 --- a/users/wpcarro/emacs/.emacs.d/wpc/cache.el +++ /dev/null @@ -1,88 +0,0 @@ -;;; cache.el --- Caching things -*- lexical-binding: t -*- - -;; Author: William Carroll -;; Version: 0.0.1 -;; Package-Requires: ((emacs "24.3")) - -;;; Commentary: -;; An immutable cache data structure. -;; -;; This is like a sideways stack, that you can pull values out from and re-push -;; to the top. It'd be like a stack supporting push, pop, pull. -;; -;; This isn't a key-value data-structure like you might expect from a -;; traditional cache. The name is subject to change, but the underlying idea of -;; a cache remains the same. -;; -;; Think about prescient.el, which uses essentially an LRU cache integrated into -;; counsel to help create a "clairovoyant", self-organizing list. -;; -;; Use-cases: -;; - Keeps an cache of workspaces sorted as MRU with an LRU eviction strategy. - -;;; Code: - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Dependencies -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(require 'prelude) -(require 'struct) -(require '>) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Library -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(cl-defstruct cache xs) - -;; TODO: Prefer another KBD for yasnippet form completion than company-mode's -;; current KBD. - -(defun cache-from-list (xs) - "Turn list, XS, into a cache." - (make-cache :xs xs)) - -(defun cache-contains? (x xs) - "Return t if X in XS." - (->> xs - cache-xs - (list-contains? x))) - -(defun cache-touch (x xs) - "Ensure value X in cache, XS, is front of the list. -If X isn't in XS (using `equal'), insert it at the front." - (struct-update - cache - xs - (>-> (list-reject (lambda (y) (equal x y))) - (list-cons x)) - xs)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Tests -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(progn - (let ((cache (cache-from-list '("chicken" "nugget")))) - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - ;; contains?/2 - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - (prelude-refute - (cache-contains? "turkey" cache)) - (prelude-assert - (cache-contains? "chicken" cache)) - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - ;; touch/2 - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - (prelude-assert - (equal - (cache-touch "nugget" cache) - (cache-from-list '("nugget" "chicken")))) - (prelude-assert - (equal - (cache-touch "spicy" cache) - (cache-from-list '("spicy" "chicken" "nugget")))))) - -(provide 'cache) -;;; cache.el ends here diff --git a/users/wpcarro/emacs/.emacs.d/wpc/dotted.el b/users/wpcarro/emacs/.emacs.d/wpc/dotted.el deleted file mode 100644 index b824ddbda7..0000000000 --- a/users/wpcarro/emacs/.emacs.d/wpc/dotted.el +++ /dev/null @@ -1,57 +0,0 @@ -;;; dotted.el --- Working with dotted pairs in Elisp -*- lexical-binding: t -*- - -;; Author: William Carroll -;; Version: 0.0.1 -;; Package-Requires: ((emacs "24.3")) - -;;; Commentary: -;; Part of my primitives library extensions in Elisp. Contrast my primitives -;; with the wrapper extensions that I provide, which expose immutable variants -;; of data structures like an list, alist, tuple, as well as quasi-typeclasses -;; like sequence, etc. - -;;; Code: - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Dependencies -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(require 'prelude) -(require 'macros) -(require 'cl-lib) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Library -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(cl-defun dotted-new (&optional a b) - "Create a new dotted pair of A and B." - (cons a b)) - -(defun dotted-instance? (x) - "Return t if X is a dotted pair." - (let ((b (cdr x))) - (and b (atom b)))) - -(defun dotted-first (x) - "Return the first element of X." - (car x)) - -(defun dotted-second (x) - "Return the second element of X." - (cdr x)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Tests -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(progn - (prelude-assert - (equal '(fname . "Bob") (dotted-new 'fname "Bob"))) - (prelude-assert - (dotted-instance? '(one . two))) - (prelude-refute - (dotted-instance? '(1 2 3)))) - -(provide 'dotted) -;;; dotted.el ends here diff --git a/users/wpcarro/emacs/.emacs.d/wpc/keyboard.el b/users/wpcarro/emacs/.emacs.d/wpc/keyboard.el index 03fb9e3f35..9049d8bd37 100644 --- a/users/wpcarro/emacs/.emacs.d/wpc/keyboard.el +++ b/users/wpcarro/emacs/.emacs.d/wpc/keyboard.el @@ -15,8 +15,6 @@ ;; Dependencies ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -(require 'string) -(require 'number) (require 'cl-lib) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -46,7 +44,7 @@ (defun keyboard-message (x) "Message X in a structured way." - (message (string-format "[keyboard.el] %s" x))) + (message (format "[keyboard.el] %s" x))) (cl-defun keyboard-set-key-repeat (&key (rate keyboard-repeat-rate) @@ -54,7 +52,7 @@ "Use xset to set the key-repeat RATE and DELAY." (prelude-start-process :name "keyboard-set-key-repeat" - :command (string-format "xset r rate %s %s" delay rate))) + :command (format "xset r rate %s %s" delay rate))) ;; NOTE: Settings like this are machine-dependent. For instance I only need to ;; do this on my laptop and other devices where I don't have access to my split @@ -76,42 +74,42 @@ (defun keyboard-inc-repeat-rate () "Increment `keyboard-repeat-rate'." (interactive) - (setq keyboard-repeat-rate (number-inc keyboard-repeat-rate)) + (setq keyboard-repeat-rate (1+ keyboard-repeat-rate)) (keyboard-set-key-repeat :rate keyboard-repeat-rate) (keyboard-message - (string-format "Rate: %s" keyboard-repeat-rate))) + (format "Rate: %s" keyboard-repeat-rate))) (defun keyboard-dec-repeat-rate () "Decrement `keyboard-repeat-rate'." (interactive) - (setq keyboard-repeat-rate (number-dec keyboard-repeat-rate)) + (setq keyboard-repeat-rate (1- keyboard-repeat-rate)) (keyboard-set-key-repeat :rate keyboard-repeat-rate) (keyboard-message - (string-format "Rate: %s" keyboard-repeat-rate))) + (format "Rate: %s" keyboard-repeat-rate))) (defun keyboard-inc-repeat-delay () "Increment `keyboard-repeat-delay'." (interactive) - (setq keyboard-repeat-delay (number-inc keyboard-repeat-delay)) + (setq keyboard-repeat-delay (1+ keyboard-repeat-delay)) (keyboard-set-key-repeat :delay keyboard-repeat-delay) (keyboard-message - (string-format "Delay: %s" keyboard-repeat-delay))) + (format "Delay: %s" keyboard-repeat-delay))) (defun keyboard-dec-repeat-delay () "Decrement `keyboard-repeat-delay'." (interactive) - (setq keyboard-repeat-delay (number-dec keyboard-repeat-delay)) + (setq keyboard-repeat-delay (1- keyboard-repeat-delay)) (keyboard-set-key-repeat :delay keyboard-repeat-delay) (keyboard-message - (string-format "Delay: %s" keyboard-repeat-delay))) + (format "Delay: %s" keyboard-repeat-delay))) (defun keyboard-print-key-repeat () "Print the currently set values for key repeat." (interactive) (keyboard-message - (string-format "Rate: %s. Delay: %s" - keyboard-repeat-rate - keyboard-repeat-delay))) + (format "Rate: %s. Delay: %s" + keyboard-repeat-rate + keyboard-repeat-delay))) (defun keyboard-set-preferences () "Reset the keyboard preferences to their default values. diff --git a/users/wpcarro/emacs/.emacs.d/wpc/number.el b/users/wpcarro/emacs/.emacs.d/wpc/number.el deleted file mode 100644 index c8ed665b30..0000000000 --- a/users/wpcarro/emacs/.emacs.d/wpc/number.el +++ /dev/null @@ -1,142 +0,0 @@ -;;; number.el --- Functions for working with numbers -*- lexical-binding: t -*- - -;; Author: William Carroll -;; Version: 0.0.1 -;; Package-Requires: ((emacs "24")) -;; Homepage: https://user.git.corp.google.com/wpcarro/briefcase - -;;; Commentary: -;; -;; Classifications of numbers: -;; - Natural: (a.k.a positive integers, counting numbers); {1, 2, 3, ... } -;; -;; - Whole: Natural Numbers, plus zero; {0, 1, 2, 3, ...} -;; -;; - Integers: Whole numbers plus all the negatives of the natural numbers; -;; {... , -2, -1, 0, 1, 2, ...} -;; -;; - Rational numbers: (a.k.a. fractions) where the top and bottom numbers are -;; integers; e.g., 1/2, 3/4, 7/2, ⁻4/3, 4/1. Note: The denominator cannot be -;; 0, but the numerator can be. -;; -;; - Real numbers: All numbers that can be written as a decimal. This includes -;; fractions written in decimal form e.g., 0.5, 0.75 2.35, ⁻0.073, 0.3333, or -;; 2.142857. It also includes all the irrational numbers such as π, √2 etc. -;; Every real number corresponds to a point on the number line. -;; -;; The functions defined herein attempt to capture the mathematical definitions -;; of numbers and their classifications as defined above. - -;;; Code: - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Dependencies -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(require 'prelude) -(require 'dash) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Library -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defconst number-test? t - "When t, run the test suite defined herein.") - -;; TODO: What about int.el? - -;; TODO: How do we handle a number typeclass? - -(defun number-positive? (x) - "Return t if `X' is a positive number." - (> x 0)) - -(defun number-negative? (x) - "Return t if `X' is a positive number." - (< x 0)) - -;; TODO: Don't rely on this. Need to have 10.0 and 10 behave similarly. -(defun number-float? (x) - "Return t if `X' is a floating point number." - (floatp x)) - -(defun number-natural? (x) - "Return t if `X' is a natural number." - (and (number-positive? x) - (not (number-float? x)))) - -(defun number-whole? (x) - "Return t if `X' is a whole number." - (or (= 0 x) - (number-natural? x))) - -(defun number-integer? (x) - "Return t if `X' is an integer." - (or (number-whole? x) - (number-natural? (- x)))) - -;; TODO: How defensive should these guards be? Should we assert that the inputs -;; are integers before checking evenness or oddness? - -;; TODO: Look up Runar (from Unison) definition of handling zero as even or odd. - -;; TODO: How should rational numbers be handled? Lisp is supposedly famous for -;; its handling of rational numbers. -;; TODO: `calc-mode' supports rational numbers as "1:2" meaning "1/2" -;; (defun number-rational? (x)) - -;; TODO: Can or should I support real numbers? -;; (defun number-real? (x)) - -(defun number-even? (x) - "Return t if `X' is an even number." - (or (= 0 x) - (= 0 (mod x 2)))) - -(defun number-odd? (x) - "Return t if `X' is an odd number." - (not (number-even? x))) - -(defun number-dec (x) - "Subtract one from `X'. -While this function is undeniably trivial, I have unintentionally done (- 1 x) - when in fact I meant to do (- x 1) that I figure it's better for this function - to exist, and for me to train myself to reach for it and its inc counterpart." - (- x 1)) - -(defun number-inc (x) - "Add one to `X'." - (+ x 1)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Tests -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(when number-test? - (prelude-assert - (number-positive? 10)) - (prelude-assert - (number-natural? 10)) - (prelude-assert - (number-whole? 10)) - (prelude-assert - (number-whole? 0)) - (prelude-assert - (number-integer? 10)) - ;; (prelude-assert - ;; (= 120 (number-factorial 5))) - (prelude-assert - (number-even? 6)) - (prelude-refute - (number-odd? 6)) - (prelude-refute - (number-positive? -10)) - (prelude-refute - (number-natural? 10.0)) - (prelude-refute - (number-natural? -10)) - (prelude-refute - (number-natural? -10.0))) - -(provide 'number) -;;; number.el ends here diff --git a/users/wpcarro/emacs/.emacs.d/wpc/random.el b/users/wpcarro/emacs/.emacs.d/wpc/random.el deleted file mode 100644 index dfe10b6d47..0000000000 --- a/users/wpcarro/emacs/.emacs.d/wpc/random.el +++ /dev/null @@ -1,80 +0,0 @@ -;;; random.el --- Functions for working with randomness -*- lexical-binding: t -*- - -;; Author: William Carroll -;; Version: 0.0.1 -;; Package-Requires: ((emacs "24")) - -;;; Commentary: -;; Functions for working with randomness. Some of this code is not as -;; functional as I'd like from. - -;;; Code: - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Dependencies -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(require 'prelude) -(require 'number) -(require 'math) -(require 'series) -(require 'list) -(require 'set) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Library -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun random-int (x) - "Return a random integer from 0 to `X'." - (random x)) - -;; TODO: Make this work with sequences instead of lists. -(defun random-choice (xs) - "Return a random element of `XS'." - (let ((ct (list-length xs))) - (list-get - (random-int ct) - xs))) - -(defun random-boolean? () - "Randonly return t or nil." - (random-choice (list t nil))) - -;; TODO: This may not work if any of these generate numbers like 0, 1, etc. -(defun random-uuid () - "Return a generated UUID string." - (let ((eight (number-dec (math-triangle-of-power :base 16 :power 8))) - (four (number-dec (math-triangle-of-power :base 16 :power 4))) - (twelve (number-dec (math-triangle-of-power :base 16 :power 12)))) - (format "%x-%x-%x-%x-%x" - (random-int eight) - (random-int four) - (random-int four) - (random-int four) - (random-int twelve)))) - -(defun random-token (length) - "Return a randomly generated hexadecimal string of LENGTH." - (->> (series/range 0 (number-dec length)) - (list-map (lambda (_) (format "%x" (random-int 15)))) - (list-join ""))) - -;; TODO: Support random-sample -;; (defun random-sample (n xs) -;; "Return a randomly sample of list XS of size N." -;; (prelude-assert (and (>= n 0) (< n (list-length xs)))) -;; (cl-labels ((do-sample -;; (n xs y ys) -;; (if (= n (set-count ys)) -;; (->> ys -;; set-to-list -;; (list-map (lambda (i) -;; (list-get i xs)))) -;; (if (set-contains? y ys) -;; (do-sample n xs (random-int (list-length xs)) ys) -;; (do-sample n xs y (set-add y ys)))))) -;; (do-sample n xs (random-int (list-length xs)) (set-new)))) - -(provide 'random) -;;; random.el ends here diff --git a/users/wpcarro/emacs/.emacs.d/wpc/scope.el b/users/wpcarro/emacs/.emacs.d/wpc/scope.el deleted file mode 100644 index 99cdbd2b5e..0000000000 --- a/users/wpcarro/emacs/.emacs.d/wpc/scope.el +++ /dev/null @@ -1,106 +0,0 @@ -;;; scope.el --- Work with a scope data structure -*- lexical-binding: t -*- - -;; Author: William Carroll -;; Version: 0.0.1 -;; Package-Requires: ((emacs "25.1")) - -;;; Commentary: -;; Exposing an API for working with a scope data structure in a non-mutative -;; way. -;; -;; What's a scope? Think of a scope as a stack of key-value bindings. - -;;; Code: - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Dependencies -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(require 'al) -(require 'stack) -(require 'struct) -(require '>) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Create -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(cl-defstruct scope scopes) - -(defun scope-new () - "Return an empty scope." - (make-scope :scopes (->> (stack-new) - (stack-push (al-new))))) - -(defun scope-flatten (xs) - "Return a flattened representation of the scope, XS. -The newest bindings eclipse the oldest." - (->> xs - scope-scopes - stack-to-list - (list-reduce (al-new) - (lambda (scope acc) - (al-merge acc scope))))) - -(defun scope-push-new (xs) - "Push a new, empty scope onto XS." - (struct-update scope - scopes - (>-> (stack-push (al-new))) - xs)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Read -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun scope-get (k xs) - "Return K from XS if it's in scope." - (->> xs - scope-flatten - (al-get k))) - -(defun scope-current (xs) - "Return the newest scope from XS." - (let ((xs-copy (copy-scope xs))) - (->> xs-copy - scope-scopes - stack-peek))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Update -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun scope-set (k v xs) - "Set value, V, at key, K, in XS for the current scope." - (struct-update scope - scopes - (>-> (stack-map-top (>-> (al-set k v)))) - xs)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Delete -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun scope-pop (xs) - "Return a new scope without the top element from XS." - (->> xs - scope-scopes - stack-pop)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Predicates -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun scope-defined? (k xs) - "Return t if K is in scope of XS." - (->> xs - scope-flatten - (al-has-key? k))) - -;; TODO: Find a faster way to write aliases like this. -(defun scope-instance? (xs) - "Return t if XS is a scope struct." - (scope-p xs)) - -(provide 'scope) -;;; scope.el ends here diff --git a/users/wpcarro/emacs/.emacs.d/wpc/sequence.el b/users/wpcarro/emacs/.emacs.d/wpc/sequence.el deleted file mode 100644 index 204a72c5b0..0000000000 --- a/users/wpcarro/emacs/.emacs.d/wpc/sequence.el +++ /dev/null @@ -1,108 +0,0 @@ -;;; sequence.el --- Working with the "sequence" types -*- lexical-binding: t -*- - -;; Author: William Carroll -;; Version: 0.0.1 -;; Package-Requires: ((emacs "25.1")) - -;;; Commentary: -;; Elisp supports a typeclass none as "sequence" which covers the following -;; types: -;; - list: '(1 2 3 4 5) -;; - vector: ["John" 27 :blue] -;; - string: "To be or not to be..." - -;; TODO: Document the difference between a "reduce" and a "fold". I.e. - reduce -;; has an initial value whereas fold uses the first element in the sequence as -;; the initial value. -;; -;; Note: This should be an approximation of Elixir's Enum protocol albeit -;; without streams. -;; -;; Elisp has done a lot of this work already and these are mostly wrapper -;; functions. -;; See the following list for reference: -;; - sequencep -;; - elt -;; - copy-sequence -;; - reverse -;; - nreverse -;; - sort -;; - seq-elt -;; - seq-length -;; - seqp -;; - seq-drop -;; - seq-take -;; - seq-take-while -;; - seq-drop-while -;; - seq-do -;; - seq-map -;; - seq-mapn -;; - seq-filter -;; - seq-remove -;; - seq-reduce -;; - seq-some -;; - seq-find -;; - seq-every-p -;; - seq-empty-p -;; - seq-count -;; - seq-sort -;; - seq-contains -;; - seq-position -;; - seq-uniq -;; - seq-subseq -;; - seq-concatenate -;; - seq-mapcat -;; - seq-partition -;; - seq-intersection -;; - seq-difference -;; - seq-group-by -;; - seq-into -;; - seq-min -;; - seq-max -;; - seq-doseq -;; - seq-let - -;;; Code: - -;; Perhaps we can provide default implementations for `filter' and `map' derived -;; from the `reduce' implementation. -;; (defprotocol sequence -;; :functions (reduce)) -;; (definstance sequence list -;; :reduce #'list-reduce -;; :filter #'list-filter -;; :map #'list-map) -;; (definstance sequence vector -;; :reduce #'vector/reduce) -;; (definstance sequence string -;; :reduce #'string) - -(defun sequence-classify (xs) - "Return the type of `XS'." - (cond - ((listp xs) 'list) - ((vectorp xs) 'vector) - ((stringp xs) 'string))) - -(defun sequence-reduce (acc f xs) - "Reduce of `XS' calling `F' on x and `ACC'." - (seq-reduce - (lambda (acc x) - (funcall f x acc)) - xs - acc)) - -;; Elixir also turned everything into a list for efficiecy reasons. - -(defun sequence-filter (p xs) - "Filter `XS' with predicate, `P'. -Returns a list regardless of the type of `XS'." - (seq-filter p xs)) - -(defun sequence-map (f xs) - "Maps `XS' calling `F' on each element. -Returns a list regardless of the type of `XS'." - (seq-map f xs)) - -(provide 'sequence) -;;; sequence.el ends here diff --git a/users/wpcarro/emacs/.emacs.d/wpc/series.el b/users/wpcarro/emacs/.emacs.d/wpc/series.el deleted file mode 100644 index d890038839..0000000000 --- a/users/wpcarro/emacs/.emacs.d/wpc/series.el +++ /dev/null @@ -1,92 +0,0 @@ -;;; series.el --- Hosting common series of numbers -*- lexical-binding: t -*- - -;; Author: William Carroll -;; Version: 0.0.1 -;; Package-Requires: ((emacs "24")) - -;;; Commentary: -;; Encoding number series as I learn about them. -;; -;; These are the following series I'm interested in supporting: -;; - Fibonacci -;; - Catalan numbers -;; - Figurate number series -;; - Triangular -;; - Square -;; - Pentagonal -;; - Hexagonal -;; - Lazy-caterer -;; - Magic square -;; - Look-and-say - -;;; Code: - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Dependencies -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(require 'number) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Library -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun series-range (beg end) - "Create a list of numbers from `BEG' to `END'. -This is an inclusive number range." - (if (< end beg) - (list-reverse - (number-sequence end beg)) - (number-sequence beg end))) - -(defun series-fibonacci-number (i) - "Return the number in the fibonacci series at `I'." - (cond - ((= 0 i) 0) - ((= 1 i) 1) - (t (+ (series-fibonacci-number (- i 1)) - (series-fibonacci-number (- i 2)))))) - -(defun series-fibonacci (n) - "Return the first `N' numbers of the fibonaccci series starting at zero." - (if (= 0 n) - '() - (list-reverse - (list-cons (series-fibonacci-number (number-dec n)) - (list-reverse - (series-fibonacci (number-dec n))))))) - -;; TODO: Consider memoization. -(defun series-triangular-number (i) - "Return the number in the triangular series at `I'." - (if (= 0 i) - 0 - (+ i (series-triangular-number (number-dec i))))) - -;; TODO: Improve performance. -;; TODO: Consider creating a stream protocol with `stream/next' and implement -;; this using that. -(defun series-triangular (n) - "Return the first `N' numbers of a triangular series starting at 0." - (if (= 0 n) - '() - (list-reverse - (list-cons (series-triangular-number (number-dec n)) - (list-reverse - (series-triangular (number-dec n))))))) - -(defun series-catalan-number (i) - "Return the catalan number in the series at `I'." - (if (= 0 i) - 1 - (/ (number-factorial (* 2 i)) - (* (number-factorial (number-inc i)) - (number-factorial i))))) - -(defun series-catalan (n) - "Return the first `N' numbers in a catalan series." - (->> (series-range 0 (number-dec n)) - (list-map #'series-catalan-number))) - -(provide 'series) -;;; series.el ends here diff --git a/users/wpcarro/emacs/.emacs.d/wpc/stack.el b/users/wpcarro/emacs/.emacs.d/wpc/stack.el deleted file mode 100644 index e81cec6a45..0000000000 --- a/users/wpcarro/emacs/.emacs.d/wpc/stack.el +++ /dev/null @@ -1,101 +0,0 @@ -;;; stack.el --- Working with stacks in Elisp -*- lexical-binding: t -*- - -;; Author: William Carroll -;; Version: 0.0.1 -;; Package-Requires: ((emacs "25.1")) - -;;; Commentary: -;; A stack is a LIFO queue. -;; The design goal here is to expose an intuitive API for working with stacks in -;; non-mutative way. -;; -;; TODO: Consider naming a Functor instance "Mappable." -;; TODO: Consider naming a Foldable instance "Reduceable." -;; -;; TODO: Consider implementing an instance for Mappable. -;; TODO: Consider implementing an instance for Reduceable. - -;;; Code: - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Dependencies -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(require 'list) -(require '>) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Create -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(cl-defstruct stack xs) - -(defun stack-new () - "Create an empty stack." - (make-stack :xs '())) - -(defun stack-from-list (xs) - "Create a new stack from the list, `XS'." - (list-reduce (stack-new) #'stack-push xs)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Read -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun stack-peek (xs) - "Look at the top element of `XS' without popping it off." - (->> xs - stack-xs - list-first)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Update -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun stack-push (x xs) - "Push `X' on `XS'." - (struct-update stack - xs - (>-> (list-cons x)) - xs)) - -;; TODO: How to return something like {(list-head xs), (list-tail xs)} in Elixir -;; TODO: How to handle popping from empty stacks? -(defun stack-pop (xs) - "Return the stack, `XS', without the top element. -Since I cannot figure out a nice way of return tuples in Elisp, if you want to -look at the first element, use `stack-peek' before running `stack-pop'." - (struct-update stack - xs - (>-> list-tail) - xs)) - -(defun stack-map-top (f xs) - "Apply F to the top element of XS." - (->> xs - stack-pop - (stack-push (funcall f (stack-peek xs))))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Miscellaneous -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun stack-to-list (xs) - "Return XS as a list. -The round-trip property of `stack-from-list' and `stack-to-list' should hold." - (->> xs - stack-xs - list-reverse)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Predicates -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -;; TODO: Create a macro that wraps `cl-defstruct' that automatically creates -;; things like `new', `instance?'. -(defun stack-instance? (xs) - "Return t if XS is a stack." - (stack-p xs)) - -(provide 'stack) -;;; stack.el ends here diff --git a/users/wpcarro/emacs/.emacs.d/wpc/timestring.el b/users/wpcarro/emacs/.emacs.d/wpc/timestring.el deleted file mode 100644 index 245ace49e7..0000000000 --- a/users/wpcarro/emacs/.emacs.d/wpc/timestring.el +++ /dev/null @@ -1,77 +0,0 @@ -;;; timestring.el --- Quickly access timestamps in different formats -*- lexical-binding: t -*- - -;; Author: William Carroll -;; Version: 0.0.1 -;; Package-Requires: ((emacs "25.1")) - -;;; Commentary: - -;; I was making some API calls where a URL needed a `since` parameter that of an -;; RFC 3339 encoded string. -;; -;; Because I didn't know what a RFC 3339 encoded -;; string was at the time, and because I didn't know what its format was -;; according to strftime, and because I'm most likely to forget both of these -;; things by the next time that I need something similar, I decided to write -;; this package so that I can accumulate a list of common time encodings. -;; -;; Thank you, Emacs. -;; -;; p.s. - I may turn this into a proper module and publish it. But not today. - -;;; Code: - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Dependencies -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(require 'ts) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Library -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defgroup timestring nil - "Customize group for timestring configuration.") - -(defcustom timestring-supported-encodings - '(("RFC 3339" . "%Y-%m-%dT%H:%M:%SZ") - ;; Does anyone recognize this format? - ("IDK" . "%Y-%m-%d %H:%M:%S %z")) - "Mapping of encoding names to their format strings." - :group 'timestring) - -(defcustom timestring-supported-times - '(("yesterday" . timestring--yesterday) - ("now" . ts-now) - ("tomorrow" . timestring--tomorrow)) - "Mapping of a labels to the functions that create those time objects." - :group 'timestring) - -(defun timestring--yesterday () - "Return a time object for yesterday." - (ts-adjust 'day -1 (ts-now))) - -(defun timestring--tomorrow () - "Return a time object for yesterday." - (ts-adjust 'day +1 (ts-now))) - -(defun timestring--completing-read (label xs) - "Call `completing-read' with LABEL over the collection XS." - (alist-get (completing-read label xs) xs nil nil #'equal)) - -(defun timestring-copy-encoded-time () - "Select a common time and an encoding. - -The selected time will be encoded using the selected encoding and copied onto -your clipboard." - (interactive) - (let ((time (funcall (timestring--completing-read - "Time: " timestring-supported-times))) - (fmt (timestring--completing-read - "Encoding: " timestring-supported-encodings))) - (kill-new (ts-format fmt time)) - (message "Copied!"))) - -(provide 'timestring) -;;; timestring.el ends here diff --git a/users/wpcarro/emacs/.emacs.d/wpc/window.el b/users/wpcarro/emacs/.emacs.d/wpc/window.el deleted file mode 100644 index aec3c7012f..0000000000 --- a/users/wpcarro/emacs/.emacs.d/wpc/window.el +++ /dev/null @@ -1,40 +0,0 @@ -;;; window.el --- Working with windows -*- lexical-binding: t -*- - -;; Author: William Carroll -;; Version: 0.0.1 -;; Package-Requires: ((emacs "25.1")) - -;;; Commentary: -;; Utilities to make CRUDing windows in Emacs easier. - -;;; Code: - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Dependencies -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(require 'prelude) -(require 'macros) -(require 'maybe) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; Library -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun window-find (name) - "Find a window by the NAME of the buffer it's hosting." - (let ((buffer (get-buffer name))) - (if (maybe-some? buffer) - (get-buffer-window buffer) - nil))) - -;; TODO: Find a way to incorporate these into function documentation. -(macros-comment - (window-find "*scratch*")) - -(defun window-delete (window) - "Delete the WINDOW reference." - (delete-window window)) - -(provide 'window) -;;; window.el ends here -- cgit 1.4.1