खोज…
वाक्य - विन्यास
(परिभाषित (नाम तर्क ...) शरीर)
(समारोह तर्क ...)
सरल समारोह कॉल
आप रैकेट में एक फ़ंक्शन को इसके बाद तर्कों के साथ कोष्ठक में लपेटकर कॉल कर सकते हैं। ऐसा लगता है (function argument ...) ।
> (define (f x) x)
> (f 1)
1
> (f "salmon")
"salmon"
> (define (g x y) (string-append x y))
> (g "large" "salmon")
"largesalmon"
> (g "large " "salmon")
"large salmon"
+ और * जैसे संचालन भी कार्य हैं, और वे f या g को कॉल करने के समान सिंटैक्स का उपयोग करते हैं।
> (+ 1 2)
3
> (* 3 4)
12
> (+ (* 3 3) (* 4 4))
25
अधिक जानकारी और उदाहरणों के लिए, रैकेट गाइड में फ़ंक्शन कॉल देखें।
कीवर्ड तर्क
रैकेट फ़ंक्शंस में कीवर्ड तर्क भी हो सकते हैं, जो एक कीवर्ड के साथ तर्क अभिव्यक्ति के बाद निर्दिष्ट होते हैं। एक कीवर्ड वर्णों से शुरू होता है #: इसलिए एक कीवर्ड तर्क #:keyword arg-expr जैसा दिखता है। फ़ंक्शन कॉल के भीतर यह ऐसा दिखता है (function #:keyword arg-expr) ।
> (define (hello #:name n)
(string-append "Hello " n))
> (hello #:name "John")
"Hello John"
> (hello #:name "Sarah")
"Hello Sarah"
> (define (kinetic-energy #:mass m #:velocity v)
(* 1/2 m (sqr v)))
> (kinetic-energy #:mass 2 #:velocity 1)
1
> (kinetic-energy #:mass 6 #:velocity 2)
12
अधिक जानकारी और उदाहरणों के लिए, रैकेट गाइड में कीवर्ड तर्क देखें।
`आवेदन` समारोह
आप एक सूची है, और आप एक समारोह के लिए तर्कों के रूप कि सूची के तत्वों का उपयोग करना चाहते हैं, क्या आप चाहते apply :
> (apply string-append (list "hello" " " "and hi" " " "are both words"))
"hello and hi are both words"
> (apply + (list 1 2 3 4))
10
> (apply append (list (list "a" "b" "c") (list 1 2 3) (list "do" "re" "mi")))
(list "a" "b" "c" 1 2 3 "do" "re" "me")
apply दो तर्क लेता है। पहला तर्क आवेदन करने का कार्य है, और दूसरा तर्क वह सूची है जिसमें तर्क हैं।
एक apply कॉल की तरह
(apply + (list 1 2 3 4))
के बराबर है
(+ 1 2 3 4)
apply का प्रमुख लाभ यह है कि यह मनमाने ढंग से गणना की गई सूचियों पर काम करता है, जिसमें शामिल हैं सूचियों और फ़ंक्शन तर्कों से आने वाली सूचियां।
> (apply + (append (list 1 2 3 4) (list 2 3 4)))
19
> (define (sum lst)
(apply + lst))
> (sum (list 1 2 3 4))
10
> (sum (append (list 1 2 3 4) (list 2 3 4)))
19
अधिक जानकारी और उदाहरणों के लिए, रैकेट गाइड में apply फ़ंक्शन देखें।
कार्य परिभाषाएँ
रैकेट में कार्य lambda फॉर्म के साथ बनाया जा सकता है। प्रपत्र तर्कों और एक निकाय की सूची लेता है।
(lambda (x y) (* x y))
उपरोक्त उदाहरण में, फ़ंक्शन दो तर्कों में लेता है और उन्हें गुणा करने का परिणाम देता है।
> ((lambda (x y) (* x y)) 4 4)
16
> ((lambda (x y) (* x y)) 3 2)
6
हर बार जब हम दो संख्याओं को गुणा करना चाहते हैं, तो फ़ंक्शन और उसके शरीर को फिर से लिखना थकाऊ है, तो आइए इसे एक नाम दें। इसे एक नाम देने के लिए, define रूप का उपयोग करें। यह फ़ंक्शन को एक नाम से बाँध देगा।
(define multiply (lambda (x y) (* x y)))
अब हम multiply करके कॉल multiply अपने फ़ंक्शन का उल्लेख कर सकते हैं
> (multiply 5 2)
10
चूंकि नामों के लिए प्रक्रियाओं को बांधना बहुत आम है, रैकेट परिभाषित रूप का उपयोग करके कार्यों को परिभाषित करने के लिए एक आशुलिपि प्रदान करता है।
(define (multiply x y) (* x y))
अधिक जानकारी और उदाहरणों के लिए, देखें कार्य: रैकेट गाइड में लैम्ब्डा ।