فهم القوائم

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

بدأت لغة بايثون في تقديم صيغة لفهم المجموعات بدءًا من الإصدار 2.7. تشبه هذه الصيغة في شكلها فهم القوائم، حيث تقوم بتكوين مجموعات بايثون بدلاً من القوائم.

s : set [ str ] = { v for v in "ABCDABCD" if v not in "CB" } print ( s ) # يطبع {'A', 'D'} print ( type ( s )) # يطبع <class 'set'>

تُنتج عبارات فهم مجموعات Racket مجموعات Racket بدلاً من القوائم.

( for/set ([ v "ABCDABCD" ] #:unless ( member v ( string->list "CB" ))) v ))

قدمت لغة بايثون صيغة جديدة لفهم القواميس في الإصدار 2.7، وهي مشابهة في الشكل لفهم القوائم ولكنها تولد قواميس بايثون بدلاً من القوائم.

s : dict [ str ] = { key : val for key , val in enumerate ( "ABCD" ) if val not in "CB" } print ( s ) # يطبع {0: 'A', 3: 'D'}

تقوم عبارات فهم جداول التجزئة في Racket بإنشاء جداول التجزئة في Racket (أحد تطبيقات نوع قاموس Racket).

( for/hash ([( val key ) ( in-indexed "ABCD" )] #:unless ( member val ( string->list "CB" ))) ( values ​​key val ))

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

-- فهم القوائم المنتظمة a = [( x , y ) | x <- [ 1 .. 5 ], y <- [ 3 .. 5 ]] -- [(1,3),(1,4),(1,5),(2,3),(2,4) ...-- فهم القائمة المضغوطة b = [( x , y ) | ( x , y ) <- zip [ 1 .. 5 ] [ 3 .. 5 ]] -- [(1,3),(2,4),(3,5)]-- فهم القوائم المتوازية c = [( x , y ) | x <- [ 1 .. 5 ] | y <- [ 3 .. 5 ]] -- [(1,3),(2,4),(3,5)]

تحتوي مكتبة Racket القياسية للفهم على إصدارات متوازية ومتداخلة من عمليات الفهم، ويُفرّق بينها باستخدام "for" مقابل "for*" في الاسم. على سبيل المثال، تُنشئ عمليات فهم المتجهات "for/vector" و"for*/vector" متجهات من خلال التكرار المتوازي مقابل التكرار المتداخل على المتتاليات. فيما يلي كود Racket لأمثلة فهم القوائم في Haskell.

> ( for*/list ([ x ( in-range 1 6 )] [ y ( in-range 3 6 )]) ( list x y )) ' (( 1 3 ) ( 1 4 ) ( 1 5 ) ( 2 3 ) ( 2 4 ) ( 2 5 ) ( 3 3 ) ( 3 4 ) ( 3 5 ) ( 4 3 ) ( 4 4 ) ( 4 5 ) ( 5 3 ) ( 5 4 ) ( 5 5 )) > ( for/list ([ x ( in-range 1 6 )] [ y ( in-range 3 6 )]) ( list x y )) ' (( 1 3 ) ( 2 4 ) ( 3 5 ))

في لغة بايثون، يمكننا القيام بما يلي:

# بناء قائمة عادية a : list [ tuple [ int , int ]] = [( x , y ) for x in range ( 1 , 6 ) for y in range ( 3 , 6 )] print ( a ) # يطبع [(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), ... # بناء قائمة متوازية/مضغوطة b : list [ tuple [ int , int ]] = [ x for x in zip ( range ( 1 , 6 ), range ( 3 , 6 ))] print ( b ) # يطبع [(1, 3), (2, 4), (3, 5)]

في لغة جوليا، يمكن تحقيق نفس النتائج عمليًا على النحو التالي:

# فهم المصفوفات العادية a :: Vector { Tuple { Int , Int }} = [( x , y ) for x in 1 : 5 for y in 3 : 5 ]# فهم المصفوفات المتوازية/المضغوطة b :: Vector { Tuple { Int , Int }} = [ x for x in zip ( 1 : 3 , 3 : 5 )]

مع الاختلاف الوحيد وهو أنه بدلاً من القوائم، لدينا في جوليا مصفوفات.

مثل استخدام NPL الأصلي، فإن هذه لغات وصول إلى قواعد البيانات بشكل أساسي.

وهذا يجعل مفهوم الفهم أكثر أهمية، لأنه من غير الممكن حسابيًا استرداد القائمة بأكملها والعمل عليها (قد تكون "القائمة الكاملة" الأولية عبارة عن قاعدة بيانات كاملة للغة الترميز القابلة للتوسيع ( XML )).

في لغة XPath، التعبير هو:

/ مكتبة / كتاب // فقرة [ @style = 'first-in-chapter' ]

يتم تقييمها من الناحية المفاهيمية على أنها سلسلة من "الخطوات" حيث تنتج كل خطوة قائمة وتقوم الخطوة التالية بتطبيق دالة تصفية على كل عنصر في مخرجات الخطوة السابقة. ^{[ 4 ]}

في XQuery، يتوفر XPath الكامل، ولكن يتم استخدام عبارات FLWOR أيضًا، وهي بنية فهم أكثر قوة. ^{[ 5 ]}

for $ b in // book where $ b [ @pages < 400 ] order by $ b // title return <shortBook> <title> { $ b // title } </title> <firstPara> {( $ book // paragraph )[ 1 ]} </firstPara> </shortBook>

هنا يتم تقييم XPath //book لإنشاء تسلسل (يُعرف أيضًا باسم قائمة)؛ عبارة where هي "مرشح" وظيفي، و order by يقوم بفرز النتيجة، ومقتطف XML هو في الواقع دالة مجهولة تقوم بإنشاء/تحويل XML لكل عنصر في التسلسل باستخدام نهج "map" الموجود في لغات البرمجة الوظيفية الأخرى.<shortBook>...</shortBook>

لذا، في لغة برمجة وظيفية أخرى، يمكن تنفيذ عبارة FLWOR المذكورة أعلاه على النحو التالي:

map ( newXML ( shortBook , newXML ( title , $ 1.title ) , newXML ( firstPara , $ 1 ... )) filter ( lt ( $ 1.pages , 400 ), xpath (// book ) ) )

يحتوي C# 3.0 على مجموعة من الميزات ذات الصلة تسمى الاستعلام المتكامل للغة (LINQ)، والتي تحدد مجموعة من عوامل تشغيل الاستعلام لمعالجة تعدادات الكائنات .

باستخدام System.Collections.Generic ؛ باستخدام System.Linq ؛IEnumerable <int> s = Enumerable.Range ( 0 , 100 ) .Where ( x = > x * x > 3 ) .Select ( x = > x * 2 ) ;​

كما أنها توفر صيغة فهم بديلة، تذكرنا بلغة الاستعلامات المهيكلة ( SQL ):

باستخدام System.Collections.Generic ؛ باستخدام System.Linq ؛IEnumerable <int> s = from x in Enumerable.Range ( 0 , 100 ) where x * x > 3 select x * 2 ;​​​​

يوفر LINQ ميزةً تتجاوز تطبيقات بناء القوائم التقليدية. فعندما يُطبّق الكائن الجذري للبناء الواجهة IQueryable، بدلاً من مجرد تنفيذ الأساليب المتسلسلة للبناء، يتم تحويل سلسلة الأوامر بأكملها إلى كائن شجرة بناء جملة مجردة (AST)، والذي يتم تمريره إلى كائن IQueryable لتفسيره وتنفيذه.

وهذا يتيح القيام بالعديد من الأمور، بما في ذلك تمكين IQueryable من:

• أعد كتابة فهم غير متوافق أو غير فعال
• قم بترجمة شجرة بناء الجملة المجردة (AST) إلى لغة استعلام أخرى (مثل SQL) لتنفيذها

لا تحتوي لغة C++ على ميزات لغوية تدعم بشكل مباشر إنشاء قوائم الفهم، ولكن تم استخدام تحميل المعاملات الزائد (مثل تحميل المعاملات الزائدة |) >>لتوفير بنية معبرة للغات الاستعلام الخاصة بالمجال "المضمنة" . بدلاً من ذلك، يمكن إنشاء قوائم الفهم باستخدام أسلوب الحذف والإزالة لاختيار العناصر في حاوية، وخوارزمية STL لتحويلها.>>=for_each

تاريخيًا، <algorithm>كان ملف الرأس يحتوي فقط على خوارزميات تعتمد على المُكرِّرات على نطاق من العناصر. ^{[ 6 ]} تم توسيع هذا لاحقًا في C++20 بإضافة خوارزميات مقيدة (في مساحة الاسم std::ranges) إلى ملف الرأس هذا، والتي تعمل على نطاق بدلاً من المُكرِّرات. ^{[ 7 ]}

استيراد std ؛باستخدام std :: vector ;template < typename Collection , typename Pred , typename Trans > Collection comprehend ( Collection && source , const Pred & predicate , const Trans & transformation ) { // تهيئة الوجهة Collection d = std :: forward < Collection > ( source );// تصفية العناصر d.erase ( std :: ranges :: remove_if ( d , predicate ), d.end ( ) ) ;// تطبيق التحويل std :: ranges :: for_each ( d , transformation );أعد د ؛ }int main ( int argc , char * argv []) { vector < int > range ( 10 ); // range عبارة عن قائمة من 10 عناصر، جميعها أصفار std :: ranges :: iota ( range , 1 ); // range الآن تحتوي على 1، 2، ...، 10vector <int> result = comprehend ( range , []( int x ) -> bool { return x * x <= 3 ; }, []( int & x ) - > void { x *= 2 ; } ); // result now contains 4, 6, ..., 20 }

<ranges>في C++20، أُضيفت ملفات رأسية إضافية، مثل `..`، والتي تتميز بخوارزميات نطاق قابلة للتركيب وعرض مُقَيَّم بشكل كسول على أي نطاق. باستخدام std::ranges::viewsالمكتبة `..` (المختصرة أيضًا بـ std::views`..`) ^{[ 8 ]} ، يمكن كتابة هذا على النحو التالي:

باستخدام std :: vector ؛ باستخدام std :: ranges :: to ؛ باستخدام std :: views :: filter ؛ باستخدام std :: views :: transform ؛vector <int> range ( 10 ); // range عبارة عن قائمة من 10 عناصر، جميعها أصفار std :: ranges :: iota ( range , 1 ); // range الآن تحتوي على 1، 2، ...، 10vector <int> result = range | filter ([]( int x ) - > bool { return x * x > 3 ; } ) | transform ([]( int x ) - > int { return x * 2 ; }) | to <vector> ( );

قدمت واجهة برمجة تطبيقات Streams في Javajava.util.stream.Stream 8 كائنًا شبيهًا بالنطاق يتم تقييمه عند الحاجة، يُسمى stream. يمكن استخدام أي نوع يُنفذ هذه الواجهة مع streams. ^{[ 9 ]} يمكن تجميع هذه الكائنات بواسطة toArray()`or` toList()، حيث تُجمع العناصر في ` Object[]or` List<T>.

استيراد java.util.List ;List <Integer> numbers = List.of ( 1 , 2 , 3 , 4 , 5 ) ; List <Integer> doubledEven = numbers.stream ( ) . filter ( x - > x % 2 == 0 ) .map ( x - > x * 2 ) .toList ( ) ;​​​​System.out.println ( doubledEven ) ; // [ 4 , 8 ]

تحتوي لغة Ruststd::iter::Iterator على مُكرِّرات، يتم تقييمها بشكل كسول. يمكن استخدام أي نوع يُطبِّق هذه السمة مع المُكرِّرات. ^{[ 10 ]} باستخدام هذه الطرق، يتم إنشاء سلسلة من مُهايئات المُكرِّرات، والتي يتم جمعها في النهاية collect()في مجموعة فعلية (عادةً Vec<T>).

let numbers = vec! [ 1 , 2 , 3 , 4 , 5 ]; let doubled_even : Vec < i32 > = numbers . iter () . filter ( |& x | x % 2 == 0 ) . map ( | x | x * 2 ) . collect ();println! ( "{:?} " , doubled_even ); // [4, 8]

• أمثلة على تدفق البديهيات

• توثيق واجهة برمجة تطبيقات Clojure - للماكرو

• تنفيذ ماكرو فهم لغة ليسب بواسطة جاي لابالم

• تقرير هاسكل 98، الفصل 3.11: فهم القوائم .
• دليل مستخدم نظام تجميع Glasgow Haskell الرائع، الفصل 7.3.4: فهم القوائم المتوازية .
• دليل مستخدم Hugs 98، الفصل 5.1.2 فهم القوائم المتوازية (المعروفة أيضًا باسم فهم zip) .

• بطاريات OCaml متضمنة
• إضافات اللغة المُقدمة في OCaml Batteries Included (مؤرشفة بتاريخ 3 مارس 2016 على موقع Wayback Machine)

• درس بايثون التعليمي، فهم القوائم .
• مرجع لغة بايثون، عرض القوائم .
• اقتراح تحسين بايثون PEP 202: فهم القوائم .
• مرجع لغة بايثون، تعابير المولد .
• اقتراح تحسين بايثون PEP 289: تعابير المولد .