सामान्य लिस्पी त्रुटि: "लैम्ब्डा अभिव्यक्ति होना चाहिए"

Question

मैंने कुछ दिनों पहले आम लिस्प सीखना शुरू किया था, और मैं एक ऐसा फ़ंक्शन बनाने की कोशिश कर रहा हूं जो एक पेड़ में एक संख्या डालता है। मैं एक त्रुटि हो रही है,

*** - SYSTEM::%EXPAND-FORM: (CONS NIL LST) should be a lambda expression

आसपास googling से ऐसा प्रतीत होता ऐसा होता है जैसे आप कोष्ठक के भी कई सेट है जब, लेकिन चारों ओर लगभग एक घंटे के लिए इस पर देख रहे हैं और बदलते चीजों के बाद, मैं यह कर सकते हैं ' यह पता नहीं लगा कि मैं यह कहां कर सकता हूं।) 2)

(defun insert (lst probe) 
    (cond ((null lst) (cons probe lst)) 
     ((equal (length lst) 1) 
      (if (<= probe (first lst)) 
       (cons probe lst) 
       (append lst (list probe)))) 
     ((equal (length lst) 2) 
      ((cons nil lst) (append lst nil) (insertat nil lst 3) 
       (cond ((<= probe (second lst)) (insert (first lst) probe)) 
        ((> probe (fourth lst)) (insert (fifth lst) probe)) 
        (t (insert (third lst) probe))))))) 

मैं बहुत यकीन है कि यह ((बराबर (लंबाई lst के बाद होने वाली रही है, जहां विचार मौजूदा में एक खाली सूची डालने के लिए है:

इस कोड को जहां यह हो रहा है है सूची है, तो अंत पर एक खाली सूची संलग्न है, तो बीच में एक खाली सूची सम्मिलित

Answer 1

सही! समस्या उसके ठीक बाद लाइन में है, जहां यह कहता है

((cons nil lst) (append lst nil) (insertat nil lst 3) ... 

समस्या दो उद्घाटन कोष्ठक है। अभिभावक विशेष संदर्भों में अर्थ बदल सकते हैं (जैसे cond फ़ॉर्म जिसका आप उपयोग कर रहे हैं), लेकिन इस संदर्भ में, कोष्ठक नियमित फ़ंक्शन एप्लिकेशन को इंगित करते हैं, जैसा कि आप शायद उपयोग कर रहे हैं। इसका मतलब है कि कोष्ठक के बाद पहली चीज एक समारोह होना चाहिए। बाहरी कोष्ठक के परिप्रेक्ष्य से, पहली बात (cons nil lst) है, इसलिए यह एक कार्य होना चाहिए (जो यह नहीं है)।

ध्यान दें कि आप केवल कोष्ठक को नहीं हटा सकते हैं, क्योंकि cons फ़ंक्शन एक नई सूची देता है जैसे आप चाहते हैं लेकिन पुरानी सूची नहीं बदलता है।

(setq lst (cons nil lst)) 
(setq lst (append lst nil)) 
(setq lst (insertat nil lst 3)) 
... 

Answer 2

आप सही कर रहे हैं; लाइन के साथ "त्रुटि यहाँ है" चिह्नित पर, वहाँ एक सिंटैक्स त्रुटि है:।

(defun insert (lst probe) 
    (cond ((null lst) (cons probe lst)) 
     ((equal (length lst) 1) 
     (if (<= probe (first lst)) 
      (cons probe lst) 
      (append lst (list probe)))) 
     ((equal (length lst) 2) 
     (#|Error is here|# (cons nil lst) (append lst nil) (insertat nil lst 3) 
      (cond ((<= probe (second lst)) (insert (first lst) probe)) 
       ((> probe (fourth lst)) (insert (fifth lst) probe)) 
       (t (insert (third lst) probe))))))) 

कंपाइलर/दुभाषिया के लिए, फ़ॉर्म "फ़ंक्शन" (cons nil list) पर फ़ंक्शन कॉल के रूप में पढ़ता है जो बिल्कुल एक फ़ंक्शन नहीं है। संकलक "ऑपरेटर" की स्थिति है, जो एक lambda नहीं है में एक यौगिक फार्म के उपयोग के बारे में यहां शिकायत (मिश्रित रूप का ही तरह उस स्थिति में स्वीकार कर लिया।)

((cons nil lst)       #| <-- Form in operator position |# 
(append lst nil)      #| <-- First argument form |# 
(insertat nil lst 3)     #| <-- Second argument form |# 
(cond ((<= probe (second lst)) (insert (first lst) probe)) #| Third argument |# 
     ((> probe (fourth lst)) (insert (fifth lst) probe)) 
     (t (insert (third lst) probe)))) 

मैं फिर से साथ मदद चाहते हैं अभिव्यक्ति को तैयार करना, लेकिन मुझे यकीन नहीं है कि आप यहां क्या हासिल करना चाहते हैं।

Answer 3

आप सही तरीके से समारोह इंडेंट है, तो आप देख सकते हैं कान्स शून्य LST के सामने एक अतिरिक्त कोष्ठक है कि वहाँ: आप शायद कुछ इस तरह करना चाहते हैं।

(defun insert (lst probe) 
    (cond ((null lst) (cons probe lst)) 
     ((equal (length lst) 1) 
     (if (<= probe (first lst)) 
      (cons probe lst) 
      (append lst (list probe)))) 
     ((equal (length lst) 2) 
     ((cons nil lst) (append lst nil) (insertat nil lst 3) 
      (cond ((<= probe (second lst)) (insert (first lst) probe)) 
       ((> probe (fourth lst)) (insert (fifth lst) probe)) 
       (t (insert (third lst) probe))))))) 

अधिकांश लिस्प आईडीई में आप अभिव्यक्ति इंडेंट कर सकते हैं। LispWorks में, पूरी अभिव्यक्ति का चयन करें और एम-एक्स इंडेंट क्षेत्र करें।

Answer 4

तत्काल त्रुटि को ठीक करने के लिए, आप वहां पहले एक प्रोग्न जोड़ सकते हैं (CONS NIL ...)। PROGN इसमें प्रत्येक फॉर्म का मूल्यांकन करके काम करता है और इसके मूल्य के रूप में अंतिम रूप का मान वापस कर देता है।

हालांकि, आपका प्रोग्राम अभी भी ऐसा नहीं करेगा जो आपको लगता है कि यह करेगा (मुझे ऐसा लगता है)। आप जानते हैं, आम लिस्प में आप पूरी गैर-खाली सूची का प्रतिनिधित्व करने के लिए पहली विपक्षी वस्तु का उपयोग करते हैं, और आप केवल मुख्य विपक्ष को प्रतिस्थापित नहीं कर सकते हैं।बेहतर तरीका है कि नई सूची को फ़ंक्शन के मान के रूप में वापस करना है।

(defun insert (lst probe) 
    (ecase (length lst) 
    (0 (list probe)) 
    (1 (let ((c (first lst))) 
     (if (<= probe c) 
      (list probe c) 
      (list c probe)))) 
    (2 (cond 
     ((<= probe (first lst)) 
      (list probe (first lst) nil (second lst) nil)) 
     ((> probe (second lst)) 
      (list nil (first lst) nil (second lst) probe)) 
     (t 
      (list nil (first lst) probe (second lst) nil)))))) 

शायद आप इस फ़ंक्शन का उपयोग करते समय (setf lst (insert lst [some-number])) चाहते हैं।