gmane.lisp.alexandria.devel

[Patch]: Fix an example in the docstring of iota.

Stas Boukarev — 2012-05-15T20:57:22

An example in the docstring of iota was
(iota 4) => (0 1 2 3 4)
while it should've been
(iota 4) => (0 1 2 3).

Split up Alexandria into an additionalexperimental package?

Tobias C Rittweiler — 2012-04-26T09:43:44

What is a good way to handle new additions to Alexandria that
are not fully fledged out yet?

As Hans noticed himself over this week, it usually takes
an incredible amount of time and effort to come up with
something with complete semantics. Time is a scarce resource,
and even if it was not, only experience and actual usage will
discover edges cases.

Common Lisp itself has been tried out and implemented many
times during the standardization process itself which is one
of the reasons it's engineered as well as it is.


What about providing an :ALEXANDRIA.EXPERIMENTAL
package that uses :ALEXANDRIA? New additions
go into the experimental package which is advertised
not necessarily to be fully backwards compatible.

People can explicitly :IMPORT-FROM that package (which
will continue to work even when the symbol moves from there
into :ALEXANDRIA, assuming no incompatible changes have been
made.)

T

DESTRUCTURE-CLAUSES -alexandria_destruct#9CF676.diff (1/1)

Tobias C Rittweiler — 2012-04-25T13:47:04

I was pleased to discover that DESTRUCTURING-CASE made it into
Alexandria meanwhile. Very nice! This allows me to share the
little gem that I'm attaching with this posting. It's a handy
macro to make writing macros like DEFPACKAGE, DEFGENERIC of
DEFREADTABLE easy like a breeze.

Happy to be giving back again! :-)

T
diff --git a/macros.lisp b/macros.lisp
index 4450435..0d4b9e9 100644
--- a/macros.lisp
+++ b/macros.lisp
< at >< at > -303,4 +303,76 < at >< at > Example:
   (setf (documentation name 'function) (documentation 'destructuring-case 'function)))
 
 
+;;; DESTRUCTURE-CLAUSES
 
+(defmacro destructure-clauses (clauses patterns &body body)
+  "Utility macro to conveniently destructure DEFPACKAGE like clauses.
+
+     clauses  ::= clause*
+     clause   ::= (keyword . list)                  ; e.g. (:FOO 1 :K 2)
+
+     patterns ::= pattern*
+     pattern  ::= (keyword . ordinary-lambda-list)  ; e.g. (:FOO N &KEY K)
+
+The CAR of each clause in CLAUSES will be tried to be matched against
+the CAR of each pattern in PATTERNS. If a match is found, the CDR of
+the matched pattern is interpreted as an ordinary lambda list and its
+parameters are bound to the values provided by the CDR of the clause.
+
+When all CLAUSES are processed, BODY will be executed with all the
+parameters of the matched patterns bound appropriately. Notice that
+parameters must hence be named distinctively in each pattern.
+
+Example:
+
+  (defmacro defpackage (name &body clauses)
+    (destructure-clauses clauses
+        ((:use &rest uses)
+         (:nicknames &rest nicknames)
+         (:export &rest exports)
+         ...)
+      (expand-defpackage name uses nicknames exports ...))
+
+Implementation note:
+
+  That a pattern consists of ordinary lambda list and not of
+  destructuring lambda lists is a /shortcoming/ of the current
+  implementation. Patches are welcome.
+"
+  (multiple-value-bind (pattern-table vars n-vars)
+      (loop for pattern in patterns
+            for vars   = (ordinary-lambda-list-parameters (cdr pattern))
+            for n-vars = (mapcar #'make-gensym vars)
+            collect (cons pattern (list vars n-vars)) into pattern-mappings
+            append vars   into all-vars
+            append n-vars into all-n-vars
+            finally
+            (return (values (alist-hash-table pattern-mappings)
+                            all-vars
+                            all-n-vars)))
+    (with-unique-names (clause)
+      `(let ,n-vars
+         (dolist (,clause ,clauses)
+           (destructuring-ecase ,clause
+             ,< at >(loop for p in patterns
+                     for (pattern-vars pattern-n-vars) = (gethash p pattern-table)
+                     collect `(,p ,< at >(loop for var   in pattern-vars
+                                          for n-var in pattern-n-vars
+                                          collect `(setq ,n-var ,var))))))
+         (let ,(mapcar #'list vars n-vars)
+           ,< at >body)))))
+
+(defun ordinary-lambda-list-parameters (ordinary-lambda-list)
+  "Return a list of all parameter names in ORDINARY-LAMBDA-LIST."
+  (flet ((optional-parameter-name (spec)
+           (car spec))
+         (key-parameter-name (spec)
+           (second (first spec))))
+    (multiple-value-bind (reqs opts rest keys aok auxs)
+        (parse-ordinary-lambda-list ordinary-lambda-list)
+      (assert (null aok)  () "&ALLOW-OTHER-KEYS not supported.")
+      (assert (null auxs) () "&AUX not supported.")
+      (append reqs
+              (mapcar #'optional-parameter-name opts)
+              (ensure-list rest)
+              (mapcar #'key-parameter-name keys)))))
\ No newline at end of file
diff --git a/package.lisp b/package.lisp
index babeb95..a025cc7 100644
--- a/package.lisp
+++ b/package.lisp
< at >< at > -240,4 +240,5 < at >< at >
    #:destructuring-case
    #:destructuring-ccase
    #:destructuring-ecase
+   #:destructure-clauses
    ))
diff --git a/tests.lisp b/tests.lisp
index e218113..51ea8ca 100644
--- a/tests.lisp
+++ b/tests.lisp
< at >< at > -1856,3 +1856,47 < at >< at >
             (when err
               (incf n))))))
   13)
+
+(deftest destructure-clauses.1
+    (let ((+clauses+ '((:required-1 :R1)
+                       (:required-n :R2 :R3 :R4)
+                       (:optional-0)
+                       (:optional-1 :O2)
+                       (:key-0)
+                       (:key-1 :KEY2 :K2)
+                       (:key-n :KEY3 :K3 :KEY4 :K4)
+                       (:required+optional-0 :R5)
+                       (:required+optional-1 :R6 :O4)
+                       (:required+key :R7 :R8 :KEY5 :K5))))
+      (destructure-clauses +clauses+
+          ((:required-1 req1)
+           (:required-n req2 req3 req4)
+           (:optional-0 &optional (opt1 :O1))
+           (:optional-1 &optional opt2)
+           (:key-0 &key (key1 :K1))
+           (:key-1 &key key2)
+           (:key-n &key key3 key4)
+           (:required+optional-0 req5 &optional (opt3 :O3))
+           (:required+optional-1 req6 &optional opt4)
+           (:required+key req7 req8 &key key5))
+        (values
+         (list req1)
+         (list req2 req3 req4)
+         (list opt1)
+         (list opt2)
+         (list key1)
+         (list key2)
+         (list key3 key4)
+         (list req5 opt3)
+         (list req6 opt4)
+         (list req7 req8 key5))))
+  (:R1)
+  (:R2 :R3 :R4)
+  (:O1)
+  (:O2)
+  (:K1)
+  (:K2)
+  (:K3 :K4)
+  (:R5 :O3)
+  (:R6 :O4)
+  (:R7 :R8 :K5))
\ No newline at end of file

EXTREMUM

Tobias C Rittweiler — 2012-04-25T09:15:59

The cl-utilities library contains one function which cannot be
found in alexandria that necessity pops up every now and then:

  Returning the maximum (or minimum) element in a sequence
  with respect to an arbitrary calculation involving the elements.

I.e.

  (elt (sort (copy-sequence <SEQUENCE>) #'< :key <FUNCTION>) 0) ; or #'>

except doing it more efficiently.

CL-UTILITIES calls this function EXTREMUM. (It also provides a couple
of more functions along the lines to cover some edge cases.)

The code can be found here:
 
http://common-lisp.net/viewvc/cl-utilities/cl-utilities/extremum.lisp?rev
ision=1.10&view=markup

As the code is Public Domain, it could just be moved as is.


I find no other use of cl-utilities and would like to see it
become entirely obsolete.

T

Some number patches

Robert Smith — 2012-04-25T03:03:10

Hello all:

I've decided I'm going to try to merge in stuff from my QTILITY
library [1] in an attempt to reduce the number of utility libraries
out there -- provided the stuff fits with the goals of Alexandria.
Xach and I decided it's best not to add more utility libraries to
Quicklisp.

I've created a patch that adds MULF and DIVF, which do what you might
expect (modify macros for * and /). I also added some numerical
predicates that I myself like, as well as others: POSITIVEP,
NEGATIVEP, NON-POSITIVE-P, NON-NEGATIVE-P, NON-ZERO-P. As you might
notice, they sound especially familiar to those who read mathematics
literature.

Also, would it be possible for me to have push permissions?

I hope you'll take these attached patches into consideration.

Thanks,

Robert Smith


[1] https://bitbucket.org/tarballs_are_good/qtility/src
_______________________________________________
alexandria-devel mailing list
alexandria-devel< at >common-lisp.net
http://lists.common-lisp.net/cgi-bin/mailman/listinfo/alexandria-devel

Proposed addition of temporary file creationutilities

Hans Hübner — 2012-04-22T13:35:45

Hi,

following up on an IRC discussion yesterday, I am proposing the
addition of the OPEN-TEMPORARY function and WITH-OPEN-TEMPORARY-FILE
macro below (and on http://paste.lisp.org/display/129090#14).  It
implements functionality that is commonly required, but that is not
available in any other library in a portable fashion.  osicat has been
suggested, but it does not implement temporary file handling on
Windows.

This posting is to determine whether there is opposition regarding
inclusion in Alexandria.  I'll re-post as a proper patch including
symbol exports when there is agreement to include it.

-Hans

(in-package :alexandria)

(defparameter *default-temporary-directory* #P"/tmp/")

(eval-when (:load-toplevel :execute)
  (when (and (null (logical-pathname-translations "TEMPORARY-FILES"))
             (probe-file *default-temporary-directory*))
    (setf (logical-pathname-translations "temporary-files") `(("*.*.*"
,*default-temporary-directory*)))))

(defparameter *max-tries* 10000)

(defun generate-random-name (prefix)
  (format nil "~A-~36R-~36R" prefix (random 100000000)
(get-internal-real-time)))

(define-condition cannot-create-temporary-file (error)
  ((directory :initarg :directory)
   (prefix :initarg :prefix)
   (type :initarg :type)
   (max-tries :initarg :max-tries))
  (:report (lambda (condition stream)
             (with-slots (directory prefix type max-tries) condition
               (format stream "cannot create temporary file in
directory ~A with template ~A.~A, giving up after ~D attempt~:P"
                       (translate-logical-pathname directory)
                       prefix type max-tries)))))

(defun open-temporary (&rest open-arguments
       &key
                         type
                         (prefix "temp")
                         (directory #P"TEMPORARY-FILES:")
 (generate-random-name 'generate-random-name)
                         (max-tries *max-tries*)
 &allow-other-keys)
  "Create a file with a randomly generated name and return the opened
   stream.  The generated pathname consists of the PREFIX with a
   pseudo-random suffix.  Its type will be TYPE.  Temporary files are
   generated in DIRECTORY which defaults to the logical pathname
   temporary TEMPORARY-FILES:, which must be properly set up.

   The name of the temporary file can be accessed calling the PATHNAME
   function on STREAM.  For convenience, the temporary file is opened
   on the physical pathname, i.e. the pathname translation is
   performed before opening the stream.

   GENERATE-RANDOM-NAME can be passed to override the default function
   that transforms PREFIX into a pseudorandom file name.  It needs to
   accept one argument, the PREFIX string passed, and return the
   generated file name.

   In order to create a unique file name, OPEN-TEMPORARY may loop
   internally up to MAX-TRIES times before giving up and signalling a
   CANNOT-CREATE-TEMPORARY-FILE condition."
  (loop thereis (apply #'open
                       (translate-logical-pathname (make-pathname
:name (funcall generate-random-name prefix)
                                                                  :type type

:defaults directory))
                       :direction :output
                       :if-exists nil
                       (remove-from-plist open-arguments :type prefix
directory generate-random-name max-tries))
        repeat max-tries
        finally (error 'cannot-create-temporary-file
                       :directory directory
                       :prefix prefix
                       :type type
                       :max-tries max-tries)))

(defmacro with-open-temporary-file ((stream &rest args) &body body)
  "Create a temporary file using OPEN-TEMPORARY with ARGS and run BODY
  with STREAM bound to the temporary file stream.  See OPEN-TEMPORARY
  for permitted options."
  `(with-open-stream (,stream (open-temporary ,< at >args))
     ,< at >body))

test failures on ACL and CMUCL

Anton Vodonosov — 2012-04-17T23:12:58

Hello. 

I wander if it's a known issue that alexandria tests fail on ACL and CMUCL?
(there also failures on CLISP, but they are marked as "known failres" in the test suite)

For you convenience here is the list of failed tests and what compilers
are affected by each failure (from the test results we collected on the recent Quicklisp):

"alist-hash-table.1" => ("clisp-2.49+-unix")
"copy-hash-table.1" => ("acl-8.2a-linux-x64" "clisp-2.49+-unix")
"copy-sequence.1" => ("cmu-20c_release-20c__20c_unicode_-linux-x86")
"plist-hash-table.1" => ("clisp-2.49+-unix")
"type=.3" => ("acl-8.2a-linux-x64")
"type=.4" => ("acl-8.2a-linux-x64")

More information (with the test run logs where more details may be found):
http://common-lisp.net/project/cl-test-grid/pivot_lib_ql-lisp.html

Best regards,
- Anton

Reminder alexandria:curry is not currying

Tomohiro Matsuyama — 2012-04-11T02:10:43

Hi,

Is there any progress on this discussion?

http://www.mail-archive.com/alexandria-devel< at >common-lisp.net/msg00199.html

I really won't use `curry' as partial application. I hope `partial-apply' will be soon available.

[PATCH] PROG1-LET

Benjamin Saunders — 2012-04-07T20:25:00

PROG1-LET is a binding macro modeled closely after WHEN-LET and
friends, which I have regularly found useful in code to implement the
"create, modify, return" pattern common in some imperative
code. As a simple and, I believe, widely useful macro, I'd like to see
this enter into Alexandria proper. Docstring follows:

Creates new variable bindings and executes FORMS, returning the
initial value of the first binding.

BINDINGS must be either single binding of the form:

 (variable initial-form)

or a list of bindings of the form:

 ((variable   initial-form)
  (variable-2 initial-form-2)
  ...
  (variable-n initial-form-n))

All initial-forms are executed sequentially in the specified order,
then all the variables are bound to the corresponding values and FORMS
are executed as an implicit PROGN. Finally, the value returned by
INITIAL-FORM is returned.
From cbccc782f34477c924ea8ff7b6000cd52511a768 Mon Sep 17 00:00:00 2001
From: Benjamin Saunders <ralith< at >gmail.com>
Date: Sat, 7 Apr 2012 13:19:19 -0700
Subject: [PATCH] Added PROG1-LET

---
 binding.lisp |   27 +++++++++++++++++++++++++++
 package.lisp |    1 +
 tests.lisp   |   24 ++++++++++++++++++++++++
 3 files changed, 52 insertions(+)

diff --git a/binding.lisp b/binding.lisp
index 36d92bc..27db561 100644
--- a/binding.lisp
+++ b/binding.lisp
< at >< at > -91,3 +91,30 < at >< at > PROGN."
          (when ,(caar binding-list)
            ,< at >(bind (cdr binding-list) forms))))))
 
+(defmacro prog1-let (bindings &body forms)
+  "Creates new variable bindings and executes FORMS, returning the initial
+value of the first binding.
+
+BINDINGS must be either single binding of the form:
+
+ (variable initial-form)
+
+or a list of bindings of the form:
+
+ ((variable   initial-form)
+  (variable-2 initial-form-2)
+  ...
+  (variable-n initial-form-n))
+
+All initial-forms are executed sequentially in the specified order, then all
+the variables are bound to the corresponding values and FORMS are executed
+as an implicit PROGN. Finally, the value returned by INITIAL-FORM is
+returned."
+  (let* ((binding-list (if (and (consp bindings) (symbolp (car bindings)))
+                           (list bindings)
+                           bindings))
+         (variables (mapcar #'car binding-list)))
+    `(let ,binding-list
+       (prog1 ,(first variables)
+         ,< at >forms))))
+
diff --git a/package.lisp b/package.lisp
index 673ed30..4bb5b56 100644
--- a/package.lisp
+++ b/package.lisp
< at >< at > -11,6 +11,7 < at >< at >
    #:if-let
    #:when-let
    #:when-let*
+   #:prog1-let
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; REVIEW IN PROGRESS
    ;;
diff --git a/tests.lisp b/tests.lisp
index b875382..8a2dbeb 100644
--- a/tests.lisp
+++ b/tests.lisp
< at >< at > -1779,6 +1779,30 < at >< at >
         :type-error))
   :type-error)
 
+(deftest prog1-let.1
+    (prog1-let (x :ok)
+      :oops)
+  :ok)
+
+(deftest prog1-let.2
+    (prog1-let ((x :ok)
+                (y :oops))
+      y)
+  :ok)
+
+(deftest prog1-let.3
+    (prog1-let (x (opaque :ok))
+      (setf x :oops))
+  :ok)
+
+(deftest prog1-let.error.1
+    (handler-case
+        (eval '(prog1-let x :oops))
+      (type-error ()
+        :type-error))
+  :type-error)
+
+
 (deftest doplist.1
     (let (keys values)
       (doplist (k v '(a 1 b 2 c 3) (values t (reverse keys) (reverse values) k v))

destructuring-case

Jasper — 2012-03-20T20:34:55

Hello all,

The `destructuring-case` macro imo is a little different than I would
think it would be upon just hearing the name.

The thing is, i'd have made the clauses to basically the
`destructuring-bind` form, except that a clause is executed if the
'nested lists-shape' matches, and all non-symbols, keywords match. I'd
add `quote` as special, something that also must match exactly, and
maybe `lambda`/`function` to indicate a function that must return
true.(which now i think of it is an idea for the next section.)

(shameless plug)Maybe the reason is that i wrote a `destructuring-regex`
https://github.com/o-jasper/j-basic/blob/master/src/destructuring-regex.lisp
of which the idea is that the variables can simply be written on the
matches/space between the matches.(Further each lisp object can add a
method giving the regular expression for it, and also provide a parser)
It uses the regex package though, is cl-ppcre more commonly used as
dependency?

But basically, i have a `regex-case` for it. Them being regexes and
either matching or not make it obvious how that should work!

Looking at the git log it was added Sep23 2010, so i am probably too
late to change `destructuring-case`? I dont know, i see there are no
official releases, and it might sneakily be that many people are using
the link from the cliki page!(from 2008)

- Ending a hopefully not too inane post, Jasper

broken LOOP forms

Greg Pfeil — 2012-03-19T18:07:55

Alexandria (QL version) doesn't compile on ECL and warns on CLISP because invalid LOOP forms are used in (at least) COPY-STREAM. EG:

(loop
   :while (< input-position start)
   :for bytes-read = (read-sequence buffer input
                                    :end (min (length buffer)
                                              (- start input-position)))
   :do (progn
         (when (zerop bytes-read)
           (error "Could not read enough bytes from the input to fulfill the START requirement in ~S" 'copy-stream))
         (incf input-position bytes-read)))

And I _think_ according to http://www.lispworks.com/documentation/HyperSpec/Body/m_loop.htm, the :WHILE expression can't precede the :FOR expression.

#'shuffle docstring is misleading

Orivej Desh — 2012-03-19T12:37:12

#'shuffle docstring states that “Permuted sequence may share storage
with the original one.”  Actually it destructively modifies the
sequence.  In the case of vectors the two might be the same, but in the
case of lists I would say that something like (sort (copy-list l) …)
shares storage with the original list but (sort l …) does more than
that.


_______________________________________________
alexandria-devel mailing list
alexandria-devel< at >common-lisp.net
http://lists.common-lisp.net/cgi-bin/mailman/listinfo/alexandria-devel

latest alexandria doesn't build on ECL due tonon-standard LOOP

Anton Vodonosov — 2012-03-14T14:27:24

Hello.

Alexandria in the latest quicklisp has a regression comparing to quicklisp 2012-02-08.

It doesn't build on ECL because on non-standard LOOP construct (it is tolerated
by most Lisps, but not by ECL; see here: http://comments.gmane.org/gmane.lisp.ecl.general/3344). 

The compiler complains about copy-stream method in io.lisp. Build logs:
https://cl-test-grid.appspot.com/blob?key=AMIfv97xRRWJgLOa5TvS78VriRK9mQ82myVc2VvHrnzvREBQSFMWQFVdpUO0nxfxKAgdBYZN_xr956y0xt7gKmwm-qa-DBpcWhdshsqTrTxeRN_VGYWjXVpVkHxpj5XV7Dbb0nOs8zQ0plRFDzBZgH7tNcChyLBwlA

Best regards,
- Anton

ALEXANDRIA:COPY-STREAM broken

Zach Beane — 2012-03-06T20:20:49

ALEXANDRIA:COPY-STREAM currently calls (< start end) even when END is
NIL. This breaks COPY-FILE unconditionally and COPY-STREAM whenever END
(or, less likely, START) is NIL.

Zach

PARSE-BODY printing its argument

Gustavo Henrique Milaré — 2012-03-01T21:15:13

Hi,

For some reason, whenever I use the function PARSE-BODY, the argument BODY
that is passed to it is printed (tested in SBCL and Clisp).

Clisp:

[4]> (alexandria.0.dev:parse-body '((declare (optimize speed)) (+ x y)))

(DECLARE (OPTIMIZE SPEED))
(+ X Y)
((+ X Y)) ;
((DECLARE (OPTIMIZE SPEED))) ;
NIL


SBCL:

* (parse-body '((declare (optimize speed)) (+ x y)))

(DECLARE (OPTIMIZE SPEED))
(+ X Y)
((+ X Y))
((DECLARE (OPTIMIZE SPEED)))
NIL


I'm using Alexandria of Quicklisp.
_______________________________________________
alexandria-devel mailing list
alexandria-devel< at >common-lisp.net
http://lists.common-lisp.net/cgi-bin/mailman/listinfo/alexandria-devel

9 new unexpected test failures on CLISP

Anton Vodonosov — 2012-02-13T01:25:21

Hello.

The alexandria version in the recent quicklisp has 9 unexpected failures on CLISP:

   ALEXANDRIA-TESTS::MEAN.1, 
   ALEXANDRIA-TESTS::MEAN.2, ALEXANDRIA-TESTS::MEAN.3, 
   ALEXANDRIA-TESTS::MEAN.4, ALEXANDRIA-TESTS::MEDIAN.1, 
   ALEXANDRIA-TESTS::MEDIAN.2, ALEXANDRIA-TESTS::MEDIAN.3, 
   ALEXANDRIA-TESTS::VARIANCE.1, ALEXANDRIA-TESTS::STANDARD-DEVIATION.1.

The library test log:
https://cl-test-grid.appspot.com/blob?key=AMIfv960NH7TxHvJO5_RSARVN0mmN_31Jlb74sx3q5njqk959i8ZkQeOxBRrZ4XKXnCBM8BTiA9d1OLpU_CqU5sBAnOK_aTxu2_rMtMnCMN_YMZxKq-MF3m6l0sHWRFXeQciOnpc-eabtE1VyLi5Btb_ZDtd60dDsA

reverting patch

Tamas Papp — 2012-02-01T10:55:49

Hi,

I have been trying to reach Nikodemus Siivola for a while but didn't
get a response, so I thought I would write here hoping that someone
can help me.

Nikodemus admitted my "generic MEAN and MEDIAN, new function
DISPLACE-ARRAY" patch to Alexandria 11 days ago.  This was meant to be
an initial patch, followed by others, with the final goal of making
mean, median and variance generic.  The first patch dealt with MEAN
and MEDIAN.

I would like to ask that this patch is removed from Alexandria for the
time being, for the following two reasons:

1. The generic variance I wrote would not support the :BIASED keyword,
in fact, only "unbiased" variance makes sense in certain situations.
Since :BIASED T is the default, this would break existing code in a
silent manner, which is not desirable.

2. The new function DISPLACE-ARRAY is badly designed: the keyword
defaults handle what turns out to be a rarely used corner case for me.
I would rather keep the old functionality, already present in
CL-NUM-UTILS.

I am sorry for the confusion.  I think it is best if I experiment
within my own libraries for a while before re-addressing these issues.
I wonder if someone could revert the patch, preferably soon, so that
the next release of Quicklisp would contain Alexandria without my
code.

Best,

Tamas

patch for generic variance and standard-deviation

Tamas Papp — 2012-01-21T15:05:26

_______________________________________________
alexandria-devel mailing list
alexandria-devel< at >common-lisp.net
http://lists.common-lisp.net/cgi-bin/mailman/listinfo/alexandria-devel

[PATCH] Fixes to make Alexandria work with:invert readtable case

Jyrki Jaakkola — 2012-01-20T11:22:49

Hi,

I have included a patch to make Alexandria work with :invert readtable case. Fixed also the tests to work with :invert readtable case.

Best regards,

Jyrki Jaakkola
_______________________________________________
alexandria-devel mailing list
alexandria-devel< at >common-lisp.net
http://lists.common-lisp.net/cgi-bin/mailman/listinfo/alexandria-devel

[PATCH] lazy-evaluate the default value inENSURE-GETHASH

Ryan Davis — 2011-12-21T18:30:59

I'm using a hash-table as a cache, and had a problem with
ensure-gethash. Some example code / output:

CL-USER> (let ((h (make-hash-table)))
  (alexandria:ensure-gethash :x h (progn (format T "expensive
computation~%") 1))
  (alexandria:ensure-gethash :x h (progn (format T "expensive
computation~%") 1)))
expensive computation
expensive computation
1
T
CL-USER>

This patch (created using git format-patch origin/master) converts
ENSURE-GETHASH to a macro that only evaluates the default if we get to
the setf branch. Has a check to create and call a lambda if the default
value looks complicated (using CONSTANTP).

After applying my patch, here's the output:
CL-USER> (let ((h (make-hash-table)))
  (alexandria:ensure-gethash :x h (progn (format T "expensive
computation~%") 1))
  (alexandria:ensure-gethash :x h (progn (format T "expensive
computation~%") 1)))
expensive computation
1
T
CL-USER>

Thoughts?

Thanks,

generic mean, variance, median,standard-deviation

Tamas Papp — 2011-12-12T16:06:06

Hi,

Would it be possible to make MEAN, VARIANCE, MEDIAN, and
STANDARD-DEVIATION generic?  The concepts are meaningful for objects
other than sequences --- including arrays and random-variables (see
cl-random), sequences pre-sorted for easy quantile calculation, etc.
Currently I am shadowing these and redefining them as generic in some
of my libraries.

I am happy to implement the change and send a patch.

Best,

Tamas