টাস্ক হ্যান্ডলার

একটি ব্লক হলো কোডের এমন একটি অংশ, যা একটি মেথডে পাস করা যায়। অন্য প্রোগ্রামিং ভাষায় এটিকে অ্যানোনিমাস ফাংশন বা ল্যামডা বলা হয়। একটি মেথড একটি ব্লককে 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 কল করা না হলে ব্লকটি কখনোই রান হবে না। এটিকে আর্গুমেন্টও দেওয়া যায়, যা ব্লকে পাস করা হবে। ব্লকে যত খুশি আর্গুমেন্ট পাস করা যায়, এর কোনো সীমা নেই। ব্লকে আর্গুমেন্টগুলো ব্যবহার করতে আপনি |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 }