الإغلاق (برمجة الحاسوب)

تظهر الدوال المغلقة عادةً في اللغات التي تدعم الدوال من الدرجة الأولى ، أي أن هذه اللغات تُمكّن من تمرير الدوال كوسائط، وإرجاعها من استدعاءات الدوال، وربطها بأسماء المتغيرات، وما إلى ذلك، تمامًا مثل الأنواع الأبسط كالسلاسل النصية والأعداد الصحيحة. على سبيل المثال، انظر إلى دالة Scheme التالية :

; إرجاع قائمة بجميع الكتب التي بيع منها ما لا يقل عن THRESHOLD من النسخ. ( define ( best-selling-books threshold ) ( filter ( lambda ( book ) ( >= ( book-sales book ) threshold )) book-list ))

في هذا المثال، يظهر تعبير لامدا(lambda (book) (>= (book-sales book) threshold)) داخل الدالة best-selling-books. عند تقييم تعبير لامدا، يقوم Scheme بإنشاء إغلاق يتكون من رمز تعبير لامدا ومرجع إلى المتغير threshold، وهو متغير حر داخل تعبير لامدا.

ثم تُمرَّر الدالة المغلقة إلى filterالدالة، التي تستدعيها بشكل متكرر لتحديد الكتب التي ستُضاف إلى قائمة النتائج والكتب التي ستُستبعد. ولأن الدالة المغلقة تحتوي على مرجع إلى متغير threshold، فإنها تستطيع استخدام هذا المتغير في كل مرة تستدعيها. قد تُعرَّف filterالدالة في ملف منفصل.filter

إليكم نفس المثال مُعاد كتابته بلغة TypeScript ، وهي لغة شائعة أخرى تدعم الدوال المغلقة:

// إرجاع قائمة بجميع الكتب التي بيع منها ما لا يقل عن "الحد الأدنى" من النسخ. دالة bestSellingBooks ( الحد الأدنى : رقم ) : Book [] { return bookList.filter ( book = > book.sales > = الحد الأدنى ); }

يتم استخدام عامل السهم =>لتعريف تعبير دالة السهم ، وطريقة ^{[ 8 ]} بدلاً من دالة عامة ، ولكن بخلاف ذلك Array.prototype.filterفإن بنية وتأثير الكود هما نفس الشيء.filter

قد تقوم الدالة بإنشاء إغلاق وإعادته، كما في هذا المثال:

نوع الدالة الأحادية = ( س : عدد ) => عدد ؛// تُعيد هذه الدالة دالة تُقارب مشتقة f // باستخدام فترة dx، والتي يجب أن تكون صغيرة بما يكفي. function derivative ( f : UnaryFunction , dx : number ) : UnaryFunction { return x => ( f ( x + dx ) - f ( x )) / dx ; }

لأن الإغلاق في هذه الحالة يستمر بعد انتهاء تنفيذ الدالة التي أنشأته، فإن المتغيرات fتبقى dxموجودة بعد انتهاء الدالة derivative، حتى بعد خروجها من نطاقها وعدم ظهورها. في اللغات التي لا تدعم الإغلاقات، يتزامن عمر المتغير المحلي التلقائي مع انتهاء إطار المكدس الذي تم فيه تعريف هذا المتغير. أما في اللغات التي تدعم الإغلاقات، فيجب أن تستمر المتغيرات في الوجود طالما أن أي إغلاقات موجودة تشير إليها. ويتم تنفيذ ذلك عادةً باستخدام نوع من أنواع جمع البيانات المهملة .

يمكن استخدام الإغلاق لربط دالة بمجموعة من المتغيرات " الخاصة "، التي تبقى موجودة حتى بعد استدعاء الدالة عدة مرات. يقتصر نطاق المتغير على الدالة المغلقة فقط، لذا لا يمكن الوصول إليه من أجزاء أخرى من البرنامج. تُشابه هذه المتغيرات الخاصة في البرمجة كائنية التوجه ، وفي الواقع، تُشبه الإغلاقات كائنات الدوال ذات الحالة (أو الدوال الوظيفية) التي تحتوي على دالة استدعاء واحدة.

في اللغات ذات الحالة، يمكن استخدام الدوال المغلقة لتطبيق نماذج تمثيل الحالة وإخفاء المعلومات ، نظرًا لأن قيم الدالة المغلقة (المتغيرات المغلقة) ذات مدى غير محدد ، وبالتالي تظل القيمة المُحددة في استدعاء واحد متاحة في الاستدعاء التالي. لا تتمتع الدوال المغلقة المستخدمة بهذه الطريقة بشفافية مرجعية ، وبالتالي لم تعد دوالًا خالصة ؛ ومع ذلك، فهي شائعة الاستخدام في اللغات الوظيفية غير الخالصة مثل Scheme .

للأغطية استخدامات عديدة:

• نظرًا لأنّ الدوال المغلقة تؤجل التقييم - أي أنها لا تُنفّذ أي شيء حتى يتم استدعاؤها - يُمكن استخدامها لتعريف هياكل التحكم. على سبيل المثال، جميع هياكل التحكم القياسية في لغة سمول توك ، بما في ذلك التفرعات (if/then/else) والحلقات (while و for)، مُعرّفة باستخدام كائنات تقبل توابعها الدوال المغلقة. كما يُمكن للمستخدمين تعريف هياكل التحكم الخاصة بهم بسهولة.
• في اللغات التي تُطبّق عملية الإسناد، يُمكن إنشاء دوال متعددة تعمل على نفس البيئة، مما يُتيح لها التواصل بشكل خاص عن طريق تغيير تلك البيئة. في لغة Scheme:

( define foo #f ) ( define bar #f )( let (( secret-message "none" )) ( set! foo ( lambda ( msg ) ( set! secret-message msg ))) ( set! bar ( lambda () secret-message )))( عرض ( الشريط )) ؛ يطبع "لا شيء" ( سطر جديد ) ( فو "قابلني عند الأرصفة عند منتصف الليل" ) ( عرض ( الشريط )) ؛ يطبع "قابلني عند الأرصفة عند منتصف الليل"

• يمكن استخدام الإغلاقات لتنفيذ أنظمة الكائنات . ^{[ 9 ]}

ملاحظة: يطلق بعض المتحدثين على أي بنية بيانات تربط بيئة معجمية اسم الإغلاق، لكن المصطلح يشير عادةً إلى الدوال على وجه التحديد.

بما أن اللغات المختلفة لا تتفق دائمًا على تعريف موحد للبيئة المعجمية، فقد تختلف تعريفاتها للإغلاق أيضًا. يُعرّف التعريف المبسط الشائع للبيئة المعجمية بأنها مجموعة جميع روابط المتغيرات ضمن النطاق، وهذا ما يجب أن تلتقطه الإغلاقات في أي لغة. مع ذلك، يختلف معنى ربط المتغير أيضًا. في اللغات الإجرائية، ترتبط المتغيرات بمواقع نسبية في الذاكرة يمكنها تخزين القيم. على الرغم من أن الموقع النسبي للربط لا يتغير أثناء التشغيل، إلا أن القيمة في الموقع المرتبط قد تتغير. في هذه اللغات، ولأن الإغلاق يلتقط الربط، فإن أي عملية على المتغير، سواء أُجريت من داخل الإغلاق أم لا، تُنفذ على نفس موقع الذاكرة النسبي. يُطلق على هذا غالبًا اسم التقاط المتغير "بالمرجع". إليك مثال يوضح هذا المفهوم في ECMAScript ، وهي إحدى هذه اللغات:

let f : () => number ; let g : () => number ; function foo () { let x : number ; f = () => ++ x ; g = () => -- x ; x = 1 ; console . log ( `inside foo, call to f(): ${ f () } ` ); } foo (); // 2 console . log ( `call to g(): ${ g () } ` ); // 1 (--x) console . log ( `call to g(): ${ g () } ` ); // 0 (--x) console . log ( `call to f(): ${ f () } ` ); // 1 (++x) console . log ( `call to f(): ${ f () } ` ); // 2 (++x)

تستخدم الدالة fooوالإغلاقات المشار إليها بواسطة المتغيرات fجميعها gنفس موقع الذاكرة النسبي المشار إليه بواسطة المتغير المحلي x.

في بعض الحالات، قد يكون السلوك المذكور أعلاه غير مرغوب فيه، ومن الضروري ربط إغلاق معجمي مختلف. في لغة ECMAScript، يتم ذلك باستخدام Function.bind().

^{[ 13 ]}

var module = { x : 42 , get () { return this . x ; } } var unboundGet = module . get ; console . log ( unboundGet ()); // يتم استدعاء الدالة في النطاق العام // تُصدر قيمة غير مُعرّفة لأن 'x' غير مُحددة في النطاق العام.var boundGet = unboundGet.bind ( module ); // تحديد وحدة الكائن كدالة مغلقة console.log ( boundGet ( ) ); // يُصدر 42

في هذا المثال، من المتوقع أن يقوم كل رابط بإصدار معرّفه عند النقر عليه؛ ولكن نظرًا لأن المتغير 'e' مرتبط بالنطاق أعلاه، ويتم تقييمه بشكل كسول عند النقر، فإن ما يحدث فعليًا هو أن كل حدث نقر يُصدر معرّف العنصر الأخير في 'elements' المرتبط في نهاية حلقة for . ^{[ 14 ]}

var elements = document.getElementsByTagName ( 'a' ); // خطأ: e مرتبط بالدالة التي تحتوي على حلقة 'for' ، وليس بإغلاق " handle " for ( var e of elements ) { e.onclick = function handle ( ) { console.log ( e.id ) ; } }

ومرة أخرى هنا، يجب ربط المتغير eبنطاق الكتلة باستخدام handle.bind(this)الكلمة المفتاحية `or` let.

من جهة أخرى، تربط العديد من لغات البرمجة الوظيفية، مثل ML ، المتغيرات مباشرةً بالقيم. في هذه الحالة، ولأنه لا توجد طريقة لتغيير قيمة المتغير بعد ربطه، فلا حاجة لمشاركة الحالة بين الدوال المغلقة، إذ تستخدم جميعها نفس القيم. يُطلق على هذا غالبًا اسم "التقاط المتغير بالقيمة". تندرج فئات Java المحلية والمجهولة أيضًا ضمن هذه الفئة، فهي تتطلب أن تكون المتغيرات المحلية الملتقطة من النوع المحدد final، مما يعني أيضًا عدم الحاجة لمشاركة الحالة.

تتيح بعض لغات البرمجة الاختيار بين تخزين قيمة المتغير أو موقعه. على سبيل المثال، في لغة C++11، تُعرَّف المتغيرات المخزنة إما باستخدام `require` [&]، أي التخزين بالمرجع، أو باستخدام ` [=]require`، أي التخزين بالقيمة.

وهناك فئة فرعية أخرى، وهي لغات البرمجة الوظيفية الكسولة مثل هاسكل ، التي تربط المتغيرات بنتائج العمليات الحسابية المستقبلية بدلاً من القيم. لنأخذ هذا المثال في هاسكل:

-- Haskell foo :: Fractional a => a -> a -> ( a -> a ) foo x y = ( \ z -> z + r ) حيث r = x / yf :: كسري a => a -> a f = foo 1 0main = print ( f 123 )

يرتبط الربط الذي rتم التقاطه بواسطة الإغلاق المُعرَّف داخل الدالة fooبالحساب (x / y)- والذي ينتج عنه في هذه الحالة القسمة على صفر. ومع ذلك، بما أن الحساب هو ما يتم التقاطه وليس القيمة، فإن الخطأ لا يظهر إلا عند استدعاء الإغلاق، ثم محاولة استخدام الربط الملتقط.

تظهر اختلافات أخرى في سلوك بنيات أخرى ذات نطاق معجمي، مثل عبارات return`require` breakو` continuerequire`. يمكن، بشكل عام، النظر إلى هذه البنيات من منظور استدعاء استمرار الهروب الذي أنشأته عبارة تحكم محيطة (في حالة `require` breakو`require` continue، يتطلب هذا التفسير النظر إلى بنيات التكرار من منظور استدعاءات الدوال المتكررة). في بعض اللغات، مثل ECMAScript، returnيشير `require` إلى الاستمرار الذي أنشأته الدالة المغلقة الأقرب معجميًا إلى عبارة `require` - وبالتالي، فإن `require` returnداخل دالة مغلقة ينقل التحكم إلى الكود الذي استدعاها. مع ذلك، في Smalltalk ، يستدعي المعامل `require`، المشابه ظاهريًا، ^استمرار الهروب الذي تم إنشاؤه لاستدعاء الدالة، متجاهلًا استمرارات الهروب لأي دوال مغلقة متداخلة. لا يمكن استدعاء استمرار الهروب لدالة مغلقة معينة في Smalltalk إلا ضمنيًا بالوصول إلى نهاية كود الدالة المغلقة. تُبرز هذه الأمثلة في ECMAScript وSmalltalk الفرق:

"Smalltalk" foo | xs | xs := #( 1 2 3 4 ) . xs do: [ : x | ^ x ] . ^ 0 bar Transcript show: ( self foo printString ) "prints 1"

// دالة ECMAScript foo ( ) : number { let xs : number [ ] = [ 1 , 2 , 3 , 4 ]; xs.forEach ( function ( x ) { return x ; }); return 0 ; } console.log ( foo ( )); // يطبع 0

ستختلف سلوكيات مقاطع الشفرة المذكورة أعلاه لأن ^عامل التشغيل في Smalltalk وعامل التشغيل في JavaScript returnليسا متماثلين. في مثال ECMAScript، return x;سيخرج من الإغلاق الداخلي لبدء تكرار جديد للحلقة forEach، بينما في مثال Smalltalk، ^xسينهي الحلقة ويعود من الدالة foo.

توفر لغة Common Lisp بنيةً تُتيح التعبير عن أيٍّ من الإجراءين المذكورين أعلاه: (return-from foo x)تتصرف Lisp كلغة Smalltalk^x ، بينما (return-from nil x)تتصرف Lisp كلغة JavaScriptreturn x . وبالتالي، تُتيح Smalltalk إمكانية استمرار استمرار الهروب المُلتقط لفترة أطول من مدى إمكانية استدعائه بنجاح. انظر إلى المثال التالي:

"Smalltalk" foo ^ [ : x | ^ x ] bar | f | f := self foo . f value: 123 "خطأ!"

عند استدعاء الدالة المغلقة التي تُعيدها الطريقة foo، فإنها تحاول إعادة قيمة من استدعاء الدالة التي fooأنشأت هذه الدالة المغلقة. ولأن هذا الاستدعاء قد أعاد قيمة بالفعل، ولأن نموذج استدعاء الدوال في لغة سمول توك لا يتبع مبدأ " مكدس الاستدعاءات المتشابكة" لتسهيل عمليات الإرجاع المتعددة، فإن هذه العملية تُؤدي إلى حدوث خطأ.

تتيح بعض لغات البرمجة، مثل روبي ، للمبرمج اختيار طريقة returnالتقاط البيانات. مثال على ذلك في روبي:

روبي# إغلاق باستخدام إجراء def foo f = Proc.new { return " العودة من foo من داخل الإجراء" } f.call # يغادر التحكم foo هنا return "العودة من foo" end# إغلاق باستخدام دالة لامدا def bar f = lambda { return "العودة من دالة لامدا" } f.call # لا يغادر التحكم bar هنا return "العودة من bar " endputs foo # يطبع "العودة من foo من داخل الإجراء" puts bar # يطبع "العودة من bar"

كلاهما Proc.newفي lambdaهذا المثال هما طريقتان لإنشاء إغلاق، لكن دلالات الإغلاقات التي تم إنشاؤها بهذه الطريقة تختلف فيما يتعلق بالعبارة return.

في لغة Scheme ، يكون تعريف ونطاق returnعبارة التحكم واضحين (وقد سُميت "return" بشكل اعتباطي لأغراض المثال فقط). فيما يلي ترجمة مباشرة لمثال Ruby.

; المخطط ( تعريف استدعاء/نسخة إلى استدعاء مع استمرارية حالية )( define ( foo ) ( call/cc ( lambda ( return ) ( define ( f ) ( return "return from foo from inside proc" )) ( f ) ; control leave foo here ( return "return from foo" ))))( define ( bar ) ( call/cc ( lambda ( return ) ( define ( f ) ( call/cc ( lambda ( return ) ( return "return from lambda" )))) ( f ) ; لا يغادر التحكم bar هنا ( return "return from bar" ))))( display ( foo )) ; يطبع "العودة من foo من داخل الإجراء" ( newline ) ( display ( bar )) ; يطبع "العودة من bar"

تدعم بعض مكتبات لغة C دوال الاستدعاء . ويتم ذلك أحيانًا بتوفير قيمتين عند تسجيل دالة الاستدعاء في المكتبة: مؤشر دالة ومؤشر منفصل void*إلى بيانات يختارها المستخدم. عند تنفيذ المكتبة لدالة الاستدعاء، فإنها تمرر مؤشر البيانات. وهذا يمكّن دالة الاستدعاء من الاحتفاظ بحالتها والرجوع إلى المعلومات التي تم جمعها وقت تسجيلها في المكتبة. يشبه هذا الأسلوب الدوال المغلقة في الوظائف، ولكنه يختلف في الصيغة. فالمؤشر void*غير آمن من حيث النوع ، لذا يختلف هذا الأسلوب في لغة C عن الدوال المغلقة الآمنة من حيث النوع في لغات C# و Haskell و ML.

تُستخدم عمليات الاستدعاء على نطاق واسع في مجموعات أدوات واجهة المستخدم الرسومية (GUI) لتنفيذ البرمجة القائمة على الأحداث من خلال ربط الوظائف العامة للعناصر الرسومية (القوائم، والأزرار، ومربعات الاختيار، والمنزلقات، والدوارات، وما إلى ذلك) بوظائف خاصة بالتطبيق لتنفيذ السلوك المطلوب المحدد للتطبيق.

#include <stdio.h>typedef int ( * FnIntToInt )( int ); // نوع الدالة int->intFnIntToInt adder ( int number ) { int add ( int value ) { return value + number ; } return & add ; // عامل & اختياري هنا لأن اسم الدالة في لغة C هو مؤشر يشير إلى نفسه }int main ( void ) { FnIntToInt add10 = adder ( 10 ); printf ( "%d \n " , add10 ( 1 )); return 0 ; }

#include <stdio.h>typedef int ( * FnIntToInt )( int ); // نوع الدالة int->intint main ( void ) { FnIntToInt adder ( int number ) { int add ( int value ) { return value + number ; } return add ; } FnIntToInt add10 = adder ( 10 ); printf ( "%d \ n " , add10 ( 1 )); return 0 ; }

تُمكّن لغة جافا من تعريف الأصناف داخل الدوال . تُسمى هذه الأصناف بالأصناف المحلية . وعندما لا تُسمى هذه الأصناف، تُعرف بالأصناف المجهولة (أو الأصناف الداخلية المجهولة ). يمكن للصنف المحلي (سواء كان مُسمى أو مجهولًا) أن يُشير إلى أسماء في الأصناف المُحيطة به، أو إلى متغيرات للقراءة فقط (مُعلّمة بـ final) في الدالة المُحيطة به.

استيراد java.net.URI ؛ استيراد javax.swing.JFrame ؛class CalculationWindow extends JFrame { private volatile int result ; // ... public void calculateInSeparateThread ( final URI uri ) { // التعبير "new Runnable() { ... }" هو فئة مجهولة تُنفذ واجهة 'Runnable'. Thread t = new Thread ( new Runnable () { @Override void run () { // يمكنه قراءة المتغيرات المحلية النهائية: calculate ( uri ); // يمكنه الوصول إلى الحقول الخاصة للفئة المُحيطة: result += 10 ; } } ); t . start (); } }

تتيح خاصية التقاط finalالمتغيرات إمكانية التقاطها حسب قيمتها. حتى لو كان المتغير المراد التقاطه غير ثابت final، يمكن دائمًا نسخه إلى finalمتغير مؤقت قبل استدعاء الفئة مباشرةً.

يمكن محاكاة عملية التقاط المتغيرات بالمرجع باستخدام finalمرجع إلى حاوية قابلة للتغيير، مثل مصفوفة ذات عنصر واحد. لن يتمكن الصنف المحلي من تغيير قيمة مرجع الحاوية، ولكنه سيتمكن من تغيير محتويات الحاوية.

مع ظهور تعابير لامدا في جافا 8، ^{[ 16 ]} يؤدي الإغلاق إلى تنفيذ الكود أعلاه على النحو التالي:

استيراد java.net.URI ؛ استيراد javax.swing.JFrame ؛class CalculationWindow extends JFrame { private volatile int result ; // ... public void calculateInSeparateThread ( final URI uri ) { // The code () -> { /* code */ } is a closure. Thread t = new Thread (() -> { calculate ( uri ); result += 10 ; }); t . start (); } }

تُعدّ الفئات المحلية أحد أنواع الفئات الداخلية التي تُصرّح داخل جسم الدالة. كما تدعم لغة جافا الفئات الداخلية المُصرّحة كأعضاء غير ثابتة في الفئة المُحيطة. ^{[ 17 ]} ويُشار إليها عادةً باسم "الفئات الداخلية". ^{[ 18 ]} تُعرّف هذه الفئات في جسم الفئة المُحيطة، ولها حق الوصول الكامل إلى متغيرات مثيل الفئة المُحيطة. ونظرًا لارتباطها بهذه المتغيرات، لا يُمكن إنشاء مثيل للفئة الداخلية إلا بربط صريح بمثيل من الفئة المُحيطة باستخدام صيغة خاصة. ^{[ 19 ]}

public class EnclosingClass { // تعريف الفئة الداخلية: public class InnerClass { public int incrementAndReturnCounter () { return counter ++ ; } }private int counter ; { counter = 0 ; }public int getCounter () { return counter ; }public static void main ( String [] args ) { EnclosingClass enclosingClassInstance = new EnclosingClass (); // إنشاء نسخة من الفئة الداخلية، مع ربطها بالمثيل EnclosingClass . InnerClass innerClassInstance = enclosingClassInstance . new InnerClass ();for ( int i = enclosingClassInstance.getCounter ( ) ; ( i = innerClassInstance.incrementAndReturnCounter ( ) ) < 10 ; // تم حذف خطوة الزيادة ) { System.out.println ( i ) ; } } }

عند التنفيذ، سيتم طباعة الأعداد الصحيحة من 0 إلى 9. احذر من الخلط بين هذا النوع من الفئات والفئة المتداخلة، والتي يتم تعريفها بنفس الطريقة مع استخدام مُعدِّل "static"؛ فهذه الفئات لا تحقق التأثير المطلوب، بل هي مجرد فئات بدون ربط خاص مُعرَّف في فئة مُغلِّفة.

ابتداءً من Java 8 ، تدعم Java الدوال ككائنات من الدرجة الأولى. تُعتبر تعابير Lambda من هذا النوع من النوع java.util.function.Function<T, U>T، حيث يُمثل T المجال وU نوع الصورة. يمكن استدعاء التعبير باستخدام دالته Function.apply(T t)، ولكن ليس باستخدام استدعاء دالة قياسي.

استيراد java.util.function.Function ;دالة < سلسلة نصية ، عدد صحيح > الطول = s - > s . الطول ( ) ; النظام.الإخراج.طباعة ( الطول.تطبيق ( " مرحباً بالعالم!" ) ) ; // يطبع '13'

قدمت شركة Apple الكتل ، وهي شكل من أشكال الإغلاق، كامتداد غير قياسي في لغات C و C++ و Objective-C 2.0 وفي نظام التشغيل Mac OS X 10.6 "Snow Leopard" ونظام التشغيل iOS 4.0 . وقد أتاحت Apple تطبيقها لمترجمي GCC و clang.

تُعلَّم المؤشرات إلى الكتل والقيم الحرفية للكتل بعلامة ^. تُخزَّن المتغيرات المحلية العادية بالقيمة عند إنشاء الكتلة، وتكون للقراءة فقط داخل الكتلة. تُعلَّم المتغيرات التي سيتم تخزينها بالمرجع بعلامة __block. قد يلزم نسخ الكتل التي تحتاج إلى البقاء خارج النطاق الذي أُنشئت فيه. ^{[ 20 ] [ 21 ]}

typedef int ( ^ IntBlock )();دالة ` downCounter` من نوع ` int` تأخذ مصفوفة ` start` كمدخل ، وتعيد مصفوفة ` int` تحتوي على ` start` و` copy` و` autorelease` .​​​IntBlock f = downCounter ( 5 ); NSLog ( @"%d" , f ()); NSLog ( @"%d" , f ()); NSLog ( @"%d" , f ());

تدعم الطرق المجهولة في لغة C# وتعبيرات لامدا خاصية الإغلاق:

باستخدام System.Collections.Generic ؛int [] data = new [ ]{ 1 , 2 , 3 , 4 } ; int multiplier = 2 ; List <int> result = data.Select ( x = > x * multiplier ) ;

يدعم Visual Basic .NET ، الذي يحتوي على العديد من ميزات اللغة المشابهة لتلك الموجودة في C#، تعبيرات لامدا مع الإغلاقات:

Dim data = { 1 , 2 , 3 , 4 } Dim multiplier = 2 Dim result = data . Select ( Function ( x ) x * multiplier )

في لغة D ، يتم تنفيذ الإغلاقات بواسطة المندوبين، وهو مؤشر دالة مقترن بمؤشر سياق (على سبيل المثال مثيل فئة، أو إطار مكدس على الكومة في حالة الإغلاقات).

auto test1 () { int a = 7 ; return delegate () { return a + 3 ; }; // إنشاء مندوب مجهول }auto test2 () { int a = 20 ; int foo () { return a + 5 ; } // دالة داخلية return & foo ; // طريقة أخرى لإنشاء المندوب }void bar () { auto dg = test1 (); dg (); // 10 (حسنًا: test1.a موجود داخل دالة مغلقة وما زال موجودًا)dg = test2 (); dg (); // 25 (حسنًا: test2.a موجود داخل دالة مغلقة وما زال موجودًا) }

يُوفر الإصدار الأول من لغة D دعمًا محدودًا للدوال المغلقة. على سبيل المثال، لن يعمل الكود المذكور أعلاه بشكل صحيح، لأن المتغير a موجود في مكدس الذاكرة، وبعد انتهاء الدالة test()، يصبح استخدامه غير صالح (على الأرجح، استدعاء الدالة foo عبر الدالة dg() سيعيد عددًا صحيحًا عشوائيًا). يمكن حل هذه المشكلة بتخصيص المتغير a صراحةً في الذاكرة الديناميكية، أو باستخدام هياكل البيانات أو الفئات لتخزين جميع المتغيرات المغلقة المطلوبة، وإنشاء دالة تفويض من دالة تُنفذ نفس الكود. يمكن تمرير الدوال المغلقة إلى دوال أخرى، طالما أنها تُستخدم فقط أثناء صلاحية القيم المُشار إليها (على سبيل المثال، استدعاء دالة أخرى باستخدام دالة مغلقة كمعامل رد نداء)، وهي مفيدة لكتابة كود معالجة بيانات عام ، لذا فإن هذا القيد، عمليًا، لا يُمثل مشكلة في أغلب الأحيان.

تم تدارك هذا القيد في الإصدار الثاني من لغة D، حيث يتم تخصيص المتغير 'a' تلقائيًا في الذاكرة الديناميكية (heap) لأنه يُستخدم في الدالة الداخلية، ويمكن لمندوب تلك الدالة الخروج من النطاق الحالي (عن طريق إسناد قيمة إلى dg أو إرجاع قيمة). أما المتغيرات المحلية الأخرى (أو الوسائط) التي لا يُشار إليها بواسطة المندوبين، أو التي يُشار إليها فقط بواسطة مندوبين لا يخرجون من النطاق الحالي، فتبقى في مكدس الذاكرة (stack)، وهو ما يُعد أبسط وأسرع من التخصيص في الذاكرة الديناميكية. وينطبق الأمر نفسه على توابع الفئة الداخلية التي تُشير إلى متغيرات الدالة.

تُمكّن لغة C++ من تعريف كائنات الدوال عبر التحميل الزائد operator(). تتصرف هذه الكائنات بشكلٍ مشابه للدوال في لغات البرمجة الوظيفية. يمكن إنشاؤها أثناء التشغيل، وقد تحتوي على حالة، لكنها لا تستحوذ ضمنيًا على المتغيرات المحلية كما تفعل الدوال المغلقة. بدءًا من إصدار 2011 ، تدعم لغة C++ أيضًا الدوال المغلقة، وهي نوع من كائنات الدوال يتم إنشاؤها تلقائيًا من بنية لغوية خاصة تُسمى تعبير لامدا . يمكن للدالة المغلقة في C++ أن تستحوذ على سياقها إما بتخزين نسخ من المتغيرات التي يتم الوصول إليها كأعضاء في كائن الدالة المغلقة، أو بالمرجع. في الحالة الأخيرة، إذا خرج كائن الدالة المغلقة عن نطاق الكائن المُشار إليه، فإن استدعاءه operator()يُسبب سلوكًا غير مُحدد، لأن الدوال المغلقة في C++ لا تُمدد عمر سياقها.

استيراد std ؛باستخدام std :: string ؛ باستخدام std :: vector ؛void foo ( string & name ) { int n = 100 ; vector < string > v ; // ...// i من نوع vector<string>::iterator auto i = std::ranges::find_if(v, [&](const string& s)->bool { return s != name && s.size ( ) > n ; } ) ; // ' i ' الآن إما ' v.end ( ) ' أو يشير إلى السلسلة الأولى في ' v ' // التي لا تساوي ' name ' وطولها أكبر من 'n' }

تحتوي لغة C++ أيضًا على كائن std::function<R(Args...)>لتخزين الدوال المجهولة. ^{[ 22 ]} ومع ذلك، نظرًا لأن الدوال المجهولة لها أسماء مُولَّدة بواسطة المُصرِّف وهي مُختلفة، فإن تخزين إحداها كـ std::functionيستخدم حذف النوع مما يُسبب عبئًا إضافيًا طفيفًا.

تتضمن لغة إيفل عوامل مضمنة تُعرّف الدوال المغلقة. العامل المضمن هو كائن يُمثل روتينًا، ويتم تعريفه من خلال كتابة رمز الروتين بشكل مضمن. على سبيل المثال، في

ok_button.click_event.subscribe ( agent ( x , y : INTEGER ) do map.country_at_coordinates ( x , y ) .display end )​​​​​​

الوسيط المُستخدم subscribeهو وكيل، يُمثل إجراءً ذا وسيطين؛ يحدد هذا الإجراء الدولة عند الإحداثيات المُقابلة ويعرضها. الوكيل بأكمله "مُشترك" في نوع الحدث click_eventلزر مُعين، بحيث كلما حدث هذا النوع من الأحداث على ذلك الزر - نتيجةً لنقر المستخدم عليه - سيتم تنفيذ الإجراء مع تمرير إحداثيات الفأرة كوسيطات للدالتين xو y.

يتمثل القيد الرئيسي لوكلاء إيفل، والذي يميزهم عن الدوال المغلقة في اللغات الأخرى، في عدم قدرتهم على الإشارة إلى المتغيرات المحلية من النطاق المحيط. يساعد هذا القرار التصميمي في تجنب الغموض عند الحديث عن قيمة متغير محلي في دالة مغلقة - هل يجب أن تكون أحدث قيمة للمتغير أم القيمة التي تم التقاطها عند إنشاء الوكيل؟ لا يمكن الوصول من داخل جسم الوكيل إلا إلى Currentمرجع للكائن الحالي (مماثل لـ `<object>` thisفي جافا)، وخصائصه، ومعاملاته. ويمكن تمرير قيم المتغيرات المحلية الخارجية بتوفير معاملات مغلقة إضافية للوكيل.

يوفر Embarcadero C++Builder الكلمة المحجوزة__closure لتوفير مؤشر إلى طريقة ذات بنية مشابهة لمؤشر الدالة. ^{[ 23 ]}

تسمح لغة C القياسية بكتابة تعريف نوع (typedef) لمؤشر إلى نوع دالة باستخدام الصيغة التالية:

typedef void ( * TMyFunctionPointer )( void );

وبالمثل، typedefيمكن تعريف مؤشر إلى دالة باستخدام هذه الصيغة:

typedef void ( __closure * TMyMethodPointer )();