racket
उच्च आदेश कार्य

नक्शा

मानचित्र सूची के प्रत्येक तत्व पर एक फ़ंक्शन लागू करता है:

map: (a -> b) (listof a) -> (listof b)

> (map (lambda (x) (* x 2)) (list 1 2 3 4 5)
(list 2 4 6 8 10)

> (map sqrt (list 1 4 9))
(list 1 2 3)

> (map (lambda (x) (if (even? x) "even" "odd")) (list 1 2 3))
(list "odd" "even" "odd")

तह

सही तरीके से सूची में हर तत्व के लिए दो-तर्क फ़ंक्शन लागू होता है, जो बाएं से दाएं आधार मूल्य के साथ शुरू होता है:

foldr: (a b -> b) b (listof a) -> b

> (foldr + 0 (list 1 2 3 4))
10

> (foldr string-append "" (list "h" "e" "l" "l" "o"))
"hello"

> (foldr cons empty (list 1 2 3 4))
(list 1 2 3 4)

लेफ्ट लेफ्ट विपरीत दिशा में एक ही क्रिया करता है:

foldl: (a b -> b) b (listof a) -> b

> (foldl + 0 (list 1 2 3 4)
10

> (foldl string-append "" (list "h" "e" "l" "l" "o"))
"olleh"

> (foldl cons empty (list 1 2 3 4))
(list 4 3 2 1)

फ़िल्टर

filter रिटर्न दी गई सूची में है जिसके लिए दिया विधेय एक गैर रिटर्न में प्रत्येक आइटम की एक सूची #f मूल्य।

;; Get only even numbers in a list
> (filter even? '(1 2 3 4))
'(2 4)

;; Get all square numbers from 1 to 100
> (filter (lambda (n) (integer? (sqrt n))) (range 1 100))
'(1 4 9 16 25 36 49 64 81) 

लिखें

आपको कई कार्यों की रचना करने देता है f₀ f₁ … fₙ । यह एक समारोह है कि क्रमिक लागू होगी रिटर्न fₙ अपने तर्कों, तो fₙ₋₁ के परिणाम के fₙ और इतने पर। गणितीय फ़ंक्शन संरचना के लिए फ़ंक्शन को दाईं से बाईं ओर लागू किया जाता है: (f ∘ g ∘ h)(x) = f(g(h(x))) ।

> ((compose sqrt +) 16 9)
5
> ((compose - sqrt) 16)
-4

प्रत्येक फ़ंक्शन की समता में फ़ंक्शन के लौटे हुए मानों की संख्या तुरंत उसके दाईं ओर शामिल होनी चाहिए। सबसे सही कार्य संपूर्ण रचना की समता को निर्धारित करता है। Compose1 फ़ंक्शन यह बताता है कि फ़ंक्शन 1 मान लौटाते हैं और 1 तर्क की अपेक्षा करते हैं। हालाँकि, कम्पोज़ 1 में अंतिम फ़ंक्शन के इनपुट एरिटी को प्रतिबंधित नहीं किया गया है, न ही पहले फ़ंक्शन के आउटपुट एरिटी को।

[n input]--> first-function -->[1 output]--> ... last function -->[m output].

((compose + values) 1 2 3 4)
10
> ((compose1 + values) 1 2 3 4)
XX result arity mismatch;
 expected number of values not received
  expected: 1
  received: 4
  values...:

करी

एक आंशिक रूप से लागू फ़ंक्शन देता है।

> ((curry + 10) 20)
30

curryr का उपयोग तब किया जा सकता है जब तर्कों को अंत में सम्मिलित करने की आवश्यकता होती है। दूसरे शब्दों में, (curryr list 1 2) कुछ new-arguments ... अपेक्षा कर एक फ़ंक्शन का उत्पादन करेगा new-arguments ... जब कॉल किया जाता है, तो वह नया कार्य बदले में कॉल करेगा (list new-arguments ... 1 2) ।

> (((curryr list) 1 2) 3 4)
'(3 4 1 2)
> ((curryr list 1 2) 3 4)
'(3 4 1 2) 
> ((curryr - 30) 40)
10
> (((curryr -) 30 40))
10