Funksioni i rendit të lartë
Në matematikë dhe shkenca kompjuterike, një funksion i rendit të lartë ( HOF ) është një funksion që kryen të paktën një nga këto:
- merr një ose më shumë funksione si argumente (p.sh. një parametër procedural, i cili është një parametër i një procedure që është në vetvete një procedurë),
- kthen një funksion ose vlerë si rezultat i tij.
Të gjitha funksionet e tjera janë funksione të rendit të parë . Në matematikë, funksionet e rendit të lartë quhen gjithashtu operatorë ose funksionalë . Operatori diferencial në analizë matematike është një shembull i zakonshëm, pasi ai harton një funksion me derivatin e tij, gjithashtu një funksion. Funksionet e rendit më të lartë nuk duhet të ngatërrohen me përdorime të tjera të fjalës "funktor" përgjatë matematikës, shih Functor (shqarim) .
Në llogaritjen e pashtypshme lambda, të gjitha funksionet janë të rendit të lartë; në një llogaritje lambda të shtypur, nga e cila rrjedhin shumica e gjuhëve programuese funksionale, funksionet e rendit më të lartë që marrin një funksion si argument janë vlera me llojet e formës .
Shembuj të përgjithshëm
- Funksioni
map, i gjetur në shumë gjuhë programimi funksionale, është një shembull i një funksioni të rendit të lartë. Merr si argumente një funksion f dhe një koleksion elementësh, dhe si rezultat, kthen një koleksion të ri me funksionin f të aplikuar për çdo element të koleksionit. - Funksionet e renditjes, të cilat marrin një funksion krahasimi si parametër, duke lejuar programuesin të ndajë algoritmin e renditjes nga krahasimet e tipeve që renditen. Funksioni standard C
qsortështë një shembull i kësaj. - filter
- fold
- apply
- Përbërja e funksioneve
- Integrimi
- Rikthimi i funksionit
- Bredhja e pemës
- Gramatika Montague, një teori semantike e gjuhës natyrore, përdor funksione të rendit më të lartë
Mbështetja në gjuhët e programimit
Mbështetje e drejtpërdrejtë
Shembujt nuk synojnë të krahasojnë dhe krahasojnë gjuhët e programimit, por të shërbejnë si shembuj të sintaksës së funksionit të rendit më të lartë
Në shembujt e mëposhtëm, funksioni i rendit të lartë Stampa:Code merr një funksion dhe e zbaton funksionin për një vlerë dy herë. Nëse Stampa:Code duhet të aplikohet disa herë për të njëjtën Stampa:Code, mundësisht duhet të kthejë një funksion dhe jo një vlerë. Kjo është në përputhje me parimin " mos e përsërit veten ".
C++
Përdorimi i Stampa:Code në C++11 :
#include <iostream>
#include <functional>
auto twice = [](const std::function<int(int)>& f)
{
return [f](int x) {
return f(f(x));
};
};
auto plus_three = [](int i)
{
return i + 3;
};
int main()
{
auto g = twice(plus_three);
std::cout << g(7) << '\n'; // 13
}
C#
Duke përdorur vetëm delegatë:
using System;
public class Program
{
public static void Main(string[] args)
{
Func<Func<int, int>, Func<int, int>> twice = f => x => f(f(x));
Func<int, int> plusThree = i => i + 3;
var g = twice(plusThree);
Console.WriteLine(g(7)); // 13
}
}
Clojure
(defn twice [f]
(fn [x] (f (f x))))
(defn plus-three [i]
(+ i 3))
(def g (twice plus-three))
(println (g 7)) ; 13
Shkoni
package main
import "fmt"
func twice(f func(int) int) func(int) int {
return func(x int) int {
return f(f(x))
}
}
func main() {
plusThree := func(i int) int {
return i + 3
}
g := twice(plusThree)
fmt.Println(g(7)) // 13
}
Haskell
twice :: (Int -> Int) -> (Int -> Int)
twice f = f . f
plusThree :: Int -> Int
plusThree = (+3)
main :: IO ()
main = print (g 7) -- 13
where
g = twice plusThree
JavaScript
Me funksionet shigjetë:
"use strict";
const twice = f => x => f(f(x));
const plusThree = i => i + 3;
const g = twice(plusThree);
console.log(g(7)); // 13
Julia
julia> function twice(f)
function result(x)
return f(f(x))
end
return result
end
twice (generic function with 1 method)
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
MATLAB
function result = twice(f)
result = @(x) f(f(x));
end
plusthree = @(i) i + 3;
g = twice(plusthree)
disp(g(7)); % 13
Python
>>> def twice(f):
... def result(x):
... return f(f(x))
... return result
>>> plus_three = lambda i: i + 3
>>> g = twice(plus_three)
>>> g(7)
13
Sintaksa Python me dekoratorë shpesh përdoret për të zëvendësuar një funksion me rezultatin e kalimit të atij funksioni përmes një funksioni të rendit më të lartë. Për shembull, funksioni Stampa:Code mund të zbatohet në mënyrë ekuivalente:
>>> @twice
... def g(i):
... return i + 3
>>> g(7)
13
Rust
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
}
Scala
object Main {
def twice(f: Int => Int): Int => Int =
f compose f
def plusThree(i: Int): Int =
i + 3
def main(args: Array[String]): Unit = {
val g = twice(plusThree)
print(g(7)) // 13
}
}
// Defunctionalized function data structures
template<typename T> struct Add { T value; };
template<typename T> struct DivBy { T value; };
template<typename F, typename G> struct Composition { F f; G g; };
// Defunctionalized function application implementations
template<typename F, typename G, typename X>
auto apply(Composition<F, G> f, X arg) {
return apply(f.f, apply(f.g, arg));
}
template<typename T, typename X>
auto apply(Add<T> f, X arg) {
return arg + f.value;
}
template<typename T, typename X>
auto apply(DivBy<T> f, X arg) {
return arg / f.value;
}
// Higher-order compose function
template<typename F, typename G>
Composition<F, G> compose(F f, G g) {
return Composition<F, G> {f, g};
}
int main(int argc, const char* argv[]) {
auto f = compose(DivBy<float>{ 2.0f }, Add<int>{ 5 });
apply(f, 3); // 4.0f
apply(f, 9); // 7.0f
return 0;
}
Shihni gjithashtu
- Funksioni i klasit të parë
- Logjika kombinuese
- Programimi në nivel funksioni
- Programim funksional
- Llogaritja Kappa - një formalizëm për funksionet që përjashton funksionet e rendit më të lartë
- Modeli i strategjisë
- Mesazhe të rendit të lartë