Wikipedia

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

Redakto
  • 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

Redakto

Mbështetje e drejtpërdrejtë

Redakto

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ë twice merr një funksion dhe e zbaton funksionin për një vlerë dy herë. Nëse twice duhet të aplikohet disa herë për të njëjtën f, 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++

Redakto

Përdorimi i std::function 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#

Redakto

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

Redakto 
(defn twice [f]
 (fn [x] (f (f x))))

(defn plus-three [i]
 (+ i 3))

(def g (twice plus-three))

(println (g 7)) ; 13

Shkoni

Redakto 
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

Redakto 
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

Redakto

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

Redakto 
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

Redakto 
function result = twice(f)
result = @(x) f(f(x));
end

plusthree = @(i) i + 3;

g = twice(plusthree)

disp(g(7)); % 13

Python

Redakto 
>>> 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 g mund të zbatohet në mënyrë ekuivalente:

>>> @twice
... def g(i):
...   return i + 3

>>> g(7)
13

Rust

Redakto 
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

Redakto 
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

Redakto
Marrë nga "https://sq.wikipedia.org/w/index.php?title=Funksioni_i_rendit_të_lartë&oldid=2686397"