उच्च-क्रम फलन

गणित और कंप्यूटर विज्ञान में, उच्च-क्रम फलन (HOF) एक फलन (गणित) है जो निम्न में से कम से कम एक कार्य को परिभाषित करता है:

• तर्क के रूप में एक या एक से अधिक कार्य करता है (अर्थात एक प्रक्रियात्मक पैरामीटर, जो एक उप नाम का एक पैरामीटर (कंप्यूटर विज्ञान) है जो स्वयं एक प्रक्रिया है),
• यह परिणाम के रूप में एक फलन देता है।

अन्य सभी कार्य प्रथम क्रम के कार्य हैं। गणित में उच्च-क्रम के कार्यों को संचालक (गणित) या कार्यात्मक (गणित) भी कहा जाता है। गणना में अंतर ऑपरेटर एक सामान्य उदाहरण है, क्योंकि यह एक फलन को इसके व्युत्पन्न के लिए रेखित करता है, यह एक फलन भी है। पूरे गणित में फ़ंक्टर शब्द के अन्य उपयोगों के साथ उच्च-क्रम के कार्यों को भ्रमित नहीं किया जाना चाहिए, फ़ंक्टर (बहुविकल्पी) देखें।

अनटाइप्ड लैम्ब्डा कैलकुलस में, सभी फंक्शन उच्च-क्रम वाले होते हैं; एक टाइप किए गए लैम्ब्डा कैलकुस में, जिसमें से अधिकांश कार्यात्मक प्रोग्रामिंग भाषाएं व्युत्पन्न होती हैं, उच्च-क्रम के फलन जो एक फलन को तर्क के रूप में लेते हैं, फॉर्म के प्रकारों के साथ मान्य होते हैं $(\tau _{1}\to \tau _{2})\to \tau _{3}$.

सामान्य उदाहरण

• map फलन, कई कार्यात्मक प्रोग्रामिंग भाषाओं में पाया जाता है, उच्च-क्रम फलन का एक उदाहरण है। यह तर्क के रूप में एक फलन f और तत्वों का एक संग्रह लेता है, और परिणामस्वरूप, संग्रह से प्रत्येक तत्व पर लागू f के साथ एक नया संग्रह देता है।
• सॉर्टिंग फ़ंक्शंस, जो एक तुलना फलन को एक पैरामीटर के रूप में लेते हैं, प्रोग्रामर को सॉर्टिंग एल्गोरिथ्म को सॉर्ट किए जा रहे आइटमों की तुलना से अलग करने की अनुमति देता है। सी (प्रोग्रामिंग भाषा) मानक फलन (कंप्यूटर विज्ञान) qsort इसका एक उदाहरण है।
• फ़िल्टर (उच्च-क्रम फलन)
• गुना (उच्च-क्रम फलन)
• आवेदन करना
• फंक्शन रचना (कंप्यूटर विज्ञान)
• अभिन्न
• कॉलबैक (कंप्यूटर प्रोग्रामिंग)
• ट्री ट्रैवर्सल
• मोंटेग व्याकरण, प्राकृतिक भाषा का एक सिमेंटिक सिद्धांत, उच्च-क्रम के कार्यों का उपयोग करता है

प्रोग्रामिंग भाषाओं में समर्थन

प्रत्यक्ष समर्थन

उदाहरणों का उद्देश्य प्रोग्रामिंग भाषाओं की तुलना और तुलना करना नहीं है, बल्कि उच्च-क्रम फलन सिंटैक्स के उदाहरण के रूप में काम करना है

निम्नलिखित उदाहरणों में, उच्च-क्रम फलन twice एक फलन लेता है, और फलन को दो बार कुछ मान पर लागू करता है। अगर twice इसके लिए कई बार आवेदन करना पड़ता है f यह अधिमानतः एक मूल्य के बजाय एक फलन वापस करना चाहिए। यह स्वयं को न दोहराने के सिद्धांत के अनुरूप है।

एपीएल

Further information: एपीएल (प्रोग्रामिंग भाषा)

      twice←{⍺⍺ ⍺⍺ ⍵}

      plusthree←{⍵+3}

      g←{plusthree twice ⍵}
    
      g 7
13

या उपलक्षित तरीके से:

      twice←⍣2

      plusthree←+∘3

      g←plusthree twice
    
      g 7
13

सी++==

Further information: C++

का उपयोग करते हुए std::function सी ++ 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
}

या, सी ++ 14 द्वारा प्रदान किए गए सामान्य लैम्ब्डा के साथ:

#include <iostream>

auto twice = [](const auto& 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#

Further information: सी शार्प (प्रोग्रामिंग भाषा)

केवल प्रतिनिधियों का उपयोग करना:

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

या समतुल्य, स्थिर विधियों के साथ:

using System;

public class Program
{
    private static Func<int, int> Twice(Func<int, int> f)
    {
        return x => f(f(x));
    }

    private static int PlusThree(int i) => i + 3;

    public static void Main(string[] args)
    {
        var g = Twice(PlusThree);

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

क्लोजर

Further information: क्लोजर

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

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

(def g (twice plus-three))

(println (g 7)) ; 13

कोल्ड फ्यूजन मार्कअप लैंग्वेज (CFML)

Further information: कोल्डफ्यूजन मार्कअप लैंग्वेज

twice = function(f) {
    return function(x) {
        return f(f(x));
    };
};

plusThree = function(i) {
    return i + 3;
};

g = twice(plusThree);

writeOutput(g(7)); // 13

आम लिस्प

Further information: सामान्य लिस्प

(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))

डी

Further information: डी (प्रोग्रामिंग भाषा)

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
}

डार्ट

Further information: डार्ट (प्रोग्रामिंग भाषा)

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
}

एलिक्सिर

Further information: एलिक्सिर ​​(प्रोग्रामिंग भाषा)

एलिक्सिर ​​​​में, आप मॉड्यूल परिभाषाओं और अनाम कार्यों को मिला सकते हैं

defmodule Hof do
    def twice(f) do
        fn(x) -> f.(f.(x)) end
    end
end

plus_three = fn(i) -> 3 + i end

g = Hof.twice(plus_three)

IO.puts g.(7) # 13

वैकल्पिक रूप से, हम शुद्ध अनाम कार्यों का उपयोग करके रचना भी कर सकते हैं।

twice = fn(f) ->
    fn(x) -> f.(f.(x)) end
end

plus_three = fn(i) -> 3 + i end

g = twice.(plus_three)

IO.puts g.(7) # 13

एरलांग

Further information: एरलांग (प्रोग्रामिंग भाषा)

or_else([], _) -> false;
or_else([F | Fs], X) -> or_else(Fs, X, F(X)).

or_else(Fs, X, false) -> or_else(Fs, X);
or_else(Fs, _, {false, Y}) -> or_else(Fs, Y);
or_else(_, _, R) -> R.

or_else([fun erlang:is_integer/1, fun erlang:is_atom/1, fun erlang:is_list/1], 3.23).

इस Erlang उदाहरण में, उच्च-क्रम फलन or_else/2 कार्यों की एक सूची लेता है (Fs) और तर्क (X). यह फलन का मूल्यांकन करता है F तर्क के साथ X तर्क के रूप में। यदि फलन F false लौटाता है फिर अगला कार्य करता है Fs मूल्यांकन किया जाएगा। यदि फलन F रिटर्न {false, Y} फिर अगला फलन में Fs तर्क के साथ Y मूल्यांकन किया जाएगा। यदि फलन F रिटर्न R उच्च-क्रम फलन or_else/2 वापसी करेंगे R. ध्यान दें कि X, Y, और R कार्य हो सकते हैं। उदाहरण लौटता है false.

एफ#

Further information: एफ शार्प (प्रोग्रामिंग भाषा)

let twice f = f >> f

let plus_three = (+) 3

let g = twice plus_three

g 7 |> printf "%A" // 13

गो

Further information: गो (प्रोग्रामिंग भाषा)

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
}

ध्यान दें कि एक फलन शाब्दिक या तो पहचानकर्ता के साथ परिभाषित किया जा सकता है (twice) या गुमनाम रूप से (वैरिएबल को असाइन किया गया plusThree).

हास्केल

Further information: हास्केल (प्रोग्रामिंग भाषा)

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

जे

Further information: जे (प्रोग्रामिंग भाषा)

स्पष्ट रूप से,

   twice=.     adverb : 'u u y'

   plusthree=. verb   : 'y + 3'
   
   g=. plusthree twice
   
   g 7
13

   twice=. ^:2

   plusthree=. +&3
   
   g=. plusthree twice
   
   g 7
13

जावा (1.8+)

Further information: जावा (प्रोग्रामिंग भाषा) and जावा संस्करण इतिहास

केवल कार्यात्मक इंटरफेस का उपयोग करना:

import java.util.function.*;

class Main {
    public static void main(String[] args) {
        Function<IntUnaryOperator, IntUnaryOperator> twice = f -> f.andThen(f);

        IntUnaryOperator plusThree = i -> i + 3;

        var g = twice.apply(plusThree);

        System.out.println(g.applyAsInt(7)); // 13
    }
}

या समतुल्य, स्थिर विधियों के साथ:

import java.util.function.*;

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

जावास्क्रिप्ट

Further information: जावास्क्रिप्ट

तीर कार्यों के साथ:

"use strict";

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

const plusThree = i => i + 3;

const g = twice(plusThree);

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

जूलिया

Further information: जूलिया (प्रोग्रामिंग भाषा)

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

कोटलिन

Further information: कोटलिन (प्रोग्रामिंग भाषा)

fun twice(f: (Int) -> Int): (Int) -> Int {
    return { f(f(it)) }
}

fun plusThree(i: Int) = i + 3

fun main() {
    val g = twice(::plusThree)

    println(g(7)) // 13
}

दो

Further information: लुआ (प्रोग्रामिंग भाषा)

function twice(f)
  return function (x)
    return f(f(x))
  end
end

function plusThree(i)
  return i + 3
end

local g = twice(plusThree)

print(g(7)) -- 13

मतलब

Further information: मैटलैब

function result = twice(f)
    result = @inner

    function val = inner(x)
        val = f(f(x));
    end
end

plusthree = @(i) i + 3;

g = twice(plusthree)

disp(g(7)); % 13

ओकैमल

Further information: OCaml (प्रोग्रामिंग भाषा)

let twice f x =
  f (f x)

let plus_three =
  (+) 3

let () =
  let g = twice plus_three in

  print_int (g 7); (* 13 *)
  print_newline ()

पीएचपी ==

Further information: PHP

<?php

declare(strict_types=1);

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');

echo $g(7), "\n"; // 13

या चर में सभी कार्यों के साथ:

<?php

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);

echo $g(7), "\n"; // 13

ध्यान दें कि एरो फ़ंक्शंस मूल रूप से पैरेंट स्कोप से आने वाले किसी भी वेरिएबल को कैप्चर करता है, जबकि अनाम कार्यों की आवश्यकता होती है use ऐसा करने के लिए कीवर्ड।

पर्ल

Further information: पर्ल

use strict;
use warnings;

sub twice {
    my ($f) = @_;
    sub {
        $f->($f->(@_));
    };
}

sub plusThree {
    my ($i) = @_;
    $i + 3;
}

my $g = twice(\&plusThree);

print $g->(7), "\n"; # 13

या चर में सभी कार्यों के साथ:

use strict;
use warnings;

my $twice = sub {
    my ($f) = @_;
    sub {
        $f->($f->(@_));
    };
};

my $plusThree = sub {
    my ($x) = @_;
    $x + 3;
};

my $g = $twice->($plusThree);

print $g->(7), "\n"; # 13

पायथन

Further information: पायथन (प्रोग्रामिंग भाषा)

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

पायथन डेकोरेटर सिंटैक्स का उपयोग अक्सर किसी फलन को उच्च-क्रम फलन के माध्यम से उस फलन को पारित करने के परिणाम के साथ बदलने के लिए किया जाता है। उदा., फलन g समान रूप से लागू किया जा सकता है:

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

>>> g(7)
13

आर

Further information: आर (प्रोग्रामिंग भाषा)

twice <- function(f) {
  return(function(x) {
    f(f(x))
  })
}

plusThree <- function(i) {
  return(i + 3)
}

g <- twice(plusThree)

> print(g(7))
[1] 13

राकु

Further information: राकू (प्रोग्रामिंग भाषा)

sub twice(Callable:D $f) {
    return sub { $f($f($^x)) };
}

sub plusThree(Int:D $i) {
    return $i + 3;
}

my $g = twice(&plusThree);

say $g(7); # 13

राकू में, सभी कोड ऑब्जेक्ट क्लोजर हैं और इसलिए आंतरिक लेक्सिकल वैरिएबल को बाहरी दायरे से संदर्भित कर सकते हैं क्योंकि लेक्सिकल वैरिएबल फलन के अंदर बंद है। Raku लैम्ब्डा एक्सप्रेशंस के लिए नुकीले ब्लॉक सिंटैक्स का भी समर्थन करता है जिसे एक चर के लिए असाइन किया जा सकता है या गुमनाम रूप से लागू किया जा सकता है।

रुबी

Further information: रूबी (प्रोग्रामिंग भाषा)

def twice(f)
  ->(x) { f.call(f.call(x)) }
end

plus_three = ->(i) { i + 3 }

g = twice(plus_three)

puts g.call(7) # 13

जंग

Further information: रस्ट (प्रोग्रामिंग भाषा)

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
}

स्काला

Further information: स्काला (प्रोग्रामिंग भाषा)

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

योजना

Further information: स्कीम (प्रोग्रामिंग भाषा)

(define (add x y) (+ x y))
(define (f x)
  (lambda (y) (+ x y)))
(display ((f 3) 7))
(display (add 3 7))

इस योजना उदाहरण में, उच्च-क्रम फलन (f x) करी को लागू करने के लिए प्रयोग किया जाता है। यह एक तर्क लेता है और एक फलन देता है। अभिव्यक्ति का मूल्यांकन ((f 3) 7) पहले मूल्यांकन के बाद एक फलन लौटाता है (f 3). लौटाया गया कार्य है (lambda (y) (+ 3 y)). फिर, यह तर्क के रूप में 7 के साथ दिए गए फलन का मूल्यांकन करता है, 10 लौटाता है। यह अभिव्यक्ति के बराबर है (add 3 7), तब से (f x) के करी रूप के बराबर है (add x y).

तेज

Further information: स्विफ्ट (प्रोग्रामिंग भाषा)

func twice(_ f: @escaping (Int) -> Int) -> (Int) -> Int {
    return { f(f($0)) }
}

let plusThree = { $0 + 3 }

let g = twice(plusThree)

print(g(7)) // 13

टीसीएल

Further information: Tcl

set twice {{f x} {apply $f [apply $f $x]}}
set plusThree {{i} {return [expr $i + 3]}}

# result: 13
puts [apply $twice $plusThree 7]

अनाम फलन (8.6 के बाद से) को लागू करने के लिए टीसीएल लागू कमांड का उपयोग करता है।

XACML

Further information: XACML

XACML मानक विशेषता बैग के एकाधिक मानों पर फलन लागू करने के लिए मानक में उच्च-क्रम फलन को परिभाषित करता है।

rule allowEntry{
    permit
    condition anyOfAny(function[stringEqual], citizenships, allowedCitizenships)
}

XACML में उच्च-क्रम के कार्यों की सूची XACML# उच्च क्रम के कार्यों को मिल सकती है।

एक्सक्वायरी

Further information: XQuery

declare function local:twice($f, $x) {
  $f($f($x))
};

declare function local:plusthree($i) {
  $i + 3
};

local:twice(local:plusthree#1, 7) (: 13 :)

विकल्प

फंक्शन पॉइंटर

C (प्रोग्रामिंग लैंग्वेज), C++, और पास्कल (प्रोग्रामिंग भाषा) जैसी भाषाओं में फंक्शन पॉइंटर्स प्रोग्रामर्स को फंक्शन्स के संदर्भ में पास करने की अनुमति देते हैं। निम्नलिखित सी कोड एक मनमानी फलन के अभिन्न अंग के अनुमान की गणना करता है:

#include <stdio.h>

double square(double x)
{
    return x * x;
}

double cube(double x)
{
    return x * x * x;
}

/* Compute the integral of f() within the interval [a,b] */
double integral(double f(double x), double a, double b, int n)
{
    int i;
    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;
}

सी मानक लाइब्रेरी से qsort फलन उच्च-क्रम फलन के व्यवहार का अनुकरण करने के लिए फलन पॉइंटर का उपयोग करता है।

मैक्रोज़

उच्च-क्रम के कार्यों के कुछ प्रभावों को प्राप्त करने के लिए मैक्रो (कंप्यूटर विज्ञान) का भी उपयोग किया जा सकता है। हालाँकि, मैक्रोज़ आसानी से वेरिएबल कैप्चर की समस्या से नहीं बच सकते हैं; उनके परिणामस्वरूप बड़ी मात्रा में डुप्लिकेट कोड भी हो सकता है, जो कि एक कंपाइलर के लिए अनुकूलित करना अधिक कठिन हो सकता है। मैक्रोज़ सामान्यतः दृढ़ता से टाइप नहीं किए जाते हैं, हालांकि वे दृढ़ता से टाइप किए गए कोड का उत्पादन कर सकते हैं।

डायनेमिक कोड मूल्यांकन

अन्य अनिवार्य प्रोग्रामिंग भाषाओं में, मूल्यांकन के दायरे में गतिशील रूप से निष्पादित कोड (कभी-कभी Eval या निष्पादन संचालन कहा जाता है) द्वारा उच्च-क्रम के कार्यों के माध्यम से प्राप्त किए गए समान एल्गोरिथम परिणामों में से कुछ को प्राप्त करना संभव है। इस दृष्टिकोण में महत्वपूर्ण कमियां हो सकती हैं:

• निष्पादित किया जाने वाला तर्क कोड सामान्यतः टाइप सिस्टम स्टेटिक टाइपिंग नहीं है; निष्पादित किए जाने वाले कोड की सुगठितता और सुरक्षा निर्धारित करने के लिए ये भाषाएं आम तौर पर टाइप सिस्टम डायनेमिक टाइपिंग पर निर्भर करती हैं।
• तर्क सामान्यतः एक स्ट्रिंग के रूप में प्रदान किया जाता है, जिसका मूल्य रन-टाइम तक ज्ञात नहीं हो सकता है। इस स्ट्रिंग को या तो प्रोग्राम के निष्पादन के दौरान संकलित किया जाना चाहिए (समय-समय पर संकलन का उपयोग करके) या दुभाषिया (कंप्यूटिंग) द्वारा मूल्यांकन किया जाना चाहिए, जिससे रन-टाइम पर कुछ अतिरिक्त ओवरहेड होता है, और सामान्यतः कम कुशल कोड उत्पन्न होता है।

वस्तुएँ

वस्तु-उन्मुख प्रोग्रामिंग भाषाओं में जो उच्च-क्रम के कार्यों का समर्थन नहीं करते हैं, वस्तु (कंप्यूटर विज्ञान) एक प्रभावी विकल्प हो सकता है। एक वस्तु की विधि (कंप्यूटर विज्ञान) कार्यों की तरह सार में कार्य करती है, और एक विधि वस्तुओं को मापदंडों के रूप में स्वीकार कर सकती है और वस्तुओं को रिटर्न मान के रूप में उत्पन्न कर सकती है। शुद्ध कार्यों की तुलना में वस्तुओं में अक्सर जोड़ा गया रन-टाइम ओवरहेड होता है, हालांकि, और किसी वस्तु और उसकी विधि को परिभाषित करने और तत्काल करने के लिए बॉयलरप्लेट कोड जोड़ा जाता है। स्टैक-आधारित मेमोरी आवंटन-आधारित (डायनेमिक मेमोरी आवंटन-आधारित बनाम) ऑब्जेक्ट्स या रिकॉर्ड (कंप्यूटर विज्ञान) की अनुमति देने वाली भाषाएं इस पद्धति के साथ अधिक लचीलापन प्रदान कर सकती हैं।

फ़्री पास्कल में एक फंक्शन के साथ एक साधारण स्टैक आधारित रिकॉर्ड का उपयोग करने का एक उदाहरण जो एक फंक्शन लौटाता है:

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);

begin  
  a := g(@f);     // return a function to "a"
  writeln(a(xy)); // prints 10
end.

कार्यक्रम a() लिया जाता है एक Txy रिकॉर्ड इनपुट के रूप में और रिकॉर्ड के योग का पूर्णांक मान लौटाता है x और y फ़ील्ड्स (3 + 7)।

निष्क्रियता

डिफंक्शनलाइजेशन का उपयोग उन भाषाओं में उच्च-क्रम के कार्यों को लागू करने के लिए किया जा सकता है जिनमें प्रथम श्रेणी के कार्यों की कमी होती है | प्रथम श्रेणी के कार्य:

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

इस मामले में, फलन अधिभार के माध्यम से विभिन्न कार्यों को ट्रिगर करने के लिए विभिन्न प्रकारों का उपयोग किया जाता है। इस उदाहरण में अतिभारित कार्य में हस्ताक्षर हैं auto apply.

यह भी देखें

• प्रथम श्रेणी फलन
• संयुक्त तर्क
• फंक्शन-लेवल प्रोग्रामिंग
• कार्यात्मक प्रोग्रामिंग
• कप्पा कलन - कार्यों के लिए एक औपचारिकता जो उच्च-क्रम के कार्यों को बाहर करती है
• रणनीति पैटर्न
• उच्च आदेश संदेश