śĪ!xL“X’¬      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./01 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ų ł ś ū ü ż ž ’                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y!Z![!\!]!^!_!`!a!b!c!d!e!f!g!h!i!j!k!l!m"n"o"p"q#r#s#t#u#v#w#x#y$z${$|$}$~$$€$$‚$ƒ$„%…%†%‡%ˆ%‰%Š%‹%Œ%%Ž%%%‘%’%“%”&•&–&—&˜&™&š&›&œ&&ž&Ÿ& '”'¢'£'¤(„(¦(§(Ø(©(Ŗ(«(¬(­)®)Æ)°)±)²)³)“)µ)¶)·)ø)¹)ŗ)»)¼)½)¾)æ)Ą)Į)Ā)Ć)Ä)Å)Ę)Ē)Č)É*Ź*Ė*Ģ*Ķ*Ī*Ļ*Š*Ń*Ņ*Ó*Ō*Õ*Ö*×*Ų*Ł*Ś*Ū*Ü*Ż*Ž*ß*ą*į*ā*ć*ä*å*ę*ē*č*é*ź*ė*ģ*ķ*ī*ļ*š*ń*ņ*ó*ō*õ*ö*÷*ų*ł*ś*ū*ü*ż*ž*’********** * * * * *************++++++ +!+"+#+$+%+&+'+(,),*,+,,,-,.-/-0-1-2-3-4-5-6.7.8.9.:.;.<.=.>/?/@/A/B0C0D0E0F0G0H0I0J0K0L0M0N0O0P1Q1R1S1T1U1V1W1X2Y2Z2[2\2]2^2_2`2a2b2c2d2e2f2g2h2i2j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4~44€55‚5ƒ5„5…5†5‡5ˆ5‰5Š5‹5Œ6Ž666‘6’6“6”6•7–7—7˜7™7š7›7œ77ž7Ÿ7 8”8¢8£8¤8„8¦8§8Ø8©8Ŗ8«8¬8­8®8Æ8°8±8²8³9“9µ9¶9·9ø9¹9ŗ9»9¼9½9¾9æ9Ą9Į9Ā9Ć9Ä9Å9Ę9Ē9Č9É9Ź9Ė9Ģ9Ķ9Ī9Ļ9Š9Ń9Ņ9Ó9Ō9Õ9Ö9×9Ų9Ł9Ś9Ū9Ü9Ż9Ž9ß9ą9į9ā9ć9ä9å9ę9ē9č9é9ź9ė9ģ9ķ9ī9ļ9š9ń9ņ9ó9ō9õ9ö9÷9ų9ł9ś9ū9ü9ż9ž9’99999999:: : : : : ::::::::::::::::::: :!:":#:$:%:&:':(:):*:+:,:-:.:/:0:1:2:3:4:5:6:7:8:9::;;;<;=;>;?;@;A;B;C;D;E;F;G;H;I;J;K;L;M;N;O;P;Q;R;S;T;U<V<W<X<Y<Z<[<\<]<^=_=`=a=b=c=d=e=f=g=h=i>j>k>l>m>n>o>p>q?r?s@t@u@v@w@x@y@z@{@|@}@~@@€AA‚AƒA„B…B†B‡BˆB‰BŠB‹BŒBBŽBBB‘B’B“B”B•B–B—B˜B™BšB›BœBBžBŸC C”C¢C£C¤C„C¦C§CØD©DŖD«D¬D­D®DÆD°D±D²D³D“DµD¶D·DøD¹DŗD»D¼D½D¾DæDĄEĮEĀEĆEÄEÅEĘEĒEČEÉEŹEĖEĢEĶEĪEĻEŠEŃEŅEÓEŌEÕEÖE×EŲEŁEŚEŪEÜEŻEŽEßEąEįEāEćEäEåEęEēEčEéEźEėEģEķEīEļEšFńFņFóFōFõFöF÷FųFłFśFūFüFżFžF’FFFFFFFFFF F F F F FFFFFFFFFFFFFFFFFFF F!F"F#F$F%F&F'F(F)F*F+F,F-F.F/F0F1F2F3F4F5F6F7F8F9F:F;F<F=F>F?F@FAFBFCFDFEFFFGFHFIFJFKFLFMFNFOFPFQFRFSFTFUFVFWFXFYFZF[F\F]F^F_F`FaFbFcFdFeFfFgFhFiFjFkFlFmFnFoFpFqFrFsFtFuFvFwFxFyFzF{F|F}F~FF€FF‚FƒF„F…F†F‡FˆF‰FŠF‹FŒFFŽFFF‘F’F“F”F•F–F—F˜F™FšF›FœFFžFŸF F”F¢F£F¤F„F¦F§FØF©FŖF«F¬F­F®FÆF°F±F²F³F“FµF¶F·GøG¹GŗG»G¼G½G¾GæGĄGĮGĀGĆGÄGÅGĘGĒGČGÉGŹGĖGĢGĶGĪGĻGŠGŃGŅGÓGŌGÕGÖH×IŲIŁIŚIŪJÜJŻJŽJßJąJįJāJćJäJåJęJēJčJéJźJėJģJķJīJļJšJńJņJóJōJõJöJ÷JųJłJśJūKüKżKžK’KKKKKKKKKK L L L L LLLLLLLLLLLLLLLLLMM M!M"M#N$N%N&N'N(N)N*N+N,N-N.N/N0N1N2N3N4N5N6N7N8N9N:N;N<N=N>N?N@NANBNCNDNENFOGOHOIOJOKOLOMONOOOPOQOROSOTOUOVOWOXOYOZO[O\O]O^O_O`OaObOcOdPePfPgPhPiPjPkPlPmPnPoPpPqPrPsPtPuPvPwPxPyPzP{P|P}P~PP€PP‚PƒP„P…P†P‡PˆQ‰QŠQ‹QŒQQŽQQQ‘Q’Q“R”R•R–R—S˜S™SšS›SœSSžSŸS S”S¢S£S¤S„S¦S§TØT©TŖT«T¬T­T®TÆT°T±T²T³T“TµT¶T·TøT¹TŗT»T¼T½T¾TæTĄTĮTĀTĆTÄTÅTĘTĒTČTÉTŹTĖTĢTĶUĪUĻUŠUŃUŅUÓUŌUÕUÖU×UŲUŁUŚUŪUÜUŻUŽUßUąUįUāUćUäUåUęUēUčUéUźUėUģUķUīUļUšUńUņVóVōVõVöV÷VųVłVśWūWüWżWžW’WWWWWWWWWW W W W W WWWWWWXXXXXXYYYYYYY Z!Z"Z#Z$Z%Z&Z'Z(Z)Z*Z+[,[-[.[/[0[1[2[3[4[5\6\7\8\9\:\;\<\=\>\?\@\A\B\C\D\E\F\G\H\I\J\K\L]M]N]O]P]Q]R]S]T]U]V^W^X^Y^Z^[^\^]^^^_^`^a^b^c^d^e^f^g^h^i^j^k^l^m^n^o^p^q^r^s^t^u^v^w^x^y^z^{^|^}^~^^€^^‚^ƒ^„^…_†_‡_ˆ_‰_Š_‹_Œ__Ž___‘_’_“_”_•_–_—_˜_™_š_›_œ__ž_Ÿ_ _”_¢_£_¤_„`¦a§bØc©cŖc«c¬c­c®cÆd°d±d²d³d“dµd¶d·død¹dŗd»d¼d½d¾dædĄeĮeĀfĆfÄfÅgĘhĒhČhÉhŹhĖhĢhĶhĪhĻhŠhŃhŅhÓhŌhÕhÖh×hŲhŁhŚhŪhÜhŻhŽhßhąhįhāićiäjåkękēlčlémźmėmģmķmīmļmšmńnņnónōnõnön÷nųnłnśnūnüożožo’o o o o o o o o o o o o p p q q q q q q q q q q q r r r r r r r r r !r "r #r $r %r &r 'r (r )r *r +r ,r -r .s /s 0s 1s 2s 3s 4t 5t 6t 7t 8t 9t :t ;t <t =u >v ?v @v Av Bw Cw Dw Ew Fw Gw Hw Iw Jw Kw Lw Mw Nw Ow Pw Qw Rw Sw Tw Uw Vw Ww Xw Yw Zx [x \x ]x ^x _x `x ax by cy dy ey fy gy hy iy jy ky ly my ny oy py qy ry sy ty uy vy wy xy yy zy {y |y }y ~y y €y y ‚y ƒy „y …y †y ‡y ˆz ‰z Šz ‹z Œz z Žz z z ‘z ’z “z ”z •z –z —z ˜z ™z šz ›z œz { ž| Ÿ|  } ”} ¢~ £~ ¤~ „~ ¦~ §~ Ø~ ©~ Ŗ~ «~ ¬~ ­~ ®~ Æ~ °~ ±~ ²~ ³~ “~ µ~ ¶~ ·~ ø~ ¹~ ŗ~ »~ ¼~ ½~ ¾~ æ~ Ą~ Į~ Ā~ Ć~ Ä~ Å~ Ę~ Ē~ Č~ É~ Ź~ Ė~ Ģ~ Ķ~ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū Ü Ż Ž ß ą į ā ć ä€ å€ ę€ ē€ č€ é€ ź€ ė€ ģ€ ķ€ ī€ ļ€ š€ ń€ ņ€ ó€ ō€ õ€ ö€ ÷ ų ł ś ū ü ż ž ’                                  ! " # $ % & '‚ (‚ )‚ *‚ +‚ ,‚ -‚ .‚ /‚ 0‚ 1‚ 2‚ 3‚ 4‚ 5‚ 6‚ 7‚ 8‚ 9‚ :‚ ;‚ <‚ =ƒ >ƒ ?ƒ @„ A„ B„ C„ D„ E„ F„ G„ H„ I„ J„ K„ L„ M„ N… O… P… Q… R… S… T… U… V… W† X‡ Y‡ Z‡ [‡ \‡ ]‡ ^‡ _‡ `‡ a‡ b‡ c‡ d‡ e‡ f‡ g‡ h‡ i‡ j‡ k‡ l‡ m‡ n‡ o‡ pˆ qˆ rˆ sˆ tˆ uˆ vˆ wˆ xˆ yˆ zˆ {ˆ |ˆ }ˆ ~ˆ ˆ €‰ ‰ ‚‰ ƒ‰ „‰ …‰ †‰ ‡‰ ˆ‰ ‰‰ Š‰ ‹‰ Œ‰ ‰ Ž‰ ‰ ‰ ‘‰ ’‰ “‰ ”‰ •‰ –‰ —‰ ˜‰ ™‰ š‰ ›Š œŠ Š žŠ ŸŠ  Š ”Š ¢Š £Š ¤Š „Š ¦Š §Š ؊ ©Š ŖŠ «Š ¬Š ­Š ®Š Ɗ °Š ±Š ²Š ³Š “Š µŠ ¶‹ ·Œ øŒ ¹Œ ŗŒ »Œ ¼Œ ½Œ ¾Œ æŒ ĄŒ ĮŒ ĀŒ ƌ Č Ō ʌ ĒŒ Ȍ Ɍ ŹŒ ĖŒ ĢŒ ĶŒ ĪŒ ĻŒ ŠŒ ь ŅŒ ӌ ŌŒ Ռ ֌ ׌ ŲŒ ŁŒ Ś Ū ܍ Ż Ž ߍ ą į āŽ ćŽ äŽ åŽ ęŽ ēŽ čŽ éŽ źŽ ėŽ ģŽ ķŽ īŽ ļŽ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’                  ‘ ‘ ’ ’ ’ ’ ’ ’ ’ ’ ’ ’ ’ ’ ’ ’ !’ "’ #’ $’ %’ &’ '“ (“ )“ *“ +“ ,“ -“ .“ /“ 0“ 1” 2” 3” 4” 5” 6” 7” 8” 9” :” ;” <• =• >• ?• @• A• B• C• D• E• F• G– H– I– J– K– L– M– N– O– P– Q– R– S— T— U— V— W— X— Y— Z— [— \— ]— ^— _— `— a— b— c— d— e— f— g— h— i˜ j™ k™ l™ m™ n™ o™ p™ q™ r™ s™ t™ u™ v™ w™ x™ y™ z™ {™ |™ }š ~š š €š š ‚š ƒš „š …š †š ‡š ˆš ‰› Š› ‹› Œ› › Ž› › › ‘› ’› “› ”› •› –› —› ˜› ™› š› ›› œ› › ž› Ÿ›  › ”› ¢› £› ¤› „› ¦› §› ؛ ©› Ŗ› «› ¬› ­› ®› ƛ °› ±› ²› ³› “› µ› ¶œ ·œ øœ ¹œ ŗœ »œ ¼œ ½œ ¾œ æœ Ąœ Įœ Āœ Ɲ ĝ ŝ ʝ Ē ȝ ɝ Ź Ė Ģ Ķ Ī Ļ Š ѝ Ņ ӝ Ō ՝ ֝ ם Ų Ł Ś Ū ܝ Ż Ž ߝ ą į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ų ł ś ū ü ż ž ’                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤ „ ¦ § ؝ © Ŗ « ¬ ­ ® Ɲ ° ± ² ³ “ µ ¶ · ø ¹ ŗ » ¼ž ½ž ¾Ÿ æŸ ĄŸ ĮŸ ĀŸ Ɵ ğ ş ʟ ĒŸ ȟ ɟ ŹŸ ĖŸ ĢŸ ĶŸ ĪŸ ĻŸ ŠŸ џ ŅŸ ӟ ŌŸ ՟ ֟ ן ŲŸ ŁŸ ŚŸ ŪŸ ܟ ŻŸ ŽŸ ߟ ąŸ įŸ āŸ ć  ä  å  ę  ē  č  é  ź  ė  ģ  ķ  ī  ļ  š  ń  ņ  ó  ō  õ  ö  ÷” ų” ł” ś” ū” ü” ż” ž¢ ’¢ ¢ ¢ ¢ ¢ ¢ ¢ ¢ £ £ £ £ £ £ £ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ !¤ "¤ #¤ $¤ %¤ &¤ '„ („ )„ *„ +„ ,„ -„ .¦ /¦ 0¦ 1¦ 2§ 3§ 4§ 5Ø 6Ø 7© 8© 9© :© ;© <© =© >© ?© @© A© B© C© D© E© F© G© H© I© J© K© L© M© N© O© P© QŖ RŖ SŖ TŖ UŖ VŖ WŖ XŖ YŖ ZŖ [Ŗ \Ŗ ]Ŗ ^Ŗ _Ŗ `Ŗ aŖ bŖ cŖ dŖ eŖ fŖ gŖ hŖ iŖ jŖ kŖ lŖ mŖ nŖ oŖ pŖ q« r« s¬ t¬ u¬ v¬ w¬ x¬ y¬ z¬ {¬ |¬ }¬ ~¬ ­ €­ ® ‚® ƒ® „Æ …Æ †Æ ‡Æ ˆ° ‰° Š° ‹° Œ° ° Ž° ° ° ‘° ’° “° ”° •° –° —° ˜± ™± š± ›± œ± ± ž± Ÿ±  ± ”± ¢± £± ¤± „± ¦± §± ر ©± Ŗ± «± ¬² ­² ®² Ʋ °² ±² ²³ ³³ “³ µ³ ¶³ ·³ ø“ ¹“ ŗµ »µ ¼µ ½µ ¾µ æµ Ąµ Įµ Āµ Ƶ ĵ ŵ ʵ Ēµ ȵ ɵ Źµ Ėµ Ģµ Ķµ Īµ Ļµ Šµ ѵ Ņµ Óµ Ōµ Õµ Öµ ×µ Ųµ Łµ Śµ Ūµ ܵ Żµ Žµ ßµ ąµ įµ āµ ćµ äµ åµ ęµ ēµ čµ éµ źµ ėµ ģ¶ ķ¶ ī¶ ļ¶ š¶ ń¶ ņ¶ ó¶ ō¶ õ¶ ö¶ ÷¶ ų· ł· ś· ū· ü· ż· ž· ’·········· · · · · ··················· ·!·"·#·$·%·&·'·(·)·*·+·,·-ø.ø/ø0ø1ø2¹3¹4¹5¹6¹7¹8¹9¹:¹;¹<¹=¹>ŗ?ŗ@»A»B¼C¼D¼E½F¾G¾HæIĄJĮKĀLĆMĆNÄOÅPĘQĒRĒSĒTĒUĒVČWÉXŹYĖZĢ[Ķ\Ķ]Ī^Ī_Ī`ĻaĻbŠcŃdŃeŃfŃgŃhŅiŅjŅkŅlŅmŅnŅoÓpÓqÓrÓsÓtŌuŌvÕwÕxÖyÖzÖ{×|Ų}Ų~ŲŲ€ŲŁ‚ŚƒŪ„܅܆܇܈܉܊Ż‹ŽŒßąŽąįā‘ā’ā“ā”ā•ā–ā—ā˜ā™āšā›ćœććžćŸä ä”ä¢å£å¤ę„ē¦č§čØé©éŖé«éļNone"#&',.1248=>?HIMPSUVX_kŹīdarcsA reflection of  > at the value level so that code can explicitly switch on it.darcsReflect  > to the value level so that code can explicitly switch on it.darcs Extract the ' from a   darcs;This type is intended to be used as a phantom type via the  DataKindsg extension. It tracks different types of repositories, e.g. to indicate when a rebase is in progress.¬darcsReflect '> to the value level so that code can explicitly switch on it.$darcsA reflection of '> at the value level so that code can explicitly switch on it.'darcs<This type is intended to be used as a phantom type via the  DataKinds extension, normally as part of  4. Indicates whether or not a rebase is in progress. !"#$%&'() !"'()#$%&None"#&',.1248=>?HIMPSUVX_kĢl-./0-./0None"#&',.1248=>?HIMPSUVX_kĶšż $ÄĆ% ÅĘĒ&ž'¢” Ÿžœ›š™˜—–•”“( ½¼)»ŗ¹ø·¶*+ł,ńš  ļī-’.N‘/0°Æ®­¬«Ŗ©Ø§¦„¤£1ĀĮĄæ¾2ĻĪĶ3!"#Sś4‡‚ˆƒ†„~}…€5a_`^6ų÷7 8DG9:;<=>EF?JKL@ABCHIMOPQRTcdefghijklmnpqrstuvwxyz{|‰Š‹ŒŽ’±²³“µČÉŹĖĢŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķņóōõöūüżż $ÄĆ% ÅĘĒ&ž'¢” Ÿžœ›š™˜—–•”“( ½¼)»ŗ¹ø·¶*+ł,ńš  ļī-’.N‘/0°Æ®­¬«Ŗ©Ø§¦„¤£1ĀĮĄæ¾2ĻĪĶ4‡‚ˆƒ†„~}…€5_`^8DG9:;<=>EF?JKL@ABCHIOPQRTcdefghijklmnpqrstuvwxyz{|‰Š‹ŒŽ’±²³“µČÉŹĖĢŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķņóōõöūüż3!"#SśM7 6ų÷a None"#&',.1248=>?HIMPSUVX_kćó1darcsJAn witness aware equality class. A minimal definition defines any one of 2, 3 and 4.2darcsyIt is unsafe to define a class instance via this method, because if it returns True then the default implementations of 3 and 4, will coerce the equality of two witnesses.&Calling this method is safe, although 3 or 4ˆ would be better choices as it is not usually meaningul to compare two patches that don't share either a starting or an ending context3darcsCompare two things with the same starting witness. If the things compare equal, evidence of the ending witnesses being equal will be returned.4darcsCompare two things with the same ending witness. If the things compare equal, evidence of the starting witnesses being equal will be returned.5darcs5U is used to pass around evidence (or lack thereof) of two witness types being equal.13425678567134283444 None"#&',.1248=>?HIMPSUVX_kõh;darcs;¾ returns a filter function that tells if a char is a member of the regChar expression or not. The regChar expression is basically a set of chars, but it can contain ranges with use of the  M (dash), and it can also be specified as a complement set by prefixing with ^€ (caret). The dash and caret, as well as the backslash, can all be escaped with a backslash to suppress their special meaning. NOTE: The Pb (dot) is allowed to be escaped. It has no special meaning if it is not escaped, but the default  filename_toks7 in Darcs.Commands.Replace uses an escaped dot (WHY?).­darcs­ö unescapes whitespace, which is escaped in the replace patch file format. It will also unescape escaped carets, which is useful for escaping a leading caret that should not invert the regChars. All other escapes are left for the unescaping in ®.®darcs®© assembles the filter function. It handles special chars, and also unescaping of escaped special chars. If a non-special char is still escaped by now we get a failure.;; None"#&',.1248=>?HIMPSUVX_kźÆdarcsbreakOutToken tokChars input splits the input  ByteString into F (before, token, after), where token6 is the first non-empty substring consisting only of 9s in tokChars, or E if no token was found. The 9s in tokChars5 should not have code points larger than 255 (0xff).<darcs$tryTokReplace tokChars old new input tries to find the token old and replace it with the token new everywhere in the input , returning F the modified input, unless the token new is already in the input in which case EN is returned. A token is a sequence of bytes that match the class defined by tokChars<. This function is supposed to work efficiently with large inputs i.e. whole files.=darcs&forceTokReplace tokChars old new input" replaces all occurrences of the old token with the new one, throughout the input.>darcs:Check if a token replace operation touches the given line.?darcsBreak a  Bytestring into tokens, according to @, discarding non-tokens.<=>?@<=>?@ None"#&',.1248=>?HIMPSUVX_kØ Bdarcson-disk format for V1 patchesCdarcson-disk format for V2 patchesDdarcsdisplay formatEdarcs1This type is used to tweak the way that lists of p are shown for a given Patch type pJ. It is needed to maintain backwards compatibility for V1 and V2 patches.Fdarcs#Show and read lists without braces.Gdarcs®Show lists with a single layer of braces around the outside, except for singletons which have no braces. Read with arbitrary nested braces and parens and flatten them out.HdarcsSShow lists without braces. Read with arbitrary nested parens and flatten them out.IdarcsjTemporary hack to disable use of showContextSeries for darcs-3 patches, until I find out how to fix this.JdarcsøShowing and reading lists of patches. This class allows us to control how lists of patches are formatted on disk. For legacy reasons V1 patches have their own special treatment (see E|). Other patch types use the default format which just puts them in a sequence without separators or any prelude/epilogue.nThis means that 'FL (FL p)' etc would be ambiguous, so there are no instances for 'FL p' or other list types. ADBCEGHIFJK JKEGHIFADBC None"#&',.1248=>?@AHIMPSUVX_kÜNdarcsŖThis nullary type class flags code that should only be used for the tests. No instance of it should be defined in either the darcs library or the main darcs executable.NNNone"#&',.1248=>?HIMPSUVX_k$<OdarcsLift an isomorphism between a and b to one between f a and f b. Like +F, except we can only map invertible functions (i.e. an Isomorphisms).Qdarcs@Lightweight type ismomorphisms (a.k.a. invertible functions). If Iso fw bw :: Iso a bthen fw and bw are supposed to satisfyfw . bw = id = bw . fwSdarcsApply an iso under a functor.Tdarcs.Apply an iso under cps (which is a cofunctor).OPQRSTQROPSTNone"#&',.1248=>?HIMPSUVX_kqUdarcsAType of primitive (not yet combined) options. The type parameter b gets instantiated to (v -> a), adding one argument of type v) to the answer type of the continuation.Vdarcs!A type for option specifications.]It consists of four components: a parser, an unparser, a checker, and a list of descriptions.„The parser converts a flag list to some result value. This can never fail: we demand that primitive parsers are written so that there is always a default value (use > with default E as a last resort).WThe unparser does the opposite of the parser: a value is converted back to a flag list.“The checker returns a list of error messages (which should be empty if there are no problems found). This can be used to e.g. check whether there are conflicting flags in the list.’Separating the checker and parser is unusual. The reason for this is that we want to support flags coming from multiple sources, such as the command line or a defaults file. Prioritising these sources is done by concatenating the flag lists in the order of precedence, so that earlier flags win over later ones. That means that when parsing the (final) flag list, conflicting flags are resolved by picking the first flag that matches an option. The checker, on the other hand, can be called for each source separately.cThe last component is a list of descriptors for each single switch/flag that the option is made of.The V7 type is heavily parameterized. The type arguments are: fThe flag type, such as Ÿź.d0A type that describes an single flag, such as ėģ or žķ. It should be a īļ.Abstracting over these types is not technically necessary: for the intended application in Darcs, we could as well fix them as d=žķ, and f=Ÿź’, saving two type parameters. However, doing that here would only obscure what's going on, making the code harder to understand, not easier. Besides, the resulting more general type signatures give us additional guarantees, known as "free theorems" (free as in beer, not in speak). In contrast, the type parameters a, b]are necessary to make chaining of options a la typed printf/scanf possible. In a nutshell, af is the result type of a function that consumes the result of parsing or unparsing an option, while b+ is the complete type of such a function.The X and YĶ members use continuation passing style, which is the reason for their apparently "inverted" type signature. To understand them, it helps to look at the type of "primitive" (not yet combined) options (see U! below). For a primitive option, b gets instantiated to v -> a, where vV is the type of values associated with the option. The whole option spec then has type  o :: 'OptSpec' d f a (v -> a) so that the Y and X members are instantiated to [ ounparse :: forall a. ([f] -> a) -> (x -> a) oparse :: forall a. (x -> a) -> ([f] -> a),which can be easily seen to be equivalent to + ounparse :: x -> [f] oparse :: [f] -> x:Chaining such options results in a combined option of type 6 o1 ^ o2 ^ ... :: OptSpec d f a (v1 -> v2 -> ... -> a) that is, b gets instantiated to  v1 -> v2 -> ... -> aTo use such an option (primitive or combined), you pass in the consumer. A typical consumer of option values is a command implementation. Given , cmd :: v1 -> v2 -> ... -> [String] -> IO ()/we can parse the flags and pass the results to cmd: ! oparse (o1 ^ o2 ^ ...) cmd flagsXdarcs1Convert option value (back) to flag list, in CPS.YdarcsaConvert flag list to option value, in CPS. Note: as a pure function, it is not supposed to fail.Zdarcs7Check for erros in a flag list, returns error messages.[darcs9Descriptions, one for each flag that makes up the option.\darcs Identity V , unit for ]]darcsV composition, associative^darcslNormalise a flag list by parsing and then unparsing it. This adds all implicit (default) flags to the list.2onormalise opts = (oparse opts . ounparse opts) id_darcs!The list of default flags for an V.&defaultFlags opts = onormalise opts []`darcsLift an isomorphism between b and c to one between V d f a b and V d f a c.The forward component of the Q is needed for X, the backward component for Y4. For the other two components this is the identity.adarcs|Combine two list valued options of the same type "in parellel". This is done by concatenating the resulting option values (Y ), flags (X ), errors (Z), and descriptors (['), respectively, of the input options.bdarcs Unit for a.cdarcs¶Parse a list of flags against a primitive option spec, returning the value associated with the option. As noted above, this cannot fail because options always have a default value. parseFlags o fs = oparse o id fsddarcsAUnparse a primitive option spec and append it to a list of flags.edarcsOperator version of c"opt ? flags = parseFlags opt flagsgdarcsSee a and b.UVWXYZ[\]^_`abcdeVWXYZ[\]^_`Uabcdee52005 Tomasz ZielonkaGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_kv$idarcs’Registers an IO action to run just before darcs exits. Useful for removing temporary files and directories, for example. Referenced in Issue1914.ijij2005 Benedikt SchmidtGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_k€\°darcsQassoc list mapping characters to strings eg (c,s) means that %c is replaced by skdarcs’ parse a commandline returning a list of strings (intended to be used as argv) and a bool value which specifies if the command expects input on stdin format specifiers with a mapping in ftable are accepted and replaced by the given strings. E.g. if the ftable is [(s:,"Some subject")], then "%s" is replaced by "Some subject"ldarcsTfor every mapping (c,s), add a mapping with uppercase c and the urlencoded string sklklNone"#&',.1248=>?HIMPSUVX_kr mnopq moqpnNone"#&',.1248=>?HIMPSUVX_k–b rdarcs’LData type to represent a connection error. The following are the codes from libcurl which map to each of the constructors: * 6 -> CouldNotResolveHost : The remote host was not resolved. * 7 -> CouldNotConnectToServer : Failed to connect() to host or proxy. * 28 -> OperationTimeout: the specified time-out period was reached.vdarcs|Q represents a prioritised queue, with two-tier priority. The left list contains higher priority items than the right list.xdarcs©A UrlState object contains a map of url -> InProgressStatus, a Q of urls waiting to be started, the current pipe length and the unique junk to create unique filenames.~darcs­A UrlRequest object contains a url to get, the file into which the contents at the given url should be written, the cachability of this request and the request's priority.‹darcs‹[ will try and take an element from the Q, preferring elements from the high priority list.Œdarcs>Return a function for adding an element based on the priority.darcs& inserts a low priority item into a Q.ŽdarcsŽ' inserts a high priority item into a Q.darcs5 removes any instances of a given element from the Q.darcs checks for membership in a Q.‘darcs‘ is an empty Q.’darcs’# checks if the Q contains no items.!rstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’!~€‚ƒ„…†‡xyz{|}vw‹ŽŒ‘’ˆ‰Šrstu22008 Dmitry Kurochkin <dmitry.kurochkin@gmail.com>GPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_k™õ r„…†‡™š›œ ›š™„…†‡œrNone"#&',.1248=>?HIMPSUVX_k”Öždarcs Encode a R into a ± according to the user's locale with the ghc specific //ROUNDTRIP feature added. This means the argument is allowed to contain non-Unicode 9s as produced by Ÿ.Ÿdarcs Decode a ± into a Ru according to the user's locale with the ghc specific //ROUNDTRIP feature added. This means the result may contain 9Ls that are not valid Unicode in case decoding with the user's locale fails.žŸ ”žŸ ”2005 Tomasz ZielonkaGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_k¤¢£¤„¦§Ø©Ŗ«¬­®Æ°Ø§£¤¢„¦©Ŗ«¬®Æ°­N(c) The University of Glasgow 2001, David Roundy 2003-2005GPL (I'm happy to also license this file BSD style but don't want to bother distributing two license files with darcs.droundy@abridgegame.org experimentalportableNone"#&',.1248=>?HIMPSUVX_kĖ$±darcsyPointer to a filesystem, possibly with start/end offsets. Supposed to be fed to (uncurry mmapFileByteString) or similar.²darcsNDrop leading white space, where white space is defined as consisting of ' ', '\t', '\n', or '\r'.½darcs’"Decompress the given bytestring into a lazy list of chunks, along with a boolean flag indicating (if True) that the CRC was corrupted. Inspecting the flag will cause the entire list of chunks to be evaluated (but if you throw away the list immediately this should run in constant space).ædarcsORead an entire file, which may or may not be gzip compressed, directly into a ±.ĆdarcsORead standard input, which may or may not be gzip compressed, directly into a ±.ÄdarcsERead in a FileSegment into a Lazy ByteString. Implemented using mmap.Ådarcs<Like readFilePS, this reads an entire file directly into a ±’ś, but it is even more efficient. It involves directly mapping the file to memory. This has the advantage that the contents of the file never need to be copied. Also, under memory pressure the page may simply be discarded, wile in the case of readFilePS it would need to be written to swap. If you read many small files, mmapFilePS will be less memory-efficient than readFilePS, since each mmapFilePS takes up a separate page of memory. Also, you can run into bus errors if the file is modified.ÉdarcsWReturn the B.ByteString between the two lines given, or Nothing if they do not appear.Źdarcs&Simpler but less efficient variant of É.Ėdarcs0Test if a ByteString is made of ascii charactersĢdarcs Decode a  ByteString containing UTF-8 to a R9. Decoding errors are flagged with the U+FFFD character.Ķdarcs Encode a R to a  ByteString using UTF-8.Īdarcs Decode a  ByteString to a RP according to the current locale, using lone surrogates for un-decodable bytes.Ļdarcs Encode a R to a  ByteString’ according to the current locale, converting lone surrogates back to the original byte. If that fails (because the locale does not support the full unicode range) then encode using utf-8, assuming that the un-ecodable characters come from patch meta data. See also ·š. ±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻ æÅĄĮĆĀ±Ä¾½²ø¹“¶·µ³ĒĘÉĖĪĻĢĶŗ»¼ČŹ62003 David Roundy 2005 Benedikt SchmidtGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_kįŃdarcs¬create a list of changes between a and b, each change has the form (starta, lima, startb, limb) which means that a[starta, lima) has to be replaced by b[startb, limb)²darcs'mark hash value where collision occured³darcsGreturn arrays with changes in a and b (1 indexed), offsets start with 0“darcs@set changes array for a and b and return number of changed linesµdarcsQreturn (xmid, ymid, cost) for the two substrings a[off_a+1..off_a+1+l_a] and b¶darcsAfind position on diag d with one more insert/delete going forward·darcsHfollow snake from northwest to southeast, x and y are absolute positionsødarcsBfind position on diag d with one more insert/delete going backward¹darcsHfollow snake from southeast to northwest, x and y are absolute positionsÓdarcsEtry to create nicer diffs by shifting around regions of changed linesŗdarcs<goto next unchanged line, return the given line if unchanged»darcsRskip at least one unchanged line, if there is none advance behind the last line¼darcsgoto n-th next unchanged line½darcs8goto next changed line, return the given line if changed¾darcs@goto previous unchanged line, return the given line if unchangedŠŃŅÓŌÕŃÓŌÕŠŅNone"#&',.1248=>?HIMPSUVX_k%ædarcs.the longest common subsequence of unique itemsĄdarcs’ZThe patientLcs algorithm is inspired by the "patience" algorithm (for which I don't have a reference handy), in that it looks for unique lines, and uses them to subdivide the problem. I use lcs to diff the unique lines. It is slower, but should lead to "better" diffs, in the sense of ones that better align with what humans think changed.’ÅNote that when compared with the Meyers algorithm used in darcs, this is somewhat slower (maybe 4x in some of my tests), but is lacking its stack overflow problem. I'm not sure how it scales in general, but it scales fine (just 10x slower than GNU diff) when comparing a 6M american english dictionary with a british english dictionary of the same size (which isn't a great test, but is the largest pair of somewhat-differing files I could find).āNote that the patientLcs algorithm is slower than the one used in lcs for sequences with mostly unique elements (as is common in text files), but much *faster* when the sequence has a high degree of redundancy. i.e. lines usrsharedictwords vs lines (cat usrsharedict words | tr 'a-z' a)Įdarcs`LCS'’ stands for ``Longest Common Subsequence,'' and it is a relatively challenging problem to find an LCS efficiently. I'm not going to explain here what an LCS is, but will point out that it is useful in finding how two sequences (lists, in this case) differ. This module implements the Hunt-Szymanski algorithm, which is appropriate for applications in which the sequence is on an infinite alphabet, such as diffing the lines in two files, where many, or most lines are unique. In the best case scenario, a permutation of unique lines, this algorithm is $O(nlog n)$. In the worst case scenario, that of a finite alphabet (i.e. where the number of elements in the sequence is much greater than the number of unique elements), it is an $O(n^2log n)$ algorithm, which is pretty terrible.ÖÖNone"#&',.1248=>?HIMPSUVX_k3ףŲŚŚ×ŁŲNone"#&',.1248=>?HIMPSUVX_k Õ ŽdarcsLocation of the lock file.ßdarcs.Location of the (one and only) head inventory.įdarcs8Location of the (one and only) tentative head inventory.ćdarcsLocation of parent inventories.ådarcsLocation of pristine trees.čdarcsLocation of patches.źdarcsLocation of index files.ģdarcsLocation of the rebase patchīdarcsLocation of format fileļdarcsLocation of pending filesņdarcsLocation of unrevert bundle.ódarcs7Location of old style (unhashed) files and directories.ŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷None"#&',.1248=>?HIMPSUVX_kėdarcs"Just copy pristine and inventoriesdarcs*First do a lazy clone then copy everythingdarcs8Same as Normal but omit telling user they can interrumptdarcs!Just files already known to darcsdarcs!All files, i.e. look for new onesdarcsAll files, even boring oneshףŲųłūśüżž’      !"#$%&(')*+,-./0123456789:;<=>?@ABCEDFGHIJKLNMOPQRSTUVWXYZ[\hUVWOPQ\LNMXYZ[IJKFGHCED@AB=>?:;<ףŲ789123./0+,-)*&('#$% !"    RST 456üżž’ųłūśNone"#&',.1248=>?HIMPSUVX_k*mĀdarcsSimple helper type used in the › and Ÿ algorithms.˜darcs"Undirected graph represented as a Ć of adjacency ™s.™darcsDSet of vertices, represented as a list for efficiency (yes, indeed).šdarcsVertices are represented as <.ÄdarcsThe neighbors of a š in a ˜.ÅdarcsThe number of vertices in a ˜.›darcs,Determine the maximal independent sets in a – of a ˜.œdarcsWThe classic Bron-Kerbosch algorithm for determining the maximal independent sets in a ˜.darcsCEnumerate all (simple) graphs of a given size (number of vertices).ŸdarcsSplit a ˜m into connected components. For efficiency we don't represent the result as a list of Graphs, but rather of ™s.Ędarcs Whether a ™E is independent i.e. no edge exists between any two of its vertices.Ēdarcs Whether a ™g is maximally independent i.e. it is independent and no longer independent if we add any other vertex. darcsWhether › is equivalent to œ.”darcsWhether ›) generates only maximal independent sets.¢darcsWhether › generates all maximal independent sets.ČdarcsWhether a list of ™s of a ˜0 is a partition of the set of all its vertices.Édarcs#Whether there is no edge between a ™ of a ˜ and the rest of the ˜.Źdarcs Whether a ™ of a ˜ is connected.Ėdarcs Whether a ™! is a connected component of the ˜.£darcsComplete specification of the Ÿ function.–—˜™š›œžŸ ”¢£˜š™–—›œŸž ”¢£None"#&',.1248=>?HIMPSUVX_k,ČØdarcsurldarcsbodydarcs mime typedarcsresult„¦§Ø„¦§ØNone"#&',.1248=>?HIMPSUVX_k7~®darcsProduce a base16 (ascii-hex) encoded string from a hash. This can be turned back into a Hash (see "decodeBase16". This is a loss-less process.Ædarcs0Take a base16-encoded string and decode it as a Hash-. If the string is malformed, yields NoHash.°darcs(Compute a sha256 of a (lazy) ByteString.±darcs%Same as previous but general purpose.¹darcsParse a ©, directly from its B16 encoding, given as a ± , or return E}. The implementation is quite low-level and optimized because the current implementation of RepoPatchV3 has to read lots of ©9 hashes, and profiling showed that this is a bottleneck.©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ«¬­®Æ°±²³·©Ŗø“µ¶ŗ¹22003 Peter Simons 2003 David RoundyGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_k¦F/ĆdarcsAn  MCalenderTime is an underspecified Ģœ It is used for parsing dates. For example, if you want to parse the date '4 January', it may be useful to underspecify the year by setting it to E*. This uses almost the same fields as Ģ1, a notable exception being that we introduce Ń. to indicate if a weekday was specified or notÓdarcs^Read/interpret a date string, assuming UTC if timezone is not specified in the string (see ĶA) Warning! This errors out if we fail to interpret the dateŌdarcs“Convert a date string into ISO 8601 format (yyyymmdd variant) assuming local timezone if not specified in the string Warning! This errors out if we fail to interpret the dateÕdarcs4Return the local timezone offset from UTC in secondsĶdarcsParse a date string with ×r Warning! This errors out if we fail to interpret the date Uses its first argument as the default time zone.Ödarcs Similar to Ó , except we ignore’ timezone info in the input string. This is incorrect and ugly. The only reason it still exists is so we can generate file names for old-fashioned repositories in the same way that old darcs versions expected them. You should not use this function except for the above stated purpose.×darcsŠParse a date string, assuming a default timezone if the date string does not specify one. The date formats understood are those of Ų and ĪŲdarcs Display a ĢF in the ISO 8601 format without any separators, e.g. 20080825142503Łdarcs+The current time in the format returned by ŲĻdarcs%Case-insensitive variant of Parsec's Š function.Ńdarcs%Case-insensitive variant of Parsec's Ņ function.ÓdarcsMatch a parser at least n times.ŌdarcsMatch a parser at least n times, but no more than m times.Īdarcs5Try each of these date parsers in the following order ÕÖ×ŲÕdarcs"CVS-style date/times, e.g. 200708:25 14:25:39 GMT Note that time-zones are optional here.×darcss"Old"-style dates, e.g. Tue Jan 3 14:08:07 EST 1999 darcs-doc: Question (what does the "old" stand for really?)Ödarcs;ISO 8601 dates and times. Please note the following flaws:I am reluctant to implement: years > 9999<truncated representations with implied century (89 for 1989)I have not implemented:!repeated durations (not relevant)-lowest order component fractions in intervalsnegative dates (BC)-I have not verified or have left too relaxed:!the difference between 24h and 0h·allows stuff like 2005-1212; either you use the hyphen all the way (2005-12-12) or you don't use it at all (20051212), but you don't use it halfway, likewise with timevNo bounds checking whatsoever on intervals! (next action: read iso doc to see if bounds-checking required?) -}ŁdarcsThree types of ISO 8601 date:6calendar date, e.g., 1997-07-17, 1997-07, 199707, 1997#week+day in year, e.g., 1997-W32-4day in year, e.g, 1997-273ŚdarcsRNote that this returns a function which sets the time on another calendar (see Ö for a list of flawsŚdarcsIntervals in ISO 8601, e.g.,2008-09/2012-08-17T16:302008-09/P2Y11MT16H30MP2Y11MT16H30M/2012-08-17T16:30See ŪŪdarcsDurations in ISO 8601, e.g.,P4Y (four years)P5M (five months)"P4Y5M (four years and five months)2P4YT3H6S (four years, three hours and six seconds)ŪdarcsŪ p xs/ parses a string with the obligatory parser pä. If this suceeds, it continues on to the rest of the input using the next parsers down the chain. Each part of the chain consists of a parser for a separator and for the content itself. The separator is optional.oA good use of this function is to help in parsing ISO ISO 8601 dates and times. For example, the parser *optchain year [(dash, month), (dash, day)]³ accepts dates like 2007 (only the year is used), 2007-07 (only the year and month), 200707 (only the year and month with no separator), 2007-07-19 (year, month and day).ÜdarcshOne or more space. WARNING! This only matches on the space character, not on whitespace in generalŻdarcs;English three-letter day abbreviations (e.g. Mon, Tue, Wed)ŽdarcsFour-digit yearßdarcs:One or two digit month (e.g. 3 for March, 11 for November)ądarcs January is 1, February is 2, etcįdarcs=English three-letter month abbreviations (e.g. Jan, Feb, Mar)ādarcs day in one or two digit notationćdarcshour in two-digit notationädarcsminute in two-digit notationådarcssecond in two-digit notationędarcslimited timezone support+HHMM or -HHMMUniversal timezones: UTC, UTZones from GNU coreutilslib5getdate.y, less half-hour ones -- sorry Newfies.>any sequence of alphabetic characters (WARNING! treated as 0!)ÜdarcsAIn English, either a date followed by a time, or vice-versa, e.g,yesterday at noonyesterday tea time12:00 yesterdaySee ē and čw Uses its first argument as "now", i.e. the time relative to which "yesterday", "today" etc are to be interpretedēdarcs:Specific dates in English as specific points of time, e.g,today yesterday/last week (i.e. the beginning of that interval)4 months ago (via é)The first argument is "now".édarcs0English expressions for points in the past, e.g. 4 months ago 1 day agoday before yesterdaySee źŻdarcs*English expressions for intervals of time,1before tea time (i.e. from the beginning of time)&after 14:00 last month (i.e. till now) between last year and last month2in the last three months (i.e. from then till now)!4 months ago (i.e. till now; see é)ŽdarcsˆDurations in English that begin with the word "last", E.g. "last 4 months" is treated as the duration between 4 months ago and nowčdarcs Either an Ś; or one of several common English time expressions like noon or 'tea time'źdarcsSome English durations, e.g.day4 score7 years 12 monthswThis is not particularly strict about what it accepts. For example, "7 yeares", "4 scores" or "1 days" are just fine.ßdarcs+The very beginning of time, i.e. 1970-01-01ądarcsTrivially convert a Ģ to a fully specified Ć (note that this sets the Ń flag to FalseįdarcsReturns the first Ģ that falls within a Ćp This is only unsafe in the sense that it plugs in default values for fields that have not been set, e.g. January for the month or 0T for the seconds field. Maybe we should rename it something happier. See also äėdarcsė i d multiplies every field in d with i‡FIXME; this seems like a terrible idea! it seems like we should get rid of it if at all possible, maybe adding an invertDiff functionädarcssSet a calendar to UTC time any eliminate any inconsistencies within (for example, where the weekday is given as ThursdayN, but this does not match what the numerical date would lead one to expect)ģdarcsģ c mc- replaces any field which is specified in mc with the equivalent field in c -copyCalendar c nullMCalendar == nullMCalendarådarcsZero the time fields of a Ģ#ĆÄĻĒŃĢÅĘĶČÉŹĖĪŠŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäå#ŁÓÖ×ÕÜŻŽŚŪŌäĆÄĻĒŃĢÅĘĶČÉŹĖĪŠćāąįåŅŲß2004 David RoundyGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_kĘŁ ēdarcsA ēō combines a potential parse for a date string with a "matcher" function that operates on a given date. We use an existential type on the matcher to allow the date string to either be interpreted as a point in time or as an interval.ķdarcsķ x y is true if x <= y < (x + one_day)+ Note that this converts the two dates to  ClockTime& to avoid any timezone-related errorsīdarcsī x1 x2 y is true if  x1 <= y < x2 Since x1 and x2U can be underspecified, we simply assume the first date that they could stand for.ļdarcsļ x1 x2 y is true if  x1 <= y < x2šdarcsš x1 x2 y is true if  x1 <= y < x2ńdarcsń  range exact is true if exact5 falls within the a range of dates represented by range’Y. The purpose of this function is to support matching on partially specified dates. That is, if you only specify the date 2007, this function should match any dates within that year. On the other hand, if you specify 2007-01, this function will match any dates within that month. This function only matches up to the second.édarcsé s" return the first matcher in ź that can parse sźdarcsź d9 returns the list of matchers that will be applied on dm. If you wish to extend the date parsing code, this will likely be the function that you modify to do so.ņdarcsņ ms' returns the first successful match in ms* It is an error if there are no matchesėdarcsė d; shows the possible interpretations for the date string d/ and how they match against the current dateģdarcsė iso d; shows the possible interpretations for the date string dK and how they match against the date represented by the ISO 8601 string isoódarcshelper function for ė and ģōdarcsō c dm tells us if dm applies to Ģ c; or if dm? just represents the failure to parse a date, in which case c is moot.ēčéźėģéēčźėģNone"#&',.1248=>?HIMPSUVX_kČUVWXYZ[\]bķīļšńņóōõö÷ZXńõ\]óļšö÷ī[bķUVņYWō None"#&',.1248=>?HIMPSUVX_kßIõdarcsõg is a wrapper around '[Printable] -> [Printable]' which allows to handle the special case of an empty õ( in a non-uniform manner. The simplest  Documents are built from Rs using 6.’darcs?A set of printers to print different types of text to a handle.ödarcsThe State associated with a  V. Contains a set of printers for each hanlde, and the current prefix of the document. darcsA   is a bit of enriched text.  s are concatenated using  from class 7, which is right-associative. darcsA  T is either a String, a packed string, or a chunk of text with both representations.÷darcs  representation of a spaceųdarcs  representation of a newline.darcsA   representing a space (" ")darcsA   representing a newlinedarcsA   representing a "-"darcsA   representing a "+"darcsA   representing a "\"darcsA   that represents "("darcsA   that represents ")"darcs parens d = lparen <> d <> rparendarcsTurn a  % into a sentence. This appends a ".".darcsFormat a list of qŻs as quoted text. It deliberately refuses to use English.andClauses but rather separates the quoted strings only with a space, because this makes it usable for copy and paste e.g. as arguments to another shell command.darcs puts a  # on stdout using the given printer.darcs puts a  ;, followed by a newline on stdout using the given printer.darcs puts a  $ on stdout using the simple printer H.darcs puts a  ), followed by a newline on stdout using Hdarcs hputDocWith puts a  - on the given handle using the given printer.darcs hputDocLnWith puts a  E, followed by a newline on the given handle using the given printer. darcshputDoc puts a   on the given handle using H!darcs hputDocLn puts a  3, followed by a newline on the given handle using H."darcslike  & but with compress data before writing#darcsWrite a  % to stderr if debugging is turned on.łdarcsł h prints a list of  s to the handle h It uses binary output of  ByteString9s. If these not available, converts according to locale.śdarcsś h prints a   to the handle h.$darcs renders a   into a R5 with control codes for the special features of the  .%darcs renders a   into a RA using a given set of printers. If content is only available as  ByteString*, decode according to the current locale.&darcs renders a   into ±C with control codes for the special features of the Doc. See also  readerString.'darcs renders a   into a list of  PackedStrings, one for each line.(darcs renders a   into a ± using a given set of printers.)darcs renders a   into a list of  PackedStrings4, one for each chunk of text that was added to the  #, using the given set of printers.ūdarcs renders a   into a list of  Printables` using a set of printers. Each item of the list corresponds to a string that was added to the  ./darcs/ builds a Doc from a R and a ±> representing the same text, but does not check that they do.0darcs0 builds a   from a R:. The string is stored in the Doc as both a String and a ±.1darcs1 builds a   from a ± using D2darcs2 builds a   from a ± using I3darcs3 creates a   with invisible text from a ±4darcs4 creates a  " representing a user chunk from a ±.4Rrrright. And what, please is that supposed to mean?5darcs5- creates a Doc containing just one character.6darcs6 creates a   from a String, using D.7darcs7 creates a   from a R, using I directly8darcs8 creates a  " containing invisible text from a String9darcs9 creates a   containing hidden text from a String:darcs: creates a   containing a user chunk from a String@darcs@ creates a   containing colored text from a StringAdarcsA n s is a   representing s line-wrapped at n charactersBdarcsGiven a list of RFs representing the words of a paragraph, format the paragraphs using A& and separate them with an empty line.Cdarcs A variant of A5 that takes a list of strings as input. Useful when {- LANGUAGE CPP -}7 makes it impossible to use multiline string literals.Ddarcs Creates a   from any  .EdarcsCreates an invisible   from any  .FdarcsCreates a hidden   from any  .Gdarcs Creates... WTF is a userchunk???HdarcsH is a  which uses the set 'simplePriners\'' on any handle.üdarcsFA set of default printers suitable for any handle. Does not use color.IdarcsI is the simplest ž3: it just concatenates together the pieces of the  JdarcsJ is the ž6 for hidden text. It just replaces the document with KŽ. It's useful to have a printer that doesn't actually do anything because this allows you to have tunable policies, for example, only printing some text if it's to the terminal, but not if it's to a file or vice-versa.Kdarcs The empty  żdarcsConcatenation of two  sMdarcsa M b is a  b if a is not empty, else emptyNdarcsa N b is a followed by b. with a space in between if both are non-emptyOdarcsa O b is a above bPdarcsa P b is a above b4 with an empty line in between if both are non-emptyQdarcsPile   s verticallyRdarcsPile  *s vertically, with a blank line in betweenSdarcs Concatenate  s horizontallyTdarcs Concatenate  (s horizontally with a space as separatorUdarcs Quote a string for screen outputVdarcs () is concatenation,  is the K  XdarcsdTogether with the language extension OverloadedStrings, this allows to use string literals where a   is expected._ųśūłżüž’      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTU_   KMNOPQRST698AUBC:1*.,+34$%&(')’žHJI  LDEFGųśūłżü;<=>?@- !"#7/052ż6N6O5P5! 2008 Eric KowGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_k0ÜYdarcs bsingular This (Noun "batch") "" == "this batch" plural This (Noun "batch") "" == "these batches"]darcsThis only distinguishes between nouns with a final -ch, and nouns which do not. More irregular nouns will just need to have their own type tplural (Noun "batch") "" == "batches" plural (Noun "bat") "" == "bats" plural (Noun "mouse") "" == "mouses" -- :-(_darcs/Things that have a plural and singular spellingbdarcs englishNum 0 (Noun "watch") "" == "watches" englishNum 1 (Noun "watch") "" == "watch" englishNum 2 (Noun "watch") "" == "watches"cdarcs,Given a list of things, combine them thusly: 4orClauses ["foo", "bar", "baz"] == "foo, bar or baz"ddarcs,Given a list of things, combine them thusly: 4orClauses ["foo", "bar", "baz"] == "foo, bar or baz"idarcs%Capitalize the first letter of a wordYZ[\]^_a`bcdefghib_a`]^[\YZcdefghi"None"#&',.1248=>?HIMPSUVX_k=:mdarcs’¾Formats an e-mail header by encoding any non-ascii characters using UTF-8 and Q-encoding, and folding lines at appropriate points. It doesn't do more than that, so the header name and header value should be well-formatted give or take line length and encoding. So no non-ASCII characters within quoted-string, quoted-pair, or atom; no semantically meaningful signs in names; no non-ASCII characters in the header name; etcetera.ždarcsęTurns a piece of string into a q-encoded block Applies q-encoding, for use in e-mail header values, as defined in RFC 2047. It just takes a string and builds an encoded-word from it, it does not check length or necessity.mnopnomp#None"#&',.1248=>?HIMPSUVX_kc!’darcsThe ’> type is a record containing the variables which control how  "s will be rendered on some output.darcsoverall use of colordarcsoverall use of escapingdarcs1overall use of colored lines (only hunks for now)darcs$alternative to color (bold, inverse)darcsdon't escape isprintsdarcsdon't escape 8-bit charsdarcsextra chars to never escapedarcsextra chars to always escapedarcsescape trailing spaces darcsignore r at end of lines darcs$escape spaces (used with poTrailing)qdarcs eputDocLn puts a  ), followed by a newline to stderr using uå. Like putDocLn, it encodes with the user's locale. This function is the recommended way to output messages that should be visible to users on the console, but cannot (or should not) be silenced even when --quiet is in effect. darcs ” returns a suitable policy for a given handle. The policy is chosen according to environment variables, and to the type of terminal which the handle representsudarcsu h7 returns a set of printers suitable for outputting to h darcs  policy< tries to color a Doc, according to policy po. That is, if policy has  poLineColor4 set, then colors the line, otherwise does nothing. darcs  policy string escapes string$ according to the rules defined in policy, turning it into a  .darcs policy c tells wether c0 will be left as-is when escaping according to policydarcsG tells wether a character is a printable character of the ascii range.darcs2 represents a special character as a string. *  quoteChar '^c' (where ^c is a control character) is "^c" * Otherwise,  quoteChar returns "hex", where hex1 is the hexadecimal number of the character.darcs policy doc marks docC with the appropriate marking for escaped characters according to policydarcs policy color doc colors doc with color color if policyZ is not set to use an alternative to color. In that case, it makes the text bold instead.darcs doc tries to make docm (usually a single escaped char) stand out with the help of only plain ascii, i.e., no color or font style.darcs)the string to reset the terminal's color.darcs color doc returns a colorized version of doc. color/ is a string that represents a color, given by darcs boldens a doc.darcs* returns an invert video version of a doc.qrstuvwxtsruvxwq$2008 David RoundyGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_km§ydarcsbeginTedious k/ starts a tedious process and registers it in  with the key kC. A tedious process is one for which we want a progress indicator.ŽWouldn't it be safer if it had type String -> IO ProgressDataKey, so that we can ensure there is no collision? What happens if you call beginTedious twice with the same string, without calling endTedious in the meantime?zdarcs endTedious k* unregisters the tedious process with key k , printing Done" if such a tedious process exists.|darcsXXX: document this constant „yz{|}~€‚ƒ yz{„ƒ~€}|‚%2003 David RoundyGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_kq%darcscommand to rundarcs any argumentsdarcsexitcode, stderr „…†ˆ‰‡Š‹ŒŽ ŽŒ‹†ˆ‰‡Š„…&None"#&',.1248=>?HIMPSUVX_k}J˜darcsonly shown on help›darcs!Ask the user for a line of input.œdarcsAsk the user to press EnterdarcsaskUserListItem prompt xs enumerates xs? on the screen, allowing the user to choose one of the itemsždarcsPrompt the user for a yes or noŸdarcs’HPrompt the user for a character, among a list of possible ones. Always returns a lowercase character. This is because the default character (ie, the character shown in uppercase, that is automatically selected when the user presses the space bar) is shown as uppercase, hence users may want to enter it as uppercase.›darcsThe prompt to displaydarcsThe string the user entered.œdarcsThe prompt to display ”•–—˜™š›œžŸ œ›”•–—˜™šžŸNone"#&',.1248=>?HIMPSUVX_k~°gogo'None"#&',.1248=>?HIMPSUVX_kĘ ”¢¢ ”(None"#&',.1248=>?HIMPSUVX_k€ä ¢¤„¦§Ø©Ŗ«¬ ¦§¤„©Ø«Ŗ¬¢)None"#&',.1248=>?HIMPSUVX_k™Œ ­darcs­ abstracts over ² and ±# for code constructing these values®darcs An empty ­, e.g. NilFL or NilRLÆdarcsA ­e constructed from a completely polymorphic value, for example the constructors for primitive patches°darcs Compose two ­C values together in series, e.g. 'joinGap (+>+)' or 'joinGap (:>:)'±darcs± p is  forall y . exists x . p x y ¾ In other words the caller is free to specify the right witness, and then the left witness is an existential. Note that the order of the type constructors is important for ensuring that  x  is dependent on the  y  that is supplied.²darcs² p is  forall x . exists y . p x y ¾ In other words the caller is free to specify the left witness, and then the right witness is an existential. Note that the order of the type constructors is important for ensuring that  y  is dependent on the  x  that is supplied. This is why Stepped2 is needed, rather than writing the more obvious · (O p) which would notionally have the same quantification of the type witnesses.darcs is similar to ·], but the type argument is universally quantified instead of being existentially quantified.µdarcs The same as ·$ but for two parameters (wX and wY).·darcsA ·Ö type is a way of hide an existentially quantified type parameter, in this case wX, inside the type. Note that the only thing we can currently recover about the existentially quantified type wX is that it exists.Ādarcs Unwrap a ² valueĆdarcs Unwrap a ± value­Æ®°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆ·ø¹µ¶ŗ³“»¼½¾æĄĮ²±ĀĆ­Æ®°*None"#&',.1248=>?HIMPSUVX_k»hÉdarcsParallel PairsĖdarcs(Forking Pair (Explicit starting context) ˆ wX wY \ / \ / \ / wU | | | wA Ķdarcs Joining PairsĻdarcs)Forking Pairs (Implicit starting context)Ńdarcs Reverse listsŌdarcs Forward lists×darcsDirected Forward PairsŪdarcsfilterOutFLFL p xs deletes any x in xs for which  p x == IsEq (indicating that xX has no effect as far as we are concerned, and can be safely removed from the chain)édarcsMonadic fold over an Ōo associating to the left, sequencing effects from left to right. The order of arguments follows the standard foldM from base.źdarcsMonadic fold over an Ō© associating to the right, sequencing effects from right to left. Mostly useful for prepend-like operations with an effect where the order of effects is not relevant.ļdarcsThe "natural" fold over an Ō& i.e. associating to the right. Like ńņ. only with the more useful order of arguments.šdarcs;The "natural" fold over an RL i.e. associating to the left.ńdarcsRight associative fold for ŌFs that transforms a witnessed state in the direction opposite to the Ō". This is the "natural" fold for Ō#s i.e. the one which replaces the Õ with the passed operator.ņdarcsThe analog of ń for Ń#s. This is the "natural" fold for Ń#s i.e. the one which replaces the Ņ with the passed operator.darcsLike Ż only for Ń`s. This function is supposed to be lazy: elements before the split point should not be touched.darcsLike Ų only for Ń`s. This function is supposed to be lazy: elements before the split point should not be touched.darcsLike × only for Ń`s. This function is supposed to be lazy: elements before the split point should not be touched.darcsCheck that two Ō7s are equal element by element. This differs from the 1 instance for Ō which uses commutation.darcs Prepend an Ń to an Ō). This traverses only the left hand side.darcs Append an Ō to an Ń*. This traverses only the right hand side.BÉŹĖĢĶĪĻŠŃÓŅŌÖÕ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’  B×ŲŌÖÕŃÓŅĻŠĶĪÉŹĖĢŁŚūüųśó÷ļšńņėķģīłŻéźęēŪÜąįŽßāćčäåö’ōõ żž É1Ź1Ķ1Ī1Ļ1Š1Ņ5Õ5×1Ų1Ž5ß555+None"#&',.1248=>?HIMPSUVX_kĀ darcs^"Clowns to the left of me, jokers to the right. Here I am, stuck in the middle of you" 0http://en.wikipedia.org/wiki/Stuck_in_the_Middle!darcsSee   !"#$%&'$%"#! &',None"#&',.1248=>?HIMPSUVX_kƌ()*+,-()*+,--None"#&',.1248=>?HIMPSUVX_kŠ<.darcs’)During a rebase, we use "fixup" patches to maintain the correct context for the real "items" that are being stored in the rebase that the user wants to keep. As the context of the rebase changes, new fixups get added to the beginning that then need to be pushed past as many items as possible.’«There are multiple fixup types and multiple ways of representing the items being stored in the rebase, so this is polymorphic in both types. Also, the structure of the results varies - in some cases it will be a single value, sometimes an FL, or sometimes zero or one values (Maybe2), so the output types are separate variables. A typical instantiation would be something like PushFixupFn Fixup Item (FL Item) (FL Fixup)../012345./012345.None"#&',.1248=>?HIMPSUVX_kŌĻ6darcsThe 74 operation must be self-inverse, i.e. an involution:invert . invert = id:darcsrDelete the first subsequence of patches that is followed by an inverse subsequence, if one exists. If not return E.6789:6789:/None"#&',.1248=>?HIMPSUVX_kß@>darcs’ PatchDebug is a hook class for temporarily adding debug information. To use it, add any methods that are required, implement those methods where needed, and then make it available in the relevant contexts. For example it can be temporarily added as a superclass of PatchyŪ. The advantage of having it here already is that everything is (or should be) declared as an instance of it, so you can use defaulting or just leave out declarations of instance methods and code will still compile.?darcsRA dummy method so we can export/import PatchDebug(..) without triggering warnings>?>?0None"#&',.1248=>?HIMPSUVX_kņOEdarcs’FCommuteFn is the basis of a general framework for building up commutation operations between different patch types in a generic manner. Unfortunately type classes are not well suited to the problem because of the multiple possible routes by which the commuter for (FL p1, FL p2) can be built out of the commuter for (p1, p2) - and more complicated problems when we start building multiple constructors on top of each other. The type class resolution machinery really can't cope with selecting some route, because it doesn't know that all possible routes should be equivalent.›Note that a CommuteFn cannot be lazy i.e. commute patches only when the resulting sequences are demanded. This is because of the possibility of failure (E_): all the commutes must be performed before we can know whether the overall commute succeeds.Hdarcs&TODO document laziness or lack thereofIdarcs&TODO document laziness or lack thereofMdarcs&TODO document laziness or lack thereofNdarcs&TODO document laziness or lack thereofOdarcsuMake use of the inverse-commute law to reduce the number of cases when defining commute for complicated patch types.BCDEFGHIJKLMNOEGJFKLCBHDIMNO1None"#&',.1248=>?HIMPSUVX_k®Pdarcs:Commute represents things that can be (possibly) commuted.)Instances should obey the following laws:SymmetryDcommute (p:>q) == Just (q':>p') <=> commute (q':>p') == Just (p':>q)If an instance Invert p exists, then_commute (p:>q) == Just (q':>p') <=> commute (invert q:>invert p) == Just (invert p':>invert q')#The more general Square-Commute lawPcommute (p:>q) == Just (q':>p') => commute (invert p:>q') == Just (q:>invert p')Ais required to hold only for primitive patches, i.e. if there is no instance Merge p, because together with merge, it implies that any two patches commute.RdarcsR commutes an Ń past an Ō.SdarcsS% commutes a RL past a single element.TdarcsT% commutes a single element past a FL.UdarcsTBuild a commuter between a patch and itself using the operation from the type class.PQRSTUPQTSRU2darcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_k3%Xdarcs9Patches that can always be merged, even if they conflict.)Instances should obey the following laws: symmetryAmerge (p :\/: q) == q' :/\: p' <=> merge (q :\/: p) == p' :/\: q' merge-commuteFmerge (p :\/: q) == q' :/\: p' ==> commute (p :> q') == Just (q :> p');that is, the two branches of a merge commute to each other. extensionLcleanMerge (p :\/: q) == Just (q' :/\: p') => merge (p :\/: q) == q' :/\: p' that is, Y is an extension of [.ZdarcsRClass of patches that can, possibly, be merged cleanly, that is, without conflict.,Every patch type can be made an instance of Z in a trivial way by defining [ _ = E0, which vacuously conforms to all required laws.)Instances should obey the following laws: symmetryYcleanMerge (p :\/: q) == Just (q' :/\: p') <=> cleanMerge (q :\/: p) == Just (p' :/\: q')If an instance P p exists, then we also require  merge-commuteRcleanMerge (p :\/: q) == Just (q' :/\: p') ==> commute (p :> q') == Just (q :> p')Athat is, the two branches of a clean merge commute to each other.If an instance 6 p exists, then we also require  square-mergefcleanMerge (p :\/: q) == Just (q' :/\: p') => cleanMerge (invert p :\/: q') == Just (q :/\: invert p')1Here is a picture that explains why we call this  square-merge: õ A---p--->X A<--p^---X | | | | | | | | q q' => q q' | | | | v v v v Y---p'-->B Y<--p'^--B\darcs%Cleanly merge a single patch with an Ō of patches.]darcs Synonym for Y._darcsLift a merge function over p :/: q to a merge function over  p :/: FL q`darcsLift a merge function over p :/: q to a merge function over  FL p :/: qadarcsLift a merge function over p :/: q to a merge function over  FL p :/: FL qbdarcsSwap the two patches, Y$, then swap again. Used to exploit f when defining Y.cdarcsISwap the two patches, apply an arbitrary merge function, then swap again.ddarcsSwap the two patches, [$, then swap again. Used to exploit prop_cleanMergeSymmetric when defining [.edarcs’ Combine a list of patch sequences, all starting at the same state, into a single sequence that also starts at the same state, using cleanMerge. If the merge fails, we return the two sequences that could not be merged so we can issue more detailed error messages.darcs’;This function serves no purpose except to demonstrate how merge together with the square commute law allows us to commute any pair of adjacent patches. Note that using this function introduces inverse conflictors if the regular commute would fail. This is problematic because it invalidates another global invariant we rely on, namely that we can always drop (obliterate or amend) patches from the end of a repo. This is because inverse conflictors contain references to patches that come after it, so dropping them would make the inverse conflictor inconsistent.fdarcs0Whether the given pair of patches satisfies the symmetry law.gdarcs0Whether the given pair of patches satisfies the  merge-commute law.XYZ[\]^_`abcdefgZ[XY]c_`a\^bdefg3None"#&',.1248=>?HIMPSUVX_kX~ jdarcs Split an Ōķ according to a predicate, using commutation as necessary, into those that satisfy the predicate and can be commuted to the left, and those that do not satisfy it and can be commuted to the right. Whatever remains stays in the middle.Note that the predicate p, should be invariant under commutation: if commute(x:>y)==Just(y':>x') then p x == p x' && p y == p y'.ldarcs Split an Ńč according to a predicate, using commutation as necessary, into those that satisfy the predicate and can be commuted to the right, and those that don't, i.e. either do not satisfy the predicate or cannot be commuted to the right.Note that the predicate p, should be invariant under commutation: if commute(x:>y)==Just(y':>x') then p x == p x' && p y == p y'.rdarcsr x xs removes x from xs if x6 can be commuted to its head. Otherwise it returns Esdarcss is like r except with Ńtdarcst ab abc returns Just c' where all the patches in abk have been commuted out of it, if possible. If this is not possible for any reason (the set of patches ab is not actually a subset of abc., or they can't be commuted out) we return E.udarcsu is like removeSubsequenceFL except that it works on ŃvdarcsThis is a minor variant of w2 with each permutation is simply returned as a Ōwdarcsw p:>:psE returns all the permutations of the list in which one element of ps is commuted past p%Suppose we have a sequence of patches  X h a y s-t-c k#Suppose furthermore that the patch c depends on t, which in turn depends on s. This function will return qX :> h a y s t c k h :> X a y s t c k a :> X h y s t c k y :> X h a s t c k s :> X h a y t c k k :> X h a y s t cxdarcsx is like w", except that we operate on an Ńg (in other words, we are pushing things to the end of a patch sequence instead of to the beginning).ydarcsAll permutations of an Ń.zdarcsxPartition a list into the patches that merge cleanly with the given patch and those that don't (including dependencies)jdarcs=predicate; if true we would like the patch in the "left" listdarcsinput Ōdarcs"left", "middle" and "right"ldarcs>predicate; if true we would like the patch in the "right" listdarcsinput Ńdarcs"left" and "right" resultsjklmnopqrstuvwxyzrsqmopnjlkvxwytuz4None"#&',.1248=>?HIMPSUVX_k†Ž}darcs.It is natural to think of conflicting patches p and q as a parallel pair p:/:qŲ because this is how conflicting patches arise. But then Darcs comes along and merges them anyway by converting one of them to a conflictor. Thus, inside a sequence of patches we may see them as a sequential pair (p:>q'). In that case, commute+ will always succeed, as expressed by the prop_mergeCommute law. ~ is a restricted version of commuteF that should fail in this case but otherwise give the same result as commute.@Primitive patch types have no conflictors, so for them we have commute == commuteNoConflicts.)Instances should obey the following laws:SymmetryZcommuteNoConflicts (p:>q) == Just (q':>p') <=> commuteNoConflicts (q':>p') == Just (p':>q)Square-Commute (if an instance 6 p exists)fcommuteNoConflicts (p:>q) == Just (q':>p') => commuteNoConflicts (invert p:>q') == Just (q:>invert p')~ is a restriction of commute?commuteNoConflicts (p:>q) == Just r => commute (p:>q) == Just r~darcsAn alternative to commute© to be used if correctness of your code depends on the validity of the square-commute law, or to determine whether patches are in conflict. A parallel pair of patches p:/:q is conflicting if and only if commuteNoConflicts(p^:>q)/ fails. Its main use is so that we can define  cleanly.darcsThe non-conflicting merge of p:/:q tries to commute the inverse p^ of p with qA. If it succeeds then the part of the result that corresponds to p^7 is re-inverted. This is also known as a "clean merge".QNote that to maintain consistency in the presence of conflictors we must use use ~ here and not commute:. Otherwise we run into contradictions as explained below.Concretely, suppose we use commute here and that q5 is a conflictor that represents the primitive patch r- and conflicts (only) with (primitive patch) p^ . That is, q results from the conflicted merge(r:/:p^)=(s:/:q), where s* is another conflictor. Now, according to prop_mergeCommute we get commute(p^:>q)=Just(r:>s) , and thus #mergeNoConflict(p:/:q)=Just(s^:/:r)) in contradiction to our assumption that p^:/:q are in conflict i.e. mergeNoConflict(p^:/:q)Ģ fails. (This argument takes for granted that the addition of conflictors to prim patches preserves their commute behavior. This is not yet stated as a law but all implementations obviously adhere to it.)?As a side note, the fact that we now get an inverse conflictor s^„ as part of the result leads to further problems. For instance, whether our repo is conflicted now depends on the order of patches: (p:>r)$ is not conflicted, but its commute (q:>s^) obviously is. In fact, (q:>s^)B is nothing else but the (identity-preserving) "force-commute" of (p:>r), see the thread at https:/lists.osuosl.org pipermail darcs-devel2017-November/018403.html}~}~5None"#&',.1248=>?HIMPSUVX_k‰ŠŠdarcspGiven an ssh URL or file path, split it into user@host, repodir, and the file (with any _darcs/ prefix removed) €ƒ‚„…†‡ˆ‰Š‹ †‡ˆ„…‰€‚ƒ‹Š%2008 David Roundy <droundy@darcs.net>GPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_kŒA    ŒŒ    6None"#&',.1248=>?HIMPSUVX_k2darcsA drop-in replacement for q, which allows us to catch anything but a signal. Useful for situations where we don't want to inhibit ctrl-C.Ž‘’Ž’‘7None"#&',.1248=>?HIMPSUVX_k¢darcslThe firstJustM returns the first Just entry in a list of monadic operations. This is close to `listToMaybe ’ sequence`, but the sequence operator evaluates all monadic members of the list before passing it along (i.e. sequence is strict). The firstJustM is lazy in that list member monads are only evaluated up to the point where the first Just entry is obtained.—darcsļThe firstJustIO is a slight modification to firstJustM: the entries in the list must be IO monad operations and the firstJustIO will silently turn any monad call that throws an exception into Nothing, basically causing it to be ignored.›darcs,Terminate the program with an error message.œdarcsVHandle only actual IO exceptions i.e. not "user errors" e.g. those raised by calling .We use f all over the place to signify erroneous conditions and we normally don't want to handle such errors.darcsLike œ+ but restricted to returning a given value.ždarcsLike * but restricted to handling non-existence.Ÿdarcs@Handle only a those exceptions for which the predicate succeeds. •–—˜™š›œžŸ —•–˜™š›Ÿœž8None"#&',.1248=>?HIMPSUVX_kŗ“ darcs"Identifier (key) for a connection.darcscA re-usable connection to a remote darcs in transfer-mode. It contains the three standard handles. darcsExpected properties:2only ever runs once in the lifetime of the program"environment variables override alltries Putty first on Windowsfalls back to plain old ssh!darcsĖGlobal mutable variable that contains open connections, identified by the repoid part of the ssh file name. Only one thread can use a connection at a time, which is why we stuff them behind their own "s.>We distinguish between a failed connection (represented by a EĮ entry in the map) and one that was never established (the repoid is not in the map). Once a connection fails, either when trying to establish it or during usage, it will not be tried again.#darcstWait for an existing connection to become available or, if none is available, try to create a new one and cache it.$darcs~Try to create a new ssh connection to a remote darcs that runs the transfer-mode command. This is tried only once per repoid.%darcscMark any connection associated with the given ssh file path as failed, so it won't be tried again.&darcs4Show a command and its arguments for debug messages.­darcs°Return the command and arguments needed to run an ssh command First try the appropriate darcs environment variable and SSH_PORT defaulting to "ssh" and no specified port.#darcsremote darcs commanddarcs destinationdarcswrapper for the action ¢”£¤„¦§Ø©Ŗ«¬­®Æ°¤„¦§ØŖ©« ¢”£­®Æ°¬9None"#&',.1248=>?HIMPSUVX_k %"³darcs’ŗThis is a type of "sane" file paths. These are always canonic in the sense that there are no stray slashes, no ".." components and similar. They are usually used to refer to a location within a Tree, but a relative filesystem path works just as well. These are either constructed from individual name components (using "appendPath", "catPaths" and "makeName"), or converted from a FilePath ("floatPath" -- but take care when doing that).·darcs³This is for situations where a string (e.g. a command line argument) may take the value "-" to mean stdin or stdout (which one depends on context) instead of a normal file path.¹darcs€Paths which are relative to the local darcs repository and normalized. Note: These are understood not to have the dot in front.¾darcsŸFor displaying paths to the user. It should never be used for on-disk patch storage. This adds the "./" for consistency with how repo paths are displayed by  showPatchH and friends, except for the root path which is displayed as plain ".".ædarcs Interpret an ³k as relative the current working directory. Intended for IO operations in the file system. Use with care!ĄdarcsĄi translates whitespace in filenames to a darcs-specific format (numerical representation according to 'o surrounded by backslashes). Note that backslashes are also escaped since they are used in the encoding. [encodeWhite "hello there" == "hello\32\there" encodeWhite "hello\there" == "hello\92\there"ĮdarcsĮB interprets the Darcs-specific "encoded" filenames produced by Ą —decodeWhite "hello\32\there" == "hello there" decodeWhite "hello\92\there" == "hello\there" decodeWhite "hello\there" == error "malformed filename"Ādarcs7Make the second path relative to the first, if possible(darcs3Ensure directory exists and is not a symbolic link.ÅdarcsEInterpret a possibly relative path wrt the current working directory.Ędarcs’¾Take an absolute path and a string representing a (possibly relative) path and combine them into an absolute path. If the second argument is already absolute, then the first argument gets ignored. This function also takes care that the result is converted to Posix convention and normalized. Also, parent directories ("..") at the front of the string argument get canceled out against trailing directory parts of the absolute path argument.’Regarding the last point, someone more familiar with how these functions are used should verify that this is indeed necessary or at least useful.)darcseConvert to posix, remove trailing slashes, and (under Posix) reduce multiple leading slashes to one.ŹdarcscExecute either the first or the second argument action, depending on whether the given path is an ø or stdin/stdout.*darcsgNormalize the path separator to Posix style (slash, not backslash). This only affects Windows systems.+darcsHReduce multiple leading slashes to one. This only affects Posix systems.ĻdarcsWhat is a malicious path?#A spoofed path is a malicious path. =Darcs only creates explicitly relative paths (beginning with "./">), so any not explicitly relative path is surely spoofed.-Darcs normalizes paths so they never contain "/../", so paths with "/../" are surely spoofed.™A path to a darcs repository's meta data can modify "trusted" patches or change safety defaults in that repository, so we check for paths containing  "/_darcs/"' which is the entry to darcs meta data.To do?How about get repositories?’Would it be worth adding a --semi-safe-paths option for allowing changes to certain preference files (_darcs/prefs/) in sub repositories'?ņTODO: Properly review the way we handle paths on Windows - it's not enough to just use the OS native concept of path separator. Windows often accepts both path separators, and repositories always use the UNIX separator anyway.Šdarcs’Iteratively tries find first non-existing path generated by buildName, it feeds to buildName the number starting with -1. When it generates non-existing path and it isn't first, it displays the message created with buildMsg. Usually used for generation of the name like  path_ number when  path# already exist (e.g. darcs.net_0).Ńdarcs1Check whether a path is a prefix of another path.Ņdarcs'Append an element to the end of a path.Ódarcs™Catenate two paths together. Not very safe, but sometimes useful (e.g. when you are representing paths relative to a different point than a Tree root).Ōdarcs&Get parent (path) of a given path. foobarbaz -> foo/barÕdarcs%List all parents of a given path. foobarbaz -> [.,foo, foo/bar]Ödarcs’If the patch is under a directory, split into Right of the first component (which must be a directory name) and the rest of teh path. Otherwise return Left of the single component. This function is *undefined* on the root path (which has no components).×darcsATake a "root" directory and an anchored path and produce a full q. Moreover, you can use  anchorPath "" to get a relative q.ŚdarcsMake a µ from a R. If the input R4 is invalid, that is, "", ".", "..", or contains a ½ , return H with an error message.,darcsMake a µ from a R. If the input R4 is invalid, that is, "", ".", "..", or contains a ½ , call error.ŪdarcsčTake a relative FilePath and turn it into an AnchoredPath. This is a partial function. Basically, by using floatPath, you are testifying that the argument is a path relative to some common root -- i.e. the root of the associated Tree’L object. In particular, the input path may not contain any ocurrences of "." or ".." after normalising. You should sanitize any FilePaths before you declare them "good" by converting into AnchoredPath (using this function), especially if the FilePath come from any external source (command line, file, environment, network, etc)-darcs A view on ³s.Żdarcs3Replace the second arg's parent with the first arg.ŽdarcsMake a µ from a ±.ādarcs¤The effect of renaming on paths. The first argument is the old path, the second is the new path, and the third is the possibly affected path we are interested in.ćdarcsØConstruct a filter from a list of AnchoredPaths, that will accept any path that is either a parent or a child of any of the listed paths, and discard everything else.ädarcs)Transform a SubPath into an AnchoredPath.ådarcsAIs the given path in (or equal to) the _darcs metadata directory?5³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęē5ĄĮąįøĘÅ·ĒɏȶĖĢ¹ĀĆä¼½ŗ»ĶĪŠÄĻćµŲŚŽß³“ÜŅ×ŃÖāŌÕŻÓŁå¾æēęŪ:None"#&',.1248=>?@AHIMPSUVX_kećdarcsGiven  pred tree , produce a   that only has items for which pred returns True\. The tree might contain stubs. When expanded, these will be subject to filtering as well. darcsĘAbstraction of a filesystem tree. Please note that the Tree returned by the respective read operations will have TreeStub items in it. To obtain a Tree without such stubs, call expand on it, eg.: (tree <- readDarcsPristine "." >>= expandœWhen a Tree is expanded, it becomes "final". All stubs are forced and the Tree can be traversed purely. Access to actual file contents stays in IO though.°A Tree may have a Hash associated with it. A pair of Tree's is identical whenever their hashes are (the reverse need not hold, since not all Trees come equipped with a hash). darcs©Get hash of a Tree. This is guaranteed to uniquely identify the Tree (including any blob content), as far as cryptographic hashes are concerned. Sha256 is recommended.darcs)Get a hash of a TreeItem. May be Nothing.darcs Look up a  % item (an immediate subtree or blob).darcsFind a  by its path. Gives E if the path is invalid. darcsFind a  by its path. Gives E6 if the path is invalid, or does not point to a Blob.!darcsFind a   by its path. Gives E6 if the path is invalid, or does not point to a Tree."darcsList all contents of a  .#darcsLike $ but for multiple paths.$darcs>All paths in the tree that that have the given path as prefix.CexplodePath t p == Prelude.filter (p `isPrefix`) (map fst (list t))&darcsōExpand a stubbed Tree into a one with no stubs in it. You might want to filter the tree before expanding to save IO. This is the basic implementation, which may be overriden by some Tree instances (this is especially true of the Index case).'darcsäUnfold a path in a (stubbed) Tree, such that the leaf node of the path is reachable without crossing any stubs. Moreover, the leaf ought not be a Stub in the resulting Tree. A non-existent path is expanded as far as it can be.(darcsąCheck the disk version of a Tree: expands it, and checks each hash. Returns either the expanded tree or a list of AnchoredPaths where there are problems. The first argument is the hashing function used to create the tree.)darcsGiven two Trees, a guide and a tree., produces a new Tree that is a identical to tree5, but only has those items that are present in both tree and guide. The guide Tree may not contain any stubs.*darcsORead a Blob into a Lazy ByteString. Might be backed by an mmap, use with care.+darcsõFor every pair of corresponding blobs from the two supplied trees, evaluate the supplied function and accumulate the results in a list. Hint: to get IO actions through, just use sequence on the resulting list. NB. This won't expand any stubs.,darcs’'For each file in each of the two supplied trees, evaluate the supplied function (supplying the corresponding file from the other tree, or Nothing) and accumulate the results in a list. Hint: to get IO actions through, just use sequence on the resulting list. NB. This won't expand any stubs..darcs™Helper function for taking the union of AnchoredPath lists that are already sorted. This function does not check the precondition so use it carefully..darcs’¤Cautiously extracts differing subtrees from a pair of Trees. It will never do any unneccessary expanding. Tree hashes are used to cut the comparison as high up the Tree branches as possible. The result is a pair of trees that do not share any identical subtrees. They are derived from the first and second parameters respectively and they are always fully expanded. It might be advantageous to feed the result into , or -./darcs:Modify a Tree (by replacing, or removing or adding items).1darcsDoes not expand the tree.2darcsDoes not expand the tree.3darcs’»Lay one tree over another. The resulting Tree will look like the base (1st parameter) Tree, although any items also present in the overlay Tree will be taken from the overlay. It is not allowed to overlay a different kind of an object, nor it is allowed for the overlay to add new objects to base. This means that the overlay Tree should be a subset of the base Tree (although any extraneous items will be ignored by the implementation).5darcsSpecification of $2«¬­      !"#$%&'()*+,-./0123452   «¬­%&'( "  !+,-.$#*)/120345;None"#&',.1248=>?HIMPSUVX_k†! ;darcs~Change content of a file at a given path. The change will be eventually flushed to disk, but might be buffered for some time.Cdarcs=Grab content of a file in the current Tree at the given path.DdarcsBCheck for existence of a node (file or directory, doesn't matter).Edarcs#Check for existence of a directory.FdarcsCheck for existence of a file.HdarcsA G) monad. A sort of like IO but it keeps a I] around as well, which is a sort of virtual filesystem. Depending on how you obtained your Gc, the actions in your virtual filesystem get somehow reflected in the actual real filesystem. For N4, nothing happens in real filesystem, however with  plainTreeIO?, the plain tree will be updated every now and then, and with  hashedTreeIO- a darcs-style hashed tree will get updated.IdarcsInternal state of the Gr monad. Keeps track of the current Tree content, unsync'd changes and a current working directory (of the monad).Mdarcs’cRun a TreeIO action without storing any changes. This is useful for running monadic tree mutations for obtaining the resulting Tree (as opposed to their effect of writing a modified tree to disk). The actions can do both read and write -- reads are passed through to the actual filesystem, but the writes are held in memory in a form of modified Tree./darcsŹModifies an item in the current Tree. This action keeps an account of the modified data, in changed and changesize, for subsequent flush operations. Any modifications (as in "modifyTree") are allowed.Odarcs“Replace an item with a new version without modifying the content of the tree. This does not do any change tracking. Ought to be only used from a sync  implementation for a particular storage format. The presumed use-case is that an existing in-memory Blob is replaced with a one referring to an on-disk file.0darcs:If buffers are becoming large, sync, otherwise do nothing.:=?><;@ABDEFCGHIJKLMNOPQRNMC;<>?=FEDBAJIHGLKOPRQ@:<None"#&',.1248=>?HIMPSUVX_k«Vdarcsrun a list of Ws. In some monads (typically IO-based ones), the progress and error messages will be used. In others they will be ignored and just the actions will be run.Wdarcsüa monadic action, annotated with a progress message that could be printed out while running the action, and a message that could be printed out on error. Actually printing out these messages is optional to allow non-IO monads to just run the action.\darcsrun a list of Ws without any feedback messagesUVWXYZ[\UVWXYZ[\=None"#&',.1248=>?HIMPSUVX_k adarcs@Compute a darcs-compatible hash value for a tree-like structure.ddarcsCRead and parse a darcs-style hashed directory listing from a given dir and with a given hash.1darcsµRead in a darcs-style hashed tree. This is mainly useful for reading "pristine.hashed". You need to provide the root hash you are interested in (found in _darcs/hashed_inventory).gdarcs1Write a Tree into a darcs-style hashed directory.2darcsCreate a hashed file from a qź and content. In case the file exists it is kept untouched and is assumed to have the right content. XXX Corrupt files should be probably renamed out of the way automatically or something (probably when they are being read though).hdarcsRun a G action in a hashed setting. The initial1 tree is assumed to be fully available from the  directoryk, and any changes will be written out to same. Please note that actual filesystem files are never removed.hdarcsactiondarcsinitialdarcs directory ^_`abcdefgh eghdfc`a^_b>None"#&',.1248=>?HIMPSUVX_k©PmdarcsosxCacheDir assumes ~LibraryCaches/ exists.ndarcsBxdgCacheDir returns the $XDG_CACHE_HOME environment variable, or ~/.cache3 if undefined. See the FreeDesktop specification: Fhttp://standards.freedesktop.org/basedir-spec/basedir-spec-latest.htmlodarcsMgetRecursiveContents returns all files under topdir that aren't directories.pdarcs—getRecursiveContentsFullPath returns all files under topdir that aren't directories. Unlike getRecursiveContents this function returns the full path.ijklmnopjiklopnm?None"#&',.1248=>?HIMPSUVX_k¬Õrdarcs Write out fulla tree to a plain directory structure. If you instead want to make incremental updates, refer to Darcs.Util.Tree.Monad.qrqr@None"#&',.1248=>?@AHIMPSUVX_kć¾3darcs$Position of the next item, in bytes.4darcsThe item extracted.5darcsaThe fileids of the files and folders inside, in a folder item and its own fileid for file item).6darcs<Whether item has changed since the last update to the index.7darcs$Position of the next item, in bytes.8darcsoNothing in case of the item doesn't exist in the tree or is filtered by a FilterTree. Or a TreeItem otherwise.9darcsThe item extracted.:darcs[When we traverse the index, we keep track of some data about the current parent directory.;darcsOlength in bytes of current path prefix, includes the trailing path separator<darcspath of the current directory=darcs(offset of current directory in the index>darcs«Description of a a single indexed item. The structure itself does not contain any data, just pointers to the underlying mmap (bytestring is a pointer + offset + length).’gThe structure is recursive-ish (as opposed to flat-ish structure, which is used by git...) It turns out that it's hard to efficiently read a flat index with our internal data structures -- we need to turn the flat index into a recursive Tree object, which is rather expensive... As a bonus, we can also efficiently implement subtree queries this way (cf. u).?darcs¤Stored to the index to verify we are on the same endianness when reading it back. We will treat the index as invalid in this case so user code will regenerate it.@darcs’Lay out the basic index item structure in memory. The memory location is given by a ForeignPointer () and an offset. The path and type given are written out, and a corresponding Item is given back. The remaining bits of the item can be filled out using update.Adarcs=Read the on-disk representation into internal data structure.See the module-level section  Index format- for details on how the index is structured.BdarcskUpdate an existing item with new hash and optionally mtime (give Nothing when updating directory entries).CdarcsŻGives a ForeignPtr to mmapped index, which can be used for reading and updates. The req_size parameter, if non-0, expresses the requested size of the index file. mmapIndex will grow the index if it is smaller than this.DdarcsGet the µ of an > in the given :. This fails for the root > because it has no µ, so we return E.Edarcs> append a µ to an ³.FdarcsCalculate the next : when entering an >. Works for the top-level >@ i.e. the root directory only because we handle that specially.tdarcskReturn a list containing all the file/folder names in an index, with their respective ItemType and FileID.udarcsRead an index and build up a  — object from it, referring to current working directory. The initial Index object returned by readIndex is not directly useful. However, you can use óōC on it. Either way, to obtain the actual Tree object, call update.The usual use pattern is this: Hdo (idx, update) <- readIndex tree <- update =<< filter predicate idx*The resulting tree will be fully expanded.vdarcs8Will add and remove files in index to make it match the  ' object given (it is an error for the  c to contain a file or directory that does not exist in a plain form in current working directory).xdarcs‹Check that a given file is an index file with a format we can handle. You should remove and re-create the index whenever this is not true.ydarcsSFor a given file or folder path, get the corresponding fileID from the filesystem. stuvwxyz uvxwtsyzANone"#&',.1248=>?HIMPSUVX_k區‚ƒ€ƒ‚BNone"#&',.1248=>?HIMPSUVX_k…darcsfTries to perform some task if it can obtain the lock, Otherwise, just gives up without doing the task‡darcs‡K safely creates an empty file (not open for writing) and returns its name.”The temp file operations are rather similar to the locking operations, in that they both should always try to clean up, so exitWith causes trouble.ˆdarcsˆ’$ creates a temporary file, and opens it. Both of them run their argument and then delete the file. Also, both of them (to my knowledge) are not susceptible to race conditions on the temporary file (as long as you never delete the temporary file; that would reintroduce a race condition).Gdarcs’Creates a directory based on the path parameter; if a relative path is given the dir is created in the darcs temp dir. If an absolute path is given this dir will be created if it doesn't exist. If it is specified as a temporary dir, it is deleted after finishing the job.ŒdarcsŒ is like :, except that it doesn't delete the directory afterwards.darcs™ creates a temporary directory, runs the action and then removes the directory. The location of that directory is determined by the contents of _darcsprefs#tmpdir, if it exists, otherwise by  $DARCS_TMPDIRp, and if that doesn't exist then whatever your operating system considers to be a a temporary directory (e.g. $TMPDIR under Unix, $TEMP under Windows).’‚If none of those exist it creates the temporary directory in the current directory, unless the current directory is under a _darcs directory, in which case the temporary directory in the parent of the highest _darcs directory to avoid accidentally corrupting darcs's internals. This should not fail, but if it does indeed fail, we go ahead and use the current directory anyway. If $DARCS_KEEP_TMPDIRW variable is set temporary directory is not removed, this can be useful for debugging.ždarcsŚDo an action in a newly created directory of the given name. If the directory is successfully created but the action raises an exception, the directory and all its content is deleted. Caught exceptions are re-thrown.l€„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œž„…†‡ˆŒŽ–—˜“”•‘’™š›œl€‰Š‹žCNone"#&',.1248=>?HIMPSUVX_k—¤darcsfetchFile fileOrUrl cacheœ returns the content of its argument (either a file or an URL). If it has to download an url, then it will use a cache as required by its second argument.ĶWe always use default remote darcs, since it is not fatal if the remote darcs does not exist or is too old -- anything that supports transfer-mode should do, and if not, we will fall back to SFTP or SCP.„darcsfetchFileLazyPS fileOrUrl cacheÖ lazily reads the content of its argument (either a file or an URL). Warning: this function may constitute a fd leak; make sure to force consumption of file contents to avoid that. See "fetchFilePS" for details.Ÿdarcsremote darcs executabledarcs(path representing the origin file or URLdarcsdestination pathdarcs%tell whether file to copy is cachable „…†‡Ÿ ”¢£¤„¦§  ”¤„¦§Ÿ„…†‡¢£DNone"#&',.1248=>?HIMPSUVX_k9ØdarcseRepresentation of the format of a repository. Each sublist corresponds to a line in the format file.HdarcsHDefine string constants in one place, for reuse in show/parse functions.IdarcsHDefine string constants in one place, for reuse in show/parse functions.JdarcsHDefine string constants in one place, for reuse in show/parse functions.KdarcsHDefine string constants in one place, for reuse in show/parse functions.LdarcsHDefine string constants in one place, for reuse in show/parse functions.MdarcsHDefine string constants in one place, for reuse in show/parse functions.NdarcsHDefine string constants in one place, for reuse in show/parse functions.OdarcsHDefine string constants in one place, for reuse in show/parse functions.³darcs4Is a given property contained within a given format?“darcs,Add a single property to an existing format.µdarcs1Remove a single property from an existing format.¶darcsIdentify the format of the repository at the given location (directory, URL, or SSH path). Fails if we weren't able to identify the format.·darcsdIdentify the format of the repository at the given location (directory, URL, or SSH path). Return H reason if it fails, where reason{ explains why we weren't able to identify the format. Note that we do no verification of the format, which is handled by ¼ or ŗ on the resulting Ø.ødarcs(Write the repo format to the given file.¹darcszCreate a repo format. The first argument specifies the patch format; the second says whether the repo has a working tree.ŗdarcsŗ source returns F: an error message if we cannot write to a repo in format source, or E if there's no such problem.»darcs» source target returns FG an error message if we cannot transfer patches from a repo in format source to a repo in format target, or E if there are no such problem.¼darcs¼ source returns F; an error message if we cannot read from a repo in format source, or E if there's no such problem.PdarcsP{ applies a function that maps format-entries to an optional error message, to each repoformat entry. Returning any errors.Qdarcs<Does this version of darcs know how to handle this property?Ø©Ŗ®¬­°±Æ«²³“µ¶·ø¹ŗ»¼Ø©Ŗ®¬­°±Æ«²¶·¹øŗ¼»³“µENone"#&',.1248=>?HIMPSUVX_k„rĄdarcsCCache is an abstract type for hiding the underlying cache locationsÕdarcsiunionRemoteCaches merges caches. It tries to do better than just blindly copying remote cache entries:ģIf remote repository is accessed through network, do not copy any cache entries from it. Taking local entries does not make sense and using network entries can lead to darcs hang when it tries to get to unaccessible host.óIf remote repository is local, copy all network cache entries. For local cache entries if the cache directory exists and is writable it is added as writable cache, if it exists but is not writable it is added as read-only cache.½This approach should save us from bogus cache entries. One case it does not work very well is when you fetch from partial repository over network. Hopefully this is not a common case.Rdarcs}Compares two caches, a remote cache is greater than a local one. The order of the comparison is given by: local < http < ssh×darcs×< computes the cache hash (i.e. filename) of a packed string.Łdarcs"fetchFileUsingCache cache dir hash receives a list of caches cache-, the directory for which that file belongs dir and the hash½ of the file to fetch. It tries to fetch the file from one of the sources, trying them in order one by one. If the file cannot be fetched from any of the sources, this operation fails.ŪdarcsThis keeps only Ē Ė entries.ßdarcs(hashedFilePath cachelocation subdir hash( returns the physical filename of hash hash in the subdir section of  cachelocation.Sdarcs0hashedFilePathReadOnly cachelocation subdir hash( returns the physical filename of hash hash in the subdir section of  cachelocationF. If directory, assume it is non-bucketed cache (old cache location).ądarcspeekInCache cache subdir hash tells whether cache# and contains an object with hash hashS in a writable position. Florent: why do we want it to be in a writable position?įdarcs/speculateFileUsingCache cache subdirectory name takes note that the file namev is likely to be useful soon: pipelined downloads will add it to the (low-priority) queue, for the rest it is a noop.ādarcsŒNote that the files are likely to be useful soon: pipelined downloads will add them to the (low-priority) queue, for the rest it is a noop.TdarcsWe hace a list of locations (cachez) ordered from "closest/fastest" (typically, the destination repo) to "farthest/slowest" (typically, the source repo). copyFileUsingCache! first checks whether given file fŗ is present in some writeable location, if yes, do nothing. If no, it copies it to the last writeable location, which would be the global cache by default, or the destination repo if  `--no-cache`Ć is passed. Function does nothing if there is no writeable location at all. If the copy should occur between two locations of the same filesystem, a hard link is actually made. TODO document oos&: what happens when we only speculate?Udarcs’lChecks if a given cache entry is reachable or not. It receives an error caught during execution and the cache entry. If the caches is not reachable it is blacklisted and not longer tried for the rest of the session. If it is reachable it is whitelisted and future errors with such cache get ignore. To determine reachability: * For a local cache, if the given source doesn't exist anymore, it is blacklisted. * For remote sources if the error is timeout, it is blacklisted, if not, it checks if _darcs/hashed_inventory exist, if it does, the entry is whitelisted, if it doesn't, it is blacklisted.VdarcsIReturns a list of reachables cache entries, removing blacklisted entries.Wdarcs<Checks if the _darcs/hashed_inventory exist and is reachableXdarcseGet contents of some hashed file taking advantage of the cache system. We have a list of locations (cache’4) ordered from "closest/fastest" (typically, the destination repo) to "farthest/slowest" (typically, the source repo). First, if possible it copies the file from remote location to local. Then, it reads it contents, and links the file across all writeable locations including the destination repository.Ydarcs"write compression filename content writes content to the file filename" according to the policy given by  compression.ćdarcs5writeFileUsingCache cache compression subdir contents write the string contents’ to the directory subdir, except if it is already in the cache, in which case it is a noop. Warning (?) this means that in case of a hash collision, writing using writeFileUsingCache is a noop. The returned value is the filename that was given to the string.ędarcs2Prints an error message with a list of bad caches.'ĄĮĀĆÄÅĘČĒÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåę'×ŲĄŅÓĘČĒĮĀĆÄÅÉŹĖĢĶĪĻŠŽŌÕäåŁįāćąÖŚŻßŃęÜŪFNone"#&',.1248=>?HIMPSUVX_kˆOšdarcsThe šZ type is a list of all flags that can ever be passed to darcs, or to one of its commands.Åš©żt&ńhuŒsrd<)÷@“Ŗl—„€”†ƒOk+375ś„ōP>Dac³’,486ū‚Q_ņóõöųłüž      !"#$%'(*-./0129:;=?ABCEFGHIJKLMNRSTUVWXYZ[\]^`befgijmnopqvwxyz{|}~…‡ˆ‰Š‹Ž‘’”•–˜™š›œžŸ ¢£¤¦§Ø«¬­®Æ°±²“Åš©żt&ńhuŒsrd<)÷@“Ŗl—„€”†ƒOk+375ś„ōP>Dac³’,486ū‚Q_ņóõöųłüž      !"#$%'(*-./0129:;=?ABCEFGHIJKLMNRSTUVWXYZ[\]^`befgijmnopqvwxyz{|}~…‡ˆ‰Š‹Ž‘’”•–˜™š›œžŸ ¢£¤¦§Ø«¬­®Æ°±²“GNone"#&',.1248=>?HIMPSUVX_k¾·darcs@The raw material from which multi-valued options are built. See Ę.ZdarcsA ¾) that requires a single argument of type a and handles flags of type f.½darcsThis is U instantiated with ¾ and æ.¾darcsWe do not instantiate the d in V d f directly with [%. Instead we (post-) compose it with (->) õö+. Modulo newtype noise, this is the same as  type ¾ f = [ (ø -> f)This is so we can pass a directory relative to which an option argument is interpreted (if it has the form of a relative path).ædarcsqThis type synonym is here for brevity and because we want to import the data constructors (but not the type) of š qualified.Ądarcs Construct a ¾ with no arguments.Įdarcs Construct a ¾ with a R argument.Ādarcs Construct a ¾ with an optional R argument.Ćdarcs Construct a ¾ with an ø argument.Ädarcs Construct a ¾ with an · argument.Ådarcs Construct a ¾ with an optional ø argument.\darcsNGet the long switch names from a raw option. Used to construct error messages.]darcsGiven a list of ·*, find all flags that match a given value.^darcsGiven a list of ·c, find all values that match a given flag list in the order in which they appear in the flag list._darcs?The first element of a list, or a default if the list is empty.`darcsLAppend " [DEFAULT" to the help text of options that match the default value.Ędarcs Construct a ½$ from a default value and a list of ·.HPrecondition: the list must have an entry for each possible value (type v).Ēdarcs Construct a 8S valued option with a single flag that takes no arguments and has no default flag.JThe arguments are: short switches, long switches, flag value, help string.Čdarcs Construct a > R0 valued option with a single flag that takes a R" argument and has no default flag.eThe arguments are: short switches, long switches, flag constructor, single flag parser, help string.Édarcs Construct a > ø1 valued option with a single flag that takes an ø" argument and has no default flag.eThe arguments are: short switches, long switches, flag constructor, single flag parser, help string.Źdarcs Similar to Čc, except that the flag can be given more than once. The flag arguments are collected in a list of Rs.Ėdarcs Similar to Ź., except that the flag arguments are optional.Ģdarcs Similar to Éc, except that the flag can be given more than once. The flag arguments are collected in a list of øs.adarcs^A multi-arg option, defined in terms of a single-arg option, returning a list of single args.’The parameters are: single argument description, short switches, long switches, flag constructor, flag list parser, arg name string, help string.ĶdarcseA deprecated option. If you want to deprecate only some flags and not the whole option, extract the ·Ģs out of the original option and create a new deprecated option. The strings in the first argument are appended to the automatically generated error message in case additional hints should be provided.·øĘĒ·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃæ¾½ĄĮĀĆÄÅ·ø¹ŗ»¼ĘĒČŹĖÉĢĶĪĻŠŃø·ĘĒHNone"#&',.1248=>?HIMPSUVX_kĄ ÖÖINone"#&',.1248=>?HIMPSUVX_kĮ×ŲŁŚŲŁŚ×JNone"#&',.1248=>?HIMPSUVX_kŲe ßdarcs-The path of the global preference directory; ~/.darcs on Unix, and %APPDATA%/darcs on Windows.ądarcs6The relative path of the global preference directory; ~/.darcs on Unix, and %APPDATA%/darcs3 on Windows. This is used for online documentation.bdarcs¢tryMakeBoringRegexp attempts to create a Regex from a given String. The evaluation is forced, to ensure any malformed exceptions are thrown here, and not later.ädarcsŌboringRegexps returns a list of the boring regexps, from the local and global prefs/boring files. Any invalid regexps are filtered, preventing an exception in (potentially) pure code, when the regexps are used.cdarcs%The lines that will be inserted into _darcsprefsbinaries when  darcs initX is run. Hence, a list of comments, blank lines and regular expressions (ERE dialect).hNote that while this matches .gz and .GZ, it will not match .gZ, i.e. it is not truly case insensitive.ńdarcs(addRepoSource adds a new entry to _darcsprefs)repos and sets it as default in _darcsprefspdefaultrepo, unless --no-set-default or --dry-run is passed, or it is the same repository as the current one.ņdarcsˆdelete references to other repositories. Used when cloning to a ssh destination. Assume the current working dir is the repository.ōdarcs?Fetch and return the message of the day for a given repository.õdarcs6Display the message of the day for a given repository,ŪŻÜŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłčņéźāįļšńģķīėŽäåŪŻÜēóćąßōõö÷ųęłKNone"#&',.1248=>?HIMPSUVX_kŚc ūüżž’ ’ūüżžLNone"#&',.1248=>?HIMPSUVX_kÜŽdarcs#An object is located by giving the  of the parent  and a µ.µ          µMNone"#&',.1248=>?HIMPSUVX_kŽl  NNone"#&',.1248=>?HIMPSUVX_k+[#darcsSee module documentation for Darcs.Patch.Choices.'darcsA sequence of (es where each patch is either $, %, or &€. The representation is optimized for the case where we start chosing patches from the left of the sequence: patches that are $= are commuted to the head immediately, but patches that are % or &- are mixed together; when a patch is marked &G, its dependencies are not updated until we retrieve the final result.ddarcsThis internal type tags a ( with a 8, to distinguish % from & patches.edarcsthe ( in questionfdarcsD = %, G = &(darcsA patch with a ) attached to it.)darcs) mp iū acts as a temporary identifier to help us keep track of patches during the selection process. These are useful for finding patches that may have moved around during patch selection (being pushed forwards or backwards as dependencies arise).)The identifier is implemented as a tuple  Label mp i. The iW is an integer, expected to be unique within the patches being scrutinised. The mp® is motivated by patch splitting; it provides a convenient way to generate a new identifier from the patch being split. For example, if we split a patch identified as Label Nothing 56, the resulting sub-patches could be identified as Label (Just (Label Nothing 5))1,  Label (Just (Label Nothing 5)) 2, etc.IOW, )" is a non-empty, reversed list of <s.gdarcsInternal function to tag a ( as % or &.-darcs Create a '@ from a sequence of patches, so that all patches are initially %..darcs@Label a sequence of patches, maybe using the given parent label./darcs Create a 'R from an already labelled sequence of patches, so that all patches are initially %.0darcsLike 2 but lumps together % and &- patches. This is more efficient than using 2 and then catenating % and &: sections because we have to commute less. (This is what ' are optimized for.)IseparateFirstFromMiddleLast c == case getChoices c of f:>m:>l -> f:>m+>+l1darcsLike 2 but lumps together $ and % patches.IseparateFirstMiddleFromLast c == case getChoices c of f:>m:>l -> f+>+m:>l2darcs'Retrieve the resulting sections from a d. The result is a triple first:>middle:>last, such that all patches in first are $, all patches in middle are %, and all patches in last are &.hdarcs3Internal function to commute patches in the common i segment so that all & patches are behind % ones. Patches % that depend on any & are promoted to &.3darcsUse the given monadic ' transformer on the % section of a '., then fold the result back into the original '.4darcsGiven a (* determine to which section of the given 'F it belongs. This is not trivial to compute, since a patch tagged as % may be forced to actually be &3 by dependencies. We return a possibly re-ordered ', so as not to waste the commutation effort.5darcs5Force all patches matching the given predicate to be $^, pulling any dependencies with them. This even forces any patches that were already tagged &.6darcs>Force all patches labelled with one of the given labels to be $^, pulling any dependencies with them. This even forces any patches that were already tagged &.7darcs9Force a single patch labelled with the given label to be $^, pulling any dependencies with them. This even forces any patches that were already tagged &.8darcs Make all % patches either $ or &H. This does *not* modify any patches that are already determined to be & by dependencies.9darcs Similar to 5% only that patches are forced to be &% regardless of their previous status.jdarcsBInternal function working directly on the constituent parts of a ' and taking an accumulating Ń to build up a new $$ section. It forces patches to be % or &, depending on the 8 parameter (G means &, D means %l). It does this regardless of the previous status of patches and also pulls any dependent patches with it.:darcs>Force all patches labelled with one of the given labels to be &a, pulling any dependencies with them. This even forces any patches that were previously tagged $.;darcs9Force a single patch labelled with the given label to be &K, pulling any dependencies with them, regardless of their previous status.<darcsForce a patch with the given ) to be %I, pulling any dependencies with it, regardless of their previous status.=darcsTurn $ patches into % ones and % into & ones.>darcsTurn % patches into $ and & patches into %%. Does *not* pull dependencies into $0, instead patches that cannot be commuted past & patches stay %.?darcsSubstitute a single (? with an equivalent list of patches, preserving its status as $, % or &-). The patch is looked up using equality of )s.jdarcsaccumulator for $ patchesdarcs original $ sectiondarcs original % and & section#$%&'()*+,-./0123456789:;<=>?'#$%&-/42105679:;<>=83?()*,.+ONone"#&',.1248=>?HIMPSUVX_k7-Fdarcs&This is used to track changes to filesLdarcs‰This is an invalid patch e.g. there is a patch 'Move Autoconf.lhs Autoconf.lhs.in' where there is no Autoconf.lhs in the darcs repoMdarcslthis is used for duplicate patches that don't have any effect, but we still want to keep track of themNdarcsUThe PatchId identifies a patch and can be created from a PatchInfo with makePatchnameQdarcsÄThe FileId for a file consists of the FilePath (creation name) and an index. The index denotes how many files with the same name have been added before (and subsequently deleted or moved)UdarcsConvert FileId to stringFMLKJIHGNOPQRSTUVWXQRSTUNOPVFMLKJIHGWXPNone"#&',.1248=>?@AHIMPSUVX_kB3kdarcs’-trackOrigRename takes an old and new name and attempts to apply the mapping to the OrigFileNameOf pair. If the old name is the most up-to-date name of the file in question, the first element of the OFNO will match, otherwise if the up-to-date name was originally old, the second element will match.{darcs’withFileNames takes a maybe list of existing rename-pairs, a list of filenames and an action, and returns the resulting triple of affected files, updated filename list and new rename details. If the rename-pairs are not present, a new list is generated from the filesnames.dehfgijklmnorpqstuvwxyz{|dehfgvwxtu{|yzijklmnorpqsQ2002-2005 David RoundyGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_kGŠŽdarcsApply a patch to a  , yielding a new  .darcsxAttempts to apply a given patch to a Tree. If the apply fails, we return Nothing, otherwise we return the updated Tree. ˆ‰Š‹ŒŽ ˆ‰Š‹ŽŒRNone"#&',.1248=>?HIMPSUVX_kI“”•––•“”SNone"#&',.1248=>?HIMPSUVX_kZ¾—darcs`This class is used only for user interaction, not for storage. The default implementations for ™ and ˜ are suitable only for  PrimPatch and  RepoPatch types. Logically, ™ should default to  while ˜ should default to „/. We define them the other way around so that ”÷/ gives reasonable results for all patch types.Ÿdarcs’showContextPatch is used to add context to a patch, as diff -u does. Thus, it differs from showPatch only for hunks. It is used for instance before putting it into a bundle. As this unified context is not included in patch representation, this requires access to the tree.¦darcs Format a ³ to a   according to the given A.“NOTE: This is not only used for display but also to format patch files. This is why we have to do the white space encoding here. See ¤ų."Besides white space encoding, for C we just pack it into a  . For B we must emulate the non-standard darcs-1 encoding of file paths: it is an UTF8 encoding of the raw byte stream, interpreted as code points. See also Sł.—˜™œš›žŸ ”¢¤£„¦ ”„¢¤£—˜™œš›žŸ¦TNone"#&',.1248=>?HIMPSUVX_k÷§darcsėA PatchInfo value contains the metadata of a patch. The date, name, author and log fields are UTF-8 encoded text in darcs 2.4 and later, and just sequences of bytes (decoded with whatever is the locale when displayed) in earlier darcs.'The members with names that start with '_'^ are not supposed to be used directly in code that does not care how the patch info is stored._piLegacyIsInverted:Historically, the  isInverted; flag was used to indicate that a Named patch was inverted.)We no longer support direct inversion of ~ś# patches, except sometimes via the ū/ wrapper which tracks inversion in the wrapper.SHowever, going even further back in time, inverted patches could be written out by darcs rollbackÓ. This was changed in 2008 so any patches on disk with this flag set would have been written by a darcs from prior to then. As they still exist, including in the darcs repository itself, we need to support them.YAs far as current darcs is concerned, the flag should be treated like any other field in §$ apart from never being set freshly:,There is no semantic relationship between a § with piLegacyIsInverted = False and the same § with piLegacyIsInverted = True5. For example they are not inverses of each other.:New or amended patches should never be written out with _piLegacyIsInverted = True.wWe do need to maintain backwards compatibility so we take care to preserve things like the hash, on-disk format etc. A patch with _piLegacyIsInverted = True4 should work with all the normal darcs operations.\The flag is completely separate and orthogonal to the tracking of explicit inversion in the ū wrapper. The ūÕ wrapper is only used in memory and never stored to disk so there should be no confusion when reading a patch from disk. Within the codebase they serve completely different purposes and should not interact at all.­darcs:See the long description of this field in the docs above.ldarcs:The isAscii limitation is due to the use of BC.pack below.µdarcspatchinfo date name author log constructs a new §© value with the given details, automatically assigning an Ignore-this header to guarantee the patch is unique. The function does not verify the date string's sanity.¶darcsNaddJunk adds a line that contains a random number to make the patch unique.ødarcsTGet the name, including an "UNDO: " prefix if the patch is a legacy inverted patch.¹darcsReturns the author of a patch.¼darcs&Returns the name of the patch. Unlike ø], it does not preprend "UNDO: " to the name if the patch has the legacy inverted flag set.¾darcsReturns the author of a patch.mdarcsüRead the date from raw patch (meta) data and convert it to UTC. The raw data may contain timezone info. This is for compatibiltity with patches that were created before 2003-11, when darcs still created patches that contained localized date strings.ĀdarcsGet the log message of a patch.Ćdarcs.Get the tag name, if the patch is a tag patch.ndarcs’Convert a metadata ByteString to a string. It first tries to convert using UTF-8, and if that fails, tries the locale encoding. We try UTF-8 first because UTF-8 is clearly recognizable, widely used, and people may have UTF-8 patches even when UTF-8 is not their locale.ĒdarcsäHash on patch metadata (patch name, author, date, log, and the legacy "inverted" flag. Robust against context changes but does not guarantee patch contents. Usually used as matcher or patch identifier (see Darcs.Patch.Match).odarcs(Patch is stored between square brackets. Ņ[ <patch name> <patch author>*<patch date> <patch log (may be empty)> (indented one) <can have multiple lines in patch log,> <as long as they're preceded by a space> <and don't end with a square bracket.> ]=note that below I assume the name has no newline in it. See ÉX for the inverse operation. There are more assumptions, see validation functions above.Édarcs Parser for §> as stored in patch bundles and inventory files, for example: «[Document the foo interface John Doe <john.doe@example.com>**20110615084241 Ignore-this: 85b94f67d377c4ab671101266ef9c229 Nobody knows what a 'foo' is, so describe it. ]See Č for the inverse operation.#§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉ#§Ø©Ŗ«¬­“µ¶·ĒÉø¹ŗ»ÄÅĄĮ¼½¾ĆĀČæĘ®°²Æ±³UNone"#&',.1248=>?HIMPSUVX_k¢Īądarcs:Replace the pristine hash at the start of a raw, unparsed Ņ or add it if none is present.ādarcsDskipPristineHash drops the 'pristine: HASH' prefix line, if present.ĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęĪĻŠŃŅĶÖ×ŲÕŌÓŁÜŪŻŽßŚąįāćäåęVNone"#&',.1248=>?@AHIMPSUVX_k±ŠpdarcsreadHashFile c subdir hash reads the file with hash hash" in dir subdir, fetching it from Ą cR if needed. The return value is a pair of the absolute file path and the content.qdarcs3This is withCurrentDirectory for read-only actions.rdarcsgeta objtype name direntries! tries to find an object of type objtype named name in  direntries.ņdarcsZGrab a whole pristine tree from a hash, and, if asked, write files in the working tree.ódarcsgReturns a list of pairs (FilePath, (strict) ByteString) of the pristine tree starting with the hash root. path‹ should be either "." or end with "/" Separator "/" is used since this function is used to generate zip archives from pristine trees.ödarcs_getHashedFiles returns all hash files targeted by files in hashroots in the hashdir directory.ņóōõöņōõöóWNone"#&',.1248=>?HIMPSUVX_kōż śdarcs3Faster equality tests for patches with an identity.żdarcsStorable identities.pThe methods here can be used to help implement ReadPatch and ShowPatch for a patch type containing the identity.:As with all Read/Show pairs, We expect that the output of showId ForStorage a can be parsed by ž to produce a.darcs{Constraint for patches that have an identity that is signed, i.e. can be positive (uninverted) or negative (inverted).Provided that an instance Invert0 exists, inverting a patch inverts its identity:%ident (invert p) = invertId (ident p)darcsSigned identities.Like for class Invert, we require that  is self-inverse:invertId . invertId = id0We also require that inverting changes the sign:(positiveId . invertId = not . positiveIdVSide remark: in mathematical terms, these properties can be expressed by stating that  is an involution and that Z is a "homomorphism of sets with an involution" (there is no official term for this) from a9 to the simplest non-trivial set with involution, namely 8 with the involution .darcs'Class of patches that have an identity.wIt generalizes named prim patches a la camp (see Darcs.Patch.Prim.Named) and Named patches i.e. those with a PatchInfo.JPatch identity should be invariant under commutation: if there is also an  instance P p, thenQcommute (p :> q) == Just (q' :> p') => ident p == ident p' && ident q == ident q'ŒThe converse should also be true: patches with the same identity can be commuted (back) to the same context and then compare equal. Assuming / p :: p wX wY, (ps :> q) :: (RL p :> p) wX wZ then:ident p == ident q => commuteRL (ps :> q) == Just (p :> _)TAs a special case we get that parallel patches with the same identity are equal: if p :: p wX wY, q :: p wX wZ, then&ident p == ident q => p =\/= q == IsEqgIn general, comparing patches via their identity is coarser than (structural) equality, so we only have)unsafeCompare p q => (ident p == ident q)darcsThis function is similar to merge&, but with one important difference: merge’s works on patches for which there is not necessarily a concept of identity (e.g. primitive patches, conflictors, etc). Thus it does not even try to recognize patches that are common to both sequences. Instead these are passed on to the Merge instance for single patches. This instance may handle duplicate patches by creating special patches (Duplicate, Conflictor).sWe do not want this to happen for named patches, or in general for patches with an identity. Instead, we want to discardŚ one of the two duplicates, retaining only one copy. This is done by the fastRemoveFL calls below. We call mergeFL only after we have ensured that the head of the left hand side does not occur in the right hand side.darcsFRemove a patch from an FL of patches with an identity. The result is F3 whenever the patch has been found and removed and E otherwise. If the patch is not found at the head of the sequence we must first commute it to the head before we can remove it.’GWe assume that this commute always succeeds. This is justified because patches are created with a (universally) unique identity, implying that if two patches have the same identity, then they have originally been the same patch; thus being at a different position must be due to commutation, meaning we can commute it back. darcsSame as  only for Ń. darcsĒFind the common and uncommon parts of two lists that start in a common context, using patch identity for comparison. Of the common patches, only one is retained, the other is discarded, similar to . darcs+Try to commute patches matching any of the  s in the set to the head of an Ō>, i.e. backwards in history. It is not required that all the ks are found in the sequence, but if they do then the traversal terminates as soon as the set is exhausted. darcs+Try to commute patches matching any of the  s in the set to the head of an Ń=, i.e. forwards in history. It is not required that all the ks are found in the sequence, but if they do then the traversal terminates as soon as the set is exhausted.darcsLike   but drag dependencies with us.darcsThe PG requirement here is not technically needed but makes sense logically.śūüżž’     żž’śūü     XNone"#&',.1248=>?HIMPSUVX_köĆYNone"#&',.1248=>?HIMPSUVX_k÷ńZNone"#&',.1248=>?HIMPSUVX_k’!!darcs’€This type exists for legacy support of on-disk format patch formats. It is a wrapper type that explicitly tracks the nesting of braces and parens in the on-disk representation of such patches. It is used as an intermediate form when reading such patches normally, and also for round-tripping such patches when checking the hash in bundles. It shouldn't be used for anything else.  !"#$%&'( !"#$'% (&[None"#&',.1248=>?HIMPSUVX_k„+darcsFThis class is used to decode patches from their binary representation.+,-./01+,.-/01\None"#%&',.1248=>?HIMPSUVX_kĀ6darcsRThis property states that no prefix of the context commutes with the rest of the 5D patch and that the context never contains a patch and its inverse.sdarcs`This property states that the first patch in the context must not commute with the rest of the 5 patch.7darcs6This property states that patches in the context of a 5: patch as well as the patch itself are positive. It does not necessarily hold for all 5 patches.tdarcsuThis property states that the inverse of the first patch in the context is not contained in the rest of the context.9darcsIdentity of a contexted patch.:darcs5z patches conflict with each other if the identity of one is in the context of the other or they cannot be merged cleanly.;darcs(We sometimes want to pattern match on a 5l patch but still guard against violation of teh invariants. So we export a view that is isomorphic to the 54 type but doesn't allow to manipulate the internals.<darcs Convert a 5 patch into a plain Ō with the patch at the end.=darcsA 5 patch with empty context.>darcs Add a patch to the context of a 5@ patch. This is the place where we take care of the invariants.?darcsAdd an Ń of patches to the context.@darcsAdd an Ō/ of patches to the context but invert it first.AdarcsAdd an Ō of patches to the context.Bdarcs)(Definition 10.2) Commute a patch past a 5Ÿ patch. This commutes it past the context and then past the patch itself. If it succeeds, the patch that we commuted past gets dropped. Note that this does not* succeed if the inverted patch is in the 5 patch.Cdarcs;Not defined in the paper but used in the commute algorithm.KdarcsEquality between 5L patches reduces to equality of the identifiers of the patches referred to ife we look at them from the same context. (This assumes witnesses aren't coerced in an unsafe manner.)56789:;<=>?@ABCDEFG59;:<=>?@ABCDEFG687]None"#&',.1248=>?HIMPSUVX_k( LdarcsLĄ is implemented by single patches that can be repaired (Prim, Patch, RepoPatchV2) There is a default so that patch types with no current legacy problems don't need to have an implementation.NdarcsN and Lp deal with repairing old patches that were were written out due to bugs or that we no longer wish to support. N_ is implemented by collections of patches (FL, Named, PatchInfoAnd) that might need repairing.LMNOPQRNOLMRPQ^None"#&',.1248=>?HIMPSUVX_kNģ Wdarcs,Mangle conflicting alternatives if possible.Xdarcs'Result of mangling a single Unravelled.YdarcsxA list of conflicting alternatives. They form a connected component of the conflict graph i.e. one transitive conflict.ddarcssiftForPending ps( simplifies the candidate pending patch psŹ through a combination of looking for self-cancellations (sequences of patches followed by their inverses), coalescing, and getting rid of any hunk/binary patches we can commute out the back’ The visual image of sifting can be quite helpful here. We are repeatedly tapping (shrinking) the patch sequence and shaking it (sift). Whatever falls out is the pending we want to keep. We do this until the sequence looks about as clean as we can get itfdarcstryToShrink ps simplifies ps> by getting rid of self-cancellations or coalescing patchesŃQuestion (Eric Kow): what properties should this have? For example, the prim1 implementation only gets rid of the first self-cancellation it finds (as far as I can tell). Is that OK? Can we try harder?gdarcsg ps coalesces as many patches in ps< as possible, sorting the results in some standard order.hdarcs£It can sometimes be handy to have a canonical representation of a given patch. We achieve this by defining a canonical form for each patch type, and a function hŪ which takes a patch and puts it into canonical form. This routine is used by the diff function to create an optimal patch (based on an LCS algorithm) from a simple hunk describing the old and new version of a file.idarcsi psņ puts a sequence of primitive patches into canonical form. Even if the patches are just hunk patches, this is not necessarily the same set of results as you would get if you applied the sequence to a specific tree and recalculated a diff.ŃNote that this process does not preserve the commutation behaviour of the patches and is therefore not appropriate for use when working with already recorded patches (unless doing amend-record or the like).jdarcsEither k or cancel inverses.?primCoalesce (p :> q) == Just r => apply r = apply p >> apply q1primCoalesce (p :> q) == Just r => lengthFL r < 2kdarcs6Coalesce adjacent patches to one with the same effect..apply (primCoalesce p q) == apply p >> apply qldarcsIf k' is addition, then this is subtraction.:Just r == primCoalesce p q => primDecoalesce r p == Just q/VWXYZ[\]^_`abcdehgfiljkmvronqptuswxy~€{‚z|}ƒ„/mvronqptuswehgfiljkxy~€{‚z|}abcd^_`\]Z[ƒVWXY„_None"#&',.1248=>?HIMPSUVX_kU”darcs” p1 p25 is used to provide an arbitrary ordering between p1 and p21. Basically, identical patches are equal and Move < DP < FP < ChangePrefF. Everything else is compared in dictionary order of its arguments.…†‡ˆ‹‰ŠŒŽ‘’“”Ž‘’…†‡ˆ‹‰ŠŒ“”`None"#&',.1248=>?HIMPSUVX_kWęudarcsModify a binary file ;binary FILENAME oldhex *HEXHEXHEX ... newhex *HEXHEXHEX ...aNone"#%&',.1248=>?HIMPSUVX_k]āvdarcs1The state of a single file as far as we know it. E7 means we don't know the content of a particular line.wdarcs$An infinite list of undefined lines.xdarcs Note that (applyHunk p . applyHunk (invert p) /= id : it converts undefined lines (E) to defined ones (F the old content of p).ydarcsIterate x.bNone"#&',.1248=>?HIMPSUVX_k^čcNone"#%&',.1248=>?HIMPSUVX_k_öØØdNone"#&',.1248=>?HIMPSUVX_ka Æ°±²³“µ¶·ø °±²³“ƶµ·øeNone"#&',.1248=>?HIMPSUVX_k{^zdarcs shrinkABit ps tries to simplify psI by one patch, the first one we find that coalesces with its neighbour{darcstryOne acc p ps pushes p as far down psh as we can go until we can either coalesce it with something or it can't go any further. Returns Just2 if we manage to get any coalescing out of this|darcsThe heart of "sortCoalesceFL"}darcs} new ps is almost like  new :>: psB except as an alternative to consing, we first try to coalesce new with the head of ps=. If this fails, we try again, using commutation to push new9 down the list until we find a place where either (a) new is LT the next member of the list  bsee 'comparePrim'u commutation fails or (c) coalescing succeeds. The basic principle is to coalesce if we can and cons otherwise.’As an additional optimization, pushCoalescePatch outputs a Left value if it wasn't able to shrink the patch sequence at all, and a Right value if it was indeed able to shrink the patch sequence. This avoids the O(N) calls to lengthFL that were in the older code.†Also note that pushCoalescePatch is only ever used (and should only ever be used) as an internal function in in sortCoalesceFL2.~darcs~ p1 p2 tries to combine p1 and p2’ into a single patch. For example, two hunk patches modifying adjacent lines can be coalesced into a bigger hunk patch. Or a patch which moves file A to file B can be coalesced with a patch that moves file B into file C, yielding a patch that moves file A to file C.darcsIf ~* is "addition" then this is "subtraction".fNone"#&',.1248=>?HIMPSUVX_k|dgNone"#&',.1248=>?HIMPSUVX_k}jŽŽhNone"#&',.1248=>?HIMPSUVX_k~xµĘĖĒČÉŹĢĶĪĻĘĖĒČÉŹĪĻĢĶµiNone"#%&',.1248=>?HIMPSUVX_k€&jNone"#&',.1248=>?HIMPSUVX_k,kNone"#&',.1248=>?HIMPSUVX_k‚2lNone"#&',.1248=>?HIMPSUVX_kƒ8üNone"#&',.1248=>?HIMPSUVX_k„>.VWXYZ[\]^_`abcdehgfiljkmvronqptuswxy~€{‚z|}ƒ.Z[ehgfiljkxy~€{‚z|}mvronqptuswabVWƒ\]^_`cdXYmNone"#%&',.1248=>?HIMPSUVX_k„édarcs’€A splitter is something that can take a patch and (possibly) render it as text in some format of its own choosing. This text can then be presented to the user for editing, and the result given to the splitter for parsing. If the parse succeeds, the result is a list of patches that could replace the original patch in any context. Typically this list will contain the changed version of the patch, along with fixup pieces to ensure that the overall effect of the list is the same as the original patch. The individual elements of the list can then be offered separately to the user, allowing them to accept some and reject others.’There's no immediate application for a splitter for anything other than Prim (you shouldn't go editing named patches, you'll break them!) However you might want to compose splitters for FilePatchType to make splitters for Prim etc, and the generality doesn't cost anything.ķdarcs’This generic splitter just lets the user edit the printed representation of the patch. Should not be used expect for testing and experimentation.īdarcsŻNever splits. In other code we normally pass around Maybe Splitter instead of using this as the default, because it saves clients that don't care about splitting from having to import this module just to get noSplitter.ļdarcsŽSplit a primitive hunk patch up by allowing the user to edit both the before and after lines, then insert fixup patches to clean up the mess.éźėģķīļšéźėģķīļšnNone"#&',.1248=>?HIMPSUVX_kžŹ ńņóōõö÷ųł ųłōõö÷ņóńoNone"#&',.1248=>?HIMPSUVX_k£yüdarcsThe format of a merger is ,Merger undos unwindings conflicting original.undos = the effect of the merger unwindings = TODO: eh? conflicting = the patch we conflict withoriginal = the patch we really areüżž’ üżž’ pNone"#&',.1248=>?HIMPSUVX_k¤Æ  qNone"#&',.1248=>?HIMPSUVX_kŗ darcsšGet hold of the underlying primitives for a given patch, placed in the context of the patch. If there are conflicts then context patches will be needed. darcsAn  ’ represents a primitive patch, together with any other primitives that are required to place the primitive in a different context. Typically, the presence of context patches indicates that the underlying primitive would be in conflict in the given context.’ÓWe have the following invariants: - if a context contains a patch, that context does not also contain the inverse of that patch (when commuted next to each other) - if either context contains a patch that commutes with the underlying patch, then neither context contains the inverse of that patch (when commuted next to each other) Another way of putting it is that all possible pairs of patch+inverse that can be reached by commutation are removed. darcs’7Given a list of unwound patches, use commutation and cancellation of inverses to remove intermediate contexts. This is not guaranteed to be possible in general, but should be possible if the patches that were unwound were all originally recorded (unconflicted) in the same context, e.g. as part of the same ~ś. darcscontext beforedarcsunderlying primitivesdarcs context after          rNone"#&',.1248=>?HIMPSUVX_k¾;€darcs5High-level representation of a piece of patch summary darcsThis type tags a patch with a  . and also hides the context witnesses (as in Sealed2 ), so we can put them in a list.         ! " # $ % # $ ! " %         sNone"#&',.1248=>?HIMPSUVX_kæ¹ . .tNone"#&',.1248=>?@AHIMPSUVX_kĄß     4 4     uNone"#&',.1248=>?HIMPSUVX_kĀĘĘvNone"#&',.1248=>?HIMPSUVX_kŃ >darcsQPatches whose concrete effect can be expressed as a list of primitive patches.(A minimal definition would be either of effect or effectRL. > ? > ?wNone"#&',.1248=>?HIMPSUVX_k飁darcsabstract over  'FL'/'RL' BdarcsFNonable represents the class of patches that can be turned into a Non. DdarcsA  D stores a context with a PrimJ patch. It is a patch whose effect isn't visible - a Non-affecting patch. FdarcsOunNon converts a Non into a FL of its context followed by the primitive patch. Gdarcs3showNons creates a Doc representing a list of Nons. Hdarcs)showNon creates a Doc representing a Non. Idarcs:readNons is a parser that attempts to read a list of Nons. Jdarcs7readNon is a parser that attempts to read a single Non. Kdarcs K x cy tries to commute x past cy" and always returns some variant cy'†. If commutation suceeds, the variant is just straightforwardly the commuted version. If commutation fails, the variant consists of x prepended to the context of cy. Ldarcs L xs cy commutes as many patches of xs past cyT as possible, adding any that don't commute to the context of cy. Suppose we have x1 x2 x3 [c1 c2 y]and that in our example x1 fails to commute past c1&, this function would commute down to x1 [c1'' c2'' y''] x2' x3' and return [x1 c1'' c2'' y''] MdarcsTcommutePrimsOrAddToCtx takes a WL of prims and attempts to commute them past a Non. Odarcs’gcommuteOrRemFromCtx attempts to remove a given patch from a Non. If the patch was not in the Non, then the commute will succeed and the modified Non will be returned. If the commute fails then the patch is either in the Non context, or the Non patch itself; we attempt to remove the patch from the context and then return the non with the updated context.TODO: understand if there is any case where p is equal to the prim patch of the Non, in which case, we return the original Non, is that right? Pdarcs~commuteOrRemFromCtxFL attempts to remove a FL of patches from a Non, returning Nothing if any of the individual removes fail. Qdarcs@(*>) attemts to modify a Non by commuting it past a given patch. RdarcsB(>*) attempts to modify a Non, by commuting a given patch past it. SdarcsJ(*>>) attempts to modify a Non by commuting it past a given WL of patches. TdarcsJ(>>*) attempts to modify a Non by commuting a given WL of patches past it. UdarcsVNons are equal if their context patches are equal, and they have an equal prim patch. B C D E F G H I J K L M N O P Q R S T D E B C F H G J I M K O L P N Q R S TxNone"#&',.1248=>?HIMPSUVX_k č [darcs’ŌThe first parameter is a context containing all patches preceding the ones for which we want to calculate the conflict resolution, which is the second parameter. Each element of the result list represents the resolution of one maximal set of transitively conflicting alternatives, in other words, a connected subset of the conflict graph. But the elements themselves must not conflict with each other, guaranteeing that they can be cleanly merged into a single Ō of prims. adarcs’ƒBy definition, a conflicting patch is resolved if another patch (that is not itself conflicted) depends on the conflict. If the representation of conflicts is self-contained as it is for V1 and V2, then we can calculate the maximal set of conflicting alternatives for a conflict separately for each conflictor at the end of a repo. This function can then be used to lift this to an Ń of patches.’^So, when looking for conflicts in a list of patches, we go through the whole list looking for individual patches that represent a conflict. But then we try to commute them past all the patches we've already seen. If we fail, i.e. there's something that depends on the conflict, then we forget about the conflict; this is the Nothing case of the commuteNoConflictsFLd call. Otherwise the patch is now in the correct position to extract the conflicting alternatives. XY Z [ \ ] ^ _ ` a Z [ \ ] ^ _XY ` ayNone"#&',.1248=>?HIMPSUVX_k ( ‚darcs‚ xs ys cs0' represents two sequences of patches that have cs in common, in other words  xs +<+ cs and  ys +<+ csƒdarcsƒ cs xs ys/ represents two sequences of patches that have cs in common, in other words  cs +>+ xs and  cs +>+ ys bdarcs bt is used to represents prim patches that are duplicates of, or conflict with, another prim patch in the repository. Normal prim: A primitive patch Duplicate x!: This patch has no effect since x' is already present in the repository. !Etacilpud x: invert (Duplicate x)Conflictor ix xx x: ix0 is the set of patches: * that conflict with xq and also conflict with another patch in the repository. * that conflict with a patch that conflict with xxx6 is the sequence of patches that conflict *only* with xx$ is the original, conflicting patch.ix and x are stored as Nona objects, which include any necessary context to uniquely define the patch that is referred to.YThe intuition is that a Conflictor should have the effect of inverting any patches that x† conflicts with, that haven't already been undone by another Conflictor in the repository. Therefore, the effect of a Conflictor is  invert xx.InvConflictor ix xx x: like invert (Conflictor ix xx x) hdarcs h p is True if p is either a  c or  d patch. idarcs i p is True if p is either an  g or  d. jdarcs j\ is used when converting from Darcs V1 patches (Mergers) to Darcs V2 patches (Conflictors).„darcsmergeAfterConflicting3 takes as input a sequence of conflicting patches xxxG (which therefore have no effect) and a sequence of primitive patches yyyz that follow said sequence of conflicting patches, and may depend upon some of the conflicting patches (as a resolution).…darcsIf xs consists only of  e patches, … xs returns Just pxs those patches (so lengthFL pxs == lengthFL xs). Otherwise, it returns E. kdarcs<This is used for unit-testing and for internal sanity checks†darcsMCommute conflicting patches, i.e. one of them is the result of a conflicted Y with the other.‡darcsSplit the rhs into those that  transitively- conflict with the lhs and those that don't.ˆdarcsˆ xs ys> returns the set of patches that can be commuted out of both xs and ys& along with the remnants of both lists‰darcs‰ xs ys@ returns the set of patches that can be commuted out of both xs and ys& along with the remnants of both lists b e c d f g h i j k b e c d f g k i h jzNone"#&',.1248=>?HIMPSUVX_k 7|ŠdarcsŠ! attempts to commute two patches p1 and p2¼, in their original order, with the given commute function. If the commute function doesn't know how to handle the patches (i.e. it returns Unknown as a result), then we try again with  invert p2 and  invert p1( (inverting the results, if succesful).^TODO: when can the first attempt fail, but the second not? What's so clever in this function?‹darcs|If we have two Filepatches which modify different files, we can return a result early, since the patches trivially commute.ŒdarcsEAttempt to commute two patches, the first of which is a Merger patch. Šdarcs}merger takes two patches, (which have been determined to conflict) and constructs a Merger patch to represent the conflict. p1' is considered to be conflicting with p2 (p1d is the "first" patch in the repo ordering), the resulting Merger is therefore a representation of p2.Y ˆ ‰ ŠY Š ‰ ˆ{None"#&',.1248=>?HIMPSUVX_k 8¢|None"#&',.1248=>?HIMPSUVX_k 9Ø}None"#&',.1248=>?HIMPSUVX_k :®~None"#&',.1248=>?HIMPSUVX_k Ls „darcs2This slightly ad-hoc class is here so we can call  ¦ with patch types that wrap a  § , such as  RebaseChange. §darcsThe Named6 type adds a patch info about a patch, that is a name.NamedP info deps p represents patch p with name info. depsz is a list of dependencies added at the named patch level, compared with the unnamed level (ie, dependencies added with darcs record --ask-deps). ¼darcsńThis instance takes care of handling the interaction between conflict resolution and explicit dependencies. By definition, a conflict counts as resolved if another patch depends on it. This principle extends to explicit dependencies between  §7 patches, but not to (aggregate) implicit dependencies.'This means we count any patch inside a  §! patch as resolved if some later  §@ patch depends on it explicitly. The patches contained inside a  §® patch that is not explicitly depended on must be commuted one by one past those we know are resolved. It is important to realize that we must not do this commutation at the  §) patch level but at the level below that. ¢ £ ¤ „ ¦ § Ø © Ŗ « ¬ ­ ® Æ ° ± ² § Ø Ŗ « © „ ¦ ¬ ­ ® Æ ° ± ¢ £ ¤ ²None"#&',.1248=>?HIMPSUVX_k cb ĪdarcsA  Ī’ encapsulates the concept of the name of a patch, without any contents. This allows us to track explicit dependencies in the rebase state, changing them to follow uses of amend-record or unsuspend on a depended-on patch, and warning the user if any are lost entirely. Ņdarcs Commute a  ĪĪ and a primitive patch. They trivially commute so this just involves changing the witnesses. This is unsafe if the patch being commuted actually has a name (e.g. Named or PatchInfo - PrimWithName is ok), Ódarcs Commute a primitive patch and a  Īø. They trivially commute so this just involves changing the witnesses. This is unsafe if the patch being commuted actually has a name (e.g. Named or PatchInfo - PrimWithName is ok), Ōdarcs¹Commute an unnamed patch with a named patch. This is unsafe if the second patch actually does have a name (e.g. Named, PatchInfoAnd, etc), as it won't check the explicit dependencies. ÕdarcsøCommute an unnamed patch with a named patch. This is unsafe if the first patch actually does have a name (e.g. Named, PatchInfoAnd, etc), as it won't check the explicit dependencies. ÖdarcsuCommute a name patch and a named patch. In most cases this is trivial but we do need to check explicit dependencies. ×darcsuCommute a named patch and a name patch. In most cases this is trivial but we do need to check explicit dependencies. Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų€None"#&',.1248=>?HIMPSUVX_k g¬ ädarcs{A single rebase fixup, needed to ensure that the actual patches being stored in the rebase state have the correct context. édarcs/Split a sequence of fixups into names and prims ä å ę ē č é ź ė ä å ę ź ė č é ēNone"#&',.1248=>?HIMPSUVX_k ‚ darcslUsing a special exception type here means that is is treated as regular failure, and not as a bug in Darcs. ÷darcs ÷ wA wBD represents the info of a patch, marked with the patch's witnesses. łdarcs ś p wA wBu represents a hope we have to get a patch through its info. We're not sure we have the patch, but we know its info.ŽdarcsSimpleHopefully is a variant of  Either String adapted for type witnesses. Actually is the equivalent of Right , while  Unavailable is Left. ūdarcs ū p C (x y) is C String (p C (x y))* in a form adapted to darcs patches. The C (x y)F represents the type witness for the patch that should be there. The  HopefullyH type just tells whether we expect the patch to be hashed or not, and Ž" does the real work of emulating C.  Hopefully sh- represents an expected unhashed patch, and Hashed hash sh3 represents an expected hashed patch with its hash. darcs  i p1 creates a PatchInfoAnd containing p with info i. darcsn2pia' creates a PatchInfoAnd representing a Named patch. darcs  hp tries to get a patch from a  śš value. If it fails, it outputs an error "failed to read patch: <description of the patch>". We get the description of the patch from the info part of hp darcs  er hp! tries to extract a patch from a  ś7. If it fails, it applies the error handling function er2 to a description of the patch info component of hpf. Note: this function must be lazy in its second argument, which is why we use a lazy pattern match. darcs hopefullyM is a version of  hopefully which calls fail! in a monad instead of erroring. ÷ ų ł ś ū ü ż ž ’          ū ś ł ÷ ų ü       ż ’   ž‚None"#&',.1248=>?HIMPSUVX_k ä 'darcsA  ' is a single chunk of a  ) . It has a §† representing a clean tag, the hash of the previous inventory (if it exists), and the list of patches since that previous inventory. )darcs’The patches in a repository are stored in chunks broken up at "clean" tags. A tag is clean if the only patches before it in the current repository ordering are ones that the tag depends on (either directly or indirectly). Each chunk is stored in a separate inventory file on disk.A  )‹ represents a repo's history as the list of patches since the last clean tag, and then a list of patch lists each delimited by clean tags.EBecause the invariants about clean tags can only be maintained if a  )G contains the whole history, the first witness is always forced to be  ,S. The type still has two witnesses so it can easily be used with combinators like × and Fork.[The history is lazily loaded from disk so does not normally need to be all kept in memory. ,darcs ,; is a type used to represent the initial context of a repo. .darcs . takes a  )# and returns an equivalent, linear Ń of patches. /darcs / takes a  )# and returns an equivalent, linear Ō of patches. 0darcs 0 takes a  ) and a ŌX of patches that "follow" the PatchSet, and concatenates the patches into the PatchSet. 1darcsƒRuns a progress action for each tag and patch in a given PatchSet, using the passed progress message. Does not alter the PatchSet. 2darcsThe tag names of all tags of a given  ). 5darcsSplit a  ) before~ the latest known clean tag. The left part is what comes before the tag, the right part is the tag and its non-dependencies. 6darcsDrop the last n patches from the given  ). ' ( ) * + , - . / 0 1 2 3 4 5 6 ) * ' ( + , 1 2 - 0 . / 3 4 5 6ƒNone"#&',.1248=>?HIMPSUVX_k £ =darcs Evaluate an Ō list and report progress. >darcs Evaluate an Ń list and report progress. ?darcs Evaluate an Ńw list and report progress. In addition to printing the number of patches we got, show the name of the last tag we got. = > ? > = ?„None"#&',.1248=>?HIMPSUVX_k Ćōdarcs1Find clean tags that are common to both argument  )s and return a Ė8 with the common clean tags and whatever remains of the  )ŗs. The two "uncommon" sequences may still have patches in common, even clean tags, since we look only at the "known clean" tags of the second argument, i.e. those that are the head of a  ' section.]This is a pretty efficient function, because it makes use of the already-broken-up nature of  )s.eNote that the first argument should be the repository that is more cheaply accessed (i.e. local), as ^ does its best to reduce the number of inventories that are accessed from its second argument.darcs takes a tag's §, t0, and a  ) and attempts to find t0 in one of the  '-s in the PatchSet. If the tag is found, the  )y is split up, on that tag, such that all later patches are in the "since last tag" patch list. If the tag is not found, E- is returned. This is a simpler version of  @" that only looks at the heads of  '+ sections and does not commute any patches. @darcs Take a tag's §, and a  )&, and attempt to find the tag in the  ). If found, return a new  )6, in which the tag is now clean (and the last of the  'z list), while all patches that are not covered by the tag are in the trailing list of patches. If the tag is not in the  ) , we return E. Adarcs Reorder a  )( such that the latest tag becomes clean.‘darcs‘h unfolds a single Tagged object in a PatchSet, adding the tag and patches to the PatchSet's patch list. Bdarcs Return the § for all the patches in a  )4 that are not depended on by any tag (in the given  )).JThis is exactly the set of patches that a new tag recorded on top of the  ) would explicitly depend on. Cdarcs Create a new  '@ section for the most recent clean tag found in the tail of un- 'L patches without re-ordering patches. Note that earlier tags may remain un- '! even if they are actually clean. MdarcsSplit a  )z at the latest clean tag. The left part is what comes before the tag, the right part is the tag and its non-dependencies. @ A B C D E F G H I J K L M B L E I F H D C @ K J G A M…None"#&',.1248=>?@AHIMPSUVX_k ʟ PdarcsApply a patch to set of ³s, yielding the new set of ³s and Fs N O P N P O†None"#&',.1248=>?HIMPSUVX_k Ē½ W W‡None"#&',.1248=>?@AHIMPSUVX_k Ėé Ydarcs;Apply patches, emitting warnings if there are any IO errors Zdarcs"Apply patches, ignoring all errors [darcsPThe default mode of applying patches: fail if the directory is not as we expect W X Y Z [ W Y Z X [ˆ2010 Petr RockaiMITdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_k Š¢ pdarcsœThis constraint expresses what is needed for a repo patch to support the high-level interface to annotation (currently annotateFile and annotateDirectory) p q r s t u v w t u w v s q r p‰None"#&',.1248=>?HIMPSUVX_k Ńš €  ‚ €  ‚żNone"#&',.1248=>?HIMPSUVX_k Ó b bŠNone"#&',.1248=>?HIMPSUVX_k Ō$ › œ  › œ žNone"#&',.1248=>?HIMPSUVX_k ÕBüü‹None"#&',.1248=>?HIMPSUVX_k ÖP61342JKPQXY ˆ‰Š‹—˜™œš›žŸ ”+,LMPQņóōõö÷ųł    > ? Z [ p ¶6 ¶ pˆ‰Š‹PQPQ Z [ > ?1342ōõö÷XY JKųł+,LMžŸ—˜™œš› ”  ņó ŒNone"#&',.1248=>?HIMPSUVX_k ķļ ødarcs°A patch, together with a list of patch names that it used to depend on, but were lost during the rebasing process. The UI can use this information to report them to the user. ¾darcsGet hold of the  § patch inside a  ¼ and wrap it in a  ś. ĄdarcshSplit a list of rebase patches into those that will have conflicts if unsuspended and those that won't. Įdarcs°Given a list of rebase items, try to push a new fixup as far as possible into the list as possible, using both commutation and coalescing. If the fixup commutes past all the ToEdit% patches then it is dropped entirely. ĀdarcsLike  Į but for a list of fixups.’darcspushThrough (ps :> (qs :> te)) tries to commute as much of ps as possible through both qs and te , giving %psStuck :> (qs' :> te') :> psCommuted,. Anything that can be commuted ends up in  psCommuted" and anything that can't goes in psStuck.“darcsForcibly commute a  ĪV with a patch, dropping any dependencies if necessary and recording them in the patch Ädarcs’Turn a selected rebase patch back into a patch we can apply to the main repository, together with residual fixups that need to go back into the rebase state (unless the rebase is now finished). Any fixups associated with the patch will turn into conflicts. ÅdarcsLike  Ä5, but any fixups are "reified" into a separate patch. · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę ¼ ½ æ Ä Å Ą ¾ ø ¹ ŗ » · Ć Į Ā ʍNone"#&',.1248=>?HIMPSUVX_k żB ŚdarcsøA single item in the rebase state consists of either a patch that is being edited, or a fixup that adjusts the context so that a subsequent patch that is being edited "makes sense".ToEdit/ holds a patch that is being edited. The name ( PatchInfo’F) of the patch will typically be the name the patch had before it was added to the rebase state; if it is moved back into the repository it must be given a fresh name to account for the fact that it will not necessarily have the same dependencies or content as the original patch. This is typically done by changing the  Ignore-This junk.Fixup* adjusts the context so that a subsequent ToEdit$ patch is correct. Where possible, Fixup changes are commuted as far as possible into the rebase state, so any remaining ones will typically cause a conflict when the ToEdit* patch is moved back into the repository. Ś Ü Ū Ż Ś Ü Ū ŻŽNone"#&',.1248=>?HIMPSUVX_k Ś ādarcs A single  Suspended9 patch contains the entire rebase state, in the form of  RebaseItems.The witnesses are such that a  Suspended¤ appears to have no effect. This behaviour is only kept so we can read old-style rebase patches, where the entire rebase state was kept in a single patch on disk. ådarcs3add fixups for the name and effect of a patch to a  ā ędarcsTremove fixups (actually, add their inverse) for the name and effect of a patch to a  ā ēdarcsAdd  § patches for editing to a  āJ. The patches to be suspended are renamed by replacing the junk in their  Patchinfo.’The reason we rename patches immediately when suspending them is that the user may pull an identical copy from a clone, Which means we have the same patch name twice, once in the normal repo and once suspended. Furthermore, they can again suspend that copy, leaving us with multiple copies of the same patch in the rebase state. This is bad because it invalidates most of the invariants for RebaseName fixups. See issue2445 and tests/rebase-repull.sh for examples which lead to crashes when we don't do the renaming here. ā ć ä å ę ē č é ā ć ä č é å ę ēNone"#&',.1248=>?HIMPSUVX_k Ų šdarcspA patch that lives in a repository where an old-style rebase is in progress. Such a repository will consist of Normal! patches along with exactly one  Suspended patch.;It is here only so that we can upgrade an old-style rebase.NormalPP represents a normal patch within a respository where a rebase is in progress.  NormalP p. is given the same on-disk representation as pa, so a repository can be switched into and out of rebasing mode simply by adding or removing a RebaseP/ patch and setting the appropriate format flag.*Note that the witnesses are such that the RebaseP patch has no effect on the context of the rest of the repository; in a sense the patches within it are dangling off to one side from the main repository. š ń ņ ó š ń ņ óNone"#&',.1248=>?HIMPSUVX_k $Į darcsRWrapper type to allow formal inversion of patches which aren't really invertible. darcs#Wrap a patch to make it (formally)  ). The result is initially positive i.e. ”. darcs!Get the underlying patch from an  9, assuming (as a precondition) that it is positive i.e. ”. darcs&Run a function on the patch inside an  T. The function has to be parametric in the witnesses, so we can run it with both a ” and a • patch.      ’None"#&',.1248=>?HIMPSUVX_k %ēE =789:QSTY Š‰ŒŽ›šœ˜™Ÿ”¢¤£„-.Qfghsvutrpqno{€~yƒųł " # % > ? [ ¦ § © Ŗ « ¬ ­ ® ¶E ųł §‰onqprtu ©v™Ÿ¢¤£”„˜ Ŗsœy~YQ =ƒ [ > ?€{789:TS.-hgf ­ ®ŠŽŒ ¬š› # % " « ¦ Q ¶‘None"#&',.1248=>?HIMPSUVX_k /g–darcs0This makes darcs-1 (non-hashed repos) filenames.$The name consists of three segments:˜timestamp (ISO8601-compatible yyyymmmddHHMMSS; note that the old-fashioned (non-hashed) format expects this date to be exactly as in the patch, ignoring, any timezone info, which is why we use Ö here)SHA1 hash of the authorHSHA1 hash of the patch name, author, date, log, and "inverted" flag.    ’None"#&',.1248=>?HIMPSUVX_k 76 darcsA  Repository’˜ is a token representing the state of a repository on disk. It is parameterized by the patch type in the repository, and witnesses for the recorded state of the repository (i.e. what darcs get would retrieve), the unrecorded state (what's in the working tree now), and the tentative state, which represents work in progress that will eventually become the new recorded state unless something goes wrong.              ! " #              ! " #“None"#&',.1248=>?HIMPSUVX_k ^Į—darcsAThe way patchfiles, inventories, and pristine trees are stored. ˜, means all files are in the same directory. ™· means we create a second level of subdirectories, such that all files whose hash starts with the same two letters are in the same directory. Currently, only the global cache uses ™ while repositories use the ˜. (darcs2Remove unreferenced entries in the pristine cache. )darcs+Set difference between two lists of hashes. *darcs7Remove unreferenced files in the inventories directory. +darcsCList of special patch files that may exist in the directory _darcspatches. We must not clean those. ,darcs3Remove unreferenced files in the patches directory.šdarcs’ZReturn a list of the inventories hashes. The first argument can be readInventory or readInventoryLocal. The second argument specifies whether the files are expected to be stored in plain or in bucketed format. The third argument is the directory of the parent inventory files. The fourth argument is the directory of the head inventory file. -darcstReturn a list of the inventories hashes. This function attempts to retrieve missing inventory files from the cache. .darcsReturn inventories hashes by following the head inventory. This function does not attempt to retrieve missing inventory files. /darcs7Return a list of the inventories hashes. The argument repoDir— is the directory of the repository from which we are going to read the head inventory file. The rest of hashed files are read from the global cache.›darcsŸReturn a list of the patch filenames, extracted from inventory files, by starting with the head inventory and then following the chain of parent inventories.CThis function does not attempt to download missing inventory files.kThe first argument specifies whether the files are expected to be stored in plain or in bucketed format.=The second argument is the directory of the parent inventory.:The third argument is the directory of the head inventory. 0darcsdlistPatchesLocalBucketed is similar to listPatchesLocal, but it read the inventory directory under darcsDir in bucketed format.œdarcsĖRead the given inventory file if it exist, otherwise return an empty inventory. Used when we expect that some inventory files may be missing. Still fails with an error message if file cannot be parsed.darcseRead an inventory from a file. Fails with an error message if file is not there or cannot be parsed. ' ( ) * + , - . / 0 * , ( ' ) - . / 0 +”None"#&',.1248=>?HIMPSUVX_k dÉ 3darcsXgot a rebase operation to run where it is required that a rebase is already in progress 4darcsGot a rebase operation to run where we may need to initialise the rebase state first. Make sure you have taken the lock before calling this. 5darcs/Generic status display for non-rebase commands. 1 2 3 4 5 6 7 8 9 : ; 1 3 4 5 7 8 6 : 9 ; 2•None"#&',.1248=>?HIMPSUVX_k sŸ ?darcs ? takes a root hash, a patch p) and attempts to apply the patch to the   identified by h~. If we encounter an old, size-prefixed pristine, we first convert it to the non-size-prefixed format, then apply the patch.ždarcsøcopyPristine copies a pristine tree into the current pristine dir, and possibly copies a clean working tree. The target is read from the passed-in dir/inventory name combination. @darcs)applyToTentativePristine applies a patch pI to the tentative pristine tree, and updates the tentative pristine hash Bdarcs"Used by the commands dist and diff Cdarcs|readHashedPristineRoot attempts to read the pristine hash from the current inventory, returning Nothing if it cannot do so. Ddarcs‹grab the pristine hash of _darcs/hash_inventory, and retrieve whole pristine tree, possibly writing a clean working tree in the process. ąį < = > ? @ A B C D E F < = > ? @ A Cąį D B E F–None"#&',.1248=>?HIMPSUVX_k Æ GdarcsRead the contents of pending. Hdarcs'Read the contents of tentative pending.Ÿdarcs'Read the contents of tentative pending. darcsURead the pending file with the given suffix. CWD should be the repository directory. Idarcs(Write the contents of tentative pending.”darcsJWrite the contents of new pending. CWD should be the repository directory. Jdarcs’ŽRemove as much as possible of the given list of prim patches from the pending patch. The "as much as possible" is due to --look-for-* options which cause changes that normally must be explicitly done by the user (such as add, move, and replace) to be inferred from the the diff between pristine and working. These changes cannot be removed from pending because they have never been part of it.·This function is used by Darcs whenever it adds a patch to the repository (eg. with apply or record). Think of it as one part of transferring patches from pending to somewhere else. Kdarcs Similar to  J©, but also takes the (old) difference between pending and working into account. It is used by amend and record commands to adjust the pending patch. See the docs for ¢ below for details.¢darcs¢ changes pending working updates pending by removing the changesT we added to the repository. If primitive patches were atomic, we could assume that changes is a subset of pending +>+ workingŖ, but alas, they are not: before we select changes we coalesce them; and during selection we can again arbitrarily split them (though currently this is limited to hunks).&The algorithm is as follows. For each x in changes we first try to remove it from pending* as is. If this fails, we commute it past pendingY, pushing any (reverse) dependencies with it, and check if we can remove the result from working.ŚIf prim patches were atomic this check would always succeed and we would be done now. But due to coalescing and splitting of prims it can fail, so we must try harder: we now try to decoalesce the commuted changes from working,. If that fails, too, then we know that our x originated from pending!. So we backtrack and decoalesce x from pending”. This final step must not fail. If it does, then we have a bug because it means we recorded a change that cannot be removed from the net effect of pending and working.£darcs)Remove as many patches as possible of an Ń from an adjacent Ō.¤darcs Remove all patches of the first Ō from the second Ō or fail.„darcs%Decoalesce all patches in the second Ō from the first Ō or fail.¦darcs-Decoalesce (subtract) a single patch from an Ōg by trying to decoalesce it with every element until it succeeds or we cannot commute it any further. Ldarcs+makeNewPending repo YesUpdatePending pendPs verifies that the pendPsh could be applied to pristine if we wanted to, and if so writes it to disk. If it can't be applied, pendPsA must be somehow buggy, so we save it for forensics and crash. Mdarcs<Replace the pending patch with the tentative pending. If NoUpdatePendingQ, this merely deletes the tentative pending without replacing the current one.LQuestion (Eric Kow): shouldn't this also delete the tentative pending if YesUpdatePending;? I'm just puzzled by the seeming inconsistency of the NoUpdatePending doing deletion, but YesUpdatePending not bothering. OdarcstentativelyAddToPending repo ps appends ps to the pending patch.œThis fuction is unsafe because it accepts a patch that works on the tentative pending and we don't currently track the state of the tentative pending. PdarcsMOverwrites the pending patch with a new one, starting at the tentative state. LdarcsDrecorded state of the repository, to check if pending can be applied d G H I J K L M N O P G H Id J K N M L O P—GPL-2None"#$&',.1248=>?HIMPSUVX_k Ö-§darcsthe patch-indexØdarcsall the Nŗs tracked by this patch index, with the most recent patch at the head of the list (note, stored in the reverse order to this on disk for backwards compatibility with an older format).©darcs information file with a given IDŖdarcsGtimespans where a file with a certain id corresponds to given filenames«darcsHtimespans where a certain filename corresponds to a file with a given id¬darcs9info about a given fileid, e.g.. is a file or a directory­darcsfirst word of patch hash®darcsūOn-disk version of patch index version 1 is the one introduced in darcs 2.10 2 changes the pids order to newer-to-older 3 changes FileName to AnchoredPath everywhere, which has different Binary (and Ord) instancesÆdarcs\'applyPatchMods pmods pindex' applies a list of PatchMods to the given patch index pindex°darcs$create new filespan for created file±darcs?start new span for name fn for file fid starting with patch pid²darcs"stop current span for file name fn³darcs?start new span for name fn for file fid starting with patch pid“darcs"stop current span for file name fnµdarcs)insert touching patchid for given file id¶darcs)insert touching patchid for given file id·darcslookup current fid of filepathødarcsClookup current fid of filepatch, returning a Maybe to allow failure¹darcs'lookup all the file ids of a given pathŗdarcs>return all fids of matching subpaths of the given filepath»darcs§returns a single file id if the given path is a file if it is a directory, if returns all the file ids of all paths inside it, at any point in repository history¼darcs<Creates patch index that corresponds to all patches in repo.½darcsconvert patches to patchmods¾darcs.return set of current filenames in patch indexædarcsžremove all patch effects of given patches from patch index. assumes that the given list of patches is a suffix of the patches tracked by the patch-indexĄdarcs=update the patch index to the current state of the repositoryĮdarcsT'createPatchIndexFrom repo pmods' creates a patch index from the given patchmods.Ādarcs5Load patch-index from disk along with some meta data.ĆdarcsZIf patch-index is useful as it is now, read it. If not, create or update it, then read it. TdarcsWRead-only. Checks if patch-index exists for this repository it works by checking if: _darcs/patch_index/, and its corresponding files are all present?patch index version is the one handled by this version of Darcs UdarcsRead-only. Checks if _darcs/noPatchIndex9 exists, that is, if patch-index is explicitely disabled. VdarcsCreate or update patch index if _darcs/no_patch_index exists, delete it if patch index exists, update itif not, create it from scratch Wdarcs+Read-only. Checks the two following things:  T UCThen only if it exists and it is not explicitely disabled, returns True, else returns FalseJ (or an error if it exists and is explicitely disabled at the same time). Xdarcs’Creates patch-index (ignoring whether it is explicitely disabled). If it is ctrl-c'ed, then aborts, delete patch-index and mark it as disabled. YdarcsQChecks if patch-index exists and is in sync with repository (more precisely with _darcs/hashed_inventory>). That is, checks if patch-index can be used as it is now.ÄdarcsStores patch-index on disk. ZdarcsDeletes patch-index (_darcs/patch_index/< and its contents) and mark repository as disabled (creates _darcs/no_patch_index).Ådarcs.return set of current filepaths in patch indexĘdarcs@return set of current filepaths in patch index, for internal use [darcsAChecks if patch index can be created and build it with interrupt.ĒdarcsČChecks whether a patch index can (and should) be created. If we are not in an old-fashioned repo, and if we haven't been told not to, then we should create a patch index if it doesn't already exist. \darcsEReturns an RL in which the order of patches matters. Useful for the annotate© command. If patch-index does not exist and is not explicitely disabled, silently create it. (Also, if it is out-of-sync, which should not happen, silently update it). ]darcs\If a patch index is available, returns a filter that takes a list of files and returns a  PatchFilter’ that only keeps patches that modify the given list of files. If patch-index cannot be used, return the original input. If patch-index does not exist and is not explicitely disabled, silently create it. (Also, if it is out-of-sync, which should not happen, silently update it). ^darcs^Dump information in patch index. Patch-index should be checked to exist beforehand. Read-only. _darcs€Read-only sanity check on patch-index. Patch-index should be checked to exist beforehand. It may not be in sync with repository.Čdarcs*the file path has some fixed fileid in thedarcsspan starting heredarcsand (maybe) ending hereÉdarcs%the fileid has some fixed name in thedarcsspan starting heredarcsand (maybe) ending hereĆdarcsFPatchSet of the repository, used if we need to create the patch-index. \darcs&Sequence of patches you want to filterdarcs=The repository (to attempt loading patch-index from its path)darcs>PatchSet of repository (in case we need to create patch-index)darcs8File(s) about which you want patches from given sequencedarcsFiltered sequence of patches ]darcsThe repositorydarcsKPatchSet of patches of repository (in case patch-index needs to be created)darcs.PatchFilter ready to be used by SelectChanges. S T U V W X Y Z [ \ ] ^ _ T U Y W X V Z [ S ] \ ^ _˜2009 Petr RockaiMITdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_k 9 i i™None"#&',.1248=>?HIMPSUVX_k fĖ mdarcs’From a repository and a list of AnchoredPath's, construct a filter that can be used on a Tree (recorded or unrecorded state) of this repository. This constructed filter will take pending into account, so the subpaths will be translated correctly relative to pending move patches.ŹdarcsLike  m8 but with the pending patch passed as a parameter. The  E parameter is not used, we need it only to avoid abiguous typing of p. ndarcs Construct a  jL that removes any boring files that are not also contained in the argument  .ÜThe standard use case is for the argument to be the recorded state, possibly with further patches applied, so as not to discard any files already known to darcs. The result is usually applied to the full working state. odarcs]Construct a Tree filter that removes any darcs metadata files the Tree might have contained. pdarcs5For a repository and an optional list of paths (when E’, take everything) compute a (forward) list of prims (i.e. a patch) going from the recorded state of the repository (pristine) to the unrecorded state of the repository (the working tree + pending). When a list of paths is given, at least the files that live under any of these paths in either recorded or unrecorded will be included in the resulting patch. NB. More patches may be included in this list, eg. the full contents of the pending patch. This is usually not a problem, since selectChanges will properly filter the results anyway.'This also depends on the options given:Ā-look-for-moves: Detect pending file moves using the index. The resulting patches are added to pending and taken into consideration, when filtering the tree according to the given path list.g-look-for-adds: Include files in the working state that do not exist in the recorded + pending state.+-include-boring: Include even boring files.Ļ-look-for-replaces: Detect pending replace patches. Like detected moves, these are added to the pending patch. Note that, like detected moves, these are mere proposals for the user to consider or reject.’E-ignore-times: Disables index usage completely -- for each file, we read both the unrecorded and the recorded copy and run a diff on them. This is very inefficient, although in extremely rare cases, the index could go out of sync (file is modified, index is updated and file is modified again within a single second).Note that use of the index is also disabled when we detect moves or replaces, since this implies that the index is out of date.Ėdarcs7filteredWorking useidx scan relevant index pending_treeA reads the working tree and filters it according to options and relevant file paths. The  pending_tree is understood to have relevant( already applied and is used (only) if  useidx == " and scan /= 3 to act as a guide for filtering the working tree.Ģdarcs„Witnesses the fact that in the absence of a working tree, we pretend that the working dir updates magically to the tentative state. rdarcsŃObtains a Tree corresponding to the "recorded" state of the repository: this is the same as the pristine cache, which is the same as the result of applying all the repository's patches to an empty directory. sdarcsŅObtains a Tree corresponding to the "unrecorded" state of the repository: the modified files of the working tree plus the "pending" patch. The optional list of paths allows to restrict the query to a subtree.ČLimiting the query may be more efficient, since hashes on the uninteresting parts of the index do not need to go through an up-to-date check (which involves a relatively expensive lstat(2) per file. tdarcs A variant of  sI that takes the UseIndex and ScanKnown options into account, similar to  qG. We are only interested in the resulting tree, not the patch, so the × option is irrelevant. udarcsNObtains the relevant (according to the given filter) part of the working tree. vdarcsObtains the recorded   with the pending patch applied.ĶdarcsObtains the recorded  ā with the pending patch applied, plus the pending patch itself. The pending patch should start at the recorded state (we even verify that it applies, and degrade to renaming pending and starting afresh if it doesn't). wdarcs’TMark the existing index as invalid. This has to be called whenever the listing of pristine changes and will cause darcs to update the index next time it tries to read it. (NB. This is about files added and removed from pristine: changes to file content in either pristine or working are handled transparently by the index reading code.) zdarcssRemove any patches (+dependencies) from a sequence that conflict with the recorded or unrecorded changes in a repoĪdarcs_Automatically detect file moves using the index. TODO: This function lies about the witnesses.ĻdarcsÄSearch for possible replaces between the recordedAndPending state and the unrecorded (or working) state. Return a Sealed FL list of replace patches to be applied to the recordedAndPending state. {darcsAdd an ŌÖ of patches started from the pending state to the pending patch. TODO: add witnesses for pending so we can make the types precise: currently the passed patch can be applied in any context, not just after pending. |darcsAdd an Ō’^ of patches starting from the working state to the pending patch, including as much extra context as is necessary (context meaning dependencies), by commuting the patches to be added past as much of the changes between pending and working as is possible, and including anything that doesn't commute, and the patch itself in the new pending patch. zdarcs9Repository itself, used for grabbing unrecorded changesdarcsWRecorded patches from repository, starting from same context as the patches to filterdarcsPatches to filterdarcs>True iff any patches were removed, possibly filtered patchesĻdarcs0pending tree (including possibly detected moves)darcs working tree !" j k l m n o p q r s t u v w x y z { | m n j k l o p r s v u q t x y w !" z { |šNone"#&',.1248=>?HIMPSUVX_k nĖ ‡darcs working treedarcsexternal merge tool commanddarcstell whether we want GUI pausedarcs our effectdarcs their effectdarcs!them merged (standard_resolution)Šdarcsexternal merge tool commanddarcstell whether we want GUI pausedarcspath to merge basedarcspath to side 1 of the mergedarcspath to side 2 of the mergedarcs%path where resolved content should go } ~  €  ‚ ƒ „ … † ‡ ˆ ‚ ‡ ˆ } ~  €  † ƒ „ …›None"#&',.1248=>?HIMPSUVX_k °ŃdarcslUsing a special exception type here means that is is treated as regular failure, and not as a bug in Darcs.ŅdarcsA Matcher is made of a Ó+ which we will use to match patches and a String representing it.ÓdarcsDA type for predicates over patches which do not care about contexts ”darcsConstraint for a patch type p that ensures  ś rt p is  ¢. ¢darcsPatches that can be matched.Ōdarcs applyMatcher applies a matcher to a patch. £darcs.The string that is emitted when the user runs darcs help patterns. ¤darcshaveNonrangeMatch flags# tells whether there is a flag in flags: which corresponds to a match that is "non-range". Thus, --match, --patch, and --hash make haveNonrangeMatch true, but not  --from-patch or  --to-patch. ¦darcs firstMatch fs tells whether fs¢ implies a "first match", that is if we match against patches from a point in the past on, rather than against all patches since the creation of the repository. §darcssecondMatch fs tells whether fs‰ implies a "second match", that is if we match against patches up to a point in the past on, rather than against all patches until now.ÕdarcsĀstrictJust is a strict version of the Just constructor, used to ensure that if we claim we've got a pattern match, that the pattern will actually match (rathern than fail to compile properly).ÖdarcsnonrangeMatcherb is the criterion that is used to match against patches in the interval. It is 'Just m' when the --patch, --match, --tag/ options are passed (or their plural variants).×darcs firstMatcherz returns the left bound of the matched interval. This left bound is also specified when we use the singular versions of --patch, --match and --tag . Otherwise,  firstMatcher returns Nothing. ©darcs"Whether a patch matches the given  Ž-s. This should be invariant under inversion:&matchAPatch (invert p) = matchAPatch pŲdarcs hasLastn fs return the --last argument in fs , if any. «darcsmatchFirstPatchset fs ps returns the part of ps[ before its first matcher, ie the one that comes first dependencywise. Hence, patches in matchFirstPatchset fs ps- are the context for the ones we don't want. ¬darcsmatchSecondPatchset fs ps returns the part of psG before its second matcher, ie the one that comes last dependencywise. ­darcs…Split on the second matcher. Note that this picks up the first match starting from the earliest patch in a sequence, as opposed to  ¬? which picks up the first match starting from the latest patch ®darcsmatchAPatchset m ps returns a prefix of ps ending in a patch matching m , and calls ż if there is none. ÆdarcsgetMatchingTag m ps, where m is a Ņ which matches tags returns a  +7 containing all patches in the last tag which matches mo. Last tag means the most recent tag in repository order, i.e. the last one you'd see if you ran darcs log -t m . Calls ż if there is no matching tag. °darcs7Rollback (i.e. apply the inverse) of what remains of a  ) after we extract a  ‰. This is the counterpart of getOnePatchset’ and is used to create a matching state. In particular, if the match is --index=n then rollback the last (n-1) patches; if the match is --tag, then rollback patches that are not depended on by the tag; otherwise rollback patches that follow the latest matching patch.ŁdarcsapplyInvToMatcher, m ps applies the inverse of the patches in ps>, starting at the end, until we hit a patch that matches the Ņ m.Śdarcs applyNInv& n ps applies the inverse of the last n patches of ps.Ūdarcs applyInvp› tries to get the patch that's in a 'PatchInfoAnd patch', and to apply its inverse. If we fail to fetch the patch then we share our sorrow with the user. ±darcs–matchingHead returns the repository up to some tag. The tag t is the last tag such that there is a patch after t that is matched by the user's query.ÜdarcsXkeyword (operator), argument name, help description, list of examples, matcher function ­darcs“The first element is the patches before and including the first patch matching the second matcher, the second element is the patches after it) ‰ Š ‹ Œ  Ž   “ ” — • – ˜ ™  Ÿ ž š › œ   ‘ ’ ” ¢ £ ¤ „ ¦ § Ø © Ŗ « ¬ ­ ® Æ ° ±) £ « ¬ ­ © ° ¦ § ¤ ‰ Š ‹ Œ  „ Ø Ŗ Æ ® Ž   “ ” — • – ˜ ™  Ÿ ž š › œ   ‘ ’ ± ¢ ”œNone"#&',.1248=>?HIMPSUVX_k ·ż ·darcsUsed by: clone ødarcsUsed by: amend ¹darcs:Used by: rebase pull/apply, send, push, pull, apply, fetch »darcsUsed by: rebase unsuspend/reify ¼darcs7Used by: unrecord, obliterate, rebase suspend, rollback ½darcs Used by: diff ¾darcsUsed by: show dependencies ædarcs Used by: log ¶darcs#show files/contents, dist, annotate Ž   “ ” — • – ˜ ™  Ÿ ž š › œ   ‘ ’ ¶ · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ž   “ ” — • – ˜ ™  Ÿ ž š › œ   ‘ ’ ¶ · ø ¹ » ¼ ¾ ½ æ Ā ŗ Ą ĮNone"#&',.1248=>?HIMPSUVX_k ĖP Ņdarcs)TODO: reconsider this grouping of options darcs3Options for darcs iself that act like sub-commands. !darcs !/ instantiates the first two type parameters of Vd to what we need in darcs. The first parameter is instantiated to The flag type is instantiate to æ. -darcséTODO someone wrote here long ago that any time --dry-run is a possibility automated users should be able to examine the results more easily with --xml. See also issue2397. dryRun w/o xml is currently used in add, pull, and repair. 7darcsĢThis option is for when a new repo gets created. Used for clone, convert import, convert darcs-2, and initialize. For clone and initialize it has the same effect as giving the name as a normal argument.The  --repodir@ alias is there for compatibility, should be removed eventually.7TODO We need a way to deprecate options / option names. ?darcsconvert, clone, init PdarcsTODO: see issue2395 bdarcs&push, apply, rebase apply: default to  cdarcspull, rebase pull: default to  edarcs&pull, apply, rebase pull, rebase apply xdarcs:Deprecated flag, still present to output an error message.’AףŲųłūśüżž’     !"#$%&(')*+,-./0123456789:;<=>?@ABCEDFGHLNMOPQRSTUVWXYZ[ Ž   “ ” — • – ˜ ™  Ÿ ž š › œ   ‘ ’ ¶ · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę Ē Č É Ź Ė Š Ī Ķ Ģ Ļ Ń Ņ Ó Õ Ō Ö × Ų Ł Ś Ū Ü ß Ż Ž ą į ā ć ä å ę ē č é ź ė ģ ķ ī ļ š ņ ń ó ō õ ö ÷ ų ū ś ł ü ż ž ’                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~  €  ‚ ƒ „ … †’! !        "     # $XYZ[ % & 'üżž’ųłūś ) * (FGH +    ,CED - . 0 /   1 2  3 4 5 6)* 9 8 7  ; :     < = > ?&(' @#$% A B C    D E ü ż ž ’ F ÷ ų ū ś ł=>?789:;< G H I J !"456 L M N O P K QףŲ R ō õ ö S ļ š ņ ń ó T ģ ķ ī U123 V+,- W å ę ē č é ź ė X Y Z [ ] ^ _ ą į ā ć ä ` Ü ß Ż Ž a b c d eUVW f gRST h iLNM \ j Ł Ś Ū k Ö × Ų l mOPQ Ņ Ó Õ Ō n@AB o./0 p q r s t z { u v w y x Ė Š Ī Ķ Ģ Ļ Ń | } ~ Ę Ē Č É Ź  €  ‚ ƒ    „ Ć Ä Å … †žNone"#&',.1248=>?HIMPSUVX_k Öo ½darcsInstantiate a ¾ with an øUVW[ZYX\]^_`abcde½¾ ! ¼ ½ !½¾ ½ ¼ŸNone"#&',.1248=>?HIMPSUVX_k • Ćdarcs(Non-trivial interaction between options. ÅdarcsDThis will become dis-entangled as soon as we inline these functions. Ędarcs2Non-trivial interaction between options. Explicit -i or -a dominates, else --count, --xml, or  --dry-run imply -a, else use the def argument. ĪdarcsŁUgly. The alternative is to put the remoteRepos accessor into the IO monad, which is hardly better. However, accessing the flag list directly here is benign, as we only map over the list and don't change the order. Ļdarcs Ļq takes a String that may be a file path or a URL. It returns either the URL, or an absolute version of the path. Šdarcs’EUsed by commands that expect arguments to be paths in the current repo. Invalid paths are dropped and a warning is issued. This may leave no valid paths to return. Although these commands all fail if there are no remaining valid paths, they do so in various different ways, issuing error messages tailored to the command. Ńdarcs’2Used by commands that interpret a set of optional path arguments as "restrict to these paths", which affects patch selection (e.g. in log command) or selection of subtrees (e.g. in record). Because of the special meaning of "no arguments", we must distinguish it from "no valid arguments". A result of E6 here means "no restriction to the set of paths". If F4 is returned, the set is guaranteed to be non-empty.Żdarcs2maybeFixSubPaths (repo_path, orig_path) file_paths tries to turn  file_paths into SubPath_s, taking into account the repository path and the original path from which darcs was invoked.A SubPath is a path under& (or inside) the repo path. This does notz mean it must exist as a file or directory, nor that the path has been added to the repository; it merely means that it could be added.’When converting a relative path to an absolute one, this function first tries to interpret the relative path with respect to the current working directory. If that fails, it tries to interpret it with respect to the repository directory. Only when that fails does it put a NothingE in the result at the position of the path that cannot be converted.?It is intended for validating file arguments to darcs commands. Ņdarcs ŅK takes a list of flags and returns the url of the repository specified by Repodir "directory"P in that list of flags, if any. This flag is present if darcs was invoked with --repodir=DIRECTORY Õdarcs ÕJ takes a list of flags and returns the author of the change specified by Author "Leo Tolstoy"/ in that list of flags, if any. Otherwise, if Pipeå is present, asks the user who is the author and returns the answer. If neither are present, try to guess the author, from repository or global preference files or environment variables, and if it's not possible, ask the user. Ödarcs Öć try to guess the author, from repository or global preference files or environment variables, and if it's not possible or alwaysAsk parameter is true, ask the user. If store parameter is true, the new author is added into  _darcs/prefs. ×darcs ׎ tries to get the author name first from the repository preferences, then from global preferences, then from environment variables. Returns []t if it could not get it. Note that it may only return multiple possibilities when reading from global preferences Śdarcs ŚG takes a list of flags and returns the sendmail command to be used by  darcs send$. Looks for a command specified by SendmailCmd "command"P in that list of flags, if any. This flag is present if darcs was invoked with --sendmail-command=COMMAND! Alternatively the user can set $SENDMAIL- which will be used as a fallback if present. ŪdarcsAccessor for output option Üdarcs ÜJ takes a list of flags and returns the subject of the mail to be sent by  darcs send$. Looks for a subject specified by Subject "subject"P in that list of flags, if any. This flag is present if darcs was invoked with --subject=SUBJECT Żdarcs Żc takes a list of flags and returns the addresses to send a copy of the patch bundle to when using  darcs send'. looks for a cc address specified by  Cc "address"K in that list of flags. Returns the addresses as a comma separated string.Kš Į % + , - 3 4 5 9 ? C K N O P R S U V W \ ] ^ _ d e f g h i o p q t y „ † ¾ æ Ą Į Ā Ć Ä Å Ę Ē Č É Ź Ė Ģ Ķ Ī Ļ Š Ń Ņ Ó Ō Õ Ö × Ų Ł Ś Ū Ü Ż Ž ß ą į āKš Ą Ä Ā Ć Å Ę Ē Č É Ė Ź Ģ Ķ ß ą æ ¾ Į Ī Ļ Š Ń Ņ Õ Ö × Ś Ó Ō Ü Ž Ż Ł Ū Ų į ā f R e \ ^ d 5 Į S N O 4 g P q % + K o - V U p ? W 9 t h i , 3 C y ] † _ „ None"#&',.1248=>?HIMPSUVX_k E© Ždarcs-if pipe to ssh, can choose to compress or notßdarcsotherwise, can specify printersądarcsgetSystemEncoding) fetches the current encoding from locale ådarcs5Get the name of the darcs executable (as supplied by getExecutablePath) ėdarcsnSend an email, optionally containing a patch bundle (more precisely, its description and the bundle itself)įdarcs’lGiven two shell commands as arguments, execute the former. The latter is then executed if the former failed because the executable wasn't found (code 127), wasn't executable (code 126) or some other exception occurred (save from a resource vanished/broken pipe error). Other failures (such as the user holding ^C) do not cause the second command to be tried. ódarcs editFile f¹ lets the user edit a file which could but does not need to already exist. This function returns the exit code from the text editor and a flag indicating if the user made any changes. ōdarcs•On Posix systems, GHC by default uses the user's locale encoding to determine how to decode/encode the raw byte sequences in the Posix API to/from Re. It also uses certain special variants of this encoding to determine how to handle encoding errors.See GHC.IO.Encoding for details.bIn particular, the default variant used for command line arguments and environment variables is /ROUNDTRIP, which means that Īany/ byte sequence can be decoded and re-encoded w/o failure or loss of information. To enable this, GHC uses code points that are outside the range of the regular unicode set. This is what you get with ā.ĖWe need to preserve the raw bytes e.g. for file names passed in by the user and also when reading file names from disk; also when re-generating files from patches, and when we display them to the user.mSo we want to use this encoding variant for *all* IO and for (almost) all conversions between raw bytes and RBs. The encoding used for IO from and to handles is controlled by ć@ which we use here to make it equal to the //ROUNDTRIP variant.setDarcsEncoding” should be called before the first time any darcs operation is run, and again if anything else might have set those encodings to different values.GNote that it isn't thread-safe and has a global effect on your program.<On Windows, this function does (and should) not do anything. ödarcsisUTF8K checks if an encoding is UTF-8 (or ascii, since it is a subset of UTF-8). édarcshandle to write email todarcsFromdarcsTodarcsSubjectdarcsCCdarcsbody ėdarcsfromdarcstodarcssubjectdarcsccdarcs send commanddarcs(content,bundle)darcsbody ć ä å ę ē č é ź ė ģ ķ ī ļ š ń ņ ó ō õ ö č é ė ģ ī ļ ķ ę ē š ń ź ć ä å ņ ó ō õ ö”None"#&',.1248=>?HIMPSUVX_k LŪ ÷darcs ÷ opts patch prints patch4 in accordance with the flags in opts, ie, whether  --verbose or  --summary" were passed at the command-line. ųdarcs ų flags patch returns a  % representing the right way to show patch given the list flags! of flags darcs was invoked with. żdarcs ż@ prints a patch, together with its context, on standard output. ÷ ų ł ś ū ü ż ż ū ü ÷ ś ų ł¢None"#&',.1248=>?HIMPSUVX_k N ž ’       ž ’      £None"#&',.1248=>?HIMPSUVX_k Yń darcsA  W is a context together with some patches. The context consists of unavailable patches. darcs Interpret a   in the context of a  )?. This means we match up a possible tag in the context of the  +. This fails if the tag couldn't be found.ädarcsŸCreate a b16 encoded SHA1 of a given a FL of named patches. This allows us to ensure that the patches in a received bundle have not been modified in transit.ådarcs-Interpret a context file in the context of a  )R. This means we match up a possible tag. This fails if the tag couldn't be found. darcsMinimize the context of an Ō' of patches to be packed into a bundle.ędarcs$Decode gpg clearsigned file content.      ¤None"#&',.1248=>?HIMPSUVX_k –ę darcs—revertTentativeChanges swaps the tentative and "real" hashed inventory files, and then updates the tentative pristine with the "real" inventory hash. darcs’—finalizeTentativeChanges trys to atomically swap the tentative inventory/pristine pointers with the "real" pointers; it first re-reads the inventory to optimize it, presumably to take account of any new tags, and then writes out the new tentative inventory, and finally does the atomic swap. In general, we can't clean the pristine cache at the same time, since a simultaneous get might be in progress.ēdarcsfAdd (append) a patch to a specific inventory file. | Warning: this allows to add any arbitrary patch! darcs|Add (append) a patch to the tentative inventory. | Warning: this allows to add any arbitrary patch! Used by convert import.čdarcsxwriteHashFile takes a Doc and writes it as a hash-named file, returning the filename that the contents were written to. darcs-readRepo returns the "current" repo patchset. darcs-readRepo returns the tentative repo patchset.édarcs5readRepoUsingSpecificInventory uses the inventory at invPath to read the repository repo.źdarcsRead a  )i from the repository (assumed to be located at the current working directory) by following the chain of Ī%s, starting with the given one. The Ą| parameter is used to locate patches and parent inventories, since not all of them need be present inside the current repo.ėdarcseRead an inventory from a file. Fails with an error message if file is not there or cannot be parsed. darcsyCopy the hashed inventory from the given location to the given repository, possibly using the given remote darcs binary. darcswwriteAndReadPatch makes a patch lazy, by writing it out to disk (thus forcing it), and then re-reads the patch lazily. darcswriteTentativeInventory writes patchSet as the tentative inventory. darcsÖwriteHashIfNecessary writes the patch and returns the resulting info/hash, if it has not already been written. If it has been written, we have the hash in the PatchInfoAnd, so we extract and return the info/hash.ģdarcs@Attempt to remove an FL of patches from the tentative inventory.=Precondition: it must be possible to remove the patches, i.e.!the patches are in the repository'any necessary commutations will succeed darcsÆAtomically copy the tentative state to the recorded state, thereby committing the tentative changes that were made so far. This includes inventories, pending, and the index. !darcsÉSlightly confusingly named: as well as throwing away any tentative changes, revertRepositoryChanges also re-initialises the tentative state. It's therefore used before makign any changes to the repo. "darcsWrites out a fresh copy of the inventory that minimizes the amount of inventory that need be downloaded when people pull from the repository.’£Specifically, it breaks up the inventory on the most recent tag. This speeds up most commands when run remotely, both because a smaller file needs to be transfered (only the most recent inventory). It also gives a guarantee that all the patches prior to a given tag are included in that tag, so less commutation and history traversal is needed. This latter issue can become very important in large repositories. #darcsERead inventories and patches from a repository and return them as a  )4. Note that patches and inventories are read lazily. $darcs’&XOR of all hashes of the patches' metadata. It enables to quickly see whether two repositories have the same patches, independently of their order. It relies on the assumption that the same patch cannot be present twice in a repository. This checksum is not cryptographically secure, see  +http://robotics.stanford.edu/~xb/crypto06b/ . %darcsAUpgrade a possible old-style rebase in progress to the new style.                   ! " # $ %  !   #            "     $ %„None"#&',.1248=>?HIMPSUVX_k ˜¬ ' ( ) * + , - , - + ' ( ) *¦GPL-2None"#&',.1248=>?HIMPSUVX_k œŗķdarcs Similar to | (ī Ł)H, exepts it stops execution if file it's going to fetch already exists. 1darcsACreate packs from the current recorded version of the repository. . / 0 1 0 / . 1§None"#&',.1248=>?HIMPSUVX_k ą 2 3 2 3ØNone"#&',.1248=>?HIMPSUVX_k ”‰ 5darcslCreate a new pristine and working tree in the current working directory, corresponding to the state of the  ) returned by getOnePatchSet for the same  ‰. 5 6 5 6©None"#&',.1248=>?HIMPSUVX_k §± 7darcsA  7³ is a general way of associating an identity with an underlying (presumably unnamed) primitive type. This is required, for example, for V3 patches. Normally the members of the name€ type will be generated in some way when a patch is initially created, to guarantee global unqiueness across all repositories. 7 8 : 9 7 8 : 9ŖNone"#%&',.1248=>?HIMPSUVX_gk Ŗ¤ VdarcsA handy synonym for ļ. WdarcsA handy synonym for š. Sdarcseffectdarcs conflictsdarcsidentity Q R S T U V W Q R S U T V W V  W «None"#&',.1248=>?HIMPSUVX_k āūńdarcs A single ń in the conflict graph. The ņ. are those that we know are in conflict with ó.ōdarcs‡Find the set of vertices of the conflict graph by searching the history for unresolved conflicts. The history is split into an initial Ń) of patches (the context) and a trailing Ń! of patches we are interested in.’…We maintain the following state: a list of contexted patches, which will become the resulting vertices of the conflict graph; and a set of patch identifiers. The latter serves as markers for patches further back in the past that we have become interested in during our traversal. We maintain the invariant that this set never contains the identifier of any patch we have already traversed.Any conflictor in the trailing Ń’ is a possible candidate for a vertex; and likewise any other patch anywhere in the history which we marked as interesting. Every patch we encounter when traversing the history is unmarked by removing its identifier from the marker set. The traversal terminates when the trailing Ńƒ has been fully traversed and the marker set is empty; that is, when there are no more patches to encounter that might interest us.’iIf we enounter a candidate, we try to commute it to the head; if that succeeds, then its commuted version must be a conflictor. (Either it was a conflictor to begin with, in which case it remains one; or it is a patch that a later conflictor conflicted with, and that means it must itself become conflicted when commuted to the head.) We then add the contexted patch that the conflictor represents to the result. We also mark any patch that the candidate conflicts with as interesting by adding its identifier to the marker set. In order to maintain our invariant, we must extract the set of conflicts from the patch in its uncommuted formd. (If we took them from the commuted version, then we might mark patches that we already traversed.)}Candidate patches that cannot be commuted to the head are ignored. We do this uniformly for every candidate, whether it is a  S or a  R’. The rationale for this is that a patch that some other patch depends on is either part of a conflict that has been resolved; or else it would be subsumed by another patch in the same component of the conflict graph that depends on it and therefore already has it in its context.²The last point is a bit subtle. RepoPatchV1 explicitly removes any vertex from the graph that another vertex depends on (the function there has the beautiful and expressive name  getSupersi;-). By uniformly ignoring any patch we cannot commute to the head we achieve the same result implicitly.õdarcs Note that :G also regards dependent contexted prims as "conflicting". That is, if q depends on p, then:'ctxNoConflict' ('ctx' p) ('ctxAdd' p ('ctx' q) == 'False'gThis is what we need here, too, in order to avoid conflicts between the separately mangled components.ödarcsHDetermine the conflict graph from a set of contexted prims. This calls õ< for every pair of elements and from that builds a list of ńs repesenting this graph.~TODO: optimize this to calculate only one triangle of the adjacency matrix, then complete the graph by adding inverted edges.÷darcs’DThe input is a list of nodes with no duplicates representing a connected component of the conflict graph. The list contains an element for each node in the graph, but the conflicts (edges) may refer to non-nodes. The output is a list of the maximal independent sets of the conflict graph: each one can be merged cleanly.¬None"#&',.1248=>?HIMPSUVX_k ź­ tdarcsSigned patch identity. The ©% hash of the non-inverted meta data (§ ) plus an <G for the sequence number within the named patch, starting with 1. The <} gets inverted together with the patch and must never be 0 else we could not distinguish between the patch and its inverse. udarcsQThis should only be used for testing, as it exposes the internal structure of a  t. wdarcs$Create an infinite list of positive  ts. s t u v w x y s t x w y u v­None"#&',.1248=>?HIMPSUVX_k ėė  ®None"#&',.1248=>?HIMPSUVX_k ļ~ųdarcsgSet the given paths executable if they are scripts. A script is any file that starts with the bytes #!/. This is used for --set-scripts-executable.  ‚ ƒ  ‚ ƒÆNone"#&',.1248=>?HIMPSUVX_k šœ „ … † ‡ „ … † ‡°GPL-2None"#&',.1248=>?HIMPSUVX_k ˆ ‹darcs:The status of a given directory: is it a darcs repository? Œdarcs'looks like a repository with some error darcs safest guess darcs5Tries to identify the repository in a given directory darcs*identifyRepository identifies the repo at urlI. Warning: you have to know what kind of patches are found in that repo. ‘darcsidentifyRepositoryFor repo url& identifies (and returns) the repo at urlE, but fails if it is not compatible for reading from and writing to. ”darcs’|hunt upwards for the darcs repository This keeps changing up one parent directory, testing at each step if the current directory is a repository or not. $ The result is: Nothing, if no repository found Just (Left errorMessage), if bad repository found Just (Right ()), if good repository found. WARNING this changes the current directory for good if matchFn succeeds —darcsfindAllReposInDir topDir) returns all paths to repositories under topDir. ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – —   ‘ ‹ Œ  Ž ˆ ‰ Š – ’ • “ ” —±None"#&',.1248=>?HIMPSUVX_k #ćłdarcsWThis type allows us to check multiple patch types against the constraints required by  žśdarcskThis type allows us to check multiple patch types against the constraints required by most repository jobsūdarcsaThis is just an internal type to Darcs.Repository.Job for calling runJob in a strongly-typed way šdarcsA RepoJobĒ wraps up an action to be performed with a repository. Because repositories can contain different types of patches, such actions typically need to be polymorphic in the kind of patch they work on. RepoJobO is used to wrap up the polymorphism, and the various functions that act on a RepoJobZ are responsible for instantiating the underlying action with the appropriate patch type. ›darcsThe most common RepoJobS; the underlying action can accept any patch type that a darcs repository may use. œdarcs(A job that only works on darcs 1 patches darcs(A job that only works on darcs 2 patches ždarcs8A job that works on any repository where the patch type p has ł p = Ž.TThis was added to support darcsden, which inspects the internals of V1 prim patches.QIn future this should be replaced with a more abstract inspection API as part of  PrimPatch. ¤darcsFapply a given RepoJob to a repository in the current working directory „darcs4apply a given RepoJob to a repository in a given url ¦darcs¹Apply a given RepoJob to a repository in the current working directory. However, before doing the job, take the repo lock and initializes a repo transaction, unless this is a dry-run. §darcs]run a lock-taking job in an old-fashion repository. only used by `darcs optimize upgrade`. Ødarcs’TApply a given RepoJob to a repository in the current working directory, taking a lock. If lock not takeable, do nothing. If old-fashioned repository, do nothing. The job must not touch pending or pending.tentative, because there is no call to revertRepositoryChanges. This entry point is currently only used for attemptCreatePatchIndex. ©darcsIf the  * of the given repo indicates that we have ), then F& the repo with the refined type, else ET. NB The amount of types we have to import to make this simple check is ridiculous! ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤ „ ¦ § Ø © š › œ  ž Ÿ   ” ¢ ˜ ™ ¦ § Ø ¤ „ © £²None"#$&',.1248=>?HIMPSUVX_k 4 üdarcs working treeżdarcsrecorded and pendingždarcsunrecorded paths ¬darcs’Return all files available under the original working directory regardless of their repo state. Subdirectories get a separator (slash) appended. ­darcs Return all files available under the original working directory that are unknown to darcs but could be added. Subdirectories get a separator (slash) appended. ®darcsØReturn all files available under the original working directory that are known to darcs (either recorded or pending). Subdirectories get a separator (slash) appended. Ædarcs¦Return all files available under the original working directory that are modified (relative to the recorded state). Subdirectories get a separator (slash) appended. °darcs-Return the available prefs of the given kind. ±darcsReturn an empty list.’darcsdTurn an action that creates all possible completions into one that removes already given arguments. ¬ ­ ® Æ ° ± ¬ ® ­ Æ ± °³None"#&',.1248=>?HIMPSUVX_k 5; ² ³ “ µ ¶ · “ µ ¶ ² ³ ·“None"#&',.1248=>?HIMPSUVX_k 9Edarcs\This function fetches all patches that the given repository has with fetchFileUsingCache. ¹darcsJReplace the existing pristine with a new one (loaded up in a Tree object). ø ¹ ø ¹None"#&',.1248=>?HIMPSUVX_k :[\ĄĮĀĆÄÅĘČĒÉŹĖĢĶĪĻŅÓęö ś ) +           ' 1 B D E O p q r s v w x z { |    ! " # 2 3  ‚ ƒ ‡ ˆ ‰ Š  ‘ ’ “ • – š › œ  ž Ÿ   ” ¢ £ ¤ „ ¦ Ø ² ³ “ µ ¶ ø ¹\         ĢĶĪĻĄĮĀĆÄÅĘČĒÉŹĖÓŅę š › œ  ž Ÿ   ” ¢  ‘ ˆ ‰ Š E ¦ Ø ¤ „ £ – ’ • “ ¹ #ö | {   O  1 2 3 ! “ µ ¶ ² ³ ø  D B " ' ) + ś ‚ ƒ ‡  r s p q z v x wµNone"#&',.1248=>?HIMPSUVX_k „0 ŗdarcs¬The type of the answers to a "shall I [wiggle] that [foo]?" question They are found in a [[KeyPress]] bunch, each list representing a set of answers which belong together ædarcs<The dynamic parameters for interactive selection of patches. Įdarcstotal number of patches Ādarcsnumber of already-seen patches Ćdarcsthe patches we offer Ädarcsthe user's choices Ådarcs.All the static settings for selecting patches.darcs7The type of the function we use to filter patches when --match is given. ĻdarcsāWhen asking about patches, we either ask about them in oldest-first or newest first (with respect to the current ordering of the repository), and we either want an initial segment or a final segment of the poset of patches. ŅW: ask for an initial segment, first patches first (default for all pull-like commands) Ó‚: ask for an initial segment, last patches first (used to ask about dependencies in record, and for pull-like commands with the  --reverse flag). щ: ask for a final segment, last patches first. (default for unpull-like commands, except for selecting *primitive* patches in rollback) Š‹: ask for a final segment, first patches first. (used for selecting primitive patches in rollback, and for unpull-like commands with the  --reverse flag«IOW: First = initial segment Last = final segment Reversed = start with the newest patch instead of oldest As usual, terminology is not, ahem, very intuitive.darcsA  Ļ is ` if the segment of patches we ask for is at the opposite end of where we start to present them.darcsA  Ļ\ is reversed if the order in which patches are presented is latest (or newest) patch first. ŌdarcsA  Å for selecting Prim patches. ÕdarcsA  Å for selecting full ( ¢ ) patches Ödarcs A generic  Å.darcsFor commands without --match,  matches all patchesdarcs3 selects patches according to the given match flags ×darcsRun a PatchSelection action in the given  Å0, without assuming that patches are invertible. ŲdarcsRun a PatchSelection action in the given  Å#, assuming patches are invertible. ŁdarcsThe equivalent of  × for the  darcs log command Śdarcs3Generates the help for a set of basic and advanced  ŗ groups. ŪdarcsThe keys used by a list of keyPress groups. ÜdarcsKThe function for selecting a patch to amend record. Read at your own risks.darcsÓThis ensures that the selected patch commutes freely with the skipped patches, including pending and also that the skipped sequences has an ending context that matches the recorded state, z, of the repository.darcs"Runs a function on the underlying  PatchChoices objectdarcs justDone n notes that n! patches have just been processed darcs)The actual interactive selection process. Ždarcs Returns a µ4 version of the patch we are asking the user about. darcs6Returns the patches we have yet to ask the user about. darcsModify the underlying  PatchChoices by some function ßdarcsreturns Just f if the  Ž only modifies f, Nothing otherwise. ądarcs decide True selects the current patch, and  decide False deselects it. įdarcslike  ą, but for all patches touching file darcsUndecide the current patch. ādarcsFocus the next patch. ćdarcsFocus the previous patch. darcsTSplit the current patch (presumably a hunk), and add the replace it with its parts.darcsŹPrint the list of the selected patches. We currently choose to display them in "commuted" form, that is, in the order in which they have been selected and with deselected patches moved out of the way.darcsSkips all remaining patches.darcs0The singular form of the noun for items of type p.darcs.The plural form of the noun for items of type p. ędarcs$The question to ask about one patch. ēdarcs4Asks the user about one patch, returns their answer.darcs,Ask the user what to do with the next patch.darcs9Shows the current patch as it should be seen by the user.darcsThe interactive part of  darcs changes čdarcs.Skips patches we should not ask the user aboutdarcsIThe action bound to space, depending on the current status of the patch.darcsFrom an ŃX of patches select the identities of those that are not depended upon by later patches.0 ŗ » ¼ ½ ¾ æ Ą Į Ā Ć Ä Å Ę Ē Č É Ī Ģ Ė Ķ Ź Ļ Š Ņ Ń Ó Ō Õ Ö × Ų Ł Ś Ū Ü Ż Ž ß ą į ā ć ä å ę ē č é0 Ļ Š Ņ Ń Ó Ł Ü × Ų Ō Ö Õ Å Ę Ē Č É Ī Ģ Ė Ķ Ź ¾ æ Ą Į Ā Ć Ä Ż Ž č ā ć ä ą į å ß ē ę ŗ » ¼ ½ Ū Ś é¶None"#&',.1248=>?HIMPSUVX_k ¦Q ģdarcsYspecify whether to ask about dependencies with respect to a particular repository, or not ļdarcsZTransformer for interactions with a hijack warning state that we need to thread through šdarcshOptions for how to deal with the situation where we are somehow modifying a patch that is not our own ńdarcsaccept all hijack requests ņdarcs0prompt once, accepting subsequent hijacks if yes ódarcs always prompt ōdarcs3Get the patch name and long description from one of/the configuration (flags, defaults, hard-coded)an existing log filestdin (e.g. a pipe) a text editorFIt ensures the patch name is not empty nor starts with the prefix TAG.^The last result component is a possible path to a temporary file that should be removed later. õdarcs5Run a job that involves a hijack confirmation prompt.See  ņ for initial values ödarcsgUpdate the metadata for a patch. This potentially involves a bit of interactivity, so we may return Nothing= if there is cause to abort what we're doing along the way ÷darcs getAuthorX tries to return the updated author for the patch. There are two different scenarios:Z[explicit] Either we want to override the patch author, be it by prompting the user (select.) or having them pass it in from the UI ( new_author), or’[implicit] We want to keep the original author, in which case we also double-check that we are not inadvertently "hijacking" somebody else's patch (if the patch author is not the same as the repository author, we give them a chance to abort the whole operation) ōdarcspatchname optiondarcs pipe optiondarcslogfile optiondarcsaskLongComment optiondarcs4possibly an existing patch name and long descriptiondarcschanges to recorddarcshpatch name, long description and possibly the path to the temporary file that should be removed later ödarcsverb: command name darcsšpatch to edit, must be conflict-free as conflicts can't be preserved when changing the identity of a patch. If necessary this can be achieved by calling fmapFL_Named effect on an Named p, first, but some callers might already have Named (PrimOf p) available. darcsnew primitives to add ÷darcsverb: command namedarcsselect: prompt for new auhordarcsnew author: explict new authordarcspatch to update ģ ķ ī ļ š ń ņ ó ō õ ö ÷ ō ÷ ö ģ ķ ī ļ š ń ņ ó õ·None"#&',.1248=>?HIMPSUVX_k ®“ üdarcsA  ü+ represents a command like add, record etc.&darcs|Set the DARCS_PATCHES and DARCS_PATCHES_XML environment variables with info about the given patches, for use in post-hooks.'darcswSet the DARCS_FILES environment variable to the files touched by the given patch, one per line, for use in post-hooks.darcs}Set some environment variable to the given value, unless said value is longer than 10K characters, in which case do nothing.5 ų ł ś ū ü ż ž ’     !"#$%&'()*+,5 ü ż ž ’     ų ł ś ū! #$"%&'()*+,øNone"#&',.1248=>?HIMPSUVX_k ±j-./0101/-.¹None"#&',.1248=>?HIMPSUVX_k Į84darcs4 action flags patchesE prints a string representing the action that would be taken if the  --dry-runG option had not been passed to darcs. Then darcs exits successfully. action. is the name of the action being taken, like "push" flags0 is the list of flags which were sent to darcs patches7 is the sequence of patches which would be touched by action.5darcs’^Given a repository and two common command options, classify the given list of paths according to whether they exist in the pristine or working tree. Paths which are neither in working nor pristine are reported and dropped. The result is a pair of path lists: those that exist only in the working tree, and those that exist in pristine or working.darcspatchFilename maps a patch description string to a safe (lowercased, spaces removed and ascii-only characters) patch filename.darcs>Get the union of the set of patches in each specified location 23456789:;<= 25346789;:<=ŗNone"#&',.1248=>?HIMPSUVX_k Åądarcs Runs the  ¾ codedarcsThe interactive part of darcs whatsnew?darcs An alias for >, with implicit -l (and thus implicit -sF) flags. We override the default description, to include these flags.>?>?»None"#&',.1248=>?HIMPSUVX_k Ęö@A@A¼None"#&',.1248=>?HIMPSUVX_k Ėdarcs genericObliterateCmd is the function that executes the "obliterate" and "unpull" commands. The first argument is the name under which the command is invoked (unpull or  obliterate).BCDBCD½None"#&',.1248=>?HIMPSUVX_k Ģ6EE¾None"#&',.1248=>?HIMPSUVX_k Õy darcsProgress of BisectdarcsDirection of Bisect trackdowndarcsBisect Patch Tree darcs2Functions defining a strategy for executing a test!darcs!test only the last recorded state"darcslinear search (with --linear)#darcs+exponential backoff search (with --backoff)$darcsbinary search (with --bisect)%darcs#Create Bisect PatchTree from the RL&darcsConvert PatchTree back to RL'darcsIterate the Patch Tree darcs test command(darcsnumber of patches to skipdarcspatches not yet skipped'darcs test commandFFæNone"#&',.1248=>?HIMPSUVX_k ևHHĄNone"#&',.1248=>?HIMPSUVX_k וIIĮNone"#&',.1248=>?HIMPSUVX_k Ų£JJĀNone"#&',.1248=>?HIMPSUVX_k Ł±KKĆNone"#&',.1248=>?HIMPSUVX_k ŚæLMLMÄNone"#&',.1248=>?HIMPSUVX_k ŪÕNNÅNone"#&',.1248=>?HIMPSUVX_k ÜėOOĘNone"#&',.1248=>?HIMPSUVX_k ŻłPPĒNone"#&',.1248=>?HIMPSUVX_k ßQRSTURQUTSČNone"#&',.1248=>?HIMPSUVX_k ą5VVÉNone"#&',.1248=>?HIMPSUVX_k āŚ)darcs$A list of all valid preferences for _darcsprefsprefs.)darcs(name, one line description)WWŹNone"#&',.1248=>?HIMPSUVX_k ćčXXĖNone"#&',.1248=>?HIMPSUVX_k äžYYĢNone"#&',.1248=>?HIMPSUVX_k ī…*darcsŠGiven a set of characters and a string, returns true iff the string contains only characters from the set. A set beginning with a caret (^%) is treated as a complementary set.+darcsThis function checks for  --token-chars’ on the command-line. If found, it validates the argument and returns it, without the surrounding square brackets. Otherwise, it returns either @ or , as explained in -.…Note: Limitations in the current replace patch file format prevents tokens and token-char specifiers from containing any whitespace.@ZZ@ĶNone"#&',.1248=>?HIMPSUVX_k š”\darcs8check is an alias for repair, with implicit DryRun flag.[\[\ĪNone"#&',.1248=>?HIMPSUVX_k ū¹.darcs‡makeRemovePatch builds a list of patches to remove the given filepaths. This function does not recursively process directories. The  Recursivee flag should be handled by the caller by adding all offspring of a directory to the files list./darcsPTakes a file path and returns the FL of patches to remove that, wrapped in a ­ . Returns Ey in case the path cannot be removed (if it is not tracked, or if it's a directory and it's not tracked). The three  ž arguments are the recorded state, the unrecorded state excluding the removal of this file, and the unrecorded state including the removal of this file.]^_]^_ĻNone"#&',.1248=>?HIMPSUVX_k ž«adarcscommit is an alias for record0darcsGCheck user specified patch name is not accidentally a command line flag`a`aŠNone"#&',.1248=>?HIMPSUVX_k ’ÉbbŃNone"#&',.1248=>?HIMPSUVX_k…1darcs*known to darcs, but absent in working tree2darcsTakes two filenames (as Subpathž), and tries to move the first into/onto the second. Needs to guess what that means: renaming or moving into a directory, and whether it is a post-hoc move.3darcstree of the working directorydarcs$tree of recorded and pending changesdarcstree of recorded changescdcdŅNone"#&',.1248=>?HIMPSUVX_k4darcsA set of repository paths. 5g means every path in the repo, it usually originates from an empty list of path arguments. The list of ³4s is always kept in sorted order with no duplicates.EIt uses lists because the number of elements is expected to be small.6darcs6 is isomorphic to >! but with the opposite semantics.About the name: I like the data constructor names, they are pretty suggestive. The data type name is up for grabs; a possible alternative is AtMost.7darcs,This is mostly for conversion to legacy APIs8darcsIntersection of two 4s9darcs Convert a 4 to a  L. Uses the English module to generate a nicely readable list of file names.hhÓNone"#&',.1248=>?HIMPSUVX_kõ:darcs’ŽTake a list of filenames and patches and produce a list of patches that actually touch the given files with a list of touched file names, a list of original-to-current filepath mappings, indicating the original names of the affected files and possibly an error. Additionaly, the function takes a "depth limit" -- maxcount, that could be Nothing (return everything) or "Just n" -- returns at most n patches touching the file (starting from the beginning of the patch list).sdarcschanges is an alias for log:darcsmaxcountdarcspathsdarcspatchesopqrssorpqŌNone"#&',.1248=>?HIMPSUVX_k+tutuÕNone"#&',.1248=>?HIMPSUVX_k{vdarcsGThis is designed for use in an atexit handler, e.g. in Darcs.RunCommandvwwvÖ2003 David RoundyGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_k&;darcsLThis function performs the actual distribution action itself. NB - it does not_ perform the pre-dist, that should already have completed successfully before this is invoked.zdarcs Flags/optionsdarcsThe path to the repositorydarcs,An action to perform on the archive contentsxyzxyz×None"#&',.1248=>?HIMPSUVX_k+“<darcs”Returns the command we should use for diff as a tuple (command, arguments). This will either be whatever the user specified via --diff-command or the default  äk. Note that this potentially involves parsing the user's diff-command, hence the possibility for failure.{{ŲNone"#&',.1248=>?HIMPSUVX_k,©||ŁNone"#&',.1248=>?HIMPSUVX_k-恁ŚNone"#&',.1248=>?HIMPSUVX_k3œ=darcs<Similarly for when the function changes all three witnesses.>darcsNeed this to make éX work with a function that changes the last two (identical) witnesses at the same time.?darcsuThis part of the help is split out because it is used twice: in the help string, and in the prompt for confirmation.‚‚ŪNone"#&',.1248=>?HIMPSUVX_k4ŖƒƒÜNone"#&',.1248=>?HIMPSUVX_k9‰@darcs;Make sure we do not overwrite an existing remote directory.AdarcsThe „¤ command takes --to-patch and --to-match as arguments, but internally wants to handle them as if they were --patch and --match. This function does the conversion.„…†‡ˆ‰…†„ˆ‡‰ŻNone"#&',.1248=>?HIMPSUVX_k;·BdarcsPOST the patch via HTTPCdarcssend patch via emailŠŠŽNone"#&',.1248=>?HIMPSUVX_k<Ķ‹‹ßNone"#&',.1248=>?HIMPSUVX_k=ćŒŒą2004, 2007 David RoundyGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_k@ ŽŽį2002-2004 David RoundyGPLdarcs-devel@darcs.net experimentalportableNone"#&',.1248=>?HIMPSUVX_kB-āNone"#&',.1248=>?HIMPSUVX_kDt’darcs*This class is a hack to abstract over pullapply and rebase pullapply. ‘’“•”–—˜™ ’“•”–—‘˜™ćNone"#&',.1248=>?HIMPSUVX_kEŅ›œžœ›žäNone"#&',.1248=>?HIMPSUVX_kGŸ ”Ÿ ”åNone"#&',.1248=>?HIMPSUVX_kHØDdarcschanges is an alias for log¢¢ęNone"#&',.1248=>?HIMPSUVX_kL ¤darcs“The commands that darcs knows about (e.g. whatsnew, record), organized into thematic groups. Note that hidden commands are also listed here.¤¤ēNone"#&',.1248=>?HIMPSUVX_k|ū Edarcs#A finite map from long switches to ¾s.Fdarcs:Result of parsing a defaults line: switch and argument(s).Gdarcs;Name of a normal command, or name of super and sub command.„darcs-Apply defaults from all sources to a list of šs (e.g. from the command line), given the command (and possibly super command) name, and a list of all options for the command.Sources for defaults are"the builtin (hard-coded) defaults,2the defaults file in the user's configuration, and,the defaults file in the current repository.Note that the pseudo command ALLt is allowed in defaults files to specify that an option should be the default for all commands to which it applies.’”The order of precedence for conflicting options (i.e. those belonging to same group of mutually exclusive options) is from less specific to more specific. In other words, options from the command line override all defaults, per-repo defaults override per-user defaults, which in turn override the built-in defaults. Inside the options from a defaults file, options for the given command override options for the ALL pseudo command.DConflicting options at the same level of precedence are not allowed.ĶErrors encountered during processing of command line or defaults flags are formatted and added as (separate) strings to the list of error messages that are returned together with the resulting flag list.HdarcsMake a G; from a possible super command name and a sub command name.IdarcsTurn a G into a R. For a J% concatenate with a space in between.Kdarcs@Parse a list of lines from a defaults file, returning a list of šH, given the current working directory, the command name, and a list of  DarcsOption for the command.RIn the result, defaults for the given command come first, then come defaults for ALL commands..We check that matching options actually exist.Wlines matching the command name: the option must exist in the command's option map.lines matching ALLC: there must be at least *some* darcs command with that option.LdarcsExtract F5s from lines of a defaults file that match the given G. The syntax is & supercmd subcmd [--]switch [args...] ,for (super) commands with a sub command, and # cmd default [--]default [args...] #for normal commands (including the ALL pseudo command).MdarcsūSearch an option list for a switch. If found, apply the flag constructor from the option to the arg, if any. The first parameter is the current working directory, which, depending on the option type, may be needed to create a flag from an argument.EFails if (default has argument /= corresponding option has argument).Ndarcs0Get all the longSwitches from a list of options.Odarcs Build an E from a list of  DarcsOptions.PdarcsNList of option switches of all commands (except help but that has no options).„darcsmaybe name of super commanddarcsthe darcs commanddarcsLthe original working directory, i.e. the one from which darcs was invokeddarcslines from user defaultsdarcslines from repo defaultsdarcsflags from command line„„čNone"#&',.1248=>?HIMPSUVX_k…ŽQdarcsŹReturns the working directory for the posthook. For most commands, the first parameter is returned. For the 'get' command, the path of the newly created repository is returned if it is not an ssh url.RdarcsxChecks if the number of extra arguments matches the number of extra arguments supported by the command as specified in Œ. Extra arguments are arguments that follow the command but aren't considered a flag. In `darcs push xyz`, xyz would be an extra argument.¦§¦§None"#&',.1248=>?HIMPSUVX_k†¤STUéNone"#&',.1248=>?HIMPSUVX_k“4VdarcsStarting from a list of Ts, unwrap one level to get a list of command names together with their subcommands.WdarcsGiven a list of (normal) arguments to the help command, produce a list of possible completions for the next (normal) argument.Xdarcs?Help on each environment variable in which Darcs is interested.YdarcsóThis function is responsible for emitting a darcs "man-page", a reference document used widely on Unix-like systems. Manpages are primarily used as a quick reference, or "memory jogger", so the output should be terser than the user manual.ŸBefore modifying the output, please be sure to read the man(7) and man-pages(7) manpages, as these respectively describe the relevant syntax and conventions.Ø©Ŗ«Ø«Ŗ©Zō       !"#$%&'()*+,-./01234567ļ89:;<3=>?@ABCDEFGHIHJHKHLHMNOPQRHSTHUHVWXHYQZQ[H\W]W^H_H`Haīb:cdefghijklmklnkloklpkqrkqsktuktvkwxDyDzD{D|}~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š‹ŒŽ‘’B“B”B•B–B—B˜B™BšB›BœBBžBŸB B”B¢B£B¤B„BņB¦§Ø§©§Ŗ§«i¬W­:®:Æ:°±²3³3“3µ3¶3·3ø3¹3ŗ3»3¼3½3¾3æ3Ą3Į3Ā3Ć3Ä3Å3Ę3Ē3Č3É3Ź3Ė3Ģ3Ķ3Ī3Ļ3ŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęē?č?é?ź?ė?ģ?ķ?ī?ļšńņóōõö÷ųłśrūüżž’        !"#$%&'()*+,-./0123423523623723823923:23;23<23=23>23?23@23A23B23CDDEFGHHIJKLMNOPQRSTUVW X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t uvwxxyz{||}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š››œœžŸ ””¢£¤„¦¦§Ø©Ŗ«¬­®Æ°±²³“µ¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõöņ÷ųłņśūüżž’      !"#$$%&'()*+,-./01234567889:;;<=>?@ABCCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefegghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ”¢£¤„¦§Ø©Ŗ«¬­­®Æ°±²³“µ¶·ø¹ŗ»¼½¾ææĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŲŁŚŪÜŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž’                          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j!k!k!l!m!n!n!o!p!q!r!s!t!u!v!w!x!y!z!{!|"}"~""€##‚#ƒ#„#…#†#‡#ˆ$‰$Š$‹$Œ$$Ž$$$‘$’$“%”%”%•%–%—%˜%™%š%›%œ%%ž%Ÿ% %”%¢&£&£&¤&„&¦&§&Ø&©&Ŗ&«&¬&­'®'®'Æ'°(±(²(³(“(µ(¶(·(ø(¹)ŗ)»)¼)½)¾)æ)Ą)Ą)Į)Į)Ā)Ā)Ć)Ä)Å)Ę)Ē)Č)É)Ź)Ė)Ģ)Ķ)Ī)Ļ)Š)Ń)Ņ*Ó*Ó*Ō*Ō*Õ*Õ*Ö*Ö*×*Ų*Ł*Ś*Ū*Ü*Ż*Ż*Ž*ß*ą*į*ā*ć*ä*å*ę*ē*č*é*ź*ė*ģ*ķ*ī*ļ*š*ń*ņ*ó*ō*õ*ö*÷*ų*ł*ś*ū*ü*ż*ž*’********** * * * * *****************+++ +!+"+#+$+%+&+'+(+)+*++,,,-,.,/,0,1-2-3-4-5-6-7-8-9.:.;.<.=.>.?.@.A/B/C/D/E0F0G0H0I0J0K0L0M0N0O0P0Q0R0S1T1U1V1W1X1Y1Z1[2\2]2^2_2`2a2b2L2c2d2e2f2g2h2i2j2k2l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}3~34€44‚5ƒ5„5…5†5‡5ˆ5‰5Š5‹5Œ55Ž66‘6’6“6”6•6–6—7˜7™7š7›7œ77ž7Ÿ7 7”7¢8£8¤8„8¦8§8§8Ø8©8Ŗ8«8¬8­8®8Æ8°8±8²8³8“9µ9µ9¶9·9ø9ö9¹9ŗ9»9¼9½9¾9æ9Ą9Į9Ā9Ć9Ä9Å9Ę9Ē9Č9É9Ź9Ė9Ģ9.9Ķ9Ī9Ļ9Š9Ń9Ņ9Ó9Ō9Õ9Ö9×9Ų9Ł9Ś9Ū9Ü9Ż9Ž9ß9ą9į9ā9ć9ä9å9ę9ē9č9é9ź9ė9ģ9ķ9ī9ļ9š9ń9ņ9ó9ō9õ9ö9÷9ų9ł9ś9ū9ü9ż9ž9’999999::ō:ó::: : : : :˜: :::::::::::::::::::: :!:":#:$:%:&:':(:):*:+:,:-:.:/:0:1:2:3:4;5;‚;6;7;8;9;:;;;<;ƒ;=;>;?;@;A;B;C;D;E;F;G;H;I;J;K;L;M<N<O<P<P<Q<R<S<T<U=V=W=X=Y=Z=[=\=]=^=_=`>a>b>c>d>e>f>g>h?i?j@k@l@m@n@o@p@q@r@s@t@u@v@wAxAyAzA{B|B}B~BB€BB‚BƒB„B…B†B‡BˆB‰BŠB‹BŒBBŽBBB‘B’B“B”B•B–C—C˜C™CšC›CœCCžCŸD D”D¢D£D¤D„D¦D%D§DØD©DŖD«D¬D­D®DÆD°D±D²D³D“DµD¶E·EøE·E¹EŗE»E¼E½E¾EæEĄEĮEĀEĆEÄEÅEĘEĒEČEÉEŹEĖEĢEĶEĪEĻEŠEŃEŅEÓEŌEÕEÖE×EŲEŁEŚEŪEÜEŻEŽEßEąEįEāEćEäEåFźFFęFēFčFéFźFėFģFķFDFFFīFļFšFrFqFpFńFņFóFōFõFöF÷FųFłFśFūFüFżFžF’FFFFFFFFFF F F F F FFFFFFFFFFFFFeFfFFFFFFFVFXFPFRFSFUF F!F"F#F$F%F&F'F(F)F*F+F,F-F.F/F0F1F2F3F4F5F0F6F1F7F8F9F:F;F<F=F>F?F@FAFBFCF*FDFEFFFGFHFIFJFKFLFMFNF-FOFPFQFRFSFTFUFVFWFXFYFZF[F\F]F^F_F`FaFbF\F=F?F@FBFcFGFdFeFfFgFhFiFjFkFlFmFnFoFpFqFrFsFtFuFvFwFxFyFzF{F|F}FYF~FF€FF‚FƒF„F…F†F‡FˆF‰FŠF‹FŒFFŽFFF‘F’G“G”G•G–G—G˜G™GķGšG›GœGGžGŸG G”G¢G£G¤G„G¦G§GØG©GŖG«G¬G­G®GÆG°H±I²I³I“IµJ¶J·JøJ¹JŗJ»J¼J½J¾JæJĄJĮJĀJĆJÄJÅJĘJĒJČJÉJŹJĖJĢJĶJĪJĻJŠJŃJŅJÓJŌJÕKÖK×KŲKŁKŚKŪKÜKŻKŽKßKąKįKāKćLäLäLåLęLēLčL¾LLéLźLėLģLģLķLīLļLšLńLņLóLōMõMöM÷MųMłNśNūNüNżNžN’NNNNNNNNNN N N N N NNNNNNNNNNNNNNNOOOO O!O"O#O$O%O&O'O(O(O)O*O+O,O-O.O/O0O1O2O3O4O5O6O7O8O9P:P;P<P=P>P?P@PAPBPCPDPEPFPGPHPIPJPKPLPMPNPOPPPQPRPSPTPUPVPWPXPYPZP[P\P]Q^Q_Q`QaQbQcQdQeQfQgQhRiRjRkRlSmSnSoSpSqSrSsStSuSvSwSxSySzS{S|T}T}T~TT€TT‚TƒT„T…T†T‡TˆT‰TŠT‹TŒTTŽTTT‘T’T“T”T•T–T—T˜T™TšT›TœTTžTŸT T”U¢U£U£U¤U„U¦U§UØU©UŖU«U¬U­U®UÆU°U±U²U³U“UµU¶U·UøU¹UŗU»U¼U½U¾UæUĄUĮUĀUĆUÄUÅVĘVĒVČVÉVŹVYVZVĖWĢWĶWĪWĻWŠWŃWŅWÓWŌWÕWÖW×W%WŲWŁWŚWŪWÜWŻWŽWßWąWįWāWćXäXåXęXęXēXčYéYźYėYģYķYīYļZšZńZņZóZōZõZöZ÷ZųZłZś[ū[ü[ż[ž[’[ [ł[ [ [ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ ] ] ]†] ]…] ] ] ] !] "^ #^ $^ %^ &^ '^ (^ )^ *^ +^ ,^ -^ .^ /^ 0^ 1^ 2^ 3^ 4^ 5^ 6^ 7^ 8^ 9^ :^ ;^ <^ =^ >^ ?^ @^ A^ B^ C^ D^ E^ F^ G^ H^ I^ J^ K^ L^ M^ N^ O^ P^ Q_ R_ S_ T_ U_ V_ W_ X_ Y_ Z_ [_ \_ ]_ ^_ __ `_ a_ b_ c_ d_ e_ f_ g_ h_ i_ j_ k_ l_ m_ n_ o_ p_ q` ra sb tc uc vc wc xc yc zc {d |d }d ~d d €d d ‚d ƒd „d …d †d ‡d ˆd ‰d Šd ‹d Œe e Žf f f ‘g ’h [h Xh “h ”h •h –h “h —h Xh ˜h ™h šh ›h œh gh ih jh kh lh mh yh xh h žh Ÿh  h {h fi ”i rj tk †k ‡l ’l m ¢m ¢m £m ¤m „m ¦m §m Øn ©n Ŗn «n ¬n ­n ®n Æn °n ±n ²n ³o “o µo ¶o ·o øo ¹o ŗo »o ¼o ½o ¾o æo Ąo Įo Āp Ćp Äq Åq Ęq Ēq Ēq Čq Éq Źq Ėq Ģq Ķq ĪrOr Ļr Šr Ńr Ņr Ór Ōr Õr Ör ×r Ųr Łr Śr Ūr Ür Żr Žr ßr ąr įr ār ćs äs vs ås ęs ēs čt ét źt ėt ģt t t ķt īt ‘u sv ļv šv ńv ņw ów ōw õw õw öw ÷w ųw łw św ūw üw żw žw ’w w/w w w w w w w w x x x x x x x x y y y y y y y y y y y y y y y y y y !y "y #y $y %y &y 'y (y )y *y +y ,y -y .y /y 0y 1y 2y 3y 4y 5z 6z 7z 8z 9z :z ;z <z =z >z ?z @z Az Bz Cz Dz Ez ˆz ‰z Šz ‹z Œ{ F| G| H} I} J~ K~ L~ M~ N~ O~ś~ P~ Q~ R~ S~ T~ U~ V~ W~ X~ Y~ Z~ [~ \~ ]~ ^~ _~ `~ a~ b~ c~ d~ e~ f~ g~ h~ i~ j~ k~ l~ m~ n~ o~ p~ q~ r~ s~ t~ u v w x y z { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹€ Œ€ € Ž€ € € ‘€ ’€ “€ ”€ •€ –€ —€ ˜€ ™€ š€ ›€ œ€ € ž Ÿ   ” ¢ £ ¤ „ ¦ § ؁ © Ŗ « ¬ ­ ® Ɓ ° ± ² ³ “ µ ¶ · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ɓ ā Ł ʁ Ē ȁ Ɂ Ź Ė Ģ Ķ Ī‚ Ļ‚ Ļ‚ Š‚ Š‚ т Ņ‚ ӂ Ō‚ Ղ ւ ׂ Ų‚ Ł‚ Ś‚ Ū‚ ܂ Ż‚ Ž‚ ߂ ą‚ į‚ āƒ ćƒ äƒ å„ ę„ ē„ č„ é„ ź„ ė„ ģ„ ķ„ ī„ ļ„ š„ ń„ ņ„ ó… ō… õ… ö… ÷… ų… ł… ś… ū… ü† ż‡ ž‡ ’‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ‡ ˆ ˆ ˆ ˆ ˆ ˆ ˆ ˆ ˆ ˆ ˆ ˆ !ˆ "ˆ #ˆ $ˆ %‰ [‰ [‰ &‰ ‰ č‰ å‰ ę‰ ē‰ ”‰ y‰ x‰ ‰ ‘‰ †‰ ‡‰ j‰ k‰ g‰ i‰ ‰ ‰ m‰ l‰ t‰ s‰ ’‰ {Š [Š [Š &Š Š čŠ åŠ ęŠ ēŠ ”Š yŠ xŠ Š ‘Š †Š ‡Š jŠ kŠ gŠ iŠ Š Š mŠ lŠ tŠ sŠ ’Š {‹ 'Œ (Œ )Œ )Œ *Œ +Œ ,Œ -Œ .Œ /Œ 0Œ 1Œ 2Œ 3Œ 4Œ 5Œ 6Œ 7Œ 8Œ 9Œ :Œ ;Œ <Œ =Œ >Œ ?Œ @Œ AŒ BŒ CŒ DŒ EŒ FŒ GŒ HŒ I J K L / M N O PŽ QŽ RŽ SŽ TŽ UŽ VŽ 1Ž 2Ž WŽ XŽ YŽ ZŽ [Ž \ ] ^ _ ` a b c d e f g h i j k lū m n o p q r s t u v w x y z { |‘ }‘ ~’ ’ €’ ’ ‚’ ƒ’ „’ …’ †’ ‡’ ˆ’ ‰’ Š’ ‹’ Œ’ ’ Ž’ ’ ’ ‘’ ’“ ““ ”“ •“ –“ —“ ˜“ ™“ š“ ›“ œ” ” ž” Ÿ”  ” ”” ¢” £” ¤” „” ¦” §• ؕ ©• Ŗ• «• ¬• ­• ®• ƕ °• ±• ²– ³– “– µ– ¶– ·– ø– ¹– ŗ– »– ¼– ½– ¾— æ— Ą— Į— Ā— Ɨ ė ŗ ʗ Ē— ȗ ɗ Ź— Ė— Ģ— Ķ— Ī— Ļ— Š— ї Ņ— ӗ Ō˜ ՙ ֙ ֙ י Ų™ Ł™ Ś™ Ū™ ܙ Ż™ Ž™ ߙ ą™ į™ ā™m™o™ ć™ ä™ åš ęš ęš ēš čš éš źš ėš ģš ķš īš ļš š› ń› ņ› ó› ō› õ› ö›\›]›^›_›ż›ž›››’››› › › ››››› ÷› ų› ł› ś› ū› ü› ż› ž› ’› › › › › › › › › › › › œ œ œ œ œ œ œ œ œ œ œ œ œ     efgh KJ       !s "P #óóō+ $ %,%'%&( & & ' ( ) * + , - . / / 0 1 2 3 4 5 6 6 7 8 9 : : ; < =2 >3 ?"#$G @ A B C D E F G H Ičéc J Kęē L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p U q r s t u v w x y z { | } ~  €  ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ  Ž   ‘ ’ “ ” • – — ˜ ™ š › œ  ž Ÿ   ” ¢ £ ¤ „ ¦ § ؝ © Ŗ « ¬ ­ ® Ɲ ° ± ² ³ “ µ ¶ · ø ¹ ŗ » ¼ ½ ¾ æ Ą Į Ā Ɲ ĝ ŝ ʝ Ē ȝ ɝ Ź Ė Ģ Ķ Ī Ļ Š ѝ Ņ ӝ Ō ՝ ֝ ם Ų Ł Ś Ū ܝ Ż Ž ߝ ą į ā ć ä å ę ē č éž źž ėŸ ģŸ ķŸsŸ īŸ 1Ÿ ļŸ šŸ ńŸ ņŸ óŸ zŸ ōŸ õŸ öŸ oŸ ÷Ÿ ųŸ łŸ śŸ ūŸ üŸ żŸ žŸ ’Ÿ Ÿ Ÿ Ÿ Ÿ Ÿ Ÿ Ÿ Ÿ Ÿ Ÿ Ÿ Ÿ                                         ” !”÷” "” #” $” %” &¢ '¢ (¢ )¢ *¢ +¢ ¤¢ „¢ ,¢ -£ .£ .£ /£ 0£ 1£ 2£ 3¤ 4¤ 4¤ 5¤ 6¤ 7¤ 8¤ 9¤ :¤ ;¤ <¤ =¤ >¤ų¤ ?¤ @¤ A¤ B¤ C¤ D¤ E¤ F¤ G¤ H¤ I¤ J„ K„ L„ M„ N„ O„ P„ Q¦ R¦ S¦ T¦ U§ V§ W§ XØ YØ Z© [© [© \© ]© ^© _© `© a© b© c© d© e© f© g© h© i© j© k© l© m© n© o© p© q© r© sŖ tŖ [Ŗ Ŗ uŖ vŖ wŖ xŖ yŖ zŖ {Ŗ |Ŗ }Ŗ ~Ŗ Ŗ €Ŗ Ŗ ‚Ŗ ƒŖ „Ŗ …Ŗ †Ŗ ‡Ŗ ˆŖ ‰Ŗ ŠŖ ‹Ŗ ŒŖ Ŗ ŽŖ Ŗ Ŗ ‘« ’« “¬ ”¬ •¬ –¬ —¬ ˜¬ ™¬ š¬ ›¬ œ¬ ¬ ž¬ Ÿ­ t­  ® ”® ž® ¢Æ £Æ ¤Æ „Æ ¦° §° Ø° ©° Ŗ° «° ¬° ­° ®° Æ° °° ±° ²° ³° “° µ° ¶± ·± ø± ¹± ¹± ŗ± »± ¼± ½± ¾± æ± Ą± Į± Ā± Ʊ ı ű ʱ Ē± ȱ ɲ Ź² Ė² Ģ² Ķ² Ī² Ļ³ Š³ Š³ Ń³ Ņ³ Ó³ Ō“ Õ“ Öµ ×µ ×µ Ųµ Łµ Śµ Ūµ ܵ Żµ Žµ ßµ ąµ įµ āµ ćµ ćµ Tµ äµ _µ bµ šµ µ åµ ęµ ēµ čµ éµ źµ ėµ ģµ ķµ īµ ļµ šµ ńµ ņµ óµ ōµ õµ öµ ÷µ ųµ łµ śµ ūµµ üµ żµ žµ ’µ¶¶¶¶¶¶¶¶¶¶ ¶ ¶ ’· · · ···················· ·!·"·#·$·%·&·'·(·)·*·+·,·-·.·/·0·1·2·3·4·5·6·7·8·9·:· ²· ±· “· µø;ø<ø=ø>ø?¹@¹A¹B¹C¹D¹E¹c¹F¹G¹H¹ ¹IŗJŗK»L»M¼N¼O¼P½Q¾R¾SæTĄUĮVĀWĆXĆYÄZÅ[Ę\Ē]Ē^Ē_Ē`ĒaČbÉcŹdĖeĢfĶgĶhĪiĪjĪkĻlĻmŠnŃ ?ŃoŃpŃqŃrŅsŅtŅuŅvŅwŅxŅyÓzÓ{Ó|Ó}Ó~ŌŌ€ÕÕ‚փքօ׆Ų‡ŲˆŲ‰ŲŠŲ‹ŁŒŚŪŽÜÜÜ‘Ü’Ü“Ü”Ż•Ž–ß ą—ą˜į™āšāšā›āœāā żāžāžāŸā ā”ć¢ć£ć¤ć„ä`ä¦ä§åØå©ęŖē«č¬č­é®éÆé°éŖ± ² ³ “µ)¶·ø¹ŗ»¼½¾æĄĮĀĆÄÅĘĒČÉŹĖĢĶĪĻŠŃŅÓŌÕÖ×ŲŁŚŪÜŚŪŻŽßąįāćäåęēčéźėģķīļšńņóōõö÷ųłśūüżž ’        "# # # # # ################### #!#"$#)$2%&7'8(8)8*8+,-8.8/808129c9394959697:8;9;:=;=<@=@>@?@@@A@B@C@D@E@F@G@H@I@J@K@L@M@N@O@PBQDRDSDTDUDVDWDXDYDZD[E\E]E^E_E`EaEbEcGdėģGeGfGgGhGiGjJkJlNmNnNoNpNqNrNsPtTuTvTwTxVyVzV{\|\}`~aa€aa‚eƒe„e…e†e‡eˆr‰wŠy‹yŒyyŽyyy‘y’z ‚z ƒz“”•„–„—„˜Œ™Œš›œ‘“ž“Ÿ“ “”“¢“£“¤•„–¦–§–ؖ -–©–Ŗ–«–¬—­—®—Ɨ°—±—²—³—“—µ—¶—·—ø—¹—ŗ—»—¼—½—¾—æ—Ą—Į—Ā—ƗėŗʗĒ—ȗɗŹ—Ė—Ģ—Ķ—Ī—Ļ™Š™љŅ™ ³™әŌš՛֛כŲ›Ł›Ś›Ū›ܛŻ›Ž›ߛą›įŸā ć ä å ęēčēé£ź£ė£ģ¤ķ¤ī¤ļ¤š¤ń¤ņ¦óīōõö÷õöų«ł«ś«ū«ü«ż«ž«’®±±±²²²²“µ µ µ µ µ µµµµµµµµµµµrµsµµµµµ·š¹¹ŗŗ ¼!¾"¾#¾$¾%¾&¾'¾(¾)¾*¾+¾,¾-É.Ģ/Ģ0Ģ1Ģ2Ī3Ī4Ļ5Ń6Ń7Ń8Ņ9Ņ:Ņ;Ņ<Ņ=Ņ>Ó?Ö@×AŚBŚCŚDÜEÜFŻGŻHå~ēIēBēJēKēLēMēNēOēPēQēRēSčTčU“V éWéXéYéZ[#darcs-2.16.2-4PysuDM0a74Ena52PM2yLs Darcs.PreludeDarcs.Util.ParserDarcs.Util.RatifiedDarcs.Util.ByteStringDarcs.Util.WorkaroundDarcs.Util.DateTimeDarcs.Patch.RepoTypeDarcs.Patch.Witnesses.UnsafeDarcs.Patch.Witnesses.EqDarcs.Patch.RegCharsDarcs.Patch.TokenReplaceDarcs.Patch.FormatDarcs.Test.TestOnlyDarcs.UI.Options.IsoDarcs.UI.Options.CoreDarcs.Util.AtExitDarcs.Util.CommandLineDarcs.Util.Download.RequestDarcs.Util.DownloadDarcs.Util.EncodingDarcs.Util.GlobalDarcs.Util.Diff.MyersDarcs.Util.Diff.PatienceDarcs.Util.DiffDarcs.Repository.PathsDarcs.Repository.FlagsDarcs.Util.GraphDarcs.Util.HTTPDarcs.Util.HashDarcs.Util.IsoDateDarcs.Util.DateMatcherDarcs.Util.PrinterDarcs.Util.EnglishDarcs.UI.EmailDarcs.Util.Printer.ColorDarcs.Util.ProgressDarcs.Util.ExecDarcs.Util.PromptDarcs.Util.ShowDarcs.Patch.Witnesses.ShowDarcs.Patch.Witnesses.SealedDarcs.Patch.Witnesses.OrderedDarcs.Patch.Witnesses.WZipperDarcs.Patch.Witnesses.MaybeDarcs.Patch.Rebase.PushFixupDarcs.Patch.InvertDarcs.Patch.DebugDarcs.Patch.CommuteFnDarcs.Patch.CommuteDarcs.Patch.MergeDarcs.Patch.PermutationsDarcs.Patch.CommuteNoConflictsDarcs.Util.URLDarcs.Util.SignalHandlerDarcs.Util.ExceptionDarcs.Util.SshDarcs.Util.PathDarcs.Util.TreeDarcs.Util.Tree.MonadDarcs.Patch.MonadProgressDarcs.Util.Tree.HashedDarcs.Util.FileDarcs.Util.Tree.PlainDarcs.Util.IndexDarcs.Util.CompatDarcs.Util.LockDarcs.Util.ExternalDarcs.Repository.FormatDarcs.Repository.CacheDarcs.UI.Options.FlagsDarcs.UI.Options.UtilDarcs.UI.Options.MarkdownDarcs.UI.Commands.Util.TreeDarcs.Repository.PrefsDarcs.Patch.SummaryData#Darcs.Patch.Prim.FileUUID.ObjectMapDarcs.Patch.InspectDarcs.Patch.ChoicesDarcs.Patch.Index.TypesDarcs.Patch.ApplyMonadDarcs.Patch.ApplyDarcs.Patch.TouchesFilesDarcs.Patch.ShowDarcs.Patch.InfoDarcs.Repository.InventoryDarcs.Repository.HashedIODarcs.Patch.IdentDarcs.Patch.FileHunkDarcs.Patch.ViewingDarcs.Patch.BracketedDarcs.Patch.ReadDarcs.Patch.V3.ContextedDarcs.Patch.RepairDarcs.Patch.Prim.ClassDarcs.Patch.Prim.V1.CoreDarcs.Patch.Prim.V1.ReadDarcs.Patch.Prim.V1.MangleDarcs.Patch.Prim.V1.DetailsDarcs.Patch.Prim.V1.ShowDarcs.Patch.Prim.V1.CommuteDarcs.Patch.Prim.V1.CoalesceDarcs.Patch.Prim.V1.ApplyDarcs.Patch.Prim.V1Darcs.Patch.Prim.FileUUID.CoreDarcs.Patch.Prim.FileUUID.Read!Darcs.Patch.Prim.FileUUID.Details!Darcs.Patch.Prim.FileUUID.Commute"Darcs.Patch.Prim.FileUUID.CoalesceDarcs.Patch.SplitDarcs.Patch.FromPrimDarcs.Patch.V1.CoreDarcs.Patch.V1.ShowDarcs.Patch.UnwindDarcs.Patch.SummaryDarcs.Patch.Prim.FileUUID.ShowDarcs.Patch.Prim.FileUUID.ApplyDarcs.Patch.Prim.FileUUIDDarcs.Patch.EffectDarcs.Patch.V2.NonDarcs.Patch.ConflictDarcs.Patch.V2.RepoPatchDarcs.Patch.V1.CommuteDarcs.Patch.V1.ReadDarcs.Patch.V1.ApplyDarcs.Patch.V1.ViewingDarcs.Patch.NamedDarcs.Patch.Rebase.NameDarcs.Patch.Rebase.FixupDarcs.Patch.PatchInfoAndDarcs.Patch.SetDarcs.Patch.ProgressDarcs.Patch.DependsDarcs.Patch.Index.MonadDarcs.Patch.ApplyPatchesDarcs.Repository.ApplyPatchesDarcs.Patch.AnnotateDarcs.Patch.V2.PrimDarcs.Patch.V1.PrimDarcs.Patch.RepoPatchDarcs.Patch.Rebase.ChangeDarcs.Patch.Rebase.Legacy.ItemDarcs.Patch.Rebase.SuspendedDarcs.Patch.Named.WrappedDarcs.Patch.InvertibleDarcs.Repository.OldDarcs.Repository.InternalTypesDarcs.Repository.TraverseDarcs.Repository.RebaseDarcs.Repository.PristineDarcs.Repository.PendingDarcs.Repository.PatchIndexDarcs.Repository.DiffDarcs.Repository.StateDarcs.Repository.ResolutionDarcs.Patch.MatchDarcs.UI.Options.MatchingDarcs.UI.Options.AllDarcs.UI.OptionsDarcs.UI.FlagsDarcs.UI.ExternalDarcs.UI.PrintPatchDarcs.UI.Commands.Convert.UtilDarcs.Patch.BundleDarcs.Repository.HashedDarcs.Repository.RepairDarcs.Repository.PacksDarcs.Repository.MergeDarcs.Repository.MatchDarcs.Patch.Prim.WithNameDarcs.Patch.V3.CoreDarcs.Patch.V3.ResolutionDarcs.Patch.Prim.NamedDarcs.Patch.V3Darcs.Repository.WorkingDarcs.Repository.TestDarcs.Repository.IdentifyDarcs.Repository.JobDarcs.UI.CompletionDarcs.Repository.CreateDarcs.Repository.CloneDarcs.UI.SelectChangesDarcs.UI.PatchHeaderDarcs.UI.CommandsDarcs.UI.UsageDarcs.UI.Commands.UtilDarcs.UI.Commands.WhatsNewDarcs.UI.Commands.UnrevertDarcs.UI.Commands.UnrecordDarcs.UI.Commands.TransferModeDarcs.UI.Commands.TestDarcs.UI.Commands.TagDarcs.UI.Commands.ShowTagsDarcs.UI.Commands.ShowRepo Darcs.UI.Commands.ShowPatchIndexDarcs.UI.Commands.ShowIndexDarcs.UI.Commands.ShowFiles"Darcs.UI.Commands.ShowDependenciesDarcs.UI.Commands.ShowContentsDarcs.UI.Commands.ShowAuthorsDarcs.UI.Commands.ShowDarcs.UI.Commands.SetPrefDarcs.UI.Commands.RollbackDarcs.UI.Commands.RevertDarcs.UI.Commands.ReplaceDarcs.UI.Commands.RepairDarcs.UI.Commands.RemoveDarcs.UI.Commands.RecordDarcs.UI.Commands.OptimizeDarcs.UI.Commands.MoveDarcs.UI.Commands.MarkConflictsDarcs.UI.Commands.LogDarcs.UI.Commands.InitDarcs.UI.Commands.GZCRCsDarcs.UI.Commands.DistDarcs.UI.Commands.Diff Darcs.UI.Commands.Convert.Import Darcs.UI.Commands.Convert.Export Darcs.UI.Commands.Convert.Darcs2Darcs.UI.Commands.ConvertDarcs.UI.Commands.CloneDarcs.UI.Commands.SendDarcs.UI.Commands.PushDarcs.UI.Commands.AnnotateDarcs.UI.Commands.AmendDarcs.UI.Commands.AddDarcs.UI.ApplyPatchesDarcs.UI.Commands.PullDarcs.UI.Commands.ApplyDarcs.UI.Commands.RebaseDarcs.UI.TheCommandsDarcs.UI.DefaultsDarcs.UI.RunCommandDarcs.UI.Commands.Help DarcsFlagSystem.Console.GetOptOptDescr DarcsOptDescr Data.FunctorFunctorsetEnvCautiouslyPreludefoldrTreefilterDarcsUtil.Path AbsolutePath showFriendlywritePatchIfNecessary readFileNameNamed InvertibleDarcs.Patch.PrimDarcs.Patch.V2Darcs.Patch.V1 Darcs.PatchDarcs.RepositoryVersionbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negatefail>>=>>fmapreturn fromIntegral realToFrac toInteger toRational<>memptymappendmconcat<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralMonadNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShow Applicative Data.FoldableFoldableData.Traversable Traversable SemigroupMonoid GHC.TypesBoolCharDoubleFloatInt integer-gmpGHC.Integer.TypeInteger GHC.MaybeMaybeOrderingRationalIOWord Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGT<$>readListconst.idString<* Text.Readread*attoparsec-0.13.2.4-5dPphue7zS64OdJnfwFzDf Data.Attoparsec.ByteString.Char8 skipSpace skipWhiletakeTillanyChar#Data.Attoparsec.ByteString.InternaltakeParserData.Attoparsec.CombinatoroptionchoiceData.Attoparsec.Internal endOfInputsequencemapM sequenceAtraverseControl.ApplicativeoptionalreadIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputCharGHC.IO.Handle.Text hGetContentsGHC.IO.ExceptionioErrorGHC.IOFilePath userErrorIOErrornotElemallanyorand concatMapconcat sequence_mapM_productsumminimummaximumelemlengthnullfoldl1foldr1foldlfoldMap Data.OldListunwordswordsunlineslinesreadseitherlex readParen readsPrecText.ParserCombinators.ReadPReadSatanhacoshasinhtanhcoshsinhatanacosasintancossinlogBase**sqrtexpatan2isIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadixlcmgcd^^oddevendivModquotRemmoddivremquotrecip/floorceilingroundtruncateproperFractionmaxBoundminBoundfromEnumtoEnumsucc showParen showStringshowCharshowsShowSshowListshow showsPrecunzip3unzipzipWith3zipWithzip3!!reversebreakspansplitAtdrop dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanlinitlasttailhead Data.Maybemaybeuncurrycurrysubtractsignumabs*+asTypeOfuntil$!flip=<<stimessconcat<$liftA2GHC.Err undefinederrorWithoutStackTraceerror/=<=compare&&||not<>maxminbytestring-0.10.8.2Data.ByteString intercalatedirectory-1.3.3.0System.DirectorygetCurrentDirectory time-1.8.0.2Data.Time.Clock.POSIXgetCurrentTime unix-2.7.2.2System.Posix.SignalsinstallHandler raiseSignalsigTERMsigPIPEsigINTsigHUPsigALRMsigABRTSignal CatchInfoOnce CatchInfo CatchOnceCatchIgnoreDefaultHandler SRepoType IsRepoTypesingletonRepoType RebaseTypeOfRepoType rebaseType IsRebaseType SRebaseType SIsRebase SNoRebase RebaseTypeIsRebaseNoRebase$fIsRebaseTypeNoRebase$fIsRebaseTypeIsRebase$fIsRepoTypeRepoType unsafeCoercePunsafeCoercePStartunsafeCoercePEndunsafeCoerceP1Eq2 unsafeCompare=\/==/\=EqCheckIsEqNotEqisIsEq $fShowEqCheck $fEqEqCheckregChars tryTokReplaceforceTokReplaceannotateReplace breakToTokens defaultToksFileNameFormatFileNameFormatV1FileNameFormatV2FileNameFormatDisplay ListFormatListFormatDefault ListFormatV1 ListFormatV2 ListFormatV3PatchListFormatpatchListFormat$fEqFileNameFormat$fShowFileNameFormatTestOnly IsoFunctorimapIsoundercps PrimOptSpecOptSpecounparseoparseocheckodescoid^ onormalise defaultFlagsoimapoappendoempty parseFlags unparseOpt?$fIsoFunctorOptSpec$fMonoidOptSpec$fSemigroupOptSpecatexit withAtexitparseCmd addUrlencoded toSeconds startOfTimeformatDateTime parseDateTime fromClockTimeConnectionErrorCouldNotResolveHostCouldNotConnectToServerOperationTimeoutQUrlState inProgress waitToStart pipeLength randomJunk UrlRequesturlfilecachablepriorityCachable UncachableMaxAgePriorityHighLowreadQaddUsingPriorityinsertQpushQdeleteQelemQemptyQnullQ $fEqPriority$fShowCachable $fEqCachable$fEqConnectionError$fReadConnectionError$fShowConnectionErrormaxPipelineLengthdisableHTTPPipelining setDebugHTTPenvironmentHelpProxyenvironmentHelpProxyPasswordencodedecode encodeUtf8 decodeUtf8 setDebugMode whenDebugMode withDebugMode debugMessage putTimingsetTimingsMode timingsMode addCRCWarninggetCRCWarningsresetCRCWarningsdarcsdirdefaultRemoteDarcsCmddarcsLastMessagedarcsSendMessagedarcsSendMessageFinal FileSegment dropSpaceisFunkyhashPSsubstrPS breakFirstPS breakLastPSlinesPS unlinesPS#prop_unlinesPS_linesPS_left_inverseprop_linesPS_lengthprop_unlinesPS_length gzDecompressisGZFile gzReadFilePS gzWriteFilePSgzWriteFilePSs gzWriteHandle gzReadStdin readSegment mmapFilePS fromPS2Hex fromHex2PSpropHexConversionbetweenLinesPSspec_betweenLinesPSisAsciiunpackPSFromUTF8packStringToUTF8 decodeLocale encodeLocalePArray getChangesgetSliceshiftBoundariesinitPaLen DiffAlgorithm PatienceDiff MyersDiff$fEqDiffAlgorithm$fShowDiffAlgorithmmakeDarcsdirPathlockPathhashedInventoryhashedInventoryPathtentativeHashedInventorytentativeHashedInventoryPathinventoriesDirinventoriesDirPathtentativePristinePath pristineDirpristineDirPath patchesDirpatchesDirPath indexPathindexInvalidPath rebasePathtentativeRebasePath formatPath pendingPathtentativePendingPathnewPendingPath unrevertPatholdPristineDirPatholdCurrentDirPatholdCheckpointDirPatholdInventoryPatholdTentativeInventoryPath HookConfigcmdprompt HooksConfigprepost PatchFormat PatchFormat1 PatchFormat2 PatchFormat3 ForgetParentYesForgetParentNoForgetParentWithWorkingDir NoWorkingDir WantGuiPauseYesWantGuiPauseNoWantGuiPauseWorkRepo WorkRepoDirWorkRepoPossibleURLWorkRepoCurrentDir ExternalMergeYesExternalMergeNoExternalMergeAllowConflictsNoAllowConflictsYesAllowConflictsYesAllowConflictsAndMark CloneKind LazyClone NormalClone CompleteClone ScanKnownScanAll ScanBoringUseIndex IgnoreIndexInheritDefaultYesInheritDefaultNoInheritDefault SetDefault YesSetDefault NoSetDefault RemoteRepos LeaveTestDirYesLeaveTestDirNoLeaveTestDirSetScriptsExecutableYesSetScriptsExecutableNoSetScriptsExecutableRunTest YesRunTest NoRunTest IncludeBoringYesIncludeBoringNoIncludeBoring LookForMovesYesLookForMovesNoLookForMovesLookForReplacesYesLookForReplacesNoLookForReplaces LookForAddsYesLookForAdds NoLookForAddsUMaskYesUMaskNoUMaskDryRun YesDryRunNoDryRunUseCache YesUseCache NoUseCache UpdatePendingYesUpdatePendingNoUpdatePendingReorder NoReorder RemoteDarcsDefaultRemoteDarcsWithPatchIndex YesPatchIndex NoPatchIndex Compression NoCompressionGzipCompression VerbosityQuietNormalVerbosityVerbose remoteDarcs $fEqVerbosity$fShowVerbosity$fEqCompression$fShowCompression$fEqWithPatchIndex$fShowWithPatchIndex$fEqRemoteDarcs$fShowRemoteDarcs $fEqReorder$fEqUpdatePending$fShowUpdatePending $fEqUseCache$fShowUseCache $fEqDryRun $fShowDryRun $fEqUMask $fShowUMask$fEqLookForAdds$fShowLookForAdds$fEqLookForReplaces$fShowLookForReplaces$fEqLookForMoves$fShowLookForMoves$fEqIncludeBoring$fShowIncludeBoring $fEqRunTest $fShowRunTest$fEqSetScriptsExecutable$fShowSetScriptsExecutable$fEqLeaveTestDir$fShowLeaveTestDir$fEqRemoteRepos$fShowRemoteRepos$fEqSetDefault$fShowSetDefault$fEqInheritDefault$fShowInheritDefault $fEqUseIndex$fShowUseIndex $fEqScanKnown$fShowScanKnown $fEqCloneKind$fShowCloneKind$fEqAllowConflicts$fShowAllowConflicts$fEqExternalMerge$fShowExternalMerge $fEqWorkRepo$fShowWorkRepo$fEqWantGuiPause$fShowWantGuiPause$fEqWithWorkingDir$fShowWithWorkingDir$fEqForgetParent$fShowForgetParent$fEqPatchFormat$fShowPatchFormat ComponentGraph VertexSetVertexltmisbkmis genGraphs genComponents componentsprop_ltmis_eq_bkmis#prop_ltmis_maximal_independent_sets'prop_ltmis_all_maximal_independent_setsprop_components$fShowComponent copyRemotecopyRemoteLazyspeculateRemotepostUrlSHA1HashSHA256NoHash encodeBase16 decodeBase16sha256 sha256sumrawHashmatchsha1Xorsha1zero sha1shortsha1PS showAsHexsha1Readsha1Show $fBinarySHA1 $fShowSHA1 $fShowHash$fEqHash $fOrdHash $fReadHash$fEqSHA1 $fOrdSHA1 MCalendarTimemctYearmctMonthmctDaymctHourmctMinmctSec mctPicosecmctWDaymctYDay mctTZNamemctTZmctIsDSTmctWeek TimeInterval readUTCDatecleanLocalDate getLocalTzreadUTCDateOldFashioned parseDateshowIsoDateTimegetIsoDateTimeiso8601Intervaliso8601DurationenglishDateTimeenglishInterval englishLast theBeginningtoMCalendarTimeunsafeToCalendarTime addToMCalsubtractFromMCal resetCalendar unsetTime$fShowMCalendarTime DateMatcherDMparseDateMatcher getMatcherstestDate testDateAtparselexWordlexChar lexStringcharstringint takeTillChar checkConsumeslinesStartingWithlinesStartingWithEndingWithColorBlueRedGreenCyanMagentaPrinter Printers'PrinterscolorP invisiblePhiddenP userchunkPdefP lineColorT lineColorSDocunDoc PrintableSPSBothspacenewlineminusplus backslashlparenrparenparenssentencepathlist putDocWith putDocLnWithputDocputDocLn hPutDocWith hPutDocLnWithhPutDoc hPutDocLn hPutDocCompr debugDocLn renderStringrenderStringWithrenderPS renderPSs renderPSWith renderPSsWithprefix prefixLinesinsertBeforeLastline lineColor hiddenPrefix unsafeBothunsafeBothText packedStringunsafePackedString invisiblePS userchunkPS unsafeChartext unsafeText invisibleText hiddenText userchunkblueTextredText greenText magentaTextcyanText colorTextwrapText formatText formatWords printableinvisiblePrintablehiddenPrintableuserchunkPrintablesimplePrinters simplePrinterinvisiblePrinteremptydoc<+>$$$+$vcatvsephcathsepquoted $fMonoidDoc$fSemigroupDoc $fIsStringDocThisPronounItNoun Countablepluralsingular englishNum andClauses orClauses anyOfClauseitemizeVerticalitemizepresentParticiple capitalize$fCountableNoun$fCountablePronoun$fCountableThis formatHeader makeEmail readEmailprop_qp_roundtrip ePutDocLndebugDoctraceDocunsafeRenderStringColored fancyPrintersenvironmentHelpColorenvironmentHelpEscapeWhiteenvironmentHelpEscape beginTedious endTedious tediousSizeminlist progressListprogressprogressKeepLatest finishedOne finishedOneIOsetProgressModewithoutProgress ExecExceptionRedirectAsIsNullFileStdout RedirectsrenderExecExceptionexecexecInteractivewithoutNonBlockreadInteractiveProcess$fShowExecException$fExceptionExecException$fShowRedirect PromptConfigpPromptpBasicCharacterspAdvancedCharacterspDefaultpHelpaskUseraskEnteraskUserListItem promptYorn promptChar BSWrapperappPrec$fShowBSWrapperShow2 showDict2Show1 showDict1 showsPrec1show1 showsPrec2show2showOp2GapemptyGapfreeGapjoinGap FreeRightFreeLeft FlippedSealSealed2Sealedsealseal2flipSealunsealmapSeal mapFlippedunseal2mapSeal2 unsealFlipped unFreeLeft unFreeRight $fShowSealed $fEqSealed $fShowSealed2$fGapFreeRight $fGapFreeLeft:||:Fork:/\::\/:RL:<:NilRLFL:>:NilFL:>nullFLnullRL filterOutFLFL filterOutRLRLfilterRL+>++<+ reverseFL reverseRLconcatFLconcatRLspanFLspanFL_M splitAtFL splitAtRLbunchFLfoldFL_MfoldRL_MallFLanyFLallRLanyRLfoldrFLfoldlRLfoldrwFLfoldlwRLmapFL_FL mapFL_FL_M sequenceFL_ zipWithFLmapRL_RLmapFLfilterFLmapRLlengthFLlengthRLisShorterThanRL snocRLSealedtoFL dropWhileFL dropWhileRL takeWhileRLspanRLbreakRLeqFL eqFLUnsafe+>>++<<+initsFL concatRLFL $fShow2:>$fEq:>$fEq2:>$fShow:> $fShow1:> $fShow2FL $fShow1FL$fShowFL $fShow2RL $fShow1RL$fShowRL $fShow2:\/: $fShow:\/: $fShow2:/\: $fShow:/\:FZipper flToZippernullFZlengthFZfocusclownsjokers rightmostrightleftmostlefttoEndtoStartMaybe2Nothing2Just2 maybeToFL maybeToRLmapMB_MB PushFixupFn dropFixupspushFixupFLFL_FLFLFLpushFixupFLFL_FLFLFLFLpushFixupFLMB_FLFLMBpushFixupIdFL_FLFLFLpushFixupIdMB_FLFLMBpushFixupIdMB_FLIdFLFLInvertinvertinvertFLinvertRL dropInverses $fInvert:> $fInvertRL $fInvertFL PatchDebugpatchDebugDummy$fPatchDebugRL$fPatchDebugFLPartialMergeFnMergeFnTotalCommuteFn CommuteFn commuterIdRL commuterIdFL mergerIdFLtotalCommuterIdFL commuterFLId commuterRLId commuterRLFLtotalCommuterFLIdtotalCommuterFLFLinvertCommuterCommutecommute commuteRLFL commuteRL commuteFL selfCommuter $fCommuteRL $fCommuteFLMergemerge CleanMerge cleanMerge cleanMergeFL selfMergermergeFL mergerFLId mergerFLFL swapMerge swapMergerswapCleanMerge mergeListprop_mergeSymmetricprop_mergeCommute$fCleanMergeFL $fMergeFL partitionFL partitionFL' partitionRLcommuteWhatWeCanFLgenCommuteWhatWeCanFLcommuteWhatWeCanRLgenCommuteWhatWeCanRL removeCommonremoveFLremoveRLremoveSubsequenceFLremoveSubsequenceRLsimpleHeadPermutationsFLheadPermutationsFLheadPermutationsRLpermutationsRLpartitionConflictingFL$fEq2RL$fEq2FLCommuteNoConflictscommuteNoConflictsmergeNoConflicts SshFilePathsshUhostsshReposshFile isRelative isAbsoluteisValidLocalPath isHttpUrlisSshUrl isSshNopath splitSshUrl sshFilePathOf setExecutable stdoutIsAPipewithSignalsHandledcatchNonSignalcatchInterrupt tryNonSignalwithSignalsBlocked$fExceptionSignalException$fShowSignalExceptioncatchallcatchNonExistence firstJustIO clarifyErrorsprettyException prettyErrordiehandleOnlyIOError ifIOErrorifDoesNotExistError handleOnlySSHCmdSSHSCPSFTP SshSettingssshscpsftpwindows defaultSshcopySSHtransferModeHeadergetSSHenvironmentHelpSshenvironmentHelpScpenvironmentHelpSshPort$fShowSshSettings$fEqSshSettings AnchoredPathNameAbsoluteOrRemotePathAbsolutePathOrStdSubPath FilePathLike toFilePath FilePathOrURLtoPath displayPathrealPath encodeWhite decodeWhite makeSubPathOf simpleSubPath doesPathExist ioAbsolute makeAbsolutemakeAbsoluteOrStdstdOutioAbsoluteOrStduseAbsoluteOrStdioAbsoluteOrRemoteisRemotesetCurrentDirectoryisMaliciousSubPathgetUniquePathNameisPrefix appendPathcatPathsparentparents breakOnDir anchorPathname2fpflattenmakeName floatPath anchoredRoot replaceParent rawMakeName eqAnycaseencodeWhiteNamedecodeWhiteNamemovedirfilename filterPaths floatSubPath inDarcsdir darcsdirNameisRoot $fShowSubPath$fFilePathLikeSubPath$fFilePathOrURLSubPath$fShowAbsolutePath$fFilePathLikeAbsolutePath$fFilePathOrURLAbsolutePath$fShowAbsolutePathOrStd$fShowAbsoluteOrRemotePath#$fFilePathOrURLAbsoluteOrRemotePath$fFilePathLike[]$fCharLikeChar$fFilePathOrURL[]$fShowCorruptPatch$fExceptionCorruptPatch $fEqSubPath $fOrdSubPath$fEqAbsolutePath$fOrdAbsolutePath$fEqAbsolutePathOrStd$fOrdAbsolutePathOrStd$fEqAbsoluteOrRemotePath$fOrdAbsoluteOrRemotePath $fBinaryName$fEqName $fShowName $fOrdName$fBinaryAnchoredPath$fEqAnchoredPath$fShowAnchoredPath$fOrdAnchoredPath$fEqCorruptPatch FilterTreeitemstreeHashItemTypeTreeTypeBlobTypeTreeItemSubTreeStubBlob listImmediateitemHashitemType emptyTree emptyBlobmakeBlob makeBlobBSmakeTreemakeTreeWithHashlookupfindfindFilefindTreelist explodePaths explodePath expandUpdateexpand expandPath checkExpandrestrictreadBlobzipCommonFileszipFileszipTrees diffTrees modifyTreeupdateSubtrees updateTreepartiallyUpdateTreeoverlayaddMissingHashesprop_explodePath$fFilterTreeTreem$fShowItemType $fEqItemType $fOrdItemTypeTreeRWcreateDirectoryunlinkrenamecopyTreeROcurrentDirectory withDirectoryexistsdirectoryExists fileExistsTreeIO TreeMonad TreeStatetree initialState runTreeMonadvirtualTreeMonad virtualTreeIO replaceItemfindM findTreeM findFileM $fTreeRORWST $fTreeRWRWST MonadProgressrunProgressActionsProgressActionpaAction paMessage paOnErrorsilentlyRunProgressActions$fMonadProgressRWSTdecodeDarcsHashdecodeDarcsSize darcsLocation darcsTreeHashdarcsUpdateHashesdarcsAddMissingHashesreadDarcsHashedDirreadDarcsHashedreadDarcsHashedNosizewriteDarcsHashed hashedTreeIOwithCurrentDirectory getFileStatusdoesDirectoryReallyExistremoveFileMayNotExist osxCacheDir xdgCacheDirgetRecursiveContentsgetRecursiveContentsFullPath readPlainTreewritePlainTreeIndex listFileIDs readIndexupdateIndexFrom updateIndexindexFormatValid getFileIDalign$fFilterTreeIndexMIO$fShowCorruptIndex$fExceptionCorruptIndex $fShowItem$fEqCorruptIndex canonFilename maybeRelinksloppyAtomicCreate atomicCreatewithLockwithLockCanFailenvironmentHelpLockswithTemp withOpenTemp tempdirLocenvironmentHelpTmpdirenvironmentHelpKeepTmpdir withPermDir withTempDirwithDelayedDir withNamedTemp readBinFile readTextFilereadDocBinFile appendBinFileappendTextFileappendDocBinFile writeBinFile writeTextFilewriteDocBinFilewriteAtomicFilePSgzWriteAtomicFilePSgzWriteAtomicFilePSsgzWriteDocFile addToErrorLocwithNewDirectory copyFileOrUrl cloneTree cloneFilebackupByRenamingbackupByCopying fetchFilePSfetchFileLazyPS gzFetchFilePSspeculateFileOrUrl RepoFormatRF RepoPropertyDarcs1Darcs2Darcs3HashedInventoryRebaseInProgressRebaseInProgress_2_16 UnknownFormat formatHas addToFormatremoveFromFormatidentifyRepoFormattryIdentifyRepoFormatwriteRepoFormatcreateRepoFormat writeProblemtransferProblem readProblem$fShowRepoProperty$fShowRepoFormat$fEqRepoPropertyCacheCacheLoc cacheType cacheWritable cacheSource CacheTypeRepo Directory WritableOrNotWritable NotWritable HashedDirHashedPristineDirHashedPatchesDirHashedInventoriesDir hashedDir allHashedDirsmkCache cacheEntries unionCachesunionRemoteCaches repo2cache cacheHashokayHashfetchFileUsingCachewritable dropNonReposclosestWritableDirectory isThisRepo bucketFolderhashedFilePath peekInCachespeculateFileUsingCachespeculateFilesUsingCachewriteFileUsingCache cleanCachescleanCachesWithHintreportBadSources$fShowCacheLoc $fEqCacheLoc $fShowCache$fEqWritableOrNot$fShowWritableOrNot $fEqCacheType$fShowCacheType$fEqOrOnlySpeculate $fEqFromWhere ExactVersion ListCommandsHelp ListOptionsNoTestTestOnlyChangesToFilesChangesToAllFilesTimingsDebug DebugHTTPToCcOutputOutputAutoNameMailSubject InReplyToCharset SendmailCmdAuthor SelectAuthor PatchNameOnePatch SeveralPatchOneHash AfterPatch UpToPatch AfterHashUpToHashTagNameLastNMaxCount IndexRangeOneIndex NumberPatchesOneTagAfterTagUpToTag GenContextContextCountLogFile RmLogFile DontRmLogFileDistNameDistZipAll Recursive NoRecursiveMinimize NoMinimize RestrictPathsDontRestrictPathsAskDeps NoAskDeps IgnoreTimesDontIgnoreTimes UseMyersDiffUsePatienceDiff IntersectionUnion ComplementSignSignAsNoSignSignSSLHappyForwardingNoHappyForwardingVerify VerifySSLRemoteDarcsOptEditDescriptionNoEditDescriptionToksEditLongCommentNoEditLongCommentPromptLongCommentKeepDate NoKeepDate MarkConflicts SkipConflictsBoring SkipBoring AllowCaseOnlyDontAllowCaseOnlyAllowWindowsReservedDontAllowWindowsReserved DontGrabDepsDontPromptForDependenciesPromptForDependenciesCompress NoCompress UnCompress WorkRepoUrl RemoteRepoNewRepo NotInRemoteReplyApplyAsMachineReadable HumanReadablePipe InteractiveDiffCmdSummary NoSummary PauseForGui NoPauseForGuiUnified NonUnifiedReverseForwardCompleteLazy DiffFlags XMLOutput ForceReplace OnePatternSeveralPattern AfterPattern UpToPatternNonApply NonVerifyNonForceDisableDontSetScriptsExecutableOnceLinearBackoffBisectHashed UseFormat1 UseFormat2 UseFormat3UseNoWorkingDir UseWorkingDirSiblingFilesNoFiles Directories NoDirectoriesPending NoPending PosthookCmd NoPosthook AskPosthook RunPosthook PrehookCmd NoPrehook AskPrehook RunPrehook StoreInMemory ApplyOnDiskNoHTTPPipeliningPacksNoPacksNoCacheAllowUnrelatedReposCheckRepair JustThisRepo ReadMarks WriteMarksNullFlagNoAmendUnrecord AmendUnrecordPatchIndexFlagNoPatchIndexFlag EnumPatches NoEnumPatches $fEqDarcsFlag$fShowDarcsFlag RawOptSpecRawNoArg RawStrArg RawAbsPathArgRawAbsPathOrStdArgRawOptAbsPathArgPrimDarcsOptionFlagnoArgstrArg optStrArg absPathArgabsPathOrStdArg optAbsPathArg withDefault singleNoArg singleStrArgsingleAbsPathArg multiStrArgmultiOptStrArgmultiAbsPathArg deprecated parseIntArgparseIndexRangeArg showIntArgshowIndexRangeArg$fIsoFunctorRawOptSpec$fShowArgumentParseError$fExceptionArgumentParseError$fEqArgumentParseErroroptionsMarkdowntreeHasAnycasetreeHas treeHasDir treeHasFileFileType BinaryFileTextFilewriteDefaultPrefsglobalPrefsDirglobalPrefsDirDocenvironmentHelpHome getGlobalglobalCacheDir boringRegexpsisBoring getPrefLinesfiletypeFunction addToPreflist getPreflist setPreflist defPrefval getPrefval setPrefval changePrefval defaultrepogetDefaultRepo addRepoSource deleteSources getCachesgetMotdshowMotdprefsUrl prefsDirPath prefsFilePathprefsFilesHelp $fEqFileTypeSummOpSummAddSummRmSummMod SummDetail SummAddDir SummRmDirSummFileSummMvSummNone $fOrdSummOp $fEqSummOp$fOrdSummDetail$fEqSummDetail ObjectMap getObject putObject listObjectsObject DirContentLocationLUUID FileContentisBlob isDirectory$fEqUUID $fOrdUUID $fShowUUID $fEqLocation$fShowLocation PatchInspectlistTouchedFiles hunkMatches$fPatchInspectRL$fPatchInspectFLSlotInFirstInMiddleInLast PatchChoices LabelledPatchLabellabel getLabelIntunLabel patchChoices labelPatchesmkPatchChoicesseparateFirstFromMiddleLastseparateFirstMiddleFromLast getChoices refineChoices patchSlotforceMatchingFirst forceFirsts forceFirstselectAllMiddlesforceMatchingLast forceLasts forceLast forceMiddlemakeEverythingLatermakeEverythingSooner substitute$fPatchInspectLabelledPatch$fCommuteLabelledPatch$fInvertLabelledPatch$fPatchInspectPatchChoice$fCommutePatchChoice $fEqLabelPatchModPTouch PCreateFile PCreateDirPRenamePRemovePInvalidPDuplicateTouchPatchIdPIDpatchIdFileIdcnamecount showFileId pid2stringshortzero$fBinaryFileId $fEqFileId $fShowFileId $fOrdFileId$fBinaryPatchId $fShowPatchId $fOrdPatchId $fEqPatchId$fShowPatchMod $fEqPatchMod$fFunctorPatchMod ApplyMonadApplyMonadBase nestedApply liftApply getApplyStateApplyMonadTreemDoesDirectoryExistmDoesFileExist mReadFilePSmCreateDirectorymRemoveDirectory mCreateFile mRemoveFilemRename mModifyFilePS mChangePrefApplyMonadStateApplyMonadStateOperationsApplyMonadTransApplyMonadOver runApplyMonadToTreetoTree withFileNames withFiles $fToTreeTree$fApplyMonadTreeRWST$fApplyMonadStateTree$fApplyMonadTreeRWST0$fApplyMonadTransTreem$fMonadProgressStateT$fApplyMonadTreeStateT$fApplyMonadTreeStateT0$fMonadProgressStateT0$fApplyMonadTreeStateT1$fApplyMonadTreeStateT2Apply ApplyStateapplyunapply effectOnPaths applyToPaths applyToTree applyToStatemaybeApplyToTree $fApplyRL $fApplyFLdeselectNotTouchingselectNotTouchingchooseTouching lookTouch ShowPatchcontent descriptionsummary summaryFLthingthingsShowContextPatchshowContextPatchShowPatchBasic showPatch ShowPatchFor ForDisplay ForStorage displayPatchformatFileName PatchInfo_piDate_piName _piAuthor_piLog_piLegacyIsInverted validDate validDatePSvalidLog validLogPS validAuthor validAuthorPS rawPatchInfo patchinfoaddJunk replaceJunkjustName justAuthorjustLogdisplayPatchInfopiNamepiRenamepiAuthorisTagpiDate piDateStringpiLogpiTagtoXml toXmlShort escapeXML makePatchname showPatchInfo readPatchInfo$fShowPatchInfo $fEqPatchInfo$fOrdPatchInfoInventoryEntry InventoryinventoryParentinventoryPatches HeadInventory PristineHash PatchHash InventoryHash ValidHash getValidHash mkValidHashinventoryPatchNamesemptyInventoryparseHeadInventoryparseInventory showInventoryshowInventoryPatchesshowInventoryEntrypokePristineHashpeekPristineHashskipPristineHash pristineNameprop_inventoryParseShowprop_peekPokePristineHashprop_skipPokePristineHash$fValidHashInventoryHash$fValidHashPatchHash$fValidHashPristineHash$fEqInventoryHash$fShowInventoryHash $fEqPatchHash$fShowPatchHash$fEqPristineHash$fShowPristineHash $fEqInventory$fShowInventory copyHashedpathsAndContentscopyPartialsHashed cleanHashdirgetHashedFiles $fEqObjTypeIdEq2=\^/==/^\= StorableIdreadIdshowId SignedIdentSignedId positiveIdinvertIdIdentidentmerge2FL fastRemoveFL fastRemoveRLfastRemoveSubsequenceRL findCommonFLcommuteToPrefixcommuteToPostfixcommuteWhatWeCanToPostfixprop_identInvariantUnderCommute"prop_sameIdentityImpliesCommutableprop_equalImpliesSameIdentity $fIdEq2FLIsHunkisHunkFileHunk showFileHunk$fInvertFileHunkshowContextHunk $fShowPatchRL$fShowContextPatchRL$fShowPatchBasicRL $fShowPatchFL$fShowContextPatchFL$fShowPatchBasicFL BracketedFL Bracketed SingletonBracedParens unBracketed unBracketedFL mapBracketedmapBracketedFLFL$fShowPatchBasicBracketed$fPatchListFormatBracketed ReadPatch readPatch'readPatchPartial readPatch bracketedFLpeekfor $fReadPatchRL $fReadPatchFL$fReadPatchBracketed Contextedprop_ctxInvariantsprop_ctxPositive prop_ctxEqctxId ctxNoConflictctxViewctxToFLctxctxAddctxAddRL ctxAddInvFLctxAddFL commutePast commutePastRL ctxTouchesctxHunkMatchesshowCtxreadCtx$fShow1Contexted$fShowContexted$fOrdContexted $fEqContexted RepairToFLapplyAndTryToFixFLapplyAndTryToFixisInconsistent mapMaybeSnd $fCheckRL $fCheckFL $fRepairFLPrimMangleUnravelledmangleUnravelledMangled Unravelled PrimApply applyPrimFLPrimReadreadPrimPrimShowshowPrim showPrimCtx PrimDetails summarizePrimPrimSiftsiftForPending PrimCanonize tryToShrinksortCoalesceFLcanonize canonizeFLcoalesce primCoalesceprimDecoalesce PrimConstructaddfilermfileadddirrmdirmove changeprefhunk tokreplacebinary primFromHunk PrimClassify primIsAddfile primIsRmfile primIsAdddir primIsRmdir primIsMove primIsHunkprimIsTokReplace primIsBinary primIsSetpref is_filepatch PrimPatchprimCleanMerge DirPatchTypeRmDirAddDir FilePatchTypeRmFileAddFileHunk TokReplaceBinaryPrimMoveDPFP ChangePref isIdentity comparePrim$fInvertFilePatchType$fEq2FilePatchType$fInvertDirPatchType$fEq2DirPatchType$fEqPrim $fEq2Prim$fPatchDebugPrim$fPatchInspectPrim $fInvertPrim $fIsHunkPrim$fPrimConstructPrim$fPrimClassifyPrim$fEqFilePatchType$fOrdFilePatchType$fEqDirPatchType$fOrdDirPatchType$fPrimReadPrim$fPrimMangleUnravelledPrim$fPrimDetailsPrimshowHunk$fPrimShowPrim$fShowFilePatchType $fShow1Prim $fShow2Prim$fShowDirPatchType $fShowPrimCommuteFunctionPerhapsUnknownFailed Succeeded toPerhaps cleverCommute speedyCommutecommuteFiledircommuteFilepatches$fCleanMergePrim $fCommutePrim$fMonadPlusPerhaps$fAlternativePerhaps$fMonadPerhaps$fApplicativePerhaps$fFunctorPerhaps$fPrimCanonizePrim $fShowSimple$fPrimApplyPrim$fRepairToFLPrim $fApplyPrim$fPrimSiftPrimHunkMoveManifest DemanifestIdentityHMH $fEq2Hunk $fShow2Hunk $fShow1Hunk $fEq2HunkMove$fEqHunk $fShowHunk $fEqHunkMove$fShowHunkMove$fReadPatchPrimSplitter applySplitter canonizeSplit rawSplitter noSplitter primSplitterreversePrimSplitter ToFromPrimToPrimtoPrimFromPrimfromAnonymousPrimfromPrim fromPrims PrimPatchBasePrimOf$fPrimPatchBaseRL$fPrimPatchBaseFL RepoPatchV1PPMergerRegremisMerger mergerUndo$fPatchDebugRepoPatchV1$fCheckRepoPatchV1$fPatchListFormatRepoPatchV1$fToPrimRepoPatchV1$fFromPrimRepoPatchV1$fPrimPatchBaseRepoPatchV1$fShow2RepoPatchV1$fShow1RepoPatchV1$fShowRepoPatchV1 showPatch_$fShowPatchBasicRepoPatchV1Unwind fullUnwindUnwound mkUnwound squashUnwound$fInvertUnwound$fShowPatchBasicUnwound$fShow2Unwound$fShow1Unwound $fShowUnwoundconflictedEffect ConflictStateOkay Conflicted DuplicatedIsConflictedPrimIsClistConflictedFilesplainSummaryPrimplainSummaryPrims plainSummaryplainSummaryFL xmlSummary$fShowIsConflictedPrim $fSummaryFL$fEqConflictState$fOrdConflictState$fShowConflictState$fReadConflictState$fOrdSummChunk $fEqSummChunk displayHunk$fShowPatchPrim$fShowContextPatchPrim$fShowPatchBasicPrim$fPatchListFormatPrimhunkEdit$fApplyMonadTransObjectMapm$fApplyMonadObjectMapStateT$fToTreeObjectMap$fApplyMonadObjectMapStateT0$fApplyMonadStateObjectMapEffecteffect $fEffectRL $fEffectFLNonablenonNonunNonshowNonsshowNonreadNonsreadNoncommuteOrAddToCtxcommuteOrAddToCtxRLcommutePrimsOrAddToCtxremNonscommuteOrRemFromCtxcommuteOrRemFromCtxFL>**>>>>*$fEqNon $fShow1Non $fShowNon$fWLRL$fWLFLConflictresolveConflictsConflictDetailsconflictMangled conflictParts mangleOrFailcombineConflicts RepoPatchV2 Duplicate EtacilpudNormal Conflictor InvConflictor isDuplicate isForwardmergeUnravelled isConsistent$fIsHunkRepoPatchV2$fEffectRepoPatchV2$fNonableRepoPatchV2$fShow2RepoPatchV2$fShow1RepoPatchV2$fShowRepoPatchV2$fReadPatchRepoPatchV2$fShowPatchRepoPatchV2$fShowContextPatchRepoPatchV2$fShowPatchBasicRepoPatchV2$fPatchListFormatRepoPatchV2$fRepairToFLRepoPatchV2$fApplyRepoPatchV2$fPatchInspectRepoPatchV2$fCleanMergeRepoPatchV2$fCommuteRepoPatchV2$fInvertRepoPatchV2$fEq2RepoPatchV2$fToPrimRepoPatchV2$fFromPrimRepoPatchV2$fCheckRepoPatchV2$fCommuteNoConflictsRepoPatchV2$fUnwindRepoPatchV2$fConflictRepoPatchV2$fSummaryRepoPatchV2$fPatchDebugRepoPatchV2$fPrimPatchBaseRepoPatchV2$fMergeRepoPatchV2 publicUnravelunravelmerger$fEqRepoPatchV1$fEq2RepoPatchV1$fInvertRepoPatchV1$fIsHunkRepoPatchV1$fEffectRepoPatchV1$fSummaryRepoPatchV1$fUnwindRepoPatchV1$fConflictRepoPatchV1$fCommuteNoConflictsRepoPatchV1$fPatchInspectRepoPatchV1$fCommuteRepoPatchV1$fMergeRepoPatchV1$fCleanMergeRepoPatchV1$fReadPatchRepoPatchV1$fRepairToFLRepoPatchV1$fApplyRepoPatchV1$fShowPatchRepoPatchV1$fShowContextPatchRepoPatchV1ShowDepsFormatShowDepsVerboseShowDepsSummaryHasDepsgetdepsNamedP anonymous infopatchadddepspatch2patchinfo patchname patchcontents fmapNamed fmapFL_Named mergerIdNamedshowDependencies$fPatchDebugNamed $fShow2Named $fShow1Named$fShowContextPatchNamed$fShowPatchBasicNamed $fCheckNamed$fSummaryNamed$fPatchInspectNamed $fUnwindNamed$fConflictNamed $fMergeNamed$fCleanMergeNamed$fCommuteNamed $fEq2Named $fRepairNamed $fApplyNamed$fReadPatchNamed$fPatchListFormatNamed $fIsHunkNamed $fIdEq2Named $fIdentNamed $fEffectNamed$fPrimPatchBaseNamed$fHasDepsNamed$fShowPatchNamed $fShowNamed$fEqShowDepsFormat RebaseNameAddNameDelNameRenamecommuteNamePrimcommutePrimNamecommuterIdNamedcommuterNamedIdcommuteNameNamedcommuteNamedName pushFixupName$fEq2RebaseName$fPatchInspectRebaseName$fInvertRebaseName$fCommuteRebaseName$fReadPatchRebaseName$fShowPatchRebaseName$fShowPatchBasicRebaseName$fShow2RebaseName$fShow1RebaseName$fEqRebaseName$fShowRebaseName RebaseFixup PrimFixup NameFixup namedToFixupspushFixupFixupflToNamesPrimscommuteNamedFixupcommuteFixupNamed$fCommuteRebaseFixup$fReadPatchRebaseFixup$fShowPatchBasicRebaseFixup$fPatchListFormatRebaseFixup$fPatchInspectRebaseFixup$fInvertRebaseFixup$fApplyRebaseFixup$fPrimPatchBaseRebaseFixup$fShow2RebaseFixup$fShow1RebaseFixup$fShowRebaseFixup WPatchInfo unWPatchInfo PatchInfoAndG PatchInfoAnd HopefullycompareWPatchInfoinfo patchDescwinfopiapn2piapatchInfoAndPatch fmapFLPIAPfmapPIAP hopefullyconscientiously hopefullyMactually createHashed extractHash unavailable$fPatchDebugPatchInfoAndG$fIsHunkPatchInfoAndG$fEffectPatchInfoAndG$fReadPatchPatchInfoAndG$fApplyPatchInfoAndG$fPatchInspectPatchInfoAndG$fMergePatchInfoAndG$fCleanMergePatchInfoAndG$fCommutePatchInfoAndG$fShowPatchPatchInfoAndG$fShowContextPatchPatchInfoAndG$fShowPatchBasicPatchInfoAndG$fPatchListFormatPatchInfoAndG$fIdEq2PatchInfoAndG$fIdentPatchInfoAndG$fEq2PatchInfoAndG$fPrimPatchBasePatchInfoAndG$fConflictPatchInfoAndG$fRepairPatchInfoAndG$fShow2PatchInfoAndG$fShow1PatchInfoAndG$fEq2WPatchInfo$fShowPatchNotAvailable$fExceptionPatchNotAvailable$fShowSimpleHopefully$fShowHopefully$fShowPatchInfoAndGTaggedPatchSetSealedPatchSetOrigin emptyPatchSet patchSet2RL patchSet2FL appendPSFLprogressPatchSet patchSetTags inOrderTags patchSetSnoc patchSetSplit patchSetDrop $fShow2Tagged $fShow1Tagged$fShow2PatchSet$fShow1PatchSet $fShowTagged$fShowPatchSet progressFL progressRLprogressRLShowTags splitOnTagcleanLatestTag getUncoveredslightlyOptimizePatchsetremoveFromPatchSetfindCommonAndUncommonfindCommonWithThem findUncommon countUsThem mergeThempatchSetIntersection patchSetUnionareUnrelatedReposcontextPatches withPatchMods makePatchIDapplyToFileMods$fApplyMonadTreeFileModMonad$fApplyMonadTreeFileModMonad0$fFunctorFileModMonad$fApplicativeFileModMonad$fMonadFileModMonad$fMonadStateFileModMonad applyPatches DefaultIO runTolerantly runSilently runDefault$fApplyMonadTreeDefaultIO$fApplyMonadTreeDefaultIO0$fMonadProgressDefaultIO$fTolerantMonadTolerantIO$fTolerantMonadSilentIO$fApplyMonadTreeTolerantWrapper $fApplyMonadTreeTolerantWrapper0$fFunctorDefaultIO$fApplicativeDefaultIO$fMonadDefaultIO$fFunctorTolerantIO$fApplicativeTolerantIO$fMonadTolerantIO$fFunctorSilentIO$fApplicativeSilentIO$fMonadSilentIO$fFunctorTolerantWrapper$fApplicativeTolerantWrapper$fMonadTolerantWrapper$fTolerantMonadTolerantWrapper AnnotateRPAnnotateannotateAnnotateResult annotateFileannotateDirectory machineFormatformat$fAnnotatePrim$fAnnotatePrim0$fShowFileOrDirectory$fEqFileOrDirectory$fShowAnnotated2$fEqAnnotated2$fShowContent2 $fEqContent2unPrim RepoPatchWDDNamedWithDroppedDepswddPatch wddDependedOn RebaseChangeRCrcToPiatoRebaseChangespartitionUnconflicted simplifyPushsimplifyPushes commuterIdWDDextractRebaseChangereifyRebaseChangeaddNamedToRebase$fPatchListFormatRebaseChange$fIsHunkRebaseChange$fPatchInspectRebaseChange$fCommuteRebaseChange$fReadPatchRebaseChange$fShowContextPatchRebaseChange$fShowPatchRebaseChange$fShowPatchBasicRebaseChange$fSummaryRebaseChange$fApplyRebaseChange$fIdentRebaseChange$fHasDepsRebaseChange$fPatchDebugRebaseChange$fPrimPatchBaseRebaseChange$fShow2RebaseChange$fShow1RebaseChange$fEffectWithDroppedDeps$fPrimPatchBaseWithDroppedDeps$fShowRebaseChange RebaseItemToEditFixup$fReadPatchRebaseItem$fShow2RebaseItem$fShow1RebaseItem$fShowRebaseItem SuspendedItems countToEditaddFixupsToSuspendedremoveFixupsFromSuspendedaddToEditsToSuspended$fReadPatchSuspended$fShowPatchBasicSuspended$fPatchInspectSuspended$fShow2Suspended$fShow1Suspended$fShowSuspended WrappedNamedNormalPRebaseP fromRebasing$fCommuteWrappedNamed$fApplyWrappedNamed$fShowPatchBasicWrappedNamed$fPatchListFormatWrappedNamed$fIdentWrappedNamed$fPrimPatchBaseWrappedNamed$fShow2WrappedNamed$fShow1WrappedNamed$fReadPatchReadRebasing$fPatchListFormatReadRebasing$fReadPatchWrappedNamed$fShowWrappedNamed mkInvertiblefromPositiveInvertiblewithInvertible$fShowContextPatchInvertible$fShowPatchInvertible$fShowPatchBasicInvertible$fPrimPatchBaseInvertible$fPatchInspectInvertible$fApplyInvertible$fEq2Invertible$fCommuteInvertible$fInvertInvertible$fIdentInvertible$fSignedIdInvertibleId$fEqInvertibleId$fOrdInvertibleId readOldRepooldRepoFailMsg Repository PristineType NoPristine PlainPristineHashedPristine repoLocationwithRepoLocation repoFormatrepoPristineType repoCache modifyCacheunsafeCoerceRepoTypeunsafeCoercePatchType unsafeCoerceR unsafeCoerceU unsafeCoerceTmkRepo$fShowPristineType$fEqPristineType$fShowRepositorycleanRepository cleanPristine diffHashListscleanInventoriesspecialPatches cleanPatcheslistInventorieslistInventoriesLocallistInventoriesRepoDirlistPatchesLocalBucketedwithManualRebaseUpdatecheckOldStyleRebaseStatus rebaseJobstartRebaseJobmaybeDisplaySuspendedStatuswithTentativeRebasereadTentativeRebasewriteTentativeRebase readRebasecreateTentativeRebasecommuteOutOldStyleRebaseApplyDir ApplyNormal ApplyInvertedapplyToHashedPristineapplyToTentativePristineapplyToTentativePristineCwd#createPartialsPristineDirectoryTreereadHashedPristineRootcreatePristineDirectoryTree withRecorded withTentative readPendingreadTentativePendingwriteTentativePendingtentativelyRemoveFromPendingtentativelyRemoveFromPWmakeNewPendingfinalizePending revertPendingtentativelyAddToPendingsetTentativePending$fShowPatchBasicFLM$fReadPatchFLM PatchFilterdoesPatchIndexExistisPatchIndexDisabledcreateOrUpdatePatchIndexDiskcanUsePatchIndexcreatePIWithInterruptisPatchIndexInSyncdeletePatchIndexattemptCreatePatchIndexgetRelevantSubsequencemaybeFilterPatchesdumpPatchIndexpiTest$fShowFileIdSpan$fEqFileIdSpan$fOrdFileIdSpan$fShowFilePathSpan$fEqFilePathSpan$fOrdFilePathSpan$fShowFileInfo $fEqFileInfo $fOrdFileInfotreeDiff TreeFilterapplyTreeFilterrestrictSubpathsrestrictBoringrestrictDarcsdirunrecordedChangesreadPendingAndWorking readRecordedreadUnrecordedreadUnrecordedFiltered readWorkingreadRecordedAndPendinginvalidateIndexfilterOutConflictsaddPendingDiffToPending addToPendingStandardResolutionmangled unmangledconflictedPathsstandardResolution warnUnmangled showUnmangledshowUnravelledannounceConflictsexternalResolutionpatchsetConflictResolutions PatchSetMatch IndexMatch PatchMatchTagMatch ContextMatch MatchFlag MatchableRP MatchablehelpOnMatchershaveNonrangeMatch patchSetMatch firstMatch secondMatchcheckMatchSyntax matchAPatch hasIndexRangematchFirstPatchsetmatchSecondPatchset splitSecondFLmatchAPatchsetgetMatchingTagrollbackToPatchSetMatch matchingHead $fShowMatcher$fShowMatchFailure$fExceptionMatchFailure$fShowMatchFlag matchUpToOnematchOneContextmatchOneNontag matchSeveral matchLastmatchSeveralOrFirstmatchSeveralOrLastmatchOneOrRange matchRangematchSeveralOrRange matchFrommatchAnycontext GzcrcsAction GzcrcsCheck GzcrcsRepair TestStrategy ChangesFormatGenXml CountPatchesNetworkOptionsnoHttpPipelining WithSummary YesSummaryNoVerify VerifyKeyring HeaderFields_to_cc_from_subject _inReplyTo TestChanges NoTestChangesYesTestChanges ExternalDiffdiffCmddiffOpts diffUnified WithContext NoContext YesContextLookForaddsreplacesmovesLogfile_logfile _rmlogfileAskLongCommentYesEditLongCommentRepoCombinatorNotInDefaultRepoNotInRemotePath SelectDepsNoDepsAutoDeps PromptDeps XmlOutputNoXmlYesXml StdCmdAction RootActionRootHelpYesEnumPatchesYesNoyesno DarcsOption rootActions stdCmdActionsdebug verbositytimings debugginghookspreHookpostHookuseCache xmlOutputdryRun dryRunXmlpipe interactive pauseForGuiaskDeps selectDepschangesReversemaxCountrepoDirnewRepopossiblyRemoteRepo remoteReposnotInRemoteFlagName notInRemoterepoCombinatorallowUnrelatedRepos justThisRepowithWorkingDir setDefaultinheritDefaultauthoraskLongCommentkeepDatelogfilelookfor lookforaddslookforreplaces lookformovesuseIndex includeBoringallowProblematicFilenamesallowCaseDifferingFilenamesallowWindowsReservedFilenames onlyToFiles recursive diffAlgorithm withContextextDiff testChangesrunTest leaveTestDir headerFields sendToContextsendmail sendmailCmdminimizecharseteditDescriptionapplyAssignverify conflictsNo conflictsYes externalMergereordercompressusePacks patchIndexNo patchIndexYes storeInMemoryoutput withSummary maybeSummarynetworkumasksetScriptsExecutable amendUnrecord selectAuthormachineReadable cloneKindmarks readMarks writeMarkshashed patchFormatdistnamedistzip changesFormattokens forceReplace testStrategyfiles directoriespendingnullFlag enumPatches gzcrcsActionssiblings$fYesNoInheritDefault$fYesNoWithWorkingDir$fYesNoWantGuiPause$fYesNoUseIndex$fYesNoLeaveTestDir$fYesNoSetScriptsExecutable$fYesNoRunTest$fYesNoIncludeBoring$fYesNoLookForMoves$fYesNoLookForReplaces$fYesNoLookForAdds $fYesNoDryRun$fYesNoUseCache$fYesNoReorder$fYesNoWithPatchIndex$fYesNoCompression$fYesNoEnumPatches$fYesNoXmlOutput$fYesNoWithContext$fYesNoWithSummary$fEqEnumPatches$fShowEnumPatches$fEqRootAction$fShowRootAction$fEqStdCmdAction$fShowStdCmdAction $fEqXmlOutput$fShowXmlOutput$fEqSelectDeps$fShowSelectDeps$fEqRepoCombinator$fShowRepoCombinator$fEqAskLongComment$fShowAskLongComment$fEqWithContext$fShowWithContext$fEqExternalDiff$fShowExternalDiff$fEqTestChanges$fEqSign $fShowSign $fEqVerify $fShowVerify $fEqOutput $fShowOutput$fEqWithSummary$fShowWithSummary$fEqChangesFormat$fShowChangesFormat$fEqTestStrategy$fShowTestStrategy$fEqGzcrcsAction$fShowGzcrcsActionConfigoptDescrverbosequietenumeratePatches scanKnown diffingOpts wantGuiPause isInteractivewillRemoveLogFile lookForAddslookForReplaces lookForMovesallowConflictsfixRemoteReposfixUrl pathsFromArgspathSetFromArgs getRepourlfileHelpAuthorenvironmentHelpEmail getAuthor promptAuthor getEasyAuthorgetDateenvironmentHelpSendmailgetSendmailCmd getOutput getSubjectgetCc getInReplyTo hasXmlOutput hasLogfileworkRepo withNewRepo sendmailPath diffProgram darcsProgrampipeDoc pipeDocSSH sendEmail generateEmail haveSendmail sendEmailDoc resendEmail execDocPipe signStringverifyPSviewDoc viewDocWitheditTexteditFilesetDarcsEncodingsgetSystemEncoding isUTF8Locale printFriendlyshowWithSummary printSummary printContentprintContentWithPagercontextualPrintPatchMarks emptyMarkslastMarkgetMarkaddMark patchHash updatePendingBundleinterpretBundle makeBundle parseBundlereadContextFile minContextUpdatePristineDontUpdatePristineDontUpdatePristineNorRevertrevertTentativeChangesfinalizeTentativeChangesaddToTentativeInventoryreadRepoHashedreadTentativeRepocopyHashedInventorywriteAndReadPatchwriteTentativeInventorytentativelyAddPatchtentativelyAddPatches_tentativelyAddPatch_tentativelyRemovePatchestentativelyRemovePatches_finalizeRepositoryChangesrevertRepositoryChangesreorderInventoryreadReporepoXorupgradeOldStyleRebase$fEqUpdatePristineRepositoryConsistencyRepositoryConsistentBrokenPristine BrokenPatchesreplayRepositoryInTempreplayRepository checkIndexpacksDirfetchAndUnpackPatchesfetchAndUnpackBasic createPackstentativelyMergePatchesconsiderMergeToWorking$fEqMakeChangesgetRecordedUpToMatchgetOnePatchset PrimWithNamewnNamewnPatch$fShowContextPatchPrimWithName$fShowPatchPrimWithName$fShowPatchBasicPrimWithName$fReadPatchPrimWithName$fCleanMergePrimWithName$fCommutePrimWithName$fPrimDetailsPrimWithName$fPrimClassifyPrimWithName$fPrimApplyPrimWithName$fIsHunkPrimWithName$fAnnotatePrimWithName$fRepairToFLPrimWithName$fPatchListFormatPrimWithName$fApplyPrimWithName$fShow2PrimWithName$fShow1PrimWithName$fShowPrimWithName$fPatchInspectPrimWithName$fInvertPrimWithName$fEq2PrimWithName$fIdEq2PrimWithName$fIdentPrimWithName RepoPatchV3 ConflictorPPrimP+|-|$fShowPatchBasicRepoPatchV3$fReadPatchRepoPatchV3$fShowContextPatchRepoPatchV3$fShowPatchRepoPatchV3$fRepairToFLRepoPatchV3$fCheckRepoPatchV3$fUnwindRepoPatchV3$fSummaryRepoPatchV3$fIsHunkRepoPatchV3$fPatchListFormatRepoPatchV3$fApplyRepoPatchV3$fPatchDebugRepoPatchV3$fToPrimRepoPatchV3$fPrimPatchBaseRepoPatchV3$fShow2RepoPatchV3$fShow1RepoPatchV3$fShowRepoPatchV3$fEq2RepoPatchV3$fPatchInspectRepoPatchV3$fCommuteRepoPatchV3$fCommuteNoConflictsRepoPatchV3$fMergeRepoPatchV3$fCleanMergeRepoPatchV3$fIdentRepoPatchV3$fEffectRepoPatchV3$fConflictRepoPatchV3 $fShowNode NamedPrim PrimPatchIdunsafePrimPatchIdprop_primPatchIdNonZeropositivePrimPatchIds namedPrimanonymousNamedPrim$fStorableIdPrimPatchId$fSignedIdPrimPatchId$fEqPrimPatchId$fOrdPrimPatchId$fShowPrimPatchId$fFromPrimRepoPatchV3applyToWorkingsetScriptsExecutablePatchesgetTest runPosthook runPrehook testTentativeReadingOrWritingReadingWriting IdentifyRepo BadRepository NonRepositoryGoodRepositorymaybeIdentifyRepositoryidentifyRepositoryidentifyRepositoryForamInRepositoryamInHashedRepositoryseekRepoamNotInRepositoryfindRepositoryfindAllReposInDirIsPrimV1toPrimV1RepoJobV1JobV2Job PrimV1JobRebaseAwareJob RebaseJob OldRebaseJobStartRebaseJob withUMaskFlagwithRepositorywithRepositoryLocation withRepoLockwithOldRepoLockwithRepoLockCanFailcheckRepoIsNoRebase$fIsPrimV1Prim$fIsPrimV1Prim0fileArgsunknownFileArgs knownFileArgsmodifiedFileArgsprefArgsnoArgsEmptyRepositorycreateRepositorycreateRepositoryV1createRepositoryV2 writePristinecloneRepositoryreplacePristineKeyPresskpkpHelpInteractiveSelectionMInteractiveSelectionStateISCtotalcurrentlpschoicesSelectionConfig allowSkipAllPatchSelectionOptions matchFlags WhichChangesLast LastReversedFirst FirstReversedselectionConfigPrimselectionConfigselectionConfigGeneric runSelectionrunInvertibleSelection viewChangeshelpForkeysForwithSelectedPatchFromListinitialSelectionState currentPatch currentFiledecidedecideWholeFileskipOnebackOnebackAll isSingleFile promptUser skipMundaneaskAboutDepends$fEqWhichChanges$fShowWhichChanges AskAboutDepsNoAskAboutDepsHijackT HijackOptions IgnoreHijackRequestHijackPermissionAlwaysRequestHijackPermissiongetLog runHijackTupdatePatchHeader CommandArgs CommandOnlySuperCommandOnlySuperCommandSub DarcsCommand SuperCommandcommandProgramName commandName commandHelpcommandDescriptioncommandExtraArgscommandExtraArgHelpcommandCommand commandPrereqcommandCompleteArgscommandArgdefaultscommandBasicOptionscommandAdvancedOptionscommandDefaultscommandCheckOptionscommandSubCommandsCommandControl CommandData HiddenCommand GroupNameextractCommandsextractAllCommands normalCommand hiddenCommand commandGroup withStdOptscommandAlloptionscommandOptions nodefaultsgetSubcommands commandAlias commandStub superNamedisambiguateCommands putVerboseputInfo putFinished putWarningputVerboseWarningabortRunsetEnvDarcsPatchessetEnvDarcsFiles defaultRepousagesubusagegetCommandMiniHelpgetCommandHelpgetSuperCommandHelp announceFilestestTentativeAndMaybeExitprintDryRunMessageAndExitfilterExistingPathsgetUniqueRepositoryNamegetUniqueDPatchNamecheckUnrelatedReposgetLastPatchespreselectPatcheshistoryEditHelpwhatsnewstatusunrevert writeUnrevertunrecordunpull obliterate transferModetest$fShowBisectDirtagshowTagsshowReposhowPatchIndex showIndex showPristine showFilesshowDeps showContentsSpelling showAuthors rankAuthorscanonizeAuthorcompiledAuthorSpellings showCommandsetprefrollbackrevertreplacerepaircheckremovermunaddrecordcommitoptimizemv$fShowFileKind $fEqFileKind$fShowFileStatus markconflicts$fTraversableOnly$fFoldableOnly $fFunctorOnly$fEqOnly $fOrdOnly $fShowOnlylog logInfoFL simpleLogInfo changelogchanges initialize initializeCmd doCRCWarningsgzcrcsdist doFastZip doFastZip' diffCommand convertImport $fShowState $fShowRefId$fShowCopyRenameNames $fShowObject convertExport convertDarcs2convertclonegetput cloneToSSH makeRepoNameotherHelpInheritDefaultsendpushamend amendrecordaddStandardPatchApplier PatchApplierApplierRepoTypeConstraintrepoJob PatchProxyapplyPatchesStartapplyPatchesFinish"$fPatchApplierStandardPatchApplierfetchpullpullCmd fetchPatchesapplyCmdgetPatchBundlerebase $fPatchApplierRebasePatchAppliercommandControlList applyDefaults runTheCommand runWithHookshelpCmdlistAvailableCommands printVersionsingletonRebaseType unescapeCharsnormalRegChars breakOutTokenFTableData.ByteString.Internal ByteStringmarkColldiffArrcmpseqfindDiagfindOne findSnake findOneRev findSnakeRev nextUnchangedskipOneUnChangednextUnchangedN nextChanged prevUnchangedlcus patientLcslcsHelper&vector-0.12.1.2-KSb3nsihfSnCDYOh5IjlsC Data.VectorVector neighboursgsizeprop_is_independent_setprop_is_maximal_independent_setprop_is_partitionprop_self_containedprop_connectedprop_connected_component'old-time-1.1.0.3-2XkcGgLYS3G4Bt8PCBG9iL System.Time CalendarTimereadDatedateTimecaseCharparsec-3.1.13.0Text.Parsec.Char caseStringmanyNmanyNtoM cvsDateTimeiso8601DateTime oldDateTimerfc2822DateTime iso8601Date iso8601TimeoptchainmySpacesdayNameyearmonthNum intToMonth monthNamedayhourminutesecondzone englishDate englishTime englishAgoenglishDuration multiplyDiff copyCalendar withinDay dateRange cDateRangewithinsamePartialDate tryMatchers testDateAtCal showMatcherDocumentStspacePnewlinePhPrintPrintableshPrintPrintable renderWithsimplePrinters'appendqEncodePolicypoColorpoEscape poLineColor poAltColor poIsprintpo8bitpoNoEscXpoEscX poTrailingpoCRpoSpace getPolicylineColorTransescapenoEscapeisPrintableAscii quoteChar markEscapecolor makeAsciiart resetColor withColorsetColormakeBold makeInvert _progressDataPoly _forceCommutecatch firstJustMRepoId Connection detectSshsshConnectionsGHC.MVarMVargetSshConnectionnewSshConnectiondropSshConnectionshowCommandLineord simpleClean pathToPosix normSlashesinternalMakeName parentChild sortedUnion modifyItem flushSomereadDarcsHashed'fsCreateHashedFilenextFresitemF_fileIDschangednexttreeitemresitemState dirlengthpathstartItemindex_endianness_indicator createItempeekItem updateItem mmapIndexnameofmaybeAppendName substateofwithDir darcs1Format darcs2Format darcs3FormathashedInventoryFormatnoWorkingDirFormatrebaseInProgressFormatrebaseInProgress_2_16newStyleRebaseInProgress findProblemsisKnowncompareByLocalityhashedFilePathReadOnlycopyFileUsingCachecheckCacheReachabilityfilterBadSources checkHashedInventoryReachabilityfetchFileUsingCachePrivatewriteSingleArgOptDescr switchNames rawUnparserawParsedefHeadaddDefaultHelpmultiArgtryMakeBoringRegexpdefaultBinaries PatchChoicepcPatch _pcIsLast pcSetLast pushLastspcsMiddleLastsforceMatchingMiddleOrLasttrackOrigRenamevalidCharForDate readPatchDatemetadataToStringstorePatchInfo readHashFilemInSubDirectorygetaprop_ctxNotComprop_ctxNotInv readBinary FileStateunknownFileState applyHunk applyHunks shrinkABittryOnesortCoalesceFL2pushCoalescePatch coalescePairdecoalescePair SummChunkWLCommonRLCommonmergeAfterConflicting allNormalcommuteConflictingallConflictsWith pullCommon pullCommonRL mergerCommutePatchNotAvailableSimpleHopefullytaggedIntersectionmaybeSplitSetOnTagunwrapOneTagged pushThroughforceCommuteNameFwdRev makeFilename DirLayout PlainLayoutBucketedLayoutlistInventoriesWithlistPatchesLocalreadInventoryLocal readInventory copyPristinereadNewPendingreadPendingFilewriteNewPending removeRLFL removeAllFLdecoalesceAllFL decoalesceFL PatchIndexpidsInfoMap FilePathSpans FileIdSpansFileInfotouchingversionapplyPatchModscreateFidStartSpan startFpSpan stopFpSpan startFidSpan stopFidSpan createInfo insertTouch lookupFid lookupFid' lookupFidf' lookupFids lookupFids'createPatchIndexDiskpatches2patchModsfpSpans2fileNamesremovePidSuffixupdatePatchIndexDiskcreatePatchIndexFromloadPatchIndexloadSafePatchIndexstorePatchIndexfpSpans2filePathsfpSpans2filePaths' canCreatePIFpSpanFidSpanrestrictSubpathsAfterfilteredWorkingworkDirLessRepoWitnessgetMoves getReplacesexternallyResolveFile MatchFailureMatcherMatchFun applyMatcher strictJustnonrangeMatcher firstMatcherhasLastnapplyInvToMatcher applyNInv applyInvpprimitiveMatchersmaybeFixSubPaths PipeToSsh PipeToOtherget_system_encoding ortryrunningGHC.IO.EncodinggetFileSystemEncodingsetLocaleEncoding hashBundleinterpretContextdecodeGpgClearsignedaddToSpecificInventory writeHashFilereadRepoUsingSpecificInventoryreadRepoFromInventoryListreadInventoryPrivateremoveFromTentativeInventoryfetchFilesUsingCachevoidcontainers-0.6.0.1Data.Set.InternalinsertdeleteNode neighborsself findVertices conflictsWith findEdges alternativessetScriptsExecutable_ UsesPrimV1IsTree RepoPatchTypehaveknownnew notYetListedfetchPatchesIfNecessaryMatchCriterionbackwardreversedtriviswantedwspfr liftChoicesjustDone textSelecttodo modifyChoices postponeNext splitCurrent printSelectedskipAll textSelectOne printCurrenttextView getDefaultindependentPatchIds patchFilename remotePatchesrunInteractiveinteractiveHunksgenericObliterateCmdBisectProgress BisectDir PatchTreeStrategyoneTest trackLinear trackBackoff trackBisectpatchTreeFromRL patchTree2RLtrackNextBisecttrackNextBackoff validPrefDataisTok chooseToks filenameToks replaceHelpmakeRemovePatch makeRemoveGapcheckNameIsNotOptionShadowmoveFile fileStatusPathSet EverythingOnlyfromOnly isectPathSet showPathSetfilterPatchesByNamesdoDistgetDiffCmdAndArgsW3W2convertDarcs2Help'guardRemoteDirDoesNotExistconvertUpToToOnePostSendMail OptionMapCmdName mkCmdName showCmdNameSuperCmd parseDefaultsparseDefaultsLines defaultToFlagoptionSwitches optionMapallOptionSwitchesgetPosthookDirextraArgumentsErrorweakhash unwrapTree completeArgsenvironmentHelpmanpage