टास्क हैंडलर

एक ब्लॉक कोड का एक टुकड़ा होता है जिसे किसी मेथड को पास किया जा सकता है। दूसरी प्रोग्रामिंग भाषाओं में इसे अनाम फंक्शन या लैम्ब्डा कहा जाता है। कोई मेथड किसी ब्लॉक को Proc में बदल सकता है, और Proc कोड के एक ब्लॉक को दर्शाता है।

def my_method(&block)
  1 + yield
end

my_method { 2 }
# => 3

Crystal में ब्लॉक और Proc का बहुत आम इस्तेमाल होता है, जैसे इटरेशन और कॉलबैक के लिए। इनका इस्तेमाल DSL (डोमेन स्पेसिफिक लैंग्वेज) बनाने में भी होता है। ऐसे DSL के कुछ उदाहरण हैं वेब फ्रेमवर्क Kemal और टेस्टिंग फ्रेमवर्क Spec (जिससे आपके Crystal हल टेस्ट किए जाते हैं)।

ब्लॉक

ऐसा मेथड बनाने के लिए जो ब्लॉक ले सके, आपको अंतिम आर्गुमेंट से पहले एम्परसेंड (&) लगाना होगा। इससे ब्लॉक Proc में बदल जाता है और उस आर्गुमेंट को असाइन हो जाता है। फिर yield इस्तेमाल करने पर मेथड को दिया गया ब्लॉक चल जाता है।

def my_method(&block)
  1 + yield
end

ब्लॉक पास करने के दो तरीके हैं: या तो do ... end कीवर्ड इस्तेमाल कीजिए, या कर्ली ब्रैकेट ({})। दोनों में मुख्य अंतर प्राथमिकता का है: do ... end कई लाइनों वाले ब्लॉक लेता है, जबकि कर्ली ब्रैकेट ({}) नहीं लेते।

my_method do
  2
end
# => 3

my_method { 2 }
# => 3

Yield

yield एक कीवर्ड है जो मेथड को दिए गए ब्लॉक को चलाता है। यानी अगर yield को कॉल नहीं किया जाए, तो वह ब्लॉक कभी नहीं चलेगा। yield को आर्गुमेंट भी दिए जा सकते हैं, जो ब्लॉक को पास हो जाते हैं। ब्लॉक को कितने ही आर्गुमेंट पास किए जा सकते हैं, इसकी कोई सीमा नहीं है। ब्लॉक में इन आर्गुमेंट का इस्तेमाल करने के लिए |x, y, ...| सिंटैक्स लिखिए। यहाँ x, y, ... आर्गुमेंट के नाम हैं।

def my_method(&block)
  1 + yield 2
end

# With curly braces:

my_method { |x| x * 3 }
# => 7

# With do ... end:

my_method do |x|
  x * 3
end
# => 7

ऊपर दिए उदाहरण में ब्लॉक को आर्गुमेंट 2 मिलता है। ब्लॉक उसे 3 से गुणा करके 6 लौटाता है। फिर मेथड नतीजे में 1 जोड़कर 7 लौटाता है।

अगर yield को ब्लॉक जितने आर्गुमेंट की अपेक्षा करता है, उससे ज़्यादा आर्गुमेंट दिए जाएँ, तो एरर आ जाती है।

def my_method(&block)
  1 + yield
end

my_method { |x| x * 3 }
# Error: too many block parameters (given 1, expected maximum 0)

ब्लॉक के प्रकार

ब्लॉक स्पष्ट रूप से या अंतर्निहित रूप से लिखे जा सकते हैं। अंतर्निहित ब्लॉक सबसे आम हैं, और ऊपर दिए उदाहरणों में यही दिखाए गए हैं। आप ब्लॉक को अलग-अलग टाइप के आर्गुमेंट भी दे सकते हैं; तब कंपाइलर टाइप का अनुमान लगाकर एक यूनियन टाइप बना देता है।

def my_method(&block)
  yield "a"
  yield 1
end

my_method do |x|
  p typeof(x)
end

# output: (String | Int32)

स्पष्ट ब्लॉक लिखते समय आप आर्गुमेंट के टाइप और रिटर्न टाइप बता सकते हैं। इसके लिए Arg1Type, Arg2Type, ... -> ResultType सिंटैक्स इस्तेमाल होता है। इसमें आर्गुमेंट कोमा (,) से अलग किए जाते हैं, और रिज़ल्ट टाइप -> से अलग किया जाता है।

def my_method(&block : Int32, Int32 -> Int32)
  1 + yield(2, 3)
end

my_method { |x, y| x * y }
# => 7

दूसरे स्पष्ट टाइप की तरह, यहाँ भी कंपाइलर यह सुनिश्चित करता है कि टाइप वही हों जिनकी अपेक्षा की गई है। अगर ब्लॉक मेथड को दिए गए टाइप से मेल नहीं खाता, तो एरर आ जाती है।

Proc

Proc का ब्लॉक से बहुत गहरा संबंध है। मुख्य अंतर यह है कि Proc एक टाइप है, जबकि ब्लॉक नहीं। Proc एक फंक्शन पॉइंटर को दर्शाता है और इसे किसी वेरिएबल की तरह इधर-उधर पास किया जा सकता है।

Proc बनाने के लिए Proc लिटरल ->(args) { ... } सिंटैक्स इस्तेमाल होता है। आर्गुमेंट कोमा (,) से अलग किए जाते हैं, और ब्लॉक { ... } से अलग किया जाता है। किसी Proc को कॉल करने के लिए call मेथड इस्तेमाल कीजिए और उसे आर्गुमेंट पास कीजिए। पैरामीटर के टाइप बताना ज़रूरी है। रिटर्न टाइप Proc के अंदर के कोड से लगाया जाता है, पर इसे स्पष्ट रूप से भी दिया जा सकता है।

my_proc = ->(x : Int32, y : Int32) : Int32 { x * y }
my_proc.call(2, 3)
# => 6

ब्लॉक कैप्चर करना

ब्लॉक कैप्चर करना एक तरीका है जिससे किसी ब्लॉक से Proc बनाया जाता है। इसके लिए मेथड के अंतिम आर्गुमेंट से पहले & ऑपरेटर लगाइए। इससे ब्लॉक Proc में बदल जाता है और उस आर्गुमेंट को असाइन हो जाता है।

def my_method(&block)
  block.call
end

my_method { 1 + 2 }
# => 3

मेथड को Proc पास करना

Proc को उन मेथड को पास किया जा सकता है जो ब्लॉक लेते हैं। यह तब काम आता है जब आपको किसी शर्त के आधार पर अलग-अलग ब्लॉक पास करने हों।

def my_method(&block)
  yield 5
end

my_proc = -> (x) { x * 2 }
my_method(&my_proc)
# => 10

वेरिएबल का टाइप घोषित करना

वेरिएबल घोषित करते समय आप : Type सिंटैक्स से उसका टाइप बता सकते हैं। Proc के लिए Proc((ArgType, ...), ResultType) सिंटैक्स इस्तेमाल होता है। इसमें अंतिम टाइप हमेशा रिटर्न टाइप होता है और बाकी आर्गुमेंट के टाइप होते हैं। यानी अगर सिर्फ एक ही टाइप दिया गया हो, तो वही रिटर्न टाइप होगा और Proc कोई आर्गुमेंट नहीं लेगा।

my_proc : Proc(Int32, Int32, Int32) = ->(x, y) { x * y }
other_proc : Proc(Int32) = -> { 1 }