लिस्प/योजना से

Question

मूल रूप से कुछ भी वापस नहीं, मैं

(define tbl '(a b c d)) 
(map (lambda (item 'c) (if (eq? item 'c) item (...what in else?)))) 

परिणाम मैं चाहता हूँ की तरह एक सूची में मानचित्र का उपयोग करने चयन करना चाहते हैं

'(c) 

है मैं और हिस्सा छोड़ करने की कोशिश की खाली, यह शिकायत करता है कि अन्य भाग की आवश्यकता है। मैं

(display "foo") 

रूप में किसी और हिस्से की कोशिश की और

(#<void> #<void> C#<void>) 

कि करीब है मिला है।

क्या कोई तरीका है कि मैं '(सी) पाने के लिए मानचित्र का उपयोग कर सकता हूं? मुझे रिकर्सिव तरीका पता है, लेकिन मुझे आश्चर्य है कि नक्शा भी ऐसा कर सकता है। यदि नहीं ('सी), कम से कम (# # सी #) लेकिन एक शून्य प्रकार वापसी मूल्य प्राप्त करने के लिए प्रदर्शन हैक का उपयोग नहीं कर रहा है। क्योंकि उत्पादन सूची संभावित इनपुट सूची की तुलना में कम तत्वों होगा -

---

Answer 1

आप filter, नहीं map उपयोग करना चाहते हैं। उन सभी #<void> मूल्यों display द्वारा दिया क्योंकि map उत्पादन सूची में एक परिणाम, भी उन तत्वों हम में कोई दिलचस्पी नहीं कर रहे हैं के लिए शामिल हमेशा जाएगा इसके तुल्य हैं

(define tbl '(a b c d)) 

(filter (lambda (item) (eq? item 'c)) tbl) 
=> '(c) 

, और थोड़ा कम:।

(filter (curry eq? 'c) tbl) 
=> '(c) 

map का उपयोग तब किया जाता है जब आप तत्व सूची को छोड़ दिए बिना इनपुट सूची में से प्रत्येक तत्व को कुछ करना चाहते हैं। दूसरी तरफ, इनपुट सूची में तत्वों के कुछ चुनने के लिए उपयोग किया जाता है, जो #t को दिए गए अनुमान के लिए मूल्यांकन करते हैं, और filter अधिकांश योजना दुभाषियों में उपलब्ध है, यदि यह उपलब्ध नहीं है तो आप SRFI-1 या उपयोग कर सकते हैं ।

का उपयोग कर '(c) प्राप्त करने के लिए कोई तरीका नहीं है केवलmap (यह, map प्लस apply या remove*, आदि का उपयोग कर काट दिया जा सकता है लेकिन है कि विचार नहीं है यह क्या है?); एक छोटे से हैकिंग के लिए

(map (lambda (item) (if (eq? item 'c) item '%)) tbl) ; placeholder in else part 
=> '(% % c %) 

(map (lambda (item) (when (eq? item 'c) item)) tbl) ; when has implicit #<void> 
=> '(#<void> #<void> C#<void>) 

समय: अगर किसी कारण से आप उपयोग केवल map करने के लिए है और प्लेसहोल्डर के साथ एक सूची लौट कोई आपत्ति नहीं है, यहाँ विकल्प के एक जोड़े हैं।map प्लस apply (@WillNess 'जवाब में समझाया गया है) का उपयोग करना, यह किसी भी RxRS दुभाषिया में काम का लाभ दिया है और सबसे पोर्टेबल समाधान है, क्योंकि यह मानक प्रक्रियाओं का उपयोग करता है:

(apply append (map (lambda (item) (if (eq? item 'c) (list item) '())) tbl)) 
=> '(c) 

map प्लस remove* का उपयोग करना:

(remove* (list (void)) (map (lambda (item) (when (eq? item 'c) item)) tbl)) 
=> '(c) 

एक बदलाव के लिए, map के बिना एक समाधान - बजाय foldr का उपयोग कर:

(foldr (lambda (item a) (append (if (eq? item 'c) (list item) '()) a)) '() tbl) 
=> '(c) 

,210

बेशक, आप हमेशा ही मानक प्रक्रियाओं का उपयोग filter के अपने स्वयं के संस्करण लागू कर सकते हैं, यह भी सभी RxRS दुभाषिए भर में पोर्टेबल हो जाएगा:

(define (filter pred? lst) 
    (cond ((null? lst) 
     '()) 
     ((not (pred? (car lst))) 
     (filter pred? (cdr lst))) 
     (else 
     (cons (car lst) 
       (filter pred? (cdr lst)))))) 

(filter (lambda (item) (eq? item 'c)) tbl) 
=> '(c) 

Answer 2

आप अपने योजना संस्करण/पर्यावरण का उल्लेख नहीं था। मान लें कि आप केवल सबसे बुनियादी योजना है, यह बहुत आसान कुछ को लागू करना है:

(define (choose-if pred list) 
    (let choosing ((list list) (rslt '())) 
    (if (null? list) 
     (reverse rslt) 
     (choosing (cdr list) 
        (if (pred (car list)) 
         (cons (car list) rslt) 
         rslt))))) 

और उसके बाद संबंधित:

(define (choose item list) 
    (choose-if (lambda (elt) (eq? item elt)) list)) 

(define (choose-if-not pred list) 
    (choose-if (lambda (elt) (not (pred elt))) list)) 

और उपयोग:

> (choose 'c '(a b c d)) 
(c) 

तुम भी विकल्प होता है निम्न स्तर के प्राइमेटिव्स का उपयोग करने के लिए:

(define (choose item list) 
    (remq #f (map (lambda (elt) (eq? item elt)) list))) 

या

(define (choose item list) 
    (remp (lambda (elt) (not (eq? item elt))) list)) 

Answer 3

सरल "मानक" चाल

(apply append (map (lambda(x)(if (eq? x 'c) (list x) '())) '(a b c d))) 
;Value 12: (c) 

जो (c) देता है। apply append ... map कॉम्बो ("नक्शा और श्रेणीबद्ध" के लिए "mapcan") कॉमन लिस्प में mapcan के रूप में जाना जाता है:

[1]> (mapcan #'(lambda(x)(if (eq x 'c) (list x))) '(a b c d)) 
(C) 

एमआईटी योजना इस समारोह भी है। >(a c) -

apply append अपने तर्क सूची में से एक स्तर, (apply append '((a)() (c)()))==(append '(a) '() '(c) '())सपाट। चूंकि खाली सूचियां गायब हो जाती हैं, इसलिए यह map वाले तत्वों को समाप्त करने के लिए उपयोगी है। यदि आपके पास कोई उपलब्ध है तो यह filter के समान प्रभाव प्राप्त करता है (यह R5RS में नहीं है, लेकिन यह SRFI1 में है)।

यह भी अन्य प्रभाव के लिए इस्तेमाल किया जा सकता है, दोहरीकरण की तरह:

[2]> (mapcan #'(lambda(x)(if (evenp x) (list x x))) '(1 2 3 4)) 
(2 2 4 4) 

---

एक अलग रूप में के रूप में, mapcan है क्या (तर्क के साथ फ़्लिप) के रूप में सूची इकाई के "बाँध" में जाना जाता है, और (apply append ...) के रूप में अपनी ऑपरेशन में शामिल हों। वास्तव में यह किसी भी मोनैड के लिए होना चाहिए, सूचियों के लिए भी bind m f == join (map f m)।

यह भी उदाहरण के लिए आधार है हास्केल के सूची comprehensions:

Prelude> [y | x<-[1,2,3,4], even x, y<-[x,x]] 
[2,2,4,4]