مقارنة لغات البرمجة (فهم القوائم)

قائمة بجميع الأرقام المزدوجة من 0 إلى 10 (حصرية)

doubles = [ i * 2 for i in range ( 10 )]

قائمة بأسماء العملاء المقيمين في ريو دي جانيرو

عملاء RJ = [ اسم العميل في قائمة العملاء إذا كانت ولاية العميل هي " RJ " ]

يمكن للغة C++std::views استخدام مساحة الاسم، التي تم تقديمها في C++20 .

باستخدام std :: vector ؛ باستخدام std :: ranges :: to ؛ باستخدام std :: views :: filter ؛ باستخدام std :: views :: transform ؛vector <int> ns = std :: views :: iota ( 0 , 100 ) | filter ([]( int x ) -> bool { return x * x > 3 ; }) | transform ( [ ]( int x ) - > int { return x * 2 ; }) | to <vector> ( );

IEnumerable <int> ns = from x in Enumerable.Range ( 0 , 100 ) where x * x > 3 select x * 2 ;​​​​

الكود السابق هو اختصار برمجي للكود التالي المكتوب باستخدام تعابير لامدا:

IEnumerable <int> ns = Enumerable.Range ( 0 , 100 ) .Where ( x = > x * x > 3 ) .Select ( x = > x * 2 ) ;​​​

تصفية الأرقام القابلة للقسمة على 3:

القيمة divisibleBy3 = { for ( i in 0 .. 100 ) if ( i % 3 == 0 ) i }; // نوع divisibleBy3 هو Iterable<Integer>

مولدات متعددة:

القيم الثلاثية = { for ( x in 0 .. 20 ) for ( y in x .. 20 ) for ( z in y .. 20 ) if ( x * x + y * y == z * z ) [ x , y , z ] }; // نوع الثلاثيات هو Iterable<Integer[3]>

سلسلة كسولة لا نهائية:

( for [x ( iterate inc 0 ) :when ( > ( * x x ) 3 ) ] ( * 2 x ))

فهم القوائم باستخدام مولدات متعددة:

( for [x ( range 20 ) y ( range 20 ) z ( range 20 ) :when ( == ( + ( * x x ) ( * y y )) ( * z z )) ] [x y z] )

يمكن التعبير عن عبارات فهم القوائم باستخدام الكلمة المفتاحية loopللماكرو collect. أما العبارات الشرطية فتُعبّر عنها باستخدام if، كما يلي:

( حلقة تكرارية لـ x من 0 إلى 100 إذا ( > ( * xx ) 3 ) اجمع ( * 2x ) )

اذكر أسماء العملاء:

أسماء = لكل عميل في العملاء احصل على اسم العميل

قائمة العملاء الذين لديهم أرصدة:

أسماء = لكل عميل في قائمة العملاء حيث رصيد العميل > 0

اذكر أسماء العملاء الذين لديهم أرصدة:

أسماء العملاء = لكل عميل في قائمة العملاء حيث رصيد العميل > 0 احصل على اسم العميل

الأشكال العامة:

لكل متغير في مجموعة قابلة للتعداد [ حيث الشرط ] احصل على تعبير لكل متغير في مجموعة قابلة للتعداد حيث الشرط

لاحظ أنه من خلال وضع الشرط والتعبير بعد اسم المتغير والكائن القابل للتعداد، يمكن للمحررات وبيئات التطوير المتكاملة توفير الإكمال التلقائي لأعضاء المتغير.

التسلسلات التي يتم تقييمها بكسل:

seq { for x in 0 .. 100 do if x * x > 3 then yield 2 * x }

أو، بالنسبة للقيم العشرية

seq { for x in 0 . .. 100 . do if x ** 2 . > 3 . then yield 2 .* x }

القوائم والمصفوفات:

[ for x in 0 . .. 100 . do if x ** 2 . > 3 . then yield 2 .* x ] [| for x in 0 . .. 100 . do if x ** 2 . > 3 . then yield 2 .* x |]

تُعدّ تعابير فهم القوائم جزءًا من عائلة أكبر من بنى اللغة تسمى تعابير الحساب.

[ x * 2 | x <- [ 0 .. 99 ], x * x > 3 ]

مثال على فهم القوائم باستخدام مولدات متعددة:

الثعبان = [( x , y , z ) | x <- [ 1 .. 20 ], y <- [ x .. 20 ], z <- [ y .. 20 ], x ^ 2 + y ^ 2 == z ^ 2 ]

باستخدام كائن النطاق، يمكن للغة Io إنشاء قائمة بسهولة كما هو الحال في اللغات الأخرى:

النطاق من 0 إلى 100 ، ثمّ حدّد ( x ، x * x > 3 ) ، ثمّ حوّل (* 2 ) .

يمكن التعبير عن تراكيب القوائم باستخدام forالصيغة الخاصة. أما العبارات الشرطية فتُعبّر عنها باستخدام if، كما يلي:

( لـ (( x0 ( + x1 ) ) ( جمع ( ) )) (( >= x100 ) ( عكس الجمع )) ( إذا كان ( > ( * xx ) 3 ) ( ضبط مجموعة الجمع ( cons ( * x2 ) جمع ) )))

تدعم لغة جوليا التعبيرات المترابطة باستخدام الصيغة التالية:

y = [ x ^ 2 + 1 for x in 1 : 10 ]

وفهم متعدد الأبعاد مثل:

z = [( x - 5 ) ^ 2 + ( y - 5 ) ^ 2 for x = 0 : 10 , y = 0 : 10 ]

من الممكن أيضاً إضافة شرط:

v = [ 3 x ^ 2 + 2 y ^ 2 for x in 1 : 7 for y in 1 : 7 if x % y == 0 ]

وبمجرد تغيير الأقواس المربعة إلى أقواس دائرية، نحصل على مولد:

g = ( 3 x ^ 2 + 2 y ^ 2 for x in 1 : 7 for y in 1 : 7 if x % y == 0 )

s = [ 2*i for i in 1..100 where i*i > 3 ];

مولدات متعددة:

pyth = [ (x,y,z) for x in 1..20 for y in x..20 for z in y..20 where x*x + y*y == z*z ];

يحتوي Nim على تسلسلات مدمجة، ومجموعات، وجداول، وفهم الكائنات في وحدة مكتبة sugar القياسية: ^{[ 1 ]}

استيراد السكرlet variable = collect ( newSeq ): for item in @[ - 9 , 1 , 42 , 0 , -1 , 9 ] : item + 1assert variable == @[- 8 , 2 , 43 , 1 , 0 , 10 ]

يتم تنفيذ الفهم كوحدة ماكرو يتم توسيعها في وقت الترجمة، ويمكنك رؤية الكود الموسع باستخدام خيار المترجم expandMacro :

var collectResult = newSeq ( Natural ( 0 )) for item in items ( @[- 9 , 1 , 42 , 0 , -1 , 9 ] ) : add ( collectResult , item + 1 ) collectResult

يمكن أن تكون العبارات المترابطة متداخلة ومتعددة الأسطر:

استيراد السكرlet values ​​= collect ( newSeq ): for val in [ 1 , 2 ] : collect ( newSeq ): for val2 in [ 3 , 4 ] : if ( val , val2 ) != ( 1 , 2 ): ( val , val2 ) assert values ​​== @[@[ ( 1 , 3 ), ( 1 , 4 ) ] , @[ ( 2 , 3 ), ( 2 , 4 ) ]]

يدعم OCaml فهم القوائم من خلال OCaml Batteries . ^{[ 2 ]}

my @s = map { 2 * $_ } grep { $_ ** 2 > 3 } 0 .. 99 ;

مصفوفة تحتوي على جميع الأعداد المضاعفة من 1 إلى 9 شاملةً:

my @doubles = map { $_ * 2 } 1 .. 9 ;

مصفوفة بأسماء العملاء المقيمين في ريو دي جانيرو (من مصفوفة من التجزئات):

my @rjCustomers = map { $_ -> { state } eq "RJ" ? $_ -> { name } : ()} @customers ;

تصفية الأرقام القابلة للقسمة على 3:

my @divisibleBy3 = grep { $_ % 3 == 0 } 0 .. 100 ;

$s = ( 0 .. 100 | ? { $_ * $_ -gt 3 } | % { 2 * $_ } )

وهو اختصار لـ:

$s = 0 .. 100 | where-object { $_ * $_ -gt 3 } | foreach -object { 2 * $_ }

تستخدم لغة بايثون الصيغة التالية للتعبير عن عمليات فهم القوائم على القوائم المحدودة:

s : list [ int ] = [ 2 * x for x in range ( 100 ) if x ** 2 > 3 ]

يمكن استخدام تعبير المولد في إصدارات بايثون >= 2.4 والذي يوفر تقييمًا كسولًا على مدخلاته، ويمكن استخدامه مع المولدات للتكرار على مدخلات "لا نهائية" مثل دالة مولد العد التي تُرجع أعدادًا صحيحة متتالية:

استورد itertools من typing استورد Iterators : Iterator [ int ] = ( 2 * x for x in itertools . count () if x ** 2 > 3 )

(سيحدد الاستخدام اللاحق لتعبير المولد متى يتم التوقف عن توليد القيم).

( for/list ([ x 100 ] #:when ( > ( * x x ) 3 )) ( * x 2 ))

مثال على مولدات متعددة:

( for*/list ([ x ( in-range 1 21 )] [ y ( in-range 1 21 )] [ z ( in-range 1 21 )] #:when ( = ( + ( * x x ) ( * y y )) ( * z z ))) ( list x y z ))

استخدام حلقة التكرار (for):

val s = for ( x <- 0 to 100 ; if x * x > 3 ) yield 2 * x

يتم دعم عمليات فهم القوائم في لغة Scheme من خلال استخدام مكتبة SRFI -42. ^{[ 3 ]}

( list - ec ( : x100 ) ( if ( > ( * xx ) 3 ) ) ( * x2 ) )

مثال على فهم القوائم باستخدام مولدات متعددة:

( list - ec ( : x121 ) ( : yx21 ) ( : zy21 ) ( if ( = ( + ( * xx ) ( * yy ) ) ( * zz ) ) ) ( listxyz ) )​​​​​​

S = [ 2 * X || X = list::getMember_nd ( L ) , X * X > 3 ]