Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Tree: 6784d57ea1
Fetching contributors…

Cannot retrieve contributors at this time

858 lines (808 sloc) 81.723 kB
;ELC
;;; Compiled by toups@deluge on Wed Dec 7 16:20:07 2011
;;; from file /home/toups/elisp/utils/utils.el
;;; in Emacs version 23.2.1
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(require 'cl)
#@14 A linebreak.
(defvar lb "\n" (#$ . 515))
(byte-code "\302B\303\302!\204\304\302\305\"\210\306B\303\306!\204\304\306\305\"\210\305\302\207" [current-load-list true else default-boundp set-default t otherwise] 3)
#@29 Convert a list to a vector.
(defalias 'list->vector #[(lst) "\301\302\"\207" [lst coerce vector] 3 (#$ . 741)])
#@29 Convert a vector to a list.
(defalias 'vector->list #[(vec) "\301\302\"\207" [vec coerce list] 3 (#$ . 860)])
#@56 Returns the current line from currently active buffer.
(defalias 'get-current-line-substring #[nil "\300 \301 {\207" [get-beginning-of-line get-end-of-line] 2 (#$ . 977)])
#@64 Returns true when the point is on the last line of the buffer.
(defalias 'last-line\? #[nil "\212\300 \301y\210\300 )=\207" [line-number-at-pos 1] 2 (#$ . 1155)])
#@106 Evaluates the function FUN with the point at the beginning of each line. FUN is passed the line number.
(defalias 'with-point-at-lines-start #[(fun) "\212eb\210\301 \204\302 \210\303 !\210\304y\210\202)\305\207" [fun last-line\? beginning-of-line line-number-at-pos 1 nil] 2 (#$ . 1325)])
#@39 Returns the line numbers of a region.
(defalias 'line-numbers-of-region #[(startp endp) "\305!\305\n!\306 X\203 \fB T\211\202 \f\237+\207" [startp i endp #1=#:--cl-var-- #2=#:--cl-var-- line-number-at-pos nil] 3 (#$ . 1626)])
#@60 Inclusive between-ness predicate. True if BEL <= IT <= AB
(defalias 'betweeni\? #[(it bel ab) " Y\205 \nX\207" [it bel ab] 2 (#$ . 1868)])
#@66 Returns true when the current line is in the region STARTP ENDP.
(defalias 'current-line-in-region\? #[(startp endp) "\302\303 \303!\303 !#\207" [startp endp betweeni\? line-number-at-pos] 5 (#$ . 2017)])
#@20 Comments a region.
(defalias 'comment-region-inv #[(startp endp) "\300\301!\207" [with-point-at-lines-start #[(ln) "\303 \"?\205\n\nc\207" [startp endp comment-start current-line-in-region\?] 3]] 2 (#$ . 2229) "r"])
#@22 Uncomments a region.
(defalias 'uncomment-region-inv #[(startp endp) "\300\301!\207" [with-point-at-lines-start #[(ln) "\302 \"?\205 \303\304!\207" [startp endp current-line-in-region\? kill-forward-chars 1] 3]] 2 (#$ . 2453) "r"])
#@90 Converts clojure unpaired vector binding expressions to regular let binding expressions.
(defalias 'jlet-bindings->let-bindings #[(bindings) "\304G\305\"\204\f\306\307!\207\310\311GS\n W\203-\n\234\nT\234D B\n\305\\\211\202*\312 !)\207" [bindings let-bindings i #1=#:--cl-var-- mod 2 error "jlet binding form needs an even number of items." nil 0 reverse] 4 (#$ . 2693)])
#@103 Clojure-ish let statement, (let [n1 v1 n2 v2] ...). Does not support destructuring, but see defn.el.
(defalias 'jlet '(macro . #[(bindings &rest body) "\302\303! BB\207" [bindings body let* jlet-bindings->let-bindings] 3 (#$ . 3085)]))
#@31 Short form LEXICAL-LET macro.
(defalias 'llet '(macro . #[(&rest args) "\301B\207" [args lexical-let] 2 (#$ . 3329)]))
#@47 Short form paired vector binding lexical let.
(defalias 'jllet '(macro . #[(bindings &rest body) "\302\303! BB\207" [bindings body lexical-let* jlet-bindings->let-bindings] 3 (#$ . 3455)]))
#@68 Returns true when SUB is in STR. SUB can be a regular expression.
(defalias 'in-string #[(sub str) "\303\304 #\211 \230)?\207" [sub str new-string replace-regexp-in-string ""] 5 (#$ . 3652)])
#@233 returns true if ITEM is in LST where LST might be a hash table. PRED determines equality, defaults to eq. If item and lst are strings, then returns true if item is a substring of lst.
(fn ITEM LST &optional (PRED (function eq)))
(defalias 'in #[(item lst &rest #1=#:--cl-rest--) "\203\f\211A@\202 \305\203\306\307\310\311G\\D\"\210\n;\203- ;\203-\312\n \"\202]\313 !\203=\310\n\314 ! #\202]\315 \203[\f\204[ @\n\"\203T\316\202? A\211\204C\f))\207" [#1# pred item lst found eq signal wrong-number-of-arguments in 3 in-string hash\? keyshash nil t] 5 (#$ . 3854)])
#@58 Returns the first item for which PRED is true, else nil.
(defalias 'in-list-by-pred-return #[(lst pred) "\302 \"@\207" [pred lst member-if] 3 (#$ . 4450)])
(defalias 'replace-when-equal #[(lst pred trans) "\306\211 :\203% @\f\n!\203 \n!\202\n B A\211\202 \237+\207" [lst #1=#:--cl-var-- item #2=#:--cl-var-- pred trans nil] 3])
#@276 Returns a new list with only the unique elements in LST under
PRED. When an element is found more than once in the list, it be
combined with the recorded element in a non-standard way using COMBINE.
(fn LST &optional (PRED (function eq)) (COMBINE (lambda (item acc) acc)))
(defalias 'unique #[(lst &rest #1=#:--cl-rest--) "\203\f\211A@\202 \306\203\211A@\202\307\203*\310\311\312\313G\\D\"\210\314\315!\314\316!\211 L\210 \nL\210\317\320\321\322\323\324\325 D\325\fD\326\257E\327 #!,\207" [#1# pred combine #2=#:--cl-combine-- #3=#:--cl-pred-- lst eq #[(item acc) "\207" [acc] 1] signal wrong-number-of-arguments unique 3 make-symbol "--pred--" "--combine--" reverse foldl lambda #4=(&rest --cl-rest--) apply #[(#5=#:G2978 #6=#:G2979 it seen) "\306\307!\306\310!\306\311!\211 L\210 \fL\210\312\313\314\315\316 D\316D\317\257EL\210\320 JJ\"\211\203S\321 JJ\312\313\314\322\316D\316 D\316\nD\316 D\316D\317\257E#\202X\nJ JB,\207" [#7=#:--cl-pred-prime-- #8=#:--cl-seen-- #9=#:--cl-it-- it seen #5# make-symbol "--it--" "--seen--" "--pred-prime--" lambda #4# apply #[(#10=#:G2976 #11=#:G2977 o) "J \n\"\207" [#11# it o] 3] quote --cl-rest-- in-list-by-pred-return replace-when-equal #[(#12=#:G2971 #13=#:G2972 #14=#:G2973 #15=#:G2974 #16=#:G2975 o) "J J\n\"\207" [#15# #14# o] 3] #6# r] 14] quote --cl-rest-- nil] 10 (#$ . 4800)])
#@54 Insert with string format string semantics on input.
(defalias 'insertf #[(&rest args) "\301\302\"c\207" [args apply format] 3 (#$ . 6176)])
#@51 Creates a keyword from a string, doesn't need ':'
(defalias 'make-keyword #[(name) "\301\302\303\"!\207" [name intern format ":%s"] 4 (#$ . 6324)])
#@39 Return a new symbol with value <SYM>!
(defalias 'bang #[(sym) "\301\302\303\"!\207" [sym intern format "%s!"] 4 (#$ . 6479)])
#@27 Concatenates two symbols.
(defalias 's-cat #[(sym1 sym2) "\302\303\304 #!\207" [sym1 sym2 intern format "%s-%s"] 5 (#$ . 6612)])
#@50 Returns a symbol with an appended question mark.
(defalias 'ques #[(sym) "\301\302\303\"!\207" [sym intern format "%s?"] 4 (#$ . 6748)])
#@30 Appends X to the end of LST.
(defalias 'suffix #[(lst x) "\302 C\"\207" [lst x append] 3 (#$ . 6892)])
#@201 Defines a set of functions to access a series of slots in a list by name. (defstruquine test a b c) defines test!, test?, test-a, test-b, and test-c which create, test-for and access the new struct.
(defalias 'defstruquine '(macro . #[(name &rest slots) "G\306\307\310\311 !\312\313\311 !DBBF\310\314 !\315\316\317\313\311 !DEFE\320 :\203N @\321\f\310\322 \"\323\324\325\nEFC\"\nT A\211\202+*\321\f\320C\"+\207" [slots n-fields i name out #1=#:--cl-var-- 1 progn defun bang list quote ques (item) eq (car item) nil append s-cat (item) elt item slot] 10 (#$ . 7003)]))
#@30 Inclusive between predicate.
(defalias 'between-inc #[(low high val) " Y\205 \nX\207" [val low high] 2 (#$ . 7597)])
#@34 Not inclusive between predicate.
(defalias 'between #[(low high val) " V\205 \nW\207" [val low high] 2 (#$ . 7723)])
#@84 Folds a function over list with an accumulator initialised to init. Left version.
(defalias 'foldl #[(fn init list) "\n\306 :\203 @ \f \" A\211\202* )\207" [init output list #1=#:--cl-var-- item fn nil] 4 (#$ . 7849)])
#@42 returns all but the last element of lst.
(defalias 'all-but-last #[(lst) "\301\211!A!\207" [lst reverse] 3 (#$ . 8086)])
#@75 Uses the initial element of init-and-list as the initial value for foldl.
(defalias 'foldla #[(fn init-and-list) "\306!\307!\211\310 :\203\" @\311 \f B\" A\211\202 * *\207" [init-and-list inits lst #1=#:--cl-var-- item fn last all-but-last nil apply] 6 (#$ . 8214)])
#@68 Adds up the elements of the arg list. Identical to +, apparently.
(defalias 'sum #[(&rest args) "\301\302\303#\207" [args foldl + 0] 4 (#$ . 8498)])
#@36 Calculates the mean value of args.
(defalias 'mean #[(&rest args) "\301\302\"G\245\207" [args apply sum] 3 (#$ . 8655)])
#@20 Synonym for listp.
(defalias 'list\? #[(arg) "<\207" [arg] 1 (#$ . 8784)])
#@73 collects and inserts sublists of lst, leaving other elements untouched.
(defalias 'flatten-once #[(lst) "\301\302\303#\207" [lst foldl #[(it ac) "<\203\n\302 \"\207\303 \"\207" [it ac append suffix] 3] nil] 4 (#$ . 8866)])
#@58 Recursively flattens all sublists of lst and lst itself.
(defalias 'flatten #[(lst) "\301\302\303\304#!\207" [lst reverse foldl #[(item output) "\302!\203\303\304 \305!#\207 B\207" [item output list\? foldl cons flatten] 5] nil] 5 (#$ . 9100)])
#@66 Executes body of macro after moving the point forward two lines.
(defalias 'after-this-line '(macro . #[(&rest body) "\301\302BB\207" [body progn (insert "\n\n")] 3 (#$ . 9357)]))
#@115 Combines a lexical-let form with lambda. Produces new lexical variables binding WHAT before a lambda is created.
(defalias 'enclambda '(macro . #[(what arglist &rest body) "\304\305\306#\307 \310\n BBE)\207" [what lexletarg arglist body foldl #[(cu ou) "\211D B\207" [cu ou] 2] nil lexical-let lambda] 5 (#$ . 9545)]))
#@33 Returns true for an empty list.
(defalias 'null\? #[(lst) "\301=\207" [lst nil] 2 (#$ . 9874)])
#@59 Returns true if any of lst is true. Stops at first true.
(defalias 'any #[(list) "\304 \304\n:\203\n@\206 \nA\211\202*)\207" [b list #1=#:--cl-var-- item nil] 2 (#$ . 9977)])
#@38 Returns true if all of list is true.
(defalias 'all #[(list) "\304 \305\n:\203\n@\205 \nA\211\202*)\207" [b list #1=#:--cl-var-- item t nil] 2 (#$ . 10173)])
#@39 Returns true if none of list is true.
(defalias 'none #[(list) "\301!?\207" [list any] 2 (#$ . 10351)])
#@132 Repeatedly applies f to its last result (initially f a0) until the result converges. Not numerical. Max it is optional argument.
(defalias 'fix #[(f a0 &rest args) "\306!\203\n\307\202\f@\n !\n\f!\f \232\204$ \n\f!\202 +\207" [args max-it f a0 prev current null\? 100] 2 (#$ . 10463)])
#@70 Returns a new list with neighbors bunched into sublists of length 2.
(defalias 'bunch-list #[(lst) "\302\303\304\305\211D#\211A@)!\207" [lst x reverse foldl #[(it ac) "@\211A@)\211\203\305 \fD\nBD\202\f\nD*\207" [ac x ol ls it nil] 4] nil] 6 (#$ . 10769)])
#@243 Creates or modifies a hash table.
(tbl! old-table <sym1> <val1> ... <symN> <valN>) modifies table OLD-TABLE with new entries.
(tbl! <sym1> <val1> ... <symN> <valN>) creates a new table with new entries.
Always returns the hash table.
(defalias 'tbl! #[(&rest args) "\301@!\203\302\303@\304A!#\207\302\305\306\307\310\"\304!#\207" [args hash\? foldl #[(pr tbl) "@\n\211A@)\306 #\210+\n\207" [pr #1=#:--cl-x-- tbl #2=#:--cl-h-- x #3=#:--cl-store-- puthash] 5] bunch-list #[(pr tbl) "@\n\211A@)\306 #\210+\n\207" [pr #4=#:--cl-x-- tbl #5=#:--cl-h-- x #6=#:--cl-store-- puthash] 5] cl-make-hash-table :test equal] 5 (#$ . 11044)])
#@139 Access a hash table.
(tbl <tbl> el) returns the element in table.
(tbl <tbl> el1 el2 el3) returns a list of the elements in question.
(defalias 'tbl #[(tbl &rest args) "\306\211 :\203 @\307\n\f\" B A\211\202 \237+\211G\310U\203, @\202- )\207" [args #1=#:--cl-var-- arg #2=#:--cl-var-- tbl res nil cl-gethash 1] 5 (#$ . 11708)])
(put 'tbl 'setf-method #[(&rest args) "\304\305\"\306\307! \nC \n\310\311 C\"*B\312 B\257*\207" [args --args--temp-- --store--temp-- store mapcar #[(_) "\300\301!\207" [make-symbol "--cl-var--"] 2] make-symbol "--cl-store--" tbl! append tbl] 7 "Not documented\n\n(fn &rest ARGS)"])
#@119 Like tbl, but can only do one element and returns OTHERWISE when that is nil.
(fn TBL KEY &optional (OTHERWISE nil))
(defalias 'tbl-or #[(tbl key &rest #1=#:--cl-rest--) "\211A@\203\304\305\306\307G\\D\"\210\310\n #)\207" [#1# otherwise key tbl signal wrong-number-of-arguments tbl-or 3 cl-gethash] 5 (#$ . 12351)])
#@44 Returns true of the regexp RE matches STR.
(defalias 'string-contains\? #[(str re) "\303\304 #\211 \230)?\207" [re str new replace-regexp-in-string ""] 5 (#$ . 12682)])
#@29 Return a hash table's keys.
(defalias 'keyshash #[(tbl) "\302\303\304 \"\210\305!)\207" [keys tbl nil maphash #[(k v) " B\211\207" [k keys] 2] reverse] 3 (#$ . 12859)])
#@31 Return a hash table's values.
(defalias 'valshash #[(tbl) "\301\302\303!\"\207" [tbl mapcar #[(k) "\302 \"\207" [k tbl gethash] 3] keyshash] 4 (#$ . 13038)])
#@23 True for hash tables.
(defalias 'hash\? #[(o) "\301!\207" [o hash-table-p] 2 (#$ . 13204)])
#@87 Maps a function of KEY and VAL over KEYS and VALS of the hash table. Returns a list.
(defalias 'lmaphash #[(lam tbl) "\306!\211\307\211\n:\203 \n@\310 \"\fB\nA\211\202 \f\237+\311\n #*\207" [tbl keys #1=#:--cl-var-- key #2=#:--cl-var-- vals keyshash nil gethash mapcar* lam] 5 (#$ . 13303)])
#@61 Maps a function over the hash table values, returns a list.
(defalias 'lmaphash-vals #[(lam tbl) "\302\303 !\"\207" [lam tbl mapcar valshash] 4 (#$ . 13616)])
#@96 Joins a LST of strings into a single string using delimiter DEL.
(fn LST &optional (DEL " "))
(defalias 'join #[(lst &rest #1=#:--cl-rest--) "\203\f\211A@\202 \303\203\304\305\306\307G\\D\"\210\310\311\312\n@\313\314\nA\"B#)\207" [#1# del lst " " signal wrong-number-of-arguments join 2 foldl #[(it ac) " P\207" [ac it] 2] "" mapcar #[(x) " P\207" [del x] 2]] 7 (#$ . 13782)])
#@61 Returns a list of elements of F for which (f item) is true.
(defalias 'filter #[(f lst) "\301\302\303\304#!\207" [lst reverse foldl #[(it ac) " !\203\n \nB\207\n\207" [f it ac] 2] nil] 5 (#$ . 14178)])
#@73 Perl-like chomp function to return a version of STR with no whitespace.
(defalias 'chomp #[(str) "9\203 \302!\202\f\212\303\304 \"\203) G\303\304 \"V\203)\305\306\307\310 $\202\303\311 \"\203D G\303\311 \"V\203D\305\306\307\310 $\202)) )\207" [str s symbol-name string-match "^\\( \\|\f\\| \\|\n\\)" replace-match "" t nil "\\( \\|\f\\| \\|\n\\)$"] 5 (#$ . 14389)])
#@38 Constructs the body of the on macro.
(defalias 'build-on #[(machines body) "\302\303\304\305ED\306 BE\207" [machines body if any mapcar (lambda (x) (string= system-name (format "%s" x))) progn] 5 (#$ . 14776)])
#@69 Perform an action only when system name is in the list of MACHINES.
(defalias 'on '(macro . #[(machines &rest body) "\302 \"\207" [machines body build-on] 3 (#$ . 14994)]))
#@113 Case expression where the system name is the value. Perform actions only on certain systems.
(fn &rest PAIRS)
(defalias 'place-case '(macro . #[(&rest pairs) "\305\306\307!D \310\211\n:\203C\n@\211@;\203&\306\307 @!D AB\2029 @9\2036\306 @D AB\2029\311\312!\fB\nA\211\202 \f\237+BB\207" [system-name pairs #1=#:--cl-var-- pair #2=#:--cl-var-- case quote intern nil error "place-case needs places enumerated as either strings or symbols"] 6 (#$ . 15175)]))
#@51 def a var and immediately market it buffer local.
(defalias 'defvar-buf-loc '(macro . #[(nm &optional vl do) "\303\304 \nF\305\306DDE\207" [nm vl do progn defvar make-variable-buffer-local quote] 5 (#$ . 15651)]))
#@55 def a custom and immediately declare it buffer local.
(defalias 'defcustom-buf-loc '(macro . #[(nm &optional vl do) "\303\304 \nF\305\306DDE\207" [nm vl do progn defcustom make-variable-buffer-local quote] 5 (#$ . 15873)]))
#@23 Function composition.
(defalias 'comp #[(&rest fs) "\302\303!\211\304 !L\210\305\306\307\310\311D\312FE)\207" [#1=#:--cl-rfs-- fs make-symbol "--rfs--" reverse lambda (&rest --cl-rest--) apply #[(#2=#:G2980 &rest args) "\302\303 J#@\207" [args #2# foldl #[(it ac) "\302 \"C\207" [it ac apply] 3]] 4] quote --cl-rest--] 7 (#$ . 16105)])
#@142 Sequential let form. (let (a b c) '(1 2 3) (list a b c)) -> (1 2 3).
binds variables to elements in a list.
(fn SYMBOLS LST &body BODY)
(defalias 'let-seq '(macro . #[(symbols lst &rest body) "\306\307!\310 DC\310\311\nG\n\312\f\312 \f W\203=\f:\203=\f@\211\313\fED B \fT\f\fA\202 \237-BBE)\207" [list-name lst symbols s #1=#:--cl-var-- #2=#:--cl-var-- gensym "list-" let 0 nil elt i #3=#:--cl-var-- body] 8 (#$ . 16452)]))
#@84 Binds variables to elements of a hash table.
(fn SYMBOL-KEY-PAIRS TBL &body BODY)
(defalias 'let-tbl '(macro . #[(symbol-key-pairs tbl &rest body) "\306\307!\310 DC\310\311\nG\n\312 \312\f W\203C\f:\203C\f@\211@\301 \211 A@)ED\fB\f T \fA\202\f\237-BBE)\207" [tbl-name tbl symbol-key-pairs sk #1=#:--cl-var-- #2=#:--cl-var-- gensym "table-" let 0 nil i #3=#:--cl-var-- x body] 8 (#$ . 16910)]))
#@177 Binds variables to elements of an alist table. SYMBOL-KEY-PAIRS is a list of symbols and the keys to access the alist for that symbol.
(fn SYMBOL-KEY-PAIRS ALIST &body BODY)
(defalias 'let-alist '(macro . #[(symbol-key-pairs alist &rest body) "\306\307!\310 DC\310\311\nG\n\312 \312\f W\203C\f:\203C\f@\211@\301 \211 A@)ED\fB\f T \fA\202\f\237-BBE)\207" [alist-name alist symbol-key-pairs sk #1=#:--cl-var-- #2=#:--cl-var-- gensym "table-" let 0 nil i #3=#:--cl-var-- x body] 8 (#$ . 17336)]))
#@193 Binds variables to elements of an alist table. SYMBOL-KEY-PAIRS is a list of symbols and the keys to access the alist for that symbol. Lexical scope.
(fn SYMBOL-KEY-PAIRS ALIST &body BODY)
(defalias 'llet-alist '(macro . #[(symbol-key-pairs alist &rest body) "\306\307!\310\300J DC\310\311\nG\n\312 \312\f W\203E\f:\203E\f@\211@\301\300J \211 A@)ED\fB\f T \fA\202\f\237-BBE)\207" [#1=#:--cl-alist-name-- alist symbol-key-pairs sk #2=#:--cl-var-- #3=#:--cl-var-- gensym "table-" let 0 nil i #4=#:--cl-var-- x body] 8 (#$ . 17863)]))
#@83 Binds SYMBOLS to elements of LST lexically, in BODY.
(fn SYMBOLS LST &body BODY)
(defalias 'llet-seq '(macro . #[(symbols lst &rest body) "\306\307!\310 DC\311\312\nG\n\313 \313 W\203=\f:\203=\f@\211\314 EDB T \fA\202\237-BBE)\207" [list-name lst symbols s #1=#:--cl-var-- #2=#:--cl-var-- gensym "list-" let lexical-let 0 nil elt i #3=#:--cl-var-- body] 8 (#$ . 18426)]))
#@103 Binds by SYMBOL-KEY-PAIRS with values in TBL lexically in BODY.
(fn SYMBOL-KEY-PAIRS TBL &body BODY)
(defalias 'llet-tbl '(macro . #[(symbol-key-pairs tbl &rest body) "\306\307!\310 DC\311\312\nG\n\313\f\313 \f W\203C\f:\203C\f@\211@\301 \211A@)ED B \fT\f\fA\202 \237-BBE)\207" [tbl-name tbl symbol-key-pairs sk #1=#:--cl-var-- #2=#:--cl-var-- gensym "table-" let lexical-let 0 nil i #3=#:--cl-var-- x body] 8 (#$ . 18834)]))
#@65 Returns a list of elements of the sequence SQ and indexes INDS.
(defalias 'elts #[(sq inds) "\305 G\306\nW\203\f \234\234 BT\211\202 \237+\207" [i inds #1=#:--cl-var-- #2=#:--cl-var-- sq 0 nil] 4 (#$ . 19291)])
#@90 Split a list at the first place (PRED ITEM) is true, true item goes into the first list.
(defalias 'split-list-left #[(lst pred) "\306!\204\307 \310\311!\211L\210\312\313\314\315\316\nD\317FE)\"\207\320\321 G\320\211\f W\203[ \204= \f\234C\244 \203J \f\234C\244 \f\234!\203T\322\fT\211\202+-D\207" [pred lst #1=#:--cl-p-- found i #2=#:--cl-var-- functionp split-list-left make-symbol "--p--" lambda (&rest --cl-rest--) apply #[(#3=#:G2981 x) "J =\207" [#3# x] 2] quote --cl-rest-- nil 0 t before after] 9 (#$ . 19520)])
#@91 Split a list at the first place (PRED ITEM) is true, true item goes into the second list.
(defalias 'split-list-right #[(lst pred) "\306!\204\307 \310\311!\211L\210\312\313\314\315\316\nD\317FE)\"\207\320\321 G\320\211\f W\203[ \f\234!\203:\322 \204G \f\234C\244 \203T \f\234C\244\fT\211\202+-D\207" [pred lst #1=#:--cl-p-- found i #2=#:--cl-var-- functionp split-list-right make-symbol "--p--" lambda (&rest --cl-rest--) apply #[(#3=#:G2982 x) "J =\207" [#3# x] 2] quote --cl-rest-- nil 0 t before after] 9 (#$ . 20079)])
#@74 Split a list at the first place (PRED ITEM) is true, drop the true item.
(defalias 'split-list-drop #[(lst pred) "\306!\204\307 \310\311!\211L\210\312\313\314\315\316\nD\317FE)\"\207\320\321 G\320\211\f W\203[ \f\234!\203:\322 \204G \f\234C\244 \203T \f\234C\244\fT\211\202+ \205eAD-\207" [pred lst #1=#:--cl-p-- found i #2=#:--cl-var-- functionp split-list-drop make-symbol "--p--" lambda (&rest --cl-rest--) apply #[(#3=#:G2983 x) "J =\207" [#3# x] 2] quote --cl-rest-- nil 0 t before after] 9 (#$ . 20641)])
#@27 Last element of a vector.
(defalias 'v-last #[(v) "\211GS\234\207" [v] 2 (#$ . 21192)])
#@37 Second to last element of a vector.
(defalias 'v-next-to-last #[(v) "\211G\301Z\234\207" [v 2] 3 (#$ . 21287)])
#@36 all but first element of a vector.
(defalias 'v-rest #[(v) "\304\305\306 G\307\nW\203 \234 BT\211\202\n \237+\"\207" [i v #1=#:--cl-var-- #2=#:--cl-var-- apply vector 1 nil] 5 (#$ . 21406)])
#@89 If ELT is out of range for SEQ, return OTHERWISE.
(fn SEQ N &optional (OTHERWISE nil))
(defalias 'elt-or #[(seq n &rest #1=#:--cl-rest--) "\211A@\203\304\305\306\307G\\D\"\210\n GW\203! \n\234\202\" )\207" [#1# otherwise n seq signal wrong-number-of-arguments elt-or 3] 5 (#$ . 21614)])
#@102 if any ELTS is out of range of SEQS return those OTHERWISES.
(fn SEQ NS &optional (OTHERWISES nil))
(defalias 'elts-or #[(seq ns &rest #1=#:--cl-rest--) "\211A@\203\306\307\310\311G\\D\"\210\n\312\211 :\2036 @\313\f\f\313 \f\312## B A\211\202 \237,\207" [#1# otherwises ns #2=#:--cl-var-- it #3=#:--cl-var-- signal wrong-number-of-arguments elts-or 3 nil elt-or seq] 8 (#$ . 21918)])
#@35 Don't do any of the code in here.
(defalias 'comment '(macro . #[(&rest rest) "\300\207" [nil] 1 (#$ . 22326)]))
#@28 Returns the type of a seq.
(defalias 'seq-type #[(sq) "<\203\301\207\302!\205\303\207" [sq list vectorp vector] 2 (#$ . 22445)])
#@69 Grabs the nthcdr of a seq, but converts the result to the seq type.
(defalias 'nthcdr-preserve-type #[(n sq) "\302\302 \303\"\233\304 !\"\207" [n sq coerce list seq-type] 5 (#$ . 22586)])
#@92 Append the longer part of FROM onto TO. If FROM is shorter than TO, this is the identity.
(defalias 'transplant-tail #[(to from) "\305\306 G\nG]\307 W\203\"\310\n \234#\fBT\211\202\f\f\237+\311\n!\"\207" [i from to #1=#:--cl-var-- #2=#:--cl-var-- coerce 0 nil elt-or seq-type] 7 (#$ . 22781)])
#@49 Find-file FILENAME and jump to line LINE-NUMBER
(defalias 'ff/line #[(filename line-number) "\303!\304\n!)\207" [filename buf line-number find-file goto-line] 2 (#$ . 23093)])
#@41 Find-file FILE and jump to CHAR-NUMBER.
(defalias 'ff/char #[(filename char-number) "\303!\nb)\207" [filename buf char-number find-file] 2 (#$ . 23277)])
#@32 Put a string on the kill ring.
(defalias 'put-string-on-kill-ring #[(string) " B\211G\nV\203\nS \233\304\241\210 \211\207" [string kill-ring kill-ring-max kill-ring-yank-pointer nil] 3 (#$ . 23439)])
#@88 Create the function call which jumps to this buffer and line, put it on the clipboard.
(defalias 'ff/line->clipboard #[nil "\302 \303 \304\305\306 #!*\207" [filename ln line-number-at-pos buffer-file-name put-string-on-kill-ring format "(ff/line \"%s\" %d)"] 5 (#$ . 23650) nil])
#@88 Create the function call which jumps to this buffer and char, put it on the clipboard.
(defalias 'ff/char->clipboard #[nil "`\302 \303\304\305 #!*\207" [filename pt buffer-file-name put-string-on-kill-ring format "(ff/char \"%s\" %d)"] 5 (#$ . 23939) nil])
#@90 Create the function call which jumps to this text in this file, put it on the clipboard.
(defalias 'ff/this-text->clipboard #[(s e) "\302\303\304\305 \306 \"#!\207" [s e put-string-on-kill-ring format "(ff/this-text \"%s\" \"%s\")" buffer-file-name buffer-substring-no-properties] 7 (#$ . 24205) "r"])
#@45 Jump to the text TEXT in the file FILENAME.
(defalias 'ff/this-text #[(filename txt) "r\302!q\210eb\210\303 !)\207" [filename txt find-file word-search-forward] 2 (#$ . 24514)])
#@45 Put the working directory in the kill ring.
(defalias 'pwd->kill-ring #[nil "\300\301 !\207" [put-string-on-kill-ring pwd] 2 (#$ . 24699) nil])
(byte-code "\301\211\302M\210)\301\207" [currently-defining-defn range #[(&rest G1590) "G\306 \307\"\203L\302J\310\234\302J\311\234\302J\312\234\303J\305J\304J\313W\203DB\\\211\202,\237.\202\217\306 \314\"\203p \315J\310\234\315J\311\234\210\316\317J\311\320J#+\202\217\306 \321\"\203\212\322J\310\234\316\310\311\323J#*\202\217\324\325 \326#)\207" [G1590 G1591 #:--cl-lambda-seq-as-sym1608-- #:--cl-start-- #:--cl-step-- #:--cl-upto-- arity-match (3 exactly) 0 1 2 nil (2 exactly) #:--cl-lambda-seq-as-sym1621-- range #:--cl-start-- #:--cl-upto-- (1 exactly) #:--cl-lambda-seq-as-sym1630-- #:--cl-upto-- error "Unable to find an arity match for %d args in fn %s." lambda i #:--cl-var-- #:--cl-var-- #:--cl-var-- e] 4 "Range function. (range 4) -> (0 1 2 3)\n (range 2 3) -> (2 3)\n (range 2 2 6) -> (2 4 6)"]] 3)
#@69 Simple infix macro. ($ a < b) -> (< a b).
(fn FIRST F &rest REST)
(defalias '$ '(macro . #[(first f &rest rest) " \nBB\207" [f first rest] 3 (#$ . 25742)]))
#@28 Return first element of l.
(defalias 'first #[(l) "\301\234\207" [l 0] 2 (#$ . 25908)])
#@64 Send the shell to the directory DIR. List newest files there.
(defalias 'shell-to #[(dir) "\303 \304!\305 \306\n\307Q\"\210rq\210\310\n!\210)\305 \311\"*\207" [buf pro dir shell get-buffer-process send-string "\ncd " "\n" cd "ls -t | head -n 10\n"] 5 (#$ . 26003)])
#@37 Don't do the body.
(fn &body BODY)
(defalias 'dont-do '(macro . #[(&rest body) "\300\207" [(progn nil)] 1 (#$ . 26280)]))
#@73 map the list function over the lists given, produce a list of sublists.
(defalias 'zip #[(&rest lsts) "\301\302\303B\"\207" [lsts apply mapcar* list] 4 (#$ . 26409)])
#@66 Replace the region's lisp code with the result of evaluating it.
(defalias 'evrep-region #[(start end) "\304 \"\305\306\n!!\307 \"\210\310\311 \"*\207" [start end str v buffer-substring-no-properties eval read kill-region insertf "%s"] 3 (#$ . 26583) "r"])
#@21 Exponential base e.
(defalias 'e #[(x) "\301\302\"\207" [x expt 10] 3 (#$ . 26850)])
#@45 Show buffers matching a regular expression.
(defalias 'buffers-matching #[(rx) "\300\301\302\303 \"\304\"\207" [sort filter #[(x) "\302\303 !\"\207" [rx x string-match buffer-name] 4] buffer-list #[(b1 b2) "\302!\302 !\231\207" [b1 b2 buffer-name] 3]] 4 (#$ . 26942)])
#@28 Prints buffers matching RX
(defalias 'print-buffers-matching #[(rx) "\301\302\303\304 \"\305\"\306\307\310\311\"\312\"!)\207" [bfrs sort filter #[(x) "\302\303 !\"\207" [rx x string-match buffer-name] 4] buffer-list #[(b1 b2) "\302!\302 !\231\207" [b1 b2 buffer-name] 3] print join mapcar buffer-name ","] 5 (#$ . 27219) "sEnter a Pattern:"])
#@57 Shows the buffers matching RX in newly created windows.
(defalias 'show-buffers-matching #[(rx) "\306\307\310\311 \"\312\"\313\314 @\"\210G\314 \315\n!\211 \245A\316 :\203C @\317\n\f\"\320\n!\210\313\n\"\210 A\211\202%.\316\207" [bfrs nbuf w h split-height #1=#:--cl-var-- sort filter #[(x) "\302\303 !\"\207" [rx x string-match buffer-name] 4] buffer-list #[(b1 b2) "\302!\302 !\231\207" [b1 b2 buffer-name] 3] set-window-buffer selected-window window-height nil split-window select-window buf] 5 (#$ . 27572) "sEnter a Pattern:"])
#@89 Inserts the name of the current buffer, eliding the extension if it is obviously there.
(defalias 'insert-buffer-name #[nil "\300\301\302\303 #c\207" [replace-regexp-in-string "\\..*$" "" buffer-name] 4 (#$ . 28133) nil])
(defalias 'strip-directory #[(dr) "\302\303\"\211A@)\207" [dr x split-string "Directory "] 4])
#@47 Insert the present directory into the buffer.
(defalias 'insert-pwd #[nil "\300\301 !c\207" [strip-directory pwd] 2 (#$ . 28458) nil])
#@35 Make a shell named NAME doing DO.
(defalias 'make-shell #[(name do) "\303!\304 \n\"\210 )\207" [name sh do shell comint-send-string] 3 (#$ . 28599)])
#@32 Start scheme here, in the PWD.
(defalias 'scheme-here #[nil "\300\301\302\303\"!\210\304 \207" [switch-to-buffer make-shell "scheme" "mred -z -e (current-directory (string->path \"~/\"))" inferior-scheme-mode] 4 (#$ . 28757) nil])
#@32 Prepare a string for googling.
(defalias 'goog-prep #[(str) "\301\302\303#\207" [str replace-regexp-in-string " " "+"] 4 (#$ . 28994)])
#@27 Google-search the region.
(defalias 'gs #[(start end) " {\303\304\305\n!\306Q!)\207" [start end search shell-command "chromium-browser \"http://www.google.com/search?hl=en&q=%22" goog-prep "%22&btnG=Google+Search\""] 4 (#$ . 29137) "r"])
#@80 Repeatedly bind the result of each FORM TO APPLY to NAME, in subsequent forms.
(defalias 'let-repeatedly '(macro . #[(name &rest forms-to-apply) "\302\303\304\" E\207" [forms-to-apply name let* mapcar #[(f) " D\207" [name f] 2]] 4 (#$ . 29383)]))
#@49 Bults a list of forms for LET-REPEATEDLY-UNTIL.
(defalias 'build-list-of-forms #[(name forms) "\305\211 :\203 @\306\fC\nE B A\211\202 \237+\207" [forms #1=#:--cl-var-- f #2=#:--cl-var-- name nil lambda] 4 (#$ . 29638)])
#@38 Test to see if a symbol has a value.
(defalias 'symbol-defined\? #[(symbol) "\301\211\302\303\217)\207" [return-val nil (byte-code "J\211\207" [symbol return-val] 2) ((error))] 4 (#$ . 29875)])
#@77 Like let-repeatedly, but stop once PRED is TRUE, returning last NAME value.
(defalias 'let-repeatedly-until '(macro . #[(name pred &rest forms) "\306\307!\306\310!\306\311!\312\313\314 DDDC\312\n\315\316 \f\"BDC\317\320 \321\n\322\323\324 EE\325\326\324 ED\327\330D\257 EE+\207" [state-holder f-name function-list-name name forms pred gensym "function-list-" "let-repeatedly-fun-" "let-repeatedly-state-holder-" let symbol-defined\? quote list build-list-of-forms loop for in do setq funcall while not finally return] 16 (#$ . 30078)]))
#@40 Not documented
(fn &optional (P 0.3))
(defalias 'ok-today\? #[(&rest #1=#:--cl-rest--) "\203\f\211A@\202 \302\203\303\304\305GTD\"\210\306\307\310\311 !\312\313OP!\314\245 V)\207" [#1# p 0.3 signal wrong-number-of-arguments ok-today\? read "#x" md5 calendar-iso-date-string 0 2 255.0] 5 (#$ . 30629)])
#@151 Ellision macro. FS is a single symbol representing functions to be composed before application to args.
(& cdr&car '( (a b c) (d e f))) -> (b c).
(defalias '& '(macro . #[(fs &rest args) "\306\307\"\310 \311\"\312\313\314\n\"!\211@ B\211A\315:\2037@\211 DA\211\202! .\207" [fs s ff args inside form format "%s" split-string "&" reverse mapcar intern nil #1=#:--cl-var-- f] 5 (#$ . 30949)]))
#@69 Sends multiple strings to BUF-OR-PROC, appending a newline to each.
(defalias 'comint-send-strings #[(buf-or-proc &rest rest) "\305!\203\f\306!\202 \n\307 :\203( @\310 \f\311P\"\210 A\211\202+\307\207" [buf-or-proc proc rest #1=#:--cl-var-- string bufferp get-buffer-process nil comint-send-string "\n"] 5 (#$ . 31375)])
#@121 Return all the words in the buffer by FORWARD and BACKWARD-WORD.
(fn &optional (START (point-min)) (STOP (point-max)))
(defalias 'all-words #[(&rest #1=#:--cl-rest--) "\203\f\211A@\202 e\203\211A@\202d\203*\305\306\307\310G\\D\"\210\212 b\210 \311\312v\203G\212\313v\210`)`{`\fB\2022\f\237-\207" [#1# start stop last-pos #2=#:--cl-var-- signal wrong-number-of-arguments all-words 2 nil 1 -1] 5 (#$ . 31716)])
#@71 With ido-completion, insert a word from somewhere else in the buffer.
(defalias 'insert-a-word #[nil "\300\301\302\303 \304\"\305\211$c\207" [ido-completing-read "word: " unique all-words string= nil] 5 (#$ . 32155) nil])
#@115 Insert a vertical histogram of the DATA into BINS. Mark with LABELS.
(fn BINS LABELS DATA (&OPTIONAL (max 50)))
(defalias 'vert-hist #[(bins labels data &rest #1=#:--cl-rest--) "G\306U\203\f@\202\307\310\311GD\"\211\203 \211A@\202!\312 \203/\307\310\311 GTD\"\210\313 G\314\" \315:\203\222@ \315\314:\203~@@Y\203q\211A@)W\204~AT\202O\f\fHTI\210+A\211\202=*\f+\207" [#1# #2=#:--cl-rest-- max bins counts data 1 signal wrong-number-of-arguments vert-hist 50 make-vector 0 nil #3=#:--cl-var-- point i bin #4=#:--cl-var-- x] 7 (#$ . 32384)])
#@54 Like intern, but with format semantics for the args.
(defalias 'internf #[(s &rest args) "\302\303\304 B\"!\207" [s args intern apply format] 5 (#$ . 32998)])
#@27 Inserts the current time.
(defalias 'insert-time #[nil "\300\301!c\207" [format-time-string "%Y-%m-%d-%R"] 2 (#$ . 33164) nil])
#@63 Split a string on spaces into words, trim and chomp elements.
(defalias 'word-list #[(s) "\301\302\303\304\"\"\207" [s mapcar org-trim split-string " "] 5 (#$ . 33298)])
#@36 Sorts LIST with PRED functionally.
(defalias 'functional-sort #[(list pred) "\302\303! \"\207" [list pred sort copy-sequence] 3 (#$ . 33475)])
#@43 Like pwd, but returns just the directory.
(defalias 'wd #[nil "\300\301!@\207" [sh "pwd"] 2 (#$ . 33625)])
#@22 List the files here.
(defalias 'files-wd #[(&rest rest) "\301\302\303 B\"\207" [rest apply directory-files wd] 4 (#$ . 33738)])
#@38 Access element EL in an alist ALIST.
(defalias 'alist #[(alist el) "\303 \"\211A@)\207" [el alist x assoc] 4 (#$ . 33873)])
#@45 Destructively updates EL to VALUE in ALIST.
(defalias 'alist! #[(alist el value) "\304 \"\211\203\nA \240\210\202\305 ! DC\241\210) \207" [el alist element-holder value assoc last] 4 (#$ . 34005)])
(put 'alist 'setf-method #[(&rest args) "\304\305\"\306\307! \nC \n\310\311 C\"*B\312 B\257*\207" [args --args--temp-- --store--temp-- store mapcar #[(_) "\300\301!\207" [make-symbol "--cl-var--"] 2] make-symbol "--cl-store--" alist! append alist] 7 "Not documented\n\n(fn &rest ARGS)"])
#@95 Like ALIST but returns OR-VAL if (alist lst el) is nil.
(fn ALIST EL &optional (OR-VAL nil))
(defalias 'alist-or #[(alist el &rest #1=#:--cl-rest--) "\211A@\203\306\307\310\311G\\D\"\210\312\n \"\211\203&\f\211A@)\202' *\207" [#1# or-val el alist v x signal wrong-number-of-arguments alist-or 3 assoc] 5 (#$ . 34512)])
#@42 Like ALIST but uses assq for efficiency.
(defalias 'qalist #[(alist el) " \236A\207" [el alist] 2 (#$ . 34849)])
#@72 Like QALIST but supports OR-VAL.
(fn ALIST EL &optional (OR-VAL nil))
(defalias 'qalist-or #[(alist el &rest #1=#:--cl-rest--) "\211A@\203\305\306\307\310G\\D\"\210\n \236\211\203 \f\202! *\207" [#1# or-val el alist v signal wrong-number-of-arguments qalist-or 3] 5 (#$ . 34969)])
#@49 Produces a new ALIST with only KEYS from ALIST.
(defalias 'sub-alist #[(alist keys) "\301\302\"\207" [keys mapcar #[(key) "\301 \"D\207" [key alist] 4]] 3 (#$ . 35267)])
#@85 Gets a value from a nested set of alist using a sequence of keys. Returns the val.
(defalias 'alist-in #[(root keys) "\302\303 #\207" [root keys foldl #[(it ac) "\302 \"\207" [ac it alist] 3]] 4 (#$ . 35446)])
#@97 Sets a value from a nested set of alists using a list of keys. Returns new alist. Functional.
(defalias 'alist>>-in #[(root keys val) "G\303U\203 \304@ \"\207\304\n@\305\306\n@\"A ##\207" [keys val root 1 alist>> alist>>-in alist] 7 (#$ . 35665)])
#@63 Replaces a deeply nested alist value with the value (FUN VAL)
(defalias 'alist>>-in-conjugate #[(root keys fun) "\304 \"\305 \n!#)\207" [root keys val fun alist-in alist>>-in] 5 (#$ . 35927)])
#@135 Returns a new alist where the value of key is now (fun (alist alst key)). Accepts an
optional OR-VAL if the key is not in the alist.
(defalias 'alist-conjugate #[(alst key fun &optional or-val) "\305 \n#\306 \f !#)\207" [alst key or-val val fun alist-or alist>>] 5 (#$ . 36131)])
#@89 Access an alist with PRED for key equality.
(fn PRED ALIST KEY &optional (OR-VAL nil))
(defalias 'pred-alist #[(pred alist key &rest #1=#:--cl-rest--) "\211A@\203\306\307\310\311G\\D\"\210\312\313\314!\211 L\210\315\316\317\320\321\nD\322FE)\f\"@@\211\2035 \2026 *\207" [#1# or-val #2=#:--cl-pred-- pred alist val signal wrong-number-of-arguments pred-alist 4 member-if make-symbol "--pred--" lambda (&rest --cl-rest--) apply #[(#3=#:G2984 item) "J \n\"\207" [#3# item key] 3] quote --cl-rest--] 8 (#$ . 36421)])
#@115 Conjugate a value in an alist with PRED as the key equality test.
(fn PRED ALIST KEY FUN &optional (OR-VAL nil))
(defalias 'pred-alist-conjugate #[(pred alist key fun &rest #1=#:--cl-rest--) "\211A@\203\306\307\310\311G\\D\"\210\312\n \f $\313\n \f\f !$*\207" [#1# or-val pred alist key item signal wrong-number-of-arguments pred-alist-conjugate 5 pred-alist pred-alist>> fun] 6 (#$ . 36954)])
#@113 Cons the element VALUE onto the list at KEY in ALST. If key is not there, obviously this creates a list there.
(defalias 'alist-cons #[(alst key value) "\304 \305\306!\211 L\210\307\310\311\312\313\nD\314FE)#\207" [alst key #1=#:--cl-value-- value alist-conjugate make-symbol "--value--" lambda (&rest --cl-rest--) apply #[(#2=#:G2985 xxx) "J B\207" [#2# xxx] 2] quote --cl-rest--] 10 (#$ . 37365)])
#@69 Filter the list at KEY using the filter-function FILTER-FUN in ALST
(defalias 'alist-filter #[(alst key filter-fun) "\304 \305\306!\211 L\210\307\310\311\312\313\nD\314FE)#\207" [alst key #1=#:--cl-fun-- filter-fun alist-conjugate make-symbol "--fun--" lambda (&rest --cl-rest--) apply #[(#2=#:G2986 list) "\302J \"\207" [#2# list filter] 3] quote --cl-rest--] 10 (#$ . 37775)])
#@142 Remove OBJECTS from the list at KEY in ALST with optional PRED for equality testing.
(fn ALST KEY OBJECT &optional (PRED (function equal)))
(defalias 'alist-remove-from-list #[(alst key object &rest #1=#:--cl-rest--) "\203\f\211A@\202 \306\203\307\310\311\312G\\D\"\210\313\n \314\315!\314\316!\211 L\210\fL\210\317\320\321\322\323\fD\323 D\324\257E*#)\207" [#1# pred alst key #2=#:--cl-o-- #3=#:--cl-p-- equal signal wrong-number-of-arguments alist-remove-from-list 4 alist-filter make-symbol "--p--" "--o--" lambda (&rest --cl-rest--) apply #[(#4=#:G2987 #5=#:G2988 thing) " J\n\"?\207" [pred #4# thing] 3] quote --cl-rest-- object] 11 (#$ . 38164)])
#@173 Adds the VALUE to the set held at KEY in ALST. Optionally specify PRED
to control set equality. Defaults to EQUAL.
(fn ALST KEY VALUE &optional (PRED (function equal)))
(defalias 'alist-add-to-set #[(alst key value &rest #1=#:--cl-rest--) "\203\f\211A@\202 \306\203\307\310\311\312G\\D\"\210\313\n \314\315!\211 L\210\316\317\320\321\322\fD\323FE)#)\207" [#1# pred alst key #2=#:--cl-value-- value equal signal wrong-number-of-arguments alist-add-to-set 4 alist-conjugate make-symbol "--value--" lambda (&rest --cl-rest--) apply #[(#3=#:G2989 xxx) "\303J \n#\204J B\207 \207" [#3# xxx pred in] 4] quote --cl-rest--] 10 (#$ . 38841)])
#@178 Removes the VALUE to the set held at KEY in ALST. Optionalally specify
PRED to control set equality. Defaults to EQUAL.
(fn ALST KEY VALUE &optional (PRED (function equal)))
(defalias 'alist-remove-from-set #[(alst key value &rest #1=#:--cl-rest--) "\203\f\211A@\202 \306\203\307\310\311\312G\\D\"\210\313\n \314\315!\211 L\210\316\317\320\321\322\fD\323FE)#)\207" [#1# pred alst key #2=#:--cl-value-- value equal signal wrong-number-of-arguments alist-remove-from-set 4 alist-conjugate make-symbol "--value--" lambda #3=(&rest --cl-rest--) apply #[(#4=#:G2991 xxx) "\302\303\304\305\306\307D\310FE \"\207" [#4# xxx filter lambda #3# apply #[(#5=#:G2990 item) " \nJ\"?\207" [pred item #5#] 3] quote --cl-rest--] 7] quote --cl-rest--] 10 (#$ . 39500)])
#@88 Remove entries with key KEYS from the ALIST using the predicate PRED for key equality.
(defalias 'pred-dissoc #[(pred alist &rest keys) "\303\304\305!\211 L\210\306\307\310\311\312D\313FE)\n\"\207" [#1=#:--cl-pred-- pred alist filter make-symbol "--pred--" lambda (&rest --cl-rest--) apply #[(#2=#:G2992 alist-item) "\303@ \nJ#?\207" [alist-item keys #2# in] 4] quote --cl-rest--] 8 (#$ . 40274)])
#@155 Create an ALIST or add to one the pairs KV-PAIRS using the key equality predicate PRED.
(fn PRED &optional (ALIST :---alist-sentinal---) &rest KV-PAIRS)
(defalias 'pred-alist>> #[(pred &rest kv-pairs) "\203\f\211A@\202 \305\211<\203@\306\307!\310\311!\211 L\210\312\313\314\315\316\nD\317FE)\"\320\321\"\314\322 \f$\323 \"+\202H\314\324 \325 B$)\207" [kv-pairs alist #1=#:--cl-pred-- pred keys :---alist-sentinal--- unique bunch-list make-symbol "--pred--" lambda (&rest --cl-rest--) apply #[(#2=#:G2993 a b) "J @\n@\"\207" [#2# a b] 3] quote --cl-rest-- mapcar car pred-dissoc append pred-alist>> nil] 10 (#$ . 40682)])
#@35 Returns a new ALIST without KEYS.
(defalias 'dissoc #[(alist &rest keys) "\306! \307\211\n:\2031\n@\211<\203 @\202 \310 \")\204* \fB\nA\211\202 \f\237,\207" [keys alist #1=#:--cl-var-- element #2=#:--cl-var-- alist-el-key flatten nil in] 4 (#$ . 41328)])
#@60 Returns a new ALIST without KEYS. Use EQUAL for equality.
(defalias 'dissoc-equal #[(alist &rest keys) "\306! \307\211\n:\2032\n@\211<\203 @\202 \310 \311#)\204+ \fB\nA\211\202 \f\237,\207" [keys alist #1=#:--cl-var-- element #2=#:--cl-var-- alist-el-key flatten nil in equal] 5 (#$ . 41606)])
#@202 Create or functionally modifies an ALIST.
(alist>> alist [key val]...) adds key vals to the alist.
(alist>> [key val]...) returns a new alist with keys and vals.
(fn &optional ALIST &rest REST)
(defalias 'alist>> #[(&optional alist &rest rest) "\305=\203 \305=\203\305\207<\203 \305=\203\207<\2042 \305=\2042\306\307\305\310\311 B!!#\207<\205V \305=?\205V\311 !\312\313\n\"\314 \"\306\307\f\310\311 !!#+\207" [alist rest pairs symbols dalist nil foldl cons reverse bunch-list mapcar car dissoc] 7 (#$ . 41925)])
#@237 Create or functionally modifies an ALIST.
(alist>> alist [key val]...) adds key vals to the alist.
(alist>> [key val]...) returns a new alist with keys and vals. Use EQUAL for redundancy checking.
(fn &optional ALIST &rest REST)
(defalias 'alist-equal>> #[(&optional alist &rest rest) "\305\232\203 \305\232\203\305\207<\203 \305\232\203\207<\2042 \305\232\2042\306\307\305\310\311 B!!#\207<\205V \305\232?\205V\311 !\312\313\n\"\314 \"\306\307\f\310\311 !!#+\207" [alist rest pairs symbols dalist nil foldl cons reverse bunch-list mapcar car dissoc-equal] 7 (#$ . 42473)])
#@22 Just the alist-keys.
(defalias 'alist-keys #[(alist) "\301\302\"\207" [alist mapcar car] 3 (#$ . 43082)])
#@53 Apply a fun to a and b before testing for equality.
(defalias 'eq-commute '(macro . #[(fun a b) "\303\304 E\304\nEE\207" [fun a b eq funcall] 5 (#$ . 43195)]))
#@67 Comppose the functions which result from applying fun to a and b.
(defalias 'bool-commute '(macro . #[(comp fun a b) "\304 \nE\304 EE\207" [comp fun a b funcall] 5 (#$ . 43363)]))
#@37 Grab the last sexp from this point.
(defalias 'get-last-sexp #[nil "\300\212\301\302!\210`)`{!\207" [read backward-sexp 1] 3 (#$ . 43551)])
#@47 Eval the last sexp but macro-expand it first.
(defalias 'macroexpand-eval-last-sexp #[nil "\300\301\302\303 !!!\207" [print eval macroexpand-all get-last-sexp] 4 (#$ . 43697) nil])
(global-set-key [C-ce] 'macroexpand-eval-last-sexp)
#@34 Get the field names of an alist.
(defalias 'alist-fields #[(alist) "\301\302\"\207" [alist mapcar car] 3 (#$ . 43936)])
#@55 Predicate to detect if a part of a alist matches key.
(defalias 'alist-inp #[(list-element key) "<\203\n@ \232\207 \232\207" [list-element key] 2 (#$ . 44063)])
#@65 Reduce the application of pred to the elements of lst with AND.
(defalias 'and-over #[(pred lst) "\301\302\303#\207" [lst foldl #[(it ac) " !\205\n\207" [pred it ac] 2] t] 4 (#$ . 44234)])
#@64 Reduce the application of pred to the elements of lst with OR.
(defalias 'or-over #[(pred lst) "\301\302\303#\207" [lst foldl #[(it ac) " !\206\n\207" [pred it ac] 2] nil] 4 (#$ . 44433)])
#@60 Return a random-enough arrangement of the elements in LST.
(defalias 'permute-list #[(lst) "\301\302!\303\"\207" [lst sort* copy-list #[(a b) "\300 \300 W\207" [random] 2]] 3 (#$ . 44632)])
#@61 Returns the current line of the current buffer as a string.
(defalias 'buffer-line #[nil "\300\301 \302 \"\207" [buffer-substring-no-properties get-beginning-of-line get-end-of-line] 3 (#$ . 44829)])
#@46 Returns all the lines in a buffer as a list.
(defalias 'buffer-all-lines #[nil "\212eb\210\301\302 B\303y\304U\204\237*\207" [#1=#:--cl-var-- nil buffer-line 1 0] 2 (#$ . 45035)])
#@49 Split an org-mode-table line in STR int a list.
(defalias 'org-line->list #[(str) "\301\302\303\304\"\"\207" [str mapcar chomp split-string "|"] 5 (#$ . 45227)])
#@84 Apply the list of functions to ARGS and return a list of Results. Bizzaro mapcar.
(defalias 'cleave #[(list-of-funs args) "<\203 \202 C \305\211\n:\203(\n@\306 \"\fB\nA\211\202\f\237,\207" [args list-of-funs #1=#:--cl-var-- f #2=#:--cl-var-- nil apply] 4 (#$ . 45396)])
#@103 Execute a shell command and return the output as a list of strings.
(fn COMMAND &optional (ARGS ""))
(defalias 'capture-shell #[(command &rest #1=#:--cl-rest--) "\203\f\211A@\202 \306\203\307\310\311\312G\\D\"\210\313\n\314\"@\315 \306\n# P\316\313\317\320!r\fq\210\321\216\322 \323\324p!\323 %\210\325 \210ed{+ \"!+\207" [#1# args command command-part #2=#:temp-buffer lb "" signal wrong-number-of-arguments capture-shell 2 split-string " " replace-regexp-in-string chomp-lines generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#2# buffer-name kill-buffer] 2)) call-process-shell-command nil buffer-name accept-process-output] 8 (#$ . 45690)])
#@124 sh command args - Send a command to the shell, get back the result as a list of strings.
(fn COMMAND &optional (ARGS ""))
(defalias 'sh #[(command &rest #1=#:--cl-rest--) "\203\f\211A@\202 \303\203\304\305\306\307G\\D\"\210\310\n \")\207" [#1# args command "" signal wrong-number-of-arguments sh 2 capture-shell] 5 (#$ . 46383)])
#@41 Short form of lambda for the very lazy.
(defalias 'la '(macro . #[(args &rest body) "\302 BB\207" [args body lambda] 3 (#$ . 46730)]))
#@38 rxq is a shorthand for regexp-quote.
(defalias 'rxq #[(string) "\301!\207" [string regexp-quote] 2 (#$ . 46872)])
#@55 reprxstr is a shorthand for replace-regexp-in-string.
(defalias 'reprxstr #[(rx rep str &optional fixedcase literal subexp start) "\306 \n \f &\207" [rx rep str fixedcase literal subexp replace-regexp-in-string start] 8 (#$ . 46993)])
#@32 Uncapitalize a word in string.
(defalias 'uncapitalize #[(s) "\303\304O\304GO\211\227 P*\207" [s rest first 0 1] 5 (#$ . 47238)])
#@96 Remove the first element if it matches pred and/or remove the last element if it matches pred.
(defalias 'remove-first-or-last-if #[(lst pred) " @!\203\f A\202 \302 !@!\203\303 \304\"\202 )\207" [pred lst last butlast 1] 4 (#$ . 47379)])
#@174 removes leading and trailing spaces from lines, removes empty lines entirely if they are leading or trailing.
(fn LST &optional (PRED (lambda (x) (string= "" (chomp x)))))
(defalias 'chomp-lines #[(lst &rest #1=#:--cl-rest--) "\203\f\211A@\202 \303\203\304\305\306\307G\\D\"\210\310\311\n\")\207" [#1# pred lst #[(x) "\301!\302\230\207" [x chomp ""] 2] signal wrong-number-of-arguments chomp-lines 2 fix #[(x) "\302 \"\207" [x pred remove-first-or-last-if] 3]] 5 (#$ . 47634)])
#@67 Takes a lisp-style-symbol in the current region and camelCasesIt.
(defalias 'region->camelcase #[(start end) " {\304\305\306\307\310\n\311\312!\"\"\313\"!\314 \"\210 c*\207" [start end reg rep uncapitalize join mapcar #[(x) "\301!\207" [x capitalize] 2] split-string rxq "_" "" kill-region] 8 (#$ . 48131) "r"])
#@34 Convert lisp-style to camelCase.
(defalias 'camel-case #[(string) "\302\303\304!\"\211@\305\306 A\"B\307 \310\"*\207" [string parts split-string rxq "-" mapcar capitalize join ""] 5 (#$ . 48454)])
#@34 Converts a keyowrd to camelCase.
(defalias 'camel-case-kw #[(kw) "\302\303\"\304\305\306 \307 GO!P!)\207" [kw s format "%s" intern ":" camel-case 1] 6 (#$ . 48660)])
#@67 Change the working directory to whatever the shell is working on.
(defalias 'cd-shell #[nil "\300r\301q\210\302 )!\207" [cd "*shell*" wd] 2 (#$ . 48834)])
#@69 Execute BODY with a temporary working directory.
(fn D &body BODY)
(defalias 'with-wd '(macro . #[(d &rest body) "\303\304!\305\306BC\307 D\310\311\nB\307DEF)\207" [current-directory d body gensym "current-directory-" let ((wd)) cd prog1 progn] 7 (#$ . 48995)]))
#@79 Execute body in the working directory of the *shell* buffer.
(fn &body BODY)
(defalias 'with-shell-directory '(macro . #[(&rest body) "\301\302BB\207" [body with-wd (with-current-buffer "*shell*" (wd))] 3 (#$ . 49268)]))
#@52 Move the *shell* to the current working directory.
(defalias 'shell-to-here #[nil "\300\301\302!\303\304 P\"\207" [comint-send-strings get-buffer "*shell*" "cd " wd] 4 (#$ . 49497) nil])
#@62 Concat strings then run the result through FORMAT with REST.
(defalias 'concatf #[(strings &rest rest) "\302\303\302\304\" #\207" [strings rest apply format concat] 5 (#$ . 49690)])
#@47 Filter a list by the indexes of the elements.
(defalias 'filter-by-index #[(pred list) "\306\307\306 :\203# @ !\203\n\fB A T\202\f\237,\207" [list index item #1=#:--cl-var-- #2=#:--cl-var-- pred nil 0] 3 (#$ . 49879)])
#@51 Just return the odd-indexed elements of the list.
(defalias 'odd-indexed-elements #[(list) "\301\302\"\207" [list filter-by-index oddp] 3 (#$ . 50119)])
#@52 Just return the even-indexed elements of the list.
(defalias 'even-indexed-elements #[(list) "\301\302\"\207" [list filter-by-index evenp] 3 (#$ . 50279)])
(defalias 'none-nil #[(lst) "\301\302\"\207" [lst and-over identity] 3])
#@116 Map TRANSFORM across elements in LISTS keeping only those for which FILTER-FUN is true on the output of TRANSFORM.
(defalias 'map&filter #[(filter-fun transform &rest lists) "\306\307\n!\203-\310\311\n\"\310\312\n\"\313 \" \f !\203) B+\202\314 !*\207" [lists output rests els new-rests transform nil none-nil mapcar car cdr apply reverse val filter-fun] 3 (#$ . 50517)])
#@85 Map TRANSFORM across ELEMENTS in LISTS only for those for which FILTER-FUN is true.
(defalias 'filter&map #[(filter-fun transform &rest lists) "\306\307\n!\203-\310\311\n\"\310\312\n\"\313 \" \f \203)\313 \" B+\202\314 !*\207" [lists output rests els new-rests filter-fun nil none-nil mapcar car cdr apply reverse check transform] 3 (#$ . 50912)])
#@67 factor a number n by recourse to the command line utility FACTOR.
(defalias 'factor #[(n) "\301\302\303\304\305\306\307\"\"@\310\311#A\"\207" [n mapcar read split-string capture-shell "factor" format "%d" " " t] 8 (#$ . 51282)])
#@39 Get from anything that is table-like.
(defalias 'table-like-get #[(tbl-like kw) "\303!\203 \304 \"\207<\205 \236\211A@)\207" [tbl-like kw x hash-table-p tbl] 4 (#$ . 51518)])
#@97 Get from anything that is table-like or return OR-VAL.
(fn TBL-LIKE KW &optional (OR-VAL nil))
(defalias 'table-like-get-or #[(tbl-like kw &rest #1=#:--cl-rest--) "\211A@\203\305\306\307\310G\\D\"\210\311\n!\203\"\312\n #\2029\n<\2059\313 \n\314\315$\211\2037\f@\2028 ))\207" [#1# or-val tbl-like kw v signal wrong-number-of-arguments table-like-get-or 3 hash-table-p tbl-or assoc-default eq nil] 6 (#$ . 51707)])
#@38 Print something before returning it.
(defalias 'print-and-return #[(x) "\301!\210\207" [x cl-prettyprint] 2 (#$ . 52142)])
#@45 Return a function which always returns val.
(defalias 'always '(macro . #[(val) "\303\304!\303\305!\306 \nDC\307\310D EE*\207" [r s val gensym "always-" "rest-" lexical-let lambda &rest] 5 (#$ . 52273)]))
#@76 Replace the current region with s, putting the old value in the kill ring.
(defalias 'cut-region-replace #[(s) "\301`\302 \"\210c\207" [s kill-region mark] 3 (#$ . 52487) "s"])
#@74 Create a lambda with lexically bound arguments.
(fn ARGLIST &body BODY)
(defalias 'lex-lambda '(macro . #[(arglist &rest body) "\304\305\"\306\307 \"\310\311\n BBE*\207" [arglist actual-args lex-forms body filter #[(x) "\301\302\"\211\303\230?\205\304\230?)\207" [x format "%s" "&rest" "&optional"] 4] mapcar #[(x) "\211D\207" [x] 2] lambda lexical-let] 5 (#$ . 52671)]))(if macro-declaration-function (funcall macro-declaration-function (quote lex-defun) (quote (declare (indent defun)))))
#@85 Define a function with lexically bound arguments.
(fn NAME ARGLIST DOC &body BODY)
(defalias 'lex-defun '(macro . #[(name arglist doc &rest body) "\306\307\"\310\311 \" ;\203\312\f \313\n BB\257\202(\312\f\313\n BBBF*\207" [arglist actual-args lex-forms doc name body filter #[(x) "\301\302\"\211\303\230?\205\304\230?)\207" [x format "%s" "&rest" "&optional"] 4] mapcar #[(x) "\211D\207" [x] 2] defun lexical-let] 7 (#$ . 53179)]))
#@146 Return the elements from LST matching INDEXES. For convenience END and END+ are bound locally to (length lst) -1 and (length lst) respectively.
(defalias 'ix: '(macro . #[(lst indexes) "\303\304!\305 D\306\307\310D\311BBD\312\310DDE\313\nEE)\207" [lst-sym lst indexes gensym "ix-lst" let* end - length (1) end+ elts] 6 (#$ . 53636)]))
#@59 Send command to a shell, but string has format semantics.
(defalias 'shf #[(command-string &rest args) "\302\303\304 #!\207" [command-string args sh apply format] 5 (#$ . 53983)])
#@48 Like print, but with format semantics on args.
(defalias 'printf #[(&rest args) "\301\302\303\"!\207" [args print apply format] 4 (#$ . 54170)])
#@34 Get the next word from a buffer.
(defalias 'buffer-next-word #[nil "`\302v\303 `{!*\207" [q s 1 chomp] 3 (#$ . 54322)])
#@22 Double quote string.
(defvar double-quote "\"" (#$ . 54450))
#@31 Quote a string for the shell.
(defalias 'shell-quote #[(x) " Q\207" [double-quote x] 3 (#$ . 54517)])
#@44 Puts escape characters in front of quotes.
(defalias 'escapce-spaces #[(s) "\301\302\303#\207" [s replace-regexp-in-string " " "\\\\ "] 4 (#$ . 54627)])
#@39 Convert anything to a string using %s
(defalias 'as-string #[(item) "\301\302\"\207" [item format "%s"] 3 (#$ . 54787)])
#@39 Convert anything to a string using %S
(defalias 'as-string-readable #[(item) "\301\302\"\207" [item format "%S"] 3 (#$ . 54915)])
#@54 Like concat, but first converts all args to strings.
(defalias 'concat* #[(&rest args) "\301\302\303\304\"\"\207" [args apply concat mapcar as-string] 5 (#$ . 55052)])
#@40 Convert all elements of LST to strings
(defalias 'list-of-strings #[(lst) "<\205 \301\302\303\"!\207" [lst all mapcar stringp] 4 (#$ . 55227)])
#@47 Get point corresponding to beginning of line.
(defalias 'line-min #[nil "\212\300 \210`)\207" [beginning-of-line] 1 (#$ . 55380)])
#@41 Get point corresponding to end of line.
(defalias 'line-max #[nil "\212\300\210`)\207" [nil] 1 (#$ . 55517)])
#@31 Case macro for string values.
(defalias 'string-case '(macro . #[(expr &rest cases) "\303\304!\305 DC\306\307\310\n\"BE)\207" [expr-sym expr cases gensym "string-case-sym-" let cond mapcar #[(x) "@\303 !\203 \202 CA\304\305\306 \"B\n+B\207" [x case-list expr list-of-strings or mapcar #[(s) "\302 E\207" [expr-sym s string=] 3]] 4]] 6 (#$ . 55634)]))
#@37 Get the current line in the buffer.
(defalias 'buffer-subline #[nil "\300 \301 {\207" [line-min line-max] 2 (#$ . 56003)])
#@56 Get the current line in the buffer without properties.
(defalias 'buffer-subline-no-properties #[nil "\300\301 \302 \"\207" [buffer-substring-no-properties line-min line-max] 3 (#$ . 56132)])
#@58 Return a function which is the composition of not and f.
(defalias 'not-f #[(f) "\302\303!\211 L\210\304\305\306\307\310D\311FE)\207" [#1=#:--cl-f-- f make-symbol "--f--" lambda (&rest --cl-rest--) apply #[(#2=#:G2994 &rest args) "\302J \"?\207" [#2# args apply] 3] quote --cl-rest--] 7 (#$ . 56330)])
#@30 True if length of X is zero.
(defalias 'empty\? #[(x) "G\301U\207" [x 0] 2 (#$ . 56641)])
#@86 Macro composition of with-current-buffer and save-excursion.
(fn BUFFER &body BODY)
(defalias 'with-current-buffer/save-excursion '(macro . #[(buffer &rest body) "\302\303 BE\207" [buffer body with-current-buffer save-excursion] 4 (#$ . 56738)]))
#@20 Composes not and f
(defalias 'f-not #[(f) "\302\303!\211 L\210\304\305\306\307\310D\311FE)\207" [#1=#:--cl-lf-- f make-symbol "--lf--" lambda (&rest --cl-rest--) apply #[(#2=#:G2995 &rest args) "\303\nJ\301J\")?\207" [args #3=#:--cl-largs-- #2# apply] 3] quote --cl-rest--] 7 (#$ . 56993)])
#@49 Returns a function which pulls KW from a table.
(defalias 'f-kw #[(kw) "\302\303!\211 L\210\304\305\306\307\310D\311FE)\207" [#1=#:--cl-lkw-- kw make-symbol "--lkw--" lambda (&rest --cl-rest--) apply #[(#2=#:G2996 tbl) "\302 J\"\207" [tbl #2# table-like-get-or] 3] quote --cl-rest--] 7 (#$ . 57294)])
#@32 Replace STR with REP in INPUT.
(defalias 'replace-string-in-string #[(str rep input) "\303\304! \n#\207" [str rep input replace-regexp-in-string rxq] 4 (#$ . 57604)])
#@281 A let form with built-in error checks following the usual binding forms.
(let ((sym val error-predicate error-message)
(sym1 val2 ...))
BODY)
Error predicate and error-message are optional.
Example:
(let ((x 10 #'numberp "x must be a number"))
(+ x 11))
(defalias 'let-with-errors '(macro . #[(bind/conditions &rest body) "\302\303\304\" BB\207" [bind/conditions body let mapcar #[(bind/condition) "9\203\210G\211\306U\204 \307U\204\310\311!\210 \306U\203$\202p \307U\205p@\211A@)\211AA)@\312\234\313\314!\313\315!\313\316!\211\317 D\fD DE\320\321\f E \310\322 EDFE.D)\207" [bind/condition n x m-temp f-temp temp 2 4 error "let-with-errors needs binding forms with 2 or 4 parts <symbol> <value> <predicate> <error>." 3 gensym "bind-condition-temp-" "bind-condition-temp-fun" "bind-condition-temp-message" let if funcall format message predicate val-expr sym] 11]] 4 (#$ . 57779)]))
#@282 A let* form with built-in error checks following the usual binding forms.
(let ((sym val error-predicate error-message)
(sym1 val2 ...))
BODY)
Error predicate and error-message are optional.
Example:
(let ((x 10 #'numberp "x must be a number"))
(+ x 11))
(defalias 'let-with-errors* '(macro . #[(bind/conditions &rest body) "\302\303\304\" BB\207" [bind/conditions body let* mapcar #[(bind/condition) "9\203\210G\211\306U\204 \307U\204\310\311!\210 \306U\203$\202p \307U\205p@\211A@)\211AA)@\312\234\313\314!\313\315!\313\316!\211\317 D\fD DE\320\321\f E \310\322 EDFE.D)\207" [bind/condition n x m-temp f-temp temp 2 4 error "let-with-errors needs binding forms with 2 or 4 parts <symbol> <value> <predicate> <error>." 3 gensym "bind-condition-temp-" "bind-condition-temp-fun" "bind-condition-temp-message" let if funcall format message predicate val-expr sym] 11]] 4 (#$ . 58734)]))
#@90 Combines mapcar and lambda. List is passed first so that the body can end the function.
(defalias 'mapcar-lambda '(macro . #[(lst args &rest body) "\303\304 BB\nE\207" [args body lst mapcar lambda] 4 (#$ . 59691)]))
(defalias 'length=1 #[(lst) "G\301U\207" [lst 1] 2])
(defalias 'length=0 #[(lst) "G\301U\207" [lst 0] 2])
(defalias 'length-is #[(lst n) "G U\207" [lst n] 2])
(defalias 'length=1or0 #[(lst) "\301!\206 \302!\207" [lst length=1 length=0] 2])
(defalias 'length=0or1 #[(lst) "\301!\206 \302!\207" [lst length=1 length=0] 2])
(defalias 'is-&rest #[(object) "9\205\301=\207" [object &rest] 2])
(defalias 'is-&optional #[(object) "9\205\301=\207" [object &optional] 2])
#@104 Breaks a list on predicate. Returns list of sublists. Each time pred is true, a new list is started.
(defalias 'break-list-on #[(pred lst) "\301\302\303\304#!\207" [lst reverse foldl #[(item output) "@A \f!\203\305\306\n! BB\202\f\nB B*\207" [output other current pred item nil reverse] 3] nil] 5 (#$ . 60396)])
#@63 Returns true for arg list separators like &rest and &optional
(defalias 'is-arg-list-sep #[(ob) "9\205\301!\206\302!\207" [ob is-&optional is-&rest] 2 (#$ . 60725)])
#@49 Parses an arg list into an alist for use later.
(defalias 'create-arg-alist #[(args) "\303\304\"\305\306\"\307\310 B\n\"*\207" [args seps parts filter #[(x) "\301!\206 \302!\207" [x is-&rest is-&optional] 2] break-list-on is-arg-list-sep zip regular] 3 (#$ . 60904)])
#@53 Make sure that optional does not occur before rest.
(defalias 'optional-before-rest\? #[(arglist) "\301\235G\302\235GW\206\302\235G\303U\206\301\235G\303U\207" [arglist &rest &optional 0] 3 (#$ . 61185)])
#@39 Check an arglist and return an alist.
(defalias 'check-and-return-arg-alist #[(args) "\302!\204 \303\304\305D\"\210\306!\307\310 \311\"!\204$\303\304\312\310 \311\"D\"\210 )\207" [args arg-alist optional-before-rest\? signal cl-assertion-failed (optional-before-rest\? args) create-arg-alist length=0or1 alist &rest (length=0or1 (alist arg-alist '&rest))] 6 (#$ . 61404)])
#@67 Grab the first element of a list or just return the thing itself.
(defalias 'car-if-list-else-id #[(item) "<\203@\207\207" [item] 1 (#$ . 61789)])
#@69 Rebuild an arglist from an arglist with error checking annotations.
(defalias 'reconstitute-standard-arg-list #[(arg-alist) "\301\302\303!!\304!\305!#\207" [arg-alist append reverse reconstitute-regular-args reconstitute-optional-args reconstitute-rest-args] 5 (#$ . 61947)])
#@76 Execute an if-statement with NAME bound to the result of PRED in BRANCHES.
(defalias 'let-if '(macro . #[(name pred true-branch &optional false-branch) "\304 DC\305\n FE\207" [name pred true-branch false-branch let if] 6 (#$ . 62232)]))
#@73 Rebuild the regular part of an arglist from the annotated parsed alist.
(defalias 'reconstitute-regular-args #[(arg-alist) "\302\303\"\211\205 \304\305 \")\207" [arg-alist regulars alist regular mapcar car-if-list-else-id] 4 (#$ . 62477)])
#@74 Rebuild the optional part of an arglist from the annotated parsed alist.
(defalias 'reconstitute-optional-args #[(arg-list) "\302\303\"\211\205\303\304\305 \"B)\207" [arg-list optionals alist &optional mapcar car-if-list-else-id] 5 (#$ . 62726)])
#@70 Rebuild the rest part of an arglist from the annotated parsed alist.
(defalias 'reconstitute-rest-args #[(arg-list) "\302\303\"\211\205\303\304\305 \"B)\207" [arg-list rests alist &rest mapcar car-if-list-else-id] 5 (#$ . 62983)])
#@58 Build the error checking statements for a defun-checked.
(defalias 'generate-error-checking-statements #[(arg-alist) "\301\302!\303!\304!#\207" [arg-alist append generate-error-checking-statements-regular generate-error-checking-statements-optional generate-error-checking-statements-rest] 5 (#$ . 63224)])
#@58 Generate the regular argument error checking statements.
(defalias 'generate-error-checking-statements-regular #[(arg-list) "\301\302\303\304\305\306\"!#\207" [arg-list foldl #[(it ac) "9\203 \207@\211A@)\211AA)@\211\204\306\f\2049\307\310!\211\311L\210\312\313\314\315\316D\317FE)\320\321\322\f\nED\323\324\325 E\nEE +B\207" [it ac sym x error-check-expr report-string "" make-symbol "--always-2997--" t lambda (&rest --cl-rest--) apply #[(#1=#:G2999 &rest #2=#:rest-2998) "J\207" [#1#] 1] quote --cl-rest-- if not funcall error concat (format "%s: " *defun-checked-name-lex*) #3=#:--cl-always-2997--] 7] nil reverse alist regular] 7 (#$ . 63540)])
#@59 Generate the optional argument error checking statements.
(defalias 'generate-error-checking-statements-optional #[(arg-list) "\301\302\303\304\305\306\"!#\207" [arg-list foldl #[(it ac) "9\203 \207@\306\234\307\234\211\204\310 \2040\311\312!\211\313L\210\314\315\316\317\320 D\321FE)\322\323\324 \nED\325\326\327\fE\nEE +B\207" [it ac sym error-check-expr report-string #1=#:--cl-always-3000-- 2 3 "" make-symbol "--always-3000--" t lambda (&rest --cl-rest--) apply #[(#2=#:G3002 &rest #3=#:rest-3001) "J\207" [#2#] 1] quote --cl-rest-- if not funcall error concat (format "%s: " *defun-checked-name-lex*)] 7] nil reverse alist &optional] 7 (#$ . 64218)])
#@58 Generate the rest part of the error checking statements.
(defalias 'generate-error-checking-statements-rest #[(arg-list) "\306\307\"@\2119?\205\223 @\310\311! \211A@) \211AA)@\312 !\203=\313\314\315 \nED\316\317\320E\nEEC\202\222 \321\322\321:\203\216@\211@\211A@)\313\314\315\323 EED\316\317\324\325\326\nFFDE*BAT\202I\237,,)\207" [arg-list rest-expr rest-name predicate-name x predicate-expression alist &rest gensym "defun-checked-rest-predicate-" functionp if not funcall error concat (format "%s: " *defun-checked-name-lex*) nil 0 elt (format "%s: " *defun-checked-name-lex*) format "%s(%d)" possible-error-string i sub-pred-expr #1=#:--cl-var-- #2=#:--cl-var-- error-str predexpr] 12 (#$ . 64898)])
(byte-code "\301\211\207" [*defun-checked-name-lex* nil] 2)
#@70 Like defun but provides argument-list level error checking features.
(defalias 'defun-checked '(macro . #[(name args &rest body) "\306\307\310\"!\204\311\312\313\307\310\"D\"\210\306\307\314\"!\204&\311\312\315\307\314\"D\"\210\316!\317 !\320 !\321\322\323\fDDC\324\f\n\325 \"BBBE+\207" [args arg-alist standard-arg-list error-checks name body length=1or0 filter is-&rest signal cl-assertion-failed (length=1or0 (filter #'is-&rest args)) is-&optional (length=1or0 (filter #'is-&optional args)) check-and-return-arg-alist reconstitute-standard-arg-list generate-error-checking-statements lexical-let *defun-checked-name-lex* quote defun* append] 8 (#$ . 65729)]))
#@24 Show the current time.
(defalias 'show-current-time #[nil "\300\301 !\207" [print current-time-string] 2 (#$ . 66410) nil])
#@44 Hooks to execute when a buffer is entered.
(defvar *after-select-window-hooks* nil (#$ . 66540))
(byte-code "\300\301\302\303\304$\210\305\301!\207" [ad-add-advice select-window (select-window-hooks nil t (advice lambda nil (loop for hook in *after-select-window-hooks* do (funcall hook)))) after nil ad-activate] 5)
#@91 Execute body with a temp file, write to it, and return the name and the resutl in a list.
(defalias 'with-write-temp-file '(macro . #[(&rest body) "\303\304!\303\305!\306 \307B\310 DDD\311\312\311\313\314\nB E\315BBE\316DEE*\207" [buffer-name file-name-name body gensym "file-name-" "buffer-" let* ((make-temp-file (format "%s" (gensym)))) find-file-noselect prog1 with-current-buffer list progn ((save-buffer)) kill-buffer] 9 (#$ . 66863)]))
#@24 Not numerically equal.
(defalias '!= #[(a b) " U?\207" [a b] 2 (#$ . 67317)])
#@44 Return all the lines in a buffer as alist.
(defalias 'buffer-list-of-lines #[(&optional buffer) "r\203 \202\npq\210\212eb\210\302\303 B\304y\305U\204 \237+\207" [buffer #1=#:--cl-var-- nil buffer-subline-no-properties 1 0] 2 (#$ . 67402)])
#@23 Launch nautilus here.
(defalias 'nautilus-here #[nil "\300\301\302 \"\207" [shf "nautilus %s &" wd] 3 (#$ . 67657)])
#@27 Launch nautilus wherever.
(defalias 'nautilus #[(s) "\301\302\"\207" [s shf "nautilus %s &"] 3 (#$ . 67780) "D"])
#@156 The unfold combinator. Call GEN repeatedly on its result (starting with init) and collect the results of F on that value until PRED on that value is nil.
(defalias 'unfold #[(pred f gen init) "\305 \n!\203 \n!B\f\n!\202)\207" [output pred init f gen nil] 2 (#$ . 67902)])
#@176 The unfold combinator. Call GEN repeatedly on its result (starting with init) and collect the results of F on that value until PRED all previous values of F on value is nil.
(defalias 'unfold-mem #[(pred f gen init) "\305\306 \"\203\n !B\f !\202)\207" [output pred f init gen nil apply] 3 (#$ . 68191)])
#@18 The constant pi.
(defconst pi 3.14159265 (#$ . 68512))
#@18 The golden ratio
(defconst phi 1.61803399 (#$ . 68573))
#@49 Like gensym with format semantics on arguments.
(defalias 'gensymf #[(&rest args) "\301\302\303\"!\207" [args gensym apply format] 4 (#$ . 68635)])
#@71 resize the text on screen for work monitor.
(fn &optional (VAL 100))
(defalias 'for-work-monitor #[(&rest #1=#:--cl-rest--) "\203\f\211A@\202 \302\203\303\304\305GTD\"\210\306\307\310\311 $)\207" [#1# val 100 signal wrong-number-of-arguments for-work-monitor set-face-attribute default nil :height] 5 (#$ . 68790) nil])
#@12 Is N zero?
(defalias 'zero\? #[(n) "\301U\207" [n 0] 2 (#$ . 69127)])
#@16 Is n positive?
(defalias 'positive\? #[(n) "\301!?\205\f\302!U\207" [n zero\? abs] 2 (#$ . 69204)])
#@16 Is n negative?
(defalias 'negative\? #[(n) "\301!?\205 \302!?\207" [n zero\? positive\?] 2 (#$ . 69314)])
#@40 Convert a keyword to a regular symbol.
(defalias 'keyword->symbol #[(kw) "\301\302\303\"\304\305O!\207" [kw intern format "%s" 1 nil] 4 (#$ . 69429)])
#@58 Convert a symbol to a keyword with the same name after :
(defalias 'symbol->keyword #[(sym) "\301\302\303\"!\207" [sym make-keyword format "%s"] 4 (#$ . 69587)])
(defalias 'with-gensyms-symbol #[(item) "<\2049\204\301\302!\207<\203$@\2119\204!\301\302!\202\")\207\207" [item error "with-gensyms requires a list of symbol names or symbol/prefix pairs."] 3])
(defalias 'with-gensyms-prefix #[(item) "<\2049\204\302\303!\207<\203<G\304U\203<\211A@)\211;\20469\2046<\2046\302\303!\202:\305\306\")\207\305\306\307!\"\207" [item x error "with-gensyms requires a list of symbol names or symbol/prefix pairs." 2 format "%s" with-gensyms-symbol] 5])
#@247 Performs BODY with the symbols specified in SYMBOL-EXPRESSIONS dynamically scoped in.
SYMBOL-EXPRESSIONS is a list of either symbols or symbol/prefix pairs. Each prefix should evaluate
to a string or symbol.
(fn SYMBOL-EXPRESSIONS &body BODY)
(defalias 'with-gensyms '(macro . #[(symbol-expressions &rest body) "<\204 \304\305!\210\306\307\"\306\310\"\311\312\n\306\313 \"\" *BB\207" [symbol-expressions prefixes symbols body error "symbols must be a list." mapcar with-gensyms-symbol with-gensyms-prefix let zip #[(prefix) "\301D\207" [prefix gensym] 2]] 6 (#$ . 70271)]))
#@196 Returns a sequence of type COERCE-TO with N ITEM's in it, each passed through COPY-BY,
which is the identity, by default.
(fn N ITEM &key (COERCE-TO (quote list)) (COPY-BY (function identity)))
(defalias 'n-of #[(n item &rest #1=#:--cl-rest--) "\306>\206\307A@\310>\206\311A@ \203@ @\312>\203) AA\211\202\313>A@\2037\314\211\202\315\316 @\"\210\202)\317\320 \314\fW\203a\n!B\fT\211\202K\237+ \"*\207" [#1# coerce-to copy-by #2=#:--cl-keys-- i n :coerce-to (nil list) :copy-by (nil identity) (:coerce-to :copy-by :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:coerce-to :copy-by)" coerce 0 #3=#:--cl-var-- #4=#:--cl-var-- item] 5 (#$ . 70862)])
#@36 Print the form FORM and its VALUE.
(defalias 'db-print '(macro . #[(form) "\301\302\303\304DFD\207" [form print format "%S - %S" quote] 5 (#$ . 71587)]))
#@35 return the second element of SEQ.
(defalias 'second #[(s) "\301\234\207" [s 1] 2 (#$ . 71749)])
#@16 Alias for NOT.
(defalias 'nil\? #[(s) "?\207" [s] 1 (#$ . 71852)])
#@84 Ignores the body, but you can go inside and execute the examples.
(fn &body BODY)
(defalias 'example '(macro . #[(&rest body) "\300\207" [nil] 1 (#$ . 71926)]))
#@47 Map F across LST and concatenate the results.
(defalias 'mapcat #[(f lst) "\305\211 :\203 @\306\f\n!! \244 A\211\202 \237+\207" [lst #1=#:--cl-var-- x #2=#:--cl-var-- f nil reverse] 4 (#$ . 72094)])
#@74 Indicate that the body should be evaluated at both compile and run time.
(defalias 'eval-when-compile-also '(macro . #[(&rest rest) "\301\302B\301BE\207" [rest progn eval-when-compile] 4 (#$ . 72310)]))
#@56 True if o is a pair, that is, exactly a non-null list.
(defalias 'pair\? #[(o) "\203<\207\207" [o] 1 (#$ . 72521)])
#@27 Lambda, then byte-compile
(defalias 'lambdac '(macro . #[(args &rest body) "\302\303 BBD\207" [args body byte-compile lambda] 4 (#$ . 72648)]))
#@74 Place ITEM at the end of LIST as its CDR. Returns a new, improper list.
(defalias 'improper-suffix #[(list item) "\304!\211A\211G\305U\204\nA\211\202\n \241\210 *\207" [list cp cp-cdr item copy-list 1] 4 (#$ . 72799)])
#@71 Apply f to the CDR of CELL, return (CONS (CAR CELL) (FUNCALL F CDR)).
(defalias 'dip-cdr #[(f cell) "@ A!B\207" [cell f] 3 (#$ . 73033)])
#@78 Apply f to the CAR of CELL, return (CONS (FUNCALL F (CAR CELL)) (CDR CELL)).
(defalias 'dip-car #[(f cell) "@ AB\207" [cell] 2 (#$ . 73179)])
#@98 Take f and return a new function which operates on the CDR of a cons cell, returning a new cons.
(defalias 'f-dip-cdr #[(f) "\302\303!\211 L\210\304\305\306\307\310D\311FE)\207" [#1=#:--cl-f-- f make-symbol "--f--" lambda (&rest --cl-rest--) apply #[(#2=#:G3003 &rest cell) "\302J \"\207" [#2# cell dip-cdr] 3] quote --cl-rest--] 7 (#$ . 73329)])
#@98 Take f and return a new function which operates on the CAR of a cons cell, returning a new cons.
(defalias 'f-dip-car #[(f) "\302\303!\211 L\210\304\305\306\307\310D\311FE)\207" [#1=#:--cl-f-- f make-symbol "--f--" lambda (&rest --cl-rest--) apply #[(#2=#:G3004 &rest cell) "\302J \"\207" [#2# cell dip-car] 3] quote --cl-rest--] 7 (#$ . 73685)])
#@70 Converts a number of seconds to a list of HOURS MINUTES and SECONDS.
(defalias 'hours-minutes-seconds #[(seconds) "\304W\203 \305\211E\207\306W\203#\307\304\245! \304_Z\305 \nE*\207\307\306\245! \306_Z \310\n!A*B\207" [seconds minutes rem hours 60 0 3600 floor hours-minutes-seconds] 3 (#$ . 74041)])
#@120 Pulls out the seconds in a time difference and returns the
result. Only works if the difference would fit in 16 bits.
(defalias 'small-time-diff #[(t1 t2) "\303 \"\211A@)\207" [t1 t2 x time-subtract] 4 (#$ . 74362)])
#@76 Execute BODY, returning the result in a VALUES list with the elapsed time.
(defalias 'tick-tock '(macro . #[(&rest body) "\303\304!\303\305!\306 \307B\310\nBDD\311\312\313\314 EDEE*\207" [result tick body gensym "tick" "result" let ((current-time)) progn values hours-minutes-seconds small-time-diff (current-time)] 8 (#$ . 74588)]))
#@34 Returns true if LENGTH LST is N.
(defalias 'length= #[(lst n) "G U\207" [lst n] 2 (#$ . 74932)])
#@43 Returns true if the LENGTH of LST is > N.
(defalias 'length> #[(lst n) "G V\207" [lst n] 2 (#$ . 75036)])
#@43 Returns true if the LENGTH of LST is < N.
(defalias 'length< #[(lst n) "G W\207" [lst n] 2 (#$ . 75149)])
#@44 Returns true if the LENGTH of LST is <= N.
(defalias 'length<= #[(lst n) "G X\207" [lst n] 2 (#$ . 75262)])
#@44 Returns true if the LENGTH of LST is >= N.
(defalias 'length>= #[(lst n) "G Y\207" [lst n] 2 (#$ . 75377)])
#@47 Not documented
(fn HEAD &optional (BODY ""))
(defalias 'notify-send #[(head &rest #1=#:--cl-rest--) "\203\f\211A@\202 \303\203\304\305\306\307G\\D\"\210\310\311\n #)\207" [#1# body head "" signal wrong-number-of-arguments notify-send 2 shf "notify-send \"%s\" \"%s\""] 5 (#$ . 75492)])
#@47 Not documented
(fn HEAD &optional (BODY ""))
(defalias 'notify-send&message #[(head &rest #1=#:--cl-rest--) "\203\f\211A@\202 \303\203\304\305\306\307G\\D\"\210\310\n \"\210\311\n\312 Q!)\207" [#1# body head "" signal wrong-number-of-arguments notify-send&message 2 notify-send message "\n"] 5 (#$ . 75795)])
(byte-code "\301\211\207" [*pom-timer* nil] 2)
(defalias 'pom-start #[nil "\302\303!\210\304\305\306\307#\304\310\306\311\312!\211L\210\313\314\315\316\317 D\320FE)#\207" [*pom-timer* #1=#:--cl-my-timer-- notify-send&message "Pom: Start work on task NOW." run-with-timer 1500 nil #[nil "\301\302!\210\303\304\305\306#\211\207" [*pom-timer* notify-send&message "Pom: Take a break!" run-with-timer 300 nil #[nil "\300\301!\210\302 \207" [notify-send&message "Pom: Break over" pom-start] 2]] 4] 750.0 make-symbol "--my-timer--" lambda (&rest --cl-rest--) apply #[(#2=#:G3005) " J\232\205 \302\303\304\305\"!\207" [*pom-timer* #2# notify-send&message format "Pom: %d minutes left." 12.5] 4] quote --cl-rest--] 10 nil nil])
(defalias 'pom-stop #[nil "\203\301!\210\302\211\207" [*pom-timer* cancel-timer nil] 2 nil nil])
(defalias 'get-pom-timer-time #[nil "\205\301\302\"\207" [*pom-timer* elts (1 2 3)] 3])
(defalias 'hours-minutes-seconds->string #[(hms) "\211\305\234 \306\234 \307\234\310\311\f \n$,\207" [hms #1=#:list-3006 s m h 0 1 2 format "%d hours %d minutes and %d seconds"] 6])
(defalias 'time-till-next-pom-event #[nil "\302 \303\304\305 \"!\211\205 \306\307 !!\210*\207" [pmtm res get-pom-timer-time hours-minutes-seconds small-time-diff current-time print hours-minutes-seconds->string] 5 nil nil])
#@34 CONS with its arguments swapped.
(defalias 'swons #[(lst el) " B\207" [el lst] 2 (#$ . 77457)])
(defalias 'insert-recent-file-buttons-list #[(n) "\306\307!\211\211GS G\310 \311\312\fG^\"\"+\313 :\203H @\314\315\316\317!\211L\210\320\321\322\323\324D\325FE)#\210 A\211\202+\313\207" [files #1=#:ix-lst3007 end end+ n #2=#:--cl-var-- sh "ls -t" elts range 0 nil insert-button action make-symbol "--file--" lambda (&rest --cl-rest--) apply #[(#3=#:G3008 b) "\301J!\207" [#3# find-file] 2] quote --cl-rest-- file #4=#:--cl-file--] 11])
(defalias 'remove-linebreaks-but-preserve-double-lines #[(s e) "\303 {! }\210\304\305\306!\n\307 %\210ed\304\305\310!\311\307 %\210\304\n\305\306!\307 %\210*~)\207" [s e sigil md5 replace-string format "\n\n" t "\n" " "] 6 nil "r"])
(defalias 'region->markdown->clipboard #[(s e) "p\305\306!r q\210\307\216prq\210\310 \f\311\n$\210)\312ed\"-\207" [buf #1=#:temp-buffer tmp-buffer s e generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) shell-command-on-region "markdown" kill-region] 5 nil "r"])
(defalias 'buffer->markdown->clipboard #[nil "\212\300ed\")\207" [region->markdown->clipboard] 3 nil nil])
#@22 Exclusive or helper.
(defalias 'xor2 #[(a b) "\203 ?\207 \207" [a b] 1 (#$ . 78692)])
#@15 Exclusive or.
(defalias 'xor #[(&rest args) "\301\302\"\207" [args reduce xor2] 3 (#$ . 78787)])
#@41 String equality test, case insensitive.
(defalias 'stringi= #[(s1 s2) "\226 \226\230\207" [s1 s2] 2 (#$ . 78891)])
#@73 Create a lexical closure over the vars VARS and execute body within it.
(defalias 'enclose '(macro . #[(vars &rest body) "\302\303\304\" BB\207" [vars body lexical-let mapcar #[(var) "\211D\207" [var] 2]] 4 (#$ . 79013)]))
(defalias 'split-after-n #[(lst n) "\306\307\n \307 \203;\307 \310U\204\311 !\203$\312\f! D\2027 \2057\306 A S @\fB\307\202\n+*\207" [recur-loop-return-value-86014 recur-loop-sentinal-86013 lst n torso tail t nil 0 empty\? reverse otherwise] 5])
#@55 Reverse the lists in the keys of an association list.
(defalias 'reverse-alist-keys #[(alst) "\301\302\"\207" [alst mapcar #[(pr) "@\302\211A@)!D\207" [pr x reverse] 4]] 3 (#$ . 79510)])
#@184 Map FUN over LST. FUN returns a list of two items, the first
of which is a key the second of which is a value. The VALUES are
accumulated at the KEYS in an ALIST which is returned.
(defalias 'mapcar/deal #[(fun lst) "\306\307\307\n \203?\307\310\n!\203\311 !\202;\f\n@!\211@ \211\fA@) \306\312   #\nA+\307\202**\207" [#1=#:recur-loop-return-value-3010 #2=#:recur-loop-sentinal-3009 lst a fun result t nil empty\? reverse-alist-keys alist-cons key x val] 6 (#$ . 79708)])
#@151 Return a list of two functions, the first of which assigns a unique label to
each input it receives. The second function resets the labeling scheme.
(defalias 'make-labeler* #[nil "\301\302!\211\303 L\210\304\305\306\307\310D\311FE\304\305\306\312\310D\311FE)D\207" [#1=#:--cl-tbl-- make-symbol "--tbl--" tbl! lambda (&rest --cl-rest--) apply #[(#2=#:G3029 item) "\304J \"\211\203\n\202\305J!G\306J #\210 ))\207" [#2# item r n tbl keyshash tbl!] 5] quote --cl-rest-- #[(#3=#:G3030) "\301 L\207" [#3# tbl!] 2]] 8 (#$ . 80211)])
#@71 Return a function which uniquely labels (with an integer) each input.
(defalias 'make-labeler #[nil "\300 @\207" [make-labeler*] 1 (#$ . 80759)])
#@101 Provide a lexical context within which LABEL unique labels its
input and RESET resets the labeling.
(defalias 'with-labeler '(macro . #[(&rest body) "\302\303!\304\305BC\306\307\310\311\312D\313BBE\314\315\311\316DDED BBE)\207" [r-list_ body gensym "r-list_" lexical-let ((make-labeler*)) labels label (x) funcall car (x) reset nil cadr] 9 (#$ . 80912)]))
#@45 Return the contents of `file-name` as text.
(defalias 'file->string #[(file-name) "\302!r q\210\303ed\")\304 !\210)\207" [file-name buf find-file-noselect buffer-substring-no-properties kill-buffer] 3 (#$ . 81278)])
#@71 Return t is path is a directory or a symlink pointing to a directory.
(defalias 'directoryp #[(path) "\302!@\211;\203\303 !\202 )\207" [path first-attr file-attributes directoryp] 3 (#$ . 81502)])
(provide 'utils)
Jump to Line
Something went wrong with that request. Please try again.