Inafasiriwa moja kwa moja kutoka kwa Wikipedia ya Kiingereza na Tafsiri ya Google

Programu ya kazi

Katika sayansi ya kompyuta , programu ya kazi ni dhana ya programu - mtindo wa kujenga muundo na mambo ya mipango ya kompyuta -ambayo inachukua hesabu kama tathmini ya kazi za hisabati na huepuka data kubadilisha na hali inayoweza kuhamasishwa . Ni utaratibu wa programu ya kutangaza , ambayo inamaanisha programu inafanywa kwa maneno [1] au matangazo [2] badala ya kauli . Katika msimbo wa kazi, thamani ya pato la kazi inategemea tu juu ya hoja zilizopitishwa kwenye kazi, kwa hiyo kupigia kazi f mara mbili kwa thamani sawa ya hoja x hutoa matokeo sawa f (x) kila wakati; hii inatofautiana na taratibu kulingana na hali ya ndani au ya kimataifa , ambayo inaweza kuzalisha matokeo tofauti kwa nyakati tofauti wakati inaitwa na hoja sawa lakini hali tofauti ya programu. Kuondoa madhara , yaani, mabadiliko katika hali ambayo hayategemea pembejeo za kazi, inaweza kufanya iwe rahisi kuelewa na kutabiri tabia ya programu, ambayo ni mojawapo ya motisha muhimu kwa ajili ya maendeleo ya programu za kazi.

Programu ya kazi ina asili yake katika lambda calculus , mfumo rasmi ulioanzishwa katika miaka ya 1930 kuchunguza computability , Entscheidungsproblem , ufafanuzi kazi , kazi kazi , na kurudia . Lugha nyingi za programu za utendaji zinaweza kutazamwa kama ufafanuzi kwenye calculda ya lambda. Mwingine kujulikana kwa utaratibu wa kuandika programu, mantiki ya programu , ni msingi wa mahusiano . [3]

Kwa kulinganisha, mipango ya mabadiliko ya mipango inasema kwa amri katika kificho cha chanzo , mfano rahisi zaidi kuwa wajibu . Programu isiyofaa ina kazi-sio maana ya hisabati-lakini kwa maana ya vikundi . Wanaweza kuwa na madhara ambayo yanaweza kubadilisha thamani ya hali ya programu. Kazi bila maadili ya kurudi hufanya busara. Kwa sababu hii, hawana uwazi wa kutafakari , yaani, kujieleza kwa lugha hiyo kunaweza kusababisha maadili tofauti kwa nyakati tofauti kutegemea hali ya mpango wa utekelezaji. [3]

Lugha za programu za uendeshaji zimesisitizwa sana wasomi badala ya maendeleo ya programu ya kibiashara. Hata hivyo, lugha za programu maarufu zinazounga mkono programu za kazi kama vile Common Lisp , Mpango , [4] [5] [6] [7] Kumbunga , [8] [9] Lugha ya Wolfram [10] (pia inajulikana kama Mathematica ), Raketi , [11] Erlang , [12] [13] [14] OCaml , [15] [16] Haskell , [17] [18] na F # [19] [20] imetumika katika maombi ya viwanda na biashara na mashirika mbalimbali. JavaScript , mojawapo ya lugha za kusambazwa sana ulimwenguni, [21] [22] ina mali ya lugha isiyofunguliwa ya kazi, [23] kwa kuongeza fikra zinazofaa na za msingi. Programu ya kazi pia inasaidiwa kwa baadhi lugha za programu maalum za programu kama R (takwimu), [24] J , K na Swali kutoka Kx Systems (uchambuzi wa kifedha), XQuery / XSLT ( XML ), [25] [26] na Opal . [27] Lugha zinazojulikana za kikoa zinazojulikana kama vile SQL na Lex / Yacc tumia vipengele vingine vya programu za kazi, hasa katika kutazama maadili yanayotumiwa . [28]

Programu katika mtindo wa kazi inaweza pia kufanywa kwa lugha ambazo si maalum kwa ajili ya programu za kazi. Kwa mfano, lugha ya programu ya Perl muhimu imekuwa chini ya kitabu kinachoeleza jinsi ya kutumia dhana za programu za kazi. [29] Hii pia ni kweli kwa lugha ya programu ya PHP . [30] C + + 11 , Java 8 , na C # 3.0 vyote vimeongezwa ili kuwezesha mtindo wa kazi. Lugha ya Julia pia inatoa uwezo wa programu za kazi. Kesi ya kuvutia ni ile ya Scala [31] - mara kwa mara imeandikwa kwa mtindo wa kazi, lakini kuwepo kwa madhara na hali inayoweza kuiweka kwenye eneo la kijivu kati ya lugha muhimu na za kazi.

Yaliyomo

Historia

Lambda calculus hutoa mfumo wa kinadharia kwa kuelezea kazi na tathmini yao. Ni mbali ya hisabati badala ya lugha ya programu-lakini hufanya msingi wa karibu kila lugha za sasa za programu za kazi. Uundaji sawa wa kinadharia, mantiki ya kuchanganya , ni kawaida inayoonekana kama zaidi ya kufikiri kuliko lambda calculus na kuitangulia katika uvumbuzi. Maandishi ya kikundi na lambda calculus wote walikuwa awali maendeleo ili kufikia mbinu wazi kwa msingi wa hisabati . [32]

Lugha ya mapema ya utendaji ilikuwa Lisp , iliyoanzishwa mwishoni mwa miaka ya 1950 kwa IBM 700/7000 kompyuta za kisayansi za mfululizo na John McCarthy wakati wa Taasisi ya Teknolojia ya Massachusetts (MIT). [33] Lisp kwanza alianzisha vipengele vingi vya utaratibu wa programu za utendaji, ingawa Lisps mapema walikuwa lugha nyingi za utaratibu , na kuingizwa kwa msaada wa mitindo mbalimbali ya programu kama vielelezo vipya vilivyobadilishwa. Baadaye, vipindi kama vile Scheme na Clojure , na madawati kama vile Dylan na Julia , walitaka kurahisisha na kurekebisha Lisp karibu na msingi wa kazi safi, wakati Common Lisp ilipangwa kuhifadhi na kusasisha vipengele vya kimapenzi vya vipengele vingi vingi vilivyochaguliwa. [34]

Lugha ya Usindikaji wa Habari (IPL) wakati mwingine hutajwa kama lugha ya kwanza ya programu ya programu ya kazi. [35] Ni lugha ya mkusanyiko wa kutengeneza orodha ya alama. Ina maana ya jenereta , ambayo ni sawa na kazi ambayo inakubali kazi kama hoja, na, kwa kuwa ni lugha ya ngazi ya mkusanyiko, msimbo unaweza kuwa data, hivyo IPL inaweza kuhesabiwa kuwa na kazi za juu. Hata hivyo, inategemea sana juu ya muundo wa orodha ya mchanganyiko na sifa zinazofaa.

Kenneth E. Iverson aliyetengeneza APL mapema miaka ya 1960, alielezea katika kitabu cha 1962 kitabu A Programming Language ( ISBN 9780471430148 ). APL ilikuwa ni ushawishi mkubwa katika FP ya John Backus . Katika miaka ya 1990, Iverson na Roger Hui waliumba J. Katikati ya miaka ya 1990, Arthur Whitney , ambaye hapo awali alifanya kazi na Iverson, aliumba K , ambayo hutumiwa kibiashara katika sekta za kifedha pamoja na kizazi chake Q.

John Backus aliwasilisha FP katika hotuba yake ya Tuba ya Turing ya 1977 "Je! Programu inaweza Kuwa huru kutoka kwa Sinema ya Neumann ? Sinema ya Kazi na Algebra ya Mipango". [36] Anafafanua mipango ya kazi kama kujengwa kwa njia ya hierarchical kwa njia ya "kuchanganya fomu" ambayo inaruhusu "algebra ya mipango"; kwa lugha ya kisasa, hii ina maana kwamba mipango ya utendaji kufuata kanuni ya utungaji [ citation inahitajika ] . Karatasi ya Backus iliongeza uchunguzi katika programu za kazi, ingawa imesisitiza programu ya ngazi ya kazi badala ya mtindo wa lambda-calculus ambao unahusishwa na programu za kazi.

Katika miaka ya 1970, ML iliundwa na Robin Milner katika Chuo Kikuu cha Edinburgh , na David Turner alianza lugha ya SASL katika Chuo Kikuu cha St Andrews na baadaye lugha ya Miranda katika Chuo Kikuu cha Kent . Pia huko Edinburgh katika miaka ya 1970, Burstall na Darlington waliendeleza lugha ya kazi ya NPL . [37] NPL ilikuwa msingi wa Equation Kleene Recursion na ilianzishwa kwanza katika kazi yao juu ya mabadiliko ya programu. [38] Burstall, MacQueen na Sannella kisha kuingiza aina ya polymorphic kuangalia kutoka ML ili kuzalisha lugha Hope . [39] ML hatimaye iliendelea kuwa lugha kadhaa, ambazo zinajulikana zaidi ni OCaml na Standard ML . Wakati huo huo, maendeleo ya Mpango , mchoro rahisi wa kisheria na wa (kazi isiyosababishwa) wa Lisp, kama ilivyoelezwa kwenye Vitabu vya kuvutia vya Lambda na kitabu cha mafunzo ya kisasa ya 1985 Uundo na Ufafanuzi wa Programu za Kompyuta , umeleta ufahamu wa nguvu za programu za kazi kwa ujumla programu ya lugha-lugha.

Katika miaka ya 1980, Per Martin-Löf alianzisha nadharia ya aina ya intuitionistic (pia inaitwa nadharia ya aina ya kujenga ), ambayo ilihusisha mipango ya kazi na ushahidi wa kujenga wa mapendekezo makubwa ya hisabati yaliyothibitishwa kama aina ya tegemezi . Hii imesababisha mbinu mpya za nguvu za theorem zinazoingiliana na zinaathiri maendeleo ya lugha nyingi zinazofuata za programu za kazi.

Lugha ya Haskell ilianza kwa makubaliano mwaka 1987 ili kuunda kiwango cha wazi cha utafiti wa programu ya kazi; releases utekelezaji yameendelea tangu 1990.

Dhana

Dhana kadhaa na vielelezo ni maalum kwa programu za kazi, na kwa ujumla ni kigeni na programu muhimu (ikiwa ni pamoja na programu zinazoelekezwa na kitu ). Hata hivyo, lugha za programu mara nyingi huwa na maonyesho kadhaa ya programu, kwa hivyo programu za kutumia "lugha nyingi" zinaweza kutumia baadhi ya dhana hizi. [40]

Kazi ya kwanza na ya juu ya utaratibu

Kazi za utaratibu wa juu ni kazi zinazoweza kuchukua kazi nyingine kama hoja au kurudi kwao kama matokeo. Katika calculus, mfano wa kazi ya juu-utaratibu ni operator tofauti , ambayo inarudi matokeo ya kazi .

Kazi za juu za utaratibu zinahusiana kwa karibu na kazi za darasa la kwanza katika kazi za juu za utaratibu na kazi za darasa la kwanza zote zinawezesha kazi kama hoja na matokeo ya kazi nyingine. Tofauti kati ya hizi mbili ni ya hila: "utaratibu wa juu" unaelezea dhana ya kazi ya hisabati ambayo inafanya kazi kwa kazi nyingine, wakati "darasa la kwanza" ni neno la sayansi ya kompyuta linalolingana vyombo vya lugha ambavyo havizuii matumizi yao (hivyo Kazi ya kwanza ya darasa inaweza kuonekana mahali popote katika programu ambayo vyombo vingine vya kwanza kama namba zinaweza, ikiwa ni pamoja na hoja kwa kazi nyingine na kama maadili ya kurudi).

Kazi za utaratibu wa juu zinawezesha maombi ya sehemu au kupima , mbinu ambayo inatumika kazi kwa hoja zake moja kwa moja, na kila maombi inarudi kazi mpya ambayo inakubali hoja inayofuata. Hii inaruhusu mpangilio kufanikisha kwa ufanisi, kwa mfano, kazi ya mrithi kama mtumiaji wa ziada anayetumiwa kwa nambari moja ya asili .

Pure kazi

Kazi safi (au maneno) hawana madhara (kumbukumbu au I / O). Hii ina maana kwamba kazi safi zina mali kadhaa muhimu, ambazo nyingi zinaweza kutumiwa kuboresha msimbo:

  • Ikiwa matokeo ya kujieleza safi hayatumiwi, inaweza kuondolewa bila kuathiri maneno mengine.
  • Ikiwa kazi safi inaitwa na hoja ambazo hazina madhara, matokeo yake ni ya kawaida kwa heshima ya orodha hiyo ya hoja (wakati mwingine huitwa uwazi wa kutafakari ), yaani, ikiwa wito wa kazi safi tena na hoja sawa hurudi matokeo sawa. (Hii inaweza kuwezesha optimization caching kama memoization .)
  • Ikiwa hakuna utegemezi wa data kati ya maneno mawili safi, utaratibu wao unaweza kugeuzwa, au wanaweza kufanywa kwa usawa na hawawezi kuingilia kati (kwa maneno mengine, tathmini ya kujieleza yoyote safi ni salama ya thread ).
  • Ikiwa lugha nzima hairuhusu madhara ya upande, basi mkakati wowote wa tathmini unaweza kutumika; hii inatoa uhuru wa compiler kurekebisha au kuchanganya tathmini ya maneno katika programu (kwa mfano, kutumia misitu ).

Wakati washiriki wengi wa lugha za programu muhimu wanachunguza kazi safi na hufanya uharibifu wa kawaida wa kutetea kwa wito wa kazi safi, hawawezi daima kufanya hivyo kwa maktaba ya awali yaliyoandaliwa, ambayo kwa ujumla haifai maelezo haya, hivyo kuzuia optimizations zinazohusisha kazi hizo za nje. Washiriki wengine, kama vile gcc , ongeza maneno muhimu ya programu ya kuandika wazi kazi ya nje kama safi, ili kuwezesha ufanisi kama huo. Fortran 95 pia inaruhusu kazi kuwa mteule safi .

Urekebishaji

Ufafanuzi (kutunga) katika lugha za kazi hufanyika kupitia upinduzi . Kazi za kupumua zinajitokeza wenyewe, kuruhusu operesheni kurudia hadi kufikia kesi ya msingi . Ingawa baadhi ya kurudia inahitaji kudumisha stack, kurudi kwa mkia inaweza kutambuliwa na kufanywa na mkusanyiko katika msimbo ule ule uliotumiwa kutekeleza iteration katika lugha zinazofaa. Kiwango cha lugha ya Scheme inahitaji utekelezaji wa kutambua na kuboresha upyaji wa mkia. Uwezo wa upyaji wa mkia unaweza kutekelezwa kwa kubadili programu katika mtindo wa kupitisha wakati wa kuandaa, miongoni mwa njia zingine.

Mwelekeo wa kawaida wa upinduzi unaweza kufanywa kwa kutumia kazi za juu, pamoja na upigaji wa mvua na anamorphisms (au "folds" na "hufunua") kuwa mifano ya dhahiri zaidi. Kazi hizo za juu zinafanya jukumu linalofanana na miundo ya kudhibiti kama vile vitanzi katika lugha muhimu .

Lugha nyingi za programu za kazi za kusudi zinawezesha kurudia upungufu usio na kizuizi na ni Turing kamili , ambayo inafanya tatizo la kusimamisha haliwezekani , linaweza kusababisha kutokuwepo kwa mawazo ya usawa , na kwa ujumla inahitaji kuanzishwa kwa kutofautiana katika mantiki iliyoonyeshwa na mfumo wa aina ya lugha. Lugha zingine za kusudi kama vile Coq zinaruhusu upungufu wa msingi tu na zinaimarisha kwa nguvu (mahesabu yasiyo ya kukataza yanaweza kutajwa tu na mito isiyo na maadili ya maadili inayoitwa codata ). Kwa hiyo, lugha hizi haziwezi kuwa Turing kamili na kuelezea kazi fulani ndani yao haiwezekani, lakini bado zinaweza kuelezea darasa kubwa la mchanganyiko wa kuvutia wakati wa kuepuka matatizo yaliyotokana na upyaji usio na kizuizi. Mpangilio wa kazi uliowekwa kwa upungufu wa msingi ulio na vikwazo vingine vingine huitwa programu ya jumla ya kazi . [41]

Mkali dhidi tathmini zisizo kali

Lugha za kazi zinaweza kugawanywa kwa kutumia kama tathmini kali (zisizohitajika) au zisizo kali (zavivu) , ambazo zinaelezea jinsi hoja za kazi zinapotumiwa wakati maelekezo yanapimwa. Tofauti ya kiufundi ni katika semantics ya dhana ya maneno yenye masomo yasiyopotea au yanayopoteza. Chini ya tathmini kali, tathmini ya neno lolote ambalo linalosababisha hali ya kushindwa inashindwa. Kwa mfano, maneno:

uchapisha urefu ([2 + 1, 3 * 2, 1/0, 5-4])

inashindwa chini ya tathmini kali kwa sababu ya mgawanyiko kwa sifuri katika kipengele cha tatu cha orodha. Chini ya tathmini ya uvivu, kazi ya urefu inarudi thamani 4 (yaani, idadi ya vitu katika orodha), kwani kutathmini haijaribu kutathmini masharti yanayofanya orodha. Kwa kifupi, tathmini kali mara zote hutathmini kikamilifu hoja za kazi kabla ya kukifanya kazi. Tathmini ya uvivu haina tathmini hoja za kazi isipokuwa maadili yao yanatakiwa kutathmini kazi inayojiita.

Mkakati wa utekelezaji wa kawaida wa tathmini ya wavivu katika lugha za kazi ni kupunguza grafu . [42] Lazy tathmini hutumiwa na default katika lugha kadhaa safi kazi, ikiwa ni pamoja Miranda , safi , na Haskell .

Hughes 1984 inasema kwa tathmini ya wavivu kama utaratibu wa kuboresha utaratibu wa utaratibu kwa kutenganisha matatizo , kwa kuondosha utekelezaji huru wa wazalishaji na watumiaji wa mito ya data. [43] Launchbury 1993 inaelezea matatizo fulani ambayo tathmini ya wavivu huanzisha, hususan katika kuchunguza mahitaji ya kuhifadhi programu, na inapendekeza semantics ya kazi ili kusaidia katika uchambuzi huo. [44] Harper 2009 inapendekeza ikiwa ni pamoja na tathmini mbili kali na yavivu katika lugha hiyo, kwa kutumia mfumo wa aina ya lugha ili kuwafautisha. [45]

Weka mifumo ya

Hasa kutokana na maendeleo ya aina ya Hindley-Milner katika miaka ya 1970, lugha za programu za utendaji zimekuwa zikitumia mipangilio ya lambda , kukataa mipango yote batili wakati wa kukusanya na kuhatarisha makosa ya uongo , isipokuwa na lambda calculated isiyo ya kawaida , ambayo inakubali yote halali mipango wakati wa kukusanya na hatari ya makosa mabaya ya uongo , kutumika katika Lisp na aina zake (kama vile Mpango ), ingawa wanakataa mipango yote batili wakati wa kukimbia, wakati maelezo ya kutosha kukataa mipango halali. Matumizi ya datatypes ya algebraic hufanya uharibifu wa miundo tata data rahisi; uwepo wa kuangalia nguvu ya wakati wa kukusanya hufanya mipango ya kuaminika zaidi kwa kutokuwepo kwa mbinu nyingine za kuaminika kama maendeleo ya mtihani , wakati uingizaji wa aina hutoa huru programu hiyo kwa haja ya kujitangaza aina ya kompiler mara nyingi.

Lugha zingine za kazi zinazohusiana na utafiti kama vile Coq , Agda , Cayenne , na Epigram zinategemea nadharia ya aina ya intuitionistic , ambayo inaruhusu aina zinategemea maneno. Aina hiyo huitwa aina ya tegemezi . Mifumo ya aina hizi hazina uingizaji wa aina ya kuamua na ni vigumu kuelewa na programu na [ citation inahitajika ] . Lakini aina za tegemezi zinaweza kutoa mapendekezo ya kiholela katika mantiki ya utabiri . Kwa njia ya isomorphism ya Curry-Howard , basi, mipango iliyoboreshwa vizuri katika lugha hizi huwa njia ya kuandika ushahidi rasmi wa hisabati ambayo mkusanyiko anaweza kuzalisha msimbo wa kuthibitishwa . Wakati lugha hizi zina maslahi katika utafiti wa kitaaluma (ikiwa ni pamoja na katika hisabati rasmi ), zimeanza kutumika katika uhandisi pia. Compcert ni compiler kwa subset ya C programu ya programu ambayo imeandikwa katika Coq na kuthibitishwa rasmi. [46]

Aina ndogo ya aina ya tegemezi inayoitwa aina za data za algebraic za jumla (GADT) zinaweza kutekelezwa kwa namna ambayo hutoa baadhi ya manufaa ya programu iliyowekwa kwa kutegemea wakati wa kuepuka matatizo mengi. [47] GADT zinapatikana katika Glasgow Haskell Compiler , katika OCaml (tangu toleo 4.00) na katika Scala (kama "makundi ya kesi"), na wamependekezwa kama nyongeza kwa lugha zingine ikiwa ni pamoja na Java na C #. [48]

Ufafanuzi wa uwazi

Programu za kazi hazina maelezo ya kazi, yaani, thamani ya kutofautiana katika programu ya kazi haijabadilishwa mara moja. Hii inachukua nafasi yoyote ya madhara kwa sababu yoyote ya kutofautiana inaweza kubadilishwa na thamani yake halisi wakati wowote wa utekelezaji. Hivyo, mipango ya kazi ni ya wazi kwa uwazi. [49]

Fikiria kauli ya kazi ya C x = x * 10 , hii inabadilishwa thamani iliyotolewa kwa variable x . Hebu tuseme kuwa thamani ya kwanza ya x ilikuwa 1 , kisha tathmini mbili za mfululizo wa variable x zinazalisha 10 na 100 mtiririko huo. Wazi, kuondoa x = x * 10 na ama 10 au 100 inatoa mpango kwa maana tofauti, na hivyo kujieleza si referentially wazi. Kwa kweli, taarifa za kazi hazijawahi kuwa wazi kwa uwazi.

Sasa, fikiria kazi nyingine kama int plusone(int x) {return x+1;} ni wazi, kwa sababu haina mabadiliko ya pembejeo x na hivyo haina madhara kama hayo . Programu za kazi zinatumia tu aina hii ya kazi na kwa hiyo ni wazi kwa uwazi.

Programu ya kazi katika lugha zisizo za kazi

Inawezekana kutumia mtindo wa utendaji wa programu katika lugha ambazo si za kawaida zinazingatiwa lugha za kazi. [50] Kwa mfano, D na Fortran 95 husaidiana wazi kazi safi. [51]

JavaScript , Lua [52] na Python zilikuwa na kazi za darasani ya kwanza tangu kuanzishwa. [53] Amrit Prem aliongeza msaada kwa Python kwa " lambda ", " ramani ", " kupunguza ", na " chujio " mwaka 1994, pamoja na kufungwa katika Python 2.2, [54] ingawa Python 3 imesababisha "kupunguza" kwenye functools moduli kiwango cha maktaba. [55] Kazi za kwanza za darasa zimeletwa katika lugha zingine za kawaida kama PHP 5.3, Visual Basic 9, C # 3.0, na C ++ 11 . [ citation inahitajika ]

Katika PHP , madarasa yasiyojulikana , kufungwa na lambdas hutumiwa kikamilifu. Maktaba na upanuzi wa lugha kwa miundo ya data isiyobadilika hupandwa ili kusaidia programu katika mtindo wa kazi.

Katika Java , madarasa yasiyojulikana wakati mwingine hutumiwa kuiga kufungwa ; [56] hata hivyo, madarasa yasiyojulikana sio kila mara sahihi ya kufungwa kwa sababu wana uwezo mdogo zaidi. [57] Java 8 inaunga mkono maneno ya lambda kama nafasi ya madarasa fulani yasiyojulikana. [58] Hata hivyo, kuwepo kwa tofauti ya kuchunguza katika Java inaweza kufanya programu za kazi zisizosababishwa, kwa sababu inaweza kuwa muhimu kukamata tofauti za kuchunguza na kisha kuzibadilisha-tatizo ambalo halitokea katika lugha zingine za JVM ambazo hazikutafuta mbali, kama vile kama Scala. [ citation inahitajika ]

Katika C # , madarasa yasiyojulikana hayakuhitajika , kwa sababu kufungwa na lambdas hutumiwa kikamilifu. Maktaba na upanuzi wa lugha kwa miundo ya data isiyobadilika hupandwa ili kusaidia programu katika mtindo wa kazi katika C #.

Wengi kitu-oriented design chati ni expressible katika suala programu ya kazi: kwa mfano, mkakati muundo tu inaonyesha matumizi ya kazi juu-ili, na mgeni muundo takribani sambamba na catamorphism , au mara .

Vivyo hivyo, wazo la data isiyoweza kuingizwa kutoka kwa programu za kazi mara nyingi hujumuishwa katika lugha zinazofaa za programu, [59] kwa mfano tuple katika Python, ambayo ni safu isiyoweza kubadilika.

Miundo ya data

Mara kwa mara miundo ya data ya kazi hufanyika kwa njia tofauti kuliko wenzao wa lazima . [60] Kwa mfano, safu na upatikanaji wa muda wa mara kwa mara na sasisho ni sehemu ya msingi ya lugha nyingi muhimu na muundo wengi wa data muhimu, kama vile meza ya hash na chungu ya binary , hutegemea vifungo. Mipangilio inaweza kubadilishwa na ramani au orodha ya upatikanaji wa random , ambayo inakubali utekelezaji wa kazi halisi, lakini wakati wa kufikia na upasishaji ni logarithmic . Kwa hivyo, miundo ya data ya kazi isiyoweza kutumika inaweza kutumika katika lugha zisizo za kazi, lakini huenda sio chombo cha ufanisi zaidi, hasa ikiwa uendelezaji hauhitajiki.

Kulinganisha na programu muhimu

Programu ya kazi ni tofauti sana na programu muhimu . Tofauti muhimu zaidi hutokana na ukweli kwamba programu za kazi huepuka madhara , ambayo hutumiwa katika programu muhimu ya kutekeleza hali na I / O. Programu sahihi ya utendaji huzuia kabisa madhara na hutoa wazi uwazi .

Kazi ya juu ya utaratibu haitumiwi mara kwa mara katika mipango ya zamani ya mapambo. Mpango wa kikabila wa jadi unaweza kutumia kitanzi kuvuka na kurekebisha orodha. Mpango wa kazi, kwa upande mwingine, ingekuwa utatumia kazi ya "ramani" ya juu ambayo inachukua kazi na orodha, kuzalisha na kurudi orodha mpya kwa kutumia kazi kwa kila kipengee cha orodha.

Simulating hali ya

Kuna kazi (kwa mfano, kudumisha uwiano wa akaunti ya benki) ambazo huonekana mara nyingi hutekelezwa kwa kawaida na serikali. Programu sahihi ya utendaji hufanya kazi hizi, na kazi za I / O kama kukubali pembejeo za mtumiaji na uchapishaji kwenye skrini, kwa njia tofauti.

Lugha safi ya programu ya programu Haskell hutumia vifaa vya kutumia miundo , inayotokana na nadharia ya jamii . Mipango hutoa njia ya aina isiyo ya kawaida ya mifumo ya computational, ikiwa ni pamoja na (lakini sio mdogo) mfano wa mchanganyiko wenye hali inayoweza kuambukizwa (na madhara mengine kama vile I / O) kwa namna ya lazima bila kupoteza usafi. Wakati mikutano iliyopo inaweza kuwa rahisi kuomba katika programu, ikitoa templates na mifano sahihi, wanafunzi wengi wanawaona kuwa vigumu kuelewa conceptually, kwa mfano, wakati waulizwa kufafanua monads mpya (ambayo wakati mwingine inahitajika kwa baadhi ya aina ya maktaba). [61]

Njia nyingine ambayo lugha za kazi zinaweza kulinganisha hali ni kwa kupitia muundo wa data unaowakilisha hali ya sasa kama parameter ya kufanya simu. Kwa kila simu ya kazi, nakala ya muundo huu wa data imeundwa na tofauti yoyote ni matokeo ya kazi. Hii inajulikana kama ' mtindo wa kupitisha hali '.

Lugha zisizofaa za kazi huwa ni pamoja na njia ya moja kwa moja ya kusimamia hali inayoweza kutumiwa. Kichujio , kwa mfano, hutumia marejeo yaliyosimamiwa ambayo yanaweza kusasishwa kwa kutumia kazi safi kwa hali ya sasa. Aina hii ya mbinu inawezesha mutability wakati bado kukuza matumizi ya kazi safi kama njia preferred ya kuelezea mahesabu.

Mbinu mbadala kama vile Hoare mantiki na pekee zimeandaliwa kufuatilia madhara katika programu. Baadhi ya lugha za kisasa za utafiti hutumia mifumo ya athari ili uwezekano wa madhara wazi.

Masuala ya ufanisi

Lugha za programu za uendeshaji ni kawaida chini ya ufanisi katika matumizi yao ya CPU na kumbukumbu kuliko lugha muhimu kama vile C na Pascal . [62] Hii inahusiana na ukweli kwamba baadhi ya miundo ya data inayoweza kugeuka kama miundo ina utekelezaji wa moja kwa moja sana kwa kutumia vifaa vya sasa (ambayo ni mashine ya Turing iliyobadilishwa sana). Vipande vya gorofa vinaweza kupatikana kwa ufanisi sana na CPU zilizopigwa kwa kasi, kupitishwa kwa ufanisi kupitia caches (bila pointer tata chasing ), au kushughulikiwa na maelekezo ya SIMD. Pia si rahisi kuunda wenzao wanaoweza kushindwa kwa ujumla sawa na kusudi. Kwa lugha halisi ya kazi, kushuka kwa hali mbaya zaidi ni logarithmic katika idadi ya seli za kumbukumbu, kwa sababu kumbukumbu inayoweza kutajwa inaweza kusimamishwa na muundo wa data wa kazi halisi na wakati wa kufikia logarithmic (kama mti unaofaa). [63] Hata hivyo, kushuka kwa kasi vile sio kwa kawaida. Kwa mipango inayofanya uchunguzi mkubwa wa namba, lugha za kazi kama vile OCaml na Safi ni ndogo kidogo tu kuliko C kulingana na The Computer Language Benchmarks Game . [64] Kwa mipango inayohusika na matrices makubwa na databases mbalimbali, safu za lugha za kazi (kama vile J na K ) zimeundwa na uboreshaji wa kasi.

Ukosefu wa data unaweza katika hali nyingi kusababisha ufanisi wa kutekeleza kwa kuruhusu mkufunzi kufanya mawazo yasiyo salama kwa lugha ya lazima, na hivyo kuongeza fursa za upanuzi wa ndani . [65]

Tathmini ya uvivu inaweza pia kuongeza kasi ya mpango huo, hata kama inavyopotoka, ingawa inaweza kupunguza kasi kwa sababu ya mara kwa mara (hata hivyo, inaweza kuanzisha uvujaji wa kumbukumbu ikiwa hutumiwa vibaya). Launchbury 1993 [44] inajadili masuala ya kinadharia kuhusiana na uvujaji wa kumbukumbu kutoka tathmini ya wavivu, na O'Sullivan et al. 2008 [66] kutoa ushauri wa vitendo kwa ajili ya kuchambua na kuifanya. Hata hivyo, utekelezaji wa jumla wa tathmini ya wavivu hutumia sana kanuni za daraja na data hazifanyi vizuri kwa wasindikaji wa kisasa na mabomba ya kina na caches mbalimbali (ambapo cache kukosa inaweza gharama mamia ya mzunguko) [ citation inahitajika ] .

Mitindo ya ukodishaji

Mipango ya uendeshaji ina mazingira na mlolongo wa hatua zinazoendesha mazingira. Mipango ya kazi ina maneno ambayo yanafanyika kwa ufanisi hadi kufikia fomu ya kawaida. Mfano unaonyesha hili kwa ufumbuzi tofauti kwa lengo moja la programu (kuhesabu namba za Fibonacci ).

PHP

Kuchapisha nambari 10 za Fibonacci kwanza, kwa kutumia kazi

kazi f ( int $ n ) : int {
    kurudi ( $ n === 0 || $ n === 1 ) ? $ n : fib ( $ n - 1 ) + fiber ( $ n - 2 );
}

kwa ( $ i = 0 ; $ i <= 10 ; $ i ++ ) echo fib ( $ i ) . PHP_EOL ;

Kuchapisha nambari 10 za Fibonacci kwanza, kwa kutumia kufungwa

$ fib = kazi ( int $ n ) matumizi ( & $ fib ) : int {
    kurudi ( $ n === 0 || $ n === 1 ) ? $ n : $ fib ( $ n - 1 ) + $ fib ( $ n - 2 );
};

kwa ( $ i = 0 ; $ i <= 10 ; $ i ++ ) echo $ fib ( $ i ) . PHP_EOL ;

Kuchapisha orodha na nambari 10 za kwanza za Fibonacci, na jenereta

kazi fib ( int $ n ) {
    mavuno 0 ; $ n - ;
    mavuno 1 ; $ n - ;
    $ pili = ( $ kwanza = 2 ) + 1 ;
    wakati ( $ n - ! == 0 ) {
        kuzalisha $ kwanza ;
        [ $ pili , $ kwanza ] = [ $ kwanza + $ pili , $ pili ];
    }
}

$ fibo = fib ( 10 );
Foreach ( $ fibo kama thamani ya $ ) {
    Echo thamani ya $ . PHP_EOL ;
}

Python

Kuchapisha nambari 10 za Fibonacci kwanza, iterative

def Fibonacci (n, kwanza = 0, pili = 1):
    wakati n = = 0 :
        Chapisha ( kwanza , mwisho + " \ n " ) # upande-athari
        N , kwanza , pili = n - 1 , pili , kwanza + pili # mgawo
fibonacci ( 10 )

Kuchapisha nambari 10 za Fibonacci kwanza, style ya kujieleza ya kazi

fibonacci = ( lambda n , kwanza = 0 , pili = 1 :
    "" ikiwa n == 0 mwingine
    str ( kwanza ) + " \ n " + fibonacci ( n - 1 , pili , kwanza + pili ))
magazeti ( fibonacci ( 10 ), mwisho = "" )

Kuchapisha orodha na nambari 10 za kwanza za Fibonacci, na jenereta

def Fibonacci (n, kwanza = 0, pili = 1):
    wakati n = = 0 :
        mazao ya kwanza
        N , kwanza , pili = n - 1 , pili , kwanza + pili # mgawo
magazeti ( orodha ( fibonacci ( 10 )))

Kuchapisha orodha yenye nambari 10 za kwanza za Fibonacci, style ya kujieleza ya kazi

fibonacci = ( lambda n , kwanza = 0 , pili = 1 :
    [] ikiwa n == 0 mwingine
    [Kwanza] + Fibonacci (n - 1, ya pili, ya kwanza + ya pili))
magazeti ( fibonacci ( 10 ))

Haskell

Kuchapisha namba za kwanza za Fibonacci 10, mtindo wa kujieleza wa kazi [1]

fibonacci_aux = \ N kwanza pili ->
    kama n == 0 basi "" mwingine
    onyesha kwanza + + " \ n " + + fibonacci_aux ( n - 1 ) pili ( kwanza + pili )
fibonacci = \ n -> fibonacci_aux n 0 1
kuu = putStr (Fibonacci 10)

Kuchapisha orodha yenye nambari 10 za kwanza za Fibonacci, mtindo wa kujieleza wa kazi [1]

fibonacci_aux = \ N kwanza pili ->
    ikiwa n == 0 basi [] kingine
    [Kwanza] ++ fibonacci_aux (n - 1) pili (kwanza + wa pili)
fibonacci = \ n -> fibonacci_aux n 0 1
kuu = putStrLn (show (Fibonacci 10))

Kuchapa nambari ya Fibonacci ya 11, mtindo wa kujieleza wa kazi [1]

fibonacci = \ n -> ikiwa n == 0 basi 0
                 mwingine kama n == 1 kisha 1
                      mwingine fibonacci ( n - 1 ) + fibonacci ( n - 2 )
kuu = putStrLn (show (Fibonacci 10))

Kuchapisha namba ya Fibonacci ya 11, mtindo wa kujieleza wa kazi, [1] mkia unaorudia

fibonacci_aux = \ N kwanza pili ->
    ikiwa n == 0 kisha kwanza kingine
    fibonacci_aux ( n - 1 ) pili ( kwanza + pili )
fibonacci = \ n -> Fibonacci_aux n 0 1
kuu = putStrLn (show (Fibonacci 10))

Kuchapisha nambari ya Fibonacci ya 11, mtindo wa kujieleza wa kazi [1] na orodha za upya

fibonacci_aux = \ kwanza pili -> kwanza: fibonacci_aux pili (kwanza + wa pili)
chagua = \ n zs -> ikiwa n == 0 basi kichwa zs
                 mwingine kuchagua (n - 1) (mkia ZS)
fibonacci = \ n -> chagua n ( fibonacci_aux 0 1 )
kuu = putStrLn (show (Fibonacci 10))

Kuchapisha nambari ya Fibonacci ya 11, mtindo wa kujieleza wa kazi [1] na vipaji vya orodha ya upya

fibonacci_aux = \ kwanza pili -> kwanza: fibonacci_aux pili (kwanza + wa pili)
fibonacci = \ n -> ( fibonacci_aux 0 1 ) !! n
kuu = putStrLn (show (Fibonacci 10))

Kuchapisha namba ya Fibonacci ya 11, mtindo wa kujieleza wa kazi [1] na vipaji vya orodha ya upya, zaidi kwa ufupi

fibonacci_aux = 0: 1: zipWith (+) fibonacci_aux (mkia fibonacci_aux)
fibonacci = \ n -> fibonacci_aux !! n
kuu = putStrLn (show (Fibonacci 10))

Kuchapisha nambari ya Fibonacci ya 11, mtindo wa utabiri wa kazi, [2] mkia unaorudia

fibonacci_aux 0 kwanza _ = kwanza
fibonacci_aux n pili ya kwanza = fibonacci_aux ( n - 1 ) pili ( kwanza + pili )
fibonacci n = fibonacci_aux n 0 1
kuu = putStrLn (show (Fibonacci 10))

Kuchapisha nambari ya Fibonacci ya 11, mtindo wa utabiri wa kazi, kwa kutumia orodha zisizo na uvivu na orodha za msingi

fiber = 1 : 1 : zipWith ( + ) fiber ( nyuzi ya mkia ) 
- orodha isiyo na mwisho ya nambari za fibonacci
- nyuzi hufafanuliwa katika suala la nyuzi
Fibonacci = (fibs !!)
kuu = putStrLn $ show $ Fibonacci 11

Perl 6

Kama inasababishwa na Haskell na wengine, Perl 6 ina njia kadhaa za kazi na za kupitisha kwa matatizo. Kwa mfano, unaweza kutafsiri kwa sauti ya kisasa toleo la kisasa (aina ya aina ni chaguo) kupitia saini ya saini inayofanana:

# kufafanua matatizo ambayo ni ya kawaida kwa wagombea wote
proto fib ( UInt: D \ n -> UInt: D ) {*}

futi nyingi ( 0 -> 0 ) {}
fiber nyingi ( 1 -> 1 ) {}

fiber mbalimbali (\ n ) {
    fib ( n - 1 ) + fib ( n - 2 )
}

kwa ^ 10 -> $ n { sema fib ( $ n )}

Njia mbadala ya hii ni kujenga mlolongo wa utata wavivu, unaoonekana kama mfano wa moja kwa moja wa mlolongo:

yangu @fib = 0 , 1 , * + * ... *; # Kuingia kila ziada ni jumla ya mbili zilizopita
                           # na mlolongo huu unaendelea kwa muda usiojulikana
sema @fib [^ 10 ]; # Onyesha funguo 10 za kwanza

Erlang

Erlang ni lugha ya kazi, ya kawaida, ya jumla ya programu ya kusudi. Mfumo wa Fibonacci uliowekwa katika Erlang (Kumbuka: Hii ni kwa kuonyesha tu syntax ya Erlang.Tumia taratibu nyingine za utendaji wa haraka [67] ):

- moduli ( fib ). Hii ni faili 'fib.erl', moduli na jina la faili lazima lilingane
- kuuza nje ([ fiber / 1 ]). Hii inauza 'fib' ya kazi ya shauri 1

fib ( 1 ) -> 1 ; Ikiwa 1, kisha urejee 1, vinginevyo (angalia semicoloni; maana 'mwingine')
fib ( 2 ) -> 1 ; Ikiwa 2, kisha urejee 1, vinginevyo
fib ( N ) -> fiber ( N - 2 ) + fiber ( N - 1 ).

Elixir

Elixir ni lugha ya kazi, ya kawaida, ya jumla ya programu ya programu inayoendeshwa kwenye mashine ya virusi ya Erlang (BEAM) .

Kazi ya Fibonacci inaweza kuandikwa katika Elixir kama ifuatavyo:

defmodule Fibonacci kufanya
  def fib ( 0 ), fanya : 0
  def fib ( 1 ), fanya : 1
  def fib ( n ), fanya : f ( n - 1 ) + fiber ( n - 2 )
mwisho

Lisp

Kazi ya Fibonacci inaweza kuandikwa katika Common Lisp kama ifuatavyo:

( defun fib ( n & chaguo ( a 0 ) ( b 1 ))
  ( ikiwa ( = n 0 )
      a
      (Fib (- n 1) b (+ b))))

au

( defun fib ( k )
     ( ikiwa ( au ( zerop k ) ( = k 1 ))
         k
        ( + ( fib ( - k 1 )) ( fiber ( - k 2 )))))

Mpango huo unaweza kuitwa kama

( fib 10 )

kusafisha

Kazi ya Fibonacci inaweza kuandikwa kwa Clojure kama ifuatavyo:

( defn fib
  [ n ]
  (Kitanzi [0 b 1 i n]
    ( kama ( zero? i )
      a
      (Kurudia b (+ b) (Desemba i)))))

Mpango huo unaweza kuitwa kama

( nyuzi 7 )

Kwa kutumia kwa urahisi "wavivu-seq", mlolongo usio na kipimo wa namba za Fibonacci unaweza kuelezwa mara kwa mara.

;; mlolongo usio na uvivu
(Def fibs (hasara 0 (hasara ya 1 (wavivu-seq (ramani + 'fibs (kupumzika fibs))))))

;; orodha ya nambari za kwanza za Fibonacci zilizochukuliwa kutoka kwa mlolongo usio na kipimo
( kuchukua fiber 10 )

Kotlin

Kazi ya Fibonacci inaweza kuandikwa Kotlin kama ifuatavyo:

fiber fun ( x : Int ): Int = kama ( x == 0 || x == 1 ) x mwingine fib ( x - 1 ) + fib ( x - 2 )

Mpango huo unaweza kuitwa kama

fib ( 7 )

JavaScript

Kazi ya Fibonacci inaweza kuandikwa kwa JavaScript kama ifuatavyo:

var fib = ( x ) => ( x === 0 || x === 1 ) ? x : fib ( x - 1 ) + fiber ( x - 2 );

D

D ina msaada wa programu za utendaji [ ufafanuzi unaohitaji ] [ citation inahitajika ] :

kuagiza std . stdio ;
kuagiza std . mbalimbali ;

kuu tupu ()
{
    / * 'f' ni aina inayowakilisha nambari 10 za kwanza za Fibonacci * /
    auto f = kurudia ! (( seq , i ) => seq [ 0 ] + seq [ 1 ]) ( 0 , 1 )
             . kuchukua ( 10 );

    aliandika ( f );
}

R

R ni mazingira ya kompyuta na takwimu za takwimu. Pia ni lugha ya programu ya utendaji.

Kazi ya Fibonacci inaweza kuandikwa kwa R kama kazi ya kurudia kama ifuatavyo:

futi <- kazi ( n ) {
 ikiwa ( n <= 2 ) 1
 mwingine fib (n - 1) + fib (n - 2)
}

Au inaweza kuandikwa kama kazi ya kurudia tu:

futi <- kazi ( n , a = 1 , b = 1 ) { 
 ikiwa ( n == 1 ) a 
 mwingine fib ( n -1 , b , a + b ) 
}

Au inaweza kuandikwa kama kazi ya iterative:

futi <- kazi ( n ) {
 ikiwa ( n == 1 ) 1
 mwingine kama ( n == 2 ) 1
 mwingine {
  fibval <- c ( 1 , 1 )
  kwa ( i katika 3 : n ) nyuzi <- c ( 0 , fiber [ 1 ]) + fiber [ 2 ]
  nyuzi [ 2 ]
 }
}

Kazi hiyo inaweza kuitwa kama

fib ( 10 )

MlolongoL

MlolongoL ni lugha ya programu, ya kawaida, ya jumla ya kusudi. Kazi ya Fibonacci inaweza kuandikwa katika SequenceL kama ifuatavyo:

F ( n ) : = n wakati n < 2 mwingine
          fib ( n - 1 ) + fib ( n - 2 );

Kazi hiyo inaweza kuitwa kama

fib ( 10 )

Ili kupunguza kumbukumbu inayotumiwa na stack ya wito wakati wa kutumia neno kubwa la Fibonacci, toleo la mkia-recursive inaweza kutumika. Kazi ya mkia-kurudia inatekelezwa na compiler ya SequenceL kama mfumo wa kuzingatia ufanisi wa kumbukumbu:

fib ( n ) : = fib_Helper ( 0 , 1 , n );

fib_Helper ( prev , ijayo , n ) : =
    prev wakati n < 1 mwingine
    ijayo wakati n = 1 mwingine
    fib_Helper ( ijayo , ijayo + kabla , n - 1 );

Tcl

Kazi ya Fibonacci inaweza kuandikwa katika Tcl kama kazi ya kurudia kama ifuatavyo:

proc fibo { x } {
    expr { $ x < 2 ? $ x: [ fibo [ incr x - 1 ]] + [ fibo [ incr x - 1 ]]}
}

Scala

Kazi ya Fibonacci inaweza kuandikwa katika Scala kwa njia kubwa:

Imperative "Java" style

def fibImper (n: Int): Int = {
  var i = 0
  var j = 1

  kwa ( k <- 0 hadi n ) {
    val l = i + j
    i = j
    j = l
  }
  i
}

Mtindo wa kupindukia, polepole

def fibec ( n : Int ) : Int = {
  n match {
    kesi 0 => 0
    kesi 1 => 1
    kesi _ => fib1 ( n - 1 ) + fib1 ( n - 2 )
  }
}

Mtindo wa haraka, haraka

def fiLailRec ( n : Int ) : Int = {
  @tailrec def f (: Int, b: Int, c: Int): Int = ikiwa (== 0) 0 kingine kama (<2) c mwingine f (- 1, c, b + c)
  f ( n , 0 , 1 )
}

Kutumia mito ya Scala

val fibStream: Stream [Int] = 0 # :: 1 # :: (fibStream zip fibStream mkia.). ramani { t => t . _1 + t . _2 }

Tumia katika sekta

Programu ya kazi kwa muda mrefu imekuwa maarufu katika wasomi, lakini kwa matumizi machache ya viwanda. [68] : ukurasa wa 11 Hata hivyo, hivi karibuni lugha kadhaa za uendeshaji maarufu zinazotumiwa katika mifumo ya kibiashara au viwanda. Kwa mfano, lugha ya programu ya Erlang , ambayo ilianzishwa na kampuni ya Kiswidi Ericsson mwishoni mwa miaka ya 1980, ilikuwa awali kutumika kutekeleza mifumo ya simu za mawasiliano yenye uovu. [13] Imekuwa maarufu kwa kujenga programu mbalimbali katika makampuni kama vile T-Mobile , Nortel , Facebook , Électricité de France na Whatsapp . [12] [14] [69] [70] [71] Mpango wa lugha ya Lisp ulitumiwa kama msingi wa maombi kadhaa kwenye kompyuta za Apple Macintosh mapema, [4] [5] na hivi karibuni imetumika kwa matatizo kama vile mafunzo ya simulation programu [6] na udhibiti wa darubini . [7] OCaml , ambayo ilianzishwa katikati ya miaka ya 1990, imeona matumizi ya kibiashara katika maeneo kama vile uchambuzi wa kifedha, [15] uthibitishaji wa dereva , programu za robot za viwanda, na uchambuzi wa static wa programu iliyoingia . [16] Haskell , ingawa awali ilipangwa kama lugha ya utafiti, [18] pia imetumika na makampuni mbalimbali, katika maeneo kama vile mifumo ya aerospace, kubuni vifaa, na programu ya wavuti. [17] [18]

Lugha nyingine za programu za uendeshaji ambazo zimeona matumizi katika sekta ni pamoja na Scala , [72] F # , [19] [20] (wote ni kazi-OO hybrids na msaada kwa ajili ya programu zote mbili za kazi na ya lazima) Lugha Wolfram , [10] Lisp , [ 73] Standard ML [74] [75] na Clojure . [76]

Katika elimu

Programu ya kazi inatumiwa kama njia ya kufundisha tatizo la kutatua matatizo, algebra na dhana za kijiometri. [77] Imekuwa pia kutumika kama chombo cha kufundisha mitambo ya kikabila katika muundo na kutafsiriwa kwa mitambo ya kawaida .

Angalia pia

  • Programu sahihi ya kazi
  • Kulinganisha dhana za programu
  • Jaribu tathmini
  • Orodha ya mada ya programu ya kazi
  • Kazi ya kazi
  • Programu ya kazi ya kuvutia
  • Programu ya tendaji ya kazi

Marejeleo

  1. ^ a b c d e f g h "Declaration vs. expression style - HaskellWiki" .
  2. ^ a b "Declaration vs. expression style - HaskellWiki" .
  3. ^ a b Hudak, Paul (September 1989). "Conception, evolution, and application of functional programming languages" (PDF) . ACM Computing Surveys . 21 (3): 359–411. doi : 10.1145/72551.72554 .
  4. ^ a b Clinger, Will (1987). "MultiTasking and MacScheme" . MacTech . 3 (12) . Retrieved 2008-08-28 .
  5. ^ a b Hartheimer, Anne (1987). "Programming a Text Editor in MacScheme+Toolsmith" . MacTech . 3 (1). Archived from the original on 2011-06-29 . Retrieved 2008-08-28 .
  6. ^ a b Kidd, Eric. Terrorism Response Training in Scheme . CUFP 2007 . Retrieved 2009-08-26 .
  7. ^ a b Cleis, Richard. Scheme in Space . CUFP 2006 . Retrieved 2009-08-26 .
  8. ^ "The useR! 2006 conference schedule includes papers on the commercial use of R" . R-project.org. 2006-06-08 . Retrieved 2011-06-20 .
  9. ^ Chambers, John M. (1998). Programming with Data: A Guide to the S Language . Springer Verlag. pp. 67–70. ISBN 978-0-387-98503-9 .
  10. ^ a b "Wolfram Language Guide: Functional Programming" . 2015 . Retrieved 2015-08-24 .
  11. ^ "State-Based Scripting in Uncharted 2" (PDF) . Archived from the original (PDF) on 2012-12-15 . Retrieved 2011-08-08 .
  12. ^ a b "Who uses Erlang for product development?" . Frequently asked questions about Erlang . Retrieved 2007-08-05 .
  13. ^ a b Armstrong, Joe (June 2007). A history of Erlang . Third ACM SIGPLAN Conference on History of Programming Languages. San Diego, California . Retrieved 2009-08-29 .
  14. ^ a b Larson, Jim (March 2009). "Erlang for concurrent programming". Communications of the ACM . 52 (3): 48. doi : 10.1145/1467247.1467263 .
  15. ^ a b Minsky, Yaron; Weeks, Stephen (July 2008). "Caml Trading — experiences with functional programming on Wall Street" . Journal of Functional Programming . Cambridge University Press. 18 (4): 553–564. doi : 10.1017/S095679680800676X . Retrieved 2008-08-27 .
  16. ^ a b Leroy, Xavier. Some uses of Caml in Industry (PDF) . CUFP 2007 . Retrieved 2009-08-26 .
  17. ^ a b "Haskell in industry" . Haskell Wiki . Retrieved 2009-08-26 . Haskell has a diverse range of use commercially, from aerospace and defense, to finance, to web startups, hardware design firms and lawnmower manufacturers.
  18. ^ a b c Hudak, Paul ; Hughes, J.; Jones, S. P.; Wadler, P. (June 2007). A history of Haskell: being lazy with class . Third ACM SIGPLAN Conference on History of Programming Languages. San Diego, California. doi : 10.1145/1238844.1238856 . Retrieved 2013-09-26 .
  19. ^ a b Mansell, Howard (2008). Quantitative Finance in F# . CUFP 2008 . Retrieved 2009-08-29 .
  20. ^ a b Peake, Alex (2009). The First Substantial Line of Business Application in F# . CUFP 2009 . Retrieved 2009-08-29 .
  21. ^ "The 15 most popular computer languages, according to the Facebook for programmers" . 2016 . Retrieved 2017-07-31 .
  22. ^ "JavaScript is the World's Dominant Programming Language" . 2016 . Retrieved 2017-07-31 .
  23. ^ http://www.crockford.com/javascript/javascript.html . Retrieved 2017-07-31 . Missing or empty |title= ( help )
  24. ^ Department of Applied Math, University of Colorado. "Functional vs. Procedural Programming Language" . Archived from the original on 2007-11-13 . Retrieved 2006-08-28 .
  25. ^ Dimitre Novatchev. "The Functional Programming Language XSLT — A proof through examples" . TopXML . Retrieved May 27, 2006 .
  26. ^ David Mertz. "XML Programming Paradigms (part four): Functional Programming approached to XML processing" . IBM developerWorks . Retrieved May 27, 2006 .
  27. ^ OPtimized Applicative Language
  28. ^ Donald D. Chamberlin and Raymond F. Boyce (1974). "SEQUEL: A structured English query language". Proceedings of the 1974 ACM SIGFIDET : 249–264.
  29. ^ Dominus, Mark J. (2005). Higher-Order Perl . Morgan Kaufmann . ISBN 1-55860-701-3 .
  30. ^ Holywell, Simon (2014). Functional Programming in PHP . php[architect]. ISBN 9781940111056 .
  31. ^ "Effective Scala" . Scala Wiki . Retrieved 2012-02-21 . Effective Scala.
  32. ^ Haskell Brooks Curry; Robert Feys (1958). Combinatory Logic . North-Holland Publishing Company . Retrieved 10 February 2013 .
  33. ^ McCarthy, John (June 1978). "History of Lisp" . In ACM /SIGPLAN History of Programming Languages Conference : 217–223. doi : 10.1145/800025.808387 .
  34. ^ Guy L. Steele; Richard P. Gabriel (February 1996). "The Evolution of Lisp" (PDF) . In ACM /SIGPLAN Second History of Programming Languages : 233–330. doi : 10.1145/234286.1057818 .
  35. ^ The memoir of Herbert A. Simon (1991), Models of My Life pp.189-190 ISBN 0-465-04640-1 claims that he, Al Newell, and Cliff Shaw are "...commonly adjudged to be the parents of [the] artificial intelligence [field]," for writing Logic Theorist , a program that proved theorems from Principia Mathematica automatically. To accomplish this, they had to invent a language and a paradigm that, viewed retrospectively, embeds functional programming.
  36. ^ "Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs" (PDF) .
  37. ^ R.M. Burstall. Design considerations for a functional programming language. Invited paper, Proc. Infotech State of the Art Conf. "The Software Revolution", Copenhagen, 45–57 (1977)
  38. ^ R.M. Burstall and J. Darlington. A transformation system for developing recursive programs. Journal of the Association for Computing Machinery 24(1):44–67 (1977)
  39. ^ R.M. Burstall, D.B. MacQueen and D.T. Sannella. HOPE: an experimental applicative language. Proc. 1980 LISP Conference, Stanford, 136–143 (1980).
  40. ^ Dick Pountain. "Functional Programming Comes of Age" . BYTE.com (August 1994) . Archived from the original on 2006-08-27 . Retrieved August 31, 2006 .
  41. ^ Turner, D.A. (2004-07-28). "Total Functional Programming" . Journal of Universal Computer Science . 10 (7): 751–768. doi : 10.3217/jucs-010-07-0751 .
  42. ^ The Implementation of Functional Programming Languages . Simon Peyton Jones, published by Prentice Hall, 1987
  43. ^ Hughes, John (1984). "Why Functional Programming Matters" .
  44. ^ a b John Launchbury (1993). "A Natural Semantics for Lazy Evaluation" .
  45. ^ Robert W. Harper (2009). Practical Foundations for Programming Languages (PDF) .
  46. ^ "The Compcert verified compiler" .
  47. ^ Simon Peyton Jones; Dimitrios Vytiniotis; Stephanie Weirich; Geoffrey Washburn. "Simple unification-based type inference for GADTs" . ICFP 2006 . pp. 50–61.
  48. ^ Andrew Kennedy; Claudio Russo (October 2005). "Generalized Algebraic Data Types and Object-Oriented Programming" (PDF) . OOPSLA . San Diego, California. Archived from the original (PDF) on 2006-12-29. source of citation
  49. ^ Huges, John. "Why Functional Programming Matters" (PDF) . http://www.chalmers.se/cse . Chalmers Tekniska H¨ogskola. External link in |website= ( help )
  50. ^ Hartel, Pieter; Henk Muller; Hugh Glaser (March 2004). "The Functional C experience" (PDF) . Journal of Functional Programming . 14 (2): 129–135. doi : 10.1017/S0956796803004817 . ; David Mertz. "Functional programming in Python, Part 3" . IBM developerWorks . Archived from the original on 2007-10-16 . Retrieved 2006-09-17 . ( Part 1 , Part 2 )
  51. ^ "Functions — D Programming Language 2.0" . Digital Mars . Retrieved 2011-06-20 .
  52. ^ "Lua Unofficial FAQ (uFAQ)" .
  53. ^ "Brendan Eich" .
  54. ^ van Rossum, Guido (2009-04-21). "Origins of Python's "Functional" Features" . The History of Python . Retrieved 2012-09-27 . External link in |publisher= ( help )
  55. ^ "functools — Higher order functions and operations on callable objects" . Python Software Foundation. 2011-07-31 . Retrieved 2011-07-31 .
  56. ^ Skarsaune, Martin (2008). The SICS Java Port Project Automatic Translation of a Large Object Oriented System from Smalltalk to Java .
  57. ^ Gosling, James. "Closures" . James Gosling: on the Java Road . Oracle . Retrieved 11 May 2013 .
  58. ^ "Java SE 8 Lambda Quick Start" .
  59. ^ Bloch, Joshua. Effective Java (Second ed.). pp. Item 15.
  60. ^ Purely functional data structures by Chris Okasaki , Cambridge University Press , 1998, ISBN 0-521-66350-4
  61. ^ Newbern, J. "All About Monads: A comprehensive guide to the theory and practice of monadic programming in Haskell" . Retrieved 2008-02-14 .
  62. ^ Larry C. Paulson (28 June 1996). ML for the Working Programmer . Cambridge University Press. ISBN 978-0-521-56543-1 . Retrieved 10 February 2013 .
  63. ^ Daniel Spiewak. "Implementing Persistent Vectors in Scala" . Retrieved Apr 17, 2012 .
  64. ^ "Which programs are fastest? | Computer Language Benchmarks Game" . benchmarksgame.alioth.debian.org . Retrieved 2011-06-20 .
  65. ^ Igor Pechtchanski; Vivek Sarkar (2005). "Immutability specification and its applications". Concurrency and Computation: Practice and Experience . 17 (5–6): 639–662. doi : 10.1002/cpe.853 .
  66. ^ "Chapter 25. Profiling and optimization" . Book.realworldhaskell.org . Retrieved 2011-06-20 .
  67. ^ [1]
  68. ^ Odersky, Martin; Spoon, Lex; Venners, Bill (December 13, 2010). Programming in Scala: A Comprehensive Step-by-step Guide (2nd ed.). Artima Inc . pp. 883/852. ISBN 978-0-9815316-4-9 .
  69. ^ Piro, Christopher (2009). Functional Programming at Facebook . CUFP 2009 . Retrieved 2009-08-29 .
  70. ^ "Sim-Diasca: a large-scale discrete event concurrent simulation engine in Erlang" . November 2011.
  71. ^ 1 million is so 2011 // WhatsApp blog, 2012-01-06: "the last important piece of our infrastracture is Erlang"
  72. ^ Momtahan, Lee (2009). Scala at EDF Trading: Implementing a Domain-Specific Language for Derivative Pricing with Scala . CUFP 2009 . Retrieved 2009-08-29 .
  73. ^ Graham, Paul (2003). "Beating the Averages" . Retrieved 2009-08-29 .
  74. ^ Sims, Steve (2006). Building a Startup with Standard ML (PDF) . CUFP 2006 . Retrieved 2009-08-29 .
  75. ^ Laurikari, Ville (2007). Functional Programming in Communications Security . CUFP 2007 . Retrieved 2009-08-29 .
  76. ^ Lorimer, R. J. "Live Production Clojure Application Announced" .
  77. ^ Emmanuel Schanzer of Bootstrap interviewed on the TV show Triangulation on the TWiT.tv network

Kusoma zaidi

  • Abelson, Hal ; Sussman, Gerald Jay (1985). Structure and Interpretation of Computer Programs . MIT Press.
  • Cousineau, Guy and Michel Mauny. The Functional Approach to Programming . Cambridge, UK: Cambridge University Press , 1998.
  • Curry, Haskell Brooks and Feys, Robert and Craig, William. Combinatory Logic . Volume I. North-Holland Publishing Company, Amsterdam, 1958.
  • Curry, Haskell B. ; Hindley, J. Roger ; Seldin, Jonathan P. (1972). Combinatory Logic . Vol. II. Amsterdam: North Holland. ISBN 0-7204-2208-6 .
  • Dominus, Mark Jason. Higher-Order Perl . Morgan Kaufmann . 2005.
  • Felleisen, Matthias; Findler, Robert; Flatt, Matthew; Krishnamurthi, Shriram (2001). How to Design Programs . MIT Press.
  • Graham, Paul. ANSI Common LISP . Englewood Cliffs, New Jersey: Prentice Hall , 1996.
  • MacLennan, Bruce J. Functional Programming: Practice and Theory . Addison-Wesley, 1990.
  • O'Sullivan, Brian; Stewart, Don; Goerzen, John (2008). Real World Haskell . O'Reilly.
  • Pratt, Terrence, W. and Marvin V. Zelkowitz. Programming Languages: Design and Implementation . 3rd ed. Englewood Cliffs, New Jersey: Prentice Hall , 1996.
  • Salus, Peter H. Functional and Logic Programming Languages . Vol. 4 of Handbook of Programming Languages. Indianapolis, Indiana: Macmillan Technical Publishing , 1998.
  • Thompson, Simon. Haskell: The Craft of Functional Programming . Harlow, England: Addison-Wesley Longman Limited , 1996.

Viungo vya nje