http://blog.gmane.org/gmane.lisp.iterate.devel hourly 1 1901-01-01T00:00+00:00 http://gmane.org/img/gmane-25t.png http://gmane.org http://comments.gmane.org/gmane.lisp.iterate.devel/178 <pre>Iterate test suite shows regression between quicklisp 2012-03-07 and quicklisp 2012-04-07. acl-8.2a-linux-x64. Test logs: quicklisp 2012-03-07: http://cl-test-grid.appspot.com/blob?key=AMIfv97pKvcGKmd6_yqeRupJ3ii6PsLmOuUZ0zDuQzUuJQgi_7uJX43ujwQLaaqlRBwTLkipZNoOijXq1ORRPH5fXepLeh-qO0a9Y1O6u1lEOnvDxgKYWuRnS2BWJQqPnRuvsf4xJ5KPwByJXBgamPqGXmoL413eHg failed tests: bug/walk.2 code-movement.else code-movement.finally code-movement.finally-protected quicklisp 2012-04-07: http://cl-test-grid.appspot.com/blob?key=20006 failed tests: bug/walk.2 code-movement.else code-movement.finally code-movement.finally-protected handler-bind.1 As you see, new failure is handler-bind.1. </pre> Anton Vodonosov 2012-05-06T22:35:25 http://comments.gmane.org/gmane.lisp.iterate.devel/177 <pre>Iterate test suite shows regression between quicklisp 2012-03-07 and quicklisp 2012-04-07. sbcl-1.0.54.84.mswinmt.1137-215bdc8-win-x64. Test logs: quicklisp 2012-03-07: http://cl-test-grid.appspot.com/blob?key=AMIfv94-RAJv0FSm0WjXUTgYha9U7tUSAzwo4V3HxonJSNx5TPSEwRcW2ca7clAc5pJIh5JZjhMS7GZWQih7hViiC7OmZfY1onNIBciD7m6kbVJu9FeiRgeGEtwrPd4YxXx-dB-y6UPs8LFQN5_-st7G9ICpZVRLkA failed tests: NONE quicklisp 2012-04-07: http://cl-test-grid.appspot.com/blob?key=53022 failed tests: bug/walk.2 As you see, new failure is bug/walk.2. </pre> Anton Vodonosov 2012-05-06T22:39:32 http://comments.gmane.org/gmane.lisp.iterate.devel/176 <pre>Hi, I reported this bug a few years ago, but it is still there. If both AT BEGINNING and RESULT-TYPE are specified, RESULT-TYPE is ignored. Example: (iter (for i below 2) (collect i at beginning result-type vector)) returns (1 0). Can someone with write access to the darcs repository fix the bug please. My previous report includes a patch: http://www.mail-archive.com/iterate-devel&lt; at &gt;common-lisp.net/msg00142.html Thanks, Ilya </pre> Ilya Perminov 2012-03-27T22:49:33 http://comments.gmane.org/gmane.lisp.iterate.devel/175 <pre>Apologies for the multiple postings. PAPER SUBMISSION DEADLINE EXTENDED European Lisp Symposium 2012, Zadar, Croatia, April 30th - May 1st, 2012 http://european-lisp-symposium.org The purpose of the European Lisp Symposium is to provide a forum for the discussion and dissemination of all aspects of design, implementation and application of any of the Lisp and Lisp-inspired dialects, including Common Lisp, Scheme, Emacs Lisp, AutoLisp, ISLISP, Dylan, Clojure, ACL2, ECMAScript, Racket, SKILL, and so on. We encourage everyone interested in Lisp to participate. The main theme of the 2012 European Lisp Conference is "Interoperability: Systems, Libraries, Workflows". Lisp based and functional-languages based systems have grown a variety of solutions to become more and more integrated with the wider world of Information and Communication Technologies in current use. There are several dimensions to the scope of the solutions proposed, ranging from "embedding" of interpreters in C-based systems, to the development of abstractions levels that facilitate the expression of complex context dependent tasks, to the construction of exchange formats handling libraries, to the construction of theorem-provers for the "Semantic Web". The European Lisp Symposium 2012 solicits the submission of papers with this specific theme in mind, alongside the more traditional tracks which have appeared in the past editions. We invite submissions in the following forms: Papers: Technical papers of up to 15 pages that describe original results or explain known ideas in new and elegant ways. Demonstrations: Abstracts of up to 4 pages for demonstrations of tools, libraries, and applications. Tutorials: Abstracts of up to 4 pages for in-depth presentations about topics of special interest for at least 90 minutes and up to 180 minutes. Lightning talks: Abstracts of up to one page for talks to last for no more than 5 minutes. All submissions should be formatted following the ACM SIGS guidelines and include ACM classification categories and terms. For more information on the submission guidelines and the ACM keywords, see: http://www.acm.org/sigs/publications/proceedings-templates and http://www.acm.org/about/class/1998. Important dates: February 15th 2012: submission deadline (extended deadline) March 7th 2012: acceptance results April 30th 2012: Conference opens Program Commitee. Chair: Marco Antoniotti, Università degli Studi di Milano Bicocca, Milan, ITALY Local organizers: Damir Cavar, Eastern Michigan University Franjo Pehar, University of Zadar Damir Kero, University of Zadar Members: Giuseppe Attardi, Università degli Studi di Pisa, Pisa, ITALY Pascal Costanza, Intel, Bruxelles, BELGIUM Marc Feeley, Université de Montreal, Montreal, CANADA Scott McKay, Google, U.S.A. Kent Pitman, U.S.A. Christophe Rhodes, Department of Computing, Goldsmiths, University of London, London, UNITED KINGDOM Robert Strandh, LABRI, Université de Bordeaux, Bordaux, FRANCE Didier Verna, EPITA / LRDE, FRANCE Taiichi Yuasa, Kyoto University, JAPAN -- Marco Antoniotti </pre> Marco Antoniotti 2012-02-01T13:13:50 http://comments.gmane.org/gmane.lisp.iterate.devel/174 <pre> Apologies for the multiple postings... =========================================================================== European Lisp Symposium 2012, Zadar, Croatia, April 30th - May 1st, 2012 http://european-lisp-symposium.org The purpose of the European Lisp Symposium is to provide a forum for the discussion and dissemination of all aspects of design, implementation and application of any of the Lisp and Lisp-inspired dialects, including Common Lisp, Scheme, Emacs Lisp, AutoLisp, ISLISP, Dylan, Clojure, ACL2, ECMAScript, Racket, SKILL, and so on. We encourage everyone interested in Lisp to participate. The main theme of the 2012 European Lisp Conference is "Interoperabilty: Systems, Libraries, Workflows". Lisp based and functional-languages based systems have grown a variety of solutions to become more and more integrated with the wider world of Information and Communication Technologies in current use. There are several dimensions to the scope of the solutions proposed, ranging from "embedding" of interpreters in C-based systems, to the development of abstractions levels that facilitate the expression of complex context dependent tasks, to the construction of exchange formats handling libraries, to the construction of theorem-provers for the "Semantic Web". The European Lisp Symposium 2012 solicits the submission of papers with this specific theme in mind, alongside the more traditional tracks which have appeared in the past editions. We invite submissions in the following forms: Papers: Technical papers of up to 15 pages that describe original results or explain known ideas in new and elegant ways. Demonstrations: Abstracts of up to 4 pages for demonstrations of tools, libraries, and applications. Tutorials: Abstracts of up to 4 pages for in-depth presentations about topics of special interest for at least 90 minutes and up to 180 minutes. Lightning talks: Abstracts of up to one page for talks to last for no more than 5 minutes. All submissions should be formatted following the ACM SIGS guidelines and include ACM classification categories and terms. For more information on the submission guidelines and the ACM keywords, see: http://www.acm.org/sigs/publications/proceedings-templates and http://www.acm.org/about/class/1998. Important dates: Jan 31st 2012: submission deadline Feb 21st 2012: acceptance results April 30th, 2012 Conference opens Program Commitee. Chair: Marco Antoniotti, Università degli Studi di Milano Bicocca, Milan, ITALY Local organizers: Damir Ćavar, Eastern Michigan University Franjo Pehar, University of Zadar Damir Kero, University of Zadar Members: Giuseppe Attardi, Università degli Studi di Pisa, Pisa, ITALY Pascal Costanza, Intel, Bruxelles, BELGIUM Marc Feeley, Université de Montreal, Montreal, CANADA Scott McKay, Google, U.S.A. Kent Pitman, U.S.A. Christophe Rhodes, Department of Computing, Goldsmiths, University of London, London, UNITED KINGDOM Robert Strandh, LABRI, Université de Bordeaux, Bordaux, FRANCE Didier Verna, EPITA / LRDE, FRANCE Taiichi Yuasa, Kyoto University, JAPAN _______________________________________________ iterate-devel site list iterate-devel&lt; at &gt;common-lisp.net http://common-lisp.net/mailman/listinfo/iterate-devel</pre> Marco Antoniotti 2012-01-23T11:59:23 http://comments.gmane.org/gmane.lisp.iterate.devel/173 <pre>Steve Haflich from Franz kindly clarified to me my misunderstanding of special-operators and macros. In particular, he pointed out to me that implementations are free to implement special operators as macros. Steve writes: "I assure you that the set of special operators in ACL is _fixed+, and that there is way for you, the _user_, to extend that set. But this requirement of the ANS does not require that the set of cl-package symbols that return true under spcial-operator-p is not larger than the required operators in the table you quoted from http://www.franz.com/support/documentation/current/ansicl/subsubsu/specialf.htm Now see here: http://www.franz.com/support/documentation/current/ansicl/subsubsu/macrofor.htm specifically An implementation is free to implement a Common Lisp special operator as a macro. An implementation is free to implement any macro operator as a special operator, but only if an equivalent definition of the macro is also provided." He goes on to explain how this works in ACL: "In ACL user(31): (macro-function 'return) #&lt;Function macroexpand-1-transform&gt; so cl:return names _both_ a special operator and a macro. In our opinion, this is explicitly recognized by the ANS. (I think I remember being there when we of X3J13 voted this issue, but I also think I think I sometimes remember things that never occurred. Your mileage may vary.) Unfortunately, this seemingly innocent divergence from the standard breaks the code walker in ITERATE (and may break other code walkers, as well). I haven't examined this particular code walker, but I speculate that it is checking special-operator-p _before_ checking macro-function. A _portable_ walker should give the latter priority, which is what Franz believes the "implementation is free" codicil intends." Steve's understanding of the code walker in FREE-VARS is correct. Actually, over and above this, there seems to be a second bug in the code-walker: the check of (MACRO-FUNCTION (CAR FORM)) is not inside the branch for (SYMBOLP (CAR FORM)). So I believe that fixing this bug is not just a matter of pandering to ACL users, but actually a matter of fixing an incorrect code walker that could cause problems for arbitrary lisp implementations. I have attempted to fix this bug by moving the branch for MACRO-FUNCTION into the branch for SYMBOLP (CAR FORM) and moving it up before the check for SPECIAL-OPERATOR-P. See attached patch. I'd be obliged if you could review it for incorporation. It reduces the number of test failures in Allegro CL to the same as the number for SBCL: one. Best, R --- /Users/rpg/lisp/iterate/iterate.lisp2012-01-05 13:38:20.000000000 -0600 +++ /Users/rpg/lisp/vendor/iterate/iterate.lisp2012-01-04 19:34:52.000000000 -0600 &lt; at &gt;&lt; at &gt; -2078,8 +2078,6 &lt; at &gt;&lt; at &gt; (defun free-vars (form bound-vars) nil) ((symbolp (car form)) (cond - ((macro-function (car form) *env*) - (free-vars (macroexpand-1 form *env*) bound-vars)) ((or (special-operator-p (car form)) ;; Lucid doesn't think that these are special forms ;; and we need to handle declarations: &lt; at &gt;&lt; at &gt; -2121,6 +2119,8 &lt; at &gt;&lt; at &gt; (defun free-vars (form bound-vars) (nconc free-vars (free-vars-list body bound-vars)))) (otherwise nil))) + ((macro-function (car form) *env*) + (free-vars (macroexpand-1 form *env*) bound-vars)) (t ; function call (free-vars-list (cdr form) bound-vars)))) ((and (consp (car form)) (eq (caar form) 'lambda)) </pre> Robert Goldman 2012-01-05T21:10:49 http://comments.gmane.org/gmane.lisp.iterate.devel/171 <pre>I find that ACL 8.2 gets 4 failed tests on the latest iterate from darcs: 4 out of 261 total tests failed: ITERATE.TEST::CODE-MOVEMENT.ELSE, ITERATE.TEST::CODE-MOVEMENT.FINALLY, ITERATE.TEST::CODE-MOVEMENT.FINALLY-PROTECTED, ITERATE.TEST::BUG/WALK.2. where SBCL seems to get only 1. I say "seems to," since the call to ASDF:TEST-SYSTEM does not print gracefully in SBCL, probably because of the compiler being chatty: 1 out of 261 total tests failed: ITERATE.TEST::BUG/WALK.2. For CODE-MOVEMENT.ELSE, I see a problem on ACL -- the function local-binding-check does not raise an error on ACL, although it *IS* invoked. The bug seems to further be localized to the fact that the following returns NIL on ACL: (free-variables form) looking further, this suggests that something goes wrong in the code-walker in FREE-VARS. Looking further, I think I have identified the divergence --- in ACL, CL:RETURN is a special-operator, and in SBCL, it is not: Allegro: CL-USER&gt; (special-operator-p 'return) #&lt;special operator RETURN &lt; at &gt; #x1000054c32&gt; SBCL: CL-USER&gt; (special-operator-p 'return) NIL I believe the appropriate fix is to include RETURN in the first list of special symbols in the case statement. This will be benign for SBCL (it won't visit that, since RETURN is not a special-operator), but should fix things for ACL. Making that change, I see that now both ACL and SBCL have only one test failure. Best, r </pre> Robert Goldman 2012-01-05T02:22:11 http://comments.gmane.org/gmane.lisp.iterate.devel/170 <pre>It seems that the problems were due to a version mismatch. Darcs 2.2 on my Mac OS X box was unable to fetch the darcs repo for iterate. Darcs 2.5 was. Oddly Darcs 2.2 on Linux was able to fetch it.... Cheers, r </pre> Robert Goldman 2012-01-05T01:40:21 http://comments.gmane.org/gmane.lisp.iterate.devel/173 <pre>Steve Haflich from Franz kindly clarified to me my misunderstanding of special-operators and macros. In particular, he pointed out to me that implementations are free to implement special operators as macros. Steve writes: "I assure you that the set of special operators in ACL is _fixed+, and that there is way for you, the _user_, to extend that set. But this requirement of the ANS does not require that the set of cl-package symbols that return true under spcial-operator-p is not larger than the required operators in the table you quoted from http://www.franz.com/support/documentation/current/ansicl/subsubsu/specialf.htm Now see here: http://www.franz.com/support/documentation/current/ansicl/subsubsu/macrofor.htm specifically An implementation is free to implement a Common Lisp special operator as a macro. An implementation is free to implement any macro operator as a special operator, but only if an equivalent definition of the macro is also provided." He goes on to explain how this works in ACL: "In ACL user(31): (macro-function 'return) #&lt;Function macroexpand-1-transform&gt; so cl:return names _both_ a special operator and a macro. In our opinion, this is explicitly recognized by the ANS. (I think I remember being there when we of X3J13 voted this issue, but I also think I think I sometimes remember things that never occurred. Your mileage may vary.) Unfortunately, this seemingly innocent divergence from the standard breaks the code walker in ITERATE (and may break other code walkers, as well). I haven't examined this particular code walker, but I speculate that it is checking special-operator-p _before_ checking macro-function. A _portable_ walker should give the latter priority, which is what Franz believes the "implementation is free" codicil intends." Steve's understanding of the code walker in FREE-VARS is correct. Actually, over and above this, there seems to be a second bug in the code-walker: the check of (MACRO-FUNCTION (CAR FORM)) is not inside the branch for (SYMBOLP (CAR FORM)). So I believe that fixing this bug is not just a matter of pandering to ACL users, but actually a matter of fixing an incorrect code walker that could cause problems for arbitrary lisp implementations. I have attempted to fix this bug by moving the branch for MACRO-FUNCTION into the branch for SYMBOLP (CAR FORM) and moving it up before the check for SPECIAL-OPERATOR-P. See attached patch. I'd be obliged if you could review it for incorporation. It reduces the number of test failures in Allegro CL to the same as the number for SBCL: one. Best, R --- /Users/rpg/lisp/iterate/iterate.lisp2012-01-05 13:38:20.000000000 -0600 +++ /Users/rpg/lisp/vendor/iterate/iterate.lisp2012-01-04 19:34:52.000000000 -0600 &lt; at &gt;&lt; at &gt; -2078,8 +2078,6 &lt; at &gt;&lt; at &gt; (defun free-vars (form bound-vars) nil) ((symbolp (car form)) (cond - ((macro-function (car form) *env*) - (free-vars (macroexpand-1 form *env*) bound-vars)) ((or (special-operator-p (car form)) ;; Lucid doesn't think that these are special forms ;; and we need to handle declarations: &lt; at &gt;&lt; at &gt; -2121,6 +2119,8 &lt; at &gt;&lt; at &gt; (defun free-vars (form bound-vars) (nconc free-vars (free-vars-list body bound-vars)))) (otherwise nil))) + ((macro-function (car form) *env*) + (free-vars (macroexpand-1 form *env*) bound-vars)) (t ; function call (free-vars-list (cdr form) bound-vars)))) ((and (consp (car form)) (eq (caar form) 'lambda)) </pre> Robert Goldman 2012-01-05T21:10:49 http://comments.gmane.org/gmane.lisp.iterate.devel/171 <pre>I find that ACL 8.2 gets 4 failed tests on the latest iterate from darcs: 4 out of 261 total tests failed: ITERATE.TEST::CODE-MOVEMENT.ELSE, ITERATE.TEST::CODE-MOVEMENT.FINALLY, ITERATE.TEST::CODE-MOVEMENT.FINALLY-PROTECTED, ITERATE.TEST::BUG/WALK.2. where SBCL seems to get only 1. I say "seems to," since the call to ASDF:TEST-SYSTEM does not print gracefully in SBCL, probably because of the compiler being chatty: 1 out of 261 total tests failed: ITERATE.TEST::BUG/WALK.2. For CODE-MOVEMENT.ELSE, I see a problem on ACL -- the function local-binding-check does not raise an error on ACL, although it *IS* invoked. The bug seems to further be localized to the fact that the following returns NIL on ACL: (free-variables form) looking further, this suggests that something goes wrong in the code-walker in FREE-VARS. Looking further, I think I have identified the divergence --- in ACL, CL:RETURN is a special-operator, and in SBCL, it is not: Allegro: CL-USER&gt; (special-operator-p 'return) #&lt;special operator RETURN &lt; at &gt; #x1000054c32&gt; SBCL: CL-USER&gt; (special-operator-p 'return) NIL I believe the appropriate fix is to include RETURN in the first list of special symbols in the case statement. This will be benign for SBCL (it won't visit that, since RETURN is not a special-operator), but should fix things for ACL. Making that change, I see that now both ACL and SBCL have only one test failure. Best, r </pre> Robert Goldman 2012-01-05T02:22:11 http://comments.gmane.org/gmane.lisp.iterate.devel/170 <pre>It seems that the problems were due to a version mismatch. Darcs 2.2 on my Mac OS X box was unable to fetch the darcs repo for iterate. Darcs 2.5 was. Oddly Darcs 2.2 on Linux was able to fetch it.... Cheers, r </pre> Robert Goldman 2012-01-05T01:40:21 http://comments.gmane.org/gmane.lisp.iterate.devel/173 <pre>Steve Haflich from Franz kindly clarified to me my misunderstanding of special-operators and macros. In particular, he pointed out to me that implementations are free to implement special operators as macros. Steve writes: "I assure you that the set of special operators in ACL is _fixed+, and that there is way for you, the _user_, to extend that set. But this requirement of the ANS does not require that the set of cl-package symbols that return true under spcial-operator-p is not larger than the required operators in the table you quoted from http://www.franz.com/support/documentation/current/ansicl/subsubsu/specialf.htm Now see here: http://www.franz.com/support/documentation/current/ansicl/subsubsu/macrofor.htm specifically An implementation is free to implement a Common Lisp special operator as a macro. An implementation is free to implement any macro operator as a special operator, but only if an equivalent definition of the macro is also provided." He goes on to explain how this works in ACL: "In ACL user(31): (macro-function 'return) #&lt;Function macroexpand-1-transform&gt; so cl:return names _both_ a special operator and a macro. In our opinion, this is explicitly recognized by the ANS. (I think I remember being there when we of X3J13 voted this issue, but I also think I think I sometimes remember things that never occurred. Your mileage may vary.) Unfortunately, this seemingly innocent divergence from the standard breaks the code walker in ITERATE (and may break other code walkers, as well). I haven't examined this particular code walker, but I speculate that it is checking special-operator-p _before_ checking macro-function. A _portable_ walker should give the latter priority, which is what Franz believes the "implementation is free" codicil intends." Steve's understanding of the code walker in FREE-VARS is correct. Actually, over and above this, there seems to be a second bug in the code-walker: the check of (MACRO-FUNCTION (CAR FORM)) is not inside the branch for (SYMBOLP (CAR FORM)). So I believe that fixing this bug is not just a matter of pandering to ACL users, but actually a matter of fixing an incorrect code walker that could cause problems for arbitrary lisp implementations. I have attempted to fix this bug by moving the branch for MACRO-FUNCTION into the branch for SYMBOLP (CAR FORM) and moving it up before the check for SPECIAL-OPERATOR-P. See attached patch. I'd be obliged if you could review it for incorporation. It reduces the number of test failures in Allegro CL to the same as the number for SBCL: one. Best, R --- /Users/rpg/lisp/iterate/iterate.lisp2012-01-05 13:38:20.000000000 -0600 +++ /Users/rpg/lisp/vendor/iterate/iterate.lisp2012-01-04 19:34:52.000000000 -0600 &lt; at &gt;&lt; at &gt; -2078,8 +2078,6 &lt; at &gt;&lt; at &gt; (defun free-vars (form bound-vars) nil) ((symbolp (car form)) (cond - ((macro-function (car form) *env*) - (free-vars (macroexpand-1 form *env*) bound-vars)) ((or (special-operator-p (car form)) ;; Lucid doesn't think that these are special forms ;; and we need to handle declarations: &lt; at &gt;&lt; at &gt; -2121,6 +2119,8 &lt; at &gt;&lt; at &gt; (defun free-vars (form bound-vars) (nconc free-vars (free-vars-list body bound-vars)))) (otherwise nil))) + ((macro-function (car form) *env*) + (free-vars (macroexpand-1 form *env*) bound-vars)) (t ; function call (free-vars-list (cdr form) bound-vars)))) ((and (consp (car form)) (eq (caar form) 'lambda)) </pre> Robert Goldman 2012-01-05T21:10:49 http://comments.gmane.org/gmane.lisp.iterate.devel/171 <pre>I find that ACL 8.2 gets 4 failed tests on the latest iterate from darcs: 4 out of 261 total tests failed: ITERATE.TEST::CODE-MOVEMENT.ELSE, ITERATE.TEST::CODE-MOVEMENT.FINALLY, ITERATE.TEST::CODE-MOVEMENT.FINALLY-PROTECTED, ITERATE.TEST::BUG/WALK.2. where SBCL seems to get only 1. I say "seems to," since the call to ASDF:TEST-SYSTEM does not print gracefully in SBCL, probably because of the compiler being chatty: 1 out of 261 total tests failed: ITERATE.TEST::BUG/WALK.2. For CODE-MOVEMENT.ELSE, I see a problem on ACL -- the function local-binding-check does not raise an error on ACL, although it *IS* invoked. The bug seems to further be localized to the fact that the following returns NIL on ACL: (free-variables form) looking further, this suggests that something goes wrong in the code-walker in FREE-VARS. Looking further, I think I have identified the divergence --- in ACL, CL:RETURN is a special-operator, and in SBCL, it is not: Allegro: CL-USER&gt; (special-operator-p 'return) #&lt;special operator RETURN &lt; at &gt; #x1000054c32&gt; SBCL: CL-USER&gt; (special-operator-p 'return) NIL I believe the appropriate fix is to include RETURN in the first list of special symbols in the case statement. This will be benign for SBCL (it won't visit that, since RETURN is not a special-operator), but should fix things for ACL. Making that change, I see that now both ACL and SBCL have only one test failure. Best, r </pre> Robert Goldman 2012-01-05T02:22:11 http://comments.gmane.org/gmane.lisp.iterate.devel/170 <pre>It seems that the problems were due to a version mismatch. Darcs 2.2 on my Mac OS X box was unable to fetch the darcs repo for iterate. Darcs 2.5 was. Oddly Darcs 2.2 on Linux was able to fetch it.... Cheers, r </pre> Robert Goldman 2012-01-05T01:40:21 http://comments.gmane.org/gmane.lisp.iterate.devel/168 <pre>Although I have a common-lisp.net account, I find that I cannot clone the darcs repository: darcs get rgoldman&lt; at &gt;common-lisp.net:/project/iterate/darcs/iterate Invalid repository: rgoldman&lt; at &gt;common-lisp.net:/project/iterate/darcs/iterate darcs failed: (scp) failed to fetch: rgoldman&lt; at &gt;common-lisp.net:/project/iterate/darcs/iterate/_darcs/inventory Any idea what I'm doing wrong? Is there some anonymous way to clone this repository for people who don't have cl.net accounts? best, r </pre> Robert Goldman 2012-01-03T16:40:13 http://comments.gmane.org/gmane.lisp.iterate.devel/167 <pre>Hello. I am running iterate tests (between other often-used CL libraries) on different Lisps. The results of continuous testing may be found here: http://common-lisp.net/project/cl-test-grid/pivot_ql-lib_lisp.html. Currently Iterate has the same failure on all the lisps: Test ITERATE.TEST::BUG/WALK.2 failed Form: (ITERATE:ITER (RETURN (IF (ODDP 1) (PROGN) 'ITERATE.TEST::EVEN))) Expected value: NIL Actual value: ITERATE.TEST::EVEN. Best regards, - Anton </pre> Anton Vodonosov 2011-12-28T22:02:10 http://comments.gmane.org/gmane.lisp.iterate.devel/166 <pre>Hi, The Scieneer CL and ACL have non-standard versions or modes in which the standard symbols are lower case and this can be accommodated with some minor changes. Regards Douglas Crosher diff -rc iterate-20111001-darcs/iterate.lisp ../iterate-20111001-darcs/iterate.lisp *** iterate-20111001-darcs/iterate.lisp2011-10-02 01:17:06.000000000 +1000 --- ../iterate-20111001-darcs/iterate.lisp2011-11-01 22:41:34.000000000 +1100 *************** *** 2324,2342 **** (setf (cdr entry) doc-string)) symbol)) ! ;;; (INITIALLY &amp;rest) (def-special-clause initially (&amp;rest forms) "Lisp forms to execute before loop starts" (mapc #'local-binding-check forms) (return-code :initial (copy-list forms))) ! ;;; (AFTER-EACH &amp;rest) (def-special-clause after-each (&amp;rest forms) "Lisp forms to execute after each iteration" (mapc #'local-binding-check forms) (return-code :step (walk-list forms))) ! ;;; (ELSE &amp;rest) (def-special-clause else (&amp;rest forms) "Lisp forms to execute if the loop is never entered" (mapc #'local-binding-check forms) --- 2324,2342 ---- (setf (cdr entry) doc-string)) symbol)) ! ;;; (initially &amp;rest) (def-special-clause initially (&amp;rest forms) "Lisp forms to execute before loop starts" (mapc #'local-binding-check forms) (return-code :initial (copy-list forms))) ! ;;; (after-each &amp;rest) (def-special-clause after-each (&amp;rest forms) "Lisp forms to execute after each iteration" (mapc #'local-binding-check forms) (return-code :step (walk-list forms))) ! ;;; (else &amp;rest) (def-special-clause else (&amp;rest forms) "Lisp forms to execute if the loop is never entered" (mapc #'local-binding-check forms) *************** *** 2345,2376 **** .,(walk-list forms))) :body (list `(setq ,flag nil))))) ! ;;; (FINALLY &amp;rest) (def-special-clause finally (&amp;rest forms) "Lisp forms to execute after loop ends" (mapc #'local-binding-check forms) (return-code :final (copy-list forms))) ! ;;; (FINALLY-PROTECTED &amp;rest) (def-special-clause finally-protected (&amp;rest forms) ! "Lisp forms in an UNWIND-PROTECT after loop ends" (mapc #'local-binding-check forms) (return-code :final-protected (copy-list forms))) ! ;;; (IF-FIRST-TIME then &amp;optional else) (def-special-clause if-first-time (then &amp;optional else) "Evaluate branch depending on whether this clause if met for the first time" (return-code :body (list (if-1st-time (list (walk-expr then)) (if else (list (walk-expr else))))))) ! ;;; (FIRST-TIME-P) ! (def-special-clause FIRST-TIME-P () "True when evaluated for the first time" (return-code :body (list (if-1st-time '(t))))) ! ;;; (FIRST-ITERATION-P) ! (def-special-clause FIRST-ITERATION-P () "True within first iteration through the body" ;; Like (with ,var = t) (after-each (setq ,var nil)) ;; except all these clauses shares a single binding. --- 2345,2376 ---- .,(walk-list forms))) :body (list `(setq ,flag nil))))) ! ;;; (finally &amp;rest) (def-special-clause finally (&amp;rest forms) "Lisp forms to execute after loop ends" (mapc #'local-binding-check forms) (return-code :final (copy-list forms))) ! ;;; (finally-protected &amp;rest) (def-special-clause finally-protected (&amp;rest forms) ! "Lisp forms in an 'unwind-protect after loop ends" (mapc #'local-binding-check forms) (return-code :final-protected (copy-list forms))) ! ;;; (if-first-time then &amp;optional else) (def-special-clause if-first-time (then &amp;optional else) "Evaluate branch depending on whether this clause if met for the first time" (return-code :body (list (if-1st-time (list (walk-expr then)) (if else (list (walk-expr else))))))) ! ;;; (first-time-p) ! (def-special-clause first-time-p () "True when evaluated for the first time" (return-code :body (list (if-1st-time '(t))))) ! ;;; (first-iteration-p) ! (def-special-clause first-iteration-p () "True within first iteration through the body" ;; Like (with ,var = t) (after-each (setq ,var nil)) ;; except all these clauses shares a single binding. *************** *** 2384,2390 **** (return-code :body `(,var) :step step-body))) ! ;;; (IN &amp;body) (def-special-clause in (block-name &amp;rest forms) "Process forms in a named Iterate block" ;; VALUE: depends on forms --- 2384,2390 ---- (return-code :body `(,var) :step step-body))) ! ;;; (in &amp;body) (def-special-clause in (block-name &amp;rest forms) "Process forms in a named Iterate block" ;; VALUE: depends on forms *************** *** 2392,2398 **** (walk-list forms) `((in ,block-name ,.(copy-list forms))))) ! ;;; (NEXT var) (def-special-clause next (var &amp;optional (n 1)) "Explicitly step a driver variable" ;; VALUE: var, after stepping. --- 2392,2398 ---- (walk-list forms) `((in ,block-name ,.(copy-list forms))))) ! ;;; (next var) (def-special-clause next (var &amp;optional (n 1)) "Explicitly step a driver variable" ;; VALUE: var, after stepping. *************** *** 2596,2609 **** ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Hash-table, Packages and Streams ! ;;; (FOR IN-HASHTABLE) (defclause-driver (for key-val-vars in-hashtable table) "Elements and keys of a hashtable" (top-level-check) (unless (consp key-val-vars) (clause-error "~a should be a list of up to two variables: the first ~ for the keys, the second for the values." key-val-vars)) ! (let* ((iterator (gensym "HASH-TABLE-ITERATOR-")) (more? (gensym)) (var-spec `(values ,more? .,key-val-vars)) (setqs (do-dsetq var-spec `(,iterator))) --- 2596,2609 ---- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Hash-table, Packages and Streams ! ;;; (for in-hashtable) (defclause-driver (for key-val-vars in-hashtable table) "Elements and keys of a hashtable" (top-level-check) (unless (consp key-val-vars) (clause-error "~a should be a list of up to two variables: the first ~ for the keys, the second for the values." key-val-vars)) ! (let* ((iterator (gensym (symbol-name '#:hash-table-iterator-))) (more? (gensym)) (var-spec `(values ,more? .,key-val-vars)) (setqs (do-dsetq var-spec `(,iterator))) *************** *** 2614,2620 **** (return-driver-code :next (list setqs test) :variable var-spec))) ! ;;; (FOR IN-PACKAGES &amp;optional HAVING-ACCESS) (defclause-driver (for sym-access-pkg-vars in-packages pkgs &amp;optional having-access (sym-types '(:external :internal :inherited))) "Symbols and their access-types in packages" ;;defclause-driver has the benefit over defmacro-driver of less code walking --- 2614,2620 ---- (return-driver-code :next (list setqs test) :variable var-spec))) ! ;;; (for in-packages &amp;optional having-access) (defclause-driver (for sym-access-pkg-vars in-packages pkgs &amp;optional having-access (sym-types '(:external :internal :inherited))) "Symbols and their access-types in packages" ;;defclause-driver has the benefit over defmacro-driver of less code walking *************** *** 2626,2632 **** (unless (consp sym-types) (clause-error "~s should be a list of symbols indicating the symbols' ~ access types." sym-types)) ! (let* ((iterator (gensym "PACKAGE-ITERATOR-")) (more? (gensym)) (var-spec `(values ,more? .,sym-access-pkg-vars)) (setqs (do-dsetq var-spec `(,iterator))) --- 2626,2632 ---- (unless (consp sym-types) (clause-error "~s should be a list of symbols indicating the symbols' ~ access types." sym-types)) ! (let* ((iterator (gensym (symbol-name '#:package-iterator-))) (more? (gensym)) (var-spec `(values ,more? .,sym-access-pkg-vars)) (setqs (do-dsetq var-spec `(,iterator))) *************** *** 2636,2654 **** (return-driver-code :next (list setqs test) :variable var-spec))) ! ;;; (FOR IN-PACKAGE &amp;optional EXTERNAL-ONLY) (defmacro-driver (for var in-package pkg &amp;optional external-only (ext nil)) "Symbols accessible in a package" `(,(if generate 'generate 'for) (,var) in-packages ,pkg having-access ,(if ext '(:external) '(:external :internal :inherited)))) ! ;;; (FOR IN-FILE &amp;optional USING) (defclause-driver (for var in-file filename &amp;optional using (reader '#'read)) "Forms in a file" (top-level-check) (return-stream-driver-code var filename reader :file generate)) ! ;;; (FOR IN-STREAM &amp;optional USING) (defclause-driver (for var in-stream stream &amp;optional using (reader '#'read)) "Forms in a stream (which will be closed at the end)" (top-level-check) --- 2636,2654 ---- (return-driver-code :next (list setqs test) :variable var-spec))) ! ;;; (for in-package &amp;optional external-only) (defmacro-driver (for var in-package pkg &amp;optional external-only (ext nil)) "Symbols accessible in a package" `(,(if generate 'generate 'for) (,var) in-packages ,pkg having-access ,(if ext '(:external) '(:external :internal :inherited)))) ! ;;; (for in-file &amp;optional using) (defclause-driver (for var in-file filename &amp;optional using (reader '#'read)) "Forms in a file" (top-level-check) (return-stream-driver-code var filename reader :file generate)) ! ;;; (for in-stream &amp;optional using) (defclause-driver (for var in-stream stream &amp;optional using (reader '#'read)) "Forms in a stream (which will be closed at the end)" (top-level-check) *************** *** 2685,2697 **** :variable var))) ! ;;; (FOR NEXT) (defclause-driver (for var next next) "General driver; VAR is set to value of NEXT" (return-driver-code :variable var :next (list (do-dsetq var (walk-expr next))))) ! ;;; (FOR DO-NEXT) (defclause-driver (for var do-next next) "General driver; VAR must be set in DO-NEXT" (do-dsetq var '(list)) ; for effect only, to make var known --- 2685,2697 ---- :variable var))) ! ;;; (for next) (defclause-driver (for var next next) "General driver; VAR is set to value of NEXT" (return-driver-code :variable var :next (list (do-dsetq var (walk-expr next))))) ! ;;; (for do-next) (defclause-driver (for var do-next next) "General driver; VAR must be set in DO-NEXT" (do-dsetq var '(list)) ; for effect only, to make var known *************** *** 2821,2827 **** (defsynonym count counting) ! ;;; (COUNTING &amp;optional INTO) (defclause (counting expr &amp;optional into var) "Increment a variable if expression is non-nil" (return-reduction-code :identity 0 --- 2821,2827 ---- (defsynonym count counting) ! ;;; (counting &amp;optional into) (defclause (counting expr &amp;optional into var) "Increment a variable if expression is non-nil" (return-reduction-code :identity 0 *************** *** 2832,2838 **** :type 'fixnum :accum-kind :increment)) ! ;;; (SUM &amp;optional INTO) (defclause (sum expr &amp;optional into var) "Sum into a variable" (return-reduction-code :identity 0 --- 2832,2838 ---- :type 'fixnum :accum-kind :increment)) ! ;;; (sum &amp;optional into) (defclause (sum expr &amp;optional into var) "Sum into a variable" (return-reduction-code :identity 0 *************** *** 2845,2851 **** (defsynonym summing sum) ! ;;; (MULTIPLY &amp;optional INTO) (defclause (multiply expr &amp;optional into var) "Multiply into a variable" (return-reduction-code :identity 1 --- 2845,2851 ---- (defsynonym summing sum) ! ;;; (multiply &amp;optional into) (defclause (multiply expr &amp;optional into var) "Multiply into a variable" (return-reduction-code :identity 1 *************** *** 2859,2865 **** (defsynonym multiplying multiply) ! ;;; (REDUCING BY &amp;optional INITIAL-VALUE INTO) (defclause (reducing expr by op &amp;optional initial-value (init-val nil iv?) into var-spec) "Generalized reduction" --- 2859,2865 ---- (defsynonym multiplying multiply) ! ;;; (reducing by &amp;optional initial-value into) (defclause (reducing expr by op &amp;optional initial-value (init-val nil iv?) into var-spec) "Generalized reduction" *************** *** 2899,2912 **** ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Extrema. ! ;;; (MAXIMIZE &amp;optional INTO) (defclause (maximize expr &amp;optional into var) "Maximize value of an expression" (return-extremum-code expr var 'max)) (defsynonym maximizing maximize) ! ;;; (MINIMIZE &amp;optional INTO) (defclause (minimize expr &amp;optional into var) "Minimize value of an expression" (return-extremum-code expr var 'min)) --- 2899,2912 ---- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Extrema. ! ;;; (maximize &amp;optional into) (defclause (maximize expr &amp;optional into var) "Maximize value of an expression" (return-extremum-code expr var 'max)) (defsynonym maximizing maximize) ! ;;; (minimize &amp;optional into) (defclause (minimize expr &amp;optional into var) "Minimize value of an expression" (return-extremum-code expr var 'min)) *************** *** 2945,2979 **** ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Control flow. ! ;;; (FIMISH) (defmacro finish () "Leave the loop gracefully, executing the epilogue" (setq *loop-end-used?* t) `(go ,*loop-end*)) ! ;;; (TERMINATE) (defmacro terminate () ; recommended for use with FOR ... NEXT "Use within FOR ... DO-/NEXT clause to end the iteration" '(finish)) ! ;;; (NEXT-ITERATION) (defmacro next-iteration () "Begin the next iteration" (setq *loop-step-used?* t) `(go ,*loop-step*)) ! ;;; (LEAVE &amp;optional) (defmacro leave (&amp;optional value) "Exit the loop without running the epilogue code" `(return-from ,*block-name* ,value)) ! ;;; (WHILE) (defclause (while expr) "Exit loop if test is nil" (setq *loop-end-used?* t) (return-code :body `((if (not ,(walk-expr expr)) (go ,*loop-end*))))) ! ;;; (UNTIL) (defclause (until expr) "Exit loop if test is non-nil" (setq *loop-end-used?* t) --- 2945,2979 ---- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Control flow. ! ;;; (fimish) (defmacro finish () "Leave the loop gracefully, executing the epilogue" (setq *loop-end-used?* t) `(go ,*loop-end*)) ! ;;; (terminate) (defmacro terminate () ; recommended for use with FOR ... NEXT "Use within FOR ... DO-/NEXT clause to end the iteration" '(finish)) ! ;;; (next-iteration) (defmacro next-iteration () "Begin the next iteration" (setq *loop-step-used?* t) `(go ,*loop-step*)) ! ;;; (leave &amp;optional) (defmacro leave (&amp;optional value) "Exit the loop without running the epilogue code" `(return-from ,*block-name* ,value)) ! ;;; (while) (defclause (while expr) "Exit loop if test is nil" (setq *loop-end-used?* t) (return-code :body `((if (not ,(walk-expr expr)) (go ,*loop-end*))))) ! ;;; (until) (defclause (until expr) "Exit loop if test is non-nil" (setq *loop-end-used?* t) *************** *** 2986,2992 **** ;; Use same :if-exists kind of accumulation as finding ... such-that ;; so the clauses can be used together. ! ;;; (ALWAYS) (defclause (always expr) "Return last value iff expression is always non-nil" ;; VALUE: primary value of expr --- 2986,2992 ---- ;; Use same :if-exists kind of accumulation as finding ... such-that ;; so the clauses can be used together. ! ;;; (always) (defclause (always expr) "Return last value iff expression is always non-nil" ;; VALUE: primary value of expr *************** *** 2996,3002 **** (return-code :body `((or (setq ,var ,expr) (return-from ,*block-name* nil)))))) ! ;;; (NEVER) (defclause (never expr) "Return T iff expression is never non-nil" ;; VALUE: always nil --- 2996,3002 ---- (return-code :body `((or (setq ,var ,expr) (return-from ,*block-name* nil)))))) ! ;;; (never) (defclause (never expr) "Return T iff expression is never non-nil" ;; VALUE: always nil *************** *** 3007,3013 **** (return-code :body `((if ,expr (return-from ,*block-name* nil)))))) ! ;;; (THEREIS) (defclause (thereis expr) "Return value of expression as soon as it is non-nil" ;; VALUE: always nil --- 3007,3013 ---- (return-code :body `((if ,expr (return-from ,*block-name* nil)))))) ! ;;; (thereis) (defclause (thereis expr) "Return value of expression as soon as it is non-nil" ;; VALUE: always nil *************** *** 3020,3026 **** ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Finders. ! ;;; (FINDING SUCH-THAT &amp;optional INTO ON-FAILURE) (defclause (finding expr such-that test &amp;optional into var-spec on-failure fval) "Return expression when test is non-nil" --- 3020,3026 ---- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Finders. ! ;;; (finding such-that &amp;optional into on-failure) (defclause (finding expr such-that test &amp;optional into var-spec on-failure fval) "Return expression when test is non-nil" *************** *** 3037,3043 **** (return-code :body `((when ,(make-funcall test expr) (setq ,var ,expr) (go ,*loop-end*)))) ! (let ((temp-var (gensym "FINDING"))) (return-code :body `((let ((,temp-var ,expr)) (when ,(make-funcall test temp-var) (setq ,var ,temp-var) --- 3037,3043 ---- (return-code :body `((when ,(make-funcall test expr) (setq ,var ,expr) (go ,*loop-end*)))) ! (let ((temp-var (gensym (symbol-name '#:finding)))) (return-code :body `((let ((,temp-var ,expr)) (when ,(make-funcall test temp-var) (setq ,var ,temp-var) *************** *** 3046,3057 **** (setq ,var ,expr) (go ,*loop-end*))))))) ! ;;; (FINDING MAXIMIZING &amp;optional INTO) (defclause (finding expr maximizing max-expr &amp;optional into variable) "Return value which maximizes expression" (return-find-extremum-code expr max-expr variable :max)) ! ;;; (FINDING MINIMIZING &amp;optional INTO) (defclause (finding expr minimizing min-expr &amp;optional into variable) "Return value which minimizes expression" (return-find-extremum-code expr min-expr variable :min)) --- 3046,3057 ---- (setq ,var ,expr) (go ,*loop-end*))))))) ! ;;; (finding maximizing &amp;optional into) (defclause (finding expr maximizing max-expr &amp;optional into variable) "Return value which maximizes expression" (return-find-extremum-code expr max-expr variable :max)) ! ;;; (finding minimizing &amp;optional into) (defclause (finding expr minimizing min-expr &amp;optional into variable) "Return value which minimizes expression" (return-find-extremum-code expr min-expr variable :min)) *************** *** 3206,3212 **** (coerce ,collect-var ',result-type))))))))))) ! ;;; (COLLECT &amp;optional INTO AT RESULT-TYPE) (defclause (collect expr &amp;optional into var at (place 'end) result-type (type 'list)) "Collect into a list" --- 3206,3212 ---- (coerce ,collect-var ',result-type))))))))))) ! ;;; (collect &amp;optional into at result-type) (defclause (collect expr &amp;optional into var at (place 'end) result-type (type 'list)) "Collect into a list" *************** *** 3221,3227 **** (defsynonym collecting collect) ! ;;; (ADJOINING &amp;optional INTO AT TEST RESULT-TYPE) (defclause (adjoining expr &amp;optional into var at (place 'end) test (test '#'eql) --- 3221,3227 ---- (defsynonym collecting collect) ! ;;; (adjoining &amp;optional into at test result-type) (defclause (adjoining expr &amp;optional into var at (place 'end) test (test '#'eql) *************** *** 3255,3261 **** ! ;;; (NCONCING &amp;optional INTO AT) (defclause (nconcing expr &amp;optional into var at (place 'end)) "Nconc into a list" (return-collection-code --- 3255,3261 ---- ! ;;; (nconcing &amp;optional into at) (defclause (nconcing expr &amp;optional into var at (place 'end)) "Nconc into a list" (return-collection-code *************** *** 3265,3271 **** :place place :one-element nil)) ! ;;; (APPENDING &amp;optional INTO AT) (defclause (appending expr &amp;optional into var at (place 'end)) "Append into a list" (return-collection-code --- 3265,3271 ---- :place place :one-element nil)) ! ;;; (appending &amp;optional into at) (defclause (appending expr &amp;optional into var at (place 'end)) "Append into a list" (return-collection-code *************** *** 3276,3282 **** :place place :one-element nil)) ! ;;; (UNIONING &amp;optional INTO AT TEST) (defclause (unioning expr &amp;optional into var at (place 'end) test (test '#'eql)) "Union into a list" --- 3276,3282 ---- :place place :one-element nil)) ! ;;; (unioning &amp;optional into at test) (defclause (unioning expr &amp;optional into var at (place 'end) test (test '#'eql)) "Union into a list" *************** *** 3294,3300 **** :place place :one-element nil)) ! ;;; (NUNIONING &amp;optional INTO AT TEST) (defclause (nunioning expr &amp;optional into var at (place 'end) test (test '#'eql)) "Union into a list, destructively" --- 3294,3300 ---- :place place :one-element nil)) ! ;;; (nunioning &amp;optional into at test) (defclause (nunioning expr &amp;optional into var at (place 'end) test (test '#'eql)) "Union into a list, destructively" *************** *** 3313,3319 **** :one-element nil)) ! ;;; (ACCUMULATE BY &amp;optional INITIAL-VALUE INTO) (defclause (accumulate expr by op &amp;optional initial-value init-val into var-spec) "Generalized accumulation" --- 3313,3319 ---- :one-element nil)) ! ;;; (accumulate by &amp;optional initial-value into) (defclause (accumulate expr by op &amp;optional initial-value init-val into var-spec) "Generalized accumulation" *************** *** 3344,3350 **** ;;; the save code can go in the step portion of the loop; but if there is a ;;; generator, the best we can do is use a flag for the first time. ! ;;; (FOR PREVIOUS &amp;optional INITIALLY BACK) (defclause (for pvar previous var &amp;optional initially (default nil default?) back (n-expr 1)) "Previous value of a variable" --- 3344,3350 ---- ;;; the save code can go in the step portion of the loop; but if there is a ;;; generator, the best we can do is use a flag for the first time. ! ;;; (for previous &amp;optional initially back) (defclause (for pvar previous var &amp;optional initially (default nil default?) back (n-expr 1)) "Previous value of a variable" *************** *** 3401,3407 **** (defun make-save-vars (var n) (let ((list nil) ! (string (format nil "SAVE-~a-" var))) (dotimes (i n) (let ((svar (make-var-and-default-binding string :using-type-of var))) (push svar list))) --- 3401,3407 ---- (defun make-save-vars (var n) (let ((list nil) ! (string (format nil "~a-~a-" '#:save var))) (dotimes (i n) (let ((svar (make-var-and-default-binding string :using-type-of var))) (push svar list))) *************** *** 3474,3480 **** init-code)) (defun make-post-save-var (var) ! (make-var-and-default-binding (format nil "POST-SAVE-~a-" var) :using-type-of var)) --- 3474,3480 ---- init-code)) (defun make-post-save-var (var) ! (make-var-and-default-binding (format nil "~a-~a-" '#:post-save var) :using-type-of var)) *************** *** 3567,3573 **** (defvar *genvar-counter* 0) ! (defun genvar (&amp;optional (string "TEMP")) (prog1 (make-symbol (format nil "~a~d" string *genvar-counter*)) (incf *genvar-counter*))) --- 3567,3573 ---- (defvar *genvar-counter* 0) ! (defun genvar (&amp;optional (string (symbol-name '#:temp))) (prog1 (make-symbol (format nil "~a~d" string *genvar-counter*)) (incf *genvar-counter*))) Only in ../iterate-20111001-darcs/: iterate.lisp~ diff -rc iterate-20111001-darcs/iterate-test.lisp ../iterate-20111001-darcs/iterate-test.lisp *** iterate-20111001-darcs/iterate-test.lisp2011-10-02 01:17:06.000000000 +1000 --- ../iterate-20111001-darcs/iterate-test.lisp2011-11-01 22:48:16.000000000 +1100 *************** *** 346,357 **** (()())) (deftest in-packages.generator-access ! (let ((iter-syms (iterate (generate (sym access) in-packages (list (find-package "COMMON-LISP"))) (repeat 1) (next sym) (collect (list sym access))))) (equal (multiple-value-list ! (find-symbol (symbol-name (caar iter-syms)) "COMMON-LISP")) (car iter-syms))) t) --- 346,357 ---- (()())) (deftest in-packages.generator-access ! (let ((iter-syms (iterate (generate (sym access) in-packages (list (find-package :common-lisp))) (repeat 1) (next sym) (collect (list sym access))))) (equal (multiple-value-list ! (find-symbol (symbol-name (caar iter-syms)) :common-lisp)) (car iter-syms))) t) *************** *** 1494,1505 **** 14) (deftest defmacro-clause.1 ! (defmacro-clause (multiply.clause expr &amp;optional INTO var) "from testsuite" `(reducing ,expr by #'* into ,var initial-value 1)) ;; A better return value would be the exact list usable with remove-clause ;; The next version shall do that ! (multiply.clause expr &amp;optional INTO var)) (deftest multiply.clause (iter (for el in '(1 2 3 4)) --- 1494,1505 ---- 14) (deftest defmacro-clause.1 ! (defmacro-clause (multiply.clause expr &amp;optional into var) "from testsuite" `(reducing ,expr by #'* into ,var initial-value 1)) ;; A better return value would be the exact list usable with remove-clause ;; The next version shall do that ! (multiply.clause expr &amp;optional into var)) (deftest multiply.clause (iter (for el in '(1 2 3 4)) *************** *** 1507,1522 **** 24) (deftest remove-clause.1 ! (iter::remove-clause '(multiply.clause &amp;optional INTO)) t) (deftest remove-clause.2 (values (ignore-errors ! (iter::remove-clause '(multiply.clause &amp;optional INTO)))) nil) ! (iter:defmacro-clause (for var IN-WHOLE-VECTOR.clause v) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym "VECTOR")) (index (gensym "INDEX"))) --- 1507,1522 ---- 24) (deftest remove-clause.1 ! (iter::remove-clause '(multiply.clause &amp;optional into)) t) (deftest remove-clause.2 (values (ignore-errors ! (iter::remove-clause '(multiply.clause &amp;optional into)))) nil) ! (iter:defmacro-clause (for var in-whole-vector.clause v) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym "VECTOR")) (index (gensym "INDEX"))) *************** *** 1526,1532 **** (for ,var = (aref ,vect ,index))))) (deftest in-whole-vector.clause ! (iter (for i IN-WHOLE-VECTOR.clause (make-array 3 :fill-pointer 2 :initial-contents '(1 2 3))) (collect i)) (1 2 3)) --- 1526,1532 ---- (for ,var = (aref ,vect ,index))))) (deftest in-whole-vector.clause ! (iter (for i in-whole-vector.clause (make-array 3 :fill-pointer 2 :initial-contents '(1 2 3))) (collect i)) (1 2 3)) *************** *** 1537,1543 **** (collect i)) (1 2)) ! (iter:defmacro-driver (for var IN-WHOLE-VECTOR v) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym "VECTOR")) (end (gensym "END")) --- 1537,1543 ---- (collect i)) (1 2)) ! (iter:defmacro-driver (for var in-whole-vector v) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym "VECTOR")) (end (gensym "END")) *************** *** 1552,1571 **** (aref ,vect ,index)))))) (deftest in-whole-vector.driver ! (iter (for i IN-WHOLE-VECTOR (make-array '(3) :fill-pointer 2 :initial-contents '(1 2 3))) (collect i)) (1 2 3)) (deftest in-whole-vector.generate ! (iter (generating i IN-WHOLE-VECTOR (make-array '(3) :fill-pointer 2 :initial-contents '(1 2 3))) (collect (next i))) (1 2 3)) (deftest defclause-sequence (progn ! (iter:defclause-sequence IN-WHOLE-VECTOR.seq INDEX-OF-WHOLE-VECTOR :access-fn 'aref :size-fn '#'(lambda (v) (array-dimension v 0)) :sequence-type 'vector --- 1552,1571 ---- (aref ,vect ,index)))))) (deftest in-whole-vector.driver ! (iter (for i in-whole-vector (make-array '(3) :fill-pointer 2 :initial-contents '(1 2 3))) (collect i)) (1 2 3)) (deftest in-whole-vector.generate ! (iter (generating i in-whole-vector (make-array '(3) :fill-pointer 2 :initial-contents '(1 2 3))) (collect (next i))) (1 2 3)) (deftest defclause-sequence (progn ! (iter:defclause-sequence in-whole-vector.seq index-of-whole-vector :access-fn 'aref :size-fn '#'(lambda (v) (array-dimension v 0)) :sequence-type 'vector *************** *** 1578,1597 **** t) (deftest in-whole-vector.seq ! (iter (for i IN-WHOLE-VECTOR.seq (make-array '(3) :fill-pointer 2 :initial-contents '(1 2 3))) (collect i)) (1 2 3)) (deftest in-whole-vector.seq.index ! (iter (for i INDEX-OF-WHOLE-VECTOR (make-array 3 :fill-pointer 2 :initial-contents '(1 2 3))) (for j previous i :initially 9) (collect (list j i))) ((9 0)(0 1)(1 2))) (deftest in-whole-vector.seq.with-index ! (iter (for e IN-WHOLE-VECTOR.seq (make-array '(3) :fill-pointer 2 :initial-contents '(a b c)) :with-index i) (for j previous i :initially 9) --- 1578,1597 ---- t) (deftest in-whole-vector.seq ! (iter (for i in-whole-vector.seq (make-array '(3) :fill-pointer 2 :initial-contents '(1 2 3))) (collect i)) (1 2 3)) (deftest in-whole-vector.seq.index ! (iter (for i index-of-whole-vector (make-array 3 :fill-pointer 2 :initial-contents '(1 2 3))) (for j previous i :initially 9) (collect (list j i))) ((9 0)(0 1)(1 2))) (deftest in-whole-vector.seq.with-index ! (iter (for e in-whole-vector.seq (make-array '(3) :fill-pointer 2 :initial-contents '(a b c)) :with-index i) (for j previous i :initially 9) *************** *** 1599,1605 **** ((9 0 a)(0 1 b)(1 2 c))) (deftest in-whole-vector.seq.generate ! (iter (generate e IN-WHOLE-VECTOR.seq (make-array 3 :fill-pointer 2 :initial-contents '(a b c)) :with-index i) (collect (list (next e) e i))) --- 1599,1605 ---- ((9 0 a)(0 1 b)(1 2 c))) (deftest in-whole-vector.seq.generate ! (iter (generate e in-whole-vector.seq (make-array 3 :fill-pointer 2 :initial-contents '(a b c)) :with-index i) (collect (list (next e) e i))) *************** *** 1612,1618 **** ;; - Do not use (finally (RETURN ,winner)) either, as that would ;; always return accumulated value, even in case of ... INTO nil. (deftest defmacro-clause.2 ! (defmacro-clause (FINDING expr MAXING func &amp;optional INTO var) "Iterate paper demo example" (let ((max-val (gensym "MAX-VAL")) (temp1 (gensym "EL")) --- 1612,1618 ---- ;; - Do not use (finally (RETURN ,winner)) either, as that would ;; always return accumulated value, even in case of ... INTO nil. (deftest defmacro-clause.2 ! (defmacro-clause (finding expr maxing func &amp;optional into var) "Iterate paper demo example" (let ((max-val (gensym "MAX-VAL")) (temp1 (gensym "EL")) *************** *** 1626,1632 **** (when (or (null ,max-val) (&gt; ,temp2 ,max-val)) (setq ,winner ,temp1 ,max-val ,temp2))) #|(finally (return ,winner))|# ))) ! (FINDING expr MAXING func &amp;optional INTO var)) (deftest maxing.1 (iter (for i in-vector #(1 5 3)) --- 1626,1632 ---- (when (or (null ,max-val) (&gt; ,temp2 ,max-val)) (setq ,winner ,temp1 ,max-val ,temp2))) #|(finally (return ,winner))|# ))) ! (finding expr maxing func &amp;optional into var)) (deftest maxing.1 (iter (for i in-vector #(1 5 3)) Only in ../iterate-20111001-darcs/: iterate-test.lisp~ </pre> Douglas Crosher 2011-11-02T04:30:22 http://comments.gmane.org/gmane.lisp.iterate.devel/165 <pre>Using something like (for old-val = (atomic-decf ...)) in SBCL gives a warning that (sb-ext:truly-the ...) isn't known. So perhaps there should be a #+sbcl (sb-ext:truly-the . walk-cddr) just below the "the" handling case. I've reported that as https://bugs.launchpad.net/sbcl/+bug/771673, too. Regards, Phil </pre> Philipp Marek 2011-04-27T10:41:39 http://comments.gmane.org/gmane.lisp.iterate.devel/158 <pre>Hi, I was trying to roll an iterate driver for iterating over dates and I am stuck with a problem. When using defmacro-driver, I am unable to get the value passed in from to and other sequence classes. I tried with the example given in the manual (chapter "Rolling your own"), but hit the same problem. The manual says: "We can now refer to parameters from, to, by, etc. which contain either the values for the corresponding keyword, or nil if the keyword was not supplied. Implementing the right code for these keywords is cumbersome but not difficult; it is left as an exercise." But I guess I am one of the dumb few who failed the exercise :)) The following is my attempt with the example given in the manual: (defmacro-driver (FOR var IN-WHOLE-VECTOR v &amp;sequence) "All the elements of a vector (disregards fill-pointer)" (let ((vect (gensym)) (end (gensym)) (index (gensym)) (myfrm (gensym "myfrm")) (kwd (if generate 'generate 'for))) `(progn (with ,vect = ,v) (with ,myfrm = ,from) (with ,end = (array-dimension ,vect 0)) (with ,index = -1) (,kwd ,var next (progn (incf ,index) (if (&gt;= ,index ,end) (terminate)) (format t "myfrm: ~a~%" ,myfrm) (aref ,vect ,index)))))) I tried using the driver with: (a is an array of 10 elements) (iter (for v in-whole-vector a from 5 below 8) (print v)) I get the following error: The variable FROM is unbound. [Condition of type UNBOUND-VARIABLE] Restarts: 0: [RETRY] Retry SLIME REPL evaluation request. 1: [*ABORT] Return to SLIME's top level. 2: [ABORT] Exit debugger, returning to top level. Backtrace: 0: ((DEFMACRO CLAUSE-FOR-IN-WHOLE-VECTOR-18) (CLAUSE-FOR-IN-WHOLE-VECTOR-18 :FOR V :IN-WHOLE-VECTOR A :FROM ...) #&lt;unused argument&gt;) 1: (MACROEXPAND-1 (CLAUSE-FOR-IN-WHOLE-VECTOR-18 :FOR V :IN-WHOLE-VECTOR A :FROM ...) #&lt;NULL-LEXENV&gt;) 2: (ITERATE::PROCESS-CLAUSE (FOR V IN-WHOLE-VECTOR A FROM 5 ...)) 3: (ITERATE::WALK (FOR V IN-WHOLE-VECTOR A FROM 5 ...)) 4: (ITERATE::WALK-LIST-NCONCING ((FOR V IN-WHOLE-VECTOR A FROM 5 ...) (PRINT V)) #&lt;FUNCTION ITERATE::WALK&gt; #&lt;FUNCTION (LAMBDA #) {100407D489}&gt;) 5: (ITERATE::WALK-LIST ((FOR V IN-WHOLE-VECTOR A FROM 5 ...) (PRINT V))) 6: ((DEFMACRO ITER) ..) I am using ubuntu maverick, 10.10, SBCL 1.0.45 64 bit. I tried the following: (with ,myfrm = from) I get an error: The variable FROM is unbound. [Condition of type UNBOUND-VARIABLE] Restarts: 0: [RETRY] Retry SLIME REPL evaluation request. 1: [*ABORT] Return to SLIME's top level. 2: [ABORT] Exit debugger, returning to top level. Backtrace: 0: ((LAMBDA ())) 1: (SB-INT:SIMPLE-EVAL-IN-LEXENV ..) 2: (SWANK::EVAL-REGION "(iter (for v in-whole-vector a from 5 below 8)\n (print v))\n") 3: ((LAMBDA ())) 2) (with ,myfrm = :from) This does not throw any error, but just prints myfrm: FROM instead of the value given I want to use defclause-driver with the sequence keywords, I could not figure out how to get the values passed in from, to and other such clauses. Can anyone please provide some pointers? </pre> Venkatesan S 2011-01-23T11:14:00 http://comments.gmane.org/gmane.lisp.iterate.devel/157 <pre></pre> Jonathan Johansen 2010-08-28T06:14:29 http://comments.gmane.org/gmane.lisp.iterate.devel/154 <pre></pre> Andrea Taverna 2010-08-15T12:58:44 Search the mailing list at Gmane query http://search.gmane.org/?group=$group=gmane.lisp.iterate.devel