mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-21 e75a20334813452c6912c090d70a0de2c805f94d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
;ELC
;;; Compiled
;;; in Emacs version 26.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.
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
(byte-code "\300\301!\210\302\303\304\305\306\307\310\311\310\312\310\313\314\315\316\317&\210\320\321\322\323\324DD\325\326\327\316\303&\207" [require cl-lib custom-declare-group anaphora nil "Anaphoric macros providing implicit temp variables" :version "1.0.4" :link (emacs-commentary-link :tag "Commentary" "anaphora") (url-link :tag "GitHub" "http://github.com/rolandwalker/anaphora") (url-link :tag "EmacsWiki" "http://emacswiki.org/emacs/Anaphora") :prefix "anaphora-" :group extensions custom-declare-variable anaphora-use-long-names-only funcall function #[0 "\300\207" [nil] 1] "Use only long names such as `anaphoric-if' instead of traditional `aif'." :type boolean] 16)
#@35 Fontify keywords `it' and `self'.
(defalias 'anaphora-install-font-lock-keywords #[0 "\300\301\302\303BC\304#\207" [font-lock-add-keywords emacs-lisp-mode "\\<\\(it\\|self\\)\\>" (1 font-lock-variable-name-face) append] 4 (#$ . 1091)])
#@133 Install traditional short aliases for anaphoric macros.
 
With negative numeric ARG, remove traditional aliases.
 
(fn &optional ARG)
(defalias 'anaphora--install-traditional-aliases #[256 "\300\247\203H\301W\203H\211\211\205C\211@\3021+\303\304\305@\"!K\303\304\306@\"!=0\202/\210\202<\203<\307\310\304\305@\"!!\210A\266\202\202 \262\202|\211\211\205z\211@\211@\310\304\305\"!\310\304\306\"!\311\"\210\312\313\313N#\210\312\314A#\266A\266\202\202I\262\207" [((if . t) (prog1 . t) (prog2 . t) (when . when) (while . t) (and . t) (cond . cond) (lambda . lambda) (block . block) (case . case) (ecase . ecase) (typecase . typecase) (etypecase . etypecase) (let . let) (+ . t) (- . t) (* . t) (/ . t)) 0 (error) intern-soft format "a%s" "anaphoric-%s" fmakunbound intern defalias put lisp-indent-function edebug-form-spec] 12 (#$ . 1334)])
(byte-code "\204\301 \210\301\207" [anaphora-use-long-names-only anaphora--install-traditional-aliases] 1)
#@205 Like `if', but the result of evaluating COND is bound to `it'.
 
The variable `it' is available within THEN and ELSE.
 
COND, THEN, and ELSE are otherwise as documented for `if'.
 
(fn COND THEN &rest ELSE)
(defalias 'anaphoric-if '(macro . #[642 "\300\301DC\302\301BBBE\207" [let it if] 9 (#$ . 2315)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-if edebug-form-spec t function-put lisp-indent-function 2] 4)
#@193 Like `prog1', but the result of evaluating FIRST is bound to `it'.
 
The variable `it' is available within BODY.
 
FIRST and BODY are otherwise as documented for `prog1'.
 
(fn FIRST &rest BODY)
(defalias 'anaphoric-prog1 '(macro . #[385 "\300\301DC\302B\303BBB\207" [let it progn (it)] 6 (#$ . 2764)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-prog1 edebug-form-spec t function-put lisp-indent-function 1] 4)
#@207 Like `prog2', but the result of evaluating FORM2 is bound to `it'.
 
The variable `it' is available within BODY.
 
FORM1, FORM2, and BODY are otherwise as documented for `prog2'.
 
(fn FORM1 FORM2 &rest BODY)
(defalias 'anaphoric-prog2 '(macro . #[642 "\300\301\302DC\300B\303BBBE\207" [progn let it (it)] 9 (#$ . 3214)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-prog2 edebug-form-spec t function-put lisp-indent-function 2] 4)
#@188 Like `when', but the result of evaluating COND is bound to `it'.
 
The variable `it' is available within BODY.
 
COND and BODY are otherwise as documented for `when'.
 
(fn COND &rest BODY)
(defalias 'anaphoric-when '(macro . #[385 "\300\301BE\207" [anaphoric-if progn] 6 (#$ . 3684)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-when edebug-form-spec when function-put lisp-indent-function 1] 4)
#@190 Like `while', but the result of evaluating TEST is bound to `it'.
 
The variable `it' is available within BODY.
 
TEST and BODY are otherwise as documented for `while'.
 
(fn TEST &rest BODY)
(defalias 'anaphoric-while '(macro . #[385 "\300\301\211EC\302BBB\207" [do it ((not it))] 6 (#$ . 4119)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-while edebug-form-spec t function-put lisp-indent-function 1] 4)
#@347 Like `and', but the result of the previous condition is bound to `it'.
 
The variable `it' is available within all CONDITIONS after the
initial one.
 
CONDITIONS are otherwise as documented for `and'.
 
Note that some implementations of this macro bind only the first
condition to `it', rather than each successive condition.
 
(fn &rest CONDITIONS)
(defalias 'anaphoric-and '(macro . #[128 "\211\204\300\207\211A\204\211@\207\301@\302ABE\207" [t anaphoric-if anaphoric-and] 5 (#$ . 4564)]))
(put 'anaphoric-and 'edebug-form-spec t)
#@207 Like `cond', but the result of each condition is bound to `it'.
 
The variable `it' is available within the remainder of each of CLAUSES.
 
CLAUSES are otherwise as documented for `cond'.
 
(fn &rest CLAUSES)
(defalias 'anaphoric-cond '(macro . #[128 "\211\205/\211@\300 \301@DC\302\302\303\304ADD\301\305    DC\nABBF\306ABFE\266\202\207" [gensym let if null quote it anaphoric-cond] 13 (#$ . 5106)]))
(put 'anaphoric-cond 'edebug-form-spec 'cond)
#@143 Like `lambda', but the function may refer to itself as `self'.
 
ARGS and BODY are otherwise as documented for `lambda'.
 
(fn ARGS &rest BODY)
(defalias 'anaphoric-lambda '(macro . #[385 "\300\301BBC\302BB\207" [cl-labels self (#'self)] 6 (#$ . 5567)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-lambda edebug-form-spec lambda function-put lisp-indent-function defun] 4)
#@240 Like `block', but the result of the previous expression is bound to `it'.
 
The variable `it' is available within all expressions of BODY
except the initial one.
 
NAME and BODY are otherwise as documented for `block'.
 
(fn NAME &rest BODY)
(defalias 'anaphoric-block '(macro . #[385 "\300\301C\211\302\303\304\305\306!\307\"\310\311%\240\210\211\242\262!E\207" [cl-block nil make-byte-code 257 "\211G\211\301\267\202\302\202@\202\303\304@DC\300\242A!E\207" vconcat vector [#s(hash-table size 2 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (0 8 1 12)) nil let it] 6 "\n\n(fn BODY)"] 12 (#$ . 5979)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-block edebug-form-spec block function-put lisp-indent-function 1] 4)
#@197 Like `case', but the result of evaluating EXPR is bound to `it'.
 
The variable `it' is available within CLAUSES.
 
EXPR and CLAUSES are otherwise as documented for `case'.
 
(fn EXPR &rest CLAUSES)
(defalias 'anaphoric-case '(macro . #[385 "\300\301DC\302\301BBE\207" [let it cl-case] 7 (#$ . 6763)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-case edebug-form-spec case function-put lisp-indent-function 1] 4)
#@199 Like `ecase', but the result of evaluating EXPR is bound to `it'.
 
The variable `it' is available within CLAUSES.
 
EXPR and CLAUSES are otherwise as documented for `ecase'.
 
(fn EXPR &rest CLAUSES)
(defalias 'anaphoric-ecase '(macro . #[385 "\300\301DC\302\301BBE\207" [let it cl-ecase] 7 (#$ . 7214)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-ecase edebug-form-spec ecase function-put lisp-indent-function 1] 4)
#@205 Like `typecase', but the result of evaluating EXPR is bound to `it'.
 
The variable `it' is available within CLAUSES.
 
EXPR and CLAUSES are otherwise as documented for `typecase'.
 
(fn EXPR &rest CLAUSES)
(defalias 'anaphoric-typecase '(macro . #[385 "\300\301DC\302\301BBE\207" [let it cl-typecase] 7 (#$ . 7671)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-typecase edebug-form-spec typecase function-put lisp-indent-function 1] 4)
#@203 Like `etypecase', but result of evaluating EXPR is bound to `it'.
 
The variable `it' is available within CLAUSES.
 
EXPR and CLAUSES are otherwise as documented for `etypecase'.
 
(fn EXPR &rest CLAUSES)
(defalias 'anaphoric-etypecase '(macro . #[385 "\300\301DC\302\301BBE\207" [let it cl-etypecase] 7 (#$ . 8146)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-etypecase edebug-form-spec etypecase function-put lisp-indent-function 1] 4)
#@141 Like `let', but the result of evaluating FORM is bound to `it'.
 
FORM and BODY are otherwise as documented for `let'.
 
(fn FORM &rest BODY)
(defalias 'anaphoric-let '(macro . #[385 "\300\301DC\302BE\207" [let it progn] 6 (#$ . 8623)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put anaphoric-let edebug-form-spec let function-put lisp-indent-function 1] 4)
#@248 Like `+', but the result of evaluating the previous expression is bound to `it'.
 
The variable `it' is available within all expressions after the
initial one.
 
NUMBERS-OR-MARKERS are otherwise as documented for `+'.
 
(fn &rest NUMBERS-OR-MARKERS)
(defalias 'anaphoric-+ '(macro . #[128 "\211\204\300\207\301\302@DC\303\302\304ABEE\207" [0 let it + anaphoric-+] 7 (#$ . 9008)]))
(put 'anaphoric-+ 'edebug-form-spec t)
#@296 Like `-', but the result of evaluating the previous expression is bound to `it'.
 
The variable `it' is available within all expressions after the
initial one.
 
NUMBER-OR-MARKER and NUMBERS-OR-MARKERS are otherwise as
documented for `-'.
 
(fn &optional NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS)
(defalias 'anaphoric-- '(macro . #[384 "\204\300\207\211\204\301D\207\302\303@DC\301\304\303\305ABEEE\207" [0 - let it + anaphoric-+] 10 (#$ . 9436)]))
(put 'anaphoric-- 'edebug-form-spec t)
#@248 Like `*', but the result of evaluating the previous expression is bound to `it'.
 
The variable `it' is available within all expressions after the
initial one.
 
NUMBERS-OR-MARKERS are otherwise as documented for `*'.
 
(fn &rest NUMBERS-OR-MARKERS)
(defalias 'anaphoric-* '(macro . #[128 "\211\204\300\207\301\302@DC\303\302\304ABEE\207" [1 let it * anaphoric-*] 7 (#$ . 9939)]))
(put 'anaphoric-* 'edebug-form-spec t)
#@267 Like `/', but the result of evaluating the previous divisor is bound to `it'.
 
The variable `it' is available within all expressions after the
first divisor.
 
DIVIDEND, DIVISOR, and DIVISORS are otherwise as documented for `/'.
 
(fn DIVIDEND DIVISOR &rest DIVISORS)
(defalias 'anaphoric-/ '(macro . #[642 "\211\204    \300E\207\301\302DC\300\303\302\304BEEE\207" [/ let it * anaphoric-*] 11 (#$ . 10367)]))
(byte-code "\300\301\302\303#\210\304\305!\207" [put anaphoric-/ edebug-form-spec t provide anaphora] 4)