d 4      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ [ \ ] ^ _ ` 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 { | } ~        !"#$%&'()*+,-./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*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/h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z0{0|0}0~000000001111222222223333333333333333333333333334444444555555566666666666666677889:::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;<=====>>> > > > > >>>>>>>>>>>>>>>>>>> >!>">#>$>%>&>'>(>)>*>+>,>->.>/>0>1>2>3>4>5>6>7?8?9?:?;?<?=@>A?A@AABBBCBDBEBFBGBHBIBJBKBLBMCNCOCPCQDRESETEUFVFWFXFYFZF[F\F]F^F_F`FaFbFcFdFeGfGgGhGiGjGkGlGmHnHoHpHqHrHsHtHuHvHwHxIyIzJ{K|K}L~LLLLLLLMMMMMMMMMMMMNOOOOOOOOOOOOOOOOOOOOPPPPQQQQQQQQQQQRRRSSSSSTTTTTTTTTTTTTTTTTUUUUUUUUVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXYZ[[[[[[[[[[[ [ [ [ [ [[[[\\\\\\\\\\\]]]] ]!]"]#]$]%^&^'^(^)^*^+^,^-^.^/^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`cadaeafbgbhcidjdkdldmdndodpdqdrdsdteuevewexeyezf{f|f}f~fffffffffgggggghhhhhhhhhhhhhhhhhhhhhhiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjkkkkkkklllllllllllllllllllllllllllllllll l l l l lllllllllllllllllll l!l"l#l$l%l&l'l(l)l*l+l,l-l.l/l0l1l2l3l4l5l6l7l8l9l:l;l<l=l>l?l@lAlBlClDlElFlGlHlIlJlKlLlMlNlOlPlQlRlSlTlUlVlWlXlYlZl[l\l]l^l_l`lalblcldlelflglhliljlklllmlnlolplqlrlsltlulvlwlxlylzl{l|l}l~llllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnoooppqqrrrrrrrrrrrrrrrrrrrrrrrrrsssssssssssstttttuuvwwxxyyyyyyyzz{|}~~      !"#$%&'()*+,-./0123 Safe-Infered+Data type to represent a connection error. * The following are the codes from libcurl ( which map to each of the constructors: A * 6 -> CouldNotResolveHost : The remote host was not resolved. I * 7 -> CouldNotConnectToServer : Failed to connect() to host or proxy. F * 28 -> OperationTimeout: the specified time-out period was reached.  !"#$%&'()*+,-./012  !"#$%&'()*+,-./012 &'()*+"%$# !,-./012  !"%$#&'()*+,-./012 Safe-Infered3456789:;<=>?@AB3456789:;<=>?@AB798;<:5634>=@?AB 3456798:;<=>?@AB Safe-InferedCRead/2interpret a date string, assuming UTC if timezone " is not specified in the string CDCDCDCD Safe-Infered EFGHIJKLMNOP EFGHIJKLMNOP OPNJLKEFGHIMEFGHIJLKMNOP Safe-InferedT1This type is used to tweak the way that lists of p are shown for a given  Patch type p>. It is needed to maintain backwards compatibility for V1 and  V2 patches. UShow lists without braces 9 Read with arbitrary nested parens and flatten them out. V=Show lists with a single layer of braces around the outside, - except for singletons which have no braces. D Read with arbitrary nested braces and parens and flatten them out. W$Show and read lists without braces. XIShowing and reading lists of patches This class allows us to control how L lists of patches are formatted on disk. For legacy reasons V1 patches have " their own special treatment (see T). Other patch types use the M default format which just puts them in a sequence without separators or any  prelude/ epilogue. This means that ' FL (FL p)'3 etc would be ambiguous, so there are no instances  for 'FL p' or other list types. QRSTUVWXY QRSTUVWXY XYTWVUQSRQSRTWVUXY  Safe-InferedZZ< returns a filter function that tells if a char is a member I of the regChar expression or not. The regChar expression is basically a 9 set of chars, but it can contain ranges with use of the 4 (dash), and @ it can also be specified as a complement set by prefixing with 5 C (caret). The dash and caret, as well as the backslash, can all be = escaped with a backslash to suppress their special meaning.  NOTE: The 6; (dot) is allowed to be escaped. It has no special meaning ' if it is not escaped, but the default  filename_toks in 4 Darcs.Commands.Replace uses an escaped dot (WHY?). ZZZZ portable experimentaldarcs-devel@darcs.net Safe-Infered[An  MCalenderTime is an underspecified 7 D 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 8'. This uses almost the same fields as  7$, a notable exception being that we  introduce i/ to indicate if a weekday was specified or not kRead/2interpret a date string, assuming UTC if timezone ' is not specified in the string (see 9) 8 Warning! This errors out if we fail to interpret the  date l>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 mRead/8interpret a date string, assuming local timezone if not  specified in the string n5Return the local timezone offset from UTC in seconds o4Parse a date string, assuming a default timezone if ; the date string does not specify one. The date formats  understood are those of : and ; p+The current time in the format returned by : qIntervals in ISO 8601, e.g.,  2008-09/2012-08-17T16:30  2008-09/P2Y11MT16H30M  P2Y11MT16H30M/2012-08-17T16:30 See r rDurations in ISO 8601, e.g.,  P4Y (four years)  P5M (five months) $ P4Y5M (four years and five months) 4 P4YT3H6S (four years, three hours and six seconds) sBIn English, either a date followed by a time, or vice-versa, e.g,  yesterday at noon  yesterday tea time  12:00 yesterday See < and =  Uses its first argument as now", i.e. the time relative to which   yesterday, today etc are to be interpreted t+English expressions for intervals of time, 3 before tea time (i.e. from the beginning of time) ( after 14:00 last month (i.e. till now) " between last year and last month 4 in the last three months (i.e. from then till now) " 4 months ago (i.e. till now; see >) u.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 vTrivially convert a 7 to a fully specified  [ (note that this sets the i flag to  False wReturns the first 7 that falls within a [ D 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 0 for the seconds field. 0 Maybe we should rename it something happier.  See also z zDSet a calendar to UTC time any eliminate any inconsistencies within / (for example, where the weekday is given as Thursday, but this does not ; match what the numerical date would lead one to expect) {Zero the time fields of a 7 ![\]^_`abcdefghijklmnopqrstuvwxyz{![\]^_`abcdefghijklmnopqrstuvwxyz{!pmkonstuqrlz[\]^_`abcdefghiyxvw{j[\]^_`abcdefghijklmnopqrstuvwxyz{ portable experimentaldarcs-devel@darcs.net Safe-Infered|A |. combines a potential parse for a date string  with a matcher) function that operates on a given date. 6 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. ~~ s return the first matcher in   that can parse s  d+ returns the list of matchers that will be  applied on d0. If you wish to extend the date parsing code, > this will likely be the function that you modify to do so. |}~|}~~|}|}~ Safe-Infered  Safe-Infered portable experimentaldarcs-devel@darcs.net Safe-Infered 1 singular This (Noun "batch") "" == "this batch" 4 plural This (Noun "batch") "" == "these batches" 8This only distinguishes between nouns with a final -ch,  and nouns which do not. > More irregular nouns will just need to have their own type ' plural (Noun "batch") "" == "batches" $ plural (Noun "bat") "" == "bats" - plural (Noun "mouse") "" == "mouses" -- :-( 0Things that have a plural and singular spelling - englishNum 0 (Noun "watch") "" == "watches" + englishNum 1 (Noun "watch") "" == "watch" - englishNum 2 (Noun "watch") "" == "watches" -Given a list of things, combine them thusly: 6 orClauses ["foo", "bar", "baz"] == "foo, bar or baz" -Given a list of things, combine them thusly: 6 orClauses ["foo", "bar", "baz"] == "foo, bar or baz" As  intersperse*, with a different separator for the last  | interspersal. ?@A ?@Aportable experimentaldarcs-devel@darcs.net Safe-Infered   Safe-Infered!An witness aware equality class. ) A minimal definition defines any one of ,  and . AIt is unsafe to define a class instance via this method, because 8 if it returns True then the default implementations of  and  , will coerce the equality of two witnesses. &Calling this method is safe, although  or  would be better D choices as it is not usually meaningul to compare two patches that  don'/t share either a starting or an ending context ACompare two things with the same starting witness. If the things B compare equal, evidence of the ending witnesses being equal will  be returned. ?Compare two things with the same ending witness. If the things D compare equal, evidence of the starting witnesses being equal will  be returned. 6 is used to pass around evidence (or lack thereof) of  two witness types being equal. BCBC Safe-InferedDD Safe-Infered abstracts over  and $ for code constructing these values  An empty , e.g. NilFL or NilRL A O constructed from a completely polymorphic value, for example the constructors  for primitive patches  Compose two ! values together in series, e.g. ' joinGap (+>+)' or ' joinGap (:>:)' ' FreeLeft p' is 'f orall y . exists x . p x y' A In other words the caller is free to specify the right witness, . and then the left witness is an existential. H Note that the order of the type constructors is important for ensuring  that x is dependent on the y that is supplied. ' FreeLeft p' is 'f orall 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. H 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 E1 is needed, rather than writing the more obvious  'Sealed (Poly p)'5 which would notionally have the same quantification  of the type witnesses.  Unwrap a  value  Unwrap a  value !FGHIJFGHIJportable experimentaldarcs-devel@darcs.net Safe-InferedKRegisters an IO action to run just before darcs exits. Useful for removing H temporary files and directories, for example. Referenced in Issue1914.  Safe-InferedKKportable experimentaldarcs-devel@darcs.net Safe-InferedbeginTedious k. starts a tedious process and registers it in  L with the key k-. A tedious process is one for which we want  a progress indicator. Wouldn'Ft it be safer if it had type String -> IO ProgressDataKey, so that we O can ensure there is no collision? What happens if you call beginTedious twice C with the same string, without calling endTedious in the meantime?  endTedious k* unregisters the tedious process with key k , printing  Done# if such a tedious process exists. XXX: document this constant portable experimentaldarcs-devel@darcs.net Safe-Infered M M Safe-Infered NOPQRSTUVW NOPQRSTUVW NOPQRSTUVWportable experimentaldroundy@abridgegame.org Safe-Infered=Do something with the internals of a PackedString. Beware of  altering the contents! EreadIntPS skips any whitespace at the beginning of its argument, and F reads an Int from the beginning of the PackedString. If there is no J integer at the beginning of the string, it returns Nothing, otherwise it E just returns the int read, along with a B.ByteString containing the  remainder of its input.  Decodes a  ByteString containing UTF-8 to a X. Decoding errors are & flagged with the U+FFFD character.  efficiently returns the  ByteString argument with E white space Chars removed from the front. It is more efficient than 1 calling dropWhile for removing whitespace. I.e.  dropWhile isSpace == dropSpace 6 returns the pair of ByteStrings when the argument is + broken at the first whitespace byte. I.e.  break isSpace == breakSpace $This function acts exactly like the Prelude unlines function, or like Data.ByteString.Char8 Y-, but with one important difference: it will <produce a string which may not end with a newline! That is:   unlinesPS ["foo", "bar"]  evaluates to "foo\nbar", not "foo\nbar\n""! This point should hold true for  as well. TODO: rename this function. QDecompress the given bytestring into a lazy list of chunks, along with a boolean 7 flag indicating (if True) that the CRC was corrupted. R Inspecting the flag will cause the entire list of chunks to be evaluated (but if I you throw away the list immediately this should run in constant space). GRead an entire file, which may or may not be gzip compressed, directly  into a Z. GRead standard input, which may or may not be gzip compressed, directly  into a Z. ;Like readFilePS, this reads an entire file directly into a  Z7, but it is even more efficient. It involves directly J mapping the file to memory. This has the advantage that the contents of I the file never need to be copied. Also, under memory pressure the page J may simply be discarded, wile in the case of readFilePS it would need to G be written to swap. If you read many small files, mmapFilePS will be I less memory-efficient than readFilePS, since each mmapFilePS takes up a I separate page of memory. Also, you can run into bus errors if the file  is modified. NOTE: as with  readFilePS, the string representation in ' the file is assumed to be ISO-8859-1. EbetweenLinesPS returns the B.ByteString between the two lines given, # or Nothing if they do not appear.  1Test if a ByteString is made of ascii characters  @Decode a ByteString to a String according to the current locale N unsafePerformIO in the locale function is ratified by the fact that GHC 6.12 J and above also supply locale conversion with functions with a pure type. 7 Unrecognized byte sequences in the input are skipped.  @Encode a String to a ByteString according to the current locale  Take a String: that represents byte values and re-decode it acording to  the current locale.                      Safe-Infered Safe-InferedRun the parser / checks if the next space delimited token from % the input stream matches a specific [.  Uses \ inside  to handle failed matches, so ' that it always returns () on success. 2 fetches the next whitespace delimited token from - from the input and checks if it matches the  ByteString input.  Uses \ inside  to handle failed matches, so ' that it always returns () on success. ;Only succeeds if the characters in the input exactly match str. 9 looks for optional spaces followed by the end of input.  Uses \ inside  to handle failed matches, so ' that it always returns () on success. Like ] except that it is in ParserM AAccepts the next character and returns it. Only fails at end of  input. 7Only succeeds at end of input, consumes no characters. @Accepts only the specified character. Consumes a character, if  available. ?Parse an integer and return it. Skips leading whitespaces and * | uses the efficient ByteString readInt. <Discards spaces until a non-space character is encountered.  Always succeeds. #Discards any characters as long as p returns True. Always  | succeeds. Takes characters while p! returns True. Always succeeds. Equivalent to takeTill (==c)", except that it is optimized for  | the equality case. Takes exactly n bytes, or fails.  ?This is a highly optimized way to read lines that start with a E particular character. To implement this efficiently we need access  to the parser'6s internal state. If this is implemented in terms of C the other primitives for the parser it requires us to consume one % character at a time. That leads to (>>=) wasting significant  time. !?This is a highly optimized way to read lines that start with a @ particular character, and stops when it reaches a particular |  character. See   for details on why this |  defined here as a primitive. "If p fails it returns x%, otherwise it returns the result of p. #)Attempts each option until one succeeds. $<Ensure that a parser consumes input when producing a result I Causes the initial state of the input stream to be held on to while the # parser runs, so use with caution. %%* applies the parser functions to a string ; and checks that each parser produced a result as it goes.  The strictness is in the  instance for ^.  !"#$%_`abcd !"#$%%"#$ ! !"#$%_`abcd Safe-Infered7-@A set of printers to print different types of text to a handle. 7a 7 is a bit of enriched text. 7s get concatanated using  r, which is right-associative. :A :4 is either a String, a packed string, or a chunk of ! text with both representations. >Minimal 7%s representing the common characters >, ?  @, A, and B. ?Minimal 7%s representing the common characters >, ?  @, A, and B. @Minimal 7%s representing the common characters >, ?  @, A, and B. AMinimal 7%s representing the common characters >, ?  @, A, and B. BMinimal 7%s representing the common characters >, ?  @, A, and B. CC is the 7 that represents "(" DD is the 7 that represents ")" EE doc returns a 7 with the content of doc put within  a pair of parenthesis. GG/ puts a doc on stdout using the given printer. HH3 puts a doc, followed by a newline on stdout using  the given printer. II/ puts a doc on stdout using the simple printer m. JJ3 puts a doc, followed by a newline on stdout using  m K hputDocWith9 puts a doc on the given handle using the given printer. L hputDocLnWith0 puts a doc, followed by a newline on the given ! handle using the given printer. MhputDoc& puts a doc on the given handle using m O renders a 7 into a X with control codes for the  special features of the doc. P renders a 7 into a X using a given set of printers. Q renders a 7 into Z with control codes for the ' special features of the Doc. See also  readerString. R renders a 7 into a list of  PackedStrings, one for each line. Srenders a doc into a Z using a given set of printers. T renders a 7 into a list of  PackedStrings, one for each A chunk of text that was added to the doc, using the given set of  printers. YY builds a Doc from a X and a Z representing 1 the same text, but does not check that they do. ZZ builds a 7 from a X. The string is stored in the  Doc as both a String and a Z. [[ builds a 7 from a Z using l \\ builds a 7 from a Z using n ]] creates a 7 with invisible text from a Z ^^ creates a 7" representing a user chunk from a Z. __. creates a Doc containing just one character. `` creates a 7 from a String, using l. aa creates a 7 from a X, using n directly bb creates a 7" containing invisible text from a String cc creates a 7 containing hidden text from a String dd creates a 7 containing a user chunk from a String ee creates a 7 containing blue text from a String fe creates a 7 containing blue text from a String ge creates a 7 containing blue text from a String he creates a 7 containing blue text from a String ie creates a 7 containing blue text from a String jj creates a 7 containing colored text from a String kk n s is a 7 representing s line-wrapped at n characters l' printable x' creates a 7 from any :. mm is a 6 which uses the set 'simplePriners\'' on any  handle. nn is the simplest , : it just concatenates together  the pieces of the 7 oo is the ,# for hidden text. It just replaces  the document with p. It'%s useful to have a printer that doesn't H 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. p The empty 7. r'( )'# is the concatenation operator for 7s sa s b is a   b if a is not empty, else empty. ta t b is a followed by a space, then b. ua u b is a above b. vv piles vertically a list of 7s. ww piles vertically a list of 7%s leaving a blank line between each. xx' concatenates (horizontally) a list of 7s S&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxS&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxS:=<;7896-./012345,&+*)('MNIJKLGHOPQSRTWUVjbcXd`lkeihgfaYZ_][\^monqprstuvwx>B@A?CDEFA&+*)(',-./0123456789:=<;>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx Safe-Inferedyz{|yz{|yz{|yz{| Safe-Infered.Gives the (user, host, dir) out of an ssh url }~ }~}~~ }~ Safe-InferedJFormats an e-mail header by encoding any non-ascii characters using UTF-8 D and Q-encoding, and folding lines at appropriate points. It doesn't do A more than that, so the header name and header value should be I well-formatted give or take line length and encoding. So no non-ASCII J characters within quoted-string, quoted-pair, or atom; no semantically J meaningful signs in names; no non-ASCII characters in the header name;  etcetera. portable experimentaldarcs-devel@darcs.net Safe-InferedCcreate a list of changes between a and b, each change has the form A (starta, lima, startb, limb) which means that a[starta, lima) ) has to be replaced by b[startb, limb) Ftry to create nicer diffs by shifting around regions of changed lines  Safe-InferedCheck that two  s are equal element by element.  This differs from the  instance for  which  uses commutation. Befghijklmnopqrs339efghijklmnopqrs Safe-InferedThings that can commute. 3Swaps the ordered pair type so that commute can be  called directly. 4Swaps the ordered pair type from the order expected " by commute to the reverse order. tu tu Safe-Infered Safe-Infered JCommuteFn is the basis of a general framework for building up commutation M operations between different patch types in a generic manner. Unfortunately R type classes are not well suited to the problem because of the multiple possible I routes by which the commuter for (FL p1, FL p2) can be built out of the N commuter for (p1, p2) - and more complicated problems when we start building Q multiple constructors on top of each other. The type class resolution machinery  really can'2t cope with selecting some route, because it doesn't know that all ' possible routes should be equivalent.  split an  into left and right lists according to a predicate p", using commutation as necessary. ] If a patch does satisfy the predicate but cannot be commuted past one that does not satisfy  the predicate, it goes in the middle list; to sum up, we have:  all p left and all (not.p) right, while  midddle is mixed.  split an  into left and rightA lists according to a predicate, using commutation as necessary. ] If a patch does satisfy the predicate but cannot be commuted past one that does not satisfy  the predicate, it goes in the left list.  x xs removes x from xs if x can be commuted to its head.  Otherwise it returns 8  is like  except with   ab abc returns Just c' where all the patches in  abE 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 8.  is like removeSubsequenceFL except that it works  on  This is a minor variant of  with each permutation  is simply returned as a   p:>:ps* 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  X :> 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 c  is like , except that we  operate on an 8 (in other words, we are pushing things to the end of a 0 patch sequence instead of to the beginning). UBuild a commuter between a patch and itself using the operation from the type class. VPartition a list into the patches that commute with the given patch and those that don't (including dependencies) 2predicate; if true we would like the patch in the left list input  left, middle and right 2predicate; if true we would like the patch in the right list input  left and right results vwxyvwxy  Safe-InferedEThis type exists for legacy support of on-disk format patch formats. N It is a wrapper type that explicitly tracks the nesting of braces and parens N in the on-disk representation of such patches. It is used as an intermediate K 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. z  z!portable experimentaldarcs-devel@darcs.net Safe-Infered!Things that can always be merged {|{|" Safe-Infered}~}~# Safe-Infered"AClowns 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 See   $ Safe-Infered8 translates whitespace in filenames to a darcs-specific 1 format (numerical representation according to  surrounded by M 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"  interprets the Darcs-specific "encoded" filenames  produced by  0 decodeWhite "hello\32\there" == "hello there" 0 decodeWhite "hello\92\there" == "hello\there" ; decodeWhite "hello\there" == error "malformed filename"  !Split a file path at the slashes                     % Safe-InferedEThis 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. GPaths which are relative to the local darcs repository and normalized. : Note: These are understood not to have the dot in front. 8Make the second path relative to the first, if possible FInterpret a possibly relative path wrt the current working directory. FTake an absolute path and a string representing a (possibly relative) H path and combine them into an absolute path. If the second argument is L already absolute, then the first argument gets ignored. This function also A takes care that the result is converted to Posix convention and ' normalized. Also, parent directories ("..") at the front of the string C argument get canceled out against trailing directory parts of the  absolute path argument. IRegarding the last point, someone more familiar with how these functions J are used should verify that this is indeed necessary or at least useful. (The root directory as an absolute path. EExecute either the first or the second argument action, depending on  whether the given path is an  or stdin/stdout. $ !"# !"# #!"" !"#&portable experimentaldarcs-devel@darcs.net Safe-Infered (only shown on help /KThe firstJustIO is a slight modification to firstJustM: the entries in the M list must be IO monad operations and the firstJustIO will silently turn any N monad call that throws an exception into Nothing, basically causing it to be  ignored. 3@Given two shell commands as arguments, execute the former. The E latter is then executed if the former failed because the executable  wasn't found (code 127), wasn'&t executable (code 126) or some other C exception occurred. Other failures (such as the user holding ^C) . do not cause the second command to be tried. 6"Ask the user for a line of input. 7Ask the user to press Enter 8askUserListItem prompt xs enumerates xs on the screen, allowing ' the user to choose one of the items :FFormat a path for screen output, so that the user sees where the path O begins and ends. Could (should?) also warn about unprintable characters here. = editFile f< lets the user edit a file which could but does not need to O already exist. This function returns the exit code from the text editor and a / flag indicating if the user made any changes. B Prompt the user for a yes or no DKConstruct a filter from a list of AnchoredPaths, that will accept any path L that is either a parent or a child of any of the listed paths, and discard  everything else. ESame as  filterPath, but for ordinary s (as opposed to  AnchoredPath). KTIn some environments, darcs requires that certain global GHC library variables that P control the encoding used in internal translations are set to specific values. setDarcsEncoding: enforces those settings, and should be called before the N first time any darcs operation is run, and again if anything else might have * set those encodings to different values. Note that it isn'7t thread-safe and has a global effect on your program. FThe current behaviour of this function is as follows, though this may  change in future: GEncodings are only set on GHC 7.4 and up, on any non-Windows platform. Two encodings are set, both to GHC.IO.Encoding.char8:  %GHC.IO.Encoding.setFileSystemEncoding and "GHC.IO.Encoding.setForeignEncoding. MisUTF89 checks if an encoding is UTF-8 (or ascii, since it is a  subset of UTF-8). *$%&'()*+,-./0123456The prompt to display The string the user entered. 7The prompt to display 89:;<=>?@ABCDEFGHIJKLM*$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM*3<;+.:/768$%&'()*BC@=>9?A-012,F45KLMEDHIJG$$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLM' Safe-InferedNOPQRNOPQRONPRQNOPQR( Safe-InferedWAll files, even boring ones X"All files, i.e. look for new ones Y"Just files already known to darcs `The `. type is a list of all flags that can ever be - passed to darcs, or to one of its commands. !ISet flags to a default value, but only one has not already been provided STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      ! distractors default flags updated flags "#STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#`     ~}|{zyxwvutsrqponmlkjihgfedcba]_^Z\[VYXWSUT "#!SUTVYXWZ\[]_^`     ~}|{zyxwvutsrqponmlkjihgfedcba !"#)portable experimentaldarcs-devel@darcs.net Safe-Infered*>Return the command and arguments needed to run an ssh command E First try the appropriate darcs environment variable and SSH_PORT  defaulting to ssh and no specified port. $%&'()*+,- $%&'()*+,- )$'&%*+,-($'&%()*+,-* Safe-Infered/6Tries to perform some task if it can obtain the lock, 1 Otherwise, just gives up without doing the task 119 safely creates an empty file (not open for writing) and  returns its name. JThe temp file operations are rather similar to the locking operations, in K that they both should always try to clean up, so exitWith causes trouble. 22) creates a temporary file, and opens it. B Both of them run their argument and then delete the file. Also, J both of them (to my knowledge) are not susceptible to race conditions on J the temporary file (as long as you never delete the temporary file; that & would reintroduce a race condition). 77 is like 8, except that it doesn't " delete the directory afterwards. 888 creates an empty directory and then removes it when it G is no longer needed. withTempDir creates a temporary directory. The = location of that directory is determined by the contents of  _darcsprefs#tmpdir, if it exists, otherwise by  $DARCS_TMPDIR , 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 J in the current directory, unless the current directory is under a _darcs O directory, in which case the temporary directory in the parent of the highest 8 _darcs directory to avoid accidentally corrupting darcs' s internals. K This should not fail, but if it does indeed fail, we go ahead and use the  current directory anyway. If $DARCS_KEEP_TMPDIR variable is set G temporary directory is not removed, this can be useful for debugging. ?IReads a file. Differs from readBinFile in that it interprets the file in 0 the current locale instead of as ISO-8859-1. DFWrites a file. Differs from writeBinFile in that it writes the string H encoded with the current locale instead of what GHC thinks is right. ./0123456789:;<=>?@ABCDEFGHIJK NP./0123456789:;<=>?@ABCDEFGHIJK ./123879<JKCDEAB>?@FGHI:0NP;4=56./0123456789:;<=>?@ABCDEFGHIJK+ Safe-Infered LMNOPQRLMNOPQRLMONPQR LMNOPQR, Safe-Infered STUVWXYZ[\ STUVWXYZ[\ W\[ZYXSVUTSVUTW\[ZYX- experimental Safe-Infered]]]].portable experimentaldarcs-devel@darcs.net Safe-Infered^0parse a commandline returning a list of strings 6 (intended to be used as argv) and a bool value which 1 specifies if the command expects input on stdin 9 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 _8for every mapping (c,s), add a mapping with uppercase c  and the urlencoded string s ^_^_^_^_/portable experimentaldarcs-devel@darcs.net Safe-Infered`abcdefg"#$%`abcdefgbaed`c"%$#fg`abcdefg0 Safe-Inferedj5Get the name of the darcs executable (as supplied by  getProgName) mfetchFile fileOrUrl cache/ returns the content of its argument (either a L file or an URL). If it has to download an url, then it will use a cache as " required by its second argument. HWe always use default remote darcs, since it is not fatal if the remote L 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. nfetchFileLazyPS fileOrUrl cache* lazily reads the content of its argument M (either a file or an URL). Warning: this function may constitute a fd leak; D make sure to force consumption of file contents to avoid that. See   fetchFilePS for details. wCRun a command on a remote location without passing it any input or , reading its output. Return its ExitCode }4Send an email, optionally containing a patch bundle ; (more precisely, its description and the bundle itself) hijklmnopqrstuvwxyz{handle to write email to From To Subject CC body |}from to subject cc  send command (content,bundle) body ~""#$%hijklmnopqrstuvwxyz{|}~"klpqrustmnoz{}~xywv"%$#|hijhijklmnopqrstuvwxyz{|}~1 Safe-Infered h3 returns a set of printers suitable for outputting  to h 2 Safe-Inferedrun a list of -s. In some monads (typically IO-based ones), F the progress and error messages will be used. In others they will be + ignored and just the actions will be run. Na monadic action, annotated with a progress message that could be printed out M while running the action, and a message that could be printed out on error. L Actually printing out these messages is optional to allow non-IO monads to  just run the action. run a list of  s without any feedback messages 3 Safe-InferedEwithFileNames takes a maybe list of existing rename-pairs, a list of N filenames and an action, and returns the resulting triple of affected files, K updated filename list and new rename details. If the rename-pairs are not 7 present, a new list is generated from the filesnames. " 4portable experimentaldarcs-devel@darcs.net Safe-InferedApply a patch to a , yielding a new . 5 Safe-InferedP is implemented by single patches that can be repaired (Prim, Patch, RealPatch) K There is a default so that patch types with no current legacy problems don' t need to  have an implementation.  and + deal with repairing old patches that were D were written out due to bugs or that we no longer wish to support.  I is implemented by collections of patches (FL, Named, PatchInfoAnd) that  might need repairing. 6 Safe-Infered RepoFormat* is the representation of the format of a > repository. Each sublist corresponds to a line in the format + file. Each line is decomposed into words. identifyRepoFormat URL) identifies the format of the repository ( at the given address. Fails if we weren't able to identify the format. tryIdentifyRepoFormat URL) identifies the format of the repository  at the given address. Return  Left reason if it fails, where  reason explains why we weren't able to identify the format. writeRepoFormat+ writes the repo format to the given file. writeProblem form+ tells if we can write to a repo in format form.  It returns Nothing if there'+s no problem writing to such a repository. readfromAndWritetoProblem form2 tells if we can read from and write to a repo in  format form . It returns Nothing if there's no problem reading # and writing to such a repository. readProblem form, tells if we can read from a repo in format form.  It returns Nothing if there'-s no problem reading from such a repository.  7 Safe-Infered@Fetch and return the message of the day for a given repository. 7Display the message of the day for a given repository,  unless either the  or the  flags are passed in 8 Safe-Infered9portable experimentaldarcs-devel@darcs.net Safe-Infered: Safe-Infered KA PatchInfo value contains the metadata of a patch. The date, name, author H and log fields are UTF-8 encoded text in darcs 2.4 and later, and just L 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 C directly in code that does not care how the patch info is stored. DaddJunk adds a line that contains a random number to make the patch  unique. Get the name, including an UNDO: " prefix if the patch is inverted. Returns the author of a patch. &Returns the name of the patch. Unlike , it does not preprend  UNDO: ' to the name if the patch is inverted. Returns the author of a patch.  Get the log message of a patch. /Get the tag name, if the patch is a tag patch. GThis makes darcs-1 (non-hashed repos) filenames, and is also generally B used in both in hashed and non-hashed repo code for making patch hashes. %The name consists of three segments: 5 timestamp (ISO8601-compatible yyyymmmddHHMMSS, UTC)  SHA1 hash of the author 5 SHA1 hash of the patch name, author, date, log, and "inverted"  flag. )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.>  ] 8note that below I assume the name has no newline in it.  See  for the inverse operation.  Parser for 1 as stored in patch bundles and inventory files,  for example:   [Document the foo interface 1 John Doe <john.doe@example.com>**20110615084241 0 Ignore-this: 85b94f67d377c4ab671101266ef9c229 0 Nobody knows what a 'foo' is, so describe it.  ] See  for the inverse operation. %##; Safe-Infered<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. < Safe-InferedLMLM= Safe-Infered> Safe-Infered ps coalesces as many patches in ps as 9 possible, sorting the results in some standard order. HIt can sometimes be handy to have a canonical representation of a given K patch. We achieve this by defining a canonical form for each patch type,  and a function & which takes a patch and puts it into I canonical form. This routine is used by the diff function to create an M optimal patch (based on an LCS algorithm) from a simple hunk describing the  old and new version of a file.  ps+ puts a sequence of primitive patches into < canonical form. Even if the patches are just hunk patches, B this is not necessarily the same set of results as you would get A if you applied the sequence to a specific tree and recalculated  a diff. CNote that this process does not preserve the commutation behaviour > of the patches and is therefore not appropriate for use when B working with already recorded patches (unless doing amend-record  or the like). 6      !"#$%&'()*+,-./01234561      !"#$%&'()*+,-./01234561 !"#$%&'()*+    6 53412,-./0       ! "#$%&'()*+,-./0123456 Safe-Infered'    "$')*+,-./0123456' 6"')*$+  12,-./0534 ? Safe-Infered 789:;<789:;<7:98;<7:98;<@ Safe-Infered====A Safe-Infered>BPatches whose concrete effect which can be expressed as a list of  primitive patches. (A minimal definition would be either of effect or effectRL. >?@>?@>?@>?@B Safe-InferedHIf H x :> y succeeds, we know that that x commutes  past yB without any conflicts. This function is useful for patch types  for which commute6 is defined to always succeed; so we need some way to Q pick out the specific cases where commutation succeeds without any conflicts. ABCDEFGHIJKL ABCDEFGHIJKL IJKLGHEFADCBADCBEFGHIJKLC Safe-InferedMNOPMNOPOMNPMNOPD Safe-InferedQQQQE Safe-InferedRSTRSTTSRRST Safe-Infered Safe-InferedF Safe-Infereddd p1 p22 is used to provide an arbitrary ordering between  p1 and p2.. Basically, identical patches are equal and  Move < DP < FP < ChangePref. E Everything else is compared in dictionary order of its arguments. UVWXYZ[\]^_`abcdUVWXYZ[\]^_`abcd^ba`_UWVX]\[ZYcdUWVX]\[ZY^ba`_cdG Safe-Infered efghijklefghijklhkjilefgefghkjil Safe-Infered Safe-InferedH Safe-InferedmnopqrstuvwJKLNOPmnopqrstuvwmsrqpontuOPNJLKwv msrqpontuvw Safe-InferedEFGHIEFGHI Safe-InferedI Safe-Inferedxyxyxyxy Safe-Infered Safe-InferedJ Safe-Infered zzz z Safe-InferedK Safe-Infered{|{||{{|L Safe-Infered}GA splitter is something that can take a patch and (possibly) render it - as text in some format of its own choosing. I This text can then be presented to the user for editing, and the result $ given to the splitter for parsing. K If the parse succeeds, the result is a list of patches that could replace $ the original patch in any context. J Typically this list will contain the changed version of the patch, along M with fixup pieces to ensure that the overall effect of the list is the same  as the original patch. K The individual elements of the list can then be offered separately to the 7 user, allowing them to accept some and reject others. There'Bs no immediate application for a splitter for anything other than  Prim (you shouldn't go editing named patches, you'll break them!) G However you might want to compose splitters for FilePatchType to make 1 splitters for Prim etc, and the generality doesn't cost anything. VThis generic splitter just lets the user edit the printed representation of the patch < Should not be used expect for testing and experimentation. YNever splits. In other code we normally pass around Maybe Splitter instead of using this 2 as the default, because it saves clients that don'&t care about splitting from having to , import this module just to get noSplitter.  Split a primitive hunk patch up Y by allowing the user to edit both the before and after lines, then insert fixup patches  to clean up the mess. }~}~}~}~M Safe-InferedThe Named7 type adds a patch info about a patch, that is a name. NamedP info deps p represents patch p with name  info. deps4 is a list of dependencies added at the named patch E level, compared with the unnamed level (ie, dependencies added with  darcs record --ask-deps).             Safe-InferedN Safe-Infered Safe-InferedCNO"$')*-.245>?JKNOPB.2-"'*5K>?)$ONOPNJO Safe-Infered a b- represents the info of a patch, marked with  the patch' s witnesses.  p a b$ 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.  p C (x y) is  String (p C (x y)) in a $ form adapted to darcs patches. The C (x y) represents the type 1 witness for the patch that should be there. The  Hopefully type A just tells whether we expect the patch to be hashed or not, and  ! does the real work of emulating  .  Hopefully sh, represents an expected unhashed patch, and  Hashed hash sh4 represents an expected hashed patch with its hash.  i p2 creates a PatchInfoAnd containing p with info i. n2pia' creates a PatchInfoAnd representing a Named patch.  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  er hp! tries to extract a patch from a . 5 If it fails, it applies the error handling function er to a description  of the patch info component of hp.  hopefullyM is a version of  hopefully which calls fail in a  monad instead of erroring. $ !"# !"Pportable experimentaldarcs-devel@darcs.net Safe-Infered##Q Safe-InferedLnewset2RL takes a PatchSet and returns an equivalent, linear RL of patches. Lnewset2FL takes a PatchSet and returns an equivalent, linear FL of patches. 5appendPSFL takes a PatchSet and a FL of patches that follow the PatchSet, 1 and concatenates the patches into the PatchSet. IRuns a progress action for each tag and patch in a given PatchSet, using ; the passed progress message. Does not alter the PatchSet. Ktags returns the PatchInfos corresponding to the tags of a given PatchSet.    R Safe-Infered Evaluate an  list and report progress.  Evaluate an  list and report progress.  Evaluate an 3 list and report progress. In addition to printing E the number of patches we got, show the name of the last tag we got. S Safe-InferedGA convenience function to call from all darcs command functions before F applying any patches. It checks for malicious paths in patches, and 5 prints an error message and fails if it finds one. :Filter out patches that contains some malicious file path What 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 C 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? B Would it be worth adding a --semi-safe-paths option for allowing / changes to certain preference files (_darcs/prefs/ ) in sub  repositories'? 5Warning : this is less rigorous than isMaliciousPath  but it',s to allow for subpath representations that  don't start with ./ T Safe-InferedgetPatchesInTag t ps returns a  of all  patches in ps which are contained in t. getTagsRight ps returns the  for all the patches in  ps= that are not depended on by anything else *through explicit D dependencies*. Tags are a likely candidate, although we may also + find some non-tag patches in this list. KKeep in mind that in a typical repository with a lot of tags, only a small K fraction of tags would be returned as they would be at least indirectly $ depended on by the topmost ones. deepOptimizePatchset2 runs through all patches whether they are in the & surface inventory or the deep one. optimizePatchset is similar to slightlyOptimizePatchset in C that it only works on the surface inventory (see below), but it 5 works a bit harder and can optimize several tags. = surface inventory: the sequence of patches that corresponds  to the _darcshashed\_inventory@ or @\_darcs inventory files ; deep inventory: the sequence of sequences of patches that  corresponds to the _darcs/ inventories directory slightlyOptimizePatchset% only works on the surface inventory  (see () and only optimises at most one tag in B there, going for the most recent tag which has no non-depended ! patch after it. Older tags won't be clean, which means the  PatchSet will not be in ' unclean :< clean' state. KMerge two FLs (say L and R), starting in a common context. The result is a N FL starting in the original end context of L, going to a new context that is E the result of applying all patches from R on top of patches from L. "While this function is similar to , there are three important  differences to keep in mind:  A does not correctly deal with duplicate patches whereas this one  does N (Question from Eric Kow: in what sense? Why not fix the mergeFL instance?)  @ returns both paths of the merge diamond, but this version only  returns one, so you')d better choose the order carefully, eg.  ( merge2FL l r) A The conventional order we use in this function is reversed from   (so  mergeFL r l vs.  merge2FL l r. This does not ; matter so much for the former since you get both paths. K (Question from Eric Kow: should we flip merge2FL for more uniformity in  the code?) U Safe-InferedA Matcher is made of a  which we will use to match  patches and a String representing it. ;A type for predicates over patches which do not care about  contexts  applyMatcher applies a matcher to a patch. .The string that is emitted when the user runs darcs help --match. $   $V Safe-InferedW Safe-InferedSee module documentation for  % mp iA acts as a temporary identifier to help us keep track of patches L during the selection process. These are useful for finding patches that J may have moved around during patch selection (being pushed forwards or % backwards as dependencies arise). )The identifier is implemented as a tuple TG mp i. The i is just some C arbitrary label, expected to be unique within the patches being  scrutinised. The mp% is motivated by patch splitting; it I provides a convenient way to generate a new identifier from the patch @ being split. For example, if we split a patch identified as  TG Nothing  53, the resulting sub-patches could be identified as TG (TG Nothing 5)  1, TG (TG Nothing 5) 2, etc. QTag a sequence of patches as subpatches of an existing tag. This is intended for C use when substituting a patch for an equivalent patch or patches. Tag a sequence of patches.  getChoices evaluates a  PatchChoices+ into the first, middle and last sequences ) by doing the commutes that were needed. refineChoices act performs act" on the middle part of a sequence = of choices, in order to hopefully get more patches into the first and  last parts of a  PatchChoices.   (a :||: bs) pcs replaces a with bs in pcs preserving the choice  associated with a &&'()*+,-.#&'()*+,-.X Safe-InferedY Safe-Infered /01234567 /01234567 Safe-Infered89:89: Safe-Infered;; Safe-Infered<=>?^^<=>?Z Safe-Infered@ABCDEF@ABCDEF Safe-InferedGHIJmmGHIJ Safe-InferedKLKL Safe-InferedMN77MN[ Safe-InferedGNonable represents the class of patches that can be turned into a Non. A  stores a context with a Prim# patch. It is a patch whose effect  isn'#t visible - a Non-affecting patch. HunNon converts a Non into a FL of its context followed by the primitive  patch. 4showNons creates a Doc representing a list of Nons. *showNon creates a Doc representing a Non. ;readNons is a parser that attempts to read a list of Nons. 8readNon is a parser that attempts to read a single Non.  x cy tries to commute x past cy and always  returns some variant cy'.. If commutation suceeds, the variant is just K straightforwardly the commuted version. If commutation fails, the variant  consists of x prepended to the context of cy.  xs cy commutes as many patches of xs past cy ! 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'']  HcommutePrimsOrAddToCtx takes a WL of prims and attempts to commute them  past a Non.  HcommuteOrRemFromCtx attempts to remove a given patch from a Non. If the N patch was not in the Non, then the commute will succeed and the modified Non L will be returned. If the commute fails then the patch is either in the Non K context, or the Non patch itself; we attempt to remove the patch from the ; context and then return the non with the updated context. LTODO: understand if there is any case where p is equal to the prim patch of D the Non, in which case, we return the original Non, is that right?  EcommuteOrRemFromCtxFL attempts to remove a FL of patches from a Non, : returning Nothing if any of the individual removes fail.  A(*>) attemts to modify a Non by commuting it past a given patch. C(>*) attempts to modify a Non, by commuting a given patch past it. K(*>>) attempts to modify a Non by commuting it past a given WL of patches. K(>>*) attempts to modify a Non by commuting a given WL of patches past it. OJNons are equal if their context patches are equal, and they have an equal  prim patch.      PQORS               PQORS\ Safe-Infered? is used to represents prim patches that are duplicates of, or 6 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:  ix is the set of patches:  * that conflict with x- and also conflict with another patch in the  repository. 3 * that conflict with a patch that conflict with x xx6 is the sequence of patches that conflict *only* with x x% is the original, conflicting patch. ix and x are stored as Non& objects, which include any necessary < context to uniquely define the patch that is referred to. KThe 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)  p is True if p is either a  or   patch.  p is True if p is either an  or  . 9 is used when converting from Darcs V1 patches (Mergers) $ to Darcs V2 patches (Conflictors). =This is used for unit-testing and for internal sanity checks "TUVWXYZ[\]^_`abcdefghij  TUVWXYZ[\]^_`abcdefghij Safe-Inferedkk] Safe-InferedHhashBundle creates a SHA1 string of a given a FL of named patches. This N allows us to ensure that the patches in a received patchBundle have not been  modified in transit. @In makeBundle2, it is presumed that the two patch sequences are E identical, but that they may be lazily generated. If two different E patch sequences are passed, a bundle with a mismatched hash will be 6 generated, which is not the end of the world, but isn't very useful  either. !IgetContext parses a context list, returning a tuple containing the list, ! and remaining ByteString input. $LpatchFilename maps a patch description string to a safe (lowercased, spaces 4 removed and ascii-only characters) patch filename.  !"#$  !"#$  "#$!  !"#$^ Safe-Infered 9IunionRemoteCaches merges caches. It tries to do better than just blindly ! copying remote cache entries: I If remote repository is accessed through network, do not copy any cache I entries from it. Taking local entries does not make sense and using D network entries can lead to darcs hang when it tries to get to  unaccessible host. J If remote repositoty is local, copy all network cache entries. For local M cache entries if the cache directory exists and is writable it is added H as writable cache, if it exists but is not writable it is added as  read-only cache. LThis approach should save us from bogus cache entries. One case it does not J work very well is when you fetch from partial repository over network. ( Hopefully this is not a common case. :ACompares two caches, a remote cache is greater than a local one. 0 The order of the comparison is given by: local < http < ssh <<= computes the cache hash (i.e. filename) of a packed string. ?"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 C cannot be fetched from any of the sources, this operation fails. B(hashedFilePath cachelocation subdir hash" returns the physical filename of  hash hash in the subdir section of  cachelocation. CpeekInCache cache subdir hash tells whether cache and  contains an object with hash hash in a writable position. : Florent: why do we want it to be in a writable position? D/speculateFileUsingCache cache subdirectory name takes note that  the file name2 is likely to be useful soon: pipelined downloads E will add it to the (low-priority) queue, for the rest it is a noop. EKNote that the files are likely to be useful soon: pipelined downloads will B add them to the (low-priority) queue, for the rest it is a noop. F5writeFileUsingCache cache compression subdir contents write the string contents to Y 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 J a noop. The returned value is the filename that was given to the string. I3Prints an error message with a list of bad caches. (%&'()*+,-./0123456789:;<=>?@ABCDEFGHIlmn%%&'()*+,-./0123456789:;<=>?@ABCDEFGHI%<=>%&,.-'()*+/102543689GH?DEFC;@AB7:I%&'()*+,.-/1025436789:;<=>?@ABCDEFGHIlmn_ Safe-InferedP6The relative path of the global preference directory; ~/.darcs on Unix,  and  %APPDATA%/darcs4 on Windows. This is used for online documentation. JKLMNOPQRSTUVWXYZ[\]^_`aJKLMNOPQRSTUVWXYZ[\]^_`aXYZRQ_`\]^[MTUOJLKWaVNSPJLKMNOPQRSTUVWXYZ[\]^_`a`portable experimentaldarcs-devel@darcs.net Safe-Inferedbbbba Safe-Inferedcdexternal merge tool command command line arguments ecdecdecdeb Safe-Infered fgopqrstuvwfggf opqrstuvwc Safe-Inferedhhhhd Safe-Inferedss repository function modifies the cache of   repository with function., remove duplicates and sort the results with :. ijklmnopqrs ijklmnopqrs klijmponqrsijklmponqrse Safe-InfereduFRead the contents of pending. CWD should be the repository directory. F The return type is currently incorrect as it refers to the tentative ' state rather than the recorded state. vPRead the contents of tentative pending. CWD should be the repository directory. wPRead the contents of tentative pending. CWD should be the repository directory. xPRead the contents of tentative pending. CWD should be the repository directory. yJRead the contents of new pending. CWD should be the repository directory. tuvwxyxytuvwxyuvxwyttuvwxyxyf Safe-Infered}'From a repository and a list of SubPath'"s, construct a filter that can be H used on a Tree (recorded or unrecorded state) of this repository. This L constructed filter will take pending into account, so the subpaths will be 8 translated correctly relative to pending move patches. ~JConstruct a Tree filter that removes any boring files the Tree might have M contained. Additionally, you should (in most cases) pass an (expanded) Tree E that corresponds to the recorded content of the repository. This is I important in the cases when the repository contains files that would be M boring otherwise. (If you pass emptyTree instead, such files will simply be ? discarded by the filter, which is usually not what you want.) MThis function is most useful when you have a plain Tree corresponding to the : full working copy of the repository, including untracked K files. Cf. whatsnew, record --look-for-adds. NB. Assumes that our CWD is  the repository root. CFor a repository and an optional list of paths (when Nothing, take M everything) compute a (forward) list of prims (i.e. a patch) going from the L recorded state of the repository (pristine) to the unrecorded state of the L repository (the working copy + pending). When a list of paths is given, at J least the files that live under any of these paths in either recorded or M unrecorded will be included in the resulting patch. NB. More patches may be L included in this list, eg. the full contents of the pending patch. This is M usually not a problem, since selectChanges will properly filter the results  anyway. JThis also depends on the options given: with LookForAdds, we will include @ any non-boring files (i.e. also those that do not exist in the recorded  state) in the working in the  unrecorded state, and therefore they will % show up in the patches as addfiles. LThe IgnoreTimes option disables index usage completely -- for each file, we M read both the unrecorded and the recorded copy and run a diff on them. This K is very inefficient, although in extremely rare cases, the index could go L out of sync (file is modified, index is updated and file is modified again  within a single second). $Obtains a Tree corresponding to the recorded state of the repository: L 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. KHandles the plain and hashed pristine cases. Currently does not handle the ; no-pristine case, as that requires replaying patches. Cf. z  and {2 in hashed-storage that are used to do the actual   construction. $Obtains a Tree corresponding to the  unrecorded state of the repository:  the working tree plus the pending* patch. The optional list of paths allows % to restrict the query to a subtree. LLimiting the query may be more efficient, since hashes on the uninteresting I parts of the index do not need to go through an up-to-date check (which 4 involves a relatively expensive lstat(2) per file. 8Obtains a Tree corresponding to the working copy of the B repository. NB. Almost always, using readUnrecorded is the right D choice. This function is only useful in not-completely-constructed  repositories. GMark the existing index as invalid. This has to be called whenever the K listing of pristine changes and will cause darcs to update the index next K time it tries to read it. (NB. This is about files added and removed from M pristine: changes to file content in either pristine or working are handled + transparently by the index reading code.) z{|}~VWXYZ[\z{|}~}~z{|Z\[VYXW z{|}~g Safe-Infered||h Safe-Infered copies the prefs/)sources file to the local repo, from the = remote, having first filtered the local filesystem sources. 'readPatchIds inventory'/ parses the content of a hashed_inventory file  after the  pristine: and Starting with inventory: header lines have J been removed. The second value in the resulting tuples is the file hash  of the associated patch (the hash: line). i Safe-Infered;The status of a given directory: is it a darcs repository?  safest guess (looks like a repository with some error BRepository IO monad. This monad-like datatype is responsible for C sequencing IO actions that modify the tentative recorded state of  the repository.  converts RIO a to IO a.  This the RIO equivalent of liftIO. Similar to the ask$ function of the MonadReader class. 9 This allows actions in the RIO monad to get the current  repository.  FIXME: Don't export this. If we don't export this 7 it makes it harder for arbitrary IO actions to access 7 the repository and hence our code is easier to audit. 6Tries to identify the repository in a given directory /identifyDarcsRepository identifies the repo at url . Warning: ? you have to know what kind of patches are found in that repo. identifyRepositoryFor repo url& identifies (and returns) the repo at url, D but fails if it is not compatible for reading from and writing to. &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 5 Just (Left errorMessage), if bad repository found . Just (Right ()), if good repository found. I WARNING this changes the current directory for good if matchFn succeeds NThis fuction is unsafe because it accepts a patch that works on the tentative  pending and we don'6t currently track the state of the tentative pending. isetTentativePending is basically unsafe. It overwrites the pending state with a new one, not related to  the repository state. <Writes out a fresh copy of the inventory that minimizes the C amount of inventory that need be downloaded when people pull from  the repository. ASpecifically, 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 C inventory). It also gives a guarantee that all the patches prior B to a given tag are included in that tag, so less commutation and A history traversal is needed. This latter issue can become very " important in large repositories. #Used by the commands dist and diff }<We have an instance of Monad so that IO actions that do not E change the tentative recorded state are convenient in the IO monad. >}~@ijkl@klij3}~j Safe-Inferedk Safe-Infered@writePatchSet is like patchSetToRepository, except that it doesn't 0 touch the working directory or pristine cache. ]patchSetToRepository takes a patch set, and writes a new repository in the current directory N that contains all the patches in the patch set. This function is used when ' darcs get'ing a W repository with the --to-match flag and the new repository is not in hashed format. L This function does not (yet) work for hashed repositories. If the passed  DarcsFlags tell @ darcs to create a hashed repository, this function will call error. KReplace the existing pristine with a new one (loaded up in a Tree object). K%&'()*+/012345IkrsKk2543%&'()*+/10rsIl Safe-Infered=A constructor for grouping related options together, such as  --hashed and  --darcs-2. A type for darcs'. options. The value contains the command line E switch(es) for the option, a help string, and a function to build a   DarcsFlag9 from the command line arguments. for each constructor,   shortSwitches4 represents the list of short command line switches E which invoke the option, longSwitches the list of long command line P switches, optDescr the description of the option, and argDescr the description = of its argument, if any. mkFlag is a function which makes a  DarcsFlag from  the arguments of the option. DarcsInternalOption X An option just for internal use (e.g. defaulting), not directly available to the user. ;DarcsNoArgOption shortSwitches longSwitches mkFlag optDescr 0 The constructon fon options with no arguments. BDarcsOptAbsPathOrStdOption shortSwitches longSwitches defaultPath  mkFlag ArgDescr OptDescr& where defaultPath is a default value @ for the Path, as a string to be parsed as if it had been given  on the command line. E The constructor for options with an optional path argument, such as -O KDarcsAbsPathOrStdOption shortSwitches longSwitches mkFlag ArgDescr OptDescr ; The constructor for options with a path argument, such as -o FDarcsAbsPathOption shortSwitches longSwitches mkFlag ArgDescr OptDescr E The constructor for options with an absolute path argument, such as   --sibling BDarcsArgOption shortSwitches longSwitches mkFlag ArgDescr OptDescr = The constructor for options with a string argument, such as  --tag maybeFixSubPaths files3 tries to turn the file paths in its argument into  SubPaths. NWhen converting a relative path to an absolute one, this function first tries O to interpret the relative path with respect to the current working directory. H If that fails, it tries to interpret it with respect to the repository / directory. Only when that fails does it put a Nothing in the result at the 0 position of the path that cannot be converted. @It is intended for validating file arguments to darcs commands. fixSubPaths files returns the SubPaths for the paths in files that = are inside the repository, preserving their order. Paths in files that are 9 outside the repository directory are not in the result. NWhen converting a relative path to an absolute one, this function first tries O to interpret the relative path with respect to the current working directory. H If that fails, it tries to interpret it with respect to the repository H directory. Only when that fails does it omit the path from the result. @It is intended for validating file arguments to darcs commands.  list_option% is an option which lists the command' s arguments 2 takes a list of flags and returns the url of the  repository specified by Repodir " directory" in that list of flags, if any. 0 This flag is present if darcs was invoked with --repodir=DIRECTORY 5 is the option used to specify the URL of the remote  repository to work with / takes a list of flags and returns the context  specified by  Context c in that list of flags, if any. 0 This flag is present if darcs was invoked with --context=FILE ""5 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 Pipe1 is present, asks the user who is the author and F returns the answer. If neither are present, try to guess the author,  from _darcs/prefs , and if it's not possible, ask the user. ##E tries to get the author name first from the repository preferences, I then from global preferences, then from environment variables. Returns [] S if it could not get it. Note that it may only return multiple possibilities when ! reading from global preferences //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" in that list of flags. 4 Returns the addresses as a comma separated string. 11; 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" in that list of flags, if any. 0 This flag is present if darcs was invoked with --subject=SUBJECT QQ flags patch returns a 7 representing the right  way to show patch given the list flags" of flags darcs was invoked with. RR action opts patches prints a string 4 representing the action that would be taken if the  --dry-run option > had not been passed to darcs. Then darcs exits successfully.  action- is the name of the action being taken, like "push"  opts/ is the list of flags which were sent to darcs  patches6 is the sequence of patches which would be touched by action. _HGet a list of all non-boring files and directories in the working copy. ``1 returns the list of all non-boring unregistered  files in the repository. aa= returns the list of all registered files in the repository. gg collects the contents of all Sibling flags in a list of flags. kk8 takes a list of flags and returns the sendmail command  to be used by  darcs send#. Looks for a command specified by   SendmailCmd "command" in that list of flags, if any. 0 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. pBSet the DARCS_PATCHES and DARCS_PATCHES_XML environment variables ; with info about the given patches, for use in post-hooks. qESet the DARCS_FILES environment variable to the files touched by the 3 given patch, one per line, for use in post-hooks. tt8 takes a list of flags and returns the posthook command  specified by  PosthookCmd a in that list of flags, if any. ww7 takes a list of flags and returns the prehook command  specified by  PrehookCmd a in that list of flags, if any.  f holds whenever f is a way of selecting  patches such as  PatchName n.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~L`abcdefghijklmnopqrstuvwxyz{|}~           !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~L`     ~}|{zyxwvutsrqponmlkjihgfedcbapq]i   J$420%&'^(769:?KL.-,M*N+)C V@W STUZY[\_~a`"#k !135/;<>=jAEBFGbhXHIPORQDcdefglmnrstuvwo}xyz{8|      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~m Safe-Infered++0n Safe-Infered opts patch prints patch in accordance with the  flags in opts, ie, whether  --verbose or  --summary were passed at  the command-line. $ prints a patch on standard output.  runs '$PAGER' and shows a patch in it. , prints a patch, together with its context,  on standard output. o Safe-Inferedpportable experimentaldarcs-devel@darcs.net Safe-Inferedq Safe-Inferedr Safe-Infered haveNonrangeMatch flags" tells whether there is a flag in  flags& which corresponds to a match that is  non-range. Thus,  --match, --patch and --index make haveNonrangeMatch  true, but not  --from-patch or  --to-patch. havePatchsetMatch flags tells whether there is a patchset match' in the flag list. A patchset match is --match or  --patch, or  --context , but not  --from-patch nor (!)  --index. 0 Question: Is it supposed not to be a subset of haveNonrangeMatch?  firstMatch fs tells whether fs implies a  first match, that D is if we match against patches from a point in the past on, rather @ than against all patches since the creation of the repository. secondMatch fs tells whether fs implies a  second match, that E is if we match against patches up to a point in the past on, rather % than against all patches until now. nonrangeMatcher0 is the criterion that is used to match against  patches in the interval. It is 'Just m' when the --patch, --match,  --tag0 options are passed (or their plural variants). matchAPatchread fs p tells whether p matches the matchers in  the flags listed in fs. matchAPatch fs p tells whether p matches the matchers in  the flags fs matchFirstPatchset fs ps returns the part of ps before its C 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. matchSecondPatchset fs ps returns the part of ps before its < second matcher, ie the one that comes last dependencywise. matchExists m ps) tells whether there is a patch matching  m in ps  applyNInv& n ps applies the inverse of the last n patches of ps. s Safe-Infered7When asking about patches, we either ask about them in D 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. First: ask for an initial C segment, first patches first (default for all pull-like commands)  FirstReversed1: ask for an initial segment, last patches first > (used to ask about dependencies in record, and for pull-like  commands with the  --reverse flag).  LastReversed8: ask for a final segment, last patches first. (default G for unpull-like commands, except for selecting *primitive* patches in  rollback) LastD: ask for a final segment, first patches first. (used for selecting F primitive patches in rollback, and for unpull-like commands with the   --reverse flag A  for selecting Prim patches. A  for selecting full patches ( patches) runs a  action in the given . Select patches from a FL. The equivalent of  for the  darcs changes command LThe function for selecting a patch to amend record. Read at your own risks. COptionally remove any patches (+dependencies) from a sequence that < conflict with the recorded or unrecorded changes in a repo Command-line options. Only  is 6 significant; filtering will happen iff it is present 0Recorded patches from repository, starting from ' same context as the patches to filter 8Repository itself, used for grabbing unrecorded changes Patches to filter ?(True iff any patches were removed, possibly filtered patches)  t Safe-Infereduportable experimentaldarcs-devel@darcs.net Safe-Inferedv Safe-Inferedw Safe-Inferedx Safe-Inferedy Safe-Inferedz Safe-Infered{ Safe-Infered| Safe-Infered}portable experimentaldarcs-devel@darcs.net Safe-Infered~ Safe-Infered Safe-InferedHThis is designed for use in an atexit handler, e.g. in Darcs.RunCommand  Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered     Safe-Infered     Safe-Infered             Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Safe-Infered Gstatus is an alias for whatsnew, with implicit Summary and LookForAdds L flags. We override the default description, to include the implicit flags.      Safe-Infered!"!""!!" Safe-Infered#### Safe-Infered$%&$%&$&%$%& Safe-Infered Safe-Infered'(url body  mime type result )*'()*'()*'()* Safe-Infered++++ Safe-Infered,=The commands that darcs knows about (e.g. whatsnew, record), > organized into thematic groups. Note that hidden commands  are also listed here. ,,,, Safe-Infered1@Help on each environment variable in which Darcs is interested. -./01-./01-01/.-./01 Safe-Infered2222 Safe-Infered3333                     ! " # $ % & ' ( ) * + , - . / 0 1 2 3  4 5 6 7 8 9 : ; < < = > ? ? @ A B C D E F GHIJKLMNOPQRSTUVWXYZ[\]]^^__`abcdefghijklmnoppqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@AABBCCDDEEFGHIJKLMNOPQRSTUVWXYZ[\]^_`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 0 0 0 0 0000000000000000000 0!0"0#0$0%0&11'1(1)2*2+2,2,2-2.2/2031323334353633738393:3;3<3=3>3?3@3A3B3C3D3E3F3G3H3I3J4K4L4M4N4O4P4Q5R5S5 5T5 5U5V6W6X6Y6Z6[6\6]6^6_6`6a6b6c6d6e7f7g8h8i9j:k:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z:{:|:}:~::::::::::::::;;;;;;;;;;;;;;<=====>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>??????@AAABBBBBBBBBBBBCCCCDEEEFFFFFFFFFFFFFFFFGGGGGGGGHHHHHH H HHH H I IJKKLLLLLLLLMMMMMMMM M!M"M#M$N%O&O'O(O)O*O+O,O-O.O/O0O1O2O3O4O5O6O7O8O9P:P;P<P=Q>Q>Q?Q?Q@QAQBQCQDQEQFRGRHRISJSKSLSMSNTOTPTQTRTSTTTUTVTWTXTYTZT[T\T]T^T_U`UaUbUcUdUeUfUgVhViVjWkWlWmWnWoWpWqWrWsWtWuWvWwWxWyWzW{W|W}W~WWWWWWWWWXXXXXXYZ[[[[[[[[[[[[[[[[[[[\\\\\\\\\\\]]]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^________________________`aaabbcdddddddddddeeeeeeffff f f f f fffffgggggghihhhhhhhhhh h!h"h#h$h%h&h'h(h)h*h+i,i-i.i,i/i0i/i1i2i1i3i4i5i6i7i8i9i:i;i<i=i>i?i@iAiBiCiiiiDiEiFiGiHiIiJiKi(iLiMiNiOiPiQiRiSiTiUiViWiXiYiZi[i\i]i^i_i`jajbkckdkekfkgkhkiljlklllmlnlolplqlrlsltlulvlwlxlylzl{l|l}l~lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmm mm m m m mmmmmmmmmmmmmmmmmmm m!m"m#m$mm%m&m'm(m)m*m+n,n-n.n/o0o1o2p3p4q5q6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMrNrOsPsQsRsSsTsUsVsWsXsYsZs[t\t]t^t_t`uaubv:wMwcxdxeyfygyhyiyjykylzmzn{o|p}q~r~stuvwxyz{|}~r          !!""$%%%%%%%%%%%% % %   +++1223333333445 5!5"6#:$:%>&>'>(>)>*?+?,?-?.@/@0@1A2A3B4B5B6B7E8E9E:E;E<E=E>E?E@EAEBECDEFFGFHFIFJFKFLFMFNFOGPGBGCQRSHGHHHIHJHKHLHMHTUVWXYZ[I\IPI]QSRJ^J_J`JaJbJcJdJeJfJgJhiKjKkKlKmMnMoMpMqMrMsMtMuMvMwMxMyMzM{M|M}M~MMOOOOOOOOOOOOOOOOOPUWWWWWWWWWWYYYYYYYYYXYZ[ZZZZZZZ[[[[[\\\\\\\\\\\\\\\\\\\\\\\^^^bbbbbbbbbeegiiss darcs-2.8.1RatifiedByteStringUtils Workaround URL.RequestDarcs.Witnesses.ShowDarcs.Patch.OldDateDarcs.Patch.Prim.V3.ObjectMapDarcs.Patch.FormatDarcs.Patch.RegCharsIsoDate DateMatcherDarcs.Witnesses.UnsafeEnglishDarcs.Witnesses.EqDarcs.SignalHandlerDarcs.Witnesses.Sealed Darcs.GlobalDarcs.Patch.MatchDataProgressExecDarcs.Patch.TokenReplaceDarcs.Patch.ReadMonadsPrinter Darcs.Bug Darcs.URL Darcs.EmailLcsDarcs.Witnesses.OrderedDarcs.Patch.CommuteDarcs.Patch.InvertDarcs.Patch.PermutationsDarcs.Patch.BracketedDarcs.Patch.MergeDarcs.Patch.InspectDarcs.Witnesses.WZipperDarcs.Patch.FileNameDarcs.RepoPath Darcs.Utils Darcs.Compat Darcs.Flags Darcs.Ssh Darcs.LockDarcs.Patch.ReadDarcs.Patch.SummaryData Crypt.SHA256 CommandLineURLDarcs.ExternalDarcs.ColorPrinterDarcs.MonadProgressDarcs.Patch.ApplyMonadDarcs.Patch.ApplyDarcs.Patch.RepairDarcs.Repository.FormatDarcs.Repository.MotdDarcs.RemoteApplySHA1Darcs.Patch.InfoDarcs.Patch.ShowDarcs.Patch.PatchyDarcs.Patch.FileHunkDarcs.Patch.Prim.ClassDarcs.Patch.V1.CoreDarcs.Patch.V1.ShowDarcs.Patch.EffectDarcs.Patch.ConflictDarcs.Patch.SummaryDarcs.Patch.ConflictMarkingDarcs.Patch.V1.CommuteDarcs.Patch.Prim.V1.CoreDarcs.Patch.Prim.V1.CommuteDarcs.Patch.Prim.V3.CoreDarcs.Patch.Prim.V3.CommuteDarcs.Patch.DummyDarcs.Patch.ViewingDarcs.Patch.SplitDarcs.Patch.NamedDarcs.Patch.RepoPatchDarcs.Patch.PatchInfoAndDarcs.AnnotateDarcs.Patch.SetDarcs.ProgressPatchesDarcs.CommandsAuxDarcs.Patch.DependsDarcs.Patch.MatchDarcs.Repository.OldDarcs.Patch.ChoicesDarcs.Patch.TouchesFilesDarcs.Patch.Prim.V1.ShowDarcs.Patch.Prim.V3.ShowDarcs.Patch.V2.NonDarcs.Patch.V2.RealDarcs.Patch.BundleDarcs.Repository.CacheDarcs.Repository.Prefs Darcs.DiffDarcs.ResolutionDarcs.IODarcs.Repository.ApplyPatchesDarcs.Repository.InternalTypesDarcs.Repository.LowLevelDarcs.Repository.StateDarcs.Repository.HashedIODarcs.Repository.HashedRepoDarcs.Repository.InternalDarcs.Repository.MergeDarcs.RepositoryDarcs.ArgumentsDarcs.CommandsDarcs.PrintPatch Darcs.TestDarcs.Commands.AddDarcs.Commands.Util Darcs.MatchDarcs.SelectChangesDarcs.Commands.RecordDarcs.Commands.AmendRecordDarcs.Commands.AnnotateDarcs.Commands.ApplyDarcs.Commands.ChangesDarcs.Repository.RepairDarcs.Commands.CheckDarcs.Commands.ConvertDarcs.Commands.DiffDarcs.Commands.DistDarcs.Commands.GetDarcs.Commands.GZCRCsDarcs.Commands.InitDarcs.Commands.MarkConflictsDarcs.Commands.MoveDarcs.Commands.OptimizeDarcs.Commands.PushDarcs.Commands.PutDarcs.Commands.RemoveDarcs.Commands.ReplaceDarcs.Commands.UnrevertDarcs.Commands.RevertDarcs.Commands.UnrecordDarcs.Commands.RollbackDarcs.Commands.SetPrefDarcs.Commands.ShowAuthorsDarcs.Commands.ShowBugDarcs.Commands.ShowContentsDarcs.Commands.ShowFilesDarcs.Commands.ShowTagsDarcs.Commands.ShowIndexDarcs.Commands.TagDarcs.Commands.TestDarcs.Commands.TrackDownDarcs.Commands.TransferModeDarcs.Commands.WhatsNewDarcs.Commands.PullDarcs.Commands.ShowRepoDarcs.Commands.ShowURL.HTTPDarcs.Commands.SendDarcs.TheCommandsDarcs.Commands.HelpDarcs.ArgumentDefaultsDarcs.RunCommandURL.CurlDarcs.Patch.PrimDarcs.Patch.V1.ApplyDarcs.Patch.V1.ReadDarcs.Patch.Prim.V1.DetailsDarcs.Patch.Prim.V1.ReadDarcs.Patch.Prim.V3.ApplyDarcs.Patch.Prim.V3.CoalesceDarcs.Patch.Prim.V3.DetailsDarcs.Patch.Prim.V3.ReadDarcs.Patch.Bracketed.InstancesDarcs.Patch.Patchy.Instances Darcs.PatchChoicesDarcs.Patch.Prim.V1.ApplyDarcs.Patch.Prim.V1.CoalesceDarcs.Patch.Prim.V1Darcs.Patch.Prim.V3Darcs.Patch.V1.ViewingDarcs.Patch.V1Darcs.Patch.V2Versionbase System.IOreadFileGHC.IO.Handle.Text hGetContentsbytestring-0.9.2.1Data.ByteString intercalatedirectory-1.1.0.2System.DirectorygetCurrentDirectory renameFile unix-2.5.1.0System.Posix.SignalsinstallHandler raiseSignalsigTERMsigPIPEsigINTsigHUPsigALRMsigABRTSignalDefaultIgnoreCatch CatchOnceHandlerConnectionErrorOperationTimeoutCouldNotConnectToServerCouldNotResolveHostPriorityLowHighQUrlState inProgress waitToStart pipeLength randomJunkCachableMaxAge Uncachable UrlRequesturlfilecachablepriorityreadQinsertQpushQdeleteQelemQemptyQnullQShow2 showDict2Show1 showDict1ShowDictShowDictRecord ShowDictClass showsPrecDshowD showListD showsPrec1show1 showsPrec2show2showOp2appPrec readUTCDateshowIsoDateTime ObjectMap getObject putObject listObjectsObjectBlob Directory DirContentLocationUUIDFileNameFormat NewFormat OldFormat ListFormat ListFormatV2 ListFormatV1ListFormatDefaultPatchListFormatpatchListFormatregChars MCalendarTimemctYearmctMonthmctDaymctHourmctMinmctSec mctPicosecmctWDaymctYDay mctTZNamemctTZmctIsDSTmctWeek TimeIntervalcleanLocalDate readLocalDate getLocalTz parseDategetIsoDateTimeiso8601Intervaliso8601DurationenglishDateTimeenglishInterval englishLasttoMCalendarTimeunsafeToCalendarTime addToMCalsubtractFromMCal resetCalendar unsetTimeDMparseDateMatcher getMatchers unsafeCoercePunsafeCoercePStartunsafeCoercePEndunsafeCoerceP2unsafeCoerceP1ThisPronounItNoun Countablepluralsingular englishNum andClauses orClausesintersperseLastpresentParticiple setExecutableMyEq unsafeCompare=\/==/\=EqCheckNotEqIsEqisIsEq stdoutIsAPipewithSignalsHandledcatchNonSignalcatchInterrupt tryNonSignalwithSignalsBlockedGapemptyGapfreeGapjoinGap FreeRightFreeLeft FlippedSealSealed2Sealedsealseal2flipSeal unsafeUnsealunsafeUnsealFlipped unsafeUnseal2unsealunsealMliftSMmapSeal mapFlippedunseal2mapSeal2 unsealFlipped unFreeLeft unFreeRight SshSettingssshscpsftpwindowsatexit withAtexit setDebugMode whenDebugMode withDebugMode debugMessage debugFail putTimingsetTimingsMode timingsMode defaultSsh addCRCWarninggetCRCWarningsresetCRCWarnings addBadSourcegetBadSourcesList isBadSourceaddReachableSourceisReachableSourcedarcsdir PatchMatch PatternMatch patchMatch beginTedious endTedious tediousSizeminlist progressListprogressprogressKeepLatest finishedOne finishedOneIOsetProgressModewithoutProgress ExecExceptionRedirectStdoutFileNullAsIs RedirectsexecexecInteractivewithoutNonBlockunsafeWithInternals readIntPSunpackPSFromUTF8packStringToUTF8 dropSpace breakSpaceisFunkyhashPSsubstrPS breakFirstPS breakLastPSlinesPS unlinesPS gzDecompressisGZFile gzReadFilePS gzWriteFilePSgzWriteFilePSs gzReadStdin mmapFilePS fromPS2Hex fromHex2PSbetweenLinesPSbreakAfterNthNewlinebreakBeforeNthNewlineisAscii decodeLocale encodeLocale decodeStringtryTokInternalforceTokReplaceParserMparselexChar lexStringstringlexEofmyLex'anyChar endOfInputcharint skipSpace skipWhiletakeTill takeTillChartakelinesStartingWithlinesStartingWithEndingWithoptionchoice checkConsumes parseStrictlyColorMagentaCyanGreenRedBlue Printers'PrinterscolorP invisiblePhiddenP userchunkPdefP lineColorT lineColorSDocunDoc PrintableBothPSSspacenewlineminusplus backslashlparenrparenparenserrorDoc putDocWith putDocLnWithputDocputDocLn hPutDocWith hPutDocLnWithhPutDoc hPutDocLn renderStringrenderStringWithrenderPS renderPSs renderPSWith renderPSsWithprefixinsertBeforeLastline lineColor hiddenPrefix unsafeBothunsafeBothText packedStringunsafePackedString invisiblePS userchunkPS unsafeChartext unsafeText invisibleText hiddenText userchunkblueTextredText greenText magentaTextcyanText colorTextwrapText printablesimplePrinters simplePrinterinvisiblePrinteremptydoc<><+>$$vcatvsephcat_bug_bugDoc _impossible _fromJust SshFilePathsshUhostsshReposshFile isRelative isAbsoluteisFile isHttpUrlisSshUrl isSshNopath splitSshUrlurlOf formatHeader makeEmail readEmail getChangesshiftBoundariesRLNilRL:<:FLNilFL:>::||::/\::\/::<:>nullFLnullRL filterFLFLfilterRL+>++<+ reverseFL reverseRLconcatFLconcatRLspanFLspanFL_M splitAtFL splitAtRLbunchFLallFLanyFLfoldlFLfoldlRLmapFL_FL zipWithFLmapRL_RLmapFLfilterFLmapRLlengthFLlengthRLisShorterThanRL consRLSealedtoFL dropWhileFL dropWhileRLeqFLeqFLRev eqFLUnsafeCommutecommute toFwdCommute toRevCommute commuteRLFL commuteRLcommuteFLorComplain commuteFLInvertinvertinvertFLinvertRL CommuteFn partitionFL partitionRLcommuteWhatWeCanFLcommuteWhatWeCanRLgenCommuteWhatWeCanRL removeCommonremoveFLremoveRLremoveSubsequenceFLremoveSubsequenceRLsimpleHeadPermutationsFLheadPermutationsFLheadPermutationsRL selfCommuter commuterIdRL commuterIdFL commuterFLIdpartitionConflictingFL BracketedFL BracketedParensBraced Singleton unBracketed unBracketedFL mapBracketedmapBracketedFL_FLMergemergemergeFL PatchInspectlistTouchedFiles hunkMatchesFZipper flToZippernullFZlengthFZfocusclownsjokers rightmostrightleftmostlefttoEndtoStartFileNamefp2fnfn2fp niceps2fn fn2nicepsfn2psps2fn encodeWhite decodeWhiteownName superName breakOnDirnormPathbreakup///isParentOrEqOfmovedirfilenameAbsoluteOrRemotePathAbsolutePathOrStd AbsolutePathSubPath FilePathLike toFilePath FilePathOrURLtoPath makeSubPathOf simpleSubPath ioAbsolute makeAbsolute rootDirectorymakeAbsoluteOrStdstdOutioAbsoluteOrStduseAbsoluteOrStdioAbsoluteOrRemoteisRemotesetCurrentDirectorysp2fn PromptConfigpPromptpBasicCharacterspAdvancedCharacterspDefaultpHelp showHexLen addToErrorLoccatchall maybeGetEnv firstJustIO clarifyErrorsprettyException prettyError ortryrunningwithCurrentDirectory withUMaskaskUseraskEnteraskUserListItemstripCr formatPath breakCommandnubsorteditFile runEditorenvironmentHelpEditor getViewerenvironmentHelpPager promptYorn promptChar filterPathsfilterFilePaths getFileStatustreeHasAnycasetreeHas treeHasDir treeHasFilesetDarcsEncodingsgetSystemEncoding isUTF8Locale canonFilename mkStdoutTemp maybeRelinksloppyAtomicCreate atomicCreate RemoteDarcsDefaultRemoteDarcs ScanKnown ScanBoringScanAllUseIndex IgnoreIndex CompressionGzipCompression NoCompression DarcsFlag AmendUnrecordNoAmendUnrecordNoRecordRollbackRecordRollbackNullFlag JustThisRepoRepairCheckAllowUnrelatedReposNoCacheNoPacksPacksNoHTTPPipelining ApplyOnDisk StoreInMemoryUMask RunPrehook AskPrehook NoPrehook PrehookCmd RunPosthook AskPosthook NoPosthook PosthookCmd NoPendingPending NoDirectories DirectoriesNoFilesFiles UpgradeFormat OptimizeHTTPOptimizePristineRelinkSiblingNoUpdateWorking UseWorkingDirUseNoWorkingDir UseFormat2UseHashedInventoryBisectDontSetScriptsExecutableSetScriptsExecutableDisable NoSetDefault SetDefaultDryRunNonForce NonVerifyNonApply UpToPattern AfterPatternSeveralPattern OnePattern ForceReplace XMLOutput DiffFlags FixFilePathLazyCompleteForwardReverse NonUnifiedUnified NoPauseForGui PauseForGui NoSummarySummary ExternalMergeDiffCmd InteractivePipe HumanReadableMachineReadableApplyAsReplyNewRepo RemoteRepo WorkRepoUrl WorkRepoDir UnCompress NoCompressCompressPromptForDependenciesDontPromptForDependencies DontGrabDepsDontAllowWindowsReservedAllowWindowsReservedDontAllowCaseOnly AllowCaseOnly SkipBoringBoring SkipConflictsNoAllowConflicts MarkConflictsAllowConflicts NoKeepDateKeepDatePromptLongCommentNoEditLongCommentEditLongCommentToksNoEditDescriptionEditDescriptionRemoteDarcsOpt VerifySSLVerifyNoHappyForwardingHappyForwardingSignSSLNoSignSignAsSign ComplementUnion Intersection CreatorHashAnyOrder NoLookForAdds LookForAddsDontIgnoreTimes IgnoreTimes NoAskDepsAskDepsDontRestrictPaths RestrictPathsReorder NoRecursive RecursiveAllDistName DontRmLogFile RmLogFileLogFileCountContext GenContextUpToTagAfterTagOneTag NumberPatchesPatchIndexRangeMaxCountLastNTagName UpToPatch AfterPatch SeveralPatchOnePatch PatchNameAuthor SendmailCmdCharset InReplyToSubjectOutputAutoNameOutputCcTargetQuietNormalVerbosityVerbose DebugHTTP DebugVerboseDebugTimingsNoLeaveTestDir LeaveTestDirChangesToAllFilesOnlyChangesToFilesTestNoTest ListOptionsHelp compression remoteDarcs diffingOptswantExternalMerge wantGuiPause isInteractivemaxCountwillIgnoreTimeswillRemoveLogFile isUnified isNotUnifieddoHappyForwarding includeBoringdoAllowCaseOnlydoAllowWindowsReserved doReverseusePacksshowChangesOnlyToFiles defaultFlagrollbackInWorkingDirremoveFromAmendedSSHCmdSFTPSCPSSHcopySSHgetSSHenvironmentHelpSshenvironmentHelpScpenvironmentHelpSshPortwithLockwithLockCanFailremoveFileMayNotExistwithTemp withOpenTempwithStdoutTemp tempdirLocenvironmentHelpTmpdirenvironmentHelpKeepTmpdir withPermDir withTempDirwithDelayedDir rmRecursiveworldReadableTemp withNamedTempeditText readBinFilereadLocaleFilereadDocBinFile appendBinFileappendDocBinFile writeBinFilewriteLocaleFilewriteDocBinFilewriteAtomicFilePSgzWriteAtomicFilePSgzWriteAtomicFilePSsgzWriteDocFile writeToFile appendToFile ReadPatch readPatch'readPatchPartial readPatch bracketedFLpeekfor readFileNameSummOpSummModSummRmSummAdd SummDetailSummNoneSummMvSummFile SummRmDir SummAddDir sha256sumparseCmd addUrlencodedmaxPipelineLength copyUrlFirstcopyUrlwaitUrldisableHTTPPipelining setDebugHTTPenvironmentHelpProxyenvironmentHelpProxyPassword sendmailPath diffProgram darcsProgrambackupByRenamingbackupByCopying fetchFilePSfetchFileLazyPS gzFetchFilePS copyFileOrUrlspeculateFileOrUrl copyLocal cloneTreecloneTreeExcept cloneFile maybeURLCmdexecSSHpipeDoc pipeDocSSH sendEmail generateEmail haveSendmail sendEmailDoc resendEmail execDocPipeexecPipeIgnoreError signStringverifyPSgetTermNColorsviewDoc viewDocWithtraceDoc assertDoc fancyPrinters MonadProgressrunProgressActionsProgressActionpaAction paMessage paOnErrorsilentlyRunProgressActions ApplyMonadApplyMonadBase nestedApply liftApply getApplyState putApplyState editDirectorymDoesDirectoryExistmDoesFileExist mReadFilePS mReadFilePSsmCreateDirectorymRemoveDirectory mCreateFile mRemoveFilemRename mModifyFilePSmModifyFilePSs mChangePrefApplyMonadTransApplyMonadOver runApplyMonadToTreetoTree withFileNames withFilesApply ApplyStateapplyeffectOnFilePathsapplyToFilePaths applyToTree applyToState RepairToFLapplyAndTryToFixFLapplyAndTryToFixisInconsistent mapMaybeSnd RepoFormatRF RepoProperty NoWorkingDirHashedInventoryDarcs2Darcs1_0identifyRepoFormattryIdentifyRepoFormatwriteRepoFormatcreateRepoFormat writeProblemreadfromAndWritetoProblem readProblem formatHasgetMotdshowMotd remoteApplyapplyAssha1PS PatchInfo_piDate_piName _piAuthor_piLog isInverted RepoPatchInfo repopatchinfo idpatchinfo patchinfoaddJunk invertNamejustName justAuthorjustLog humanFriendlypiNamepiRenamepiAuthorisTagpiDate piDateStringpiDateBytestring setPiDatepiLogpiTagtoXml escapeXMLmakeAltFilename makeFilename makePatchname showPatchInfo readPatchInforeadPatchInfos ShowPatch showNicelyshowContextPatch descriptionsummary summaryFLthingthingsShowPatchBasic showPatchshowNamedPrefix writePatch gzWritePatchformatFileNamePatchyIsHunkisHunkFileHunk showFileHunk PrimApply applyPrimFLPrimReadreadPrimPrimShowshowPrim PrimDetails summarizePrim PrimCanonize tryToShrinktryShrinkingInversesortCoalesceFLcanonize canonizeFLjoin PrimConstructaddfilermfileadddirrmdirmove changeprefhunk tokreplacebinary primFromHunk anIdentity PrimClassify primIsAddfile primIsRmfile primIsAdddir primIsRmdir primIsMove primIsHunkprimIsTokReplace primIsBinary primIsSetpref is_filepatch FromPrims fromPrims joinPatches ToFromPrimtoPrimFromPrimfromPrim PrimPatchBasePrimOf PrimPatch showPrimFLPatchRegremMergerPPisMerger mergerUndo showPatch_EffecteffecteffectRL ConflictState Duplicated ConflictedOkayIsConflictedPrimIsCCommuteNoConflictscommuteNoConflictsConflictlistConflictedFilesresolveConflictsconflictedEffectplainSummaryPrimplainSummaryPrims plainSummary xmlSummarymangleUnravelled publicUnravelunravelmerger DirPatchTypeAddDirRmDir FilePatchTypeBinary TokReplaceHunkAddFileRmFilePrim ChangePrefFPDPMove isIdentity comparePrimWrappedCommuteFunctionrunWrappedCommuteFunctionPerhaps SucceededFailedUnknown subcommutesIdentity DemanifestManifestTextHunk BinaryHunkhunkEdittouches CommuteMonad commuteFail DummyPatchshowContextSeriesshowContextHunkSplitter applySplitter canonizeSplit rawSplitter noSplitter primSplitterreversePrimSplitterNamedNamedP namepatch anonymous infopatchadddepsgetdepspatch2patchinfo patchname patchcontents fmapNamed fmapFL_Named RepoPatch WPatchInfo unWPatchInfo PatchInfoAnd HopefullycompareWPatchInfoinfo patchDescwinfopiapn2piapatchInfoAndPatchfmapPIAP fmapFL_PIAP hopefullyconscientiously hopefullyMactually createHashed extractHash unavailableannotateannotateDirectory machineFormatformatTaggedPatchSetSealedPatchSetOrigin newset2RL newset2FL appendPSFLprogressPatchSettags progressFL progressRLprogressRLShowTags checkPathsmaliciousPatcheshasMaliciousPathisMaliciousPathisMaliciousSubPathgetPatchesBeyondTag splitOnTaggetPatchesInTag getTagsRightdeepOptimizePatchsetoptimizePatchsetslightlyOptimizePatchset commuteToEndremoveFromPatchSetfindCommonWithThem findUncommon countUsThem mergeThemnewsetIntersection newsetUnionmerge2FLareUnrelatedReposMatcherMatchFun makeMatcher applyMatcher parseMatch matchPattern matchParserhelpOnMatchers readOldReporevertTentativeChangesoldRepoFailMsgSlotInLastInMiddleInFirst PatchChoices TaggedPatchTagtagtpPatch patchChoicespatchChoicesTpsSubpatchChoicesTpsseparateFirstFromMiddleLastseparateFirstMiddleFromLast getChoices refineChoices patchSlot patchSlot'forceMatchingFirst forceFirsts forceFirstselectAllMiddlesforceMatchingLast forceLasts forceLast makeUncertainmakeEverythingLatermakeEverythingSooner substituteselectTouchingdeselectNotTouchingselectNotTouchingchooseTouchingchoosePreTouching lookTouchshowHunkNonablenonNonunNonshowNonsshowNonreadNonsreadNoncommuteOrAddToCtxcommuteOrAddToCtxRLcommutePrimsOrAddToCtxremNonscommuteOrRemFromCtxcommuteOrRemFromCtxFL*>>**>>>>* RealPatch InvConflictor ConflictorNormal Etacilpud Duplicate isDuplicate isForwardmergeUnravelled isConsistent prim2real hashBundle makeBundleN makeBundle2 parseBundle scanBundle getContextcontextPatches scanContext patchFilenameCacheCaCacheLoc cacheType cacheWritable cacheSource CacheTypeRepo WritableOrNot NotWritableWritable HashedDirHashedInventoriesDirHashedPatchesDirHashedPristineDir hashedDir allHashedDirs unionCachesunionRemoteCachescompareByLocality repo2cache cacheHashokayHashtakeHashfetchFileUsingCachewritable isthisrepohashedFilePath peekInCachespeculateFileUsingCachespeculateFilesUsingCachewriteFileUsingCache cleanCachescleanCachesWithHintreportBadSourcesFileTypeTextFile BinaryFilewriteDefaultPrefsboringFileHelpdarcsdirFilterglobalPrefsDirDocenvironmentHelpHome getGlobalglobalCacheDir boringRegexpsboringFileFilterbinariesFileHelpfiletypeFunction addToPreflist getPreflist setPreflist defPrefval getPrefval setPrefval changePrefval defaultreposetDefaultrepo getCachestreeDiffstandardResolutionexternalResolutionpatchsetConflictResolutions runSilently runTolerantly applyPatchesRepoTypeDarcsRepository RepositoryPristineHashedPristine PlainPristine NoPristine extractCacheextractOptions modifyCache pendingName readPendingreadTentativePendingreadNewPendingwriteTentativePendingwriteNewPending TreeFilterapplyTreeFilterrestrictSubpathsrestrictBoringunrecordedChanges readRecordedreadUnrecorded readWorkingreadRecordedAndPendinginvalidateIndex readIndexRWHashedIO copyHashedcopyPartialsHashed cleanHashdirfinalizeTentativeChangesreadHashedPristineRoot cleanPristineaddToSpecificInventoryaddToTentativeInventoryremoveFromTentativeInventoryreadReporeadTentativeReporeadRepoUsingSpecificInventoryreadRepoFromInventoryListcopyRepo copySourceswriteAndReadPatchwriteTentativeInventorywritePatchIfNecessarylistInventories readPatchIdsapplyToTentativePristine copyPristinecopyPartialsPristinepris2invRepoJobV2JobV1JobUpdatePristineDontUpdatePristine MakeChangesDontMakeChanges IdentifyRepoGoodRepository NonRepository BadRepositoryRIO unsafeUnRIOrIO getRepositorymaybeIdentifyRepositoryidentifyDarcsRepositoryidentifyRepositoryForamInRepositoryamInHashedRepositoryseekRepoamNotInRepositoryfindRepositorymakeNewPending makePatchLazyprefsUrl unrevertUrlapplyToWorkingannounceMergeConflictscheckUnrecordedConflictstentativelyAddPatchtentativelyAddPatch_tentativelyAddToPendingsetTentativePendingtentativelyRemovePatchestentativelyReplacePatchesfinalizeRepositoryChanges testTentative testRecordedrevertRepositoryChangespatchSetToPatches withGutsOfwithRepositorywithRepositoryDirectory withRepoLockwithRepoReadLockoptimizeInventorycleanRepositorycreatePristineDirectoryTree#createPartialsPristineDirectoryTree withRecordedsetScriptsExecutablesetScriptsExecutablePatchestentativelyMergePatchesconsiderMergeToWorkingcreateRepositorycopyRepository writePatchSetpatchSetToRepositorycheckUnrelatedRepos addToPendingreplacePristine DarcsOptionDarcsMutuallyExclusiveDarcsMultipleChoiceOptionDarcsSingleOptionDarcsAtomicOptionDarcsInternalOptionDarcsNoArgOptionDarcsOptAbsPathOptionDarcsAbsPathOrStdOptionDarcsAbsPathOptionDarcsArgOptionisinarein nubOptions applyDefaults atomicOptionsoptionFromDarcsOptionfixFilePathOrStd fixUrlFlagfixUrlmaybeFixSubPaths fixSubPaths listOptions flagToStringhelpdisable anyVerbosityworkingRepoDirpossiblyRemoteRepoDir getRepourl remoteRepopatchnameOption sendToContextmatchOneContextmatchOnematchOneNontag matchSeveral matchRangematchSeveralOrRangematchSeveralOrLast matchMaxcountnotesttest leaveTestDirrecordRollback amendUnrecord ignoretimes lookforaddsaskdepsaskLongCommentkeepDatelogfile rmlogfileauthorfromOptfileHelpAuthorenvironmentHelpEmail getAuthor getEasyAuthor nocompressuncompressNocompressunifiedunidiff diffCmdFlag pauseForGui storeInMemorytargetccSendccApplygetCcsubject getSubjectcharset getCharset inReplyTo getInReplyTooutputoutputAutoName getOutputeditDescriptiondistnameOption recursivepatchFormatChoices useWorkingDir upgradeFormat xmloutput creatorhashsignapplyashappyForwarding setDefaultverifyreponamedepsSeltokenspartial forceReplacereplyapplyConflictOptionspullConflictOptionsuseExternalMerge dryRunNoxmldryRun showFriendlyprintDryRunMessageAndExit noskipBoringallowProblematicFilenames diffflags changesFormatchangesReverse onlyToFiles humanReadablemachineReadableallInteractiveallPipeInteractivepipeInteractiverepoCombinator listFileslistUnregisteredFileslistRegisteredFiles optionsLatexsetScriptsExecutableOptionbisectrelinksiblingflagsToSiblingsreorderPatches sendmailCmdenvironmentHelpSendmailgetSendmailCmdfiles directoriespendingnullFlagsetEnvDarcsPatchessetEnvDarcsFiles posthookCmdposthookPromptgetPosthookCmd prehookCmd prehookPrompt getPrehookCmdnetworkOptionsnoCacheoptimizePristine optimizeHTTP umaskOption restrictPathsallowUnrelatedRepos justThisRepo checkOrRepairpatchSelectFlagmakeScriptsExecutable CommandArgsSuperCommandSubSuperCommandOnly CommandOnly DarcsCommand SuperCommandcommandSubCommandscommandProgramName commandName commandHelpcommandDescriptioncommandExtraArgscommandExtraArgHelpcommandCommand commandPrereqcommandGetArgPossibilitiescommandArgdefaultscommandBasicOptionscommandAdvancedOptionsCommandControl GroupName HiddenCommand CommandDataextractCommandscommandAlloptionscommandOptions nodefaultsgetSubcommands commandAlias commandStubusagesubusage usageHelper chompNewlinegetCommandMiniHelpgetCommandHelpdisambiguateCommands putVerboseputInfo putWarningabortRun printFriendly printPatchprintPatchPagercontextualPrintPatchgetTest runPosthook runPrehookadd expandDirs announceFilesfilterExistingFilesInclusiveOrExclusive Exclusive InclusivehaveNonrangeMatchhavePatchsetMatchgetNonrangeMatchgetPartialNonrangeMatchgetNonrangeMatchS firstMatch getFirstMatchgetPartialFirstMatch secondMatchgetPartialSecondMatchcheckMatchSyntaxnonrangeMatchermatchAPatchread matchAPatch matchPatchgetOnePatchset hasIndexRangematchFirstPatchsetmatchSecondPatchset matchExistsapplyInvToMatcher applyNInv WhichChanges FirstReversedFirst LastReversedLastselectionContextPrimselectionContext runSelection selectChanges viewChangeswithSelectedPatchFromRepofilterOutConflictsrecordcommitgetDategetLogaskAboutDepends amendrecord amendunrecordgetPatchBundlechangeslogRepositoryConsistency BrokenPatchesBrokenPristineRepositoryConsistentreplayRepositoryInTempreplayRepository checkIndexcheckrepairconvert diffCommanddistgetclone doCRCWarningsgzcrcs initialize initializeCmd markconflictsmvoptimizepushputremovermunaddreplace defaultToksunrevert writeUnrevertrevertunrecordgetLastPatchesunpull obliteraterollbacksetpref showAuthorsshowBug showContents showFilestoListManifestmanifest manifestCmdshowTags showIndexshowPristineCmd trackdown transferModewhatsnewstatusfetchpullshowRepo showCommandquerylistfetchUrlpostUrl requestUrl waitNextUrlsendcommandControlListhelpCmdlistAvailableCommands printVersionenvironmentHelpgetDefaultFlags runTheCommandGHC.Num-GHC.Real^GHC.Base.old-time-1.1.0.0 System.Time CalendarTime Data.MaybeNothingreadDatedateTime englishDate englishTime englishAgo$fCountableThis$fCountablePronoun$fCountableNoun $fShowEqCheck $fEqEqCheck$fExceptionSignalExceptionStepped$fGapFreeRight $fGapFreeLeft $fShowSealed2 $fShowSealed $fEqSealed$fShowPatchMatch _progressData$fExceptionExecExceptioncurl_pipelining_enabledcurl_enable_debug curl_last_urlcurl_wait_next_urlcurl_request_urlpipeliningEnabled cachableToIntString Data.ListunlinesData.ByteString.Internal ByteStringghc-prim GHC.TypesCharMaybemyLexSM$fAlternativeSM$fApplicativeSM $fFunctorSM $fMonadPlusSM $fParserMSM $fMonadSM $fShow1:> $fShow2RL $fShow1RL$fShowRL $fShow2FL $fShow1FL$fShowFL $fShow2:\/: $fShow:\/: $fShow2:>$fEq:<$fMyEq:<$fEq:>$fMyEq:>$fShow:> $fCommuteRL $fCommuteFL $fInvertRL$fMyEqRL $fInvertFL$fMyEqFL$fPatchListFormatBracketed $fMergeRL $fMergeFL$fPatchInspectRL$fPatchInspectFLord$fShowFileName$fShowAbsoluteOrRemotePath$fShowAbsolutePathOrStd $fShowSubPath$fShowAbsolutePath$fFilePathLike[]$fCharLikeChar$fFilePathLikeSubPath$fFilePathLikeAbsolutePath$fFilePathLikeFileName$fFilePathOrURLFileName#$fFilePathOrURLAbsoluteOrRemotePath$fFilePathOrURL[]$fFilePathOrURLSubPath$fFilePathOrURLAbsolutePathGHC.IOFilePath $fReadPatchRL $fReadPatchFL$fReadPatchBracketed $fShowDoc$fMonadProgressRWST$fMonadProgressIO$fMonadProgressStateT$fApplyMonadStateTTree$fMonadProgressStateT0$fApplyMonadStateTTree0$fApplyMonadRWSTTree$fApplyMonadTransmTree $fToTreeTreehashed-storage-0.5.9Storage.Hashed.TreeTree $fApplyRL $fApplyFL $fRepairFL $fCheckRL $fCheckFL$fShowRepoProperty$fShowPatchInfo$fHTMLRepoPatchInfo $fFromPrimsRL $fFromPrimsFL $fFromPrimFL$fPrimPatchBaseRL$fPrimPatchBaseFL $fCheckPatch$fPatchListFormatPatch$fFromPrimPatch$fPrimPatchBasePatch $fShow2Patch $fShow1Patch $fShowPatch $fEffectRL $fEffectFL$fCommuteNoConflictsRL $fConflictRL$fCommuteNoConflictsFL $fConflictFL $fEqPatch $fMyEqPatch $fInvertPatch $fIsHunkPatch $fEffectPatch$fConflictPatch$fCommuteNoConflictsPatch$fPatchInspectPatch$fCommutePatch $fMergePatch$fMonadPlusPerhaps$fMonadPerhaps$fRepairToFLPatch $fApplyPatch$fReadPatchPatch$fEqPrim $fMyEqPrim$fPatchInspectPrim $fInvertPrim $fIsHunkPrim$fPrimConstructPrim$fPrimClassifyPrim$fMyEqDirPatchType$fMyEqFilePatchType $fCommutePrim$fPrimDetailsPrim$fPrimReadPrim$fReadPatchPrim $fMyEqHunk$fApplyMonadTransmObjectMap$fApplyMonadStateTObjectMap$fToTreeObjectMap$fPrimApplyPrim$fRepairToFLPrim $fApplyPrim$fPrimCanonizePrim$fCommute'Prim$fCommuteMonadMaybe$fPatchyDummyPatch$fApplyDummyPatch$fCommuteDummyPatch$fShowPatchDummyPatch$fShowPatchBasicDummyPatch$fReadPatchDummyPatch$fPatchInspectDummyPatch$fInvertDummyPatch$fMyEqDummyPatch$fPatchListFormatDummyPatch$fIsHunkDummyPatch$fShowPatchBasicBracketed $fShowPatchRL$fShowPatchBasicRL $fShowPatchFL$fShowPatchBasicFL $fShow2Named $fShow1Named $fShowNamed$fShowPatchNamed$fShowPatchBasicNamed $fCheckNamed$fConflictNamed$fPatchInspectNamed $fMergeNamed$fCommuteNamed $fInvertNamed $fMyEqNamed $fRepairNamed $fApplyNamed$fReadPatchNamed$fPatchListFormatNamed $fIsHunkNamed $fEffectNamed$fPrimPatchBaseNamed $fPatchyRL $fPatchyFL $fPatchyNamed Data.EitherEitherSimpleHopefully$fPatchyPatchInfoAnd$fIsHunkPatchInfoAnd$fEffectPatchInfoAnd$fReadPatchPatchInfoAnd$fRepairPatchInfoAnd$fApplyPatchInfoAnd$fPatchInspectPatchInfoAnd$fMergePatchInfoAnd$fCommutePatchInfoAnd$fShowPatchPatchInfoAnd$fShowPatchBasicPatchInfoAnd$fPatchListFormatPatchInfoAnd$fInvertPatchInfoAnd$fMyEqPatchInfoAnd$fMyEqWPatchInfo$fPrimPatchBasePatchInfoAnd $fShowMatcherTG$fMyEqPatchChoice$fMergePatchChoice$fPatchInspectPatchChoice$fCommutePatchChoice$fMergeTaggedPatch$fPatchInspectTaggedPatch$fCommuteTaggedPatch$fInvertTaggedPatch$fMyEqTaggedPatch$fPrimShowPrim$fShowDirPatchType$fShowFilePatchType $fShow1Prim $fShow2Prim $fShowPrim$fShowPatchPrim$fShowPatchBasicPrim$fPatchListFormatPrim$fFromPrimPrim$fPrimPatchBasePrim $fPatchyPrim$fPrimPatchPrim$fShowPatchPatch$fShowPatchBasicPatch$fRepoPatchPatch $fPatchyPatch$fEqNon$fWLRL$fWLFL $fShow1Non $fShowNon$fIsHunkRealPatch$fEffectRealPatch$fNonableRealPatch$fShow2RealPatch$fShowRealPatch$fReadPatchRealPatch$fShowPatchRealPatch$fShowPatchBasicRealPatch$fPatchListFormatRealPatch$fRepairToFLRealPatch$fApplyRealPatch$fPatchInspectRealPatch$fMergeRealPatch$fCommuteRealPatch$fInvertRealPatch$fMyEqRealPatch$fToFromPrimRealPatch$fFromPrimRealPatch$fCheckRealPatch$fCommuteNoConflictsRealPatch$fConflictRealPatch$fPatchyRealPatch$fPrimPatchBaseRealPatch$fRepoPatchRealPatch $fShowCache$fShowCacheLoc $fEqCacheLoc$fApplyMonadSilentIOTree$fApplyMonadTolerantIOTree$fMonadSilentIO$fFunctorSilentIO$fMonadTolerantIO$fFunctorTolerantIO$fTolerantMonadSilentIO$fTolerantMonadTolerantIO$fApplyMonadIOTree$fShowPatchBasicFLM$fReadPatchFLMStorage.Hashed.DarcsreadDarcsHashedStorage.Hashed.Plain readPlainTree $fMonadRIO $fFunctorRIOPatchSelectionContextPatchSelectionversion builddepscontext