A defunkcionalizálás a programozásban egy program fordítási idõben történõ átalakítására szolgáló technika , amely a magasabb rendû függvényeket egyetlen függvény hívásával helyettesíti, amely függvényt alkalmaz egy argumentumra.
John Reynolds írta le először 1972- ben [ 1] . Mivel minden program véges számú funkcionális absztrakciót tartalmaz, mindegyik helyettesíthető egyedi azonosítóval, és egy absztrakt függvény minden egyes alkalmazása egy ilyen programban helyettesíthető az alkalmazás függvény függvényhívásával az absztrakt azonosítójával. első paraméterként működjön. Ebben az esetben az alkalmazás függvény az absztrakt függvény azonosítója alapján választja ki a műveleteket, és végrehajtja azokat a többi argumentumra (az absztrakt függvény eredeti argumentumaira).
Ennek a technikának az egyik nehézsége, hogy a funkcionális absztrakció szabad változókra hivatkozhat . Ilyen helyzetben a λ-emelést – a szabad változók lezárásokká alakítását – el kell végezni a defunkcionalizálás végrehajtása előtt , hogy a funkcionális absztrakció által használt bármely szabad változó argumentumként kerüljön át az alkalmazásfüggvénybe. Továbbá, ha az öblítés első osztályú értékként támogatott , akkor új adatstruktúrákat kell létrehozni a rögzített értékek megjelenítéséhez.
Ahelyett, hogy egyetlen alkalmazásfüggvényt használnánk az összes eset kezelésére, különféle vezérlési folyamatelemzési technikák (beleértve a különböző típusú aritások (argumentumok száma) vagy típusaláírások ) egyszerű megkülönböztetését is használhatják az alkalmazás több speciális funkcióra történő szétválasztására. Ezenkívül a programozási nyelv támogathatja a funkciómutatókat , amelyek hatékonyabbak lehetnek, mint a küldési megközelítés.
Amellett, hogy a funkcionális programozási nyelvek fordítóiban használják magasabb rendű függvényeket használva, a defunkcionalizálást is megvizsgálták, mint egy tolmács absztrakt géppé történő mechanikus átalakításának módszerét . A defunkcionalizálás a függvények függvényobjektumokkal való ábrázolásának technikájához is kapcsolódik az objektumorientált programozásban (a lezárások alternatívájaként).
a következő program működésképtelenné vált:
hátrányok :: a -> [ a ] -> [ a ] hátrányok x xs = x : xs o :: ( b -> c ) -> ( a -> b ) -> a -> c o f g x = f ( g x ) lapít :: Fa t -> [ t ] lapít t = séta t [] séta :: Fa t -> [ t ] -> [ t ] séta ( Leaf x ) = cons x walk ( Node t1 t2 ) = o ( séta t1 ) ( séta t2 )Ehhez minden magasabb rendű függvényt ( cons, o, és walk) egy típusú értékkel Lamhelyettesítünk, és a közvetlen függvényhívás helyett egy olyan függvényt használunk apply, amely az ilyen típusú értékeket dolgozza fel:
adatok Lam a = LamCons a | LamO ( Lam a ) ( Lam a ) alkalmazni :: Lam a -> [ a ] -> [ a ] · alkalmazni ( LamCons x ) xs = x : xs alkalmazni ( LamO f1 f2 ) xs = alkalmazni f1 ( alkalmazni f2 xs ) cons_def :: a -> Lam a cons_def x = LamCons x o_def :: Lam a -> Lam a -> Lam a o_def f1 f2 = LamO f1 f2 flatten_def :: Fa t -> [ t ] flatten_def t = alkalmaz ( walk_def t ) [] walk_def :: Fa t -> Lam t walk_def ( Leaf x ) = cons_def x walk_def ( Node t1 t2 ) = o_def ( walk_def t1 ) ( walk_def t2 )