Térkép (magasabb rendű funkció) - Map (higher-order function)

Sok programozási nyelvek , térkép a neve egy magasabb rendű függvény , amely érvényes a megadott függvény , hogy minden egyes eleme egy funktorhoz , például egy lista , visszatérve a találati listát ugyanabban a sorrendben. Gyakran alkalmazható mindennek, ha funkcionális formában tekintik .

A térkép fogalma nem korlátozódik a listákra: szekvenciális konténerekre , faszerű konténerekre, vagy akár absztrakt konténerekre, például határidős és ígéretes konténerekre vonatkozik .

Példák: lista feltérképezése

Tegyük fel, hogy van egy egész számok listája, [1, 2, 3, 4, 5]és ki szeretnénk számítani az egyes egészek négyzetét. Ehhez először definiálunk egy függvényt squareegyetlen számhoz (itt látható a Haskellben ):

square x = x * x

Utána hívhatunk

>>> map square [1, 2, 3, 4, 5]

amely azt eredményezi [1, 4, 9, 16, 25], hogy mapa teljes listán keresztülment, és squareminden elemre alkalmazta a függvényt .

Vizuális példa

Az alábbiakban megtekintheti a leképezési folyamat egyes lépéseinek nézetét azoknak az egész számoknak X = [0, 5, 8, 3, 2, 1]a listájához X', amelyeket a funkciónak megfelelően új listába szeretnénk leképezni  : ${\ displaystyle f (x) = x+1}$

A feldolgozási lépések nézete a térképfunkció listán való alkalmazásakor

A mapHaskell alap -előjátéka (azaz "standard könyvtár") része, és a következőképpen valósul meg:

map :: (a -> b) -> [a] -> [b]
map _ []       = []
map f (x : xs) = f x : map f xs

Általánosítás

Haskell -ben a polimorf függvényt map :: (a -> b) -> [a] -> [b] egy poltipikus függvényre általánosítják fmap :: Functor f => (a -> b) -> f a -> f b, amely minden típusosztályhoz tartozó típusra vonatkozik . Functor

A típusú kivitelező listák []lehet meghatározni, mint egy példány a Functortípusú osztály alkalmazásával a mapfunkciót az előző példa:

instance Functor [] where
  fmap = map

További példák a Functorfák:

-- a simple binary tree
data Tree a = Leaf a | Fork (Tree a) (Tree a)

instance Functor Tree where  
  fmap f (Leaf x) = Leaf (f x)
  fmap f (Fork l r) = Fork (fmap f l) (fmap f r)

A fa hozamának feltérképezése:

>>> fmap square (Fork (Fork (Leaf 1) (Leaf 2)) (Fork (Leaf 3) (Leaf 4)))
Fork (Fork (Leaf 1) (Leaf 4)) (Fork (Leaf 9) (Leaf 16))

Minden esetben a Functortípusú osztály, fmapa szerződésben köteles engedelmeskedni funktorhoz törvények:

fmap id      ≡ id              -- identity law
fmap (f . g) ≡ fmap f . fmap g -- composition law

ahol a Haskell függvényösszetételét. jelöli .

Többek között ez lehetővé teszi elemi műveletek meghatározását különféle gyűjteményekhez .

Ezenkívül, ha F és G két functor, a természetes transzformáció a polimorf típusú függvény, amely tiszteletben tartja az fmap -t : ${\ displaystyle h: \ teljes TF (T) \ G (T)}$

${\ displaystyle h_ {Y} \ circ \ operatornév {fmap} (f) = \ operatornév {fmap} (f) \ circ h_ {X}}$bármilyen funkcióhoz .${\ displaystyle f: X \ Y}$

Ha a h függvényt paraméteres polimorfizmus határozza meg, mint a fenti típusdefinícióban, akkor ez a specifikáció mindig teljesül.

Optimalizálás

A térképek matematikai alapja számos optimalizálást tesz lehetővé . Az összetételi törvény biztosítja mindkettőt

• (map f . map g) list és
• map (f . g) list

ugyanarra az eredményre vezet; vagyis , . A második űrlapot azonban hatékonyabban lehet kiszámítani, mint az elsőt, mert mindegyikhez a teljes lista újratelepítése szükséges. Ezért a fordítók megpróbálják az első űrlapot a másodikra ​​alakítani; Az ilyen típusú optimalizálási ismert térkép fúzió és a funkcionális analógja hurok fúzió . ${\ displaystyle \ operatornév {térkép} (f) \ kör \ operatornév {térkép} (g) = \ operatnev$map

A térképfüggvények olyan hajtogatással definiálhatók és gyakran definiálhatók, mint például foldr, ami azt jelenti, hogy egy térkép-hajtogatási fúziót lehet végezni : foldr f z . map gegyenértékű a következővel foldr (f . g) z.

A fenti térkép megvalósítása az egyedileg linkelt listákon nem farok-rekurzív , ezért sok keretet hozhat létre a veremben, ha nagy listával hívják meg. Sok nyelv felváltva biztosít "fordított térkép" funkciót, amely egyenértékű a leképezett lista megfordításával, de farok-rekurzív. Itt van egy megvalósítás, amely a fold -bal funkciót használja.

reverseMap f = foldl (\ys x -> f x : ys) []

Mivel az egyedileg linkelt lista megfordítása szintén farok-rekurzív, a fordított és a fordított térkép összeállítható a normál térkép farok-rekurzív módon történő végrehajtásához, bár a listán két áthaladást kell végrehajtani.

Nyelvi összehasonlítás

A térkép funkció funkcionális programozási nyelvekből származik.

A nyelv Lisp bevezetett egy térkép funkció az úgynevezett maplist1959-ben, némileg eltérő változatok már megjelent 1958-ban Ez az eredeti definíció maplist, és feltérképezi a funkció az egymást követő többi meg:

maplist[x;f] = [null[x] -> NIL;T -> cons[f[x];maplist[cdr[x];f]]]

A funkció maplisttovábbra is elérhető az újabb Lisps -ekben, például a Common Lisp -ben , bár a hasonló mapcarvagy az általánosabb funkciókat maprészesítenék előnyben.

Négyszögesítése eleme egy listát maplistlenne írva S-expresszió jelölést, mint ez:

(maplist (lambda (l) (sqr (car l))) '(1 2 3 4 5))

A függvény használatával a mapcarfenti példát így írnánk:

(mapcar (function sqr) '(1 2 3 4 5))

Ma mapping funkciókat támogatja (vagy meg lehet határozni) számos eljárási , objektum-orientált , és multi-paradigma nyelveken is: A C ++ 's Standard Library , ez az úgynevezett std::transform, a C # (3,0)' s LINQ könyvtár, hanem ún Select. A Térkép gyakran használt művelet olyan magas szintű nyelveken is, mint a ColdFusion Markup Language (CFML), a Perl , a Python és a Ruby ; a műveletet mapmind a négy nyelven hívják . A Ruby collectalias mapis rendelkezésre áll (a Smalltalk -tól ). A Common Lisp térképszerű funkciók családját biztosítja; az itt leírt viselkedésnek megfelelőt hívják mapcar(a -carhozzáférést a CAR művelet segítségével jelzi ). Vannak olyan szintaktikai konstrukciójú nyelvek is, amelyek ugyanazt a funkcionalitást nyújtják, mint a térkép funkció.

A térképet néha úgy általánosítják, hogy elfogadja a kétdimenziós (2-argumentus) függvényeket, amelyek a felhasználó által szolgáltatott függvényt két lista megfelelő elemeire tudják alkalmazni. Egyes nyelvek erre speciális neveket használnak, például map2 vagy zipWith . Nyelvek explicit variadic funkciók lehetnek változatai térkép változó argumentumainak száma a támogatás változó argumentumainak száma funkciókat. A 2 vagy több listát tartalmazó térkép kezelési problémával szembesül, ha a listák különböző hosszúságúak. Különböző nyelvek különböznek ebben. Néhányan kivételt emelnek. Néhányan megállnak a legrövidebb lista lejárta után, és figyelmen kívül hagyják a többi lista további elemeit. Néhányan folytatják a leghosszabb lista hosszát, és a már befejeződött listák esetében adjanak át néhány helyőrző értéket az értéket jelző függvénynek.

A nyelvek, amelyek támogatják az első osztályú funkciók és kikészítéséhez , maplehet részben alkalmazták , hogy szüntesse meg a funkciót, hogy a művek csak az egyik értéket egy elemenkénti egyenértékű, hogy a művek egy egész tartály; például map squareegy Haskell -függvény, amely négyzetbe zárja a lista egyes elemeit.

Lásd még

• Funkció (funkcionális programozás)
• Konvolúció (informatika) , más néven konv vagy zip
• Szűrő (magasabb rendű funkció)
• Hajtogatás (magasabb rendű funkció)
• az egyes
• Szabad monoid
• Funkcionális programozás
• Magasabb rendű funkció
• A lista megértése
• Térkép (párhuzamos minta)

Hivatkozások