added alist test in ldnout. using map instead of cons car/cdr pattern

because otherwise we get stack overflow on larger structures

docs/lqn.md

@@ -1,4 +1,4 @@
-# Lisp Query Notation Symbol Documentation (2.1.1)
+# Lisp Query Notation Symbol Documentation (2.1.2)
 
 ```
  ; LQN:??

lqn.asd

@@ -1,6 +1,6 @@
 (asdf:defsystem #:lqn
   :description "Lisp Query Notation"
-  :version "2.1.1"
+  :version "2.1.2"
   :author "anders hoff / @inconvergent / inconvergent@gmail.com"
   :in-order-to ((asdf:test-op (asdf:test-op #:lqn/tests)))
   :licence "MIT" :pathname "src/" :serial nil
@@ -19,7 +19,7 @@
 
 (asdf:defsystem #:lqn/tests
   :depends-on (#:lqn #:prove #:uiop #:asdf)
-  :version "2.1.1"
+  :version "2.1.2"
   :perform (asdf:test-op (o s) (uiop:symbol-call ':lqn-tests '#:run-tests))
   :pathname "test/" :serial t
   :components ((:file "run")))

src/io.lisp

@@ -70,10 +70,17 @@
 (defun ldnout (o) "serialize internal representation to readable lisp data.
 most notably lists and vectors are serialized as #(..), and hash-tables are serialized
 as alists. see ldnload."
+  ; TODO: there is/was a recursion stack overflow here for large lists (in
+  ; particular) and when flattening hash-tables can we do this in a smarter
+  ; way?
   (labels ((ldnkey (k) (typecase k (number k) (string (kw k)) (sequence k)
                                    (character k) (otherwise (kw k)))))
    (typecase o (string o)
-     (cons (cons (ldnout (car o)) (ldnout (cdr o))))
+                 ; simplistic alist test
+     (cons (cond ((consp (cdr o)) (map 'list (lambda (k) (ldnout k)) o))
+                 ; map appears to behave better than loop+collect and (cons car cdr)?
+                 (t (cons (ldnout (car o)) (ldnout (cdr o))))))
+     ; (cons (cons (ldnout (car o)) (ldnout (cdr o))))
      (hash-table (loop for k being the hash-keys of o using (hash-value v)
                        collect `(,(ldnkey k) . ,(ldnout v))))
      (vector (loop with res = (make-adjustable-vector)