Functor, Applicative և Monad. ֆունկցիոնալ կոնտեյներների ամփոփում
Այս հոդվածում քննարկվում է, թե ինչպես են առնչվում միմյանց հետ երեք ֆունկցիոնալ կոնտեյներները՝ Functor-ը, Monad-ը և Applicative-ը։
Այս հոդվածով ավարտվում է կատեգորիաների տեսության մասին իմ շարքը։ Այստեղ ուշադրությունը սևեռում եմ այն բանի վրա, թե ինչպես են առնչվում միմյանց հետ նախկինում դիտարկված երեք ֆունկցիոնալ կոնտեյներները՝ Functor-ը, Monad-ը և Applicative-ը։
Ստորև դրանք համեմատում եմ հետևյալ առումներով.
- Տեսություն
- Օրենքներ
- Մեթոդներ
- Հնարավորություններ և կիրառման դեպքեր
Տեսություն
Functor
Կատեգորիաների տեսությունը Functor-ը սահմանում է որպես արտապատկերում մի կատեգորիայից մյուսը։
Ծրագրավորման մեջ Functor-ը կարելի է պատկերացնել որպես օժանդակ դաս, որը թույլ է տալիս կոնտեքստում փաթաթված արժեքներին կիրառել արտապատկերման գործողություն։ Այն կարելի է դիտարկել նաև որպես ինտերֆեյս, որը երաշխավորում է որոշակի կարողություն՝ օբյեկտի վիճակը փոխակերպելու հնարավորություն։ Ավելի ֆունկցիոնալ կողմնորոշում ունեցող լեզուներում, ինչպիսիք են Scala-ն կամ Haskell-ը, Functor-ը typeclass է։
Functor-ները լինում են մի քանի տեսակի։ Դրանց խորությամբ նկարագրելն ու վերլուծելը շատ դուրս է այս հոդվածի շրջանակից, բայց մի անհանգստացեք. ես ներառել եմ հղումներ լրացուցիչ ռեսուրսների, որոնք կօգնեն ավելին սովորել։
Functor-ների տեսակները.
- Contravariant Functor
- Invariant Functor
- Opposite Functor
- Bifunctor և Multifunctor
Java-ն և այլ ժամանակակից JVM լեզուները Functor-ների լավ ներկառուցված համարժեքներ չեն առաջարկում։ Այդուհանդերձ, ձեռքով գրելը բավական պարզ է։ Ամենամոտ համարժեքները, հավանաբար, Scala-ի Cats գրադարանում և Haskell-ում եղածներն են։
Applicative
Կատեգորիաների տեսության մեջ Applicative-ը (կոչվում է նաև Applicative Functor) ընդհանրացնում է Functor-ը. այն թույլ է տալիս գործել ոչ միայն կոնտեքստում գտնվող արժեքների, այլև կոնտեքստում գտնվող ֆունկցիաների վրա։
Արտահայտչական ուժի առումով այն գտնվում է Functor-ների և Monad-ների միջև։ Applicative-ները Monad-ներից թույլ են, բայց Functor-ներից ավելի շատ կառուցվածք ունեն։
Խիստ ասած՝ Applicative-ները թույլ չեն տալիս շղթայել գործողությունները այնպես, ինչպես Monad-ները, որտեղ մի գործողության արդյունքը սնում է հաջորդին։ Սակայն, ի տարբերություն Functor-ների, Applicative-ները թույլ են տալիս հաջորդականացնել հաշվարկները։
Ցավոք, այսպիսի առնչությունը ծրագրային ապահովման մեջ բավական դժվար է իրականացնել, քանի որ ի վերջո հիմքում ընկած տվյալները դառնում են հաջորդ գործողության մուտքը։
Monad
Ծրագրային ապահովման տերմիններով՝ կարող ենք այն դիտարկել որպես փաթաթան, որը մեր արժեքը դնում է կոնտեքստի մեջ և թույլ է տալիս այդ արժեքի վրա գործողություններ կատարել, մասնավորապես այնպիսի գործողություններ, որոնց արդյունքները փաթաթվում են Monad-ային կոնտեքստով։
Monad-ները հիմնականում ծառայում են ամեն տեսակի կողմնակի էֆեկտների մշակմանը.
- I/O գործողությունների կատարում
- Բացառություն նետել կարող գործողությունների հետ աշխատանք
- Ասինխրոն գործողությունների հետ աշխատանք
Արժե նշել նաև, որ գործողությունները կարելի է շղթայել այնպես, որ յուրաքանչյուր քայլի արդյունքը դառնա հաջորդի մուտքը։ Սա թույլ է տալիս գրել խիստ դեկլարատիվ կոդ՝ քիչ boilerplate-ով։
Ի տարբերություն Functor-ի, Monad-ը ժամանակակից ծրագրավորման լեզուներում ունի բազմաթիվ ներկառուցված իրականացումներ.
- Scala (Option, Try, Either, … և այլք)
- Haskell (IO, …. և այլք ),
- Java (Optional, խիստ ասած Monad չէ, բայց գրեթե)
Թե՛ գործնականում, թե՛ տեսականորեն այն նաև երեք հասկացություններից ամենահզորն է։ Ըստ զուտ մաթեմատիկական ուժի՝ ամենաթույլից մինչև ամենաուժեղը, ամբողջ հիերարխիան մոտավորապես այսպիսի տեսք ունի.

Օրենքներ
Functor
Functor-ի իրականացումը պետք է բավարարի երկու օրենք՝ Identity և Associativity
1. Identity
Functor-ի ներսի արժեքների արտապատկերումը identity ֆունկցիայով միշտ պետք է արժեքը վերադարձնի անփոփոխ։
2. Associativity
Երբ ֆունկցիաները կիրառվում են շղթայով, պետք չէ նշանակություն ունենա, թե ինչպես են դրանք ներդրված։
Applicative
Applicative-ի իրականացումը պետք է բավարարի չորս օրենք՝ Identity, Homomorphism, Interchange, Composition։
1. Identity
Identity ֆունկցիան կոնտեքստում գտնվող արժեքին կիրառելը միշտ պետք է արժեքը վերադարձնի անփոփոխ։
2. Homomorphism
Կոնտեքստում գտնվող ֆունկցիան կոնտեքստում գտնվող արժեքին կիրառելը պետք է նույն արդյունքը տա, ինչ ֆունկցիան արժեքին կիրառելը և հետո արդյունքը pure-ով կոնտեքստում փաթաթելը։
3. Interchange
f կոնտեքստով ֆունկցիան կոնտեքստով արժեքին կիրառելը պետք է համարժեք լինի փաթաթված ֆունկցիան, որը արժեքը որպես արգումենտ փոխանցում է մեկ այլ ֆունկցիայի, f կոնտեքստով ֆունկցիային կիրառելուն։
4. Composition
f կոնտեքստով ֆունկցիան, ապա g կոնտեքստով ֆունկցիան կիրառելը պետք է նույն արդյունքները տա, ինչ f-ի և g-ի կոմպոզիցիան կոնտեքստի ներսում կիրառելը։
Alternative Applicative
Կա նաև Applicative-ի համարժեք ձևակերպում, որի իրականացումը պետք է բավարարի երեք օրենք՝ Associativity, Left Identity և Right Identity։
1. Left identity
Նոր Applicative ստեղծելը և այն ֆունկցիայի հետ bind անելը պետք է նույն արդյունքը տա, ինչ ֆունկցիան արժեքին կիրառելը։
2. Right identity
Unit ֆունկցիան Applicative-ի հետ bind անելը պետք է նույն արդյունքը տա, ինչ նոր Applicative ստեղծելը։
3. Associativity
Երբ ֆունկցիաները կիրառվում են շղթայով, պետք չէ նշանակություն ունենա, թե ինչպես են դրանք ներդրված։
Եթե ավելի ուշադիր նայեք Applicative-ի այս ձևակերպման օրենքներին, կտեսնեք, որ դրանք համընկնում են Functor-ի օրենքների հետ։ Identity Law-ի տարբերությունը գալիս է երկու հասկացությունների կառուցվածքից, հատկապես Applicative-ում pure մեթոդի առկայությունից, ինչը ինչ-որ իմաստով նշանակում է, որ ստուգելու ևս մեկ դեպք կա։
Monad
Monad-ի իրականացումը պետք է բավարարի երեք օրենք՝ Left Identity, Right Identity և Associativity։
1. Left identity
Նոր Monad ստեղծելը և այն ֆունկցիայի հետ bind անելը պետք է նույն արդյունքը տա, ինչ ֆունկցիան արժեքին կիրառելը։
2. Right identity
Unit ֆունկցիան Monad-ի հետ bind անելը պետք է նույն արդյունքը տա, ինչ նոր Monad ստեղծելը։
3. Associativity
Երբ ֆունկցիաները կիրառվում են շղթայով, պետք չէ նշանակություն ունենա, թե ինչպես են դրանք ներդրված։
Ճիշտ ինչպես Applicative-ի դեպքում, Monad-ների օրենքները սերտորեն նման են Functor-ի օրենքներին։ Ավելին, Monad-ի օրենքները նույնական են Applicative-ի օրենքներին. տարբերվում է միայն հասկացությունը, որը օրենքները նկարագրում են, իսկ պայմանը մնում է նույնը։
Ինչ վերաբերում է նրան, թե որ հասկացությունն ինչն է ընդլայնում, երեքի միջև կապը մոտավորապես այնպիսին է, ինչպես ստորև նկարում. կարճ ասած՝ ամեն ինչ Functor է։

Մեթոդներ
Այս կառուցվածքներից որևէ մեկի իրականացումը պահանջում է generics-ներ աջակցող լեզու, քանի որ դրանցից յուրաքանչյուրը կառուցված է M<T> պարամետրիզացված տիպի վրա։ Որպես այլընտրանք՝ կարող եք յուրաքանչյուր անհրաժեշտ տիպի համար կոդ գեներացնել մակրոյով կամ նման կոնստրուկցիայով, բայց generics-ները դա շատ հեշտացնում են։
Functor
Functor-ը պահանջում է ընդամենը մեկ մեթոդ.
- map, որը ընդունում է ֆունկցիա, որը գործում է կոնտեքստի արժեքի վրա։ Դրա ստորագրությունը պետք է լինի M<R> (T -> R)։

Applicative
Applicative-ը պահանջում է երկու մեթոդ.
- pure, որը ձեր արժեքը փաթաթում է Applicative կոնտեքստով. դրա ստորագրությունը M<T>(T) է։
- apply (ap), որը ընդունում է կոնտեքստում գտնվող ֆունկցիա. այդ ֆունկցիան հետո գործում է կոնտեքստում գտնվող արժեքի վրա։ Դրա ստորագրությունը պետք է լինի M<U> (M<T -> U>)։

Alternative Applicative
Գոյություն ունի նաև Applicative-ի համարժեք ձևակերպում, որում product-ը փոխարինում է apply-ին։
- product, որը ընդունում է Applicative կոնտեքստով փաթաթված երկու առանձին արժեք և վերադարձնում է կոնտեքստ, որը երկուսն էլ պարունակում է։ Դրա ստորագրությունը պետք է լինի M<(T, U)>(M<T>, M<U>)։

Applicative-ների ցանկացած ձևակերպման դեպքում M<R> (T -> R) ստորագրությամբ map մեթոդը գալիս է ըստ սահմանման, քանի որ յուրաքանչյուր Applicative Functor է։
Monad
Monad-ը պահանջում է երկու մեթոդ.
- unit (of,), որը արժեքը փաթաթում է Monad կոնտեքստով. դրա ստորագրությունը M<T>(T) է։
- bind (flatMap), որը ընդունում է կոնտեքստի արժեքի վրա գործող ֆունկցիա, որի արդյունքն արդեն փաթաթված է Monad կոնտեքստով։ Դրա ստորագրությունը պետք է լինի M<U> (T -> M<U>)։

Ավելին, Monad-ը նաև Applicative է և հետևաբար նաև Functor։ Սա նշանակում է, որ շատ լրացուցիչ մեթոդներ ստանում ենք անվճար՝ մասնավորապես map-ը Functor-ից և apply-ը կամ product-ը Applicative-ից։
Հնարավորություններ և կիրառման դեպքեր
Functor
Functor-ը զուտ օժանդակ մեթոդ է։ Այն առաջարկում է միայն կամայական կոնտեքստի ներսում արժեքի պարզ արտապատկերում։
Միևնույն ժամանակ այն երեք հասկացություններից ամենապարզն ու մատչելին է և հարմար է գրեթե ամենուր, որտեղ պետք է կոնտեքստում գտնվող արժեքների վրա գործել։
Այդուհանդերձ, Functor-ներն ունեն սահմաններ։ Ըստ սահմանման՝ Functor-ը չի կարող շղթայել հաշվարկները։ Այն նաև ճանապարհ չի տալիս հարթեցնելու իր կատարած գործողությունների արդյունքները, ուստի ներդրված տիպեր, ինչպես <List<List<Long>>, հեշտությամբ կարող են հայտնվել։

Այդուհանդերձ, էֆեկտավոր գործողություններ կատարելու հնարավորությունը՝ առանց դրանք կոնտեքստից հանելու, իսկապես օգտակար հատկություն է։
Applicative
Մեկ քայլ առաջ Applicative-ն է, որը թույլ է տալիս կոնտեքստում գտնվող ֆունկցիաները կիրառել կոնտեքստում գտնվող արժեքին։ Դրանից բացի՝ նրա product տարբերակը թույլ է տալիս նույն կոնտեքստի երկու օբյեկտից tuple կառուցել։
Սա կարող է չափազանց հարմար լինել որոշ իրավիճակներում. կարող ենք շատ էֆեկտներ միավորել մեկի մեջ՝ List<Future> տիպերը վերածելով ավելի խելամիտ Future<List>-ի։
Ահա թե ինչու Applicative-ները շատ լավ են աշխատում parser-ներ, traversable-ներ կամ composer-ներ իրականացնելու և ցանկացած այլ դեպքում, երբ գործ ունենք նույն տիպի բազմաթիվ անկախ էֆեկտների հետ։
Եվ քանի որ Applicative-ը Functor է, այս արդյունքային tuple-ների վրա կարող ենք նաև գործողություններ կատարել map մեթոդով։
Monad
Վերջապես, կա Monad-ը՝ երեք կառուցվածքներից ամենաուժեղը։
Monad-ի յուրաքանչյուր իրականացում ներկայացնում է մի էֆեկտ.
- արժեքի բացակայություն (Option)
- հնարավոր ձախողում (Try)
- կա՛մ գործողության արդյունքը, կա՛մ ձախողումը (Either)
- հաշվարկների հաջորդականություն (IO)
Monad-ը նաև ճանապարհ է տալիս արժեքները դնելու այդպիսի էֆեկտավոր կոնտեքստում։
Ավելին, flatMap մեթոդը թույլ է տալիս աշխատել ներդրված վերադարձվող տիպերի հետ, ինչը իր հերթին վերացնում է M<M<T>> ձևի տիպերի (Optional<Optional<Long>) հետ կապված խնդիրները։

Monad-ի իրականացումը այդպիսի տիպերը ավտոմատ հարթեցնում է, որպեսզի մնա միայն մեկ էֆեկտ. մի բան, որ Functor-ի map մեթոդը ըստ սահմանման չի կարող անել։

Monad-ները թույլ են տալիս նաև կատարել կոնտեքստային գործողություններ, քանի որ մի գործողության ելքը կարող է ծառայել որպես մեկ այլի մուտք՝ տալով հաշվարկների մաքուր, դեկլարատիվ շղթա։
Ամփոփում
Ֆունկցիոնալ կոնտեյներները խիստ գործնական գործիք են, որը կարող է լուծել շատ տարբեր խնդիրներ։ Հավատում եմ, որ դրանք արժանի են տեղ գրավելու մեր ինժեներական գործիքակազմում, կամ գոնե մեր իրազեկվածության մեջ։ Պարզապես հիշեք, որ դրանք արծաթե փամփուշտ չեն, և ամեն ինչ Monad դարձնելը կոդ գրելու լավագույն մոտեցումը չէ։
Եզրափակելով՝ այս կոնտեյներները մի փոքր ավելի մաթեմատիկական նրբագեղություն են բերում ծրագրային ինժեներիա, ինչը, իմ կարծիքով, դրանք գնահատելու ևս մեկ պատճառ է։
Հուսով եմ՝ ձեզ դուր եկավ այս ընթերցանությունը։ Շնորհակալություն ձեր ժամանակի համար։