सामान्य लिस्प में, एक सामान्य डेटा प्रकार विनिर्देशक (जैसे पूर्णांक की सूची) को परिभाषित करने के लिए कैसे?

Question

मैं एक प्रकार के विनिर्देश को परिभाषित करना चाहता हूं जो एक ही प्रकार की चीजों की सूची का वर्णन करता है। इसलिए मैं (list-of integer)(array integer) (जो अंतर्निहित है) के समान होना चाहता हूं। मैं, एक विशिष्ट प्रकार के लिए उसे बनाने के लिए इस तरह कर रहा हूँ:

(defun elements-are-integer (seq) 
    (every #'(lambda (x) (typep x 'integer)) seq)) 
(deftype list-of-integer() 
    '(and list (satisfies elements-are-integer))) 

हालांकि, इसका मतलब यह है कि मैं हर संभव प्रकार के लिए यह करने के लिए किया है। मैं इस कोड को कैसे बदल सकता हूं ताकि प्रकार एक तर्क के रूप में एक और प्रकार ले ले, और satisfies फ्लाई पर भविष्यवाणी कर सके? समस्या यह है कि satisfies को वैश्विक प्रतीक की आवश्यकता है, और मुझे नहीं पता कि उचित संदर्भ में पूर्वानुमान कार्य को कैसे परिभाषित किया जाए (मुझे लगता है कि मुझे किसी भी तरह gensym की आवश्यकता है, लेकिन कैसे?)। इसके अलावा, समाधान को काम करना चाहिए ताकि प्रकार किसी अन्य पैकेज के अंदर बनाया जा सके।

Answer 1

मैं कबूल करना चाहिए मैं काफी आम तुतलाना पता नहीं है समझने के लिए वास्तव में क्या deftype के लिए प्रयोग किया जाता है, लेकिन इस मैक्रो यह करना चाहिए ...

(defmacro deftype-list-of (type) 
    (let* ((etfname (intern (concatenate 'string "ELEMENTS-ARE-" 
             (symbol-name type)))) 
     (ltname (intern (concatenate 'string "LIST-OF-" 
             (symbol-name type)))) 
     (tcdef `(defun ,etfname (seq) 
        (every (lambda (x) (typep x ',type)) seq))) 
     (ltdef `(deftype ,ltname() 
        '(and list (satisfies ,etfname))))) 
    (if (fboundp etfname) 
     ltdef 
     `(progn ,tcdef ,ltdef)))) 

उदाहरण (deftype-list-of integer) के लिए एक के बराबर कोड करने के लिए फैलता है आपने पोस्ट किया

यह कोड वर्तमान पैकेज (मुझे लगता है) में टाइप को परिभाषित करता है, लेकिन पैकेज नाम को स्वीकार करने की अनुमति देने के लिए इसे बदलना छोटा होना चाहिए।

Answer 2

इस प्रयास करें:

(defun elements-are-of-type (seq type) 
    (every #'(lambda (x) (typep x type)) seq)) 

(deftype list-of-type (type) 
    (let ((predicate (gensym))) 
    (setf (symbol-function predicate) 
     #'(lambda (seq) (elements-are-of-type seq type))) 
    `(and list (satisfies ,predicate)))) 

(typep '(1 2 3) '(list-of-type integer)) 
; -> T 

(typep '(1 2 a) '(list-of-type integer)) 
; -> NIL 

(typep '(a b c) '(list-of-type symbol)) 
; -> T