دالة من الدرجة العليا
المحتويات
- class Main {
- سي++
- julia> plusthree(i) = i + 3
- let twice f x
- مؤشرات الدوال
- كومون ليسب
- (display (g 7)) ; 13
- function twice(callable $f): Closure {
- declare function local:twice($f, $x) {
- (defn plus-three [i]
- آر
- echo $g(7), "\n"; // 13
- كوتلن
- إلغاء التفعيلية
- ماتلاب
- سويفت
- plusThree :: Int -> Int
- #include
- 13
- رست
- #include
- }
- };
- {
- plusthree = @(i) i + 3;
- console.log(g(7)); // 13
- الماكرو
- الكائنات
- تي سي إل
- import std.stdio : writeln;
- "use strict";
- أباتشي جروفي
- }
- >>> @twice
- }
- #include
- end
- end
- writeln(a(xy)); // يطبع 10
- end
- بايثون
- }
- (defn twice [f]
- plusThree <- function(i) i + 3
- جوليا
- }
- or_else(Fs, _, {false, Y}) -> or_else(Fs, Y);
- }
- or_else([], _) -> false;
- };
- def main(args: Array[String]): Unit = {
- };
- الدعم المباشر
- 13
- return func(x int) int {
- begin
- أمثلة عامة
- هاسكل
- }
- }
- سكيم
- }
- اجتياز هيكلة الشجرة
- }
- echo $g(7), "\n"; // 13
- fun main {
- 13
- double sum = 0;
- print $g->(7), "\n"; # 13
- Function twice = f -> f.andThen(f);
- لوا
- declare(strict_types=1);
- سي شارب
- ... return i + 3
- جيه
- {
- تقييم الشيفرة ديناميكيًا
- إليكسير
- permit
- إكس إيه سي إم إل
- {
- say $g(7); # 13
- end
- let g = twice plus_three in
- int main(int argc, const char* argv[]) {
- جافا
- جافا سكريبت
- template struct DivBy { T value; };
- package main
- ... return result
- }
- IO.puts g.(7) # 13
- object Main {
- end
- روبي
- puts [apply $twice $plusThree 7]
- end
بدايةً، في الرياضيات وعلم الحاسوب، تُعدّ الدالة من المرتبة الأعلى أو الدالة من الدرجة العليا التي تُعرف اختصارًا بـ HOF، هي دالة تقوم على الأقل بأحد الأمور التالية:
من جانب آخر، في تكامل لامدا غير المُنمَّط، تكون جميع الدوال من المرتبة الأعلى؛ أما في تفاضل لامدا النمطي، الذي تشتق منه أغلب لغات برمجة وظيفية، فإن الدوال من المرتبة الأعلى التي تأخذ دالة كوسيط تكون لها أنواع بالقالب التالي: .
من جهة ثانية، جميع الدوال الأخرى تُعدّ دوال من المرتبة الأولى. في الرياضيات، تُسمى الدوال من المرتبة الأعلى كذلك بالمؤثر أو الدالي. ويُعدّ المؤثر التفاضلي في التفاضل والتكامل مثالًا شائعًا، لأنه يُحوّل دالة إلى مشتقِ لها، وهي كذلك دالة. لا ينبغي الخلط بين الدوال من المرتبة الأعلى وغيرها من الاستخدامات لكلمة "المؤثر" في الرياضيات، انظر دال.
تُرجع دالة كنتيجة.
علاوةً على ذلك، تأخذ دالة أو أكثر كوسيط (أي معامل إجرائي، وهو وسيط في الدالة يكون بحد ذاته إجراء)،
class Main {
- private static IntUnaryOperator twice(IntUnaryOperator f) {
- return f.andThen(f);
- }
- private static int plusThree(int i) {
- return i + 3;
- }
- public static void main(String[] args) {
- var g = twice(Main::plusThree);
- System.out.println(g.applyAsInt(7)); // 13
- }
- }
سي++
يُستعمل في سي++11:
#include
julia> plusthree(i) = i + 3
- plusthree (generic function with 1 method)
- julia> g = twice(plusthree)
- (::var"#result#3"{typeof(plusthree)}) (generic function with 1 method)
- julia> g(7)
- 13
let twice f x
- f (f x)
- let plus_three
- (+) 3
- let
مؤشرات الدوال
من جانب آخر، تسمح مؤشرات الدوال في لغات مثل سي، سي++، فورتران، وباسكال للمبرمجين بتمرير مراجع إلى الدوال. الكود التالي في لغة C يحسب على وجه التقريب للتكامل لدالة عشوائية:
كومون ليسب
- (defun twice (f)
- (lambda (x) (funcall f (funcall f x))))
- (defun plus-three (i)
- (+ i 3))
- (defvar g (twice #'plus-three))
- (print (funcall g 7))
- دي
(display (g 7)) ; 13
(display "\n")
function twice(callable $f): Closure {
- return function (int $x) use ($f): int {
- return $f($f($x));
- };
- }
- function plusThree(int $i): int {
- return $i + 3;
- }
- $g = twice('plusThree');
declare function local:twice($f, $x) {
- $f($f($x))
- };
- declare function local:plusthree($i) {
- $i + 3
(defn plus-three [i]
- (+ i 3))
- (def g (twice plus-three))
- (println (g 7)) ; 13
- سي إف إم
- twice = function(f) {
- return function(x) {
- return f(f(x));
- };
- };
- plusThree = function(i) {
- return i + 3;
- };
- g = twice(plusThree);
- writeOutput(g(7)); // 13
آر
twice <- \(f) \(x) f(f(x))
echo $g(7), "\n"; // 13
<?php
أو باستخدام متغيرات لكل الدوال:
كوتلن
- fun twice(f: (Int) -> Int): (Int) -> Int {
- return { f(f(it)) }
- }
- fun plusThree(i: Int) = i + 3
إلغاء التفعيلية
template struct Add { T value; };
// هياكل بيانات الدوال التي تم إلغاء تفعيلها
وفي السياق ذاته، يمكن استخدام إلغاء التفعيلية لتنفيذ الدوال من المرتبة الأعلى في لغات البرمجة التي لا تدعم الدوال من الدرجة الأولى:
ماتلاب
- function result = twice(f)
- result = @(x) f(f(x));
- end
سويفت
func twice(_ f: @escaping (Int) -> Int) -> (Int) -> Int {
return { f(f($0)) }
plusThree :: Int -> Int
- plusThree = (+3)
- main :: IO
- main = print (g 7) -- 13
- where
- g = twice plusThree
#include
- auto twice = [](const std::function& f)
- {
- return [f](int x) {
- return f(f(x));
- };
13
- أو بطريقة ضمنية:
- twice←⍣2
- plusthree←+∘3
- g←plusthree twice
- g 7
- 13
رست
- fn twice(f: impl Fn(i32) -> i32) -> impl Fn(i32) -> i32 {
- move |x| f(f(x))
- }
- fn plus_three(i: i32) -> i32 {
- i + 3
- }
- fn main {
- let g = twice(plus_three);
- println!("{}", g(7)) // 13
- }
- سكالا
#include
- double square(double x)
- {
- return x * x;
}
أو، باستخدام لامبدا العامة التي يوفرها سي++14:
};
- auto plus_three = [](int i)
- {
- return i + 3;
- };
- int main
- {
- auto g = twice(plus_three);
- std::cout << g(7) << '\n'; // 13
- }
{
- private static Func Twice(Func f)
- {
- return x => f(f(x));
plusthree = @(i) i + 3;
- g = twice(plusthree)
- disp(g(7)); % 13
- أوكامل
console.log(g(7)); // 13
- أو باستخدام الصيغة الكلاسيكية:
- "use strict";
- function twice(f) {
- return function (x) {
- return f(f(x));
- };
- }
- function plusThree(i) {
- return i + 3;
- }
- const g = twice(plusThree);
- console.log(g(7)); // 13
الماكرو
إضافةً إلى ذلك، يمكن كذلك استخدام الماكرو لتحقيق بعض تأثيرات الدوال من المرتبة الأعلى. ومع ذلك، لا يمكن للماكرو بسهولة تجنب مشكلة التقاط المتغيرات ؛ وقد يؤدي كذلك إلى توليد كميات كبيرة من الشيفرة المكررة، مما قد يصعب على المُصرّف تحسينها. وبشكل عام، لا تكون الماكروات مُنظمة بنظام أنواع قوي، على الرغم من أنها قد تُنتج شيفرة تعتمد على نظام أنواع قوي.
الكائنات
- مثال على استخدام سجل بسيط مخزَّن في المكدس في فري باسكال مع دالة تُعيد دالة:
- program example;
- type
- int = integer;
- Txy = record x, y: int; end;
- Tf = function (xy: Txy): int;
- function f(xy: Txy): int;
- begin
- Result := xy.y + xy.x;
- end;
- function g(func: Tf): Tf;
- begin
- result := func;
- end;
- var
- a: Tf;
- xy: Txy = (x: 3; y: 7);
وفي هذا السياق، في لغات البرمجة كائنية التوجه التي لا تدعم الدوال من المرتبة الأعلى، يمكن أن يكون الكائن بديلاً فعالًا. إذ أن الطريقة الخاصة بالكائن تعمل بشكل جوهري كالدوال، ويمكن للطريقة أن تقبل كائنات كوسائط وأن تُنتج كائنات كقيمة مُعادة. ومع ذلك، غالبًا ما تُضيف الكائنات عبئًا إضافيًا في وقت التشغيل مقارنةً بالدوال البحتة، فضلًا عن المزيد من الشفرة المتداولة لتعريف الكائن وإنشاء نسخة منه مع الطريقة (أو الطرق) الخاصة به. تتيح اللغات التي تدعم كائنات مخصصة للتخزين في المكدس (بدلاً من الاعتماد على إدارة الذاكرة) أو السجلات مزيدًا من المرونة عند استخدام هذا الأسلوب.
تي سي إل
- set twice f x} {apply $f [apply $f $x]
- set plusThree i} {return [expr $i + 3]
- # result: 13
import std.stdio : writeln;
- alias twice = (f) => (int x) => f(f(x));
- alias plusThree = (int i) => i + 3;
- void main
- {
- auto g = twice(plusThree);
- writeln(g(7)); // 13
- }
- دارت
- int Function(int) twice(int Function(int) f) {
- return (x) {
- return f(f(x));
- };
- }
- int plusThree(int i) {
- return i + 3;
- }
- void main {
- final g = twice(plusThree);
- print(g(7)); // 13
- }
"use strict";
- const twice = f => x => f(f(x));
- const plusThree = i => i + 3;
- const g = twice(plusThree);
أباتشي جروفي
- def twice = { f, x -> f(f(x)) }
- def plusThree = { it + 3 }
- def g = twice.curry(plusThree)
- println g(7) // 13
}
من جانب آخر، دالة qsort من مكتبة C القياسية تستعمل مؤشر دالة لمحاكاة سلوك دالة من المرتبة الأعلى.
>>> @twice
... def g(i):
}
- private static int PlusThree(int i) => i + 3;
- public static void Main(string[] args)
- {
- var g = Twice(PlusThree);
- Console.WriteLine(g(7)); // 13
- }
- }
- كلوجر
#include
- auto twice = [](const auto& f)
- {
- return [f](int x) {
- return f(f(x));
- };
end
print(g(7)) -- 13
local g = twice(plusThree)
end
- plus_three = ->(i) { i + 3 }
- g = twice(plus_three)
- puts g.call(7) # 13
writeln(a(xy)); // يطبع 10
end.
ومن ناحية أخرى، تقوم الدالة a بأخذ سجل من النوع Txy كوسيط وتُعيد القيمة الصحيحة (عدد صحيح) الناتجة من جمع الحقلين x وy في السجل (3 + 7).
end
function plusThree(i)
return i + 3
بايثون
- >>> def twice(f):
- ... def result(x):
- ... return f(f(x))
}
- /* حساب التكامل لدالة f ضمن الفاصل الزمني [a,b] */
- double integral(double f(double x), double a, double b, int n)
- {
- int i;
(defn twice [f]
(fn [x] (f (f x))))
plusThree <- function(i) i + 3
- g <- twice(plusThree)
- > g(7)
- [1] 13
- راكو
- sub twice(Callable:D $f) {
- return sub { $f($f($^x)) };
- }
- sub plusThree(Int:D $i) {
- return $i + 3;
- }
- my $g = twice(&plusThree);
جوليا
- julia> function twice(f)
- function result(x)
- return f(f(x))
- end
- return result
}
- انظر كذلك
- برمجة وظيفية
- نموذج الإستراتيجية
ومن جهة أخرى، في هذا المثال، يتم استخدام أنواع مختلفة لتفعيل دوال مختلفة عبر تعدد أشكال الدوال. الدالة التي تم تطبيق تعدد الأشكال عليها في هذا المثال تحمل التوقيع auto apply.
or_else(Fs, _, {false, Y}) -> or_else(Fs, Y);
وفي السياق ذاته، or_else([fun erlang:is_integer/1, fun erlang:is_atom/1, fun erlang:is_list/1], 3.23).
- إف شارب
- let twice f = f >> f
- let plus_three = (+) 3
- let g = twice plus_three
- g 7 |> printf "%A" // 13
- غو
or_else(_, _, R) -> R.
وعلى صعيد آخر، في هذا المثال بلغة Erlang، تقوم الدالة العليا بأخذ قائمة من الدوال ومعامل . تقوم الدالة بتقييم الدالة باستخدام كمعامل. إذا أعادت الدالة القيمة false، فسيتم تقييم الدالة التالية في القائمة . إذا أعادت الدالة القيمة }، فسيتم تقييم الدالة التالية في القائمة باستخدام كمعامل. إذا أعادت الدالة القيمة ، فإن الدالة العليا ستُرجع . لاحظ أن و و يمكن أن تكون دوال. المثال يعيد القيمة .
}
أو بشكل مكافئ، باستخدام دوال ثابتة:
import java.util.function.*;
or_else([], _) -> false;
or_else([F | Fs], X) -> or_else(Fs, X, F(X)).
or_else(Fs, X, false) -> or_else(Fs, X);
};
local:twice(local:plusthree#1, 7) (: 13 :)
البدائل
def main(args: Array[String]): Unit = {
- val g = twice(plusThree)
- print(g(7)) // 13
- }
- }
};
- auto plus_three = [](int i)
- {
- return i + 3;
- };
- int main
- {
- auto g = twice(plus_three);
- std::cout << g(7) << '\n'; // 13
الدعم المباشر
- إيه بي إل
- twice←{⍺⍺ ⍺⍺ ⍵}
- plusthree←{⍵+3}
- g←{plusthree twice ⍵}
- g 7
وفي هذا السياق، في الأمثلة التالية، تقوم الدالة من المرتبة الأعلى بأخذ دالة وتطبيقها على قيمة معينة مرتين. وإذا كان من الضروري تطبيق عدة مرات على نفس الدالة ، فمن الأفضل أن تُرجع دالة بدلاً من قيمة. وهذا يتماشى مع مبدأ "لا تكرر نفسك".
من جانب آخر، الأمثلة الواردة ليست بغرض المقارنة بين لغات البرمجة، وإنما لتوضيح بنية دوال المرتبة الأعلى فيها
13
أو ضمنيًا،
- twice=. ^:2
- plusthree=. +&3
- g=. plusthree twice
- g 7
- 13
return func(x int) int {
- return f(f(x))
- }
- }
- func main {
- plusThree := func(i int) int {
- return i + 3
begin
a := g(@f); // تعيين الدالة المُعادة إلى "a"
أمثلة عامة
ومن جهة أخرى، دالة map، الموجودة في الكثير من لغات البرمجة الوظيفية، تُعد مثالًا على دالة من المرتبة الأعلى. فهي تأخذ دالة f ومجموعة من العناصر كوسيطين، وتُرجع نتيجةً هي مجموعة جديدة تحتوي على f مطبّقة على كل عنصر من عناصر المجموعة الأصلية.
- التصفية
- الطي
- المجموع التراكمي
- التطبيث
- تركيب الدوال
- التكامل
- رد النداء
من جانب آخر، دوال الترتيب ، التي تأخذ دالة مقارنة كوسيط، مما يتيح للمبرمج فصل خوارزمية الترتيب عن طريقة مقارنة العناصر. وتُعد الدالة القياسية qsort في لغة سي مثالًا على ذلك.
هاسكل
twice :: (Int -> Int) -> (Int -> Int)
twice f = f . f
}
وفي هذا السياق، لاحظ أن التعبير الحرفي للدالة يمكن تعريفه إما باستخدام معرف أو بشكل مجهول (ويُسند إلى متغير مثل ).
}
- let plusThree = { $0 + 3 }
- let g = twice(plusThree)
- print(g(7)) // 13
سكيم
- (define (compose f g)
- (lambda (x) (f (g x))))
- (define (twice f)
- (compose f f))
- (define (plus-three i)
- (+ i 3))
- (define g (twice plus-three))
}
- double cube(double x)
- {
- return x * x * x;
اجتياز هيكلة الشجرة
وفي هذا السياق، نحو مونتاغيو، وهي نظرية دلالية للغة الطبيعية، تستعمل الدوال من المرتبة الأعلى.
الدعم في لغات البرمجة
}
fmt.Println(g(7)) // 13
g := twice(plusThree)
echo $g(7), "\n"; // 13
من جانب آخر، لاحظ أن دوال السهم تقوم ضمنيًا بالتقاط أي متغيرات من النطاق الأبوي، بينما تتطلب الدوال المجهولة استخدام الكلمة المفتاحية للقيام بذلك.
- بيرل
- use strict;
- use warnings;
- sub twice {
- my ($f) = @_;
- sub {
- $f->($f->(@_));
- };
- }
- sub plusThree {
- my ($i) = @_;
- $i + 3;
- }
- my $g = twice(\&plusThree);
fun main {
- val g = twice(::plusThree)
- println(g(7)) // 13
- }
13
ومن ناحية أخرى، غالبًا ما يُستعمل بناء جملة مُزيّن بايثون لاستبدال دالة بنتيجة تمريرها عبر دالة من رتبة أعلى. مثلًا، يمكن تنفيذ الدالة بشكل مكافئ:
double sum = 0;
- double dt = (b - a) / n;
- for (i = 0; i < n; ++i) {
- sum += f(a + (i + 0.5) * dt);
- }
- return sum * dt;
- }
- int main
- {
- printf("%g\n", integral(square, 0, 1, 100));
- printf("%g\n", integral(cube, 0, 1, 100));
- return 0;
print $g->(7), "\n"; # 13
- أو باستخدام جميع الدوال في متغيرات:
- use strict;
- use warnings;
- my $twice = sub {
- my ($f) = @_;
- sub {
- $f->($f->(@_));
- };
- };
- my $plusThree = sub {
- my ($i) = @_;
- $i + 3;
- };
- my $g = $twice->($plusThree);
- print $g->(7), "\n"; # 13
Function twice = f -> f.andThen(f);
- IntUnaryOperator plusThree = i -> i + 3;
- var g = twice.apply(plusThree);
- System.out.println(g.applyAsInt(7)); // 13
- }
لوا
- function twice(f)
- return function (x)
- return f(f(x))
- end
declare(strict_types=1);
- $twice = fn(callable $f): Closure => fn(int $x): int => $f($f($x));
- $plusThree = fn(int $i): int => $i + 3;
- $g = $twice($plusThree);
سي شارب
- باستخدام المفوضات فقط :
- using System;
- public class Program
... return i + 3
>>> g(7)
13
جيه
- twice=. adverb : 'u u y'
- plusthree=. verb : 'y + 3'
- g=. plusthree twice
- g 7
بشكلٍ واضح،
{
- Func twice = f => x => f(f(x));
- Func plusThree = i => i + 3;
- var g = twice(plusThree);
- Console.WriteLine(g(7)); // 13
- }
تقييم الشيفرة ديناميكيًا
علاوةً على ذلك، عادةً لا يكون الكود المُمرَّر كوسيط نظامي النوع؛ حيث تعتمد هذه اللغات بشكل عام على نظام الأنواع للتحقق من صحة الشيفرة وسلامتها.
من جانب آخر، غالبًا ما يُقدَّم الوسيط على شكل سلسلة نصية، قد لا يكون معروفًا محتواها إلا أثناء وقت التشغيل. ويجب ترجمة هذه السلسلة إما أثناء تنفيذ البرنامج (باستخدام الترجمة في الوقت المناسب) أو تقييمها باستخدام المفسر. وهذا يؤدي إلى زيادة في العبء على وقت التشغيل، وغالبًا ما ينتج عنه كود أقل كفاءة.
إضافةً إلى ذلك، في بعض لغات البرمجة الأمرية، يمكن تحقيق بعض النتائج الخوارزمية نفسها التي يتم الوصول إليها باستخدام الدوال من المرتبة الأعلى، وذلك عن طريق تنفيذ الشيفرة ديناميكيًا (ويُشار إلى هذه العملية أحيانًا باسم "Eval" أو "Execute") ضمن نطاق التقييم. ومع ذلك، هناك عيوب كبيرة محتملة لهذا النهج:
إليكسير
- في إليكسير، يمكنك المزج بين تعريفات الوحدة والدالة المجهولة
- defmodule Hof do
- def twice(f) do
- fn(x) -> f.(f.(x)) end
- end
permit
- condition anyOfAny(function[stringEqual], citizenships, allowedCitizenships)
- }
- إكس كويري
إكس إيه سي إم إل
من جانب آخر، يعرّف معيار إكس إيه سي إم إل دوالًا من المرتبة الأعلى ضمن المعيار لتطبيق دالة على عدة قيم من مجموعات السمات.
rule allowEntry{
{
public static void Main(string[] args)
say $g(7); # 13
من جهة ثانية، في راكو، جميع كائنات الكود هي إغلاقات، وبالتالي يمكنها الإشارة إلى متغيرات "معجمية" داخلية من نطاق خارجي لأن المتغير المعجمي "مغلق" داخل الدالة. يدعم راكو كذلك صيغة "الكتلة المدببة" لتعبيرات لامدا، والتي يمكن تخصيصها لمتغير أو استدعاؤها بشكل مجهول.
end
- plus_three = fn(i) -> i + 3 end
- g = twice.(plus_three)
- IO.puts g.(7) # 13
- إرلانج
let g = twice plus_three in
- print_int (g 7); (* 13 *)
- print_newline
- بي إتش بي
- <?php
- declare(strict_types=1);
int main(int argc, const char* argv[]) {
- auto f = compose(DivBy{ 2.0f }, Add{ 5 });
- apply(f, 3); // 4.0f
- apply(f, 9); // 7.0f
- return 0;
جافا
- باستخدام واجهات الدوال فقط:
- import java.util.function.*;
- class Main {
- public static void main(String[] args) {
جافا سكريبت
باستخدام دوال السهم :
template struct DivBy { T value; };
- template struct Composition { F f; G g; };
- // تنفيذ تطبيقات الدوال التي تم إلغاء تفعيلها
- template
- auto apply(Composition f, X arg) {
- return apply(f.f, apply(f.g, arg));
- }
- template
- auto apply(Add f, X arg) {
- return arg + f.value;
- }
- template
- auto apply(DivBy f, X arg) {
- return arg / f.value;
- }
- // دالة التركيب من الدرجة الأعلى
- template
- Composition compose(F f, G g) {
- return Composition {f, g};
- }
package main
func twice(f func(int) int) func(int) int {
import "fmt"
... return result
- >>> plus_three = lambda i: i + 3
- >>> g = twice(plus_three)
- >>> g(7)
}
- أو بطريقة مكافئة، باستخدام دوال ثابتة :
- using System;
- public class Program
IO.puts g.(7) # 13
- وبدلاً من ذلك، يمكننا كذلك التأليف باستخدام وظائف مجهولة الهوية تمامًا.
- twice = fn(f) ->
- fn(x) -> f.(f.(x)) end
object Main {
- def twice(f: Int => Int): Int => Int
- f compose f
- def plusThree(i: Int): Int
- i + 3
end
g = Hof.twice(plus_three)
plus_three = fn(i) -> i + 3 end
روبي
def twice(f)
->(x) { f.call(f.call(x)) }
puts [apply $twice $plusThree 7]
وفي هذا الصدد، تستعمل تي سي إل الأمر "apply" لتطبيق دالة مجهولة (منذ الإصدار 8.6).
end
twice (generic function with 1 method)
📝 هل في هذه المقالة خطأ؟
إذا وجدت معلومة تحتاج تصحيحاً أو إضافة، أو أردت حذف المقالة، أرسل لنا طلباً وسنراجعه.
ما رأيك في هذه المقالة؟