मैं सामान्य लिस्प में एक अलिस्ट कैसे प्रारूपित कर सकता हूं?

Question

मैं मुझे कुछ सामान्य लिस्प लिखना शुरू कर रहा हूं और मुझे चीजों को एक साथ जोड़ने और उन्हें स्वरूपित करने का लटका मिल रहा हूं।

(defvar *map* '((0 . "zero") (1 . "one") (2 . "two"))) 

कैसे मैं इसे इस तरह से प्रारूप है:

की मैं इस तरह, एक alist है लगता है?

0: zero 
1: one 
2: two 

मैं (format t "~{~{~a: ~a~}~%~}" *map*) की तरह कुछ सोच रहा था, लेकिन क्योंकि "शून्य" एक सूची नहीं है और आप इसके बारे में कार नहीं ले सकते कि एक त्रुटि देता है।

बेशक

, (format t "~{~a~%~}" *map*) प्रिंट

(0 . "zero") 
(1 . "one") 
(2 . "two") 

है जैसे कि यह चाहिए था कर रही है, लेकिन यह मैं काफी क्या चाहते हैं नहीं है। क्या (dolist (entry *mapping*) (format t "~a: ~a~%" (car entry) (cdr entry))) से ऐसा करने का कोई बेहतर तरीका है?

Answer 1

Freenode पर # सीएल-माली चैनल इस तरह की एक destructuring पाश बाँध करने का सुझाव देता:

(loop for (a . b) in *mapping* 
    do (format t "~a: ~a" a b)) 

Answer 2

मुझे नहीं लगता कि ऐसा करने का एक बेहतर तरीका है; मैं map() इस्तेमाल किया जाएगा:

(format t "~{~a~%~}" 
    (map 'list 
    #'(lambda (entry) 
     (format nil "~a: ~a" (car entry) (cdr entry)) 
    *map*)) 

Answer 3

आप सही हैं, जबकि इसमें कोई तरीका प्रारूप से एक विपक्ष सेल के अलावा लेने के लिए है की तरह नहीं दिखता।

आप एक ही संघ फ़ॉर्मेट करने के लिए एक और समारोह को परिभाषित हैं:

(defun print-assoc (stream arg colonp atsignp) 
    (format stream "~A: ~A" (car arg) (cdr arg))) 

तो यह आसान है:

(format t "~{~/print-assoc/~%~}" *map*) 

मुझे यकीन है कि नहीं कर रहा हूँ अगर यह एक सुधार है या नहीं। एक तरफ, यह थोड़ा और जटिल है, लेकिन दूसरी ओर, यह प्रिंट-एस्कोक को एक (पुन: प्रयोज्य) फ़ंक्शन में तोड़ देता है, जो उपयोगी हो सकता है।

Answer 4

मुझे लगता है कि टेकअवे यहाँ सबक वास्तव में अपने alists के लिए बिंदीदार सूचियों का उपयोग करने के लिए नहीं है। आप एक विपक्षी सेल को सुरक्षित रखते हैं, लेकिन आप सभी अच्छे अनुक्रम और सूची कार्यों को छोड़ देते हैं। यह सिर्फ इसके लायक नहीं है। आपका स्वरूपण उदाहरण पूरी तरह से बनाई सूचियों के साथ मामूली बात है:

(defvar *map* '((0 "zero") (1 "one") (2 "two"))) 
(format t "~:{~a: ~a~}" *map*) 

Answer 5

(a 2) सूची प्रारूप में

(mapcar #'(lambda (x) `(,(car x) ,(cdr x))) *map*) 

और फिर प्रक्रिया का उपयोग कर alist कोशिकाओं (a . 2) बदलें।

उदाहरण के लिए।, मुद्रित करने के लिए ((a . 2) (b . 3)) रूप "a=2&b=3"

उपयोग

(format t "~{~{~a~^=~}~^&~}" (mapcar #'(lambda (x) `(,(car x) ,(cdr x))) *map*))