janet/libs/pp.gst

(do

(: pp nil)

"Pretty print an array or tuple"
(: print-seq (fn [start end a seen]
    (: seen (if seen seen {}))
    (if (get seen a) (get seen a)
        (do
            (set! seen a "<cycle>")
            (: parts [])
            (: len (length a))
            (: i 0)
            (while (< i len)
                (push! parts (pp (get a i) seen))
                (push! parts " ")
                (: i (+ 1 i)))
            (if (> len 0) (pop! parts))
            (push! parts end)
            (: ret (apply string start parts))
            (set! seen a ret)
            ret))))

"Pretty print an object or struct"
(: print-struct (fn [start end s seen]
    (: seen (if seen seen {}))
    (if (get seen s) (get seen s)
        (do
            (set! seen s "<cycle>")
            (: parts [])
            (: key (next s))
            (while (not (= key nil))
                    (push! parts (pp key seen))
                    (push! parts " ")
                    (push! parts (pp (get s key) seen))
                    (push! parts " ")
                    (: key (next s key)))
            (if (> (length parts) 0) (pop! parts))
            (push! parts end)
            (: ret (apply string start parts))
            (set! seen s ret)
            ret))))

"Type handlers"
(: handlers {
    "array" (fn [a seen] (print-seq "[" "]" a seen))
    "tuple" (fn [a seen] (print-seq "(" ")" a seen))
    "table" (fn [s seen] (print-struct "{" "}" s seen))
    "struct" (fn [s seen] (print-struct "#{" "}" s seen))
 })

"Define pretty print"
(: pp (fn [x seen]
    (: handler (get handlers (type x)))
    (: handler (if handler handler tostring))
    (handler x seen)))

"Export pretty print"
(export! "pp" pp)

(: arr [1 2 3 4])
(push! arr arr)
(print (pp arr))

)