عرض مصدر Ruby/Proc/lambda-3F

{{DISPLAYTITLE:التابع ?Proc.lambda في روبي}}

يتحقَّق التابع ?lambda إذا كانت معالجة الوسائط صارمةً في الكائن Proc (أي يجب تمرير نفس العدد تمامًا من الوسائط المعرَّفة عند إنشاء الكائن). تُنشأ هذه الكائنات عادةً بوساطة lambda.

كائنات الصنف Proc المُنشأة بوساطة proc ليست صارمةً وتمتلك الميزات التالية:
* تتجاهل الوسائط الإضافيَّة:
proc {|a,b| [a,b] }.call(1,2,3)    #=> [1,2]
* تُعيِّن القيمة nil للوسائط الناقصة:
proc {|a,b| [a,b] }.call(1)        #=> [1,nil]
* توسِّع وسيط مصفوفة مفردة:
proc {|a,b| [a,b] }.call([1,2])    #=> [1,2]

كائن الصنف Proc المُنشأ بواسطة lambda لا يمتلك هذه الميِّزات.<syntaxhighlight lang="ruby">
lambda {|a,b| [a,b] }.call(1,2,3)  #=> ArgumentError
lambda {|a,b| [a,b] }.call(1)      #=> ArgumentError
lambda {|a,b| [a,b] }.call([1,2])  #=> ArgumentError

</syntaxhighlight>التابع ?lambda هو تابعٌ خَبَريٌ (predicate) لهذه الميِّزات. يُعيد القيمة true إذا لم تُطبَّق أي ميِّزة.<syntaxhighlight lang="ruby">
lambda {}.lambda?            #=> true
proc {}.lambda?              #=> false

</syntaxhighlight>يؤدي التابع new نفس عمل proc.

Proc.new {}.lambda?          #=> false

تحافظ lambda و proc و new على ميزات كائن الصنف Proc المعطيَّة بالوسيط &.<syntaxhighlight lang="ruby">
lambda(&lambda {}).lambda?   #=> true
proc(&lambda {}).lambda?     #=> true
Proc.new(&lambda {}).lambda? #=> true

lambda(&proc {}).lambda?     #=> false
proc(&proc {}).lambda?       #=> false
Proc.new(&proc {}).lambda?   #=> false

</syntaxhighlight>يمتلك كائن الصنف Proc المُنشَأ عبر الوسيط & تلك الميزات.<syntaxhighlight lang="ruby">
def n(&b) b.lambda? end
n {}                         #=> false

</syntaxhighlight>يحتفظ الوسيط & بهذه الميِّزات إذا أُعطي كائن الصنف Proc عبر الوسيط &.<syntaxhighlight lang="ruby">
n(&lambda {})                #=> true
n(&proc {})                  #=> false
n(&Proc.new {})              #=> false

</syntaxhighlight>لا يمتلك كائن Proc المُحوَّل من تابع أي ميِّزات.<syntaxhighlight lang="ruby">
def m() end
method(:m).to_proc.lambda?   #=> true

n(&method(:m))               #=> true
n(&method(:m).to_proc)       #=> true

</syntaxhighlight>يُعامَل define_method كما يُعامل تعريف التابع. لا يمتلك التابع المُعرَّف أية ميِّزات.<syntaxhighlight lang="ruby">
class C
  define_method(:d) {}
end
C.new.d(1,2)       #=> ArgumentError
C.new.method(:d).to_proc.lambda?   #=> true

</syntaxhighlight>يُعرِّف define_method تابعًا من دون ميِّزات دومًا حتى إذا أُعطي كائنٌ من النوع Proc لم يُنشأ باستعمال lambda. هذا الاستثناء الوحيد الذي لا تُحفظ فيه الميِّزات.<syntaxhighlight lang="ruby">
class C
  define_method(:e, &proc {})
end
C.new.e(1,2)       #=> ArgumentError
C.new.method(:e).to_proc.lambda?   #=> true

</syntaxhighlight>يَضمن هذا الاستثناء أنَّ التوابع لا تمتلك ميِّزاتٍ ويجعل من السَّهل على المُغلِّفات (wrappers) تعريف التوابع التي تسلك سلوكًا طبيعيًّا.<syntaxhighlight lang="ruby">
class C
  def self.def2(name, &body)
    define_method(name, &body)
  end

  def2(:f) {}
end
C.new.f(1,2)       #=> ArgumentError

</syntaxhighlight>يُعرَّف المُغلِّف def2 تابعًا لا يمتلك ميِّزات.

== البنية العامة ==
lambda? → true or false

== القيم المعادة ==
تُعاد القيمة true إذا كانت معالجة الوسائط صارمةً، أو تعاد القيمة false خلاف ذلك.

== انظر أيضًا ==
* التابع hash: يحسب قيمة التجزئة الموافقة لجسم الكتلة proc التي استدعيت معه ثمَّ يعيدها.
* التابع to_proc: يُعدُّ جزءًا من البروتوكول المستخدم في تحويل الكائنات إلى كائناتٍ من الصنف Proc.
* المعامل ===: يستدعي الكتلة بتمرير الكائن الواقع على يمينه كمعاملٍ للنسخة proc.
* التابع call: يستدعي الكتلة المرتبطة بالمتغير الذي استعمل معه مُعيِّنًا معاملات الكتلة إلى القيم المعطاة ضمنه ويُعيد المعامل قيمة آخر تعبيرٍ قُيِّم في الكتلة.

== مصادر ==
* [http://ruby-doc.org/core-2.5.1/Proc.html#method-i-lambda-3F صفحة التابع ?lambda في الصنف Proc في توثيق روبي الرسمي.]
[[تصنيف:Ruby]]
[[تصنيف:Ruby Method]]
[[تصنيف:Ruby Proc]]