नक्शा और योजना में लागू के बीच क्या अंतर है?

Question

मैं योजना जानने की कोशिश कर रहा हूँ और मैं एक मुश्किल समय map और apply के बीच अंतर को समझने हो रहा है।

जैसा कि मैं समझता हूं, map सूची के प्रत्येक तत्व में फ़ंक्शन लागू करता है, और apply किसी प्रक्रिया के तर्कों पर कुछ लागू होता है।

वे interchangeably उपयोग किया जा सकता है?

Answer 1

वे समान नहीं हैं! उनके नाम वास्तव में याद जो क्या करता है कर सकते हैं।

map एक प्रक्रिया और एक या अधिक सूचियों के रूप में तर्क लेगा। प्रक्रिया, सूचियों में से प्रत्येक स्थिति के लिए एक बार बुलाया जाएगा तर्क के रूप में उस स्थिति में तत्वों की सूची का उपयोग:

(map - '(2 3 4)) 
; => (-2 -3 -4) 

map(- 2), (- 3), (- 4) बुलाया सूची बनाने के लिए।

(map + '(1 2 3) 
     '(10 20 30)) 
; => (11 22 33) 

map(+ 1 10)(+ 2 20)(+ 3 30) बुलाया सूची बनाने के लिए।

(map * '(2 2 -1) 
     '(0 3 4) 
     '(5 4 2)) 
; => (0 24 -8) 

map(* 2 0 5)(* 2 3 4)(* -1 4 2) बुलाया सूची बनाने के लिए। ,

(map - '(2 3 4)) 
arguments  mapping "-"  result 
    2  === (- 2) ===>  -2 
    3  === (- 3) ===>  -3 
    4  === (- 4) ===>  -4 

(map + '(1 2 3) 
     '(10 20 30)) 
arguments  mapping "+"  result 
    1 10  === (+ 1 10) ===>  11 
    2 20  === (+ 2 20) ===>  22 
    3 30  === (+ 3 30) ===>  33 

applyकम से कम दो तर्क ले जाएगा उनमें से पहले:

map क्योंकि यह एक "नक्शा" (समारोह) मानों का एक सेट पर (सूचियों में) लागू करता है कि नाम है एक प्रक्रिया है और पिछले एक सूची किया जा रहा है।के रूप में (+ 2 3 4)

(apply display '("Hello, world!")) 
; does not return a value, but prints "Hello, world!" 

(apply + '(2 3 4)) 
; => 9 

यह वही है यह (display "Hello, world!") रूप में ही है: यह है, तो निम्न तर्क के साथ प्रक्रिया कॉल करेंगे सूची के अंदर भी शामिल हैं।

apply

(define arguments '(10 50 100)) 
(apply + arguments) 

आप apply का उपयोग किए बिना अंतिम पंक्ति को फिर से लिखने का प्रयास करेंगे तो आपको पता चल जाएगा कि आप प्रत्येक तत्व संक्षेप सूची पर पाश की जरूरत है, तो आप एक सूची के रूप में तर्क है जब उपयोगी है। ..

apply का उपयोग उन दो तर्कों से अधिक के साथ भी किया जा सकता है। पहला तर्क एक कॉल करने योग्य वस्तु (एक प्रक्रिया या निरंतरता) होना चाहिए। अंतिम एक सूची होना चाहिए। अन्य (पहले और आखिरी के बीच) किसी भी प्रकार की वस्तुएं हैं। तो

(PROC a b c ... y z one two ... twenty) 

यहाँ एक ठोस उदाहरण है कॉल करने जैसा ही बुला

(apply PROC a b c ... y z '(one two ... twenty)) 

है:

(apply + 1 -2 3 '(10 20)) 
; => 32 

इस रूप में (+ 1 -2 3 10 20)

apply एक ही है कि नाम है क्योंकि यह अनुमति देता है है है आप कई तर्कों के लिए एक प्रक्रिया "लागू" करने के लिए।

Answer 2

नहीं है, apply एक प्रक्रिया के रूप में अपना पहला तर्क कहता है, अपने तर्कों के रूप में सभी बाकी है, पिछले एक के साथ साथ - सूची -, खोल दिया उसकी सामग्री "में कटा हुआ" अर्थात्:

(apply f a b (list c d e)) == (f a b c d e) 

उदाहरण के लिए:

(लागू + 1 2 (सूची 3 4 5))
; मूल्य: 15

यह सिर्फ एक कॉल है, map वास्तव में अपने दूसरे तर्क के प्रत्येक सदस्य के तत्व के लिए अपने पहले तर्क बुला रहा है।

map और apply में से एक संयुक्त उपयोग प्रसिद्ध transpose चाल है:

(नक्शा सूची लागू '((1 2 3) (10 20 30)))
; मान: ((1 10) (2 20) (3 30))