anchor.diff:  (defun reading-str-seq (seq)
     (let* ((kanji-text (car (query (:select 'text :from 'kanji-text :where (:and (:= 'seq seq) (:= 'ord 0))) :column)))
            (kana-text (car (query (:select 'text :from 'kana-text :where (:and (:= 'seq seq) (:= 'ord 0))) :column))))
  -    (reading-str kanji-text kana-text)))
  +    (reading-str* kanji-text kana-text)))
  +
  +(defgeneric reading-str (obj)
  +  (:method ((obj simple-text))
  +    (reading-str* (get-kanji obj) (get-kana obj)))
  +  (:method ((obj integer))
  +    (reading-str-seq obj)))
   
   (defun entry-info-short (seq &key with-pos)
     (let ((sense-str (short-sense-str seq :with-pos with-pos)))
  
positive.code:              (push via via-used)))
         (princ " ]" out)))
  
  (defun conj-info-json (seq &key conjugations text)
    (loop with via-used = nil
       for conj in (select-conjs seq conjugations)
       for via = (seq-via conj)
       unless (member via via-used)
       collect (let* ((conj-pos nil)
                      (orig-text (get-original-text-once (get-conj-data seq (list (id conj))) text))
                      (js (jsown:new-js 
                            ("prop" (loop for conj-prop in (select-dao 'conj-prop (:= 'conj-id (id conj)))
                                       do (push (pos conj-prop) conj-pos)
                                       collect (conj-prop-json conj-prop))))))
                 (if (eql via :null)
                     (jsown:extend-js js
                       ("reading" (reading-str-seq (seq-from conj)))
                       ("gloss" (get-senses-json (seq-from conj)
                                                 :pos-list conj-pos
                                                 :reading-getter (lambda ()
                                                                   (when orig-text
                                                                     ;; TODO: fix match-sense-restrictions to accept multiple readings
                                                                     (car (find-words-seqs orig-text (seq-from conj))))))))
                     (progn
                       (jsown:extend-js js
                         ("via" (conj-info-json via :text orig-text)))
                       (push via via-used)))
                 js)))
  
  (defun map-word-info-kana (fn word-info &key (separator "/")
                             &aux (wkana (word-info-kana word-info)))
  
negative.code:        'sense.ord)
        1)) :single))
  
  (defun reading-str* (kanji kana)
    (if kanji
        (format nil "~a 【~a】" kanji kana)
        kana))
  