معالج المهام

الكتلة هي قطعة من الكود يمكن تمريرها إلى طريقة. وتُعرف هذه في لغات البرمجة الأخرى باسم دالة مجهولة أو لامدا. ويمكن للطريقة تحويل كتلة إلى Proc يمثّل كتلة من الكود.

def my_method(&block)
  1 + yield
end

my_method { 2 }
# => 3

تُستخدم الكتل و Proc كثيرًا جدًا في Crystal، في أشياء مثل التكرار ودوال الاستدعاء. ولكن أيضًا لإنشاء لغات محددة المجال (DSLs)، ومن أمثلة هذه اللغات إطار الويب 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 }