نادي الجبن

من الناحية التقنية، Higher Order Function هي ببساطة دالة تفعل واحدًا على الأقل مما يلي:

• تقبل دالة كأحد وسائطها.
• تُرجع دالة كنتيجة لها.

داخل عالم البرمجة الوظيفية، يميل الاستخدام إلى أن يكون أضيق نطاقًا. يشير المصطلح عادةً إلى دوال مثل filter وmap وreduce التي تطبّق دالة مُمرَّرة على عناصر مجموعة.

التعامل مع المجموعات

في هذه المرحلة من المنهج، رأينا بالفعل طرقًا متعددة لتطبيق عملية على جميع عناصر مجموعة قابلة للتكرار، مثل Vector:

• استخدام حلقة (كما تفعل معظم لغات البرمجة منذ فجر الحوسبة الرقمية).
• استخدام استيعاب (على طريقة Python).
• استخدام البث (وهو صياغة مميزة لـ Julia، وإن كانت مدينة كثيرًا لـ R وMatlab وNumPy).

سيركّز هذا المفهوم على الدوال عالية الرتبة (المألوفة في أي لغة وظيفية، مثل Haskell أو F#).

تشمل الأساليب الأخرى الممكنة:

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

التصفية

تأخذ الدالة filter() دالةً مُمرَّرة تُرجع قيمة منطقية وتطبّقها على مجموعة. لا تُضمَّن في القيمة المُرجَعة إلا العناصر التي تُرجع true، وهي من النوع الأساسي نفسه الذي للمُدخل (انظر أدناه).

julia> filter(iseven, 1:6)
3-element Vector{Int64}:
 2
 4
 6

# String is a collection of Chars, so String in -> String out
julia> filter(!isascii, "Hrōðgār")
"ōðā"

# tuple input -> tuple output
julia> filter(iseven, (1, 2, 3, 4, 5))
(2, 4)

مع المصفوفات متعددة الأبعاد، تُسطّح الدالة filter أبعاد المُدخل وتُرجع Vector: وهذا هو الاستثناء الرئيسي لأي قاعدة تتعلق بمطابقة نوع المُخرَج لنوع المُدخل.

julia> m
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> filter(isodd, m)
3-element Vector{Int64}:
 1
 5
 3

تستخدم الأمثلة أعلاه دوالًا مدمجة، لكن استخدام الدوال المجهولة شائع جدًا في هذا السياق.

julia> filter(x -> x % 3 == 0, 1:20)
6-element Vector{Int64}:
  3
  6
  9
 12
 15
 18

توجد أيضًا نسخة تُعدّل في المكان نفسه، filter!()، كما هو الحال مع كثير من الدوال في هذا المفهوم.

التعيين

تحوّل الدالة map() مجموعةً بتطبيق دالة على كل عنصر. قد يكون هذا مشابهًا للبث في الحالات البسيطة، حيث يطابق شكل المُخرَج شكل المُدخل.

julia> map(√, [1, 4, 9])
3-element Vector{Float64}:
 1.0
 2.0
 3.0

julia> map(x -> x^2 + 1, 1:4)
4-element Vector{Int64}:
  2
  5
 10
 17

julia> m
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> map(√, m)
2×3 Matrix{Float64}:
 1.0  1.41421  1.73205
 2.0  2.23607  2.44949

تعمل map() أيضًا عنصرًا بعنصر على مجموعات متعددة.

julia> map(*, [1, 2], [3, 4])
2-element Vector{Int64}:
 3
 8

من الناحية المفاهيمية، يمكننا اعتبار هذا مكافئًا لتشغيل zip() على مجموعات المُدخل المتعددة، ثم تشغيل map() على كل عنصر من النتيجة الوسيطة. هذا مجرد تشبيه تقريبي، ولا يعني شيئًا عن طريقة التنفيذ!

وكما هو الحال مع zip()، تُقتطع المجموعات ذات الأشكال غير المتطابقة إلى بُعد (أو أبعاد) الأصغر منها.

أحيانًا لا نحتاج إلا إلى الآثار الجانبية للدالة المُمرَّرة، مثل الكتابة في قاعدة بيانات أو push! إلى مصفوفة. عندئذٍ تتوفر الدالة عالية الرتبة foreach()، التي تُرجع دائمًا nothing.

الاختزال

تأخذ الدالة reduce() دالةً بوسيطين وتطبّقها على مجموعة، مما يؤدي إلى تقليص الأبعاد.

قد يبدو هذا محيّرًا عند الحديث عنه بشكل مجرد، لكن فكّر في دوال مثل sum() أو prod() التي تأخذ مجموعة وتُرجع قيمة واحدة.

julia> sum(1:4) # add
10

julia> prod(1:4) # multiply
24

هذه الدوال الخاصة عالية التحسين وينبغي استخدامها دائمًا عند توفرها. تشمل الأمثلة الأخرى maximum() وminimum()، والدالتين المنطقيتين all() وany()، وكثيرًا من الدوال الإحصائية.

للتوضيح فقط، لنتأمل الوظيفة نفسها مُنفَّذة بالدالة الأكثر عمومية reduce() (تذكّر أن العاملين البينيين + و* هما في الحقيقة دالتان داخليًا).

julia> reduce(+, 1:4) # add
10

julia> reduce(*, 1:4) # multiply
24

وكما هو الحال مع sum() ودوال التجميع الأخرى، يمكن لـ reduce() أن تأخذ وسيطًا اختياريًا بكلمة مفتاحية dims، لتحديد البُعد (أو الأبعاد) المراد تقليصها.

julia> m
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> reduce(+, m; dims=1)
1×3 Matrix{Int64}:
 5  7  9

هذه أمثلة سهلة، لأن الجمع والضرب عمليتان تبديليتان (1+2 == 2+1) وتجميعيتان ((1+2)+3 == 1+(2+3)).

وهذا أبعد ما يكون عن أن يكون قاعدة عامة! فحتى عمليات شائعة مثل الطرح والقسمة ليست تجميعية.

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

اتجاه الدالة reduce في Julia يعتمد على طريقة التنفيذ وغير مضمون.

للتحكم في الاتجاه بشكل صريح، توجد الدالتان foldl() وfoldr()، وتبدآن نظريًا من «اليسار» و«اليمين» على الترتيب (وفي الحقيقة من الأعلى والأسفل، في حالة Vector).

julia> foldl(-, 1:3) # (1 - 2) - 3
-4

julia> foldr(-, 1:3) # 1 - (2 - 3)
2

لاحظ أن هاتين الدالتين مخصصتان للمجموعات التي يمكن التعامل معها كأحادية البُعد، فتُرجعان نتيجة قياسية. لا يُدعم استخدام وسيط dims مع foldl وfoldr، بل مع reduce فقط.

MapReduce

الجمع بين عملية map وعملية reduce شائع جدًا في مجالات برمجية متنوعة.

يمكننا تشغيل map بالتتابع، ثم تشغيل reduce على مجموعة وسيطة. لكن هذا غير فعّال في أفضل الأحوال، ويسوء أداؤه كثيرًا مع نمو المجموعة.

يُوصى بشدة باستخدام الدالة المُدمَجة mapreduce() بدلًا من ذلك. فهي قادرة على تنفيذ خوارزمية أعلى أداءً تُشابك بين عمليتي map وreduce.

الوسيط الأول هو الدالة التي ستُستخدم في التعيين، والوسيط الثاني هو عامل الاختزال.

julia> mapreduce(x -> x^2 + 1, +, 1:3)
17

# equivalent to (2 + 5 + 10)
julia> sum(map(x -> x^2 + 1, 1:3))
17

وكما قد نتوقع، توفّر Julia أيضًا الدالتين mapfoldl() وmapfoldr() للحالات التي يكون فيها الاتجاه مهمًا.