Hi Alex, > Most of all, a cell can be passed to functions that expect a variable > 'var' argument, like 'set', 'inc', 'pop', and many more. This is also > the reason for the property functions 'prop' and '::'. > > : (put 'A 'counter 0) > -> 0 > > : (put 'A 'list (1 2 3 4)) > -> (1 2 3 4) > > : (with 'A (inc (:: counter))) > -> 1 > > : (pop (prop 'A 'list)) > -> 1 > > : (show 'A) > A NIL > list (2 3 4) > counter 1 > -> A
Isn't it just because it was implemented this way? I mean these functions could be implemented to behave the same way even if getl returned a list of (property-name . property-value) which in this case would be: :(put 'A 'counter 0) -> 0 : (put 'A 'list (1 2 3 4)) -> (1 2 3 4) : (getl 'A) -> (((1 2 3 4) . list) (0 . counter)) # currently -> ((list . (1 2 3 4)) (counter . 0)) # I would expect this? Or, how is the order inside pairs for getl/putl important to these functions? > Another reason is that a property list could be searched for a given > value with 'assoc'. I see, you think it is more useful to search for a given value and I thought it was more useful to search for a given property (even though there are other functions but they don't work with the list of properties as a whole). How and what for would you use assoc in your example? What information would you get if you found that some property has a given value and how/what for would you use this information? Also, values can be "random" from a programmer point of view as opposed to keys (usually) and a few properties can have the same value; in that case assoc fails to be useful: : (assoc 0 '((0 . list) (0 . counter))) -> (0 . list) Sometimes a list of (key . value) is needed (e.g. a list of attributes for xml function) and in those cases, if I use getl in my code, I need to "swap" car and cdr values which is rather inconvenient. Am I missing something? I was thinking about XML data binding, representing XML using symbols instead of lists and that was where getl surprized me. It is not an issue though, just unexpected surprice;-) # convert xml "list" (as returned by xml function) to xml "symbol" (de xml2sym (S X) (if S (let (E (car X) A (cadr X) B (cddr X) G (group B)) (for H G (let E2 (car H) (if (<= (length (cdr H)) 1) (for I (cdr H) (if (<= (length (cdr I)) 1) (put S E2 (cadr I)) (put S E2 (xml2sym (new) (cons E2 I))))) (for I (cdr H) (if (<= (length (cdr I)) 1) (put S E2 (conc (get S E2) (list (cadr I)))) (put S E2 (conc (get S E2) (list (xml2sym (new) (cons E2 I)))))))))) S) (when X (let (R (new)) (put R (car X) (xml2sym (new) X)) R)))) # convert xml "symbol" to xml "list" (as consumed by xml function) (de sym2xml (S) (let P (car (getl S)) (_sym2xml (car P) (cdr P)))) (de _sym2xml (S E) (if (or (num? S) (not (getl S))) (list E NIL S) (let (N (get S '@@ns) C (filter '((X) (not (pat? (cdr X)))) (getl S)) A (filter '((X) (and (pat? (cdr X)) (<> '@@ns (cdr X)))) (getl S))) (make (link (if N (intern (pack N ': E)) E) (reverse (mapcar '((X) (cons (intern (pack (cdr (chop (cdr X))))) (car X))) A))) (for I (reverse C) (if (lst? (car I)) (for J (car I) (link (_sym2xml J (cdr I)))) (link (_sym2xml (car I) (cdr I))))))))) (de xload (F) (xml2sym NIL (in F (xml)))) (de xwrite (S) (xml? T) (xml (sym2xml S))) (de xsave (F S) (out F (xwrite S))) To see how it works, run something like: (setq X (xload "my.xml")) (show X) ... (xsave "my2.xml" X) The advantage of this approach is that I can use all those property access functions instead of searching for elements & attributes in a list. Also, other useful stuff could be added to a symbol representing an XML element, e.g. indices for accessing items of a list hold by a property in a specific order. Thanks, Tomas -- UNSUBSCRIBE: mailto:[EMAIL PROTECTED]