Re: Gnus: Thread notes?

[Michael Heerdegen]

Eric Abrahamsen <eric@ericabrahamsen.net> writes:

> The idea with the registry is that it's sort of a catch-all slush
> bucket. I think it's expected that it will fill up rather quickly, and
> then get pruned as necessary.

FWIW, pruning now kicked in the first time, and it errored with

Debugger entered--Lisp error: (wrong-type-argument listp quote)
  car(quote)
  (memq (car entry-key) precious)
  (cdr (memq (car entry-key) precious))
  (lambda (entry-key) (cdr (memq (car entry-key) precious)))(quote)
  cl-some((lambda (entry-key) (cdr (memq (car entry-key) precious))) 
'''''''''''''''''''''''''''''''''''''''''''''''''''''''((creation-time (23012 
49774 793490 105000)) (group) (sender) (subject)))
  apply(cl-some (lambda (entry-key) (cdr (memq (car entry-key) precious))) 
'''''''''''''''''''''''''''''''''''''''''''''''''''''''((creation-time (23012 
49774 793490 105000)) (group) (sender) (subject)) nil)
  cl-notany((lambda (entry-key) (cdr (memq (car entry-key) precious))) 
'''''''''''''''''''''''''''''''''''''''''''''''''''''''((creation-time (23012 
49774 793490 105000)) (group) (sender) (subject)))
  (if (cl-notany precious-p v) (progn (setq #1=#:--cl-var-- (cons (cons k v) 
#1#))))
  (lambda (k v) (if (cl-notany precious-p v) (progn (setq #1=#:--cl-var-- (cons 
(cons k v) #1#)))))("" 
'''''''''''''''''''''''''''''''''''''''''''''''''''''''((creation-time (23012 
49774 793490 105000)) (group) (sender) (subject)))
  maphash((lambda (k v) (if (cl-notany precious-p v) (progn (setq 
#1=#:--cl-var-- (cons (cons k v) #1#))))) #<hash-table equal 25000/40000 
0x1bbf149>)
  (let* ((#1=#:--cl-var-- nil)) (maphash (function (lambda (k v) (if (cl-notany 
precious-p v) (progn (setq #1# (cons (cons k v) #1#)))))) data) (nreverse #1#))
  (let* ((precious (eieio-oref db 'precious)) (precious-p (function (lambda 
(entry-key) (cdr (memq (car entry-key) precious))))) (data (eieio-oref db 
'data)) (candidates (let* ((#1=#:--cl-var-- nil)) (maphash (function (lambda (k 
v) (if (cl-notany precious-p v) (progn (setq #1# (cons (cons k v) #1#)))))) 
data) (nreverse #1#)))) (if sortfunc (progn (setq candidates (sort candidates 
sortfunc)))) (cl-subseq (mapcar (function car) candidates) 0 (min limit (length 
candidates))))
  (progn (let* ((precious (eieio-oref db 'precious)) (precious-p (function 
(lambda (entry-key) (cdr (memq (car entry-key) precious))))) (data (eieio-oref 
db 'data)) (candidates (let* ((#1=#:--cl-var-- nil)) (maphash (function (lambda 
(k v) (if (cl-notany precious-p v) (progn (setq #1# (cons (cons k v) #1#)))))) 
data) (nreverse #1#)))) (if sortfunc (progn (setq candidates (sort candidates 
sortfunc)))) (cl-subseq (mapcar (function car) candidates) 0 (min limit (length 
candidates)))))
  (lambda (db limit sortfunc) "Collects pruning candidates from the registry-db 
object DB.\n\nProposes only entries without the :precious keys, and attempts 
to\nreturn LIMIT such candidates.  If SORTFUNC is provided, sort\nentries first 
and return candidates from beginning of list." (progn (let* ((precious 
(eieio-oref db 'precious)) (precious-p (function (lambda (entry-key) (cdr (memq 
(car entry-key) precious))))) (data (eieio-oref db 'data)) (candidates (let* 
((#1=#:--cl-var-- nil)) (maphash (function (lambda (k v) (if (cl-notany 
precious-p v) (progn (setq #1# (cons (cons k v) #1#)))))) data) (nreverse 
#1#)))) (if sortfunc (progn (setq candidates (sort candidates sortfunc)))) 
(cl-subseq (mapcar (function car) candidates) 0 (min limit (length 
candidates))))))(#<registry-db registry-db-195b804> 2500 
gnus-registry-sort-by-creation-time)
  apply((lambda (db limit sortfunc) "Collects pruning candidates from the 
registry-db object DB.\n\nProposes only entries without the :precious keys, and 
attempts to\nreturn LIMIT such candidates.  If SORTFUNC is provided, 
sort\nentries first and return candidates from beginning of list." (progn (let* 
((precious (eieio-oref db 'precious)) (precious-p (function (lambda (entry-key) 
(cdr (memq (car entry-key) precious))))) (data (eieio-oref db 'data)) 
(candidates (let* ((#1=#:--cl-var-- nil)) (maphash (function (lambda (k v) (if 
(cl-notany precious-p v) (progn (setq #1# (cons (cons k v) #1#)))))) data) 
(nreverse #1#)))) (if sortfunc (progn (setq candidates (sort candidates 
sortfunc)))) (cl-subseq (mapcar (function car) candidates) 0 (min limit (length 
candidates)))))) #<registry-db registry-db-195b804> (2500 
gnus-registry-sort-by-creation-time))
  registry-collect-prune-candidates(#<registry-db registry-db-195b804> 2500 
gnus-registry-sort-by-creation-time)
  (setq candidates (registry-collect-prune-candidates db (- size target-size) 
sortfunc))
  (progn (setq candidates (registry-collect-prune-candidates db (- size 
target-size) sortfunc)) (length (registry-delete db candidates nil)))
  (if (registry-full db) (progn (setq candidates 
(registry-collect-prune-candidates db (- size target-size) sortfunc)) (length 
(registry-delete db candidates nil))) 0)
  (let ((size (registry-size db)) (target-size (floor (- (eieio-oref db 
'max-size) (* (eieio-oref db 'max-size) (eieio-oref db 'prune-factor))))) 
candidates) (if (registry-full db) (progn (setq candidates 
(registry-collect-prune-candidates db (- size target-size) sortfunc)) (length 
(registry-delete db candidates nil))) 0))
  (progn (let ((size (registry-size db)) (target-size (floor (- (eieio-oref db 
'max-size) (* (eieio-oref db 'max-size) (eieio-oref db 'prune-factor))))) 
candidates) (if (registry-full db) (progn (setq candidates 
(registry-collect-prune-candidates db (- size target-size) sortfunc)) (length 
(registry-delete db candidates nil))) 0)))
  (lambda (db &optional sortfunc) "Prunes the registry-db object 
DB.\n\nAttempts to prune the number of entries down to (*\n:max-size 
:prune-factor) less than the max-size limit, so\npruning doesn't need to happen 
on every save. Removes only\nentries without the :precious keys, so it may not 
be possible to\nreach the target limit.\n\nEntries to be pruned are first 
sorted using SORTFUNC.  Entries\nfrom the front of the list are deleted 
first.\n\nReturns the number of deleted entries." (progn (let ((size 
(registry-size db)) (target-size (floor (- (eieio-oref db 'max-size) (* 
(eieio-oref db 'max-size) (eieio-oref db 'prune-factor))))) candidates) (if 
(registry-full db) (progn (setq candidates (registry-collect-prune-candidates 
db (- size target-size) sortfunc)) (length (registry-delete db candidates 
nil))) 0))))(#<registry-db registry-db-195b804> 
gnus-registry-sort-by-creation-time)
  apply((lambda (db &optional sortfunc) "Prunes the registry-db object 
DB.\n\nAttempts to prune the number of entries down to (*\n:max-size 
:prune-factor) less than the max-size limit, so\npruning doesn't need to happen 
on every save. Removes only\nentries without the :precious keys, so it may not 
be possible to\nreach the target limit.\n\nEntries to be pruned are first 
sorted using SORTFUNC.  Entries\nfrom the front of the list are deleted 
first.\n\nReturns the number of deleted entries." (progn (let ((size 
(registry-size db)) (target-size (floor (- (eieio-oref db 'max-size) (* 
(eieio-oref db 'max-size) (eieio-oref db 'prune-factor))))) candidates) (if 
(registry-full db) (progn (setq candidates (registry-collect-prune-candidates 
db (- size target-size) sortfunc)) (length (registry-delete db candidates 
nil))) 0)))) #<registry-db registry-db-195b804> 
gnus-registry-sort-by-creation-time)
  registry-prune(#<registry-db registry-db-195b804> 
gnus-registry-sort-by-creation-time)
  gnus-registry-save()
  run-hooks(gnus-save-newsrc-hook)
  apply(run-hooks gnus-save-newsrc-hook)
  gnus-run-hooks(gnus-save-newsrc-hook)
  gnus-save-newsrc-file()
  gnus-group-exit()
  funcall-interactively(gnus-group-exit)
  call-interactively(gnus-group-exit nil nil)
  command-execute(gnus-group-exit)

There seems to be an entry with a lot of quotes.  Any idea what could be
happening here?  An eieio related thing, maybe?  Where should I dig?


Thanks,

Michael.