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 (\tau_1\to\tau_2)\to\tau_3 .

## 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ë    merr një funksion dhe e zbaton funksionin për një vlerë dy herë. Nëse  duhet të aplikohet disa herë për të njëjtën , 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  në C++11 :
```c++
#include 
#include 

auto twice = [](const std::function& 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 , Func> twice = f => x => f(f(x));

    Func plusThree = i => i + 3;

    var g = twice(plusThree);

    Console.WriteLine(g(7)); // 13
  }
}
```

#### Clojure 
```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 
```go
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 
```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ë:
```javascript
"use strict";

const twice = f => x => f(f(x));

const plusThree = i => i + 3;

const g = twice(plusThree);

console.log(g(7)); // 13
```

#### Julia 
```jlcon
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 
```matlab
function result = twice(f)
result = @(x) f(f(x));
end

plusthree = @(i) i + 3;

g = twice(plusthree)

disp(g(7)); % 13
```

#### Python 
```pycon
>>> 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  mund të zbatohet në mënyrë ekuivalente:
```pycon
>>> @twice
... def g(i):
...   return i + 3

>>> g(7)
13
```

#### Rust 
```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 
```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
 }
}
```

```cpp
// Defunctionalized function data structures
template struct Add { T value; };
template struct DivBy { T value; };
template struct Composition { F f; G g; };

// Defunctionalized function application implementations
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;
}

// Higher-order compose function
template
Composition compose(F f, G g) {
    return Composition {f, g};
}

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;
}
```

## 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ë