pro July 2015

pro@common-lisp.net

19 participants
4 discussions

Do symbols need to be EQ?
by Edi Weitz 16 Aug '15

16 Aug '15

Just out of curiosity and without any relevance in practise: Is there one place in the standard where it is explicitly said that two symbols which are the "same" symbol must be "identical"? I know that there are a couple of examples where this is implied, but formally the examples aren't part of the standard, right? The EQ dictionary entry for example shows this example: (eq 'a 'a) => true and then it continues with this note (emphasis mine): "Symbols that print the same USUALLY are EQ to each other because of the use of the INTERN function." And the entry for INTERN is actually the closest I could find in terms of clarification because it says that if a symbol of a specified name is already accessible, _IT_ is returned -- which sounds like object identity to me. But how does this fit into the picture? CL-USER 1 > (defparameter *s* 'foo) *S* CL-USER 2 > (unintern 'foo) T CL-USER 3 > (defparameter *s2* 'foo) *S2* CL-USER 4 > (eq *s* *s2*) NIL *S* has lost its home package and is thus not EQ to *S2*, sure, but how do we explain this in terms of object identity? Has the UNINTERN operation changed the identity of *S* which once was the one and only CL-USER::FOO but can't be anymore because this role is now occupied by *S2*? Did I miss some clarifying words in the standard? Did I just manage to confuse myself? Thanks, Edi. PS: The UNINTERN entry warns about side effects which could harm consistency, so maybe this is what they meant?

12 24

Caching of effective methods in custom method combinations
by Edi Weitz 21 Jul '15

21 Jul '15

Hi everybody, Here's some behavior I see on SBCL as well as LispWorks, so I'm assuming for now they're right in doing so. My question would be why they are. I start with the following code which I compile and load: ;;;;;;;;;;;;;;;;;;;;;;;; (defvar *current-qualifiers* '(:a :b :c)) (define-method-combination test () ((methods *)) (let ((selected-methods (loop for method in methods when (intersection (method-qualifiers method) *current-qualifiers*) collect method))) `(call-method ,(first selected-methods) ,(rest selected-methods)))) (defgeneric foo (thing) (:method-combination test)) (defmethod foo :a (thing) '(:red)) (defmethod foo :b (thing) '(:blue)) ;;;;;;;;;;;;;;;;;;;;;;;;;; Now, in the REPL I do the following: CL-USER> (foo 42) (:BLUE) CL-USER> (setq *current-qualifiers* '(:a :c)) (:A :C) CL-USER> (foo 42) (:BLUE) I almost expected this. The effective method obviously isn't computed anew but was cached. But even if I now re-evaluate the DEFINE-METHOD-COMBINATION form, (FOO 42) will still return (:BLUE). Only if I re-evaluate the DEFGENERIC form will the return value change to (:RED). My question is if the standard somewhere allows this caching to happen. That would for example mean that any kind of "dynamic method combination" (for example based on the time of the day, just for grins) is impossible. Or am I missing something and my interpretation is wrong? Thanks, Edi.

3 4

Should GC hooks be used to help broken software?
by Elias Mårtenson 06 Jul '15

06 Jul '15

The following question was raised during my development of an asynchronous library <https://github.com/lokedhs/cl-rabbit-async> I'm currently building for RabbitMQ. In summary, the library allows you to create an object of type ASYNCH-CONNECTION, from which instances of ASYNC-CHANNEL can be retrieved. A connection holds a reference to all channels that it uses, and each channel holds a reference to its connection. The connection object has a pointer to a native CFFI object that for the underlying connection (my library is built on the RabbitMQ C API). My question is: Should I use trivial-garbage to create a GC hook for the connection object so that if the user of the library forgets to close the connection, it will get closed eventually once it's GC'ed? I can see arguments for both behaviours: - It's a bad idea, since losing the reference to the connection object means that the program is broken, and silently cleaning up the underlying connection might hide the fact there is a bug (if the GC doesn't run often enough I might have hundreds or even thousands of lingering connections) - On the other hand, it might be a good idea since Lisp developers often use the REPL to experiment, so it's easy to accidentally lose a reference to an object during testing. Thus, using the GC hook will improve the stability of one's development environment. To me, there is no strictly correct answer to the question, which is why I'm asking for suggestions from you guys. Regards, Elias (loke on #lisp)

6 9

cl-ppcre:split question
by Mark H. David 02 Jul '15

02 Jul '15

The examples for cl-ppcre:split here http://weitz.de/cl-ppcre/#split include this tempting recipe: (split "\\s+" "foo bar baz frob") => ("foo" "bar" "baz" "frob") However, (split "\\s+" " foo bar baz frob") => ("" "foo" "bar" "baz" "frob") I.e., the result list includes an empty string as the first element if there are one or more whitespace characters at the beginning of the string. How can I get rid of the empty string at the beginning? Is there a regexp match for this that would work with split? Thanks, Mark

2 1

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

pro July 2015