alexandria-devel

alexandria-devel@common-lisp.net

184 discussions

[alexandria-devel] [PATCH] fix generate-switch-body
by Stelian Ionescu 09 Feb '08

09 Feb '08

The attached patch makes GENERATE-SWITCH-BODY extract the function name of KEY too, not just TEST. -- Stelian Ionescu a.k.a. fe[nl]ix Quidquid latine dictum sit, altum videtur.

2 1

[alexandria-devel] format-mixed-radix-number, format-duration
by Michael Weber 07 Feb '08

07 Feb '08

Hi, wonder whether the functions below are candidates for alexandria: ;;; Examples (format-duration nil 86401.5) => "1d0h0m1.50s" (format-duration nil 86401 :format '(" ~,2F second~:P" " ~D minute~:P" " ~D hour~:P" " ~D day~:P")) => " 1 day 0 hours 0 minutes 1.00 second" ;;; Code: (defun format-mixed-radix-number (stream number radix-list format-list &key lsb-first leading-zeros (trailing-zeros t)) "Prints NUMBER to STREAM in mixed-radix RADIX. representation-LIST is a list of radixes, least-significant first. FORMAT-LIST is a list of format directives, one for each digit. When LSB-FIRST is nil (default), print most-significant digit first, otherwise least-significant digit first. When LEADING-ZEROS and TRAILING-ZEROS are nil, leading and trailing zero digits are not printed, respectively. \(default: remove leading zeros, keep trailing zeros)" (let ((format-pairs (loop with digit and fraction initially (setf (values number fraction) (truncate number)) for f-list on format-list and r-list = radix-list then (rest r-list) collect (list (first f-list) (cond ((endp r-list) (shiftf number 0)) ((rest f-list) (setf (values number digit) (truncate number (first r- list))) digit) (t number))) into list finally (progn (incf (cadar list) fraction) (return (nreverse list)))))) (unless trailing-zeros (setf format-pairs (member-if #'plusp format-pairs :key #'second))) (when lsb-first (setf format-pairs (nreverse format-pairs))) (unless leading-zeros (setf format-pairs (member-if #'plusp format-pairs :key #'second))) (format stream "~{~{~@?~}~}" format-pairs))) (defvar *duration-format-string* '("~4,2Fs" "~Dm" "~Dh" "~Dd" "~Dy") "Default format for `format-duration'. Least-significant digit first.") (defun format-duration (stream duration &rest args &key (format *duration-format-string*) leading-zeros trailing-zeros &allow-other-keys) "Prints DURATION (a time duration in seconds) to STREAM according to FORMAT \(default: *DURATION-FORMAT-STRING*). \(See also `format-mixed-radix-number'.)" (declare (ignore leading-zeros trailing-zeros)) (alexandria:remove-from-plistf args :format) (apply #'format-mixed-radix-number stream duration '(60 60 24 365) format args))

2 2

[alexandria-devel] :TEST and :KEY for maphash-{keys, values}: in the spirit of 14.1.2.2
by Samium Gromoff 28 Jan '08

28 Jan '08

In the spirit of `14.1.2.2 Lists as Sets', that is, in order to facilitate use of hash tables as sets, it seems to make sense to extend MAPHASH-KEYS and MAPHASH-VALUES to accept :TEST, :TEST-NOT and :KEY, as specified by `17.2.1 Satisfying a Two-Argument Test', with a difference of making tests accept a single parameter. A possible implementation (derived from SBCL sources) is as follows: (defmacro apply-key (key element) `(if ,key (funcall ,key ,element) ,element)) (defmacro satisfies-the-test (elt) (with-gensyms (key-tmp) `(let ((,key-tmp (apply-key key ,elt))) (cond (testp (funcall test ,key-tmp)) (notp (not (funcall test-not ,key-tmp))) (t t))))) (declaim (inline maphash-keys)) (defun maphash-keys (function table &key key (test nil testp) (test-not nil notp)) "Like MAPHASH, but calls FUNCTION with each key in the hash table TABLE." (when (and testp notp) (error ":TEST and :TEST-NOT were both supplied.")) (maphash (lambda (k v) (declare (ignore v)) (when (satisfies-the-test k) (funcall function k))) table)) (declaim (inline maphash-values)) (defun maphash-values (function table &key key (test nil testp) (test-not nil notp)) "Like MAPHASH, but calls FUNCTION with each value in the hash table TABLE." (when (and testp notp) (error ":TEST and :TEST-NOT were both supplied.")) (maphash (lambda (k v) (declare (ignore k)) (when (satisfies-the-test k) (funcall function v))) table)) There is also a question of whether it is desirable to extend in a similar manner MAPHASH itself (under a different name), so as to make it accept :KEY-KEY, :VALUE-KEY, :KEY-TEST, :VALUE-TEST, which would make the extension protocol usable in a wider range of scenarios. regards, Samium Gromoff

1 0

[alexandria-devel] SOMETIMES
by Tobias C. Rittweiler 17 Jan '08

17 Jan '08

I'd also like to propose the following addition: (defun sometimes (test then &optional (else nil else-p)) "Returns a function that applies TEST on its arguments and returns either THEN or ELSE depending on the test result. If ELSE is not provided, the arguments passed to the returned function are returned as multiple values. Examples: (mapcar (sometimes #'plusp 1 -1) '(1 -1 2 -2 3 -3)) ==> (1 -1 1 -1 1 -1) (mapcar (sometimes #'minusp 0) '(1 -1 2 -2 3 -3)) ==> (1 0 2 0 3 0) " (flet ((%sometimes (&rest args) (if (apply test args) then (if else-p else (values-list args))))) #'%sometimes)) It's in the same spirit as CONSTANTLY, which is also the reason for its name. (SOMETIMES #'PLUSP 1 -1) can be read as sometimes 1, sometimes -1, depending on PLUSP. The internal FLET should probably be replaced by a call to ALEXANDRIA:NAMED-LET. -T.

2 1

[alexandria-devel] MAYBECALL
by Tobias C. Rittweiler 17 Jan '08

17 Jan '08

I'd like to propose the addition of the following function: (defun maybecall (bool fn &rest args) "Call FN with ARGS if BOOL is T. Otherwise return ARGS as multiple values." (if bool (apply fn args) (values-list args))) MAYBECALL is the general, or anonymous, solution to many ensure-foo problems. (maybecall (not (listp thing)) #'list thing) == (ensure-list thing) (maybecall (listp thing) #'car thing) == (ensure-car thing) I've thought about naming it FUNCALL-IF, but that could be read as taking a predicate function a la all the sequence functions, rather than a boolean value. And the result of making it take a predicate (funcall-if #'listp #'car thing) is not so nice if you want the call not to depend directly on the arguments passed. E.g. a use case where I often use MAYBECALL is to call a function depending on a flag (most often argument to the surrounding function.) I.e. (maybecall removep #'remove foo bars) vs. (funcall-if (constantly removep) #'remove foo bars) That said, I don't care much which of these two you eventually decide upon. -T.

2 2

[alexandria-devel] Next steps
by Nikodemus Siivola 16 Jan '08

16 Jan '08

I last said something about this 6 months ago... I think it's time to close the floodgates for version 1 any day now. IMPORTANT: If there are people with patches languishing in the archives, who would like to see them merged, please holler before the end of this month. Likewise, if there are people with "you're still missing X" grievances, please report them before the end of this month. Likewise, if there are Alexandria hackers with pending _new_ additions, please push them (or at least tell us about them) before the end of this month. Starting February 1st, Alexandria version 1 will not be added to anymore -- things may still be changed and dropped, and all sorts of funky stuff may happen, but new additions will have to wait for the start of Alexandria 2 cycle. (Assuming this is all right with the veto-enabled people.) Cheers, -- Nikodemus

2 2

[alexandria-devel] Anonymous modify macros through `CALLF'
by Tobias C. Rittweiler 16 Jan '08

16 Jan '08

Hi, Alexandria seems to contain a lot of modify macro definitions. Which is no wonder, as those are quite practical: They're concise, and simultaneously guarantee that their arguments are only evaluated once. Inspired from CL.el in Emacs, I grew quite fond of CALLF which is a generalized modify macro, or if you look from the right angle, an anonymous modify macro facility. Instead of having to globally define modify macros each time you want one for a certain function, you simply use CALLF instead: (callf #'append place l1 l2 l3 ...) == (appendf place l1 l2 l3) (callf #'coerce place 'foo) == (coercef place 'foo) and so on. CALLF is actually just an abbreviation for the even more general macro CALLF-N: (callf-n n function &rest args) which takes the Nth argument to be the place. I.e. (callf #'f place x y z) == (callf-n 1 #'f place x y z) This is important if you want to use things like REMOVE or DELETE where the place is the second argument. I.e. something almost equivalent to Erik Naggum's DROP could be defined like: (defmacro drop (object place &rest keys &key key test test-not) "Drop a particular OBJECT from list in PLACE. (Intended as counterpart to PUSH.)" (declare (ignore key test test-not)) `(callf2 #'delete ,object ,place :count 1 ,@keys)) where CALLF2 is equivalent to (CALLF-N 2); CALLF and CALLF2 are abbreviations for the most common cases, so they're specially provided. As you can see, these macro also aid macro programming because they relieve you from having to mess with GET-SETF-EXPANSION &c. I place the implementation below into the public domain to be included into the Alexandria library. Notice that the implementation uses another utility BREAKUP which (together with its sibling BREAKUP-IF) should also be included into Alexandria. -T. (defun breakup (n list) "Breaks LIST into two pieces at position N where the (NTH n) element will become the first element of the second piece. Both pieces are returned in a list. If N < 0, treat N as if 0. If N >= (length LIST), return NIL as second piece. Examples: (breakup 0 '(0 1 2 3 4)) => (NIL (0 1 2 3 4)) (breakup 2 '(0 1 2 3 4)) => ((0 1) (2 3 4)) (breakup 9 '(0 1 2 3 4)) => ((0 1 2 3 4) NIL) " (let ((front nil)) (dotimes (i n) (when (null list) (return)) (push (car list) front) (setf list (cdr list))) (list (nreverse front) list))) (defun breakup-if (predicate list) "Breaks LIST into two pieces at the first element of which PREDICATE returns T. Examples: (breakup-if #'oddp '(2 4 6 7 8 10)) => ((2 4 6) (7 8 19)) (breakup-if #'evenp '(2 4 6 7 8 10)) => (NIL (2 4 6 7 8 10)) " (loop with tail = nil for (x . rest) on list if (not (funcall predicate x)) collect x into front else do (setq tail (cons x rest)) (loop-finish) finally (return (list front tail)))) (defmacro callf-n (n function &rest args &environment env) "CALLF-N represents an anonymous modify macro facility. The Nth argument (starting from 1) of ARGS is considered to be a `place'. This place is set to `(FUNCTION arg1 ... arg{N-1} place arg{N+1} ...)'. Examples: (appendf place l1 l2 ...) == (callf-n 1 #'append place l1 l2 ...) (progn (defvar *foo* (list 1 2 (list 3 4 4 4 5) 6 7)) (callf-n 2 #'remove 4 (third *foo*)) *foo*) ==> (1 2 (3 5) 6 7) " (destructuring-bind ((&rest frontargs) (place &rest tailargs)) (breakup (1- n) args) (multiple-value-bind (gvars vals gstorevars setter getter) (get-setf-expansion place env) (when (second gstorevars) (error "CALLF does not support setting multiple values via the (VALUES ...) place.")) (let ((gstorevar (first gstorevars))) `(let ,(mapcar #'list gvars vals) (let ((,gstorevar (funcall ,function ,@frontargs ,getter ,@tailargs))) ,setter) ))))) (defmacro callf (function &rest args) "Abbreviation for (CALLF-N 1 FUNCTION args..)." `(callf-n 1 ,function ,@args)) (defmacro callf2 (function &rest args) "Abbreviation for (CALLF-N 2 FUNCTION args..)." `(callf-n 2 ,function ,@args)) -- Diese Nachricht wurde auf Viren und andere gefaerliche Inhalte untersucht und ist - aktuelle Virenscanner vorausgesetzt - sauber. Freebits E-Mail Virus Scanner

2 1

[alexandria-devel] [PATCH] Fixing documentation typos and omission, better formatting
by Victor Kryukov 02 Jan '08

02 Jan '08

Hello Alexandria developers, attached is the patch that fixes some typos, omissions and formatting in alexandria manual. Note that the manual at http://common-lisp.net/project/alexandria/draft/alexandria.pdf is outdated. I had to manually comment fun-alexandria-sans.info entry, as this file is not generated by docstring.lisp. I have no idea why :( - could it be related to inlining? Also, while compiling the pdf, I've noticed a bug in docstring.lisp: title names for functions like (defun (setf something) ...) should be surrounded by '{}'. An obvious patch for that is also attached. Best Regards, Victor

1 0

[alexandria-devel] remove-from-plist argument order
by Attila Lendvai 22 Dec '07

22 Dec '07

hi, Nikodemus, i've seen your comment regarding r-f-p. i have more or less copied r-f-p from arnesi and unfortunately didn't give it enough thoughts and therefore the current argument order just a heritage. the (r-f-p plist &rest keys) signature looks much better and performance can be have through inlining the calls, so i suggest to simply changing r-f-p to that signature, and recording the change with a big fat warning. -- attila

3 2

[alexandria-devel] [patch] implement multiple-value-or
by Andreas Fuchs 19 Dec '07

19 Dec '07

Hi there, I just stumbled over the lack of a multiple-value-or in CL, so here's a patch hat implement it in alexandria (with the first value specifying which value's non-NIL-ness to consider): It may look horrifying, but it allows pleasant things like: (multiple-value-or 1 (gethash key table) (gethash key alternative- table)) and other niceties. Hope you like it, -- Andreas Fuchs, (http://|im:asf@|mailto:asf@)boinkor.net, antifuchs

2 2

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

alexandria-devel