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

> 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 
      (when X
         (let (R (new))
            (put R (car X) (xml2sym (new) X))

# 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)))
               (if N (intern (pack N ': E)) E)
                     '((X) (cons (intern (pack (cdr (chop (cdr X))))) (car X)))
            (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.



Reply via email to