Skip to main content
Module

x/ramda/dist/ramda.js

:ram: Practical functional Javascript
Latest
File
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280528152825283528452855286528752885289529052915292529352945295529652975298529953005301530253035304530553065307530853095310531153125313531453155316531753185319532053215322532353245325532653275328532953305331533253335334533553365337533853395340534153425343534453455346534753485349535053515352535353545355535653575358535953605361536253635364536553665367536853695370537153725373537453755376537753785379538053815382538353845385538653875388538953905391539253935394539553965397539853995400540154025403540454055406540754085409541054115412541354145415541654175418541954205421542254235424542554265427542854295430543154325433543454355436543754385439544054415442544354445445544654475448544954505451545254535454545554565457545854595460546154625463546454655466546754685469547054715472547354745475547654775478547954805481548254835484548554865487548854895490549154925493549454955496549754985499550055015502550355045505550655075508550955105511551255135514551555165517551855195520552155225523552455255526552755285529553055315532553355345535553655375538553955405541554255435544554555465547554855495550555155525553555455555556555755585559556055615562556355645565556655675568556955705571557255735574557555765577557855795580558155825583558455855586558755885589559055915592559355945595559655975598559956005601560256035604560556065607560856095610561156125613561456155616561756185619562056215622562356245625562656275628562956305631563256335634563556365637563856395640564156425643564456455646564756485649565056515652565356545655565656575658565956605661566256635664566556665667566856695670567156725673567456755676567756785679568056815682568356845685568656875688568956905691569256935694569556965697569856995700570157025703570457055706570757085709571057115712571357145715571657175718571957205721572257235724572557265727572857295730573157325733573457355736573757385739574057415742574357445745574657475748574957505751575257535754575557565757575857595760576157625763576457655766576757685769577057715772577357745775577657775778577957805781578257835784578557865787578857895790579157925793579457955796579757985799580058015802580358045805580658075808580958105811581258135814581558165817581858195820582158225823582458255826582758285829583058315832583358345835583658375838583958405841584258435844584558465847584858495850585158525853585458555856585758585859586058615862586358645865586658675868586958705871587258735874587558765877587858795880588158825883588458855886588758885889589058915892589358945895589658975898589959005901590259035904590559065907590859095910591159125913591459155916591759185919592059215922592359245925592659275928592959305931593259335934593559365937593859395940594159425943594459455946594759485949595059515952595359545955595659575958595959605961596259635964596559665967596859695970597159725973597459755976597759785979598059815982598359845985598659875988598959905991599259935994599559965997599859996000600160026003600460056006600760086009601060116012601360146015601660176018601960206021602260236024602560266027602860296030603160326033603460356036603760386039604060416042604360446045604660476048604960506051605260536054605560566057605860596060606160626063606460656066606760686069607060716072607360746075607660776078607960806081608260836084608560866087608860896090609160926093609460956096609760986099610061016102610361046105610661076108610961106111611261136114611561166117611861196120612161226123612461256126612761286129613061316132613361346135613661376138613961406141614261436144614561466147614861496150615161526153615461556156615761586159616061616162616361646165616661676168616961706171617261736174617561766177617861796180618161826183618461856186618761886189619061916192619361946195619661976198619962006201620262036204620562066207620862096210621162126213621462156216621762186219622062216222622362246225622662276228622962306231623262336234623562366237623862396240624162426243624462456246624762486249625062516252625362546255625662576258625962606261626262636264626562666267626862696270627162726273627462756276627762786279628062816282628362846285628662876288628962906291629262936294629562966297629862996300630163026303630463056306630763086309631063116312631363146315631663176318631963206321632263236324632563266327632863296330633163326333633463356336633763386339634063416342634363446345634663476348634963506351635263536354635563566357635863596360636163626363636463656366636763686369637063716372637363746375637663776378637963806381638263836384638563866387638863896390639163926393639463956396639763986399640064016402640364046405640664076408640964106411641264136414641564166417641864196420642164226423642464256426642764286429643064316432643364346435643664376438643964406441644264436444644564466447644864496450645164526453645464556456645764586459646064616462646364646465646664676468646964706471647264736474647564766477647864796480648164826483648464856486648764886489649064916492649364946495649664976498649965006501650265036504650565066507650865096510651165126513651465156516651765186519652065216522652365246525652665276528652965306531653265336534653565366537653865396540654165426543654465456546654765486549655065516552655365546555655665576558655965606561656265636564656565666567656865696570657165726573657465756576657765786579658065816582658365846585658665876588658965906591659265936594659565966597659865996600660166026603660466056606660766086609661066116612661366146615661666176618661966206621662266236624662566266627662866296630663166326633663466356636663766386639664066416642664366446645664666476648664966506651665266536654665566566657665866596660666166626663666466656666666766686669667066716672667366746675667666776678667966806681668266836684668566866687668866896690669166926693669466956696669766986699670067016702670367046705670667076708670967106711671267136714671567166717671867196720672167226723672467256726672767286729673067316732673367346735673667376738673967406741674267436744674567466747674867496750675167526753675467556756675767586759676067616762676367646765676667676768676967706771677267736774677567766777677867796780678167826783678467856786678767886789679067916792679367946795679667976798679968006801680268036804680568066807680868096810681168126813681468156816681768186819682068216822682368246825682668276828682968306831683268336834683568366837683868396840684168426843684468456846684768486849685068516852685368546855685668576858685968606861686268636864686568666867686868696870687168726873687468756876687768786879688068816882688368846885688668876888688968906891689268936894689568966897689868996900690169026903690469056906690769086909691069116912691369146915691669176918691969206921692269236924692569266927692869296930693169326933693469356936693769386939694069416942694369446945694669476948694969506951695269536954695569566957695869596960696169626963696469656966696769686969697069716972697369746975697669776978697969806981698269836984698569866987698869896990699169926993699469956996699769986999700070017002700370047005700670077008700970107011701270137014701570167017701870197020702170227023702470257026702770287029703070317032703370347035703670377038703970407041704270437044704570467047704870497050705170527053705470557056705770587059706070617062706370647065706670677068706970707071707270737074707570767077707870797080708170827083708470857086708770887089709070917092709370947095709670977098709971007101710271037104710571067107710871097110711171127113711471157116711771187119712071217122712371247125712671277128712971307131713271337134713571367137713871397140714171427143714471457146714771487149715071517152715371547155715671577158715971607161716271637164716571667167716871697170717171727173717471757176717771787179718071817182718371847185718671877188718971907191719271937194719571967197719871997200720172027203720472057206720772087209721072117212721372147215721672177218721972207221722272237224722572267227722872297230723172327233723472357236723772387239724072417242724372447245724672477248724972507251725272537254725572567257725872597260726172627263726472657266726772687269727072717272727372747275727672777278727972807281728272837284728572867287728872897290729172927293729472957296729772987299730073017302730373047305730673077308730973107311731273137314731573167317731873197320732173227323732473257326732773287329733073317332733373347335733673377338733973407341734273437344734573467347734873497350735173527353735473557356735773587359736073617362736373647365736673677368736973707371737273737374737573767377737873797380738173827383738473857386738773887389739073917392739373947395739673977398739974007401740274037404740574067407740874097410741174127413741474157416741774187419742074217422742374247425742674277428742974307431743274337434743574367437743874397440744174427443744474457446744774487449745074517452745374547455745674577458745974607461746274637464746574667467746874697470747174727473747474757476747774787479748074817482748374847485748674877488748974907491749274937494749574967497749874997500750175027503750475057506750775087509751075117512751375147515751675177518751975207521752275237524752575267527752875297530753175327533753475357536753775387539754075417542754375447545754675477548754975507551755275537554755575567557755875597560756175627563756475657566756775687569757075717572757375747575757675777578757975807581758275837584758575867587758875897590759175927593759475957596759775987599760076017602760376047605760676077608760976107611761276137614761576167617761876197620762176227623762476257626762776287629763076317632763376347635763676377638763976407641764276437644764576467647764876497650765176527653765476557656765776587659766076617662766376647665766676677668766976707671767276737674767576767677767876797680768176827683768476857686768776887689769076917692769376947695769676977698769977007701770277037704770577067707770877097710771177127713771477157716771777187719772077217722772377247725772677277728772977307731773277337734773577367737773877397740774177427743774477457746774777487749775077517752775377547755775677577758775977607761776277637764776577667767776877697770777177727773777477757776777777787779778077817782778377847785778677877788778977907791779277937794779577967797779877997800780178027803780478057806780778087809781078117812781378147815781678177818781978207821782278237824782578267827782878297830783178327833783478357836783778387839784078417842784378447845784678477848784978507851785278537854785578567857785878597860786178627863786478657866786778687869787078717872787378747875787678777878787978807881788278837884788578867887788878897890789178927893789478957896789778987899790079017902790379047905790679077908790979107911791279137914791579167917791879197920792179227923792479257926792779287929793079317932793379347935793679377938793979407941794279437944794579467947794879497950795179527953795479557956795779587959796079617962796379647965796679677968796979707971797279737974797579767977797879797980798179827983798479857986798779887989799079917992799379947995799679977998799980008001800280038004800580068007800880098010801180128013801480158016801780188019802080218022802380248025802680278028802980308031803280338034803580368037803880398040804180428043804480458046804780488049805080518052805380548055805680578058805980608061806280638064806580668067806880698070807180728073807480758076807780788079808080818082808380848085808680878088808980908091809280938094809580968097809880998100810181028103810481058106810781088109811081118112811381148115811681178118811981208121812281238124812581268127812881298130813181328133813481358136813781388139814081418142814381448145814681478148814981508151815281538154815581568157815881598160816181628163816481658166816781688169817081718172817381748175817681778178817981808181818281838184818581868187818881898190819181928193819481958196819781988199820082018202820382048205820682078208820982108211821282138214821582168217821882198220822182228223822482258226822782288229823082318232823382348235823682378238823982408241824282438244824582468247824882498250825182528253825482558256825782588259826082618262826382648265826682678268826982708271827282738274827582768277827882798280828182828283828482858286828782888289829082918292829382948295829682978298829983008301830283038304830583068307830883098310831183128313831483158316831783188319832083218322832383248325832683278328832983308331833283338334833583368337833883398340834183428343834483458346834783488349835083518352835383548355835683578358835983608361836283638364836583668367836883698370837183728373837483758376837783788379838083818382838383848385838683878388838983908391839283938394839583968397839883998400840184028403840484058406840784088409841084118412841384148415841684178418841984208421842284238424842584268427842884298430843184328433843484358436843784388439844084418442844384448445844684478448844984508451845284538454845584568457845884598460846184628463846484658466846784688469847084718472847384748475847684778478847984808481848284838484848584868487848884898490849184928493849484958496849784988499850085018502850385048505850685078508850985108511851285138514851585168517851885198520852185228523852485258526852785288529853085318532853385348535853685378538853985408541854285438544854585468547854885498550855185528553855485558556855785588559856085618562856385648565856685678568856985708571857285738574857585768577857885798580858185828583858485858586858785888589859085918592859385948595859685978598859986008601860286038604860586068607860886098610861186128613861486158616861786188619862086218622862386248625862686278628862986308631863286338634863586368637863886398640864186428643864486458646864786488649865086518652865386548655865686578658865986608661866286638664866586668667866886698670867186728673867486758676867786788679868086818682868386848685868686878688868986908691869286938694869586968697869886998700870187028703870487058706870787088709871087118712871387148715871687178718871987208721872287238724872587268727872887298730873187328733873487358736873787388739874087418742874387448745874687478748874987508751875287538754875587568757875887598760876187628763876487658766876787688769877087718772877387748775877687778778877987808781878287838784878587868787878887898790879187928793879487958796879787988799880088018802880388048805880688078808880988108811881288138814881588168817881888198820882188228823882488258826882788288829883088318832883388348835883688378838883988408841884288438844884588468847884888498850885188528853885488558856885788588859886088618862886388648865886688678868886988708871887288738874887588768877887888798880888188828883888488858886888788888889889088918892889388948895889688978898889989008901890289038904890589068907890889098910891189128913891489158916891789188919892089218922892389248925892689278928892989308931893289338934893589368937893889398940894189428943894489458946894789488949895089518952895389548955895689578958895989608961896289638964896589668967896889698970897189728973897489758976897789788979898089818982898389848985898689878988898989908991899289938994899589968997899889999000900190029003900490059006900790089009901090119012901390149015901690179018901990209021902290239024902590269027902890299030903190329033903490359036903790389039904090419042904390449045904690479048904990509051905290539054905590569057905890599060906190629063906490659066906790689069907090719072907390749075907690779078907990809081908290839084908590869087908890899090909190929093909490959096909790989099910091019102910391049105910691079108910991109111911291139114911591169117911891199120912191229123912491259126912791289129913091319132913391349135913691379138913991409141914291439144914591469147914891499150915191529153915491559156915791589159916091619162916391649165916691679168916991709171917291739174917591769177917891799180918191829183918491859186918791889189919091919192919391949195919691979198919992009201920292039204920592069207920892099210921192129213921492159216921792189219922092219222922392249225922692279228922992309231923292339234923592369237923892399240924192429243924492459246924792489249925092519252925392549255925692579258925992609261926292639264926592669267926892699270927192729273927492759276927792789279928092819282928392849285928692879288928992909291929292939294929592969297929892999300930193029303930493059306930793089309931093119312931393149315931693179318931993209321932293239324932593269327932893299330933193329333933493359336933793389339934093419342934393449345934693479348934993509351935293539354935593569357935893599360936193629363936493659366936793689369937093719372937393749375937693779378937993809381938293839384938593869387938893899390939193929393939493959396939793989399940094019402940394049405940694079408940994109411941294139414941594169417941894199420942194229423942494259426942794289429943094319432943394349435943694379438943994409441944294439444944594469447944894499450945194529453945494559456945794589459946094619462946394649465946694679468946994709471947294739474947594769477947894799480948194829483948494859486948794889489949094919492949394949495949694979498949995009501950295039504950595069507950895099510951195129513951495159516951795189519952095219522952395249525952695279528952995309531953295339534953595369537953895399540954195429543954495459546954795489549955095519552955395549555955695579558955995609561956295639564956595669567956895699570957195729573957495759576957795789579958095819582958395849585958695879588958995909591959295939594959595969597959895999600960196029603960496059606960796089609961096119612961396149615961696179618961996209621962296239624962596269627962896299630963196329633963496359636963796389639964096419642964396449645964696479648964996509651965296539654965596569657965896599660966196629663966496659666966796689669967096719672967396749675967696779678967996809681968296839684968596869687968896899690969196929693969496959696969796989699970097019702970397049705970697079708970997109711971297139714971597169717
// Ramda v0.27.1// https://github.com/ramda/ramda// (c) 2013-2020 Scott Sauyet, Michael Hurley, and David Chambers// Ramda may be freely distributed under the MIT license.
(function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = global || self, factory(global.R = {}));}(this, function (exports) { 'use strict';
/** * A function that always returns `false`. Any passed in parameters are ignored. * * @func * @memberOf R * @since v0.9.0 * @category Function * @sig * -> Boolean * @param {*} * @return {Boolean} * @see R.T * @example * * R.F(); //=> false */ var F = function() {return false;}; /** * A function that always returns `true`. Any passed in parameters are ignored. * * @func * @memberOf R * @since v0.9.0 * @category Function * @sig * -> Boolean * @param {*} * @return {Boolean} * @see R.F * @example * * R.T(); //=> true */ var T = function() {return true;}; /** * A special placeholder value used to specify "gaps" within curried functions, * allowing partial application of any combination of arguments, regardless of * their positions. * * If `g` is a curried ternary function and `_` is `R.__`, the following are * equivalent: * * - `g(1, 2, 3)` * - `g(_, 2, 3)(1)` * - `g(_, _, 3)(1)(2)` * - `g(_, _, 3)(1, 2)` * - `g(_, 2, _)(1, 3)` * - `g(_, 2)(1)(3)` * - `g(_, 2)(1, 3)` * - `g(_, 2)(_, 3)(1)` * * @name __ * @constant * @memberOf R * @since v0.6.0 * @category Function * @example * * const greet = R.replace('{name}', R.__, 'Hello, {name}!'); * greet('Alice'); //=> 'Hello, Alice!' */ var __ = {'@@functional/placeholder': true}; function _isPlaceholder(a) { return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true; } /** * Optimized internal one-arity curry function. * * @private * @category Function * @param {Function} fn The function to curry. * @return {Function} The curried function. */ function _curry1(fn) { return function f1(a) { if (arguments.length === 0 || _isPlaceholder(a)) { return f1; } else { return fn.apply(this, arguments); } }; } /** * Optimized internal two-arity curry function. * * @private * @category Function * @param {Function} fn The function to curry. * @return {Function} The curried function. */ function _curry2(fn) { return function f2(a, b) { switch (arguments.length) { case 0: return f2; case 1: return _isPlaceholder(a) ? f2 : _curry1(function(_b) { return fn(a, _b); }); default: return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); }) : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); }) : fn(a, b); } }; } /** * Adds two values. * * @func * @memberOf R * @since v0.1.0 * @category Math * @sig Number -> Number -> Number * @param {Number} a * @param {Number} b * @return {Number} * @see R.subtract * @example * * R.add(2, 3); //=> 5 * R.add(7)(10); //=> 17 */ var add = _curry2(function add(a, b) { return Number(a) + Number(b); }); /** * Private `concat` function to merge two array-like objects. * * @private * @param {Array|Arguments} [set1=[]] An array-like object. * @param {Array|Arguments} [set2=[]] An array-like object. * @return {Array} A new, merged array. * @example * * _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3] */ function _concat(set1, set2) { set1 = set1 || []; set2 = set2 || []; var idx; var len1 = set1.length; var len2 = set2.length; var result = []; idx = 0; while (idx < len1) { result[result.length] = set1[idx]; idx += 1; } idx = 0; while (idx < len2) { result[result.length] = set2[idx]; idx += 1; } return result; } function _arity(n, fn) { /* eslint-disable no-unused-vars */ switch (n) { case 0: return function() { return fn.apply(this, arguments); }; case 1: return function(a0) { return fn.apply(this, arguments); }; case 2: return function(a0, a1) { return fn.apply(this, arguments); }; case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); }; case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); }; case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); }; case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); }; case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); }; case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); }; case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); }; case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); }; default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten'); } } /** * Internal curryN function. * * @private * @category Function * @param {Number} length The arity of the curried function. * @param {Array} received An array of arguments received thus far. * @param {Function} fn The function to curry. * @return {Function} The curried function. */ function _curryN(length, received, fn) { return function() { var combined = []; var argsIdx = 0; var left = length; var combinedIdx = 0; while (combinedIdx < received.length || argsIdx < arguments.length) { var result; if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) { result = received[combinedIdx]; } else { result = arguments[argsIdx]; argsIdx += 1; } combined[combinedIdx] = result; if (!_isPlaceholder(result)) { left -= 1; } combinedIdx += 1; } return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn)); }; } /** * Returns a curried equivalent of the provided function, with the specified * arity. The curried function has two unusual capabilities. First, its * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the * following are equivalent: * * - `g(1)(2)(3)` * - `g(1)(2, 3)` * - `g(1, 2)(3)` * - `g(1, 2, 3)` * * Secondly, the special placeholder value [`R.__`](#__) may be used to specify * "gaps", allowing partial application of any combination of arguments, * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__), * the following are equivalent: * * - `g(1, 2, 3)` * - `g(_, 2, 3)(1)` * - `g(_, _, 3)(1)(2)` * - `g(_, _, 3)(1, 2)` * - `g(_, 2)(1)(3)` * - `g(_, 2)(1, 3)` * - `g(_, 2)(_, 3)(1)` * * @func * @memberOf R * @since v0.5.0 * @category Function * @sig Number -> (* -> a) -> (* -> a) * @param {Number} length The arity for the returned function. * @param {Function} fn The function to curry. * @return {Function} A new, curried function. * @see R.curry * @example * * const sumArgs = (...args) => R.sum(args); * * const curriedAddFourNumbers = R.curryN(4, sumArgs); * const f = curriedAddFourNumbers(1, 2); * const g = f(3); * g(4); //=> 10 */ var curryN = _curry2(function curryN(length, fn) { if (length === 1) { return _curry1(fn); } return _arity(length, _curryN(length, [], fn)); }); /** * Creates a new list iteration function from an existing one by adding two new * parameters to its callback function: the current index, and the entire list. * * This would turn, for instance, [`R.map`](#map) function into one that * more closely resembles `Array.prototype.map`. Note that this will only work * for functions in which the iteration callback function is the first * parameter, and where the list is the last parameter. (This latter might be * unimportant if the list parameter is not used.) * * @func * @memberOf R * @since v0.15.0 * @category Function * @category List * @sig ((a ... -> b) ... -> [a] -> *) -> ((a ..., Int, [a] -> b) ... -> [a] -> *) * @param {Function} fn A list iteration function that does not pass index or list to its callback * @return {Function} An altered list iteration function that passes (item, index, list) to its callback * @example * * const mapIndexed = R.addIndex(R.map); * mapIndexed((val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']); * //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r'] */ var addIndex = _curry1(function addIndex(fn) { return curryN(fn.length, function() { var idx = 0; var origFn = arguments[0]; var list = arguments[arguments.length - 1]; var args = Array.prototype.slice.call(arguments, 0); args[0] = function() { var result = origFn.apply(this, _concat(arguments, [idx, list])); idx += 1; return result; }; return fn.apply(this, args); }); }); /** * Optimized internal three-arity curry function. * * @private * @category Function * @param {Function} fn The function to curry. * @return {Function} The curried function. */ function _curry3(fn) { return function f3(a, b, c) { switch (arguments.length) { case 0: return f3; case 1: return _isPlaceholder(a) ? f3 : _curry2(function(_b, _c) { return fn(a, _b, _c); }); case 2: return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function(_a, _c) { return fn(_a, b, _c); }) : _isPlaceholder(b) ? _curry2(function(_b, _c) { return fn(a, _b, _c); }) : _curry1(function(_c) { return fn(a, b, _c); }); default: return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function(_a, _b) { return fn(_a, _b, c); }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function(_a, _c) { return fn(_a, b, _c); }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function(_b, _c) { return fn(a, _b, _c); }) : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b, c); }) : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b, c); }) : _isPlaceholder(c) ? _curry1(function(_c) { return fn(a, b, _c); }) : fn(a, b, c); } }; } /** * Applies a function to the value at the given index of an array, returning a * new copy of the array with the element at the given index replaced with the * result of the function application. * * @func * @memberOf R * @since v0.14.0 * @category List * @sig Number -> (a -> a) -> [a] -> [a] * @param {Number} idx The index. * @param {Function} fn The function to apply. * @param {Array|Arguments} list An array-like object whose value * at the supplied index will be replaced. * @return {Array} A copy of the supplied array-like object with * the element at index `idx` replaced with the value * returned by applying `fn` to the existing element. * @see R.update * @example * * R.adjust(1, R.toUpper, ['a', 'b', 'c', 'd']); //=> ['a', 'B', 'c', 'd'] * R.adjust(-1, R.toUpper, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c', 'D'] * @symb R.adjust(-1, f, [a, b]) = [a, f(b)] * @symb R.adjust(0, f, [a, b]) = [f(a), b] */ var adjust = _curry3(function adjust(idx, fn, list) { if (idx >= list.length || idx < -list.length) { return list; } var start = idx < 0 ? list.length : 0; var _idx = start + idx; var _list = _concat(list); _list[_idx] = fn(list[_idx]); return _list; }); /** * Tests whether or not an object is an array. * * @private * @param {*} val The object to test. * @return {Boolean} `true` if `val` is an array, `false` otherwise. * @example * * _isArray([]); //=> true * _isArray(null); //=> false * _isArray({}); //=> false */ var _isArray = Array.isArray || function _isArray(val) { return (val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]'); }; function _isTransformer(obj) { return obj != null && typeof obj['@@transducer/step'] === 'function'; } /** * Returns a function that dispatches with different strategies based on the * object in list position (last argument). If it is an array, executes [fn]. * Otherwise, if it has a function with one of the given method names, it will * execute that function (functor case). Otherwise, if it is a transformer, * uses transducer [xf] to return a new transformer (transducer case). * Otherwise, it will default to executing [fn]. * * @private * @param {Array} methodNames properties to check for a custom implementation * @param {Function} xf transducer to initialize if object is transformer * @param {Function} fn default ramda implementation * @return {Function} A function that dispatches on object in list position */ function _dispatchable(methodNames, xf, fn) { return function() { if (arguments.length === 0) { return fn(); } var args = Array.prototype.slice.call(arguments, 0); var obj = args.pop(); if (!_isArray(obj)) { var idx = 0; while (idx < methodNames.length) { if (typeof obj[methodNames[idx]] === 'function') { return obj[methodNames[idx]].apply(obj, args); } idx += 1; } if (_isTransformer(obj)) { var transducer = xf.apply(null, args); return transducer(obj); } } return fn.apply(this, arguments); }; } function _reduced(x) { return x && x['@@transducer/reduced'] ? x : { '@@transducer/value': x, '@@transducer/reduced': true }; } var _xfBase = { init: function() { return this.xf['@@transducer/init'](); }, result: function(result) { return this.xf['@@transducer/result'](result); } }; function XAll(f, xf) { this.xf = xf; this.f = f; this.all = true; } XAll.prototype['@@transducer/init'] = _xfBase.init; XAll.prototype['@@transducer/result'] = function(result) { if (this.all) { result = this.xf['@@transducer/step'](result, true); } return this.xf['@@transducer/result'](result); }; XAll.prototype['@@transducer/step'] = function(result, input) { if (!this.f(input)) { this.all = false; result = _reduced(this.xf['@@transducer/step'](result, false)); } return result; }; var _xall = _curry2(function _xall(f, xf) { return new XAll(f, xf); }); /** * Returns `true` if all elements of the list match the predicate, `false` if * there are any that don't. * * Dispatches to the `all` method of the second argument, if present. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig (a -> Boolean) -> [a] -> Boolean * @param {Function} fn The predicate function. * @param {Array} list The array to consider. * @return {Boolean} `true` if the predicate is satisfied by every element, `false` * otherwise. * @see R.any, R.none, R.transduce * @example * * const equals3 = R.equals(3); * R.all(equals3)([3, 3, 3, 3]); //=> true * R.all(equals3)([3, 3, 1, 3]); //=> false */ var all = _curry2(_dispatchable(['all'], _xall, function all(fn, list) { var idx = 0; while (idx < list.length) { if (!fn(list[idx])) { return false; } idx += 1; } return true; })); /** * Returns the larger of its two arguments. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig Ord a => a -> a -> a * @param {*} a * @param {*} b * @return {*} * @see R.maxBy, R.min * @example * * R.max(789, 123); //=> 789 * R.max('a', 'b'); //=> 'b' */ var max = _curry2(function max(a, b) { return b > a ? b : a; }); function _map(fn, functor) { var idx = 0; var len = functor.length; var result = Array(len); while (idx < len) { result[idx] = fn(functor[idx]); idx += 1; } return result; } function _isString(x) { return Object.prototype.toString.call(x) === '[object String]'; } /** * Tests whether or not an object is similar to an array. * * @private * @category Type * @category List * @sig * -> Boolean * @param {*} x The object to test. * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise. * @example * * _isArrayLike([]); //=> true * _isArrayLike(true); //=> false * _isArrayLike({}); //=> false * _isArrayLike({length: 10}); //=> false * _isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true */ var _isArrayLike = _curry1(function isArrayLike(x) { if (_isArray(x)) { return true; } if (!x) { return false; } if (typeof x !== 'object') { return false; } if (_isString(x)) { return false; } if (x.nodeType === 1) { return !!x.length; } if (x.length === 0) { return true; } if (x.length > 0) { return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1); } return false; }); function XWrap(fn) { this.f = fn; } XWrap.prototype['@@transducer/init'] = function() { throw new Error('init not implemented on XWrap'); }; XWrap.prototype['@@transducer/result'] = function(acc) { return acc; }; XWrap.prototype['@@transducer/step'] = function(acc, x) { return this.f(acc, x); }; function _xwrap(fn) { return new XWrap(fn); } /** * Creates a function that is bound to a context. * Note: `R.bind` does not provide the additional argument-binding capabilities of * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind). * * @func * @memberOf R * @since v0.6.0 * @category Function * @category Object * @sig (* -> *) -> {*} -> (* -> *) * @param {Function} fn The function to bind to context * @param {Object} thisObj The context to bind `fn` to * @return {Function} A function that will execute in the context of `thisObj`. * @see R.partial * @example * * const log = R.bind(console.log, console); * R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3} * // logs {a: 2} * @symb R.bind(f, o)(a, b) = f.call(o, a, b) */ var bind = _curry2(function bind(fn, thisObj) { return _arity(fn.length, function() { return fn.apply(thisObj, arguments); }); }); function _arrayReduce(xf, acc, list) { var idx = 0; var len = list.length; while (idx < len) { acc = xf['@@transducer/step'](acc, list[idx]); if (acc && acc['@@transducer/reduced']) { acc = acc['@@transducer/value']; break; } idx += 1; } return xf['@@transducer/result'](acc); } function _iterableReduce(xf, acc, iter) { var step = iter.next(); while (!step.done) { acc = xf['@@transducer/step'](acc, step.value); if (acc && acc['@@transducer/reduced']) { acc = acc['@@transducer/value']; break; } step = iter.next(); } return xf['@@transducer/result'](acc); } function _methodReduce(xf, acc, obj, methodName) { return xf['@@transducer/result'](obj[methodName](bind(xf['@@transducer/step'], xf), acc)); } var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator'; function _reduce(fn, acc, list) { if (typeof fn === 'function') { fn = _xwrap(fn); } if (_isArrayLike(list)) { return _arrayReduce(fn, acc, list); } if (typeof list['fantasy-land/reduce'] === 'function') { return _methodReduce(fn, acc, list, 'fantasy-land/reduce'); } if (list[symIterator] != null) { return _iterableReduce(fn, acc, list[symIterator]()); } if (typeof list.next === 'function') { return _iterableReduce(fn, acc, list); } if (typeof list.reduce === 'function') { return _methodReduce(fn, acc, list, 'reduce'); } throw new TypeError('reduce: list must be array or iterable'); } function XMap(f, xf) { this.xf = xf; this.f = f; } XMap.prototype['@@transducer/init'] = _xfBase.init; XMap.prototype['@@transducer/result'] = _xfBase.result; XMap.prototype['@@transducer/step'] = function(result, input) { return this.xf['@@transducer/step'](result, this.f(input)); }; var _xmap = _curry2(function _xmap(f, xf) { return new XMap(f, xf); }); function _has(prop, obj) { return Object.prototype.hasOwnProperty.call(obj, prop); } var toString = Object.prototype.toString; var _isArguments = (function() { return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) { return toString.call(x) === '[object Arguments]'; } : function _isArguments(x) { return _has('callee', x); }; }()); // cover IE < 9 keys issues var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString'); var nonEnumerableProps = [ 'constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString' ]; // Safari bug var hasArgsEnumBug = (function() { return arguments.propertyIsEnumerable('length'); }()); var contains = function contains(list, item) { var idx = 0; while (idx < list.length) { if (list[idx] === item) { return true; } idx += 1; } return false; }; /** * Returns a list containing the names of all the enumerable own properties of * the supplied object. * Note that the order of the output array is not guaranteed to be consistent * across different JS platforms. * * @func * @memberOf R * @since v0.1.0 * @category Object * @sig {k: v} -> [k] * @param {Object} obj The object to extract properties from * @return {Array} An array of the object's own properties. * @see R.keysIn, R.values * @example * * R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c'] */ var keys = typeof Object.keys === 'function' && !hasArgsEnumBug ? _curry1(function keys(obj) { return Object(obj) !== obj ? [] : Object.keys(obj); }) : _curry1(function keys(obj) { if (Object(obj) !== obj) { return []; } var prop, nIdx; var ks = []; var checkArgsLength = hasArgsEnumBug && _isArguments(obj); for (prop in obj) { if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) { ks[ks.length] = prop; } } if (hasEnumBug) { nIdx = nonEnumerableProps.length - 1; while (nIdx >= 0) { prop = nonEnumerableProps[nIdx]; if (_has(prop, obj) && !contains(ks, prop)) { ks[ks.length] = prop; } nIdx -= 1; } } return ks; }); /** * Takes a function and * a [functor](https://github.com/fantasyland/fantasy-land#functor), * applies the function to each of the functor's values, and returns * a functor of the same shape. * * Ramda provides suitable `map` implementations for `Array` and `Object`, * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`. * * Dispatches to the `map` method of the second argument, if present. * * Acts as a transducer if a transformer is given in list position. * * Also treats functions as functors and will compose them together. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig Functor f => (a -> b) -> f a -> f b * @param {Function} fn The function to be called on every element of the input `list`. * @param {Array} list The list to be iterated over. * @return {Array} The new list. * @see R.transduce, R.addIndex * @example * * const double = x => x * 2; * * R.map(double, [1, 2, 3]); //=> [2, 4, 6] * * R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6} * @symb R.map(f, [a, b]) = [f(a), f(b)] * @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) } * @symb R.map(f, functor_o) = functor_o.map(f) */ var map = _curry2(_dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) { switch (Object.prototype.toString.call(functor)) { case '[object Function]': return curryN(functor.length, function() { return fn.call(this, functor.apply(this, arguments)); }); case '[object Object]': return _reduce(function(acc, key) { acc[key] = fn(functor[key]); return acc; }, {}, keys(functor)); default: return _map(fn, functor); } })); /** * Determine if the passed argument is an integer. * * @private * @param {*} n * @category Type * @return {Boolean} */ var _isInteger = Number.isInteger || function _isInteger(n) { return (n << 0) === n; }; /** * Returns the nth element of the given list or string. If n is negative the * element at index length + n is returned. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig Number -> [a] -> a | Undefined * @sig Number -> String -> String * @param {Number} offset * @param {*} list * @return {*} * @example * * const list = ['foo', 'bar', 'baz', 'quux']; * R.nth(1, list); //=> 'bar' * R.nth(-1, list); //=> 'quux' * R.nth(-99, list); //=> undefined * * R.nth(2, 'abc'); //=> 'c' * R.nth(3, 'abc'); //=> '' * @symb R.nth(-1, [a, b, c]) = c * @symb R.nth(0, [a, b, c]) = a * @symb R.nth(1, [a, b, c]) = b */ var nth = _curry2(function nth(offset, list) { var idx = offset < 0 ? list.length + offset : offset; return _isString(list) ? list.charAt(idx) : list[idx]; }); /** * Retrieves the values at given paths of an object. * * @func * @memberOf R * @since v0.27.1 * @category Object * @typedefn Idx = [String | Int] * @sig [Idx] -> {a} -> [a | Undefined] * @param {Array} pathsArray The array of paths to be fetched. * @param {Object} obj The object to retrieve the nested properties from. * @return {Array} A list consisting of values at paths specified by "pathsArray". * @see R.path * @example * * R.paths([['a', 'b'], ['p', 0, 'q']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, 3] * R.paths([['a', 'b'], ['p', 'r']], {a: {b: 2}, p: [{q: 3}]}); //=> [2, undefined] */ var paths = _curry2(function paths(pathsArray, obj) { return pathsArray.map(function(paths) { var val = obj; var idx = 0; var p; while (idx < paths.length) { if (val == null) { return; } p = paths[idx]; val = _isInteger(p) ? nth(p, val) : val[p]; idx += 1; } return val; }); }); /** * Retrieve the value at a given path. * * @func * @memberOf R * @since v0.2.0 * @category Object * @typedefn Idx = String | Int * @sig [Idx] -> {a} -> a | Undefined * @param {Array} path The path to use. * @param {Object} obj The object to retrieve the nested property from. * @return {*} The data at `path`. * @see R.prop, R.nth * @example * * R.path(['a', 'b'], {a: {b: 2}}); //=> 2 * R.path(['a', 'b'], {c: {b: 2}}); //=> undefined * R.path(['a', 'b', 0], {a: {b: [1, 2, 3]}}); //=> 1 * R.path(['a', 'b', -2], {a: {b: [1, 2, 3]}}); //=> 2 */ var path = _curry2(function path(pathAr, obj) { return paths([pathAr], obj)[0]; }); /** * Returns a function that when supplied an object returns the indicated * property of that object, if it exists. * * @func * @memberOf R * @since v0.1.0 * @category Object * @typedefn Idx = String | Int * @sig Idx -> {s: a} -> a | Undefined * @param {String|Number} p The property name or array index * @param {Object} obj The object to query * @return {*} The value at `obj.p`. * @see R.path, R.nth * @example * * R.prop('x', {x: 100}); //=> 100 * R.prop('x', {}); //=> undefined * R.prop(0, [100]); //=> 100 * R.compose(R.inc, R.prop('x'))({ x: 3 }) //=> 4 */ var prop = _curry2(function prop(p, obj) { return path([p], obj); }); /** * Returns a new list by plucking the same named property off all objects in * the list supplied. * * `pluck` will work on * any [functor](https://github.com/fantasyland/fantasy-land#functor) in * addition to arrays, as it is equivalent to `R.map(R.prop(k), f)`. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig Functor f => k -> f {k: v} -> f v * @param {Number|String} key The key name to pluck off of each object. * @param {Array} f The array or functor to consider. * @return {Array} The list of values for the given key. * @see R.props * @example * * var getAges = R.pluck('age'); * getAges([{name: 'fred', age: 29}, {name: 'wilma', age: 27}]); //=> [29, 27] * * R.pluck(0, [[1, 2], [3, 4]]); //=> [1, 3] * R.pluck('val', {a: {val: 3}, b: {val: 5}}); //=> {a: 3, b: 5} * @symb R.pluck('x', [{x: 1, y: 2}, {x: 3, y: 4}, {x: 5, y: 6}]) = [1, 3, 5] * @symb R.pluck(0, [[1, 2], [3, 4], [5, 6]]) = [1, 3, 5] */ var pluck = _curry2(function pluck(p, list) { return map(prop(p), list); }); /** * Returns a single item by iterating through the list, successively calling * the iterator function and passing it an accumulator value and the current * value from the array, and then passing the result to the next call. * * The iterator function receives two values: *(acc, value)*. It may use * [`R.reduced`](#reduced) to shortcut the iteration. * * The arguments' order of [`reduceRight`](#reduceRight)'s iterator function * is *(value, acc)*. * * Note: `R.reduce` does not skip deleted or unassigned indices (sparse * arrays), unlike the native `Array.prototype.reduce` method. For more details * on this behavior, see: * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description * * Dispatches to the `reduce` method of the third argument, if present. When * doing so, it is up to the user to handle the [`R.reduced`](#reduced) * shortcuting, as this is not implemented by `reduce`. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig ((a, b) -> a) -> a -> [b] -> a * @param {Function} fn The iterator function. Receives two values, the accumulator and the * current element from the array. * @param {*} acc The accumulator value. * @param {Array} list The list to iterate over. * @return {*} The final, accumulated value. * @see R.reduced, R.addIndex, R.reduceRight * @example * * R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10 * // - -10 * // / \ / \ * // - 4 -6 4 * // / \ / \ * // - 3 ==> -3 3 * // / \ / \ * // - 2 -1 2 * // / \ / \ * // 0 1 0 1 * * @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d) */ var reduce = _curry3(_reduce); /** * Takes a list of predicates and returns a predicate that returns true for a * given list of arguments if every one of the provided predicates is satisfied * by those arguments. * * The function returned is a curried function whose arity matches that of the * highest-arity predicate. * * @func * @memberOf R * @since v0.9.0 * @category Logic * @sig [(*... -> Boolean)] -> (*... -> Boolean) * @param {Array} predicates An array of predicates to check * @return {Function} The combined predicate * @see R.anyPass * @example * * const isQueen = R.propEq('rank', 'Q'); * const isSpade = R.propEq('suit', '♠︎'); * const isQueenOfSpades = R.allPass([isQueen, isSpade]); * * isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false * isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true */ var allPass = _curry1(function allPass(preds) { return curryN(reduce(max, 0, pluck('length', preds)), function() { var idx = 0; var len = preds.length; while (idx < len) { if (!preds[idx].apply(this, arguments)) { return false; } idx += 1; } return true; }); }); /** * Returns a function that always returns the given value. Note that for * non-primitives the value returned is a reference to the original value. * * This function is known as `const`, `constant`, or `K` (for K combinator) in * other languages and libraries. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig a -> (* -> a) * @param {*} val The value to wrap in a function * @return {Function} A Function :: * -> val. * @example * * const t = R.always('Tee'); * t(); //=> 'Tee' */ var always = _curry1(function always(val) { return function() { return val; }; }); /** * Returns `true` if both arguments are `true`; `false` otherwise. * * @func * @memberOf R * @since v0.1.0 * @category Logic * @sig a -> b -> a | b * @param {Any} a * @param {Any} b * @return {Any} the first argument if it is falsy, otherwise the second argument. * @see R.both, R.xor * @example * * R.and(true, true); //=> true * R.and(true, false); //=> false * R.and(false, true); //=> false * R.and(false, false); //=> false */ var and = _curry2(function and(a, b) { return a && b; }); function XAny(f, xf) { this.xf = xf; this.f = f; this.any = false; } XAny.prototype['@@transducer/init'] = _xfBase.init; XAny.prototype['@@transducer/result'] = function(result) { if (!this.any) { result = this.xf['@@transducer/step'](result, false); } return this.xf['@@transducer/result'](result); }; XAny.prototype['@@transducer/step'] = function(result, input) { if (this.f(input)) { this.any = true; result = _reduced(this.xf['@@transducer/step'](result, true)); } return result; }; var _xany = _curry2(function _xany(f, xf) { return new XAny(f, xf); }); /** * Returns `true` if at least one of the elements of the list match the predicate, * `false` otherwise. * * Dispatches to the `any` method of the second argument, if present. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig (a -> Boolean) -> [a] -> Boolean * @param {Function} fn The predicate function. * @param {Array} list The array to consider. * @return {Boolean} `true` if the predicate is satisfied by at least one element, `false` * otherwise. * @see R.all, R.none, R.transduce * @example * * const lessThan0 = R.flip(R.lt)(0); * const lessThan2 = R.flip(R.lt)(2); * R.any(lessThan0)([1, 2]); //=> false * R.any(lessThan2)([1, 2]); //=> true */ var any = _curry2(_dispatchable(['any'], _xany, function any(fn, list) { var idx = 0; while (idx < list.length) { if (fn(list[idx])) { return true; } idx += 1; } return false; })); /** * Takes a list of predicates and returns a predicate that returns true for a * given list of arguments if at least one of the provided predicates is * satisfied by those arguments. * * The function returned is a curried function whose arity matches that of the * highest-arity predicate. * * @func * @memberOf R * @since v0.9.0 * @category Logic * @sig [(*... -> Boolean)] -> (*... -> Boolean) * @param {Array} predicates An array of predicates to check * @return {Function} The combined predicate * @see R.allPass * @example * * const isClub = R.propEq('suit', '♣'); * const isSpade = R.propEq('suit', '♠'); * const isBlackCard = R.anyPass([isClub, isSpade]); * * isBlackCard({rank: '10', suit: '♣'}); //=> true * isBlackCard({rank: 'Q', suit: '♠'}); //=> true * isBlackCard({rank: 'Q', suit: '♦'}); //=> false */ var anyPass = _curry1(function anyPass(preds) { return curryN(reduce(max, 0, pluck('length', preds)), function() { var idx = 0; var len = preds.length; while (idx < len) { if (preds[idx].apply(this, arguments)) { return true; } idx += 1; } return false; }); }); /** * ap applies a list of functions to a list of values. * * Dispatches to the `ap` method of the second argument, if present. Also * treats curried functions as applicatives. * * @func * @memberOf R * @since v0.3.0 * @category Function * @sig [a -> b] -> [a] -> [b] * @sig Apply f => f (a -> b) -> f a -> f b * @sig (r -> a -> b) -> (r -> a) -> (r -> b) * @param {*} applyF * @param {*} applyX * @return {*} * @example * * R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6] * R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> ["tasty pizza", "tasty salad", "PIZZA", "SALAD"] * * // R.ap can also be used as S combinator * // when only two functions are passed * R.ap(R.concat, R.toUpper)('Ramda') //=> 'RamdaRAMDA' * @symb R.ap([f, g], [a, b]) = [f(a), f(b), g(a), g(b)] */ var ap = _curry2(function ap(applyF, applyX) { return ( typeof applyX['fantasy-land/ap'] === 'function' ? applyX['fantasy-land/ap'](applyF) : typeof applyF.ap === 'function' ? applyF.ap(applyX) : typeof applyF === 'function' ? function(x) { return applyF(x)(applyX(x)); } : _reduce(function(acc, f) { return _concat(acc, map(f, applyX)); }, [], applyF) ); }); function _aperture(n, list) { var idx = 0; var limit = list.length - (n - 1); var acc = new Array(limit >= 0 ? limit : 0); while (idx < limit) { acc[idx] = Array.prototype.slice.call(list, idx, idx + n); idx += 1; } return acc; } function XAperture(n, xf) { this.xf = xf; this.pos = 0; this.full = false; this.acc = new Array(n); } XAperture.prototype['@@transducer/init'] = _xfBase.init; XAperture.prototype['@@transducer/result'] = function(result) { this.acc = null; return this.xf['@@transducer/result'](result); }; XAperture.prototype['@@transducer/step'] = function(result, input) { this.store(input); return this.full ? this.xf['@@transducer/step'](result, this.getCopy()) : result; }; XAperture.prototype.store = function(input) { this.acc[this.pos] = input; this.pos += 1; if (this.pos === this.acc.length) { this.pos = 0; this.full = true; } }; XAperture.prototype.getCopy = function() { return _concat(Array.prototype.slice.call(this.acc, this.pos), Array.prototype.slice.call(this.acc, 0, this.pos) ); }; var _xaperture = _curry2(function _xaperture(n, xf) { return new XAperture(n, xf); }); /** * Returns a new list, composed of n-tuples of consecutive elements. If `n` is * greater than the length of the list, an empty list is returned. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.12.0 * @category List * @sig Number -> [a] -> [[a]] * @param {Number} n The size of the tuples to create * @param {Array} list The list to split into `n`-length tuples * @return {Array} The resulting list of `n`-length tuples * @see R.transduce * @example * * R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]] * R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]] * R.aperture(7, [1, 2, 3, 4, 5]); //=> [] */ var aperture = _curry2(_dispatchable([], _xaperture, _aperture)); /** * Returns a new list containing the contents of the given list, followed by * the given element. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig a -> [a] -> [a] * @param {*} el The element to add to the end of the new list. * @param {Array} list The list of elements to add a new item to. * list. * @return {Array} A new list containing the elements of the old list followed by `el`. * @see R.prepend * @example * * R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests'] * R.append('tests', []); //=> ['tests'] * R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']] */ var append = _curry2(function append(el, list) { return _concat(list, [el]); }); /** * Applies function `fn` to the argument list `args`. This is useful for * creating a fixed-arity function from a variadic function. `fn` should be a * bound function if context is significant. * * @func * @memberOf R * @since v0.7.0 * @category Function * @sig (*... -> a) -> [*] -> a * @param {Function} fn The function which will be called with `args` * @param {Array} args The arguments to call `fn` with * @return {*} result The result, equivalent to `fn(...args)` * @see R.call, R.unapply * @example * * const nums = [1, 2, 3, -99, 42, 6, 7]; * R.apply(Math.max, nums); //=> 42 * @symb R.apply(f, [a, b, c]) = f(a, b, c) */ var apply = _curry2(function apply(fn, args) { return fn.apply(this, args); }); /** * Returns a list of all the enumerable own properties of the supplied object. * Note that the order of the output array is not guaranteed across different * JS platforms. * * @func * @memberOf R * @since v0.1.0 * @category Object * @sig {k: v} -> [v] * @param {Object} obj The object to extract values from * @return {Array} An array of the values of the object's own properties. * @see R.valuesIn, R.keys * @example * * R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3] */ var values = _curry1(function values(obj) { var props = keys(obj); var len = props.length; var vals = []; var idx = 0; while (idx < len) { vals[idx] = obj[props[idx]]; idx += 1; } return vals; }); // Use custom mapValues function to avoid issues with specs that include a "map" key and R.map // delegating calls to .map function mapValues(fn, obj) { return keys(obj).reduce(function(acc, key) { acc[key] = fn(obj[key]); return acc; }, {}); } /** * Given a spec object recursively mapping properties to functions, creates a * function producing an object of the same structure, by mapping each property * to the result of calling its associated function with the supplied arguments. * * @func * @memberOf R * @since v0.20.0 * @category Function * @sig {k: ((a, b, ..., m) -> v)} -> ((a, b, ..., m) -> {k: v}) * @param {Object} spec an object recursively mapping properties to functions for * producing the values for these properties. * @return {Function} A function that returns an object of the same structure * as `spec', with each property set to the value returned by calling its * associated function with the supplied arguments. * @see R.converge, R.juxt * @example * * const getMetrics = R.applySpec({ * sum: R.add, * nested: { mul: R.multiply } * }); * getMetrics(2, 4); // => { sum: 6, nested: { mul: 8 } } * @symb R.applySpec({ x: f, y: { z: g } })(a, b) = { x: f(a, b), y: { z: g(a, b) } } */ var applySpec = _curry1(function applySpec(spec) { spec = mapValues( function(v) { return typeof v == 'function' ? v : applySpec(v); }, spec ); return curryN( reduce(max, 0, pluck('length', values(spec))), function() { var args = arguments; return mapValues(function(f) { return apply(f, args); }, spec); }); }); /** * Takes a value and applies a function to it. * * This function is also known as the `thrush` combinator. * * @func * @memberOf R * @since v0.25.0 * @category Function * @sig a -> (a -> b) -> b * @param {*} x The value * @param {Function} f The function to apply * @return {*} The result of applying `f` to `x` * @example * * const t42 = R.applyTo(42); * t42(R.identity); //=> 42 * t42(R.add(1)); //=> 43 */ var applyTo = _curry2(function applyTo(x, f) { return f(x); }); /** * Makes an ascending comparator function out of a function that returns a value * that can be compared with `<` and `>`. * * @func * @memberOf R * @since v0.23.0 * @category Function * @sig Ord b => (a -> b) -> a -> a -> Number * @param {Function} fn A function of arity one that returns a value that can be compared * @param {*} a The first item to be compared. * @param {*} b The second item to be compared. * @return {Number} `-1` if fn(a) < fn(b), `1` if fn(b) < fn(a), otherwise `0` * @see R.descend * @example * * const byAge = R.ascend(R.prop('age')); * const people = [ * { name: 'Emma', age: 70 }, * { name: 'Peter', age: 78 }, * { name: 'Mikhail', age: 62 }, * ]; * const peopleByYoungestFirst = R.sort(byAge, people); * //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }] */ var ascend = _curry3(function ascend(fn, a, b) { var aa = fn(a); var bb = fn(b); return aa < bb ? -1 : aa > bb ? 1 : 0; }); /** * Makes a shallow clone of an object, setting or overriding the specified * property with the given value. Note that this copies and flattens prototype * properties onto the new object as well. All non-primitive properties are * copied by reference. * * @func * @memberOf R * @since v0.8.0 * @category Object * @sig String -> a -> {k: v} -> {k: v} * @param {String} prop The property name to set * @param {*} val The new value * @param {Object} obj The object to clone * @return {Object} A new object equivalent to the original except for the changed property. * @see R.dissoc, R.pick * @example * * R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3} */ var assoc = _curry3(function assoc(prop, val, obj) { var result = {}; for (var p in obj) { result[p] = obj[p]; } result[prop] = val; return result; }); /** * Checks if the input value is `null` or `undefined`. * * @func * @memberOf R * @since v0.9.0 * @category Type * @sig * -> Boolean * @param {*} x The value to test. * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`. * @example * * R.isNil(null); //=> true * R.isNil(undefined); //=> true * R.isNil(0); //=> false * R.isNil([]); //=> false */ var isNil = _curry1(function isNil(x) { return x == null; }); /** * Makes a shallow clone of an object, setting or overriding the nodes required * to create the given path, and placing the specific value at the tail end of * that path. Note that this copies and flattens prototype properties onto the * new object as well. All non-primitive properties are copied by reference. * * @func * @memberOf R * @since v0.8.0 * @category Object * @typedefn Idx = String | Int * @sig [Idx] -> a -> {a} -> {a} * @param {Array} path the path to set * @param {*} val The new value * @param {Object} obj The object to clone * @return {Object} A new object equivalent to the original except along the specified path. * @see R.dissocPath * @example * * R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}} * * // Any missing or non-object keys in path will be overridden * R.assocPath(['a', 'b', 'c'], 42, {a: 5}); //=> {a: {b: {c: 42}}} */ var assocPath = _curry3(function assocPath(path, val, obj) { if (path.length === 0) { return val; } var idx = path[0]; if (path.length > 1) { var nextObj = (!isNil(obj) && _has(idx, obj)) ? obj[idx] : _isInteger(path[1]) ? [] : {}; val = assocPath(Array.prototype.slice.call(path, 1), val, nextObj); } if (_isInteger(idx) && _isArray(obj)) { var arr = [].concat(obj); arr[idx] = val; return arr; } else { return assoc(idx, val, obj); } }); /** * Wraps a function of any arity (including nullary) in a function that accepts * exactly `n` parameters. Any extraneous parameters will not be passed to the * supplied function. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig Number -> (* -> a) -> (* -> a) * @param {Number} n The desired arity of the new function. * @param {Function} fn The function to wrap. * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of * arity `n`. * @see R.binary, R.unary * @example * * const takesTwoArgs = (a, b) => [a, b]; * * takesTwoArgs.length; //=> 2 * takesTwoArgs(1, 2); //=> [1, 2] * * const takesOneArg = R.nAry(1, takesTwoArgs); * takesOneArg.length; //=> 1 * // Only `n` arguments are passed to the wrapped function * takesOneArg(1, 2); //=> [1, undefined] * @symb R.nAry(0, f)(a, b) = f() * @symb R.nAry(1, f)(a, b) = f(a) * @symb R.nAry(2, f)(a, b) = f(a, b) */ var nAry = _curry2(function nAry(n, fn) { switch (n) { case 0: return function() {return fn.call(this);}; case 1: return function(a0) {return fn.call(this, a0);}; case 2: return function(a0, a1) {return fn.call(this, a0, a1);}; case 3: return function(a0, a1, a2) {return fn.call(this, a0, a1, a2);}; case 4: return function(a0, a1, a2, a3) {return fn.call(this, a0, a1, a2, a3);}; case 5: return function(a0, a1, a2, a3, a4) {return fn.call(this, a0, a1, a2, a3, a4);}; case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.call(this, a0, a1, a2, a3, a4, a5);}; case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6);}; case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);}; case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);}; case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);}; default: throw new Error('First argument to nAry must be a non-negative integer no greater than ten'); } }); /** * Wraps a function of any arity (including nullary) in a function that accepts * exactly 2 parameters. Any extraneous parameters will not be passed to the * supplied function. * * @func * @memberOf R * @since v0.2.0 * @category Function * @sig (* -> c) -> (a, b -> c) * @param {Function} fn The function to wrap. * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of * arity 2. * @see R.nAry, R.unary * @example * * const takesThreeArgs = function(a, b, c) { * return [a, b, c]; * }; * takesThreeArgs.length; //=> 3 * takesThreeArgs(1, 2, 3); //=> [1, 2, 3] * * const takesTwoArgs = R.binary(takesThreeArgs); * takesTwoArgs.length; //=> 2 * // Only 2 arguments are passed to the wrapped function * takesTwoArgs(1, 2, 3); //=> [1, 2, undefined] * @symb R.binary(f)(a, b, c) = f(a, b) */ var binary = _curry1(function binary(fn) { return nAry(2, fn); }); function _isFunction(x) { var type = Object.prototype.toString.call(x); return type === '[object Function]' || type === '[object AsyncFunction]' || type === '[object GeneratorFunction]' || type === '[object AsyncGeneratorFunction]'; } /** * "lifts" a function to be the specified arity, so that it may "map over" that * many lists, Functions or other objects that satisfy the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply). * * @func * @memberOf R * @since v0.7.0 * @category Function * @sig Number -> (*... -> *) -> ([*]... -> [*]) * @param {Function} fn The function to lift into higher context * @return {Function} The lifted function. * @see R.lift, R.ap * @example * * const madd3 = R.liftN(3, (...args) => R.sum(args)); * madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7] */ var liftN = _curry2(function liftN(arity, fn) { var lifted = curryN(arity, fn); return curryN(arity, function() { return _reduce(ap, map(lifted, arguments[0]), Array.prototype.slice.call(arguments, 1)); }); }); /** * "lifts" a function of arity > 1 so that it may "map over" a list, Function or other * object that satisfies the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply). * * @func * @memberOf R * @since v0.7.0 * @category Function * @sig (*... -> *) -> ([*]... -> [*]) * @param {Function} fn The function to lift into higher context * @return {Function} The lifted function. * @see R.liftN * @example * * const madd3 = R.lift((a, b, c) => a + b + c); * * madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7] * * const madd5 = R.lift((a, b, c, d, e) => a + b + c + d + e); * * madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24] */ var lift = _curry1(function lift(fn) { return liftN(fn.length, fn); }); /** * A function which calls the two provided functions and returns the `&&` * of the results. * It returns the result of the first function if it is false-y and the result * of the second function otherwise. Note that this is short-circuited, * meaning that the second function will not be invoked if the first returns a * false-y value. * * In addition to functions, `R.both` also accepts any fantasy-land compatible * applicative functor. * * @func * @memberOf R * @since v0.12.0 * @category Logic * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean) * @param {Function} f A predicate * @param {Function} g Another predicate * @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together. * @see R.and * @example * * const gt10 = R.gt(R.__, 10) * const lt20 = R.lt(R.__, 20) * const f = R.both(gt10, lt20); * f(15); //=> true * f(30); //=> false * * R.both(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(false) * R.both([false, false, 'a'], [11]); //=> [false, false, 11] */ var both = _curry2(function both(f, g) { return _isFunction(f) ? function _both() { return f.apply(this, arguments) && g.apply(this, arguments); } : lift(and)(f, g); }); /** * Returns a curried equivalent of the provided function. The curried function * has two unusual capabilities. First, its arguments needn't be provided one * at a time. If `f` is a ternary function and `g` is `R.curry(f)`, the * following are equivalent: * * - `g(1)(2)(3)` * - `g(1)(2, 3)` * - `g(1, 2)(3)` * - `g(1, 2, 3)` * * Secondly, the special placeholder value [`R.__`](#__) may be used to specify * "gaps", allowing partial application of any combination of arguments, * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__), * the following are equivalent: * * - `g(1, 2, 3)` * - `g(_, 2, 3)(1)` * - `g(_, _, 3)(1)(2)` * - `g(_, _, 3)(1, 2)` * - `g(_, 2)(1)(3)` * - `g(_, 2)(1, 3)` * - `g(_, 2)(_, 3)(1)` * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig (* -> a) -> (* -> a) * @param {Function} fn The function to curry. * @return {Function} A new, curried function. * @see R.curryN, R.partial * @example * * const addFourNumbers = (a, b, c, d) => a + b + c + d; * * const curriedAddFourNumbers = R.curry(addFourNumbers); * const f = curriedAddFourNumbers(1, 2); * const g = f(3); * g(4); //=> 10 */ var curry = _curry1(function curry(fn) { return curryN(fn.length, fn); }); /** * Returns the result of calling its first argument with the remaining * arguments. This is occasionally useful as a converging function for * [`R.converge`](#converge): the first branch can produce a function while the * remaining branches produce values to be passed to that function as its * arguments. * * @func * @memberOf R * @since v0.9.0 * @category Function * @sig (*... -> a),*... -> a * @param {Function} fn The function to apply to the remaining arguments. * @param {...*} args Any number of positional arguments. * @return {*} * @see R.apply * @example * * R.call(R.add, 1, 2); //=> 3 * * const indentN = R.pipe(R.repeat(' '), * R.join(''), * R.replace(/^(?!$)/gm)); * * const format = R.converge(R.call, [ * R.pipe(R.prop('indent'), indentN), * R.prop('value') * ]); * * format({indent: 2, value: 'foo\nbar\nbaz\n'}); //=> ' foo\n bar\n baz\n' * @symb R.call(f, a, b) = f(a, b) */ var call = curry(function call(fn) { return fn.apply(this, Array.prototype.slice.call(arguments, 1)); }); /** * `_makeFlat` is a helper function that returns a one-level or fully recursive * function based on the flag passed in. * * @private */ function _makeFlat(recursive) { return function flatt(list) { var value, jlen, j; var result = []; var idx = 0; var ilen = list.length; while (idx < ilen) { if (_isArrayLike(list[idx])) { value = recursive ? flatt(list[idx]) : list[idx]; j = 0; jlen = value.length; while (j < jlen) { result[result.length] = value[j]; j += 1; } } else { result[result.length] = list[idx]; } idx += 1; } return result; }; } function _forceReduced(x) { return { '@@transducer/value': x, '@@transducer/reduced': true }; } var preservingReduced = function(xf) { return { '@@transducer/init': _xfBase.init, '@@transducer/result': function(result) { return xf['@@transducer/result'](result); }, '@@transducer/step': function(result, input) { var ret = xf['@@transducer/step'](result, input); return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret; } }; }; var _flatCat = function _xcat(xf) { var rxf = preservingReduced(xf); return { '@@transducer/init': _xfBase.init, '@@transducer/result': function(result) { return rxf['@@transducer/result'](result); }, '@@transducer/step': function(result, input) { return !_isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input); } }; }; var _xchain = _curry2(function _xchain(f, xf) { return map(f, _flatCat(xf)); }); /** * `chain` maps a function over a list and concatenates the results. `chain` * is also known as `flatMap` in some libraries. * * Dispatches to the `chain` method of the second argument, if present, * according to the [FantasyLand Chain spec](https://github.com/fantasyland/fantasy-land#chain). * * If second argument is a function, `chain(f, g)(x)` is equivalent to `f(g(x), x)`. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.3.0 * @category List * @sig Chain m => (a -> m b) -> m a -> m b * @param {Function} fn The function to map with * @param {Array} list The list to map over * @return {Array} The result of flat-mapping `list` with `fn` * @example * * const duplicate = n => [n, n]; * R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3] * * R.chain(R.append, R.head)([1, 2, 3]); //=> [1, 2, 3, 1] */ var chain = _curry2(_dispatchable(['fantasy-land/chain', 'chain'], _xchain, function chain(fn, monad) { if (typeof monad === 'function') { return function(x) { return fn(monad(x))(x); }; } return _makeFlat(false)(map(fn, monad)); })); /** * Restricts a number to be within a range. * * Also works for other ordered types such as Strings and Dates. * * @func * @memberOf R * @since v0.20.0 * @category Relation * @sig Ord a => a -> a -> a -> a * @param {Number} minimum The lower limit of the clamp (inclusive) * @param {Number} maximum The upper limit of the clamp (inclusive) * @param {Number} value Value to be clamped * @return {Number} Returns `minimum` when `val < minimum`, `maximum` when `val > maximum`, returns `val` otherwise * @example * * R.clamp(1, 10, -5) // => 1 * R.clamp(1, 10, 15) // => 10 * R.clamp(1, 10, 4) // => 4 */ var clamp = _curry3(function clamp(min, max, value) { if (min > max) { throw new Error('min must not be greater than max in clamp(min, max, value)'); } return value < min ? min : value > max ? max : value; }); function _cloneRegExp(pattern) { return new RegExp(pattern.source, (pattern.global ? 'g' : '') + (pattern.ignoreCase ? 'i' : '') + (pattern.multiline ? 'm' : '') + (pattern.sticky ? 'y' : '') + (pattern.unicode ? 'u' : '')); } /** * Gives a single-word string description of the (native) type of a value, * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not * attempt to distinguish user Object types any further, reporting them all as * 'Object'. * * @func * @memberOf R * @since v0.8.0 * @category Type * @sig (* -> {*}) -> String * @param {*} val The value to test * @return {String} * @example * * R.type({}); //=> "Object" * R.type(1); //=> "Number" * R.type(false); //=> "Boolean" * R.type('s'); //=> "String" * R.type(null); //=> "Null" * R.type([]); //=> "Array" * R.type(/[A-z]/); //=> "RegExp" * R.type(() => {}); //=> "Function" * R.type(undefined); //=> "Undefined" */ var type = _curry1(function type(val) { return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1); }); /** * Copies an object. * * @private * @param {*} value The value to be copied * @param {Array} refFrom Array containing the source references * @param {Array} refTo Array containing the copied source references * @param {Boolean} deep Whether or not to perform deep cloning. * @return {*} The copied value. */ function _clone(value, refFrom, refTo, deep) { var copy = function copy(copiedValue) { var len = refFrom.length; var idx = 0; while (idx < len) { if (value === refFrom[idx]) { return refTo[idx]; } idx += 1; } refFrom[idx + 1] = value; refTo[idx + 1] = copiedValue; for (var key in value) { copiedValue[key] = deep ? _clone(value[key], refFrom, refTo, true) : value[key]; } return copiedValue; }; switch (type(value)) { case 'Object': return copy({}); case 'Array': return copy([]); case 'Date': return new Date(value.valueOf()); case 'RegExp': return _cloneRegExp(value); default: return value; } } /** * Creates a deep copy of the value which may contain (nested) `Array`s and * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are * assigned by reference rather than copied * * Dispatches to a `clone` method if present. * * @func * @memberOf R * @since v0.1.0 * @category Object * @sig {*} -> {*} * @param {*} value The object or array to clone * @return {*} A deeply cloned copy of `val` * @example * * const objects = [{}, {}, {}]; * const objectsClone = R.clone(objects); * objects === objectsClone; //=> false * objects[0] === objectsClone[0]; //=> false */ var clone = _curry1(function clone(value) { return value != null && typeof value.clone === 'function' ? value.clone() : _clone(value, [], [], true); }); /** * Makes a comparator function out of a function that reports whether the first * element is less than the second. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig ((a, b) -> Boolean) -> ((a, b) -> Number) * @param {Function} pred A predicate function of arity two which will return `true` if the first argument * is less than the second, `false` otherwise * @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0` * @example * * const byAge = R.comparator((a, b) => a.age < b.age); * const people = [ * { name: 'Emma', age: 70 }, * { name: 'Peter', age: 78 }, * { name: 'Mikhail', age: 62 }, * ]; * const peopleByIncreasingAge = R.sort(byAge, people); * //=> [{ name: 'Mikhail', age: 62 },{ name: 'Emma', age: 70 }, { name: 'Peter', age: 78 }] */ var comparator = _curry1(function comparator(pred) { return function(a, b) { return pred(a, b) ? -1 : pred(b, a) ? 1 : 0; }; }); /** * A function that returns the `!` of its argument. It will return `true` when * passed false-y value, and `false` when passed a truth-y one. * * @func * @memberOf R * @since v0.1.0 * @category Logic * @sig * -> Boolean * @param {*} a any value * @return {Boolean} the logical inverse of passed argument. * @see R.complement * @example * * R.not(true); //=> false * R.not(false); //=> true * R.not(0); //=> true * R.not(1); //=> false */ var not = _curry1(function not(a) { return !a; }); /** * Takes a function `f` and returns a function `g` such that if called with the same arguments * when `f` returns a "truthy" value, `g` returns `false` and when `f` returns a "falsy" value `g` returns `true`. * * `R.complement` may be applied to any functor * * @func * @memberOf R * @since v0.12.0 * @category Logic * @sig (*... -> *) -> (*... -> Boolean) * @param {Function} f * @return {Function} * @see R.not * @example * * const isNotNil = R.complement(R.isNil); * isNil(null); //=> true * isNotNil(null); //=> false * isNil(7); //=> false * isNotNil(7); //=> true */ var complement = lift(not); function _pipe(f, g) { return function() { return g.call(this, f.apply(this, arguments)); }; } /** * This checks whether a function has a [methodname] function. If it isn't an * array it will execute that function otherwise it will default to the ramda * implementation. * * @private * @param {Function} fn ramda implemtation * @param {String} methodname property to check for a custom implementation * @return {Object} Whatever the return value of the method is. */ function _checkForMethod(methodname, fn) { return function() { var length = arguments.length; if (length === 0) { return fn(); } var obj = arguments[length - 1]; return (_isArray(obj) || typeof obj[methodname] !== 'function') ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1)); }; } /** * Returns the elements of the given list or string (or object with a `slice` * method) from `fromIndex` (inclusive) to `toIndex` (exclusive). * * Dispatches to the `slice` method of the third argument, if present. * * @func * @memberOf R * @since v0.1.4 * @category List * @sig Number -> Number -> [a] -> [a] * @sig Number -> Number -> String -> String * @param {Number} fromIndex The start index (inclusive). * @param {Number} toIndex The end index (exclusive). * @param {*} list * @return {*} * @example * * R.slice(1, 3, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] * R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd'] * R.slice(0, -1, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c'] * R.slice(-3, -1, ['a', 'b', 'c', 'd']); //=> ['b', 'c'] * R.slice(0, 3, 'ramda'); //=> 'ram' */ var slice = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) { return Array.prototype.slice.call(list, fromIndex, toIndex); })); /** * Returns all but the first element of the given list or string (or object * with a `tail` method). * * Dispatches to the `slice` method of the first argument, if present. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig [a] -> [a] * @sig String -> String * @param {*} list * @return {*} * @see R.head, R.init, R.last * @example * * R.tail([1, 2, 3]); //=> [2, 3] * R.tail([1, 2]); //=> [2] * R.tail([1]); //=> [] * R.tail([]); //=> [] * * R.tail('abc'); //=> 'bc' * R.tail('ab'); //=> 'b' * R.tail('a'); //=> '' * R.tail(''); //=> '' */ var tail = _curry1(_checkForMethod('tail', slice(1, Infinity))); /** * Performs left-to-right function composition. The first argument may have * any arity; the remaining arguments must be unary. * * In some libraries this function is named `sequence`. * * **Note:** The result of pipe is not automatically curried. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z) * @param {...Function} functions * @return {Function} * @see R.compose * @example * * const f = R.pipe(Math.pow, R.negate, R.inc); * * f(3, 4); // -(3^4) + 1 * @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b))) */ function pipe() { if (arguments.length === 0) { throw new Error('pipe requires at least one argument'); } return _arity( arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)) ); } /** * Returns a new list or string with the elements or characters in reverse * order. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig [a] -> [a] * @sig String -> String * @param {Array|String} list * @return {Array|String} * @example * * R.reverse([1, 2, 3]); //=> [3, 2, 1] * R.reverse([1, 2]); //=> [2, 1] * R.reverse([1]); //=> [1] * R.reverse([]); //=> [] * * R.reverse('abc'); //=> 'cba' * R.reverse('ab'); //=> 'ba' * R.reverse('a'); //=> 'a' * R.reverse(''); //=> '' */ var reverse = _curry1(function reverse(list) { return _isString(list) ? list.split('').reverse().join('') : Array.prototype.slice.call(list, 0).reverse(); }); /** * Performs right-to-left function composition. The last argument may have * any arity; the remaining arguments must be unary. * * **Note:** The result of compose is not automatically curried. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z) * @param {...Function} ...functions The functions to compose * @return {Function} * @see R.pipe * @example * * const classyGreeting = (firstName, lastName) => "The name's " + lastName + ", " + firstName + " " + lastName * const yellGreeting = R.compose(R.toUpper, classyGreeting); * yellGreeting('James', 'Bond'); //=> "THE NAME'S BOND, JAMES BOND" * * R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7 * * @symb R.compose(f, g, h)(a, b) = f(g(h(a, b))) */ function compose() { if (arguments.length === 0) { throw new Error('compose requires at least one argument'); } return pipe.apply(this, reverse(arguments)); } /** * Returns the right-to-left Kleisli composition of the provided functions, * each of which must return a value of a type supported by [`chain`](#chain). * * `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), f)`. * * @func * @memberOf R * @since v0.16.0 * @category Function * @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (a -> m z) * @param {...Function} ...functions The functions to compose * @return {Function} * @see R.pipeK * @deprecated since v0.26.0 * @example * * // get :: String -> Object -> Maybe * * const get = R.curry((propName, obj) => Maybe(obj[propName])) * * // getStateCode :: Maybe String -> Maybe String * const getStateCode = R.composeK( * R.compose(Maybe.of, R.toUpper), * get('state'), * get('address'), * get('user'), * ); * getStateCode({"user":{"address":{"state":"ny"}}}); //=> Maybe.Just("NY") * getStateCode({}); //=> Maybe.Nothing() * @symb R.composeK(f, g, h)(a) = R.chain(f, R.chain(g, h(a))) */ function composeK() { if (arguments.length === 0) { throw new Error('composeK requires at least one argument'); } var init = Array.prototype.slice.call(arguments); var last = init.pop(); return compose(compose.apply(this, map(chain, init)), last); } function _pipeP(f, g) { return function() { var ctx = this; return f.apply(ctx, arguments).then(function(x) { return g.call(ctx, x); }); }; } /** * Performs left-to-right composition of one or more Promise-returning * functions. The first argument may have any arity; the remaining arguments * must be unary. * * @func * @memberOf R * @since v0.10.0 * @category Function * @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z) * @param {...Function} functions * @return {Function} * @see R.composeP * @deprecated since v0.26.0 * @example * * // followersForUser :: String -> Promise [User] * const followersForUser = R.pipeP(db.getUserById, db.getFollowers); */ function pipeP() { if (arguments.length === 0) { throw new Error('pipeP requires at least one argument'); } return _arity( arguments[0].length, reduce(_pipeP, arguments[0], tail(arguments)) ); } /** * Performs right-to-left composition of one or more Promise-returning * functions. The last arguments may have any arity; the remaining * arguments must be unary. * * @func * @memberOf R * @since v0.10.0 * @category Function * @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z) * @param {...Function} functions The functions to compose * @return {Function} * @see R.pipeP * @deprecated since v0.26.0 * @example * * const db = { * users: { * JOE: { * name: 'Joe', * followers: ['STEVE', 'SUZY'] * } * } * } * * // We'll pretend to do a db lookup which returns a promise * const lookupUser = (userId) => Promise.resolve(db.users[userId]) * const lookupFollowers = (user) => Promise.resolve(user.followers) * lookupUser('JOE').then(lookupFollowers) * * // followersForUser :: String -> Promise [UserId] * const followersForUser = R.composeP(lookupFollowers, lookupUser); * followersForUser('JOE').then(followers => console.log('Followers:', followers)) * // Followers: ["STEVE","SUZY"] */ function composeP() { if (arguments.length === 0) { throw new Error('composeP requires at least one argument'); } return pipeP.apply(this, reverse(arguments)); } /** * Returns the first element of the given list or string. In some libraries * this function is named `first`. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig [a] -> a | Undefined * @sig String -> String * @param {Array|String} list * @return {*} * @see R.tail, R.init, R.last * @example * * R.head(['fi', 'fo', 'fum']); //=> 'fi' * R.head([]); //=> undefined * * R.head('abc'); //=> 'a' * R.head(''); //=> '' */ var head = nth(0); function _identity(x) { return x; } /** * A function that does nothing but return the parameter supplied to it. Good * as a default or placeholder function. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig a -> a * @param {*} x The value to return. * @return {*} The input value, `x`. * @example * * R.identity(1); //=> 1 * * const obj = {}; * R.identity(obj) === obj; //=> true * @symb R.identity(a) = a */ var identity = _curry1(_identity); /** * Performs left-to-right function composition using transforming function. The first argument may have * any arity; the remaining arguments must be unary. * * **Note:** The result of pipeWith is not automatically curried. Transforming function is not used on the * first argument. * * @func * @memberOf R * @since v0.26.0 * @category Function * @sig ((* -> *), [((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)]) -> ((a, b, ..., n) -> z) * @param {...Function} functions * @return {Function} * @see R.composeWith, R.pipe * @example * * const pipeWhileNotNil = R.pipeWith((f, res) => R.isNil(res) ? res : f(res)); * const f = pipeWhileNotNil([Math.pow, R.negate, R.inc]) * * f(3, 4); // -(3^4) + 1 * @symb R.pipeWith(f)([g, h, i])(...args) = f(i, f(h, g(...args))) */ var pipeWith = _curry2(function pipeWith(xf, list) { if (list.length <= 0) { return identity; } var headList = head(list); var tailList = tail(list); return _arity(headList.length, function() { return _reduce( function(result, f) { return xf.call(this, f, result); }, headList.apply(this, arguments), tailList ); }); }); /** * Performs right-to-left function composition using transforming function. The last argument may have * any arity; the remaining arguments must be unary. * * **Note:** The result of compose is not automatically curried. Transforming function is not used on the * last argument. * * @func * @memberOf R * @since v0.26.0 * @category Function * @sig ((* -> *), [(y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)]) -> ((a, b, ..., n) -> z) * @param {...Function} ...functions The functions to compose * @return {Function} * @see R.compose, R.pipeWith * @example * * const composeWhileNotNil = R.composeWith((f, res) => R.isNil(res) ? res : f(res)); * * composeWhileNotNil([R.inc, R.prop('age')])({age: 1}) //=> 2 * composeWhileNotNil([R.inc, R.prop('age')])({}) //=> undefined * * @symb R.composeWith(f)([g, h, i])(...args) = f(g, f(h, i(...args))) */ var composeWith = _curry2(function composeWith(xf, list) { return pipeWith.apply(this, [xf, reverse(list)]); }); function _arrayFromIterator(iter) { var list = []; var next; while (!(next = iter.next()).done) { list.push(next.value); } return list; } function _includesWith(pred, x, list) { var idx = 0; var len = list.length; while (idx < len) { if (pred(x, list[idx])) { return true; } idx += 1; } return false; } function _functionName(f) { // String(x => x) evaluates to "x => x", so the pattern may not match. var match = String(f).match(/^function (\w*)/); return match == null ? '' : match[1]; } // Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is function _objectIs(a, b) { // SameValue algorithm if (a === b) { // Steps 1-5, 7-10 // Steps 6.b-6.e: +0 != -0 return a !== 0 || 1 / a === 1 / b; } else { // Step 6.a: NaN == NaN return a !== a && b !== b; } } var _objectIs$1 = typeof Object.is === 'function' ? Object.is : _objectIs; /** * private _uniqContentEquals function. * That function is checking equality of 2 iterator contents with 2 assumptions * - iterators lengths are the same * - iterators values are unique * * false-positive result will be returned for comparision of, e.g. * - [1,2,3] and [1,2,3,4] * - [1,1,1] and [1,2,3] * */ function _uniqContentEquals(aIterator, bIterator, stackA, stackB) { var a = _arrayFromIterator(aIterator); var b = _arrayFromIterator(bIterator); function eq(_a, _b) { return _equals(_a, _b, stackA.slice(), stackB.slice()); } // if *a* array contains any element that is not included in *b* return !_includesWith(function(b, aItem) { return !_includesWith(eq, aItem, b); }, b, a); } function _equals(a, b, stackA, stackB) { if (_objectIs$1(a, b)) { return true; } var typeA = type(a); if (typeA !== type(b)) { return false; } if (a == null || b == null) { return false; } if (typeof a['fantasy-land/equals'] === 'function' || typeof b['fantasy-land/equals'] === 'function') { return typeof a['fantasy-land/equals'] === 'function' && a['fantasy-land/equals'](b) && typeof b['fantasy-land/equals'] === 'function' && b['fantasy-land/equals'](a); } if (typeof a.equals === 'function' || typeof b.equals === 'function') { return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a); } switch (typeA) { case 'Arguments': case 'Array': case 'Object': if (typeof a.constructor === 'function' && _functionName(a.constructor) === 'Promise') { return a === b; } break; case 'Boolean': case 'Number': case 'String': if (!(typeof a === typeof b && _objectIs$1(a.valueOf(), b.valueOf()))) { return false; } break; case 'Date': if (!_objectIs$1(a.valueOf(), b.valueOf())) { return false; } break; case 'Error': return a.name === b.name && a.message === b.message; case 'RegExp': if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) { return false; } break; } var idx = stackA.length - 1; while (idx >= 0) { if (stackA[idx] === a) { return stackB[idx] === b; } idx -= 1; } switch (typeA) { case 'Map': if (a.size !== b.size) { return false; } return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b])); case 'Set': if (a.size !== b.size) { return false; } return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b])); case 'Arguments': case 'Array': case 'Object': case 'Boolean': case 'Number': case 'String': case 'Date': case 'Error': case 'RegExp': case 'Int8Array': case 'Uint8Array': case 'Uint8ClampedArray': case 'Int16Array': case 'Uint16Array': case 'Int32Array': case 'Uint32Array': case 'Float32Array': case 'Float64Array': case 'ArrayBuffer': break; default: // Values of other types are only equal if identical. return false; } var keysA = keys(a); if (keysA.length !== keys(b).length) { return false; } var extendedStackA = stackA.concat([a]); var extendedStackB = stackB.concat([b]); idx = keysA.length - 1; while (idx >= 0) { var key = keysA[idx]; if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) { return false; } idx -= 1; } return true; } /** * Returns `true` if its arguments are equivalent, `false` otherwise. Handles * cyclical data structures. * * Dispatches symmetrically to the `equals` methods of both arguments, if * present. * * @func * @memberOf R * @since v0.15.0 * @category Relation * @sig a -> b -> Boolean * @param {*} a * @param {*} b * @return {Boolean} * @example * * R.equals(1, 1); //=> true * R.equals(1, '1'); //=> false * R.equals([1, 2, 3], [1, 2, 3]); //=> true * * const a = {}; a.v = a; * const b = {}; b.v = b; * R.equals(a, b); //=> true */ var equals = _curry2(function equals(a, b) { return _equals(a, b, [], []); }); function _indexOf(list, a, idx) { var inf, item; // Array.prototype.indexOf doesn't exist below IE9 if (typeof list.indexOf === 'function') { switch (typeof a) { case 'number': if (a === 0) { // manually crawl the list to distinguish between +0 and -0 inf = 1 / a; while (idx < list.length) { item = list[idx]; if (item === 0 && 1 / item === inf) { return idx; } idx += 1; } return -1; } else if (a !== a) { // NaN while (idx < list.length) { item = list[idx]; if (typeof item === 'number' && item !== item) { return idx; } idx += 1; } return -1; } // non-zero numbers can utilise Set return list.indexOf(a, idx); // all these types can utilise Set case 'string': case 'boolean': case 'function': case 'undefined': return list.indexOf(a, idx); case 'object': if (a === null) { // null can utilise Set return list.indexOf(a, idx); } } } // anything else not covered above, defer to R.equals while (idx < list.length) { if (equals(list[idx], a)) { return idx; } idx += 1; } return -1; } function _includes(a, list) { return _indexOf(list, a, 0) >= 0; } function _quote(s) { var escaped = s .replace(/\\/g, '\\\\') .replace(/[\b]/g, '\\b') // \b matches word boundary; [\b] matches backspace .replace(/\f/g, '\\f') .replace(/\n/g, '\\n') .replace(/\r/g, '\\r') .replace(/\t/g, '\\t') .replace(/\v/g, '\\v') .replace(/\0/g, '\\0'); return '"' + escaped.replace(/"/g, '\\"') + '"'; } /** * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>. */ var pad = function pad(n) { return (n < 10 ? '0' : '') + n; }; var _toISOString = typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) { return d.toISOString(); } : function _toISOString(d) { return ( d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z' ); }; function _complement(f) { return function() { return !f.apply(this, arguments); }; } function _filter(fn, list) { var idx = 0; var len = list.length; var result = []; while (idx < len) { if (fn(list[idx])) { result[result.length] = list[idx]; } idx += 1; } return result; } function _isObject(x) { return Object.prototype.toString.call(x) === '[object Object]'; } function XFilter(f, xf) { this.xf = xf; this.f = f; } XFilter.prototype['@@transducer/init'] = _xfBase.init; XFilter.prototype['@@transducer/result'] = _xfBase.result; XFilter.prototype['@@transducer/step'] = function(result, input) { return this.f(input) ? this.xf['@@transducer/step'](result, input) : result; }; var _xfilter = _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); }); /** * Takes a predicate and a `Filterable`, and returns a new filterable of the * same type containing the members of the given filterable which satisfy the * given predicate. Filterable objects include plain objects or any object * that has a filter method such as `Array`. * * Dispatches to the `filter` method of the second argument, if present. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig Filterable f => (a -> Boolean) -> f a -> f a * @param {Function} pred * @param {Array} filterable * @return {Array} Filterable * @see R.reject, R.transduce, R.addIndex * @example * * const isEven = n => n % 2 === 0; * * R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4] * * R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4} */ var filter = _curry2(_dispatchable(['filter'], _xfilter, function(pred, filterable) { return ( _isObject(filterable) ? _reduce(function(acc, key) { if (pred(filterable[key])) { acc[key] = filterable[key]; } return acc; }, {}, keys(filterable)) : // else _filter(pred, filterable) ); })); /** * The complement of [`filter`](#filter). * * Acts as a transducer if a transformer is given in list position. Filterable * objects include plain objects or any object that has a filter method such * as `Array`. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig Filterable f => (a -> Boolean) -> f a -> f a * @param {Function} pred * @param {Array} filterable * @return {Array} * @see R.filter, R.transduce, R.addIndex * @example * * const isOdd = (n) => n % 2 === 1; * * R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4] * * R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4} */ var reject = _curry2(function reject(pred, filterable) { return filter(_complement(pred), filterable); }); function _toString(x, seen) { var recur = function recur(y) { var xs = seen.concat([x]); return _includes(y, xs) ? '<Circular>' : _toString(y, xs); }; // mapPairs :: (Object, [String]) -> [String] var mapPairs = function(obj, keys$$1) { return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys$$1.slice().sort()); }; switch (Object.prototype.toString.call(x)) { case '[object Arguments]': return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))'; case '[object Array]': return '[' + _map(recur, x).concat(mapPairs(x, reject(function(k) { return /^\d+$/.test(k); }, keys(x)))).join(', ') + ']'; case '[object Boolean]': return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString(); case '[object Date]': return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')'; case '[object Null]': return 'null'; case '[object Number]': return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10); case '[object String]': return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x); case '[object Undefined]': return 'undefined'; default: if (typeof x.toString === 'function') { var repr = x.toString(); if (repr !== '[object Object]') { return repr; } } return '{' + mapPairs(x, keys(x)).join(', ') + '}'; } } /** * Returns the string representation of the given value. `eval`'ing the output * should result in a value equivalent to the input value. Many of the built-in * `toString` methods do not satisfy this requirement. * * If the given value is an `[object Object]` with a `toString` method other * than `Object.prototype.toString`, this method is invoked with no arguments * to produce the return value. This means user-defined constructor functions * can provide a suitable `toString` method. For example: * * function Point(x, y) { * this.x = x; * this.y = y; * } * * Point.prototype.toString = function() { * return 'new Point(' + this.x + ', ' + this.y + ')'; * }; * * R.toString(new Point(1, 2)); //=> 'new Point(1, 2)' * * @func * @memberOf R * @since v0.14.0 * @category String * @sig * -> String * @param {*} val * @return {String} * @example * * R.toString(42); //=> '42' * R.toString('abc'); //=> '"abc"' * R.toString([1, 2, 3]); //=> '[1, 2, 3]' * R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}' * R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")' */ var toString$1 = _curry1(function toString(val) { return _toString(val, []); }); /** * Returns the result of concatenating the given lists or strings. * * Note: `R.concat` expects both arguments to be of the same type, * unlike the native `Array.prototype.concat` method. It will throw * an error if you `concat` an Array with a non-Array value. * * Dispatches to the `concat` method of the first argument, if present. * Can also concatenate two members of a [fantasy-land * compatible semigroup](https://github.com/fantasyland/fantasy-land#semigroup). * * @func * @memberOf R * @since v0.1.0 * @category List * @sig [a] -> [a] -> [a] * @sig String -> String -> String * @param {Array|String} firstList The first list * @param {Array|String} secondList The second list * @return {Array|String} A list consisting of the elements of `firstList` followed by the elements of * `secondList`. * * @example * * R.concat('ABC', 'DEF'); // 'ABCDEF' * R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3] * R.concat([], []); //=> [] */ var concat = _curry2(function concat(a, b) { if (_isArray(a)) { if (_isArray(b)) { return a.concat(b); } throw new TypeError(toString$1(b) + ' is not an array'); } if (_isString(a)) { if (_isString(b)) { return a + b; } throw new TypeError(toString$1(b) + ' is not a string'); } if (a != null && _isFunction(a['fantasy-land/concat'])) { return a['fantasy-land/concat'](b); } if (a != null && _isFunction(a.concat)) { return a.concat(b); } throw new TypeError(toString$1(a) + ' does not have a method named "concat" or "fantasy-land/concat"'); }); /** * Returns a function, `fn`, which encapsulates `if/else, if/else, ...` logic. * `R.cond` takes a list of [predicate, transformer] pairs. All of the arguments * to `fn` are applied to each of the predicates in turn until one returns a * "truthy" value, at which point `fn` returns the result of applying its * arguments to the corresponding transformer. If none of the predicates * matches, `fn` returns undefined. * * @func * @memberOf R * @since v0.6.0 * @category Logic * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *) * @param {Array} pairs A list of [predicate, transformer] * @return {Function} * @see R.ifElse, R.unless, R.when * @example * * const fn = R.cond([ * [R.equals(0), R.always('water freezes at 0°C')], * [R.equals(100), R.always('water boils at 100°C')], * [R.T, temp => 'nothing special happens at ' + temp + '°C'] * ]); * fn(0); //=> 'water freezes at 0°C' * fn(50); //=> 'nothing special happens at 50°C' * fn(100); //=> 'water boils at 100°C' */ var cond = _curry1(function cond(pairs) { var arity = reduce( max, 0, map(function(pair) { return pair[0].length; }, pairs) ); return _arity(arity, function() { var idx = 0; while (idx < pairs.length) { if (pairs[idx][0].apply(this, arguments)) { return pairs[idx][1].apply(this, arguments); } idx += 1; } }); }); /** * Wraps a constructor function inside a curried function that can be called * with the same arguments and returns the same type. The arity of the function * returned is specified to allow using variadic constructor functions. * * @func * @memberOf R * @since v0.4.0 * @category Function * @sig Number -> (* -> {*}) -> (* -> {*}) * @param {Number} n The arity of the constructor function. * @param {Function} Fn The constructor function to wrap. * @return {Function} A wrapped, curried constructor function. * @example * * // Variadic Constructor function * function Salad() { * this.ingredients = arguments; * } * * Salad.prototype.recipe = function() { * const instructions = R.map(ingredient => 'Add a dollop of ' + ingredient, this.ingredients); * return R.join('\n', instructions); * }; * * const ThreeLayerSalad = R.constructN(3, Salad); * * // Notice we no longer need the 'new' keyword, and the constructor is curried for 3 arguments. * const salad = ThreeLayerSalad('Mayonnaise')('Potato Chips')('Ketchup'); * * console.log(salad.recipe()); * // Add a dollop of Mayonnaise * // Add a dollop of Potato Chips * // Add a dollop of Ketchup */ var constructN = _curry2(function constructN(n, Fn) { if (n > 10) { throw new Error('Constructor with greater than ten arguments'); } if (n === 0) { return function() { return new Fn(); }; } return curry(nAry(n, function($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) { switch (arguments.length) { case 1: return new Fn($0); case 2: return new Fn($0, $1); case 3: return new Fn($0, $1, $2); case 4: return new Fn($0, $1, $2, $3); case 5: return new Fn($0, $1, $2, $3, $4); case 6: return new Fn($0, $1, $2, $3, $4, $5); case 7: return new Fn($0, $1, $2, $3, $4, $5, $6); case 8: return new Fn($0, $1, $2, $3, $4, $5, $6, $7); case 9: return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8); case 10: return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9); } })); }); /** * Wraps a constructor function inside a curried function that can be called * with the same arguments and returns the same type. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig (* -> {*}) -> (* -> {*}) * @param {Function} fn The constructor function to wrap. * @return {Function} A wrapped, curried constructor function. * @see R.invoker * @example * * // Constructor function * function Animal(kind) { * this.kind = kind; * }; * Animal.prototype.sighting = function() { * return "It's a " + this.kind + "!"; * } * * const AnimalConstructor = R.construct(Animal) * * // Notice we no longer need the 'new' keyword: * AnimalConstructor('Pig'); //=> {"kind": "Pig", "sighting": function (){...}}; * * const animalTypes = ["Lion", "Tiger", "Bear"]; * const animalSighting = R.invoker(0, 'sighting'); * const sightNewAnimal = R.compose(animalSighting, AnimalConstructor); * R.map(sightNewAnimal, animalTypes); //=> ["It's a Lion!", "It's a Tiger!", "It's a Bear!"] */ var construct = _curry1(function construct(Fn) { return constructN(Fn.length, Fn); }); /** * Returns `true` if the specified value is equal, in [`R.equals`](#equals) * terms, to at least one element of the given list; `false` otherwise. * Works also with strings. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig a -> [a] -> Boolean * @param {Object} a The item to compare against. * @param {Array} list The array to consider. * @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise. * @see R.includes * @deprecated since v0.26.0 * @example * * R.contains(3, [1, 2, 3]); //=> true * R.contains(4, [1, 2, 3]); //=> false * R.contains({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true * R.contains([42], [[42]]); //=> true * R.contains('ba', 'banana'); //=>true */ var contains$1 = _curry2(_includes); /** * Accepts a converging function and a list of branching functions and returns * a new function. The arity of the new function is the same as the arity of * the longest branching function. When invoked, this new function is applied * to some arguments, and each branching function is applied to those same * arguments. The results of each branching function are passed as arguments * to the converging function to produce the return value. * * @func * @memberOf R * @since v0.4.2 * @category Function * @sig ((x1, x2, ...) -> z) -> [((a, b, ...) -> x1), ((a, b, ...) -> x2), ...] -> (a -> b -> ... -> z) * @param {Function} after A function. `after` will be invoked with the return values of * `fn1` and `fn2` as its arguments. * @param {Array} functions A list of functions. * @return {Function} A new function. * @see R.useWith * @example * * const average = R.converge(R.divide, [R.sum, R.length]) * average([1, 2, 3, 4, 5, 6, 7]) //=> 4 * * const strangeConcat = R.converge(R.concat, [R.toUpper, R.toLower]) * strangeConcat("Yodel") //=> "YODELyodel" * * @symb R.converge(f, [g, h])(a, b) = f(g(a, b), h(a, b)) */ var converge = _curry2(function converge(after, fns) { return curryN(reduce(max, 0, pluck('length', fns)), function() { var args = arguments; var context = this; return after.apply(context, _map(function(fn) { return fn.apply(context, args); }, fns)); }); }); function XReduceBy(valueFn, valueAcc, keyFn, xf) { this.valueFn = valueFn; this.valueAcc = valueAcc; this.keyFn = keyFn; this.xf = xf; this.inputs = {}; } XReduceBy.prototype['@@transducer/init'] = _xfBase.init; XReduceBy.prototype['@@transducer/result'] = function(result) { var key; for (key in this.inputs) { if (_has(key, this.inputs)) { result = this.xf['@@transducer/step'](result, this.inputs[key]); if (result['@@transducer/reduced']) { result = result['@@transducer/value']; break; } } } this.inputs = null; return this.xf['@@transducer/result'](result); }; XReduceBy.prototype['@@transducer/step'] = function(result, input) { var key = this.keyFn(input); this.inputs[key] = this.inputs[key] || [key, this.valueAcc]; this.inputs[key][1] = this.valueFn(this.inputs[key][1], input); return result; }; var _xreduceBy = _curryN(4, [], function _xreduceBy(valueFn, valueAcc, keyFn, xf) { return new XReduceBy(valueFn, valueAcc, keyFn, xf); } ); /** * Groups the elements of the list according to the result of calling * the String-returning function `keyFn` on each element and reduces the elements * of each group to a single value via the reducer function `valueFn`. * * This function is basically a more general [`groupBy`](#groupBy) function. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.20.0 * @category List * @sig ((a, b) -> a) -> a -> (b -> String) -> [b] -> {String: a} * @param {Function} valueFn The function that reduces the elements of each group to a single * value. Receives two values, accumulator for a particular group and the current element. * @param {*} acc The (initial) accumulator value for each group. * @param {Function} keyFn The function that maps the list's element into a key. * @param {Array} list The array to group. * @return {Object} An object with the output of `keyFn` for keys, mapped to the output of * `valueFn` for elements which produced that key when passed to `keyFn`. * @see R.groupBy, R.reduce * @example * * const groupNames = (acc, {name}) => acc.concat(name) * const toGrade = ({score}) => * score < 65 ? 'F' : * score < 70 ? 'D' : * score < 80 ? 'C' : * score < 90 ? 'B' : 'A' * * var students = [ * {name: 'Abby', score: 83}, * {name: 'Bart', score: 62}, * {name: 'Curt', score: 88}, * {name: 'Dora', score: 92}, * ] * * reduceBy(groupNames, [], toGrade, students) * //=> {"A": ["Dora"], "B": ["Abby", "Curt"], "F": ["Bart"]} */ var reduceBy = _curryN(4, [], _dispatchable([], _xreduceBy, function reduceBy(valueFn, valueAcc, keyFn, list) { return _reduce(function(acc, elt) { var key = keyFn(elt); acc[key] = valueFn(_has(key, acc) ? acc[key] : _clone(valueAcc, [], [], false), elt); return acc; }, {}, list); })); /** * Counts the elements of a list according to how many match each value of a * key generated by the supplied function. Returns an object mapping the keys * produced by `fn` to the number of occurrences in the list. Note that all * keys are coerced to strings because of how JavaScript objects work. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig (a -> String) -> [a] -> {*} * @param {Function} fn The function used to map values to keys. * @param {Array} list The list to count elements from. * @return {Object} An object mapping keys to number of occurrences in the list. * @example * * const numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2]; * R.countBy(Math.floor)(numbers); //=> {'1': 3, '2': 2, '3': 1} * * const letters = ['a', 'b', 'A', 'a', 'B', 'c']; * R.countBy(R.toLower)(letters); //=> {'a': 3, 'b': 2, 'c': 1} */ var countBy = reduceBy(function(acc, elem) { return acc + 1; }, 0); /** * Decrements its argument. * * @func * @memberOf R * @since v0.9.0 * @category Math * @sig Number -> Number * @param {Number} n * @return {Number} n - 1 * @see R.inc * @example * * R.dec(42); //=> 41 */ var dec = add(-1); /** * Returns the second argument if it is not `null`, `undefined` or `NaN`; * otherwise the first argument is returned. * * @func * @memberOf R * @since v0.10.0 * @category Logic * @sig a -> b -> a | b * @param {a} default The default value. * @param {b} val `val` will be returned instead of `default` unless `val` is `null`, `undefined` or `NaN`. * @return {*} The second value if it is not `null`, `undefined` or `NaN`, otherwise the default value * @example * * const defaultTo42 = R.defaultTo(42); * * defaultTo42(null); //=> 42 * defaultTo42(undefined); //=> 42 * defaultTo42(false); //=> false * defaultTo42('Ramda'); //=> 'Ramda' * // parseInt('string') results in NaN * defaultTo42(parseInt('string')); //=> 42 */ var defaultTo = _curry2(function defaultTo(d, v) { return v == null || v !== v ? d : v; }); /** * Makes a descending comparator function out of a function that returns a value * that can be compared with `<` and `>`. * * @func * @memberOf R * @since v0.23.0 * @category Function * @sig Ord b => (a -> b) -> a -> a -> Number * @param {Function} fn A function of arity one that returns a value that can be compared * @param {*} a The first item to be compared. * @param {*} b The second item to be compared. * @return {Number} `-1` if fn(a) > fn(b), `1` if fn(b) > fn(a), otherwise `0` * @see R.ascend * @example * * const byAge = R.descend(R.prop('age')); * const people = [ * { name: 'Emma', age: 70 }, * { name: 'Peter', age: 78 }, * { name: 'Mikhail', age: 62 }, * ]; * const peopleByOldestFirst = R.sort(byAge, people); * //=> [{ name: 'Peter', age: 78 }, { name: 'Emma', age: 70 }, { name: 'Mikhail', age: 62 }] */ var descend = _curry3(function descend(fn, a, b) { var aa = fn(a); var bb = fn(b); return aa > bb ? -1 : aa < bb ? 1 : 0; }); function _Set() { /* globals Set */ this._nativeSet = typeof Set === 'function' ? new Set() : null; this._items = {}; } // until we figure out why jsdoc chokes on this // @param item The item to add to the Set // @returns {boolean} true if the item did not exist prior, otherwise false // _Set.prototype.add = function(item) { return !hasOrAdd(item, true, this); }; // // @param item The item to check for existence in the Set // @returns {boolean} true if the item exists in the Set, otherwise false // _Set.prototype.has = function(item) { return hasOrAdd(item, false, this); }; // // Combines the logic for checking whether an item is a member of the set and // for adding a new item to the set. // // @param item The item to check or add to the Set instance. // @param shouldAdd If true, the item will be added to the set if it doesn't // already exist. // @param set The set instance to check or add to. // @return {boolean} true if the item already existed, otherwise false. // function hasOrAdd(item, shouldAdd, set) { var type = typeof item; var prevSize, newSize; switch (type) { case 'string': case 'number': // distinguish between +0 and -0 if (item === 0 && 1 / item === -Infinity) { if (set._items['-0']) { return true; } else { if (shouldAdd) { set._items['-0'] = true; } return false; } } // these types can all utilise the native Set if (set._nativeSet !== null) { if (shouldAdd) { prevSize = set._nativeSet.size; set._nativeSet.add(item); newSize = set._nativeSet.size; return newSize === prevSize; } else { return set._nativeSet.has(item); } } else { if (!(type in set._items)) { if (shouldAdd) { set._items[type] = {}; set._items[type][item] = true; } return false; } else if (item in set._items[type]) { return true; } else { if (shouldAdd) { set._items[type][item] = true; } return false; } } case 'boolean': // set._items['boolean'] holds a two element array // representing [ falseExists, trueExists ] if (type in set._items) { var bIdx = item ? 1 : 0; if (set._items[type][bIdx]) { return true; } else { if (shouldAdd) { set._items[type][bIdx] = true; } return false; } } else { if (shouldAdd) { set._items[type] = item ? [false, true] : [true, false]; } return false; } case 'function': // compare functions for reference equality if (set._nativeSet !== null) { if (shouldAdd) { prevSize = set._nativeSet.size; set._nativeSet.add(item); newSize = set._nativeSet.size; return newSize === prevSize; } else { return set._nativeSet.has(item); } } else { if (!(type in set._items)) { if (shouldAdd) { set._items[type] = [item]; } return false; } if (!_includes(item, set._items[type])) { if (shouldAdd) { set._items[type].push(item); } return false; } return true; } case 'undefined': if (set._items[type]) { return true; } else { if (shouldAdd) { set._items[type] = true; } return false; } case 'object': if (item === null) { if (!set._items['null']) { if (shouldAdd) { set._items['null'] = true; } return false; } return true; } /* falls through */ default: // reduce the search size of heterogeneous sets by creating buckets // for each type. type = Object.prototype.toString.call(item); if (!(type in set._items)) { if (shouldAdd) { set._items[type] = [item]; } return false; } // scan through all previously applied items if (!_includes(item, set._items[type])) { if (shouldAdd) { set._items[type].push(item); } return false; } return true; } } /** * Finds the set (i.e. no duplicates) of all elements in the first list not * contained in the second list. Objects and Arrays are compared in terms of * value equality, not reference equality. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig [*] -> [*] -> [*] * @param {Array} list1 The first list. * @param {Array} list2 The second list. * @return {Array} The elements in `list1` that are not in `list2`. * @see R.differenceWith, R.symmetricDifference, R.symmetricDifferenceWith, R.without * @example * * R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2] * R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5] * R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}] */ var difference = _curry2(function difference(first, second) { var out = []; var idx = 0; var firstLen = first.length; var secondLen = second.length; var toFilterOut = new _Set(); for (var i = 0; i < secondLen; i += 1) { toFilterOut.add(second[i]); } while (idx < firstLen) { if (toFilterOut.add(first[idx])) { out[out.length] = first[idx]; } idx += 1; } return out; }); /** * Finds the set (i.e. no duplicates) of all elements in the first list not * contained in the second list. Duplication is determined according to the * value returned by applying the supplied predicate to two list elements. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a] * @param {Function} pred A predicate used to test whether two items are equal. * @param {Array} list1 The first list. * @param {Array} list2 The second list. * @return {Array} The elements in `list1` that are not in `list2`. * @see R.difference, R.symmetricDifference, R.symmetricDifferenceWith * @example * * const cmp = (x, y) => x.a === y.a; * const l1 = [{a: 1}, {a: 2}, {a: 3}]; * const l2 = [{a: 3}, {a: 4}]; * R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}] */ var differenceWith = _curry3(function differenceWith(pred, first, second) { var out = []; var idx = 0; var firstLen = first.length; while (idx < firstLen) { if (!_includesWith(pred, first[idx], second) && !_includesWith(pred, first[idx], out)) { out.push(first[idx]); } idx += 1; } return out; }); /** * Returns a new object that does not contain a `prop` property. * * @func * @memberOf R * @since v0.10.0 * @category Object * @sig String -> {k: v} -> {k: v} * @param {String} prop The name of the property to dissociate * @param {Object} obj The object to clone * @return {Object} A new object equivalent to the original but without the specified property * @see R.assoc, R.omit * @example * * R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3} */ var dissoc = _curry2(function dissoc(prop, obj) { var result = {}; for (var p in obj) { result[p] = obj[p]; } delete result[prop]; return result; }); /** * Removes the sub-list of `list` starting at index `start` and containing * `count` elements. _Note that this is not destructive_: it returns a copy of * the list with the changes. * <small>No lists have been harmed in the application of this function.</small> * * @func * @memberOf R * @since v0.2.2 * @category List * @sig Number -> Number -> [a] -> [a] * @param {Number} start The position to start removing elements * @param {Number} count The number of elements to remove * @param {Array} list The list to remove from * @return {Array} A new Array with `count` elements from `start` removed. * @see R.without * @example * * R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8] */ var remove = _curry3(function remove(start, count, list) { var result = Array.prototype.slice.call(list, 0); result.splice(start, count); return result; }); /** * Returns a new copy of the array with the element at the provided index * replaced with the given value. * * @func * @memberOf R * @since v0.14.0 * @category List * @sig Number -> a -> [a] -> [a] * @param {Number} idx The index to update. * @param {*} x The value to exist at the given index of the returned array. * @param {Array|Arguments} list The source array-like object to be updated. * @return {Array} A copy of `list` with the value at index `idx` replaced with `x`. * @see R.adjust * @example * * R.update(1, '_', ['a', 'b', 'c']); //=> ['a', '_', 'c'] * R.update(-1, '_', ['a', 'b', 'c']); //=> ['a', 'b', '_'] * @symb R.update(-1, a, [b, c]) = [b, a] * @symb R.update(0, a, [b, c]) = [a, c] * @symb R.update(1, a, [b, c]) = [b, a] */ var update = _curry3(function update(idx, x, list) { return adjust(idx, always(x), list); }); /** * Makes a shallow clone of an object, omitting the property at the given path. * Note that this copies and flattens prototype properties onto the new object * as well. All non-primitive properties are copied by reference. * * @func * @memberOf R * @since v0.11.0 * @category Object * @typedefn Idx = String | Int * @sig [Idx] -> {k: v} -> {k: v} * @param {Array} path The path to the value to omit * @param {Object} obj The object to clone * @return {Object} A new object without the property at path * @see R.assocPath * @example * * R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}} */ var dissocPath = _curry2(function dissocPath(path, obj) { switch (path.length) { case 0: return obj; case 1: return _isInteger(path[0]) && _isArray(obj) ? remove(path[0], 1, obj) : dissoc(path[0], obj); default: var head = path[0]; var tail = Array.prototype.slice.call(path, 1); if (obj[head] == null) { return obj; } else if (_isInteger(head) && _isArray(obj)) { return update(head, dissocPath(tail, obj[head]), obj); } else { return assoc(head, dissocPath(tail, obj[head]), obj); } } }); /** * Divides two numbers. Equivalent to `a / b`. * * @func * @memberOf R * @since v0.1.0 * @category Math * @sig Number -> Number -> Number * @param {Number} a The first value. * @param {Number} b The second value. * @return {Number} The result of `a / b`. * @see R.multiply * @example * * R.divide(71, 100); //=> 0.71 * * const half = R.divide(R.__, 2); * half(42); //=> 21 * * const reciprocal = R.divide(1); * reciprocal(4); //=> 0.25 */ var divide = _curry2(function divide(a, b) { return a / b; }); function XDrop(n, xf) { this.xf = xf; this.n = n; } XDrop.prototype['@@transducer/init'] = _xfBase.init; XDrop.prototype['@@transducer/result'] = _xfBase.result; XDrop.prototype['@@transducer/step'] = function(result, input) { if (this.n > 0) { this.n -= 1; return result; } return this.xf['@@transducer/step'](result, input); }; var _xdrop = _curry2(function _xdrop(n, xf) { return new XDrop(n, xf); }); /** * Returns all but the first `n` elements of the given list, string, or * transducer/transformer (or object with a `drop` method). * * Dispatches to the `drop` method of the second argument, if present. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig Number -> [a] -> [a] * @sig Number -> String -> String * @param {Number} n * @param {*} list * @return {*} A copy of list without the first `n` elements * @see R.take, R.transduce, R.dropLast, R.dropWhile * @example * * R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz'] * R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz'] * R.drop(3, ['foo', 'bar', 'baz']); //=> [] * R.drop(4, ['foo', 'bar', 'baz']); //=> [] * R.drop(3, 'ramda'); //=> 'da' */ var drop = _curry2(_dispatchable(['drop'], _xdrop, function drop(n, xs) { return slice(Math.max(0, n), Infinity, xs); })); function XTake(n, xf) { this.xf = xf; this.n = n; this.i = 0; } XTake.prototype['@@transducer/init'] = _xfBase.init; XTake.prototype['@@transducer/result'] = _xfBase.result; XTake.prototype['@@transducer/step'] = function(result, input) { this.i += 1; var ret = this.n === 0 ? result : this.xf['@@transducer/step'](result, input); return this.n >= 0 && this.i >= this.n ? _reduced(ret) : ret; }; var _xtake = _curry2(function _xtake(n, xf) { return new XTake(n, xf); }); /** * Returns the first `n` elements of the given list, string, or * transducer/transformer (or object with a `take` method). * * Dispatches to the `take` method of the second argument, if present. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig Number -> [a] -> [a] * @sig Number -> String -> String * @param {Number} n * @param {*} list * @return {*} * @see R.drop * @example * * R.take(1, ['foo', 'bar', 'baz']); //=> ['foo'] * R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar'] * R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] * R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] * R.take(3, 'ramda'); //=> 'ram' * * const personnel = [ * 'Dave Brubeck', * 'Paul Desmond', * 'Eugene Wright', * 'Joe Morello', * 'Gerry Mulligan', * 'Bob Bates', * 'Joe Dodge', * 'Ron Crotty' * ]; * * const takeFive = R.take(5); * takeFive(personnel); * //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan'] * @symb R.take(-1, [a, b]) = [a, b] * @symb R.take(0, [a, b]) = [] * @symb R.take(1, [a, b]) = [a] * @symb R.take(2, [a, b]) = [a, b] */ var take = _curry2(_dispatchable(['take'], _xtake, function take(n, xs) { return slice(0, n < 0 ? Infinity : n, xs); })); function dropLast(n, xs) { return take(n < xs.length ? xs.length - n : 0, xs); } function XDropLast(n, xf) { this.xf = xf; this.pos = 0; this.full = false; this.acc = new Array(n); } XDropLast.prototype['@@transducer/init'] = _xfBase.init; XDropLast.prototype['@@transducer/result'] = function(result) { this.acc = null; return this.xf['@@transducer/result'](result); }; XDropLast.prototype['@@transducer/step'] = function(result, input) { if (this.full) { result = this.xf['@@transducer/step'](result, this.acc[this.pos]); } this.store(input); return result; }; XDropLast.prototype.store = function(input) { this.acc[this.pos] = input; this.pos += 1; if (this.pos === this.acc.length) { this.pos = 0; this.full = true; } }; var _xdropLast = _curry2(function _xdropLast(n, xf) { return new XDropLast(n, xf); }); /** * Returns a list containing all but the last `n` elements of the given `list`. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.16.0 * @category List * @sig Number -> [a] -> [a] * @sig Number -> String -> String * @param {Number} n The number of elements of `list` to skip. * @param {Array} list The list of elements to consider. * @return {Array} A copy of the list with only the first `list.length - n` elements * @see R.takeLast, R.drop, R.dropWhile, R.dropLastWhile * @example * * R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar'] * R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo'] * R.dropLast(3, ['foo', 'bar', 'baz']); //=> [] * R.dropLast(4, ['foo', 'bar', 'baz']); //=> [] * R.dropLast(3, 'ramda'); //=> 'ra' */ var dropLast$1 = _curry2(_dispatchable([], _xdropLast, dropLast)); function dropLastWhile(pred, xs) { var idx = xs.length - 1; while (idx >= 0 && pred(xs[idx])) { idx -= 1; } return slice(0, idx + 1, xs); } function XDropLastWhile(fn, xf) { this.f = fn; this.retained = []; this.xf = xf; } XDropLastWhile.prototype['@@transducer/init'] = _xfBase.init; XDropLastWhile.prototype['@@transducer/result'] = function(result) { this.retained = null; return this.xf['@@transducer/result'](result); }; XDropLastWhile.prototype['@@transducer/step'] = function(result, input) { return this.f(input) ? this.retain(result, input) : this.flush(result, input); }; XDropLastWhile.prototype.flush = function(result, input) { result = _reduce( this.xf['@@transducer/step'], result, this.retained ); this.retained = []; return this.xf['@@transducer/step'](result, input); }; XDropLastWhile.prototype.retain = function(result, input) { this.retained.push(input); return result; }; var _xdropLastWhile = _curry2(function _xdropLastWhile(fn, xf) { return new XDropLastWhile(fn, xf); }); /** * Returns a new list excluding all the tailing elements of a given list which * satisfy the supplied predicate function. It passes each value from the right * to the supplied predicate function, skipping elements until the predicate * function returns a `falsy` value. The predicate function is applied to one argument: * *(value)*. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.16.0 * @category List * @sig (a -> Boolean) -> [a] -> [a] * @sig (a -> Boolean) -> String -> String * @param {Function} predicate The function to be called on each element * @param {Array} xs The collection to iterate over. * @return {Array} A new array without any trailing elements that return `falsy` values from the `predicate`. * @see R.takeLastWhile, R.addIndex, R.drop, R.dropWhile * @example * * const lteThree = x => x <= 3; * * R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4] * * R.dropLastWhile(x => x !== 'd' , 'Ramda'); //=> 'Ramd' */ var dropLastWhile$1 = _curry2(_dispatchable([], _xdropLastWhile, dropLastWhile)); function XDropRepeatsWith(pred, xf) { this.xf = xf; this.pred = pred; this.lastValue = undefined; this.seenFirstValue = false; } XDropRepeatsWith.prototype['@@transducer/init'] = _xfBase.init; XDropRepeatsWith.prototype['@@transducer/result'] = _xfBase.result; XDropRepeatsWith.prototype['@@transducer/step'] = function(result, input) { var sameAsLast = false; if (!this.seenFirstValue) { this.seenFirstValue = true; } else if (this.pred(this.lastValue, input)) { sameAsLast = true; } this.lastValue = input; return sameAsLast ? result : this.xf['@@transducer/step'](result, input); }; var _xdropRepeatsWith = _curry2(function _xdropRepeatsWith(pred, xf) { return new XDropRepeatsWith(pred, xf); }); /** * Returns the last element of the given list or string. * * @func * @memberOf R * @since v0.1.4 * @category List * @sig [a] -> a | Undefined * @sig String -> String * @param {*} list * @return {*} * @see R.init, R.head, R.tail * @example * * R.last(['fi', 'fo', 'fum']); //=> 'fum' * R.last([]); //=> undefined * * R.last('abc'); //=> 'c' * R.last(''); //=> '' */ var last = nth(-1); /** * Returns a new list without any consecutively repeating elements. Equality is * determined by applying the supplied predicate to each pair of consecutive elements. The * first element in a series of equal elements will be preserved. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.14.0 * @category List * @sig ((a, a) -> Boolean) -> [a] -> [a] * @param {Function} pred A predicate used to test whether two items are equal. * @param {Array} list The array to consider. * @return {Array} `list` without repeating elements. * @see R.transduce * @example * * const l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3]; * R.dropRepeatsWith(R.eqBy(Math.abs), l); //=> [1, 3, 4, -5, 3] */ var dropRepeatsWith = _curry2(_dispatchable([], _xdropRepeatsWith, function dropRepeatsWith(pred, list) { var result = []; var idx = 1; var len = list.length; if (len !== 0) { result[0] = list[0]; while (idx < len) { if (!pred(last(result), list[idx])) { result[result.length] = list[idx]; } idx += 1; } } return result; })); /** * Returns a new list without any consecutively repeating elements. * [`R.equals`](#equals) is used to determine equality. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.14.0 * @category List * @sig [a] -> [a] * @param {Array} list The array to consider. * @return {Array} `list` without repeating elements. * @see R.transduce * @example * * R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2] */ var dropRepeats = _curry1( _dispatchable([], _xdropRepeatsWith(equals), dropRepeatsWith(equals)) ); function XDropWhile(f, xf) { this.xf = xf; this.f = f; } XDropWhile.prototype['@@transducer/init'] = _xfBase.init; XDropWhile.prototype['@@transducer/result'] = _xfBase.result; XDropWhile.prototype['@@transducer/step'] = function(result, input) { if (this.f) { if (this.f(input)) { return result; } this.f = null; } return this.xf['@@transducer/step'](result, input); }; var _xdropWhile = _curry2(function _xdropWhile(f, xf) { return new XDropWhile(f, xf); }); /** * Returns a new list excluding the leading elements of a given list which * satisfy the supplied predicate function. It passes each value to the supplied * predicate function, skipping elements while the predicate function returns * `true`. The predicate function is applied to one argument: *(value)*. * * Dispatches to the `dropWhile` method of the second argument, if present. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.9.0 * @category List * @sig (a -> Boolean) -> [a] -> [a] * @sig (a -> Boolean) -> String -> String * @param {Function} fn The function called per iteration. * @param {Array} xs The collection to iterate over. * @return {Array} A new array. * @see R.takeWhile, R.transduce, R.addIndex * @example * * const lteTwo = x => x <= 2; * * R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1] * * R.dropWhile(x => x !== 'd' , 'Ramda'); //=> 'da' */ var dropWhile = _curry2(_dispatchable(['dropWhile'], _xdropWhile, function dropWhile(pred, xs) { var idx = 0; var len = xs.length; while (idx < len && pred(xs[idx])) { idx += 1; } return slice(idx, Infinity, xs); })); /** * Returns `true` if one or both of its arguments are `true`. Returns `false` * if both arguments are `false`. * * @func * @memberOf R * @since v0.1.0 * @category Logic * @sig a -> b -> a | b * @param {Any} a * @param {Any} b * @return {Any} the first argument if truthy, otherwise the second argument. * @see R.either, R.xor * @example * * R.or(true, true); //=> true * R.or(true, false); //=> true * R.or(false, true); //=> true * R.or(false, false); //=> false */ var or = _curry2(function or(a, b) { return a || b; }); /** * A function wrapping calls to the two functions in an `||` operation, * returning the result of the first function if it is truth-y and the result * of the second function otherwise. Note that this is short-circuited, * meaning that the second function will not be invoked if the first returns a * truth-y value. * * In addition to functions, `R.either` also accepts any fantasy-land compatible * applicative functor. * * @func * @memberOf R * @since v0.12.0 * @category Logic * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean) * @param {Function} f a predicate * @param {Function} g another predicate * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together. * @see R.or * @example * * const gt10 = x => x > 10; * const even = x => x % 2 === 0; * const f = R.either(gt10, even); * f(101); //=> true * f(8); //=> true * * R.either(Maybe.Just(false), Maybe.Just(55)); // => Maybe.Just(55) * R.either([false, false, 'a'], [11]) // => [11, 11, "a"] */ var either = _curry2(function either(f, g) { return _isFunction(f) ? function _either() { return f.apply(this, arguments) || g.apply(this, arguments); } : lift(or)(f, g); }); /** * Returns the empty value of its argument's type. Ramda defines the empty * value of Array (`[]`), Object (`{}`), String (`''`), and Arguments. Other * types are supported if they define `<Type>.empty`, * `<Type>.prototype.empty` or implement the * [FantasyLand Monoid spec](https://github.com/fantasyland/fantasy-land#monoid). * * Dispatches to the `empty` method of the first argument, if present. * * @func * @memberOf R * @since v0.3.0 * @category Function * @sig a -> a * @param {*} x * @return {*} * @example * * R.empty(Just(42)); //=> Nothing() * R.empty([1, 2, 3]); //=> [] * R.empty('unicorns'); //=> '' * R.empty({x: 1, y: 2}); //=> {} */ var empty = _curry1(function empty(x) { return ( (x != null && typeof x['fantasy-land/empty'] === 'function') ? x['fantasy-land/empty']() : (x != null && x.constructor != null && typeof x.constructor['fantasy-land/empty'] === 'function') ? x.constructor['fantasy-land/empty']() : (x != null && typeof x.empty === 'function') ? x.empty() : (x != null && x.constructor != null && typeof x.constructor.empty === 'function') ? x.constructor.empty() : _isArray(x) ? [] : _isString(x) ? '' : _isObject(x) ? {} : _isArguments(x) ? (function() { return arguments; }()) : void 0 // else ); }); /** * Returns a new list containing the last `n` elements of the given list. * If `n > list.length`, returns a list of `list.length` elements. * * @func * @memberOf R * @since v0.16.0 * @category List * @sig Number -> [a] -> [a] * @sig Number -> String -> String * @param {Number} n The number of elements to return. * @param {Array} xs The collection to consider. * @return {Array} * @see R.dropLast * @example * * R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz'] * R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['bar', 'baz'] * R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] * R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz'] * R.takeLast(3, 'ramda'); //=> 'mda' */ var takeLast = _curry2(function takeLast(n, xs) { return drop(n >= 0 ? xs.length - n : 0, xs); }); /** * Checks if a list ends with the provided sublist. * * Similarly, checks if a string ends with the provided substring. * * @func * @memberOf R * @since v0.24.0 * @category List * @sig [a] -> [a] -> Boolean * @sig String -> String -> Boolean * @param {*} suffix * @param {*} list * @return {Boolean} * @see R.startsWith * @example * * R.endsWith('c', 'abc') //=> true * R.endsWith('b', 'abc') //=> false * R.endsWith(['c'], ['a', 'b', 'c']) //=> true * R.endsWith(['b'], ['a', 'b', 'c']) //=> false */ var endsWith = _curry2(function(suffix, list) { return equals(takeLast(suffix.length, list), suffix); }); /** * Takes a function and two values in its domain and returns `true` if the * values map to the same value in the codomain; `false` otherwise. * * @func * @memberOf R * @since v0.18.0 * @category Relation * @sig (a -> b) -> a -> a -> Boolean * @param {Function} f * @param {*} x * @param {*} y * @return {Boolean} * @example * * R.eqBy(Math.abs, 5, -5); //=> true */ var eqBy = _curry3(function eqBy(f, x, y) { return equals(f(x), f(y)); }); /** * Reports whether two objects have the same value, in [`R.equals`](#equals) * terms, for the specified property. Useful as a curried predicate. * * @func * @memberOf R * @since v0.1.0 * @category Object * @sig k -> {k: v} -> {k: v} -> Boolean * @param {String} prop The name of the property to compare * @param {Object} obj1 * @param {Object} obj2 * @return {Boolean} * * @example * * const o1 = { a: 1, b: 2, c: 3, d: 4 }; * const o2 = { a: 10, b: 20, c: 3, d: 40 }; * R.eqProps('a', o1, o2); //=> false * R.eqProps('c', o1, o2); //=> true */ var eqProps = _curry3(function eqProps(prop, obj1, obj2) { return equals(obj1[prop], obj2[prop]); }); /** * Creates a new object by recursively evolving a shallow copy of `object`, * according to the `transformation` functions. All non-primitive properties * are copied by reference. * * A `transformation` function will not be invoked if its corresponding key * does not exist in the evolved object. * * @func * @memberOf R * @since v0.9.0 * @category Object * @sig {k: (v -> v)} -> {k: v} -> {k: v} * @param {Object} transformations The object specifying transformation functions to apply * to the object. * @param {Object} object The object to be transformed. * @return {Object} The transformed object. * @example * * const tomato = {firstName: ' Tomato ', data: {elapsed: 100, remaining: 1400}, id:123}; * const transformations = { * firstName: R.trim, * lastName: R.trim, // Will not get invoked. * data: {elapsed: R.add(1), remaining: R.add(-1)} * }; * R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123} */ var evolve = _curry2(function evolve(transformations, object) { var result = object instanceof Array ? [] : {}; var transformation, key, type; for (key in object) { transformation = transformations[key]; type = typeof transformation; result[key] = type === 'function' ? transformation(object[key]) : transformation && type === 'object' ? evolve(transformation, object[key]) : object[key]; } return result; }); function XFind(f, xf) { this.xf = xf; this.f = f; this.found = false; } XFind.prototype['@@transducer/init'] = _xfBase.init; XFind.prototype['@@transducer/result'] = function(result) { if (!this.found) { result = this.xf['@@transducer/step'](result, void 0); } return this.xf['@@transducer/result'](result); }; XFind.prototype['@@transducer/step'] = function(result, input) { if (this.f(input)) { this.found = true; result = _reduced(this.xf['@@transducer/step'](result, input)); } return result; }; var _xfind = _curry2(function _xfind(f, xf) { return new XFind(f, xf); }); /** * Returns the first element of the list which matches the predicate, or * `undefined` if no element matches. * * Dispatches to the `find` method of the second argument, if present. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig (a -> Boolean) -> [a] -> a | undefined * @param {Function} fn The predicate function used to determine if the element is the * desired one. * @param {Array} list The array to consider. * @return {Object} The element found, or `undefined`. * @see R.transduce * @example * * const xs = [{a: 1}, {a: 2}, {a: 3}]; * R.find(R.propEq('a', 2))(xs); //=> {a: 2} * R.find(R.propEq('a', 4))(xs); //=> undefined */ var find = _curry2(_dispatchable(['find'], _xfind, function find(fn, list) { var idx = 0; var len = list.length; while (idx < len) { if (fn(list[idx])) { return list[idx]; } idx += 1; } })); function XFindIndex(f, xf) { this.xf = xf; this.f = f; this.idx = -1; this.found = false; } XFindIndex.prototype['@@transducer/init'] = _xfBase.init; XFindIndex.prototype['@@transducer/result'] = function(result) { if (!this.found) { result = this.xf['@@transducer/step'](result, -1); } return this.xf['@@transducer/result'](result); }; XFindIndex.prototype['@@transducer/step'] = function(result, input) { this.idx += 1; if (this.f(input)) { this.found = true; result = _reduced(this.xf['@@transducer/step'](result, this.idx)); } return result; }; var _xfindIndex = _curry2(function _xfindIndex(f, xf) { return new XFindIndex(f, xf); }); /** * Returns the index of the first element of the list which matches the * predicate, or `-1` if no element matches. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.1.1 * @category List * @sig (a -> Boolean) -> [a] -> Number * @param {Function} fn The predicate function used to determine if the element is the * desired one. * @param {Array} list The array to consider. * @return {Number} The index of the element found, or `-1`. * @see R.transduce * @example * * const xs = [{a: 1}, {a: 2}, {a: 3}]; * R.findIndex(R.propEq('a', 2))(xs); //=> 1 * R.findIndex(R.propEq('a', 4))(xs); //=> -1 */ var findIndex = _curry2(_dispatchable([], _xfindIndex, function findIndex(fn, list) { var idx = 0; var len = list.length; while (idx < len) { if (fn(list[idx])) { return idx; } idx += 1; } return -1; })); function XFindLast(f, xf) { this.xf = xf; this.f = f; } XFindLast.prototype['@@transducer/init'] = _xfBase.init; XFindLast.prototype['@@transducer/result'] = function(result) { return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last)); }; XFindLast.prototype['@@transducer/step'] = function(result, input) { if (this.f(input)) { this.last = input; } return result; }; var _xfindLast = _curry2(function _xfindLast(f, xf) { return new XFindLast(f, xf); }); /** * Returns the last element of the list which matches the predicate, or * `undefined` if no element matches. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.1.1 * @category List * @sig (a -> Boolean) -> [a] -> a | undefined * @param {Function} fn The predicate function used to determine if the element is the * desired one. * @param {Array} list The array to consider. * @return {Object} The element found, or `undefined`. * @see R.transduce * @example * * const xs = [{a: 1, b: 0}, {a:1, b: 1}]; * R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1} * R.findLast(R.propEq('a', 4))(xs); //=> undefined */ var findLast = _curry2(_dispatchable([], _xfindLast, function findLast(fn, list) { var idx = list.length - 1; while (idx >= 0) { if (fn(list[idx])) { return list[idx]; } idx -= 1; } })); function XFindLastIndex(f, xf) { this.xf = xf; this.f = f; this.idx = -1; this.lastIdx = -1; } XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init; XFindLastIndex.prototype['@@transducer/result'] = function(result) { return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx)); }; XFindLastIndex.prototype['@@transducer/step'] = function(result, input) { this.idx += 1; if (this.f(input)) { this.lastIdx = this.idx; } return result; }; var _xfindLastIndex = _curry2(function _xfindLastIndex(f, xf) { return new XFindLastIndex(f, xf); }); /** * Returns the index of the last element of the list which matches the * predicate, or `-1` if no element matches. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.1.1 * @category List * @sig (a -> Boolean) -> [a] -> Number * @param {Function} fn The predicate function used to determine if the element is the * desired one. * @param {Array} list The array to consider. * @return {Number} The index of the element found, or `-1`. * @see R.transduce * @example * * const xs = [{a: 1, b: 0}, {a:1, b: 1}]; * R.findLastIndex(R.propEq('a', 1))(xs); //=> 1 * R.findLastIndex(R.propEq('a', 4))(xs); //=> -1 */ var findLastIndex = _curry2(_dispatchable([], _xfindLastIndex, function findLastIndex(fn, list) { var idx = list.length - 1; while (idx >= 0) { if (fn(list[idx])) { return idx; } idx -= 1; } return -1; })); /** * Returns a new list by pulling every item out of it (and all its sub-arrays) * and putting them in a new array, depth-first. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig [a] -> [b] * @param {Array} list The array to consider. * @return {Array} The flattened list. * @see R.unnest * @example * * R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]); * //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] */ var flatten = _curry1(_makeFlat(true)); /** * Returns a new function much like the supplied one, except that the first two * arguments' order is reversed. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig ((a, b, c, ...) -> z) -> (b -> a -> c -> ... -> z) * @param {Function} fn The function to invoke with its first two parameters reversed. * @return {*} The result of invoking `fn` with its first two parameters' order reversed. * @example * * const mergeThree = (a, b, c) => [].concat(a, b, c); * * mergeThree(1, 2, 3); //=> [1, 2, 3] * * R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3] * @symb R.flip(f)(a, b, c) = f(b, a, c) */ var flip = _curry1(function flip(fn) { return curryN(fn.length, function(a, b) { var args = Array.prototype.slice.call(arguments, 0); args[0] = b; args[1] = a; return fn.apply(this, args); }); }); /** * Iterate over an input `list`, calling a provided function `fn` for each * element in the list. * * `fn` receives one argument: *(value)*. * * Note: `R.forEach` does not skip deleted or unassigned indices (sparse * arrays), unlike the native `Array.prototype.forEach` method. For more * details on this behavior, see: * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description * * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns * the original array. In some libraries this function is named `each`. * * Dispatches to the `forEach` method of the second argument, if present. * * @func * @memberOf R * @since v0.1.1 * @category List * @sig (a -> *) -> [a] -> [a] * @param {Function} fn The function to invoke. Receives one argument, `value`. * @param {Array} list The list to iterate over. * @return {Array} The original list. * @see R.addIndex * @example * * const printXPlusFive = x => console.log(x + 5); * R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3] * // logs 6 * // logs 7 * // logs 8 * @symb R.forEach(f, [a, b, c]) = [a, b, c] */ var forEach = _curry2(_checkForMethod('forEach', function forEach(fn, list) { var len = list.length; var idx = 0; while (idx < len) { fn(list[idx]); idx += 1; } return list; })); /** * Iterate over an input `object`, calling a provided function `fn` for each * key and value in the object. * * `fn` receives three argument: *(value, key, obj)*. * * @func * @memberOf R * @since v0.23.0 * @category Object * @sig ((a, String, StrMap a) -> Any) -> StrMap a -> StrMap a * @param {Function} fn The function to invoke. Receives three argument, `value`, `key`, `obj`. * @param {Object} obj The object to iterate over. * @return {Object} The original object. * @example * * const printKeyConcatValue = (value, key) => console.log(key + ':' + value); * R.forEachObjIndexed(printKeyConcatValue, {x: 1, y: 2}); //=> {x: 1, y: 2} * // logs x:1 * // logs y:2 * @symb R.forEachObjIndexed(f, {x: a, y: b}) = {x: a, y: b} */ var forEachObjIndexed = _curry2(function forEachObjIndexed(fn, obj) { var keyList = keys(obj); var idx = 0; while (idx < keyList.length) { var key = keyList[idx]; fn(obj[key], key, obj); idx += 1; } return obj; }); /** * Creates a new object from a list key-value pairs. If a key appears in * multiple pairs, the rightmost pair is included in the object. * * @func * @memberOf R * @since v0.3.0 * @category List * @sig [[k,v]] -> {k: v} * @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object. * @return {Object} The object made by pairing up `keys` and `values`. * @see R.toPairs, R.pair * @example * * R.fromPairs([['a', 1], ['b', 2], ['c', 3]]); //=> {a: 1, b: 2, c: 3} */ var fromPairs = _curry1(function fromPairs(pairs) { var result = {}; var idx = 0; while (idx < pairs.length) { result[pairs[idx][0]] = pairs[idx][1]; idx += 1; } return result; }); /** * Splits a list into sub-lists stored in an object, based on the result of * calling a String-returning function on each element, and grouping the * results according to values returned. * * Dispatches to the `groupBy` method of the second argument, if present. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig (a -> String) -> [a] -> {String: [a]} * @param {Function} fn Function :: a -> String * @param {Array} list The array to group * @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements * that produced that key when passed to `fn`. * @see R.reduceBy, R.transduce * @example * * const byGrade = R.groupBy(function(student) { * const score = student.score; * return score < 65 ? 'F' : * score < 70 ? 'D' : * score < 80 ? 'C' : * score < 90 ? 'B' : 'A'; * }); * const students = [{name: 'Abby', score: 84}, * {name: 'Eddy', score: 58}, * // ... * {name: 'Jack', score: 69}]; * byGrade(students); * // { * // 'A': [{name: 'Dianne', score: 99}], * // 'B': [{name: 'Abby', score: 84}] * // // ..., * // 'F': [{name: 'Eddy', score: 58}] * // } */ var groupBy = _curry2(_checkForMethod('groupBy', reduceBy(function(acc, item) { if (acc == null) { acc = []; } acc.push(item); return acc; }, null))); /** * Takes a list and returns a list of lists where each sublist's elements are * all satisfied pairwise comparison according to the provided function. * Only adjacent elements are passed to the comparison function. * * @func * @memberOf R * @since v0.21.0 * @category List * @sig ((a, a) → Boolean) → [a] → [[a]] * @param {Function} fn Function for determining whether two given (adjacent) * elements should be in the same group * @param {Array} list The array to group. Also accepts a string, which will be * treated as a list of characters. * @return {List} A list that contains sublists of elements, * whose concatenations are equal to the original list. * @example * * R.groupWith(R.equals, [0, 1, 1, 2, 3, 5, 8, 13, 21]) * //=> [[0], [1, 1], [2], [3], [5], [8], [13], [21]] * * R.groupWith((a, b) => a + 1 === b, [0, 1, 1, 2, 3, 5, 8, 13, 21]) * //=> [[0, 1], [1, 2, 3], [5], [8], [13], [21]] * * R.groupWith((a, b) => a % 2 === b % 2, [0, 1, 1, 2, 3, 5, 8, 13, 21]) * //=> [[0], [1, 1], [2], [3, 5], [8], [13, 21]] * * R.groupWith(R.eqBy(isVowel), 'aestiou') * //=> ['ae', 'st', 'iou'] */ var groupWith = _curry2(function(fn, list) { var res = []; var idx = 0; var len = list.length; while (idx < len) { var nextidx = idx + 1; while (nextidx < len && fn(list[nextidx - 1], list[nextidx])) { nextidx += 1; } res.push(list.slice(idx, nextidx)); idx = nextidx; } return res; }); /** * Returns `true` if the first argument is greater than the second; `false` * otherwise. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig Ord a => a -> a -> Boolean * @param {*} a * @param {*} b * @return {Boolean} * @see R.lt * @example * * R.gt(2, 1); //=> true * R.gt(2, 2); //=> false * R.gt(2, 3); //=> false * R.gt('a', 'z'); //=> false * R.gt('z', 'a'); //=> true */ var gt = _curry2(function gt(a, b) { return a > b; }); /** * Returns `true` if the first argument is greater than or equal to the second; * `false` otherwise. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig Ord a => a -> a -> Boolean * @param {Number} a * @param {Number} b * @return {Boolean} * @see R.lte * @example * * R.gte(2, 1); //=> true * R.gte(2, 2); //=> true * R.gte(2, 3); //=> false * R.gte('a', 'z'); //=> false * R.gte('z', 'a'); //=> true */ var gte = _curry2(function gte(a, b) { return a >= b; }); /** * Returns whether or not a path exists in an object. Only the object's * own properties are checked. * * @func * @memberOf R * @since v0.26.0 * @category Object * @typedefn Idx = String | Int * @sig [Idx] -> {a} -> Boolean * @param {Array} path The path to use. * @param {Object} obj The object to check the path in. * @return {Boolean} Whether the path exists. * @see R.has * @example * * R.hasPath(['a', 'b'], {a: {b: 2}}); // => true * R.hasPath(['a', 'b'], {a: {b: undefined}}); // => true * R.hasPath(['a', 'b'], {a: {c: 2}}); // => false * R.hasPath(['a', 'b'], {}); // => false */ var hasPath = _curry2(function hasPath(_path, obj) { if (_path.length === 0 || isNil(obj)) { return false; } var val = obj; var idx = 0; while (idx < _path.length) { if (!isNil(val) && _has(_path[idx], val)) { val = val[_path[idx]]; idx += 1; } else { return false; } } return true; }); /** * Returns whether or not an object has an own property with the specified name * * @func * @memberOf R * @since v0.7.0 * @category Object * @sig s -> {s: x} -> Boolean * @param {String} prop The name of the property to check for. * @param {Object} obj The object to query. * @return {Boolean} Whether the property exists. * @example * * const hasName = R.has('name'); * hasName({name: 'alice'}); //=> true * hasName({name: 'bob'}); //=> true * hasName({}); //=> false * * const point = {x: 0, y: 0}; * const pointHas = R.has(R.__, point); * pointHas('x'); //=> true * pointHas('y'); //=> true * pointHas('z'); //=> false */ var has = _curry2(function has(prop, obj) { return hasPath([prop], obj); }); /** * Returns whether or not an object or its prototype chain has a property with * the specified name * * @func * @memberOf R * @since v0.7.0 * @category Object * @sig s -> {s: x} -> Boolean * @param {String} prop The name of the property to check for. * @param {Object} obj The object to query. * @return {Boolean} Whether the property exists. * @example * * function Rectangle(width, height) { * this.width = width; * this.height = height; * } * Rectangle.prototype.area = function() { * return this.width * this.height; * }; * * const square = new Rectangle(2, 2); * R.hasIn('width', square); //=> true * R.hasIn('area', square); //=> true */ var hasIn = _curry2(function hasIn(prop, obj) { return prop in obj; }); /** * Returns true if its arguments are identical, false otherwise. Values are * identical if they reference the same memory. `NaN` is identical to `NaN`; * `0` and `-0` are not identical. * * Note this is merely a curried version of ES6 `Object.is`. * * @func * @memberOf R * @since v0.15.0 * @category Relation * @sig a -> a -> Boolean * @param {*} a * @param {*} b * @return {Boolean} * @example * * const o = {}; * R.identical(o, o); //=> true * R.identical(1, 1); //=> true * R.identical(1, '1'); //=> false * R.identical([], []); //=> false * R.identical(0, -0); //=> false * R.identical(NaN, NaN); //=> true */ var identical = _curry2(_objectIs$1); /** * Creates a function that will process either the `onTrue` or the `onFalse` * function depending upon the result of the `condition` predicate. * * @func * @memberOf R * @since v0.8.0 * @category Logic * @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *) * @param {Function} condition A predicate function * @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value. * @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value. * @return {Function} A new function that will process either the `onTrue` or the `onFalse` * function depending upon the result of the `condition` predicate. * @see R.unless, R.when, R.cond * @example * * const incCount = R.ifElse( * R.has('count'), * R.over(R.lensProp('count'), R.inc), * R.assoc('count', 1) * ); * incCount({}); //=> { count: 1 } * incCount({ count: 1 }); //=> { count: 2 } */ var ifElse = _curry3(function ifElse(condition, onTrue, onFalse) { return curryN(Math.max(condition.length, onTrue.length, onFalse.length), function _ifElse() { return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments); } ); }); /** * Increments its argument. * * @func * @memberOf R * @since v0.9.0 * @category Math * @sig Number -> Number * @param {Number} n * @return {Number} n + 1 * @see R.dec * @example * * R.inc(42); //=> 43 */ var inc = add(1); /** * Returns `true` if the specified value is equal, in [`R.equals`](#equals) * terms, to at least one element of the given list; `false` otherwise. * Works also with strings. * * @func * @memberOf R * @since v0.26.0 * @category List * @sig a -> [a] -> Boolean * @param {Object} a The item to compare against. * @param {Array} list The array to consider. * @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise. * @see R.any * @example * * R.includes(3, [1, 2, 3]); //=> true * R.includes(4, [1, 2, 3]); //=> false * R.includes({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true * R.includes([42], [[42]]); //=> true * R.includes('ba', 'banana'); //=>true */ var includes = _curry2(_includes); /** * Given a function that generates a key, turns a list of objects into an * object indexing the objects by the given key. Note that if multiple * objects generate the same value for the indexing key only the last value * will be included in the generated object. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.19.0 * @category List * @sig (a -> String) -> [{k: v}] -> {k: {k: v}} * @param {Function} fn Function :: a -> String * @param {Array} array The array of objects to index * @return {Object} An object indexing each array element by the given property. * @example * * const list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}]; * R.indexBy(R.prop('id'), list); * //=> {abc: {id: 'abc', title: 'B'}, xyz: {id: 'xyz', title: 'A'}} */ var indexBy = reduceBy(function(acc, elem) { return elem; }, null); /** * Returns the position of the first occurrence of an item in an array, or -1 * if the item is not included in the array. [`R.equals`](#equals) is used to * determine equality. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig a -> [a] -> Number * @param {*} target The item to find. * @param {Array} xs The array to search in. * @return {Number} the index of the target, or -1 if the target is not found. * @see R.lastIndexOf * @example * * R.indexOf(3, [1,2,3,4]); //=> 2 * R.indexOf(10, [1,2,3,4]); //=> -1 */ var indexOf = _curry2(function indexOf(target, xs) { return typeof xs.indexOf === 'function' && !_isArray(xs) ? xs.indexOf(target) : _indexOf(xs, target, 0); }); /** * Returns all but the last element of the given list or string. * * @func * @memberOf R * @since v0.9.0 * @category List * @sig [a] -> [a] * @sig String -> String * @param {*} list * @return {*} * @see R.last, R.head, R.tail * @example * * R.init([1, 2, 3]); //=> [1, 2] * R.init([1, 2]); //=> [1] * R.init([1]); //=> [] * R.init([]); //=> [] * * R.init('abc'); //=> 'ab' * R.init('ab'); //=> 'a' * R.init('a'); //=> '' * R.init(''); //=> '' */ var init = slice(0, -1); /** * Takes a predicate `pred`, a list `xs`, and a list `ys`, and returns a list * `xs'` comprising each of the elements of `xs` which is equal to one or more * elements of `ys` according to `pred`. * * `pred` must be a binary function expecting an element from each list. * * `xs`, `ys`, and `xs'` are treated as sets, semantically, so ordering should * not be significant, but since `xs'` is ordered the implementation guarantees * that its values are in the same order as they appear in `xs`. Duplicates are * not removed, so `xs'` may contain duplicates if `xs` contains duplicates. * * @func * @memberOf R * @since v0.24.0 * @category Relation * @sig ((a, b) -> Boolean) -> [a] -> [b] -> [a] * @param {Function} pred * @param {Array} xs * @param {Array} ys * @return {Array} * @see R.intersection * @example * * R.innerJoin( * (record, id) => record.id === id, * [{id: 824, name: 'Richie Furay'}, * {id: 956, name: 'Dewey Martin'}, * {id: 313, name: 'Bruce Palmer'}, * {id: 456, name: 'Stephen Stills'}, * {id: 177, name: 'Neil Young'}], * [177, 456, 999] * ); * //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}] */ var innerJoin = _curry3(function innerJoin(pred, xs, ys) { return _filter(function(x) { return _includesWith(pred, x, ys); }, xs); }); /** * Inserts the supplied element into the list, at the specified `index`. _Note that * this is not destructive_: it returns a copy of the list with the changes. * <small>No lists have been harmed in the application of this function.</small> * * @func * @memberOf R * @since v0.2.2 * @category List * @sig Number -> a -> [a] -> [a] * @param {Number} index The position to insert the element * @param {*} elt The element to insert into the Array * @param {Array} list The list to insert into * @return {Array} A new Array with `elt` inserted at `index`. * @example * * R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4] */ var insert = _curry3(function insert(idx, elt, list) { idx = idx < list.length && idx >= 0 ? idx : list.length; var result = Array.prototype.slice.call(list, 0); result.splice(idx, 0, elt); return result; }); /** * Inserts the sub-list into the list, at the specified `index`. _Note that this is not * destructive_: it returns a copy of the list with the changes. * <small>No lists have been harmed in the application of this function.</small> * * @func * @memberOf R * @since v0.9.0 * @category List * @sig Number -> [a] -> [a] -> [a] * @param {Number} index The position to insert the sub-list * @param {Array} elts The sub-list to insert into the Array * @param {Array} list The list to insert the sub-list into * @return {Array} A new Array with `elts` inserted starting at `index`. * @example * * R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4] */ var insertAll = _curry3(function insertAll(idx, elts, list) { idx = idx < list.length && idx >= 0 ? idx : list.length; return [].concat( Array.prototype.slice.call(list, 0, idx), elts, Array.prototype.slice.call(list, idx) ); }); /** * Returns a new list containing only one copy of each element in the original * list, based upon the value returned by applying the supplied function to * each list element. Prefers the first item if the supplied function produces * the same value on two items. [`R.equals`](#equals) is used for comparison. * * @func * @memberOf R * @since v0.16.0 * @category List * @sig (a -> b) -> [a] -> [a] * @param {Function} fn A function used to produce a value to use during comparisons. * @param {Array} list The array to consider. * @return {Array} The list of unique items. * @example * * R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10] */ var uniqBy = _curry2(function uniqBy(fn, list) { var set = new _Set(); var result = []; var idx = 0; var appliedItem, item; while (idx < list.length) { item = list[idx]; appliedItem = fn(item); if (set.add(appliedItem)) { result.push(item); } idx += 1; } return result; }); /** * Returns a new list containing only one copy of each element in the original * list. [`R.equals`](#equals) is used to determine equality. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig [a] -> [a] * @param {Array} list The array to consider. * @return {Array} The list of unique items. * @example * * R.uniq([1, 1, 2, 1]); //=> [1, 2] * R.uniq([1, '1']); //=> [1, '1'] * R.uniq([[42], [42]]); //=> [[42]] */ var uniq = uniqBy(identity); /** * Combines two lists into a set (i.e. no duplicates) composed of those * elements common to both lists. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig [*] -> [*] -> [*] * @param {Array} list1 The first list. * @param {Array} list2 The second list. * @return {Array} The list of elements found in both `list1` and `list2`. * @see R.innerJoin * @example * * R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3] */ var intersection = _curry2(function intersection(list1, list2) { var lookupList, filteredList; if (list1.length > list2.length) { lookupList = list1; filteredList = list2; } else { lookupList = list2; filteredList = list1; } return uniq(_filter(flip(_includes)(lookupList), filteredList)); }); /** * Creates a new list with the separator interposed between elements. * * Dispatches to the `intersperse` method of the second argument, if present. * * @func * @memberOf R * @since v0.14.0 * @category List * @sig a -> [a] -> [a] * @param {*} separator The element to add to the list. * @param {Array} list The list to be interposed. * @return {Array} The new list. * @example * * R.intersperse('a', ['b', 'n', 'n', 's']); //=> ['b', 'a', 'n', 'a', 'n', 'a', 's'] */ var intersperse = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) { var out = []; var idx = 0; var length = list.length; while (idx < length) { if (idx === length - 1) { out.push(list[idx]); } else { out.push(list[idx], separator); } idx += 1; } return out; })); // Based on https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign function _objectAssign(target) { if (target == null) { throw new TypeError('Cannot convert undefined or null to object'); } var output = Object(target); var idx = 1; var length = arguments.length; while (idx < length) { var source = arguments[idx]; if (source != null) { for (var nextKey in source) { if (_has(nextKey, source)) { output[nextKey] = source[nextKey]; } } } idx += 1; } return output; } var _objectAssign$1 = typeof Object.assign === 'function' ? Object.assign : _objectAssign; /** * Creates an object containing a single key:value pair. * * @func * @memberOf R * @since v0.18.0 * @category Object * @sig String -> a -> {String:a} * @param {String} key * @param {*} val * @return {Object} * @see R.pair * @example * * const matchPhrases = R.compose( * R.objOf('must'), * R.map(R.objOf('match_phrase')) * ); * matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]} */ var objOf = _curry2(function objOf(key, val) { var obj = {}; obj[key] = val; return obj; }); var _stepCatArray = { '@@transducer/init': Array, '@@transducer/step': function(xs, x) { xs.push(x); return xs; }, '@@transducer/result': _identity }; var _stepCatString = { '@@transducer/init': String, '@@transducer/step': function(a, b) { return a + b; }, '@@transducer/result': _identity }; var _stepCatObject = { '@@transducer/init': Object, '@@transducer/step': function(result, input) { return _objectAssign$1( result, _isArrayLike(input) ? objOf(input[0], input[1]) : input ); }, '@@transducer/result': _identity }; function _stepCat(obj) { if (_isTransformer(obj)) { return obj; } if (_isArrayLike(obj)) { return _stepCatArray; } if (typeof obj === 'string') { return _stepCatString; } if (typeof obj === 'object') { return _stepCatObject; } throw new Error('Cannot create transformer for ' + obj); } /** * Transforms the items of the list with the transducer and appends the * transformed items to the accumulator using an appropriate iterator function * based on the accumulator type. * * The accumulator can be an array, string, object or a transformer. Iterated * items will be appended to arrays and concatenated to strings. Objects will * be merged directly or 2-item arrays will be merged as key, value pairs. * * The accumulator can also be a transformer object that provides a 2-arity * reducing iterator function, step, 0-arity initial value function, init, and * 1-arity result extraction function result. The step function is used as the * iterator function in reduce. The result function is used to convert the * final accumulator into the return type and in most cases is R.identity. The * init function is used to provide the initial accumulator. * * The iteration is performed with [`R.reduce`](#reduce) after initializing the * transducer. * * @func * @memberOf R * @since v0.12.0 * @category List * @sig a -> (b -> b) -> [c] -> a * @param {*} acc The initial accumulator value. * @param {Function} xf The transducer function. Receives a transformer and returns a transformer. * @param {Array} list The list to iterate over. * @return {*} The final, accumulated value. * @see R.transduce * @example * * const numbers = [1, 2, 3, 4]; * const transducer = R.compose(R.map(R.add(1)), R.take(2)); * * R.into([], transducer, numbers); //=> [2, 3] * * const intoArray = R.into([]); * intoArray(transducer, numbers); //=> [2, 3] */ var into = _curry3(function into(acc, xf, list) { return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), _clone(acc, [], [], false), list); }); /** * Same as [`R.invertObj`](#invertObj), however this accounts for objects with * duplicate values by putting the values into an array. * * @func * @memberOf R * @since v0.9.0 * @category Object * @sig {s: x} -> {x: [ s, ... ]} * @param {Object} obj The object or array to invert * @return {Object} out A new object with keys in an array. * @see R.invertObj * @example * * const raceResultsByFirstName = { * first: 'alice', * second: 'jake', * third: 'alice', * }; * R.invert(raceResultsByFirstName); * //=> { 'alice': ['first', 'third'], 'jake':['second'] } */ var invert = _curry1(function invert(obj) { var props = keys(obj); var len = props.length; var idx = 0; var out = {}; while (idx < len) { var key = props[idx]; var val = obj[key]; var list = _has(val, out) ? out[val] : (out[val] = []); list[list.length] = key; idx += 1; } return out; }); /** * Returns a new object with the keys of the given object as values, and the * values of the given object, which are coerced to strings, as keys. Note * that the last key found is preferred when handling the same value. * * @func * @memberOf R * @since v0.9.0 * @category Object * @sig {s: x} -> {x: s} * @param {Object} obj The object or array to invert * @return {Object} out A new object * @see R.invert * @example * * const raceResults = { * first: 'alice', * second: 'jake' * }; * R.invertObj(raceResults); * //=> { 'alice': 'first', 'jake':'second' } * * // Alternatively: * const raceResults = ['alice', 'jake']; * R.invertObj(raceResults); * //=> { 'alice': '0', 'jake':'1' } */ var invertObj = _curry1(function invertObj(obj) { var props = keys(obj); var len = props.length; var idx = 0; var out = {}; while (idx < len) { var key = props[idx]; out[obj[key]] = key; idx += 1; } return out; }); /** * Turns a named method with a specified arity into a function that can be * called directly supplied with arguments and a target object. * * The returned function is curried and accepts `arity + 1` parameters where * the final parameter is the target object. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig Number -> String -> (a -> b -> ... -> n -> Object -> *) * @param {Number} arity Number of arguments the returned function should take * before the target object. * @param {String} method Name of any of the target object's methods to call. * @return {Function} A new curried function. * @see R.construct * @example * * const sliceFrom = R.invoker(1, 'slice'); * sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm' * const sliceFrom6 = R.invoker(2, 'slice')(6); * sliceFrom6(8, 'abcdefghijklm'); //=> 'gh' * * const dog = { * speak: async () => 'Woof!' * }; * const speak = R.invoker(0, 'speak'); * speak(dog).then(console.log) //~> 'Woof!' * * @symb R.invoker(0, 'method')(o) = o['method']() * @symb R.invoker(1, 'method')(a, o) = o['method'](a) * @symb R.invoker(2, 'method')(a, b, o) = o['method'](a, b) */ var invoker = _curry2(function invoker(arity, method) { return curryN(arity + 1, function() { var target = arguments[arity]; if (target != null && _isFunction(target[method])) { return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity)); } throw new TypeError(toString$1(target) + ' does not have a method named "' + method + '"'); }); }); /** * See if an object (`val`) is an instance of the supplied constructor. This * function will check up the inheritance chain, if any. * * @func * @memberOf R * @since v0.3.0 * @category Type * @sig (* -> {*}) -> a -> Boolean * @param {Object} ctor A constructor * @param {*} val The value to test * @return {Boolean} * @example * * R.is(Object, {}); //=> true * R.is(Number, 1); //=> true * R.is(Object, 1); //=> false * R.is(String, 's'); //=> true * R.is(String, new String('')); //=> true * R.is(Object, new String('')); //=> true * R.is(Object, 's'); //=> false * R.is(Number, {}); //=> false */ var is = _curry2(function is(Ctor, val) { return val != null && val.constructor === Ctor || val instanceof Ctor; }); /** * Returns `true` if the given value is its type's empty value; `false` * otherwise. * * @func * @memberOf R * @since v0.1.0 * @category Logic * @sig a -> Boolean * @param {*} x * @return {Boolean} * @see R.empty * @example * * R.isEmpty([1, 2, 3]); //=> false * R.isEmpty([]); //=> true * R.isEmpty(''); //=> true * R.isEmpty(null); //=> false * R.isEmpty({}); //=> true * R.isEmpty({length: 0}); //=> false */ var isEmpty = _curry1(function isEmpty(x) { return x != null && equals(x, empty(x)); }); /** * Returns a string made by inserting the `separator` between each element and * concatenating all the elements into a single string. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig String -> [a] -> String * @param {Number|String} separator The string used to separate the elements. * @param {Array} xs The elements to join into a string. * @return {String} str The string made by concatenating `xs` with `separator`. * @see R.split * @example * * const spacer = R.join(' '); * spacer(['a', 2, 3.4]); //=> 'a 2 3.4' * R.join('|', [1, 2, 3]); //=> '1|2|3' */ var join = invoker(1, 'join'); /** * juxt applies a list of functions to a list of values. * * @func * @memberOf R * @since v0.19.0 * @category Function * @sig [(a, b, ..., m) -> n] -> ((a, b, ..., m) -> [n]) * @param {Array} fns An array of functions * @return {Function} A function that returns a list of values after applying each of the original `fns` to its parameters. * @see R.applySpec * @example * * const getRange = R.juxt([Math.min, Math.max]); * getRange(3, 4, 9, -3); //=> [-3, 9] * @symb R.juxt([f, g, h])(a, b) = [f(a, b), g(a, b), h(a, b)] */ var juxt = _curry1(function juxt(fns) { return converge(function() { return Array.prototype.slice.call(arguments, 0); }, fns); }); /** * Returns a list containing the names of all the properties of the supplied * object, including prototype properties. * Note that the order of the output array is not guaranteed to be consistent * across different JS platforms. * * @func * @memberOf R * @since v0.2.0 * @category Object * @sig {k: v} -> [k] * @param {Object} obj The object to extract properties from * @return {Array} An array of the object's own and prototype properties. * @see R.keys, R.valuesIn * @example * * const F = function() { this.x = 'X'; }; * F.prototype.y = 'Y'; * const f = new F(); * R.keysIn(f); //=> ['x', 'y'] */ var keysIn = _curry1(function keysIn(obj) { var prop; var ks = []; for (prop in obj) { ks[ks.length] = prop; } return ks; }); /** * Returns the position of the last occurrence of an item in an array, or -1 if * the item is not included in the array. [`R.equals`](#equals) is used to * determine equality. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig a -> [a] -> Number * @param {*} target The item to find. * @param {Array} xs The array to search in. * @return {Number} the index of the target, or -1 if the target is not found. * @see R.indexOf * @example * * R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6 * R.lastIndexOf(10, [1,2,3,4]); //=> -1 */ var lastIndexOf = _curry2(function lastIndexOf(target, xs) { if (typeof xs.lastIndexOf === 'function' && !_isArray(xs)) { return xs.lastIndexOf(target); } else { var idx = xs.length - 1; while (idx >= 0) { if (equals(xs[idx], target)) { return idx; } idx -= 1; } return -1; } }); function _isNumber(x) { return Object.prototype.toString.call(x) === '[object Number]'; } /** * Returns the number of elements in the array by returning `list.length`. * * @func * @memberOf R * @since v0.3.0 * @category List * @sig [a] -> Number * @param {Array} list The array to inspect. * @return {Number} The length of the array. * @example * * R.length([]); //=> 0 * R.length([1, 2, 3]); //=> 3 */ var length = _curry1(function length(list) { return list != null && _isNumber(list.length) ? list.length : NaN; }); /** * Returns a lens for the given getter and setter functions. The getter "gets" * the value of the focus; the setter "sets" the value of the focus. The setter * should not mutate the data structure. * * @func * @memberOf R * @since v0.8.0 * @category Object * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s * @sig (s -> a) -> ((a, s) -> s) -> Lens s a * @param {Function} getter * @param {Function} setter * @return {Lens} * @see R.view, R.set, R.over, R.lensIndex, R.lensProp * @example * * const xLens = R.lens(R.prop('x'), R.assoc('x')); * * R.view(xLens, {x: 1, y: 2}); //=> 1 * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2} * R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2} */ var lens = _curry2(function lens(getter, setter) { return function(toFunctorFn) { return function(target) { return map( function(focus) { return setter(focus, target); }, toFunctorFn(getter(target)) ); }; }; }); /** * Returns a lens whose focus is the specified index. * * @func * @memberOf R * @since v0.14.0 * @category Object * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s * @sig Number -> Lens s a * @param {Number} n * @return {Lens} * @see R.view, R.set, R.over, R.nth * @example * * const headLens = R.lensIndex(0); * * R.view(headLens, ['a', 'b', 'c']); //=> 'a' * R.set(headLens, 'x', ['a', 'b', 'c']); //=> ['x', 'b', 'c'] * R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c'] */ var lensIndex = _curry1(function lensIndex(n) { return lens(nth(n), update(n)); }); /** * Returns a lens whose focus is the specified path. * * @func * @memberOf R * @since v0.19.0 * @category Object * @typedefn Idx = String | Int * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s * @sig [Idx] -> Lens s a * @param {Array} path The path to use. * @return {Lens} * @see R.view, R.set, R.over * @example * * const xHeadYLens = R.lensPath(['x', 0, 'y']); * * R.view(xHeadYLens, {x: [{y: 2, z: 3}, {y: 4, z: 5}]}); * //=> 2 * R.set(xHeadYLens, 1, {x: [{y: 2, z: 3}, {y: 4, z: 5}]}); * //=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]} * R.over(xHeadYLens, R.negate, {x: [{y: 2, z: 3}, {y: 4, z: 5}]}); * //=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]} */ var lensPath = _curry1(function lensPath(p) { return lens(path(p), assocPath(p)); }); /** * Returns a lens whose focus is the specified property. * * @func * @memberOf R * @since v0.14.0 * @category Object * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s * @sig String -> Lens s a * @param {String} k * @return {Lens} * @see R.view, R.set, R.over * @example * * const xLens = R.lensProp('x'); * * R.view(xLens, {x: 1, y: 2}); //=> 1 * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2} * R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2} */ var lensProp = _curry1(function lensProp(k) { return lens(prop(k), assoc(k)); }); /** * Returns `true` if the first argument is less than the second; `false` * otherwise. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig Ord a => a -> a -> Boolean * @param {*} a * @param {*} b * @return {Boolean} * @see R.gt * @example * * R.lt(2, 1); //=> false * R.lt(2, 2); //=> false * R.lt(2, 3); //=> true * R.lt('a', 'z'); //=> true * R.lt('z', 'a'); //=> false */ var lt = _curry2(function lt(a, b) { return a < b; }); /** * Returns `true` if the first argument is less than or equal to the second; * `false` otherwise. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig Ord a => a -> a -> Boolean * @param {Number} a * @param {Number} b * @return {Boolean} * @see R.gte * @example * * R.lte(2, 1); //=> false * R.lte(2, 2); //=> true * R.lte(2, 3); //=> true * R.lte('a', 'z'); //=> true * R.lte('z', 'a'); //=> false */ var lte = _curry2(function lte(a, b) { return a <= b; }); /** * The `mapAccum` function behaves like a combination of map and reduce; it * applies a function to each element of a list, passing an accumulating * parameter from left to right, and returning a final value of this * accumulator together with the new list. * * The iterator function receives two arguments, *acc* and *value*, and should * return a tuple *[acc, value]*. * * @func * @memberOf R * @since v0.10.0 * @category List * @sig ((acc, x) -> (acc, y)) -> acc -> [x] -> (acc, [y]) * @param {Function} fn The function to be called on every element of the input `list`. * @param {*} acc The accumulator value. * @param {Array} list The list to iterate over. * @return {*} The final, accumulated value. * @see R.scan, R.addIndex, R.mapAccumRight * @example * * const digits = ['1', '2', '3', '4']; * const appender = (a, b) => [a + b, a + b]; * * R.mapAccum(appender, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']] * @symb R.mapAccum(f, a, [b, c, d]) = [ * f(f(f(a, b)[0], c)[0], d)[0], * [ * f(a, b)[1], * f(f(a, b)[0], c)[1], * f(f(f(a, b)[0], c)[0], d)[1] * ] * ] */ var mapAccum = _curry3(function mapAccum(fn, acc, list) { var idx = 0; var len = list.length; var result = []; var tuple = [acc]; while (idx < len) { tuple = fn(tuple[0], list[idx]); result[idx] = tuple[1]; idx += 1; } return [tuple[0], result]; }); /** * The `mapAccumRight` function behaves like a combination of map and reduce; it * applies a function to each element of a list, passing an accumulating * parameter from right to left, and returning a final value of this * accumulator together with the new list. * * Similar to [`mapAccum`](#mapAccum), except moves through the input list from * the right to the left. * * The iterator function receives two arguments, *acc* and *value*, and should * return a tuple *[acc, value]*. * * @func * @memberOf R * @since v0.10.0 * @category List * @sig ((acc, x) -> (acc, y)) -> acc -> [x] -> (acc, [y]) * @param {Function} fn The function to be called on every element of the input `list`. * @param {*} acc The accumulator value. * @param {Array} list The list to iterate over. * @return {*} The final, accumulated value. * @see R.addIndex, R.mapAccum * @example * * const digits = ['1', '2', '3', '4']; * const appender = (a, b) => [b + a, b + a]; * * R.mapAccumRight(appender, 5, digits); //=> ['12345', ['12345', '2345', '345', '45']] * @symb R.mapAccumRight(f, a, [b, c, d]) = [ * f(f(f(a, d)[0], c)[0], b)[0], * [ * f(a, d)[1], * f(f(a, d)[0], c)[1], * f(f(f(a, d)[0], c)[0], b)[1] * ] * ] */ var mapAccumRight = _curry3(function mapAccumRight(fn, acc, list) { var idx = list.length - 1; var result = []; var tuple = [acc]; while (idx >= 0) { tuple = fn(tuple[0], list[idx]); result[idx] = tuple[1]; idx -= 1; } return [tuple[0], result]; }); /** * An Object-specific version of [`map`](#map). The function is applied to three * arguments: *(value, key, obj)*. If only the value is significant, use * [`map`](#map) instead. * * @func * @memberOf R * @since v0.9.0 * @category Object * @sig ((*, String, Object) -> *) -> Object -> Object * @param {Function} fn * @param {Object} obj * @return {Object} * @see R.map * @example * * const xyz = { x: 1, y: 2, z: 3 }; * const prependKeyAndDouble = (num, key, obj) => key + (num * 2); * * R.mapObjIndexed(prependKeyAndDouble, xyz); //=> { x: 'x2', y: 'y4', z: 'z6' } */ var mapObjIndexed = _curry2(function mapObjIndexed(fn, obj) { return _reduce(function(acc, key) { acc[key] = fn(obj[key], key, obj); return acc; }, {}, keys(obj)); }); /** * Tests a regular expression against a String. Note that this function will * return an empty array when there are no matches. This differs from * [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match) * which returns `null` when there are no matches. * * @func * @memberOf R * @since v0.1.0 * @category String * @sig RegExp -> String -> [String | Undefined] * @param {RegExp} rx A regular expression. * @param {String} str The string to match against * @return {Array} The list of matches or empty array. * @see R.test * @example * * R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na'] * R.match(/a/, 'b'); //=> [] * R.match(/a/, null); //=> TypeError: null does not have a method named "match" */ var match = _curry2(function match(rx, str) { return str.match(rx) || []; }); /** * `mathMod` behaves like the modulo operator should mathematically, unlike the * `%` operator (and by extension, [`R.modulo`](#modulo)). So while * `-17 % 5` is `-2`, `mathMod(-17, 5)` is `3`. `mathMod` requires Integer * arguments, and returns NaN when the modulus is zero or negative. * * @func * @memberOf R * @since v0.3.0 * @category Math * @sig Number -> Number -> Number * @param {Number} m The dividend. * @param {Number} p the modulus. * @return {Number} The result of `b mod a`. * @see R.modulo * @example * * R.mathMod(-17, 5); //=> 3 * R.mathMod(17, 5); //=> 2 * R.mathMod(17, -5); //=> NaN * R.mathMod(17, 0); //=> NaN * R.mathMod(17.2, 5); //=> NaN * R.mathMod(17, 5.3); //=> NaN * * const clock = R.mathMod(R.__, 12); * clock(15); //=> 3 * clock(24); //=> 0 * * const seventeenMod = R.mathMod(17); * seventeenMod(3); //=> 2 * seventeenMod(4); //=> 1 * seventeenMod(10); //=> 7 */ var mathMod = _curry2(function mathMod(m, p) { if (!_isInteger(m)) { return NaN; } if (!_isInteger(p) || p < 1) { return NaN; } return ((m % p) + p) % p; }); /** * Takes a function and two values, and returns whichever value produces the * larger result when passed to the provided function. * * @func * @memberOf R * @since v0.8.0 * @category Relation * @sig Ord b => (a -> b) -> a -> a -> a * @param {Function} f * @param {*} a * @param {*} b * @return {*} * @see R.max, R.minBy * @example * * // square :: Number -> Number * const square = n => n * n; * * R.maxBy(square, -3, 2); //=> -3 * * R.reduce(R.maxBy(square), 0, [3, -5, 4, 1, -2]); //=> -5 * R.reduce(R.maxBy(square), 0, []); //=> 0 */ var maxBy = _curry3(function maxBy(f, a, b) { return f(b) > f(a) ? b : a; }); /** * Adds together all the elements of a list. * * @func * @memberOf R * @since v0.1.0 * @category Math * @sig [Number] -> Number * @param {Array} list An array of numbers * @return {Number} The sum of all the numbers in the list. * @see R.reduce * @example * * R.sum([2,4,6,8,100,1]); //=> 121 */ var sum = reduce(add, 0); /** * Returns the mean of the given list of numbers. * * @func * @memberOf R * @since v0.14.0 * @category Math * @sig [Number] -> Number * @param {Array} list * @return {Number} * @see R.median * @example * * R.mean([2, 7, 9]); //=> 6 * R.mean([]); //=> NaN */ var mean = _curry1(function mean(list) { return sum(list) / list.length; }); /** * Returns the median of the given list of numbers. * * @func * @memberOf R * @since v0.14.0 * @category Math * @sig [Number] -> Number * @param {Array} list * @return {Number} * @see R.mean * @example * * R.median([2, 9, 7]); //=> 7 * R.median([7, 2, 10, 9]); //=> 8 * R.median([]); //=> NaN */ var median = _curry1(function median(list) { var len = list.length; if (len === 0) { return NaN; } var width = 2 - len % 2; var idx = (len - width) / 2; return mean(Array.prototype.slice.call(list, 0).sort(function(a, b) { return a < b ? -1 : a > b ? 1 : 0; }).slice(idx, idx + width)); }); /** * Creates a new function that, when invoked, caches the result of calling `fn` * for a given argument set and returns the result. Subsequent calls to the * memoized `fn` with the same argument set will not result in an additional * call to `fn`; instead, the cached result for that set of arguments will be * returned. * * * @func * @memberOf R * @since v0.24.0 * @category Function * @sig (*... -> String) -> (*... -> a) -> (*... -> a) * @param {Function} fn The function to generate the cache key. * @param {Function} fn The function to memoize. * @return {Function} Memoized version of `fn`. * @example * * let count = 0; * const factorial = R.memoizeWith(R.identity, n => { * count += 1; * return R.product(R.range(1, n + 1)); * }); * factorial(5); //=> 120 * factorial(5); //=> 120 * factorial(5); //=> 120 * count; //=> 1 */ var memoizeWith = _curry2(function memoizeWith(mFn, fn) { var cache = {}; return _arity(fn.length, function() { var key = mFn.apply(this, arguments); if (!_has(key, cache)) { cache[key] = fn.apply(this, arguments); } return cache[key]; }); }); /** * Create a new object with the own properties of the first object merged with * the own properties of the second object. If a key exists in both objects, * the value from the second object will be used. * * @func * @memberOf R * @since v0.1.0 * @category Object * @sig {k: v} -> {k: v} -> {k: v} * @param {Object} l * @param {Object} r * @return {Object} * @see R.mergeRight, R.mergeDeepRight, R.mergeWith, R.mergeWithKey * @deprecated since v0.26.0 * @example * * R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 }); * //=> { 'name': 'fred', 'age': 40 } * * const withDefaults = R.merge({x: 0, y: 0}); * withDefaults({y: 2}); //=> {x: 0, y: 2} * @symb R.merge(a, b) = {...a, ...b} */ var merge = _curry2(function merge(l, r) { return _objectAssign$1({}, l, r); }); /** * Merges a list of objects together into one object. * * @func * @memberOf R * @since v0.10.0 * @category List * @sig [{k: v}] -> {k: v} * @param {Array} list An array of objects * @return {Object} A merged object. * @see R.reduce * @example * * R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3} * R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2} * @symb R.mergeAll([{ x: 1 }, { y: 2 }, { z: 3 }]) = { x: 1, y: 2, z: 3 } */ var mergeAll = _curry1(function mergeAll(list) { return _objectAssign$1.apply(null, [{}].concat(list)); }); /** * Creates a new object with the own properties of the two provided objects. If * a key exists in both objects, the provided function is applied to the key * and the values associated with the key in each object, with the result being * used as the value associated with the key in the returned object. * * @func * @memberOf R * @since v0.19.0 * @category Object * @sig ((String, a, a) -> a) -> {a} -> {a} -> {a} * @param {Function} fn * @param {Object} l * @param {Object} r * @return {Object} * @see R.mergeDeepWithKey, R.merge, R.mergeWith * @example * * let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r * R.mergeWithKey(concatValues, * { a: true, thing: 'foo', values: [10, 20] }, * { b: true, thing: 'bar', values: [15, 35] }); * //=> { a: true, b: true, thing: 'bar', values: [10, 20, 15, 35] } * @symb R.mergeWithKey(f, { x: 1, y: 2 }, { y: 5, z: 3 }) = { x: 1, y: f('y', 2, 5), z: 3 } */ var mergeWithKey = _curry3(function mergeWithKey(fn, l, r) { var result = {}; var k; for (k in l) { if (_has(k, l)) { result[k] = _has(k, r) ? fn(k, l[k], r[k]) : l[k]; } } for (k in r) { if (_has(k, r) && !(_has(k, result))) { result[k] = r[k]; } } return result; }); /** * Creates a new object with the own properties of the two provided objects. * If a key exists in both objects: * - and both associated values are also objects then the values will be * recursively merged. * - otherwise the provided function is applied to the key and associated values * using the resulting value as the new value associated with the key. * If a key only exists in one object, the value will be associated with the key * of the resulting object. * * @func * @memberOf R * @since v0.24.0 * @category Object * @sig ((String, a, a) -> a) -> {a} -> {a} -> {a} * @param {Function} fn * @param {Object} lObj * @param {Object} rObj * @return {Object} * @see R.mergeWithKey, R.mergeDeepWith * @example * * let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r * R.mergeDeepWithKey(concatValues, * { a: true, c: { thing: 'foo', values: [10, 20] }}, * { b: true, c: { thing: 'bar', values: [15, 35] }}); * //=> { a: true, b: true, c: { thing: 'bar', values: [10, 20, 15, 35] }} */ var mergeDeepWithKey = _curry3(function mergeDeepWithKey(fn, lObj, rObj) { return mergeWithKey(function(k, lVal, rVal) { if (_isObject(lVal) && _isObject(rVal)) { return mergeDeepWithKey(fn, lVal, rVal); } else { return fn(k, lVal, rVal); } }, lObj, rObj); }); /** * Creates a new object with the own properties of the first object merged with * the own properties of the second object. If a key exists in both objects: * - and both values are objects, the two values will be recursively merged * - otherwise the value from the first object will be used. * * @func * @memberOf R * @since v0.24.0 * @category Object * @sig {a} -> {a} -> {a} * @param {Object} lObj * @param {Object} rObj * @return {Object} * @see R.merge, R.mergeDeepRight, R.mergeDeepWith, R.mergeDeepWithKey * @example * * R.mergeDeepLeft({ name: 'fred', age: 10, contact: { email: 'moo@example.com' }}, * { age: 40, contact: { email: 'baa@example.com' }}); * //=> { name: 'fred', age: 10, contact: { email: 'moo@example.com' }} */ var mergeDeepLeft = _curry2(function mergeDeepLeft(lObj, rObj) { return mergeDeepWithKey(function(k, lVal, rVal) { return lVal; }, lObj, rObj); }); /** * Creates a new object with the own properties of the first object merged with * the own properties of the second object. If a key exists in both objects: * - and both values are objects, the two values will be recursively merged * - otherwise the value from the second object will be used. * * @func * @memberOf R * @since v0.24.0 * @category Object * @sig {a} -> {a} -> {a} * @param {Object} lObj * @param {Object} rObj * @return {Object} * @see R.merge, R.mergeDeepLeft, R.mergeDeepWith, R.mergeDeepWithKey * @example * * R.mergeDeepRight({ name: 'fred', age: 10, contact: { email: 'moo@example.com' }}, * { age: 40, contact: { email: 'baa@example.com' }}); * //=> { name: 'fred', age: 40, contact: { email: 'baa@example.com' }} */ var mergeDeepRight = _curry2(function mergeDeepRight(lObj, rObj) { return mergeDeepWithKey(function(k, lVal, rVal) { return rVal; }, lObj, rObj); }); /** * Creates a new object with the own properties of the two provided objects. * If a key exists in both objects: * - and both associated values are also objects then the values will be * recursively merged. * - otherwise the provided function is applied to associated values using the * resulting value as the new value associated with the key. * If a key only exists in one object, the value will be associated with the key * of the resulting object. * * @func * @memberOf R * @since v0.24.0 * @category Object * @sig ((a, a) -> a) -> {a} -> {a} -> {a} * @param {Function} fn * @param {Object} lObj * @param {Object} rObj * @return {Object} * @see R.mergeWith, R.mergeDeepWithKey * @example * * R.mergeDeepWith(R.concat, * { a: true, c: { values: [10, 20] }}, * { b: true, c: { values: [15, 35] }}); * //=> { a: true, b: true, c: { values: [10, 20, 15, 35] }} */ var mergeDeepWith = _curry3(function mergeDeepWith(fn, lObj, rObj) { return mergeDeepWithKey(function(k, lVal, rVal) { return fn(lVal, rVal); }, lObj, rObj); }); /** * Create a new object with the own properties of the first object merged with * the own properties of the second object. If a key exists in both objects, * the value from the first object will be used. * * @func * @memberOf R * @since v0.26.0 * @category Object * @sig {k: v} -> {k: v} -> {k: v} * @param {Object} l * @param {Object} r * @return {Object} * @see R.mergeRight, R.mergeDeepLeft, R.mergeWith, R.mergeWithKey * @example * * R.mergeLeft({ 'age': 40 }, { 'name': 'fred', 'age': 10 }); * //=> { 'name': 'fred', 'age': 40 } * * const resetToDefault = R.mergeLeft({x: 0}); * resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2} * @symb R.mergeLeft(a, b) = {...b, ...a} */ var mergeLeft = _curry2(function mergeLeft(l, r) { return _objectAssign$1({}, r, l); }); /** * Create a new object with the own properties of the first object merged with * the own properties of the second object. If a key exists in both objects, * the value from the second object will be used. * * @func * @memberOf R * @since v0.26.0 * @category Object * @sig {k: v} -> {k: v} -> {k: v} * @param {Object} l * @param {Object} r * @return {Object} * @see R.mergeLeft, R.mergeDeepRight, R.mergeWith, R.mergeWithKey * @example * * R.mergeRight({ 'name': 'fred', 'age': 10 }, { 'age': 40 }); * //=> { 'name': 'fred', 'age': 40 } * * const withDefaults = R.mergeRight({x: 0, y: 0}); * withDefaults({y: 2}); //=> {x: 0, y: 2} * @symb R.mergeRight(a, b) = {...a, ...b} */ var mergeRight = _curry2(function mergeRight(l, r) { return _objectAssign$1({}, l, r); }); /** * Creates a new object with the own properties of the two provided objects. If * a key exists in both objects, the provided function is applied to the values * associated with the key in each object, with the result being used as the * value associated with the key in the returned object. * * @func * @memberOf R * @since v0.19.0 * @category Object * @sig ((a, a) -> a) -> {a} -> {a} -> {a} * @param {Function} fn * @param {Object} l * @param {Object} r * @return {Object} * @see R.mergeDeepWith, R.merge, R.mergeWithKey * @example * * R.mergeWith(R.concat, * { a: true, values: [10, 20] }, * { b: true, values: [15, 35] }); * //=> { a: true, b: true, values: [10, 20, 15, 35] } */ var mergeWith = _curry3(function mergeWith(fn, l, r) { return mergeWithKey(function(_, _l, _r) { return fn(_l, _r); }, l, r); }); /** * Returns the smaller of its two arguments. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig Ord a => a -> a -> a * @param {*} a * @param {*} b * @return {*} * @see R.minBy, R.max * @example * * R.min(789, 123); //=> 123 * R.min('a', 'b'); //=> 'a' */ var min = _curry2(function min(a, b) { return b < a ? b : a; }); /** * Takes a function and two values, and returns whichever value produces the * smaller result when passed to the provided function. * * @func * @memberOf R * @since v0.8.0 * @category Relation * @sig Ord b => (a -> b) -> a -> a -> a * @param {Function} f * @param {*} a * @param {*} b * @return {*} * @see R.min, R.maxBy * @example * * // square :: Number -> Number * const square = n => n * n; * * R.minBy(square, -3, 2); //=> 2 * * R.reduce(R.minBy(square), Infinity, [3, -5, 4, 1, -2]); //=> 1 * R.reduce(R.minBy(square), Infinity, []); //=> Infinity */ var minBy = _curry3(function minBy(f, a, b) { return f(b) < f(a) ? b : a; }); /** * Divides the first parameter by the second and returns the remainder. Note * that this function preserves the JavaScript-style behavior for modulo. For * mathematical modulo see [`mathMod`](#mathMod). * * @func * @memberOf R * @since v0.1.1 * @category Math * @sig Number -> Number -> Number * @param {Number} a The value to the divide. * @param {Number} b The pseudo-modulus * @return {Number} The result of `b % a`. * @see R.mathMod * @example * * R.modulo(17, 3); //=> 2 * // JS behavior: * R.modulo(-17, 3); //=> -2 * R.modulo(17, -3); //=> 2 * * const isOdd = R.modulo(R.__, 2); * isOdd(42); //=> 0 * isOdd(21); //=> 1 */ var modulo = _curry2(function modulo(a, b) { return a % b; }); /** * Move an item, at index `from`, to index `to`, in a list of elements. * A new list will be created containing the new elements order. * * @func * @memberOf R * @since v0.27.1 * @category List * @sig Number -> Number -> [a] -> [a] * @param {Number} from The source index * @param {Number} to The destination index * @param {Array} list The list which will serve to realise the move * @return {Array} The new list reordered * @example * * R.move(0, 2, ['a', 'b', 'c', 'd', 'e', 'f']); //=> ['b', 'c', 'a', 'd', 'e', 'f'] * R.move(-1, 0, ['a', 'b', 'c', 'd', 'e', 'f']); //=> ['f', 'a', 'b', 'c', 'd', 'e'] list rotation */ var move = _curry3(function(from, to, list) { var length = list.length; var result = list.slice(); var positiveFrom = from < 0 ? length + from : from; var positiveTo = to < 0 ? length + to : to; var item = result.splice(positiveFrom, 1); return positiveFrom < 0 || positiveFrom >= list.length || positiveTo < 0 || positiveTo >= list.length ? list : [] .concat(result.slice(0, positiveTo)) .concat(item) .concat(result.slice(positiveTo, list.length)); }); /** * Multiplies two numbers. Equivalent to `a * b` but curried. * * @func * @memberOf R * @since v0.1.0 * @category Math * @sig Number -> Number -> Number * @param {Number} a The first value. * @param {Number} b The second value. * @return {Number} The result of `a * b`. * @see R.divide * @example * * const double = R.multiply(2); * const triple = R.multiply(3); * double(3); //=> 6 * triple(4); //=> 12 * R.multiply(2, 5); //=> 10 */ var multiply = _curry2(function multiply(a, b) { return a * b; }); /** * Negates its argument. * * @func * @memberOf R * @since v0.9.0 * @category Math * @sig Number -> Number * @param {Number} n * @return {Number} * @example * * R.negate(42); //=> -42 */ var negate = _curry1(function negate(n) { return -n; }); /** * Returns `true` if no elements of the list match the predicate, `false` * otherwise. * * Dispatches to the `all` method of the second argument, if present. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.12.0 * @category List * @sig (a -> Boolean) -> [a] -> Boolean * @param {Function} fn The predicate function. * @param {Array} list The array to consider. * @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise. * @see R.all, R.any * @example * * const isEven = n => n % 2 === 0; * const isOdd = n => n % 2 === 1; * * R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true * R.none(isOdd, [1, 3, 5, 7, 8, 11]); //=> false */ var none = _curry2(function none(fn, input) { return all(_complement(fn), input); }); /** * Returns a function which returns its nth argument. * * @func * @memberOf R * @since v0.9.0 * @category Function * @sig Number -> *... -> * * @param {Number} n * @return {Function} * @example * * R.nthArg(1)('a', 'b', 'c'); //=> 'b' * R.nthArg(-1)('a', 'b', 'c'); //=> 'c' * @symb R.nthArg(-1)(a, b, c) = c * @symb R.nthArg(0)(a, b, c) = a * @symb R.nthArg(1)(a, b, c) = b */ var nthArg = _curry1(function nthArg(n) { var arity = n < 0 ? 1 : n + 1; return curryN(arity, function() { return nth(n, arguments); }); }); /** * `o` is a curried composition function that returns a unary function. * Like [`compose`](#compose), `o` performs right-to-left function composition. * Unlike [`compose`](#compose), the rightmost function passed to `o` will be * invoked with only one argument. Also, unlike [`compose`](#compose), `o` is * limited to accepting only 2 unary functions. The name o was chosen because * of its similarity to the mathematical composition operator ∘. * * @func * @memberOf R * @since v0.24.0 * @category Function * @sig (b -> c) -> (a -> b) -> a -> c * @param {Function} f * @param {Function} g * @return {Function} * @see R.compose, R.pipe * @example * * const classyGreeting = name => "The name's " + name.last + ", " + name.first + " " + name.last * const yellGreeting = R.o(R.toUpper, classyGreeting); * yellGreeting({first: 'James', last: 'Bond'}); //=> "THE NAME'S BOND, JAMES BOND" * * R.o(R.multiply(10), R.add(10))(-4) //=> 60 * * @symb R.o(f, g, x) = f(g(x)) */ var o = _curry3(function o(f, g, x) { return f(g(x)); }); function _of(x) { return [x]; } /** * Returns a singleton array containing the value provided. * * Note this `of` is different from the ES6 `of`; See * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of * * @func * @memberOf R * @since v0.3.0 * @category Function * @sig a -> [a] * @param {*} x any value * @return {Array} An array wrapping `x`. * @example * * R.of(null); //=> [null] * R.of([42]); //=> [[42]] */ var of = _curry1(_of); /** * Returns a partial copy of an object omitting the keys specified. * * @func * @memberOf R * @since v0.1.0 * @category Object * @sig [String] -> {String: *} -> {String: *} * @param {Array} names an array of String property names to omit from the new object * @param {Object} obj The object to copy from * @return {Object} A new object with properties from `names` not on it. * @see R.pick * @example * * R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3} */ var omit = _curry2(function omit(names, obj) { var result = {}; var index = {}; var idx = 0; var len = names.length; while (idx < len) { index[names[idx]] = 1; idx += 1; } for (var prop in obj) { if (!index.hasOwnProperty(prop)) { result[prop] = obj[prop]; } } return result; }); /** * Accepts a function `fn` and returns a function that guards invocation of * `fn` such that `fn` can only ever be called once, no matter how many times * the returned function is invoked. The first value calculated is returned in * subsequent invocations. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig (a... -> b) -> (a... -> b) * @param {Function} fn The function to wrap in a call-only-once wrapper. * @return {Function} The wrapped function. * @example * * const addOneOnce = R.once(x => x + 1); * addOneOnce(10); //=> 11 * addOneOnce(addOneOnce(50)); //=> 11 */ var once = _curry1(function once(fn) { var called = false; var result; return _arity(fn.length, function() { if (called) { return result; } called = true; result = fn.apply(this, arguments); return result; }); }); function _assertPromise(name, p) { if (p == null || !_isFunction(p.then)) { throw new TypeError('`' + name + '` expected a Promise, received ' + _toString(p, [])); } } /** * Returns the result of applying the onFailure function to the value inside * a failed promise. This is useful for handling rejected promises * inside function compositions. * * @func * @memberOf R * @since v0.26.0 * @category Function * @sig (e -> b) -> (Promise e a) -> (Promise e b) * @sig (e -> (Promise f b)) -> (Promise e a) -> (Promise f b) * @param {Function} onFailure The function to apply. Can return a value or a promise of a value. * @param {Promise} p * @return {Promise} The result of calling `p.then(null, onFailure)` * @see R.then * @example * * var failedFetch = (id) => Promise.reject('bad ID'); * var useDefault = () => ({ firstName: 'Bob', lastName: 'Loblaw' }) * * //recoverFromFailure :: String -> Promise ({firstName, lastName}) * var recoverFromFailure = R.pipe( * failedFetch, * R.otherwise(useDefault), * R.then(R.pick(['firstName', 'lastName'])), * ); * recoverFromFailure(12345).then(console.log) */ var otherwise = _curry2(function otherwise(f, p) { _assertPromise('otherwise', p); return p.then(null, f); }); // `Identity` is a functor that holds a single value, where `map` simply // transforms the held value with the provided function. var Identity = function(x) { return {value: x, map: function(f) { return Identity(f(x)); }}; };
/** * Returns the result of "setting" the portion of the given data structure * focused by the given lens to the result of applying the given function to * the focused value. * * @func * @memberOf R * @since v0.16.0 * @category Object * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s * @sig Lens s a -> (a -> a) -> s -> s * @param {Lens} lens * @param {*} v * @param {*} x * @return {*} * @see R.prop, R.lensIndex, R.lensProp * @example * * const headLens = R.lensIndex(0); * * R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz'] */ var over = _curry3(function over(lens, f, x) { // The value returned by the getter function is first transformed with `f`, // then set as the value of an `Identity`. This is then mapped over with the // setter function of the lens. return lens(function(y) { return Identity(f(y)); })(x).value; }); /** * Takes two arguments, `fst` and `snd`, and returns `[fst, snd]`. * * @func * @memberOf R * @since v0.18.0 * @category List * @sig a -> b -> (a,b) * @param {*} fst * @param {*} snd * @return {Array} * @see R.objOf, R.of * @example * * R.pair('foo', 'bar'); //=> ['foo', 'bar'] */ var pair = _curry2(function pair(fst, snd) { return [fst, snd]; }); function _createPartialApplicator(concat) { return _curry2(function(fn, args) { return _arity(Math.max(0, fn.length - args.length), function() { return fn.apply(this, concat(args, arguments)); }); }); } /** * Takes a function `f` and a list of arguments, and returns a function `g`. * When applied, `g` returns the result of applying `f` to the arguments * provided initially followed by the arguments provided to `g`. * * @func * @memberOf R * @since v0.10.0 * @category Function * @sig ((a, b, c, ..., n) -> x) -> [a, b, c, ...] -> ((d, e, f, ..., n) -> x) * @param {Function} f * @param {Array} args * @return {Function} * @see R.partialRight, R.curry * @example * * const multiply2 = (a, b) => a * b; * const double = R.partial(multiply2, [2]); * double(2); //=> 4 * * const greet = (salutation, title, firstName, lastName) => * salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!'; * * const sayHello = R.partial(greet, ['Hello']); * const sayHelloToMs = R.partial(sayHello, ['Ms.']); * sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!' * @symb R.partial(f, [a, b])(c, d) = f(a, b, c, d) */ var partial = _createPartialApplicator(_concat); /** * Takes a function `f` and a list of arguments, and returns a function `g`. * When applied, `g` returns the result of applying `f` to the arguments * provided to `g` followed by the arguments provided initially. * * @func * @memberOf R * @since v0.10.0 * @category Function * @sig ((a, b, c, ..., n) -> x) -> [d, e, f, ..., n] -> ((a, b, c, ...) -> x) * @param {Function} f * @param {Array} args * @return {Function} * @see R.partial * @example * * const greet = (salutation, title, firstName, lastName) => * salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!'; * * const greetMsJaneJones = R.partialRight(greet, ['Ms.', 'Jane', 'Jones']); * * greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!' * @symb R.partialRight(f, [a, b])(c, d) = f(c, d, a, b) */ var partialRight = _createPartialApplicator(flip(_concat)); /** * Takes a predicate and a list or other `Filterable` object and returns the * pair of filterable objects of the same type of elements which do and do not * satisfy, the predicate, respectively. Filterable objects include plain objects or any object * that has a filter method such as `Array`. * * @func * @memberOf R * @since v0.1.4 * @category List * @sig Filterable f => (a -> Boolean) -> f a -> [f a, f a] * @param {Function} pred A predicate to determine which side the element belongs to. * @param {Array} filterable the list (or other filterable) to partition. * @return {Array} An array, containing first the subset of elements that satisfy the * predicate, and second the subset of elements that do not satisfy. * @see R.filter, R.reject * @example * * R.partition(R.includes('s'), ['sss', 'ttt', 'foo', 'bars']); * // => [ [ 'sss', 'bars' ], [ 'ttt', 'foo' ] ] * * R.partition(R.includes('s'), { a: 'sss', b: 'ttt', foo: 'bars' }); * // => [ { a: 'sss', foo: 'bars' }, { b: 'ttt' } ] */ var partition = juxt([filter, reject]); /** * Determines whether a nested path on an object has a specific value, in * [`R.equals`](#equals) terms. Most likely used to filter a list. * * @func * @memberOf R * @since v0.7.0 * @category Relation * @typedefn Idx = String | Int * @sig [Idx] -> a -> {a} -> Boolean * @param {Array} path The path of the nested property to use * @param {*} val The value to compare the nested property with * @param {Object} obj The object to check the nested property in * @return {Boolean} `true` if the value equals the nested object property, * `false` otherwise. * @example * * const user1 = { address: { zipCode: 90210 } }; * const user2 = { address: { zipCode: 55555 } }; * const user3 = { name: 'Bob' }; * const users = [ user1, user2, user3 ]; * const isFamous = R.pathEq(['address', 'zipCode'], 90210); * R.filter(isFamous, users); //=> [ user1 ] */ var pathEq = _curry3(function pathEq(_path, val, obj) { return equals(path(_path, obj), val); }); /** * If the given, non-null object has a value at the given path, returns the * value at that path. Otherwise returns the provided default value. * * @func * @memberOf R * @since v0.18.0 * @category Object * @typedefn Idx = String | Int * @sig a -> [Idx] -> {a} -> a * @param {*} d The default value. * @param {Array} p The path to use. * @param {Object} obj The object to retrieve the nested property from. * @return {*} The data at `path` of the supplied object or the default value. * @example * * R.pathOr('N/A', ['a', 'b'], {a: {b: 2}}); //=> 2 * R.pathOr('N/A', ['a', 'b'], {c: {b: 2}}); //=> "N/A" */ var pathOr = _curry3(function pathOr(d, p, obj) { return defaultTo(d, path(p, obj)); }); /** * Returns `true` if the specified object property at given path satisfies the * given predicate; `false` otherwise. * * @func * @memberOf R * @since v0.19.0 * @category Logic * @typedefn Idx = String | Int * @sig (a -> Boolean) -> [Idx] -> {a} -> Boolean * @param {Function} pred * @param {Array} propPath * @param {*} obj * @return {Boolean} * @see R.propSatisfies, R.path * @example * * R.pathSatisfies(y => y > 0, ['x', 'y'], {x: {y: 2}}); //=> true * R.pathSatisfies(R.is(Object), [], {x: {y: 2}}); //=> true */ var pathSatisfies = _curry3(function pathSatisfies(pred, propPath, obj) { return pred(path(propPath, obj)); }); /** * Returns a partial copy of an object containing only the keys specified. If * the key does not exist, the property is ignored. * * @func * @memberOf R * @since v0.1.0 * @category Object * @sig [k] -> {k: v} -> {k: v} * @param {Array} names an array of String property names to copy onto a new object * @param {Object} obj The object to copy from * @return {Object} A new object with only properties from `names` on it. * @see R.omit, R.props * @example * * R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4} * R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1} */ var pick = _curry2(function pick(names, obj) { var result = {}; var idx = 0; while (idx < names.length) { if (names[idx] in obj) { result[names[idx]] = obj[names[idx]]; } idx += 1; } return result; }); /** * Similar to `pick` except that this one includes a `key: undefined` pair for * properties that don't exist. * * @func * @memberOf R * @since v0.1.0 * @category Object * @sig [k] -> {k: v} -> {k: v} * @param {Array} names an array of String property names to copy onto a new object * @param {Object} obj The object to copy from * @return {Object} A new object with only properties from `names` on it. * @see R.pick * @example * * R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4} * R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined} */ var pickAll = _curry2(function pickAll(names, obj) { var result = {}; var idx = 0; var len = names.length; while (idx < len) { var name = names[idx]; result[name] = obj[name]; idx += 1; } return result; }); /** * Returns a partial copy of an object containing only the keys that satisfy * the supplied predicate. * * @func * @memberOf R * @since v0.8.0 * @category Object * @sig ((v, k) -> Boolean) -> {k: v} -> {k: v} * @param {Function} pred A predicate to determine whether or not a key * should be included on the output object. * @param {Object} obj The object to copy from * @return {Object} A new object with only properties that satisfy `pred` * on it. * @see R.pick, R.filter * @example * * const isUpperCase = (val, key) => key.toUpperCase() === key; * R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4} */ var pickBy = _curry2(function pickBy(test, obj) { var result = {}; for (var prop in obj) { if (test(obj[prop], prop, obj)) { result[prop] = obj[prop]; } } return result; }); /** * Returns the left-to-right Kleisli composition of the provided functions, * each of which must return a value of a type supported by [`chain`](#chain). * * `R.pipeK(f, g, h)` is equivalent to `R.pipe(f, R.chain(g), R.chain(h))`. * * @func * @memberOf R * @since v0.16.0 * @category Function * @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (a -> m z) * @param {...Function} * @return {Function} * @see R.composeK * @deprecated since v0.26.0 * @example * * // parseJson :: String -> Maybe * * // get :: String -> Object -> Maybe * * * // getStateCode :: Maybe String -> Maybe String * const getStateCode = R.pipeK( * parseJson, * get('user'), * get('address'), * get('state'), * R.compose(Maybe.of, R.toUpper) * ); * * getStateCode('{"user":{"address":{"state":"ny"}}}'); * //=> Just('NY') * getStateCode('[Invalid JSON]'); * //=> Nothing() * @symb R.pipeK(f, g, h)(a) = R.chain(h, R.chain(g, f(a))) */ function pipeK() { if (arguments.length === 0) { throw new Error('pipeK requires at least one argument'); } return composeK.apply(this, reverse(arguments)); } /** * Returns a new list with the given element at the front, followed by the * contents of the list. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig a -> [a] -> [a] * @param {*} el The item to add to the head of the output list. * @param {Array} list The array to add to the tail of the output list. * @return {Array} A new array. * @see R.append * @example * * R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum'] */ var prepend = _curry2(function prepend(el, list) { return _concat([el], list); }); /** * Multiplies together all the elements of a list. * * @func * @memberOf R * @since v0.1.0 * @category Math * @sig [Number] -> Number * @param {Array} list An array of numbers * @return {Number} The product of all the numbers in the list. * @see R.reduce * @example * * R.product([2,4,6,8,100,1]); //=> 38400 */ var product = reduce(multiply, 1); /** * Accepts a function `fn` and a list of transformer functions and returns a * new curried function. When the new function is invoked, it calls the * function `fn` with parameters consisting of the result of calling each * supplied handler on successive arguments to the new function. * * If more arguments are passed to the returned function than transformer * functions, those arguments are passed directly to `fn` as additional * parameters. If you expect additional arguments that don't need to be * transformed, although you can ignore them, it's best to pass an identity * function so that the new function reports the correct arity. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig ((x1, x2, ...) -> z) -> [(a -> x1), (b -> x2), ...] -> (a -> b -> ... -> z) * @param {Function} fn The function to wrap. * @param {Array} transformers A list of transformer functions * @return {Function} The wrapped function. * @see R.converge * @example * * R.useWith(Math.pow, [R.identity, R.identity])(3, 4); //=> 81 * R.useWith(Math.pow, [R.identity, R.identity])(3)(4); //=> 81 * R.useWith(Math.pow, [R.dec, R.inc])(3, 4); //=> 32 * R.useWith(Math.pow, [R.dec, R.inc])(3)(4); //=> 32 * @symb R.useWith(f, [g, h])(a, b) = f(g(a), h(b)) */ var useWith = _curry2(function useWith(fn, transformers) { return curryN(transformers.length, function() { var args = []; var idx = 0; while (idx < transformers.length) { args.push(transformers[idx].call(this, arguments[idx])); idx += 1; } return fn.apply(this, args.concat(Array.prototype.slice.call(arguments, transformers.length))); }); }); /** * Reasonable analog to SQL `select` statement. * * @func * @memberOf R * @since v0.1.0 * @category Object * @category Relation * @sig [k] -> [{k: v}] -> [{k: v}] * @param {Array} props The property names to project * @param {Array} objs The objects to query * @return {Array} An array of objects with just the `props` properties. * @example * * const abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2}; * const fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7}; * const kids = [abby, fred]; * R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}] */ var project = useWith(_map, [pickAll, identity]); // passing `identity` gives correct arity /** * Returns `true` if the specified object property is equal, in * [`R.equals`](#equals) terms, to the given value; `false` otherwise. * You can test multiple properties with [`R.whereEq`](#whereEq). * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig String -> a -> Object -> Boolean * @param {String} name * @param {*} val * @param {*} obj * @return {Boolean} * @see R.whereEq, R.propSatisfies, R.equals * @example * * const abby = {name: 'Abby', age: 7, hair: 'blond'}; * const fred = {name: 'Fred', age: 12, hair: 'brown'}; * const rusty = {name: 'Rusty', age: 10, hair: 'brown'}; * const alois = {name: 'Alois', age: 15, disposition: 'surly'}; * const kids = [abby, fred, rusty, alois]; * const hasBrownHair = R.propEq('hair', 'brown'); * R.filter(hasBrownHair, kids); //=> [fred, rusty] */ var propEq = _curry3(function propEq(name, val, obj) { return equals(val, obj[name]); }); /** * Returns `true` if the specified object property is of the given type; * `false` otherwise. * * @func * @memberOf R * @since v0.16.0 * @category Type * @sig Type -> String -> Object -> Boolean * @param {Function} type * @param {String} name * @param {*} obj * @return {Boolean} * @see R.is, R.propSatisfies * @example * * R.propIs(Number, 'x', {x: 1, y: 2}); //=> true * R.propIs(Number, 'x', {x: 'foo'}); //=> false * R.propIs(Number, 'x', {}); //=> false */ var propIs = _curry3(function propIs(type, name, obj) { return is(type, obj[name]); }); /** * If the given, non-null object has an own property with the specified name, * returns the value of that property. Otherwise returns the provided default * value. * * @func * @memberOf R * @since v0.6.0 * @category Object * @sig a -> String -> Object -> a * @param {*} val The default value. * @param {String} p The name of the property to return. * @param {Object} obj The object to query. * @return {*} The value of given property of the supplied object or the default value. * @example * * const alice = { * name: 'ALICE', * age: 101 * }; * const favorite = R.prop('favoriteLibrary'); * const favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary'); * * favorite(alice); //=> undefined * favoriteWithDefault(alice); //=> 'Ramda' */ var propOr = _curry3(function propOr(val, p, obj) { return pathOr(val, [p], obj); }); /** * Returns `true` if the specified object property satisfies the given * predicate; `false` otherwise. You can test multiple properties with * [`R.where`](#where). * * @func * @memberOf R * @since v0.16.0 * @category Logic * @sig (a -> Boolean) -> String -> {String: a} -> Boolean * @param {Function} pred * @param {String} name * @param {*} obj * @return {Boolean} * @see R.where, R.propEq, R.propIs * @example * * R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true */ var propSatisfies = _curry3(function propSatisfies(pred, name, obj) { return pred(obj[name]); }); /** * Acts as multiple `prop`: array of keys in, array of values out. Preserves * order. * * @func * @memberOf R * @since v0.1.0 * @category Object * @sig [k] -> {k: v} -> [v] * @param {Array} ps The property names to fetch * @param {Object} obj The object to query * @return {Array} The corresponding values or partially applied function. * @example * * R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2] * R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2] * * const fullName = R.compose(R.join(' '), R.props(['first', 'last'])); * fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth' */ var props = _curry2(function props(ps, obj) { return ps.map(function(p) { return path([p], obj); }); }); /** * Returns a list of numbers from `from` (inclusive) to `to` (exclusive). * * @func * @memberOf R * @since v0.1.0 * @category List * @sig Number -> Number -> [Number] * @param {Number} from The first number in the list. * @param {Number} to One more than the last number in the list. * @return {Array} The list of numbers in the set `[a, b)`. * @example * * R.range(1, 5); //=> [1, 2, 3, 4] * R.range(50, 53); //=> [50, 51, 52] */ var range = _curry2(function range(from, to) { if (!(_isNumber(from) && _isNumber(to))) { throw new TypeError('Both arguments to range must be numbers'); } var result = []; var n = from; while (n < to) { result.push(n); n += 1; } return result; }); /** * Returns a single item by iterating through the list, successively calling * the iterator function and passing it an accumulator value and the current * value from the array, and then passing the result to the next call. * * Similar to [`reduce`](#reduce), except moves through the input list from the * right to the left. * * The iterator function receives two values: *(value, acc)*, while the arguments' * order of `reduce`'s iterator function is *(acc, value)*. * * Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse * arrays), unlike the native `Array.prototype.reduceRight` method. For more details * on this behavior, see: * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description * * @func * @memberOf R * @since v0.1.0 * @category List * @sig ((a, b) -> b) -> b -> [a] -> b * @param {Function} fn The iterator function. Receives two values, the current element from the array * and the accumulator. * @param {*} acc The accumulator value. * @param {Array} list The list to iterate over. * @return {*} The final, accumulated value. * @see R.reduce, R.addIndex * @example * * R.reduceRight(R.subtract, 0, [1, 2, 3, 4]) // => (1 - (2 - (3 - (4 - 0)))) = -2 * // - -2 * // / \ / \ * // 1 - 1 3 * // / \ / \ * // 2 - ==> 2 -1 * // / \ / \ * // 3 - 3 4 * // / \ / \ * // 4 0 4 0 * * @symb R.reduceRight(f, a, [b, c, d]) = f(b, f(c, f(d, a))) */ var reduceRight = _curry3(function reduceRight(fn, acc, list) { var idx = list.length - 1; while (idx >= 0) { acc = fn(list[idx], acc); idx -= 1; } return acc; }); /** * Like [`reduce`](#reduce), `reduceWhile` returns a single item by iterating * through the list, successively calling the iterator function. `reduceWhile` * also takes a predicate that is evaluated before each step. If the predicate * returns `false`, it "short-circuits" the iteration and returns the current * value of the accumulator. * * @func * @memberOf R * @since v0.22.0 * @category List * @sig ((a, b) -> Boolean) -> ((a, b) -> a) -> a -> [b] -> a * @param {Function} pred The predicate. It is passed the accumulator and the * current element. * @param {Function} fn The iterator function. Receives two values, the * accumulator and the current element. * @param {*} a The accumulator value. * @param {Array} list The list to iterate over. * @return {*} The final, accumulated value. * @see R.reduce, R.reduced * @example * * const isOdd = (acc, x) => x % 2 === 1; * const xs = [1, 3, 5, 60, 777, 800]; * R.reduceWhile(isOdd, R.add, 0, xs); //=> 9 * * const ys = [2, 4, 6] * R.reduceWhile(isOdd, R.add, 111, ys); //=> 111 */ var reduceWhile = _curryN(4, [], function _reduceWhile(pred, fn, a, list) { return _reduce(function(acc, x) { return pred(acc, x) ? fn(acc, x) : _reduced(acc); }, a, list); }); /** * Returns a value wrapped to indicate that it is the final value of the reduce * and transduce functions. The returned value should be considered a black * box: the internal structure is not guaranteed to be stable. * * Note: this optimization is only available to the below functions: * - [`reduce`](#reduce) * - [`reduceWhile`](#reduceWhile) * - [`transduce`](#transduce) * * @func * @memberOf R * @since v0.15.0 * @category List * @sig a -> * * @param {*} x The final value of the reduce. * @return {*} The wrapped value. * @see R.reduce, R.reduceWhile, R.transduce * @example * * R.reduce( * (acc, item) => item > 3 ? R.reduced(acc) : acc.concat(item), * [], * [1, 2, 3, 4, 5]) // [1, 2, 3] */ var reduced = _curry1(_reduced); /** * Calls an input function `n` times, returning an array containing the results * of those function calls. * * `fn` is passed one argument: The current value of `n`, which begins at `0` * and is gradually incremented to `n - 1`. * * @func * @memberOf R * @since v0.2.3 * @category List * @sig (Number -> a) -> Number -> [a] * @param {Function} fn The function to invoke. Passed one argument, the current value of `n`. * @param {Number} n A value between `0` and `n - 1`. Increments after each function call. * @return {Array} An array containing the return values of all calls to `fn`. * @see R.repeat * @example * * R.times(R.identity, 5); //=> [0, 1, 2, 3, 4] * @symb R.times(f, 0) = [] * @symb R.times(f, 1) = [f(0)] * @symb R.times(f, 2) = [f(0), f(1)] */ var times = _curry2(function times(fn, n) { var len = Number(n); var idx = 0; var list; if (len < 0 || isNaN(len)) { throw new RangeError('n must be a non-negative number'); } list = new Array(len); while (idx < len) { list[idx] = fn(idx); idx += 1; } return list; }); /** * Returns a fixed list of size `n` containing a specified identical value. * * @func * @memberOf R * @since v0.1.1 * @category List * @sig a -> n -> [a] * @param {*} value The value to repeat. * @param {Number} n The desired size of the output list. * @return {Array} A new array containing `n` `value`s. * @see R.times * @example * * R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi'] * * const obj = {}; * const repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}] * repeatedObjs[0] === repeatedObjs[1]; //=> true * @symb R.repeat(a, 0) = [] * @symb R.repeat(a, 1) = [a] * @symb R.repeat(a, 2) = [a, a] */ var repeat = _curry2(function repeat(value, n) { return times(always(value), n); }); /** * Replace a substring or regex match in a string with a replacement. * * The first two parameters correspond to the parameters of the * `String.prototype.replace()` function, so the second parameter can also be a * function. * * @func * @memberOf R * @since v0.7.0 * @category String * @sig RegExp|String -> String -> String -> String * @param {RegExp|String} pattern A regular expression or a substring to match. * @param {String} replacement The string to replace the matches with. * @param {String} str The String to do the search and replacement in. * @return {String} The result. * @example * * R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo' * R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo' * * // Use the "g" (global) flag to replace all occurrences: * R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar' */ var replace = _curry3(function replace(regex, replacement, str) { return str.replace(regex, replacement); }); /** * Scan is similar to [`reduce`](#reduce), but returns a list of successively * reduced values from the left * * @func * @memberOf R * @since v0.10.0 * @category List * @sig ((a, b) -> a) -> a -> [b] -> [a] * @param {Function} fn The iterator function. Receives two values, the accumulator and the * current element from the array * @param {*} acc The accumulator value. * @param {Array} list The list to iterate over. * @return {Array} A list of all intermediately reduced values. * @see R.reduce, R.mapAccum * @example * * const numbers = [1, 2, 3, 4]; * const factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24] * @symb R.scan(f, a, [b, c]) = [a, f(a, b), f(f(a, b), c)] */ var scan = _curry3(function scan(fn, acc, list) { var idx = 0; var len = list.length; var result = [acc]; while (idx < len) { acc = fn(acc, list[idx]); result[idx + 1] = acc; idx += 1; } return result; }); /** * Transforms a [Traversable](https://github.com/fantasyland/fantasy-land#traversable) * of [Applicative](https://github.com/fantasyland/fantasy-land#applicative) into an * Applicative of Traversable. * * Dispatches to the `sequence` method of the second argument, if present. * * @func * @memberOf R * @since v0.19.0 * @category List * @sig (Applicative f, Traversable t) => (a -> f a) -> t (f a) -> f (t a) * @param {Function} of * @param {*} traversable * @return {*} * @see R.traverse * @example * * R.sequence(Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([1, 2, 3]) * R.sequence(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing() * * R.sequence(R.of, Just([1, 2, 3])); //=> [Just(1), Just(2), Just(3)] * R.sequence(R.of, Nothing()); //=> [Nothing()] */ var sequence = _curry2(function sequence(of, traversable) { return typeof traversable.sequence === 'function' ? traversable.sequence(of) : reduceRight( function(x, acc) { return ap(map(prepend, x), acc); }, of([]), traversable ); }); /** * Returns the result of "setting" the portion of the given data structure * focused by the given lens to the given value. * * @func * @memberOf R * @since v0.16.0 * @category Object * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s * @sig Lens s a -> a -> s -> s * @param {Lens} lens * @param {*} v * @param {*} x * @return {*} * @see R.prop, R.lensIndex, R.lensProp * @example * * const xLens = R.lensProp('x'); * * R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2} * R.set(xLens, 8, {x: 1, y: 2}); //=> {x: 8, y: 2} */ var set = _curry3(function set(lens, v, x) { return over(lens, always(v), x); }); /** * Returns a copy of the list, sorted according to the comparator function, * which should accept two values at a time and return a negative number if the * first value is smaller, a positive number if it's larger, and zero if they * are equal. Please note that this is a **copy** of the list. It does not * modify the original. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig ((a, a) -> Number) -> [a] -> [a] * @param {Function} comparator A sorting function :: a -> b -> Int * @param {Array} list The list to sort * @return {Array} a new array with its elements sorted by the comparator function. * @example * * const diff = function(a, b) { return a - b; }; * R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7] */ var sort = _curry2(function sort(comparator, list) { return Array.prototype.slice.call(list, 0).sort(comparator); }); /** * Sorts the list according to the supplied function. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig Ord b => (a -> b) -> [a] -> [a] * @param {Function} fn * @param {Array} list The list to sort. * @return {Array} A new list sorted by the keys generated by `fn`. * @example * * const sortByFirstItem = R.sortBy(R.prop(0)); * const pairs = [[-1, 1], [-2, 2], [-3, 3]]; * sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]] * * const sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name'))); * const alice = { * name: 'ALICE', * age: 101 * }; * const bob = { * name: 'Bob', * age: -10 * }; * const clara = { * name: 'clara', * age: 314.159 * }; * const people = [clara, bob, alice]; * sortByNameCaseInsensitive(people); //=> [alice, bob, clara] */ var sortBy = _curry2(function sortBy(fn, list) { return Array.prototype.slice.call(list, 0).sort(function(a, b) { var aa = fn(a); var bb = fn(b); return aa < bb ? -1 : aa > bb ? 1 : 0; }); }); /** * Sorts a list according to a list of comparators. * * @func * @memberOf R * @since v0.23.0 * @category Relation * @sig [(a, a) -> Number] -> [a] -> [a] * @param {Array} functions A list of comparator functions. * @param {Array} list The list to sort. * @return {Array} A new list sorted according to the comarator functions. * @example * * const alice = { * name: 'alice', * age: 40 * }; * const bob = { * name: 'bob', * age: 30 * }; * const clara = { * name: 'clara', * age: 40 * }; * const people = [clara, bob, alice]; * const ageNameSort = R.sortWith([ * R.descend(R.prop('age')), * R.ascend(R.prop('name')) * ]); * ageNameSort(people); //=> [alice, clara, bob] */ var sortWith = _curry2(function sortWith(fns, list) { return Array.prototype.slice.call(list, 0).sort(function(a, b) { var result = 0; var i = 0; while (result === 0 && i < fns.length) { result = fns[i](a, b); i += 1; } return result; }); }); /** * Splits a string into an array of strings based on the given * separator. * * @func * @memberOf R * @since v0.1.0 * @category String * @sig (String | RegExp) -> String -> [String] * @param {String|RegExp} sep The pattern. * @param {String} str The string to separate into an array. * @return {Array} The array of strings from `str` separated by `sep`. * @see R.join * @example * * const pathComponents = R.split('/'); * R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node'] * * R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd'] */ var split = invoker(1, 'split'); /** * Splits a given list or string at a given index. * * @func * @memberOf R * @since v0.19.0 * @category List * @sig Number -> [a] -> [[a], [a]] * @sig Number -> String -> [String, String] * @param {Number} index The index where the array/string is split. * @param {Array|String} array The array/string to be split. * @return {Array} * @example * * R.splitAt(1, [1, 2, 3]); //=> [[1], [2, 3]] * R.splitAt(5, 'hello world'); //=> ['hello', ' world'] * R.splitAt(-1, 'foobar'); //=> ['fooba', 'r'] */ var splitAt = _curry2(function splitAt(index, array) { return [slice(0, index, array), slice(index, length(array), array)]; }); /** * Splits a collection into slices of the specified length. * * @func * @memberOf R * @since v0.16.0 * @category List * @sig Number -> [a] -> [[a]] * @sig Number -> String -> [String] * @param {Number} n * @param {Array} list * @return {Array} * @example * * R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]] * R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz'] */ var splitEvery = _curry2(function splitEvery(n, list) { if (n <= 0) { throw new Error('First argument to splitEvery must be a positive integer'); } var result = []; var idx = 0; while (idx < list.length) { result.push(slice(idx, idx += n, list)); } return result; }); /** * Takes a list and a predicate and returns a pair of lists with the following properties: * * - the result of concatenating the two output lists is equivalent to the input list; * - none of the elements of the first output list satisfies the predicate; and * - if the second output list is non-empty, its first element satisfies the predicate. * * @func * @memberOf R * @since v0.19.0 * @category List * @sig (a -> Boolean) -> [a] -> [[a], [a]] * @param {Function} pred The predicate that determines where the array is split. * @param {Array} list The array to be split. * @return {Array} * @example * * R.splitWhen(R.equals(2), [1, 2, 3, 1, 2, 3]); //=> [[1], [2, 3, 1, 2, 3]] */ var splitWhen = _curry2(function splitWhen(pred, list) { var idx = 0; var len = list.length; var prefix = []; while (idx < len && !pred(list[idx])) { prefix.push(list[idx]); idx += 1; } return [prefix, Array.prototype.slice.call(list, idx)]; }); /** * Checks if a list starts with the provided sublist. * * Similarly, checks if a string starts with the provided substring. * * @func * @memberOf R * @since v0.24.0 * @category List * @sig [a] -> [a] -> Boolean * @sig String -> String -> Boolean * @param {*} prefix * @param {*} list * @return {Boolean} * @see R.endsWith * @example * * R.startsWith('a', 'abc') //=> true * R.startsWith('b', 'abc') //=> false * R.startsWith(['a'], ['a', 'b', 'c']) //=> true * R.startsWith(['b'], ['a', 'b', 'c']) //=> false */ var startsWith = _curry2(function(prefix, list) { return equals(take(prefix.length, list), prefix); }); /** * Subtracts its second argument from its first argument. * * @func * @memberOf R * @since v0.1.0 * @category Math * @sig Number -> Number -> Number * @param {Number} a The first value. * @param {Number} b The second value. * @return {Number} The result of `a - b`. * @see R.add * @example * * R.subtract(10, 8); //=> 2 * * const minus5 = R.subtract(R.__, 5); * minus5(17); //=> 12 * * const complementaryAngle = R.subtract(90); * complementaryAngle(30); //=> 60 * complementaryAngle(72); //=> 18 */ var subtract = _curry2(function subtract(a, b) { return Number(a) - Number(b); }); /** * Finds the set (i.e. no duplicates) of all elements contained in the first or * second list, but not both. * * @func * @memberOf R * @since v0.19.0 * @category Relation * @sig [*] -> [*] -> [*] * @param {Array} list1 The first list. * @param {Array} list2 The second list. * @return {Array} The elements in `list1` or `list2`, but not both. * @see R.symmetricDifferenceWith, R.difference, R.differenceWith * @example * * R.symmetricDifference([1,2,3,4], [7,6,5,4,3]); //=> [1,2,7,6,5] * R.symmetricDifference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5,1,2] */ var symmetricDifference = _curry2(function symmetricDifference(list1, list2) { return concat(difference(list1, list2), difference(list2, list1)); }); /** * Finds the set (i.e. no duplicates) of all elements contained in the first or * second list, but not both. Duplication is determined according to the value * returned by applying the supplied predicate to two list elements. * * @func * @memberOf R * @since v0.19.0 * @category Relation * @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a] * @param {Function} pred A predicate used to test whether two items are equal. * @param {Array} list1 The first list. * @param {Array} list2 The second list. * @return {Array} The elements in `list1` or `list2`, but not both. * @see R.symmetricDifference, R.difference, R.differenceWith * @example * * const eqA = R.eqBy(R.prop('a')); * const l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}]; * const l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}]; * R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}] */ var symmetricDifferenceWith = _curry3(function symmetricDifferenceWith(pred, list1, list2) { return concat(differenceWith(pred, list1, list2), differenceWith(pred, list2, list1)); }); /** * Returns a new list containing the last `n` elements of a given list, passing * each value to the supplied predicate function, and terminating when the * predicate function returns `false`. Excludes the element that caused the * predicate function to fail. The predicate function is passed one argument: * *(value)*. * * @func * @memberOf R * @since v0.16.0 * @category List * @sig (a -> Boolean) -> [a] -> [a] * @sig (a -> Boolean) -> String -> String * @param {Function} fn The function called per iteration. * @param {Array} xs The collection to iterate over. * @return {Array} A new array. * @see R.dropLastWhile, R.addIndex * @example * * const isNotOne = x => x !== 1; * * R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4] * * R.takeLastWhile(x => x !== 'R' , 'Ramda'); //=> 'amda' */ var takeLastWhile = _curry2(function takeLastWhile(fn, xs) { var idx = xs.length - 1; while (idx >= 0 && fn(xs[idx])) { idx -= 1; } return slice(idx + 1, Infinity, xs); }); function XTakeWhile(f, xf) { this.xf = xf; this.f = f; } XTakeWhile.prototype['@@transducer/init'] = _xfBase.init; XTakeWhile.prototype['@@transducer/result'] = _xfBase.result; XTakeWhile.prototype['@@transducer/step'] = function(result, input) { return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result); }; var _xtakeWhile = _curry2(function _xtakeWhile(f, xf) { return new XTakeWhile(f, xf); }); /** * Returns a new list containing the first `n` elements of a given list, * passing each value to the supplied predicate function, and terminating when * the predicate function returns `false`. Excludes the element that caused the * predicate function to fail. The predicate function is passed one argument: * *(value)*. * * Dispatches to the `takeWhile` method of the second argument, if present. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig (a -> Boolean) -> [a] -> [a] * @sig (a -> Boolean) -> String -> String * @param {Function} fn The function called per iteration. * @param {Array} xs The collection to iterate over. * @return {Array} A new array. * @see R.dropWhile, R.transduce, R.addIndex * @example * * const isNotFour = x => x !== 4; * * R.takeWhile(isNotFour, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3] * * R.takeWhile(x => x !== 'd' , 'Ramda'); //=> 'Ram' */ var takeWhile = _curry2(_dispatchable(['takeWhile'], _xtakeWhile, function takeWhile(fn, xs) { var idx = 0; var len = xs.length; while (idx < len && fn(xs[idx])) { idx += 1; } return slice(0, idx, xs); })); function XTap(f, xf) { this.xf = xf; this.f = f; } XTap.prototype['@@transducer/init'] = _xfBase.init; XTap.prototype['@@transducer/result'] = _xfBase.result; XTap.prototype['@@transducer/step'] = function(result, input) { this.f(input); return this.xf['@@transducer/step'](result, input); }; var _xtap = _curry2(function _xtap(f, xf) { return new XTap(f, xf); }); /** * Runs the given function with the supplied object, then returns the object. * * Acts as a transducer if a transformer is given as second parameter. * * @func * @memberOf R * @since v0.1.0 * @category Function * @sig (a -> *) -> a -> a * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away. * @param {*} x * @return {*} `x`. * @example * * const sayX = x => console.log('x is ' + x); * R.tap(sayX, 100); //=> 100 * // logs 'x is 100' * @symb R.tap(f, a) = a */ var tap = _curry2(_dispatchable([], _xtap, function tap(fn, x) { fn(x); return x; })); function _isRegExp(x) { return Object.prototype.toString.call(x) === '[object RegExp]'; } /** * Determines whether a given string matches a given regular expression. * * @func * @memberOf R * @since v0.12.0 * @category String * @sig RegExp -> String -> Boolean * @param {RegExp} pattern * @param {String} str * @return {Boolean} * @see R.match * @example * * R.test(/^x/, 'xyz'); //=> true * R.test(/^y/, 'xyz'); //=> false */ var test = _curry2(function test(pattern, str) { if (!_isRegExp(pattern)) { throw new TypeError('‘test’ requires a value of type RegExp as its first argument; received ' + toString$1(pattern)); } return _cloneRegExp(pattern).test(str); }); /** * Returns the result of applying the onSuccess function to the value inside * a successfully resolved promise. This is useful for working with promises * inside function compositions. * * @func * @memberOf R * @since v0.27.1 * @category Function * @sig (a -> b) -> (Promise e a) -> (Promise e b) * @sig (a -> (Promise e b)) -> (Promise e a) -> (Promise e b) * @param {Function} onSuccess The function to apply. Can return a value or a promise of a value. * @param {Promise} p * @return {Promise} The result of calling `p.then(onSuccess)` * @see R.otherwise * @example * * var makeQuery = (email) => ({ query: { email }}); * * //getMemberName :: String -> Promise ({firstName, lastName}) * var getMemberName = R.pipe( * makeQuery, * fetchMember, * R.andThen(R.pick(['firstName', 'lastName'])) * ); */ var andThen = _curry2(function andThen(f, p) { _assertPromise('andThen', p); return p.then(f); }); /** * The lower case version of a string. * * @func * @memberOf R * @since v0.9.0 * @category String * @sig String -> String * @param {String} str The string to lower case. * @return {String} The lower case version of `str`. * @see R.toUpper * @example * * R.toLower('XYZ'); //=> 'xyz' */ var toLower = invoker(0, 'toLowerCase'); /** * Converts an object into an array of key, value arrays. Only the object's * own properties are used. * Note that the order of the output array is not guaranteed to be consistent * across different JS platforms. * * @func * @memberOf R * @since v0.4.0 * @category Object * @sig {String: *} -> [[String,*]] * @param {Object} obj The object to extract from * @return {Array} An array of key, value arrays from the object's own properties. * @see R.fromPairs * @example * * R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]] */ var toPairs = _curry1(function toPairs(obj) { var pairs = []; for (var prop in obj) { if (_has(prop, obj)) { pairs[pairs.length] = [prop, obj[prop]]; } } return pairs; }); /** * Converts an object into an array of key, value arrays. The object's own * properties and prototype properties are used. Note that the order of the * output array is not guaranteed to be consistent across different JS * platforms. * * @func * @memberOf R * @since v0.4.0 * @category Object * @sig {String: *} -> [[String,*]] * @param {Object} obj The object to extract from * @return {Array} An array of key, value arrays from the object's own * and prototype properties. * @example * * const F = function() { this.x = 'X'; }; * F.prototype.y = 'Y'; * const f = new F(); * R.toPairsIn(f); //=> [['x','X'], ['y','Y']] */ var toPairsIn = _curry1(function toPairsIn(obj) { var pairs = []; for (var prop in obj) { pairs[pairs.length] = [prop, obj[prop]]; } return pairs; }); /** * The upper case version of a string. * * @func * @memberOf R * @since v0.9.0 * @category String * @sig String -> String * @param {String} str The string to upper case. * @return {String} The upper case version of `str`. * @see R.toLower * @example * * R.toUpper('abc'); //=> 'ABC' */ var toUpper = invoker(0, 'toUpperCase'); /** * Initializes a transducer using supplied iterator function. Returns a single * item by iterating through the list, successively calling the transformed * iterator function and passing it an accumulator value and the current value * from the array, and then passing the result to the next call. * * The iterator function receives two values: *(acc, value)*. It will be * wrapped as a transformer to initialize the transducer. A transformer can be * passed directly in place of an iterator function. In both cases, iteration * may be stopped early with the [`R.reduced`](#reduced) function. * * A transducer is a function that accepts a transformer and returns a * transformer and can be composed directly. * * A transformer is an an object that provides a 2-arity reducing iterator * function, step, 0-arity initial value function, init, and 1-arity result * extraction function, result. The step function is used as the iterator * function in reduce. The result function is used to convert the final * accumulator into the return type and in most cases is * [`R.identity`](#identity). The init function can be used to provide an * initial accumulator, but is ignored by transduce. * * The iteration is performed with [`R.reduce`](#reduce) after initializing the transducer. * * @func * @memberOf R * @since v0.12.0 * @category List * @sig (c -> c) -> ((a, b) -> a) -> a -> [b] -> a * @param {Function} xf The transducer function. Receives a transformer and returns a transformer. * @param {Function} fn The iterator function. Receives two values, the accumulator and the * current element from the array. Wrapped as transformer, if necessary, and used to * initialize the transducer * @param {*} acc The initial accumulator value. * @param {Array} list The list to iterate over. * @return {*} The final, accumulated value. * @see R.reduce, R.reduced, R.into * @example * * const numbers = [1, 2, 3, 4]; * const transducer = R.compose(R.map(R.add(1)), R.take(2)); * R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3] * * const isOdd = (x) => x % 2 === 1; * const firstOddTransducer = R.compose(R.filter(isOdd), R.take(1)); * R.transduce(firstOddTransducer, R.flip(R.append), [], R.range(0, 100)); //=> [1] */ var transduce = curryN(4, function transduce(xf, fn, acc, list) { return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list); }); /** * Transposes the rows and columns of a 2D list. * When passed a list of `n` lists of length `x`, * returns a list of `x` lists of length `n`. * * * @func * @memberOf R * @since v0.19.0 * @category List * @sig [[a]] -> [[a]] * @param {Array} list A 2D list * @return {Array} A 2D list * @example * * R.transpose([[1, 'a'], [2, 'b'], [3, 'c']]) //=> [[1, 2, 3], ['a', 'b', 'c']] * R.transpose([[1, 2, 3], ['a', 'b', 'c']]) //=> [[1, 'a'], [2, 'b'], [3, 'c']] * * // If some of the rows are shorter than the following rows, their elements are skipped: * R.transpose([[10, 11], [20], [], [30, 31, 32]]) //=> [[10, 20, 30], [11, 31], [32]] * @symb R.transpose([[a], [b], [c]]) = [a, b, c] * @symb R.transpose([[a, b], [c, d]]) = [[a, c], [b, d]] * @symb R.transpose([[a, b], [c]]) = [[a, c], [b]] */ var transpose = _curry1(function transpose(outerlist) { var i = 0; var result = []; while (i < outerlist.length) { var innerlist = outerlist[i]; var j = 0; while (j < innerlist.length) { if (typeof result[j] === 'undefined') { result[j] = []; } result[j].push(innerlist[j]); j += 1; } i += 1; } return result; }); /** * Maps an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning * function over a [Traversable](https://github.com/fantasyland/fantasy-land#traversable), * then uses [`sequence`](#sequence) to transform the resulting Traversable of Applicative * into an Applicative of Traversable. * * Dispatches to the `traverse` method of the third argument, if present. * * @func * @memberOf R * @since v0.19.0 * @category List * @sig (Applicative f, Traversable t) => (a -> f a) -> (a -> f b) -> t a -> f (t b) * @param {Function} of * @param {Function} f * @param {*} traversable * @return {*} * @see R.sequence * @example * * // Returns `Maybe.Nothing` if the given divisor is `0` * const safeDiv = n => d => d === 0 ? Maybe.Nothing() : Maybe.Just(n / d) * * R.traverse(Maybe.of, safeDiv(10), [2, 4, 5]); //=> Maybe.Just([5, 2.5, 2]) * R.traverse(Maybe.of, safeDiv(10), [2, 0, 5]); //=> Maybe.Nothing */ var traverse = _curry3(function traverse(of, f, traversable) { return typeof traversable['fantasy-land/traverse'] === 'function' ? traversable['fantasy-land/traverse'](f, of) : sequence(of, map(f, traversable)); }); var ws = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' + '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028' + '\u2029\uFEFF'; var zeroWidth = '\u200b'; var hasProtoTrim = (typeof String.prototype.trim === 'function'); /** * Removes (strips) whitespace from both ends of the string. * * @func * @memberOf R * @since v0.6.0 * @category String * @sig String -> String * @param {String} str The string to trim. * @return {String} Trimmed version of `str`. * @example * * R.trim(' xyz '); //=> 'xyz' * R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z'] */ var trim = !hasProtoTrim || (ws.trim() || !zeroWidth.trim()) ? _curry1(function trim(str) { var beginRx = new RegExp('^[' + ws + '][' + ws + ']*'); var endRx = new RegExp('[' + ws + '][' + ws + ']*$'); return str.replace(beginRx, '').replace(endRx, ''); }) : _curry1(function trim(str) { return str.trim(); }); /** * `tryCatch` takes two functions, a `tryer` and a `catcher`. The returned * function evaluates the `tryer`; if it does not throw, it simply returns the * result. If the `tryer` *does* throw, the returned function evaluates the * `catcher` function and returns its result. Note that for effective * composition with this function, both the `tryer` and `catcher` functions * must return the same type of results. * * @func * @memberOf R * @since v0.20.0 * @category Function * @sig (...x -> a) -> ((e, ...x) -> a) -> (...x -> a) * @param {Function} tryer The function that may throw. * @param {Function} catcher The function that will be evaluated if `tryer` throws. * @return {Function} A new function that will catch exceptions and send then to the catcher. * @example * * R.tryCatch(R.prop('x'), R.F)({x: true}); //=> true * R.tryCatch(() => { throw 'foo'}, R.always('catched'))('bar') // => 'catched' * R.tryCatch(R.times(R.identity), R.always([]))('s') // => [] * R.tryCatch(() => { throw 'this is not a valid value'}, (err, value)=>({error : err, value }))('bar') // => {'error': 'this is not a valid value', 'value': 'bar'} */ var tryCatch = _curry2(function _tryCatch(tryer, catcher) { return _arity(tryer.length, function() { try { return tryer.apply(this, arguments); } catch (e) { return catcher.apply(this, _concat([e], arguments)); } }); }); /** * Takes a function `fn`, which takes a single array argument, and returns a * function which: * * - takes any number of positional arguments; * - passes these arguments to `fn` as an array; and * - returns the result. * * In other words, `R.unapply` derives a variadic function from a function which * takes an array. `R.unapply` is the inverse of [`R.apply`](#apply). * * @func * @memberOf R * @since v0.8.0 * @category Function * @sig ([*...] -> a) -> (*... -> a) * @param {Function} fn * @return {Function} * @see R.apply * @example * * R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]' * @symb R.unapply(f)(a, b) = f([a, b]) */ var unapply = _curry1(function unapply(fn) { return function() { return fn(Array.prototype.slice.call(arguments, 0)); }; }); /** * Wraps a function of any arity (including nullary) in a function that accepts * exactly 1 parameter. Any extraneous parameters will not be passed to the * supplied function. * * @func * @memberOf R * @since v0.2.0 * @category Function * @sig (* -> b) -> (a -> b) * @param {Function} fn The function to wrap. * @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of * arity 1. * @see R.binary, R.nAry * @example * * const takesTwoArgs = function(a, b) { * return [a, b]; * }; * takesTwoArgs.length; //=> 2 * takesTwoArgs(1, 2); //=> [1, 2] * * const takesOneArg = R.unary(takesTwoArgs); * takesOneArg.length; //=> 1 * // Only 1 argument is passed to the wrapped function * takesOneArg(1, 2); //=> [1, undefined] * @symb R.unary(f)(a, b, c) = f(a) */ var unary = _curry1(function unary(fn) { return nAry(1, fn); }); /** * Returns a function of arity `n` from a (manually) curried function. * * @func * @memberOf R * @since v0.14.0 * @category Function * @sig Number -> (a -> b) -> (a -> c) * @param {Number} length The arity for the returned function. * @param {Function} fn The function to uncurry. * @return {Function} A new function. * @see R.curry * @example * * const addFour = a => b => c => d => a + b + c + d; * * const uncurriedAddFour = R.uncurryN(4, addFour); * uncurriedAddFour(1, 2, 3, 4); //=> 10 */ var uncurryN = _curry2(function uncurryN(depth, fn) { return curryN(depth, function() { var currentDepth = 1; var value = fn; var idx = 0; var endIdx; while (currentDepth <= depth && typeof value === 'function') { endIdx = currentDepth === depth ? arguments.length : idx + value.length; value = value.apply(this, Array.prototype.slice.call(arguments, idx, endIdx)); currentDepth += 1; idx = endIdx; } return value; }); }); /** * Builds a list from a seed value. Accepts an iterator function, which returns * either false to stop iteration or an array of length 2 containing the value * to add to the resulting list and the seed to be used in the next call to the * iterator function. * * The iterator function receives one argument: *(seed)*. * * @func * @memberOf R * @since v0.10.0 * @category List * @sig (a -> [b]) -> * -> [b] * @param {Function} fn The iterator function. receives one argument, `seed`, and returns * either false to quit iteration or an array of length two to proceed. The element * at index 0 of this array will be added to the resulting array, and the element * at index 1 will be passed to the next call to `fn`. * @param {*} seed The seed value. * @return {Array} The final list. * @example * * const f = n => n > 50 ? false : [-n, n + 10]; * R.unfold(f, 10); //=> [-10, -20, -30, -40, -50] * @symb R.unfold(f, x) = [f(x)[0], f(f(x)[1])[0], f(f(f(x)[1])[1])[0], ...] */ var unfold = _curry2(function unfold(fn, seed) { var pair = fn(seed); var result = []; while (pair && pair.length) { result[result.length] = pair[0]; pair = fn(pair[1]); } return result; }); /** * Combines two lists into a set (i.e. no duplicates) composed of the elements * of each list. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig [*] -> [*] -> [*] * @param {Array} as The first list. * @param {Array} bs The second list. * @return {Array} The first and second lists concatenated, with * duplicates removed. * @example * * R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4] */ var union = _curry2(compose(uniq, _concat)); /** * Returns a new list containing only one copy of each element in the original * list, based upon the value returned by applying the supplied predicate to * two list elements. Prefers the first item if two items compare equal based * on the predicate. * * @func * @memberOf R * @since v0.2.0 * @category List * @sig ((a, a) -> Boolean) -> [a] -> [a] * @param {Function} pred A predicate used to test whether two items are equal. * @param {Array} list The array to consider. * @return {Array} The list of unique items. * @example * * const strEq = R.eqBy(String); * R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2] * R.uniqWith(strEq)([{}, {}]); //=> [{}] * R.uniqWith(strEq)([1, '1', 1]); //=> [1] * R.uniqWith(strEq)(['1', 1, 1]); //=> ['1'] */ var uniqWith = _curry2(function uniqWith(pred, list) { var idx = 0; var len = list.length; var result = []; var item; while (idx < len) { item = list[idx]; if (!_includesWith(pred, item, result)) { result[result.length] = item; } idx += 1; } return result; }); /** * Combines two lists into a set (i.e. no duplicates) composed of the elements * of each list. Duplication is determined according to the value returned by * applying the supplied predicate to two list elements. * * @func * @memberOf R * @since v0.1.0 * @category Relation * @sig ((a, a) -> Boolean) -> [*] -> [*] -> [*] * @param {Function} pred A predicate used to test whether two items are equal. * @param {Array} list1 The first list. * @param {Array} list2 The second list. * @return {Array} The first and second lists concatenated, with * duplicates removed. * @see R.union * @example * * const l1 = [{a: 1}, {a: 2}]; * const l2 = [{a: 1}, {a: 4}]; * R.unionWith(R.eqBy(R.prop('a')), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}] */ var unionWith = _curry3(function unionWith(pred, list1, list2) { return uniqWith(pred, _concat(list1, list2)); }); /** * Tests the final argument by passing it to the given predicate function. If * the predicate is not satisfied, the function will return the result of * calling the `whenFalseFn` function with the same argument. If the predicate * is satisfied, the argument is returned as is. * * @func * @memberOf R * @since v0.18.0 * @category Logic * @sig (a -> Boolean) -> (a -> a) -> a -> a * @param {Function} pred A predicate function * @param {Function} whenFalseFn A function to invoke when the `pred` evaluates * to a falsy value. * @param {*} x An object to test with the `pred` function and * pass to `whenFalseFn` if necessary. * @return {*} Either `x` or the result of applying `x` to `whenFalseFn`. * @see R.ifElse, R.when, R.cond * @example * * let safeInc = R.unless(R.isNil, R.inc); * safeInc(null); //=> null * safeInc(1); //=> 2 */ var unless = _curry3(function unless(pred, whenFalseFn, x) { return pred(x) ? x : whenFalseFn(x); }); /** * Shorthand for `R.chain(R.identity)`, which removes one level of nesting from * any [Chain](https://github.com/fantasyland/fantasy-land#chain). * * @func * @memberOf R * @since v0.3.0 * @category List * @sig Chain c => c (c a) -> c a * @param {*} list * @return {*} * @see R.flatten, R.chain * @example * * R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]] * R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6] */ var unnest = chain(_identity); /** * Takes a predicate, a transformation function, and an initial value, * and returns a value of the same type as the initial value. * It does so by applying the transformation until the predicate is satisfied, * at which point it returns the satisfactory value. * * @func * @memberOf R * @since v0.20.0 * @category Logic * @sig (a -> Boolean) -> (a -> a) -> a -> a * @param {Function} pred A predicate function * @param {Function} fn The iterator function * @param {*} init Initial value * @return {*} Final value that satisfies predicate * @example * * R.until(R.gt(R.__, 100), R.multiply(2))(1) // => 128 */ var until = _curry3(function until(pred, fn, init) { var val = init; while (!pred(val)) { val = fn(val); } return val; }); /** * Returns a list of all the properties, including prototype properties, of the * supplied object. * Note that the order of the output array is not guaranteed to be consistent * across different JS platforms. * * @func * @memberOf R * @since v0.2.0 * @category Object * @sig {k: v} -> [v] * @param {Object} obj The object to extract values from * @return {Array} An array of the values of the object's own and prototype properties. * @see R.values, R.keysIn * @example * * const F = function() { this.x = 'X'; }; * F.prototype.y = 'Y'; * const f = new F(); * R.valuesIn(f); //=> ['X', 'Y'] */ var valuesIn = _curry1(function valuesIn(obj) { var prop; var vs = []; for (prop in obj) { vs[vs.length] = obj[prop]; } return vs; }); // `Const` is a functor that effectively ignores the function given to `map`. var Const = function(x) { return {value: x, 'fantasy-land/map': function() { return this; }}; }; /** * Returns a "view" of the given data structure, determined by the given lens. * The lens's focus determines which portion of the data structure is visible. * * @func * @memberOf R * @since v0.16.0 * @category Object * @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s * @sig Lens s a -> s -> a * @param {Lens} lens * @param {*} x * @return {*} * @see R.prop, R.lensIndex, R.lensProp * @example * * const xLens = R.lensProp('x'); * * R.view(xLens, {x: 1, y: 2}); //=> 1 * R.view(xLens, {x: 4, y: 2}); //=> 4 */ var view = _curry2(function view(lens, x) { // Using `Const` effectively ignores the setter function of the `lens`, // leaving the value returned by the getter function unmodified. return lens(Const)(x).value; }); /** * Tests the final argument by passing it to the given predicate function. If * the predicate is satisfied, the function will return the result of calling * the `whenTrueFn` function with the same argument. If the predicate is not * satisfied, the argument is returned as is. * * @func * @memberOf R * @since v0.18.0 * @category Logic * @sig (a -> Boolean) -> (a -> a) -> a -> a * @param {Function} pred A predicate function * @param {Function} whenTrueFn A function to invoke when the `condition` * evaluates to a truthy value. * @param {*} x An object to test with the `pred` function and * pass to `whenTrueFn` if necessary. * @return {*} Either `x` or the result of applying `x` to `whenTrueFn`. * @see R.ifElse, R.unless, R.cond * @example * * // truncate :: String -> String * const truncate = R.when( * R.propSatisfies(R.gt(R.__, 10), 'length'), * R.pipe(R.take(10), R.append('…'), R.join('')) * ); * truncate('12345'); //=> '12345' * truncate('0123456789ABC'); //=> '0123456789…' */ var when = _curry3(function when(pred, whenTrueFn, x) { return pred(x) ? whenTrueFn(x) : x; }); /** * Takes a spec object and a test object; returns true if the test satisfies * the spec. Each of the spec's own properties must be a predicate function. * Each predicate is applied to the value of the corresponding property of the * test object. `where` returns true if all the predicates return true, false * otherwise. * * `where` is well suited to declaratively expressing constraints for other * functions such as [`filter`](#filter) and [`find`](#find). * * @func * @memberOf R * @since v0.1.1 * @category Object * @sig {String: (* -> Boolean)} -> {String: *} -> Boolean * @param {Object} spec * @param {Object} testObj * @return {Boolean} * @see R.propSatisfies, R.whereEq * @example * * // pred :: Object -> Boolean * const pred = R.where({ * a: R.equals('foo'), * b: R.complement(R.equals('bar')), * x: R.gt(R.__, 10), * y: R.lt(R.__, 20) * }); * * pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true * pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false * pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false * pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false * pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false */ var where = _curry2(function where(spec, testObj) { for (var prop in spec) { if (_has(prop, spec) && !spec[prop](testObj[prop])) { return false; } } return true; }); /** * Takes a spec object and a test object; returns true if the test satisfies * the spec, false otherwise. An object satisfies the spec if, for each of the * spec's own properties, accessing that property of the object gives the same * value (in [`R.equals`](#equals) terms) as accessing that property of the * spec. * * `whereEq` is a specialization of [`where`](#where). * * @func * @memberOf R * @since v0.14.0 * @category Object * @sig {String: *} -> {String: *} -> Boolean * @param {Object} spec * @param {Object} testObj * @return {Boolean} * @see R.propEq, R.where * @example * * // pred :: Object -> Boolean * const pred = R.whereEq({a: 1, b: 2}); * * pred({a: 1}); //=> false * pred({a: 1, b: 2}); //=> true * pred({a: 1, b: 2, c: 3}); //=> true * pred({a: 1, b: 1}); //=> false */ var whereEq = _curry2(function whereEq(spec, testObj) { return where(map(equals, spec), testObj); }); /** * Returns a new list without values in the first argument. * [`R.equals`](#equals) is used to determine equality. * * Acts as a transducer if a transformer is given in list position. * * @func * @memberOf R * @since v0.19.0 * @category List * @sig [a] -> [a] -> [a] * @param {Array} list1 The values to be removed from `list2`. * @param {Array} list2 The array to remove values from. * @return {Array} The new array without values in `list1`. * @see R.transduce, R.difference, R.remove * @example * * R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4] */ var without = _curry2(function(xs, list) { return reject(flip(_includes)(xs), list); }); /** * Exclusive disjunction logical operation. * Returns `true` if one of the arguments is truthy and the other is falsy. * Otherwise, it returns `false`. * * @func * @memberOf R * @since v0.27.1 * @category Logic * @sig a -> b -> Boolean * @param {Any} a * @param {Any} b * @return {Boolean} true if one of the arguments is truthy and the other is falsy * @see R.or, R.and * @example * * R.xor(true, true); //=> false * R.xor(true, false); //=> true * R.xor(false, true); //=> true * R.xor(false, false); //=> false */ var xor = _curry2(function xor(a, b) { return Boolean(!a ^ !b); }); /** * Creates a new list out of the two supplied by creating each possible pair * from the lists. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig [a] -> [b] -> [[a,b]] * @param {Array} as The first list. * @param {Array} bs The second list. * @return {Array} The list made by combining each possible pair from * `as` and `bs` into pairs (`[a, b]`). * @example * * R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']] * @symb R.xprod([a, b], [c, d]) = [[a, c], [a, d], [b, c], [b, d]] */ var xprod = _curry2(function xprod(a, b) { // = xprodWith(prepend); (takes about 3 times as long...) var idx = 0; var ilen = a.length; var j; var jlen = b.length; var result = []; while (idx < ilen) { j = 0; while (j < jlen) { result[result.length] = [a[idx], b[j]]; j += 1; } idx += 1; } return result; }); /** * Creates a new list out of the two supplied by pairing up equally-positioned * items from both lists. The returned list is truncated to the length of the * shorter of the two input lists. * Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`. * * @func * @memberOf R * @since v0.1.0 * @category List * @sig [a] -> [b] -> [[a,b]] * @param {Array} list1 The first array to consider. * @param {Array} list2 The second array to consider. * @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`. * @example * * R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']] * @symb R.zip([a, b, c], [d, e, f]) = [[a, d], [b, e], [c, f]] */ var zip = _curry2(function zip(a, b) { var rv = []; var idx = 0; var len = Math.min(a.length, b.length); while (idx < len) { rv[idx] = [a[idx], b[idx]]; idx += 1; } return rv; }); /** * Creates a new object out of a list of keys and a list of values. * Key/value pairing is truncated to the length of the shorter of the two lists. * Note: `zipObj` is equivalent to `pipe(zip, fromPairs)`. * * @func * @memberOf R * @since v0.3.0 * @category List * @sig [String] -> [*] -> {String: *} * @param {Array} keys The array that will be properties on the output object. * @param {Array} values The list of values on the output object. * @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`. * @example * * R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3} */ var zipObj = _curry2(function zipObj(keys, values) { var idx = 0; var len = Math.min(keys.length, values.length); var out = {}; while (idx < len) { out[keys[idx]] = values[idx]; idx += 1; } return out; }); /** * Creates a new list out of the two supplied by applying the function to each * equally-positioned pair in the lists. The returned list is truncated to the * length of the shorter of the two input lists. * * @function * @memberOf R * @since v0.1.0 * @category List * @sig ((a, b) -> c) -> [a] -> [b] -> [c] * @param {Function} fn The function used to combine the two elements into one value. * @param {Array} list1 The first array to consider. * @param {Array} list2 The second array to consider. * @return {Array} The list made by combining same-indexed elements of `list1` and `list2` * using `fn`. * @example * * const f = (x, y) => { * // ... * }; * R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']); * //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')] * @symb R.zipWith(fn, [a, b, c], [d, e, f]) = [fn(a, d), fn(b, e), fn(c, f)] */ var zipWith = _curry3(function zipWith(fn, a, b) { var rv = []; var idx = 0; var len = Math.min(a.length, b.length); while (idx < len) { rv[idx] = fn(a[idx], b[idx]); idx += 1; } return rv; }); /** * Creates a thunk out of a function. A thunk delays a calculation until * its result is needed, providing lazy evaluation of arguments. * * @func * @memberOf R * @since v0.26.0 * @category Function * @sig ((a, b, ..., j) -> k) -> (a, b, ..., j) -> (() -> k) * @param {Function} fn A function to wrap in a thunk * @return {Function} Expects arguments for `fn` and returns a new function * that, when called, applies those arguments to `fn`. * @see R.partial, R.partialRight * @example * * R.thunkify(R.identity)(42)(); //=> 42 * R.thunkify((a, b) => a + b)(25, 17)(); //=> 42 */ var thunkify = _curry1(function thunkify(fn) { return curryN(fn.length, function createThunk() { var fnArgs = arguments; return function invokeThunk() { return fn.apply(this, fnArgs); }; }); }); exports.F = F; exports.T = T; exports.__ = __; exports.add = add; exports.addIndex = addIndex; exports.adjust = adjust; exports.all = all; exports.allPass = allPass; exports.always = always; exports.and = and; exports.any = any; exports.anyPass = anyPass; exports.ap = ap; exports.aperture = aperture; exports.append = append; exports.apply = apply; exports.applySpec = applySpec; exports.applyTo = applyTo; exports.ascend = ascend; exports.assoc = assoc; exports.assocPath = assocPath; exports.binary = binary; exports.bind = bind; exports.both = both; exports.call = call; exports.chain = chain; exports.clamp = clamp; exports.clone = clone; exports.comparator = comparator; exports.complement = complement; exports.compose = compose; exports.composeK = composeK; exports.composeP = composeP; exports.composeWith = composeWith; exports.concat = concat; exports.cond = cond; exports.construct = construct; exports.constructN = constructN; exports.contains = contains$1; exports.converge = converge; exports.countBy = countBy; exports.curry = curry; exports.curryN = curryN; exports.dec = dec; exports.defaultTo = defaultTo; exports.descend = descend; exports.difference = difference; exports.differenceWith = differenceWith; exports.dissoc = dissoc; exports.dissocPath = dissocPath; exports.divide = divide; exports.drop = drop; exports.dropLast = dropLast$1; exports.dropLastWhile = dropLastWhile$1; exports.dropRepeats = dropRepeats; exports.dropRepeatsWith = dropRepeatsWith; exports.dropWhile = dropWhile; exports.either = either; exports.empty = empty; exports.endsWith = endsWith; exports.eqBy = eqBy; exports.eqProps = eqProps; exports.equals = equals; exports.evolve = evolve; exports.filter = filter; exports.find = find; exports.findIndex = findIndex; exports.findLast = findLast; exports.findLastIndex = findLastIndex; exports.flatten = flatten; exports.flip = flip; exports.forEach = forEach; exports.forEachObjIndexed = forEachObjIndexed; exports.fromPairs = fromPairs; exports.groupBy = groupBy; exports.groupWith = groupWith; exports.gt = gt; exports.gte = gte; exports.has = has; exports.hasIn = hasIn; exports.hasPath = hasPath; exports.head = head; exports.identical = identical; exports.identity = identity; exports.ifElse = ifElse; exports.inc = inc; exports.includes = includes; exports.indexBy = indexBy; exports.indexOf = indexOf; exports.init = init; exports.innerJoin = innerJoin; exports.insert = insert; exports.insertAll = insertAll; exports.intersection = intersection; exports.intersperse = intersperse; exports.into = into; exports.invert = invert; exports.invertObj = invertObj; exports.invoker = invoker; exports.is = is; exports.isEmpty = isEmpty; exports.isNil = isNil; exports.join = join; exports.juxt = juxt; exports.keys = keys; exports.keysIn = keysIn; exports.last = last; exports.lastIndexOf = lastIndexOf; exports.length = length; exports.lens = lens; exports.lensIndex = lensIndex; exports.lensPath = lensPath; exports.lensProp = lensProp; exports.lift = lift; exports.liftN = liftN; exports.lt = lt; exports.lte = lte; exports.map = map; exports.mapAccum = mapAccum; exports.mapAccumRight = mapAccumRight; exports.mapObjIndexed = mapObjIndexed; exports.match = match; exports.mathMod = mathMod; exports.max = max; exports.maxBy = maxBy; exports.mean = mean; exports.median = median; exports.memoizeWith = memoizeWith; exports.merge = merge; exports.mergeAll = mergeAll; exports.mergeDeepLeft = mergeDeepLeft; exports.mergeDeepRight = mergeDeepRight; exports.mergeDeepWith = mergeDeepWith; exports.mergeDeepWithKey = mergeDeepWithKey; exports.mergeLeft = mergeLeft; exports.mergeRight = mergeRight; exports.mergeWith = mergeWith; exports.mergeWithKey = mergeWithKey; exports.min = min; exports.minBy = minBy; exports.modulo = modulo; exports.move = move; exports.multiply = multiply; exports.nAry = nAry; exports.negate = negate; exports.none = none; exports.not = not; exports.nth = nth; exports.nthArg = nthArg; exports.o = o; exports.objOf = objOf; exports.of = of; exports.omit = omit; exports.once = once; exports.or = or; exports.otherwise = otherwise; exports.over = over; exports.pair = pair; exports.partial = partial; exports.partialRight = partialRight; exports.partition = partition; exports.path = path; exports.paths = paths; exports.pathEq = pathEq; exports.pathOr = pathOr; exports.pathSatisfies = pathSatisfies; exports.pick = pick; exports.pickAll = pickAll; exports.pickBy = pickBy; exports.pipe = pipe; exports.pipeK = pipeK; exports.pipeP = pipeP; exports.pipeWith = pipeWith; exports.pluck = pluck; exports.prepend = prepend; exports.product = product; exports.project = project; exports.prop = prop; exports.propEq = propEq; exports.propIs = propIs; exports.propOr = propOr; exports.propSatisfies = propSatisfies; exports.props = props; exports.range = range; exports.reduce = reduce; exports.reduceBy = reduceBy; exports.reduceRight = reduceRight; exports.reduceWhile = reduceWhile; exports.reduced = reduced; exports.reject = reject; exports.remove = remove; exports.repeat = repeat; exports.replace = replace; exports.reverse = reverse; exports.scan = scan; exports.sequence = sequence; exports.set = set; exports.slice = slice; exports.sort = sort; exports.sortBy = sortBy; exports.sortWith = sortWith; exports.split = split; exports.splitAt = splitAt; exports.splitEvery = splitEvery; exports.splitWhen = splitWhen; exports.startsWith = startsWith; exports.subtract = subtract; exports.sum = sum; exports.symmetricDifference = symmetricDifference; exports.symmetricDifferenceWith = symmetricDifferenceWith; exports.tail = tail; exports.take = take; exports.takeLast = takeLast; exports.takeLastWhile = takeLastWhile; exports.takeWhile = takeWhile; exports.tap = tap; exports.test = test; exports.andThen = andThen; exports.times = times; exports.toLower = toLower; exports.toPairs = toPairs; exports.toPairsIn = toPairsIn; exports.toString = toString$1; exports.toUpper = toUpper; exports.transduce = transduce; exports.transpose = transpose; exports.traverse = traverse; exports.trim = trim; exports.tryCatch = tryCatch; exports.type = type; exports.unapply = unapply; exports.unary = unary; exports.uncurryN = uncurryN; exports.unfold = unfold; exports.union = union; exports.unionWith = unionWith; exports.uniq = uniq; exports.uniqBy = uniqBy; exports.uniqWith = uniqWith; exports.unless = unless; exports.unnest = unnest; exports.until = until; exports.update = update; exports.useWith = useWith; exports.values = values; exports.valuesIn = valuesIn; exports.view = view; exports.when = when; exports.where = where; exports.whereEq = whereEq; exports.without = without; exports.xor = xor; exports.xprod = xprod; exports.zip = zip; exports.zipObj = zipObj; exports.zipWith = zipWith; exports.thunkify = thunkify; Object.defineProperty(exports, '__esModule', { value: true });}));