Mercurial > hg > xemacs-beta

comparison lisp/cl-extra.el @ 4996:c17c857e20bf

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge.
author Aidan Kehoe <kehoea@parhasard.net>
date Wed, 03 Feb 2010 20:18:53 +0000
parents 6ef8256a020a 8431b52e43b1
children 8800b5350a13
comparison
equal deleted inserted replaced
4927:5274591ce707 4996:c17c857e20bf
73 ;; XEmacs addition: enhanced numeric type coercions 73 ;; XEmacs addition: enhanced numeric type coercions
74 ((and-fboundp 'coerce-number 74 ((and-fboundp 'coerce-number
75 (memq type '(integer ratio bigfloat)) 75 (memq type '(integer ratio bigfloat))
76 (coerce-number x type))) 76 (coerce-number x type)))
77 ;; XEmacs addition: bit-vector coercion 77 ;; XEmacs addition: bit-vector coercion
78 ((eq type 'bit-vector) (if (bit-vector-p x) x 78 ((or (eq type 'bit-vector)
79 (apply 'bit-vector (append x nil)))) 79 (eq type 'simple-bit-vector))
80 (if (bit-vector-p x) x (apply 'bit-vector (append x nil))))
80 ;; XEmacs addition: weak-list coercion 81 ;; XEmacs addition: weak-list coercion
81 ((eq type 'weak-list) 82 ((eq type 'weak-list)
82 (if (weak-list-p x) x 83 (if (weak-list-p x) x
83 (let ((wl (make-weak-list))) 84 (let ((wl (make-weak-list)))
84 (set-weak-list-list wl (if (listp x) x (append x nil))) 85 (set-weak-list-list wl (if (listp x) x (append x nil)))
85 wl))) 86 wl)))
87 ((and
88 (consp type)
89 (or (eq (car type) 'vector)
90 (eq (car type) 'simple-array)
91 (eq (car type) 'simple-vector))
92 (cond
93 ((equal (cdr-safe type) '(*))
94 (coerce x 'vector))
95 ((equal (cdr-safe type) '(bit))
96 (coerce x 'bit-vector))
97 ((equal (cdr-safe type) '(character))
98 (coerce x 'string)))))
86 ((typep x type) x) 99 ((typep x type) x)
87 (t (error "Can't coerce %s to type %s" x type)))) 100 (t (error "Can't coerce %s to type %s" x type))))
88 101
89 102
90 ;;;;; Predicates. 103 ;;;;; Predicates.
210 ;; ;; bit-vectors and strings are only equalp if they're 223 ;; ;; bit-vectors and strings are only equalp if they're
211 ;; ;; zero-length: 224 ;; ;; zero-length:
212 ;; (and (equal "" y) (equal #* x))))) 225 ;; (and (equal "" y) (equal #* x)))))
213 ;; (t (equal x y))))))) 226 ;; (t (equal x y)))))))
214 227
215 ;;; Control structures. 228 ;; XEmacs; #'map, #'mapc, #'mapl, #'maplist, #'mapcon are now in C, together
216 229 ;; with #'map-into, which was never in this file.
217 (defun cl-mapcar-many (cl-func cl-seqs)
218 (if (cdr (cdr cl-seqs))
219 (let* ((cl-res nil)
220 (cl-n (apply 'min (mapcar 'length cl-seqs)))
221 (cl-i 0)
222 (cl-args (copy-sequence cl-seqs))
223 cl-p1 cl-p2)
224 (setq cl-seqs (copy-sequence cl-seqs))
225 (while (< cl-i cl-n)
226 (setq cl-p1 cl-seqs cl-p2 cl-args)
227 (while cl-p1
228 (setcar cl-p2
229 (if (consp (car cl-p1))
230 (prog1 (car (car cl-p1))
231 (setcar cl-p1 (cdr (car cl-p1))))
232 (aref (car cl-p1) cl-i)))
233 (setq cl-p1 (cdr cl-p1) cl-p2 (cdr cl-p2)))
234 (push (apply cl-func cl-args) cl-res)
235 (setq cl-i (1+ cl-i)))
236 (nreverse cl-res))
237 (let ((cl-res nil)
238 (cl-x (car cl-seqs))
239 (cl-y (nth 1 cl-seqs)))
240 (let ((cl-n (min (length cl-x) (length cl-y)))
241 (cl-i -1))
242 (while (< (setq cl-i (1+ cl-i)) cl-n)
243 (push (funcall cl-func
244 (if (consp cl-x) (pop cl-x) (aref cl-x cl-i))
245 (if (consp cl-y) (pop cl-y) (aref cl-y cl-i)))
246 cl-res)))
247 (nreverse cl-res))))
248
249 (defun map (cl-type cl-func cl-seq &rest cl-rest)
250 "Map a function across one or more sequences, returning a sequence.
251 TYPE is the sequence type to return, FUNC is the function, and SEQS
252 are the argument sequences."
253 (let ((cl-res (apply 'mapcar* cl-func cl-seq cl-rest)))
254 (and cl-type (coerce cl-res cl-type))))
255
256 (defun maplist (cl-func cl-list &rest cl-rest)
257 "Map FUNC to each sublist of LIST or LISTS.
258 Like `mapcar', except applies to lists and their cdr's rather than to
259 the elements themselves."
260 (if cl-rest
261 (let ((cl-res nil)
262 (cl-args (cons cl-list (copy-sequence cl-rest)))
263 cl-p)
264 (while (not (memq nil cl-args))
265 (push (apply cl-func cl-args) cl-res)
266 (setq cl-p cl-args)
267 (while cl-p (setcar cl-p (cdr (pop cl-p)) )))
268 (nreverse cl-res))
269 (let ((cl-res nil))
270 (while cl-list
271 (push (funcall cl-func cl-list) cl-res)
272 (setq cl-list (cdr cl-list)))
273 (nreverse cl-res))))
274
275 ;; XEmacs change: in Emacs, this function is named cl-mapc.
276 (defun mapc (cl-func cl-seq &rest cl-rest)
277 "Like `mapcar', but does not accumulate values returned by the function."
278 (if cl-rest
279 (apply 'map nil cl-func cl-seq cl-rest)
280 ;; XEmacs change: in the simplest case we call mapc-internal,
281 ;; which really doesn't accumulate any results.
282 (mapc-internal cl-func cl-seq))
283 cl-seq)
284
285 ;; XEmacs addition: FSF compatibility
286 (defalias 'cl-mapc 'mapc)
287
288 (defun mapl (cl-func cl-list &rest cl-rest)
289 "Like `maplist', but does not accumulate values returned by the function."
290 (if cl-rest
291 (apply 'maplist cl-func cl-list cl-rest)
292 (let ((cl-p cl-list))
293 (while cl-p (funcall cl-func cl-p) (setq cl-p (cdr cl-p)))))
294 cl-list)
295
296 (defun mapcan (cl-func cl-seq &rest cl-rest)
297 "Like `mapcar', but nconc's together the values returned by the function."
298 (apply 'nconc (apply 'mapcar* cl-func cl-seq cl-rest)))
299
300 (defun mapcon (cl-func cl-list &rest cl-rest)
301 "Like `maplist', but nconc's together the values returned by the function."
302 (apply 'nconc (apply 'maplist cl-func cl-list cl-rest)))
303 230
304 (defun some (cl-pred cl-seq &rest cl-rest) 231 (defun some (cl-pred cl-seq &rest cl-rest)
305 "Return true if PREDICATE is true of any element of SEQ or SEQs. 232 "Return true if PREDICATE is true of any element of SEQ or SEQs.
306 If so, return the true (non-nil) value returned by PREDICATE." 233 If so, return the true (non-nil) value returned by PREDICATE."
307 (if (or cl-rest (nlistp cl-seq)) 234 (if (or cl-rest (nlistp cl-seq))