h*l      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  !!!!!!!"""""""""""""################$$$$$$$$$$$$%%%%%%%%%%%%%&'''''''''(((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))**************++++++,,,,,,,,-------....//////////////000000001111111111111111112222222222222222222223334444444444444555555555555555555555555 5 5 5 5 5 5 5 5 5 5 5  6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < = = = = = = = = = = = = = = = = = = = > > > > > > > > > > > > > > > ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ A A A A A A A A B B B B B B B B B B B B B B B B B B B B B B C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C D D D D D D D D D D D D D D D D D D D D D D D D E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E E F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F F G H H H H H H H H H H H H H H H H H H H H H H HHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJKKKKKKLLLLLLLLLLLLLLLLLLLLLMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQRRRRSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXYYYYYYYYYYZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[\\\\\\\]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^___________________``````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaabcccccccdddddddeeefghhhhhhhhhhhhhhhhhhhhhhhhhhhiijkkllmmmmmnoppppppppqqqqqqqqqqqrrrrrrrrrrrrrrrsstttttttttttuuuuuuuuuuuuuuuuuuuuuuvvvvvvwwwwwwwxyyyyzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{||||||||||||||||||||||||||||||||||||||}}}}}}}}}}}}}}}}}}}}}~2.18.2 Safe-Inferred%&)*/1679=N Safe-Inferred%&)*/1679=O<7EH9:;FGA=0Y"NO#  /',WB+jklmno8@& -$P)[(DIJ314%* {|}~.V\ghispqrtuvwxyz2! UZX65QR7EH9:;FGA=0Y"NO#  /',WB+jklmno8@& -$P)[(DIJ314%* {|}~.V\ghispqrtuvwxyz2! UZX65QR  Safe-Inferred%&)*/1679=VJdarcsAn witness aware equality class. A minimal definition defines any one of ,  and .darcsIt is unsafe to define a class instance via this method, because 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 choices as it is not usually meaningul to compare two patches that don't share either a starting or an ending contextdarcsCompare two things with the same starting witness. If the things compare equal, evidence of the ending witnesses being equal will be returned.darcsCompare two things with the same ending witness. If the things compare equal, evidence of the starting witnesses being equal will be returned.darcs is used to pass around evidence (or lack thereof) of two witness types being equal.44  Safe-Inferred%&)*/1679=[darcs returns a filter function that tells if a char is a member of the regChar expression or not. The regChar expression is basically a set of chars, but it can contain ranges with use of the   (dash), and it can also be specified as a complement set by prefixing with ^ (caret). The dash and caret, as well as the backslash, can all be escaped with a backslash to suppress their special meaning. NOTE: The h (dot) is allowed to be escaped. It has no special meaning if it is not escaped, but the default  filename_toks7 in Darcs.Commands.Replace uses an escaped dot (WHY?).darcs unescapes whitespace, which is escaped in the replace patch file format. It will also unescape escaped carets, which is useful for escaping a leading caret that should not invert the regChars. All other escapes are left for the unescaping in .darcs assembles the filter function. It handles special chars, and also unescaping of escaped special chars. If a non-special char is still escaped by now we get a failure.  Safe-Inferred%&)*/1679=_darcsbreakOutToken tokChars input splits the input  ByteString into G (before, token, after), where token6 is the first non-empty substring consisting only of 9s in tokChars, or F if no token was found. The 9s in tokChars5 should not have code points larger than 255 (0xff).darcs$tryTokReplace tokChars old new input tries to find the token old and replace it with the token new everywhere in the input , returning G the modified input, unless the token new is already in the input in which case F is returned. A token is a sequence of bytes that match the class defined by tokChars<. This function is supposed to work efficiently with large inputs i.e. whole files.darcs&forceTokReplace tokChars old new input" replaces all occurrences of the old token with the new one, throughout the input.darcs:Check if a token replace operation touches the given line.darcsBreak a  Bytestring into tokens, according to , discarding non-tokens.  Safe-Inferred%&)*/1679=d darcson-disk format for V1 patchesdarcson-disk format for V2 patchesdarcsdisplay formatdarcs1This 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.darcs#Show and read lists without braces.darcsShow lists with a single layer of braces around the outside, except for singletons which have no braces. Read with arbitrary nested braces and parens and flatten them out.darcsShow lists without braces. Read with arbitrary nested parens and flatten them out.darcsTemporary hack to disable use of showContextSeries for darcs-3 patches, until I find out how to fix this.darcsShowing and reading lists of patches. This class allows us to control how lists of patches are formatted on disk. For legacy reasons V1 patches have their own special treatment (see ). Other patch types use the default format which just puts them in a sequence without separators or any prelude/epilogue.This means that 'FL (FL p)' etc would be ambiguous, so there are no instances for 'FL p' or other list types.    Safe-Inferred%&)*/1679=f"darcsThis nullary type class flags code that should only be used for the tests. No instance of it should be defined in either the darcs library or the main darcs executable. Safe-Inferred%&)*/1679=hLdarcsLift an isomorphism between a and b to one between f a and f b. Like ), except we can only map invertible functions (i.e. an Isomorphisms).darcsLightweight type ismomorphisms (a.k.a. invertible functions). If Iso fw bw :: Iso a bthen fw and bw are supposed to satisfyfw . bw = id = bw . fwdarcsApply an iso under a functor.darcs.Apply an iso under cps (which is a cofunctor). Safe-Inferred%&)*/1679=}odarcsType of primitive (not yet combined) options. The type parameter b gets instantiated to (v -> a), adding one argument of type v) to the answer type of the continuation.darcs!A type for option specifications.It consists of four components: a parser, an unparser, a checker, and a list of descriptions.The parser converts a flag list to some result value. This can never fail: we demand that primitive parsers are written so that there is always a default value (use > with default F as a last resort).The unparser does the opposite of the parser: a value is converted back to a flag list.The checker returns a list of error messages (which should be empty if there are no problems found). This can be used to e.g. check whether there are conflicting flags in the list.Separating the checker and parser is unusual. The reason for this is that we want to support flags coming from multiple sources, such as the command line or a defaults file. Prioritising these sources is done by concatenating the flag lists in the order of precedence, so that earlier flags win over later ones. That means that when parsing the (final) flag list, conflicting flags are resolved by picking the first flag that matches an option. The checker, on the other hand, can be called for each source separately.The last component is a list of descriptors for each single switch/flag that the option is made of.The 7 type is heavily parameterized. The type arguments are: fThe flag type, such as .d0A type that describes an single flag, such as  or . It should be a .Abstracting over these types is not technically necessary: for the intended application in Darcs, we could as well fix them as d=, and f=, saving two type parameters. However, doing that here would only obscure what's going on, making the code harder to understand, not easier. Besides, the resulting more general type signatures give us additional guarantees, known as "free theorems" (free as in beer, not in speak). In contrast, the type parameters a, bare necessary to make chaining of options a la typed printf/scanf possible. In a nutshell, a is the result type of a function that consumes the result of parsing or unparsing an option, while b+ is the complete type of such a function.The  and  members use continuation passing style, which is the reason for their apparently "inverted" type signature. To understand them, it helps to look at the type of "primitive" (not yet combined) options (see ! below). For a primitive option, b gets instantiated to v -> a, where v is the type of values associated with the option. The whole option spec then has type  o :: 'OptSpec' d f a (v -> a) so that the  and  members are instantiated to  ounparse :: forall a. ([f] -> a) -> (x -> a) oparse :: forall a. (x -> a) -> ([f] -> a),which can be easily seen to be equivalent to + ounparse :: x -> [f] oparse :: [f] -> x:Chaining such options results in a combined option of type 6 o1 ^ o2 ^ ... :: OptSpec d f a (v1 -> v2 -> ... -> a) that is, b gets instantiated to  v1 -> v2 -> ... -> aTo use such an option (primitive or combined), you pass in the consumer. A typical consumer of option values is a command implementation. Given , cmd :: v1 -> v2 -> ... -> [String] -> IO ()/we can parse the flags and pass the results to cmd: ! oparse (o1 ^ o2 ^ ...) cmd flagsdarcs1Convert option value (back) to flag list, in CPS.darcsConvert flag list to option value, in CPS. Note: as a pure function, it is not supposed to fail.darcs7Check for erros in a flag list, returns error messages.darcs9Descriptions, one for each flag that makes up the option.darcs Identity  , unit for darcs composition, associativedarcsNormalise a flag list by parsing and then unparsing it. This adds all implicit (default) flags to the list.2onormalise opts = (oparse opts . ounparse opts) iddarcs!The list of default flags for an .&defaultFlags opts = onormalise opts []darcsLift an isomorphism between b and c to one between  d f a b and  d f a c.The forward component of the  is needed for , the backward component for 4. For the other two components this is the identity.darcsCombine two list valued options of the same type "in parellel". This is done by concatenating the resulting option values ( ), flags ( ), errors (), and descriptors ('), respectively, of the input options.darcs Unit for .darcsParse a list of flags against a primitive option spec, returning the value associated with the option. As noted above, this cannot fail because options always have a default value. parseFlags o fs = oparse o id fsdarcsUnparse a primitive option spec and append it to a list of flags.darcsOperator version of "opt ? flags = parseFlags opt flagsdarcsSee  and .52005 Tomasz ZielonkaGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679=~darcsRegisters an IO action to run just before darcs exits. Useful for removing temporary files and directories, for example. Referenced in Issue1914.2005 Benedikt SchmidtGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679=darcsassoc list mapping characters to strings eg (c,s) means that %c is replaced by sdarcsparse a commandline returning a list of strings (intended to be used as argv) and a bool value which specifies if the command expects input on stdin format specifiers with a mapping in ftable are accepted and replaced by the given strings. E.g. if the ftable is [(s:,"Some subject")], then "%s" is replaced by "Some subject"darcsfor every mapping (c,s), add a mapping with uppercase c and the urlencoded string s Safe-Inferred%&)*/1679= Safe-Inferred%&)*/1679=?darcs Encode a 8 into a  according to the user's locale with the ghc specific //ROUNDTRIP feature added. This means the argument is allowed to contain non-Unicode 9s as produced by .darcs Decode a  into a 8 according to the user's locale with the ghc specific //ROUNDTRIP feature added. This means the result may contain 9s that are not valid Unicode in case decoding with the user's locale fails.2005 Tomasz ZielonkaGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679=  (c) The University of Glasgow 2001, David Roundy 2003-2005GPL (I'm happy to also license this file BSD style but don't want to bother distributing two license files with darcs.droundy@abridgegame.org experimentalportable Safe-Inferred%&)*/1679=darcsPointer to a filesystem, possibly with start/end offsets. Supposed to be fed to (uncurry mmapFileByteString) or similar.darcsDrop leading white space, where white space is defined as consisting of ' ', 't', 'n', or 'r'.darcsSplit the input into lines, that is, sections separated by 'n' bytes, unless it is empty, in which case the result has one empty line.darcs6Concatenate the inputs with 'n' bytes in interspersed.darcsDecompress the given bytestring into a lazy list of chunks, along with a boolean flag indicating (if True) that the CRC was corrupted. Inspecting the flag will cause the entire list of chunks to be evaluated (but if you throw away the list immediately this should run in constant space).darcsRead an entire file, which may or may not be gzip compressed, directly into a .darcsRead standard input, which may or may not be gzip compressed, directly into a .darcsRead in a FileSegment into a Lazy ByteString. Implemented using mmap.darcs 9999any sequence of alphabetic characters (WARNING! treated as 0!)darcsIn English, either a date followed by a time, or vice-versa, e.g,yesterday at noonyesterday tea time12:00 yesterdaySee  and  Uses its first argument as "now", i.e. the time relative to which "yesterday", "today" etc are to be interpreteddarcs:Specific dates in English as specific points of time, e.g,today yesterday/last week (i.e. the beginning of that interval)4 months ago (via )The first argument is "now".darcs0English expressions for points in the past, e.g. 4 months ago 1 day agoday before yesterdaySee darcs*English expressions for intervals of time,1before tea time (i.e. from the beginning of time)&after 14:00 last month (i.e. till now) between last year and last month2in the last three months (i.e. from then till now)!4 months ago (i.e. till now; see )darcsDurations in English that begin with the word "last", E.g. "last 4 months" is treated as the duration between 4 months ago and nowdarcs Either an ; or one of several common English time expressions like noon or 'tea time'darcsSome English durations, e.g.day4 score7 years 12 monthsThis is not particularly strict about what it accepts. For example, "7 yeares", "4 scores" or "1 days" are just fine.darcs+The very beginning of time, i.e. 1970-01-01darcsTrivially convert a  to a fully specified  (note that this sets the  flag to FalsedarcsReturns the first  that falls within a  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. Maybe we should rename it something happier. See also darcs i d multiplies every field in d with iFIXME; this seems like a terrible idea! it seems like we should get rid of it if at all possible, maybe adding an invertDiff functiondarcsSet 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)darcs c mc- replaces any field which is specified in mc with the equivalent field in c -copyCalendar c nullMCalendar == nullMCalendardarcsZero the time fields of a ##2004 David RoundyGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679= darcsA  combines a potential parse for a date string with a "matcher" function that operates on a given date. We use an existential type on the matcher to allow the date string to either be interpreted as a point in time or as an interval.darcs x y is true if x <= y < (x + one_day)+ Note that this converts the two dates to  ClockTime& to avoid any timezone-related errorsdarcs x1 x2 y is true if  x1 <= y < x2 Since x1 and x2 can be underspecified, we simply assume the first date that they could stand for.darcs x1 x2 y is true if  x1 <= y < x2darcs x1 x2 y is true if  x1 <= y < x2darcs  range exact is true if exact5 falls within the a range of dates represented by range. The purpose of this function is to support matching on partially specified dates. That is, if you only specify the date 2007, this function should match any dates within that year. On the other hand, if you specify 2007-01, this function will match any dates within that month. This function only matches up to the second.darcs s" return the first matcher in  that can parse sdarcs d9 returns the list of matchers that will be applied on d. If you wish to extend the date parsing code, this will likely be the function that you modify to do so.darcs ms' returns the first successful match in ms* It is an error if there are no matchesdarcs d; shows the possible interpretations for the date string d/ and how they match against the current datedarcs iso d; shows the possible interpretations for the date string d and how they match against the date represented by the ISO 8601 string isodarcshelper function for  and darcs c dm tells us if dm applies to  c; or if dm? just represents the failure to parse a date, in which case c is moot. Safe-Inferred%&)*/1679=ac^]`TS_febdac^]`T_febdS Safe-Inferred%&)*/1679=*darcs is a wrapper around '[Printable] -> [Printable]' which allows to handle the special case of an empty ( in a non-uniform manner. The simplest  Documents are built from 8s using .darcs?A set of printers to print different types of text to a handle.darcsThe State associated with a . Contains a set of printers for each hanlde, and the current prefix of the document.darcsA  is a bit of enriched text. s are concatenated using  from class 6, which is right-associative.darcsA  is either a String, a packed string, or a chunk of text with both representations.darcs representation of a spacedarcs representation of a newline.darcsA  representing a space (" ")darcsA  representing a newlinedarcsA  representing a "-"darcsA  representing a "+"darcsA  representing a "\"darcsA  that represents "("darcsA  that represents ")"darcs parens d = lparen <> d <> rparendarcsTurn a % into a sentence. This appends a ".".darcsFormat a list of s as quoted text. It deliberately refuses to use English.andClauses but rather separates the quoted strings only with a space, because this makes it usable for copy and paste e.g. as arguments to another shell command.darcs puts a # on stdout using the given printer.darcs puts a ;, followed by a newline on stdout using the given printer.darcs puts a $ on stdout using the simple printer .darcs puts a ), followed by a newline on stdout using darcs hputDocWith puts a - on the given handle using the given printer.darcs hputDocLnWith puts a , followed by a newline on the given handle using the given printer.darcshputDoc puts a  on the given handle using darcs hputDocLn puts a 3, followed by a newline on the given handle using .darcslike & but with compress data before writingdarcsWrite a % to stderr if debugging is turned on.darcs h prints a list of s to the handle h It uses binary output of  ByteString9s. If these not available, converts according to locale.darcs h prints a  to the handle h.darcs renders a  into a 85 with control codes for the special features of the .darcs renders a  into a 8 using a given set of printers. If content is only available as  ByteString*, decode according to the current locale.darcs renders a  into  with control codes for the special features of the Doc. See also  readerString.darcs renders a  into a list of  PackedStrings, one for each line.darcs renders a  into a  using a given set of printers.darcs renders a  into a list of  PackedStrings4, one for each chunk of text that was added to the #, using the given set of printers.darcs renders a  into a list of  Printables using a set of printers. Each item of the list corresponds to a string that was added to the .darcs builds a Doc from a 8 and a > representing the same text, but does not check that they do.darcs builds a  from a 8:. The string is stored in the Doc as both a String and a .darcs builds a  from a  using darcs builds a  from a  using darcs creates a  with invisible text from a darcs Create a " representing a user chunk from a ; see  for details.darcs- creates a Doc containing just one character.darcs creates a  from a String, using .darcs creates a  from a 8, using  directlydarcs creates a " containing invisible text from a Stringdarcs creates a  containing hidden text from a Stringdarcs Create a  containing a userchunk from a String.Userchunks are used for printing arbitrary bytes stored in prim patches:1old and new preference values in ChangePref prims7tokenChars, old token and new token in TokReplace prims'old and new content lines in Hunk primsIn colored mode they are printed such that trailing whitespace before the end of a line is made visible by marking the actual line ending with a red  char (unless DARCS_DONT_ESCAPE_TRAILING_SPACES or even DARCS_DONT_ESCAPE_ANYTHING are set in the environment).darcs creates a  containing colored text from a Stringdarcs n s is a  representing s line-wrapped at n charactersdarcsGiven a list of 8s representing the words of a paragraph, format the paragraphs using & and separate them with an empty line.darcs A variant of 5 that takes a list of strings as input. Useful when {-# LANGUAGE CPP #-}7 makes it impossible to use multiline string literals.darcs Creates a  from any .darcsCreates an invisible  from any .darcsCreates a hidden  from any .darcsCreates a userchunk from any ; see  for details.darcs is a 4 which uses the set 'simplePriners'' on any handle.darcsA set of default printers suitable for any handle. Does not use color.darcs is the simplest 3: it just concatenates together the pieces of the darcs is the 6 for hidden text. It just replaces the document with . It's useful to have a printer that doesn't actually do anything because this allows you to have tunable policies, for example, only printing some text if it's to the terminal, but not if it's to a file or vice-versa.darcs The empty darcsConcatenation of two sdarcsa  b is a  b if a is not empty, else emptydarcsa  b is a followed by b. with a space in between if both are non-emptydarcsa  b is a above bdarcsa  b is a above b4 with an empty line in between if both are non-emptydarcsPile  s verticallydarcsPile *s vertically, with a blank line in betweendarcs Concatenate s horizontallydarcs Concatenate (s horizontally with a space as separatordarcs Quote a string for screen outputdarcs () is concatenation,  is the  darcsTogether with the language extension OverloadedStrings, this allows to use string literals where a  is expected.6655 2008 Eric KowGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679=darcs singular This (Noun "batch") "" == "this batch" plural This (Noun "batch") "" == "these batches"darcsThis 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" -- :-(darcs/Things that have a plural and singular spellingdarcs englishNum 0 (Noun "watch") "" == "watches" englishNum 1 (Noun "watch") "" == "watch" englishNum 2 (Noun "watch") "" == "watches"darcs,Given a list of things, combine them thusly: 4orClauses ["foo", "bar", "baz"] == "foo, bar or baz"darcs,Given a list of things, combine them thusly: 4orClauses ["foo", "bar", "baz"] == "foo, bar or baz"darcs%Capitalize the first letter of a word  Safe-Inferred%&)*/1679=darcsFormats an e-mail header by encoding any non-ascii characters using UTF-8 and Q-encoding, and folding lines at appropriate points. It doesn't do more than that, so the header name and header value should be well-formatted give or take line length and encoding. So no non-ASCII characters within quoted-string, quoted-pair, or atom; no semantically meaningful signs in names; no non-ASCII characters in the header name; etcetera.darcsTurns a piece of string into a q-encoded block Applies q-encoding, for use in e-mail header values, as defined in RFC 2047. It just takes a string and builds an encoded-word from it, it does not check length or necessity.! Safe-Inferred%&)*/1679=darcsThe > type is a record containing the variables which control how "s will be rendered on some output.darcsoverall use of colordarcsoverall use of escapingdarcs1overall use of colored lines (only hunks for now)darcs$alternative to color (bold, inverse)darcsdon't escape isprintsdarcsdon't escape 8-bit charsdarcsextra chars to never escapedarcsextra chars to always escapedarcsescape trailing spacesdarcsignore r at end of linesdarcs$escape spaces (used with poTrailing)darcs eputDocLn puts a ), followed by a newline to stderr using . Like putDocLn, it encodes with the user's locale. This function is the recommended way to output messages that should be visible to users on the console, but cannot (or should not) be silenced even when --quiet is in effect.darcs returns a suitable policy for a given handle. The policy is chosen according to environment variables, and to the type of terminal which the handle representsdarcs h7 returns a set of printers suitable for outputting to hdarcs policy< tries to color a Doc, according to policy po. That is, if policy has  poLineColor4 set, then colors the line, otherwise does nothing.darcs policy string escapes string$ according to the rules defined in policy, turning it into a .darcs policy c tells wether c0 will be left as-is when escaping according to policydarcs tells wether a character is a printable character of the ascii range.darcs2 represents a special character as a string. * quoteChar '^c' (where ^c is a control character) is "^c" * Otherwise,  quoteChar returns "hex", where hex1 is the hexadecimal number of the character.darcs policy doc marks doc with the appropriate marking for escaped characters according to policydarcs policy color doc colors doc with color color if policy is not set to use an alternative to color. In that case, it makes the text bold instead.darcs doc tries to make doc (usually a single escaped char) stand out with the help of only plain ascii, i.e., no color or font style.darcs)the string to reset the terminal's color.darcs color doc returns a colorized version of doc. color/ is a string that represents a color, given by darcs boldens a doc.darcs* returns an invert video version of a doc."2008 David RoundyGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679= darcsbeginTedious k/ starts a tedious process and registers it in  with the key k. A tedious process is one for which we want a progress indicator.Wouldn't it be safer if it had type String -> IO ProgressDataKey, so that we can ensure there is no collision? What happens if you call beginTedious twice with the same string, without calling endTedious in the meantime?darcs endTedious k* unregisters the tedious process with key k , printing Done" if such a tedious process exists.darcsXXX: document this constant#2003 David RoundyGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679= darcscommand to rundarcs any argumentsdarcsexitcode, stderr  $ Safe-Inferred%&)*/1679=cdarcsonly shown on helpdarcs!Ask the user for a line of input.darcsAsk the user to press EnterdarcsaskUserListItem prompt xs enumerates xs? on the screen, allowing the user to choose one of the itemsdarcsPrompt the user for a yes or nodarcsPrompt the user for a character, among a list of possible ones. Always returns a lowercase character. This is because the default character (ie, the character shown in uppercase, that is automatically selected when the user presses the space bar) is shown as uppercase, hence users may want to enter it as uppercase.darcsThe prompt to displaydarcsThe string the user entered.darcsThe prompt to display  % Safe-Inferred%&)*/1679=+darcs>Generate the help string from a verb and list of choice groups   Safe-Inferred%&)*/1679= Safe-Inferred%&)*/1679=RdarcsThe "sane" API for regex ( makeRegexOptM ) requires 15 but we want a pure one for compatibility with e.g. Darcs.Patch.Match.darcsMakes a regular expression with the default options (multi-line, case-sensitive). The syntax of regular expressions is otherwise that of egrep. (i.e. POSIX "extended" regular expressions).darcsMakes a regular expression, where the multi-line and case-sensitive options can be changed from the default settings.darcs+Match a regular expression against a stringdarcs!The regular expression to compiledarcsH <=> '^' and '$' match the beginning and end of individual lines respectively, and '.' does not match the newline character.darcsH <=> matching is case-sensitivedarcs(Returns: the compiled regular expressiondarcsThe regular expressiondarcsThe string to match againstdarcs Returns: G strs if the match succeeded (and strs, is the list of subexpression matches), or F otherwise.& Safe-Inferred%&)*/1679=' Safe-Inferred%&)*/1679=  ( Safe-Inferred%&)*/1679=G darcs abstracts over  and # for code constructing these valuesdarcs An empty , e.g. NilFL or NilRLdarcsA  constructed from a completely polymorphic value, for example the constructors for primitive patchesdarcs Compose two  values together in series, e.g. 'joinGap (+>+)' or 'joinGap (:>:)'darcs p is  forall y . exists x . p x y  In other words the caller is free to specify the right witness, and then the left witness is an existential. Note that the order of the type constructors is important for ensuring that  x  is dependent on the  y  that is supplied.darcs p is  forall x . exists y . p x y  In other words the caller is free to specify the left witness, and then the right witness is an existential. Note that the order of the type constructors is important for ensuring that  y  is dependent on the  x  that is supplied. This is why Stepped2 is needed, rather than writing the more obvious  ( p) which would notionally have the same quantification of the type witnesses.darcs is similar to , but the type argument is universally quantified instead of being existentially quantified.darcsDuplicate a single witness. This is for situations where a patch-like type is expected, i.e. a type with two witnesses, but we have only a type with one witness. Naturally, any concrete value must have both witnesses agreeing. Note that  ( p wX) is isomorphic to p wX.darcs The same as $ but for two parameters (wX and wY).darcsA  type is a way of hide an existentially quantified type parameter, in this case wX, inside the type. Note that the only thing we can currently recover about the existentially quantified type wX is that it exists.darcs Unwrap a  valuedarcs Unwrap a  value) Safe-Inferred%&)*/1679=)darcsParallel Pairsdarcs(Forking Pair (Explicit starting context)  wX wY \ / \ / \ / wU | | | wA darcs Joining Pairsdarcs)Forking Pairs (Implicit starting context)darcs Reverse listsdarcs Forward listsdarcsDirected Forward PairsdarcsfilterOutFLFL p xs deletes any x in xs for which  p x == IsEq (indicating that x has no effect as far as we are concerned, and can be safely removed from the chain)darcsConcatenate two *s. This traverses only the left hand side.darcsConcatenate two +s. This traverses only the right hand side.darcsMonadic fold over an  associating to the left, sequencing effects from left to right. The order of arguments follows the standard foldM from base.darcsMonadic fold over an  associating to the right, sequencing effects from right to left. Mostly useful for prepend-like operations with an effect where the order of effects is not relevant.darcsThe "natural" fold over an & i.e. associating to the right. Like . only with the more useful order of arguments.darcs;The "natural" fold over an RL i.e. associating to the left.darcsRight associative fold for s that transforms a witnessed state in the direction opposite to the ". This is the "natural" fold for #s i.e. the one which replaces the  with the passed operator.darcsThe analog of  for #s. This is the "natural" fold for #s i.e. the one which replaces the $ with the (flipped) passed operator.darcs!Strict left associative fold for s that transforms a witnessed state in the direction of the patches. This is for apply-like functions that transform the witnesses in forward direction.darcs"Strict right associative fold for s that transforms a witnessed state in the opposite direction of the patches. This is for unapply-like functions that transform the witnesses in backward direction.darcsLike  only for s. This function is supposed to be lazy: elements before the split point should not be touched.darcsLike  only for s. This function is supposed to be lazy: elements before the split point should not be touched.darcsLike  only for s. This function is supposed to be lazy: elements before the split point should not be touched.darcs Prepend an  to an ). This traverses only the left hand side.darcs Append an  to an *. This traverses only the right hand side.11111155115555* Safe-Inferred%&)*/1679=,adarcs"Clowns to the left of me, jokers to the right. Here I am, stuck in the middle of you" 0http://en.wikipedia.org/wiki/Stuck_in_the_MiddledarcsSee + Safe-Inferred%&)*/1679=,, Safe-Inferred%&)*/1679=02darcsDuring a rebase, we use "fixup" patches to maintain the correct context for the real "items" that are being stored in the rebase that the user wants to keep. As the context of the rebase changes, new fixups get added to the beginning that then need to be pushed past as many items as possible.There are multiple fixup types and multiple ways of representing the items being stored in the rebase, so this is polymorphic in both types. Also, the structure of the results varies - in some cases it will be a single value, sometimes an FL, or sometimes zero or one values (Maybe2), so the output types are separate variables. A typical instantiation would be something like PushFixupFn Fixup Item (FL Item) (FL Fixup).- Safe-Inferred%&)*/1679=1darcsThe 4 operation must be self-inverse, i.e. an involution:invert . invert = id. Safe-Inferred%&)*/1679=3darcsPatchDebug is a hook class for temporarily adding debug information. To use it, add any methods that are required, implement those methods where needed, and then make it available in the relevant contexts. For example it can be temporarily added as a superclass of Patchy. The advantage of having it here already is that everything is (or should be) declared as an instance of it, so you can use defaulting or just leave out declarations of instance methods and code will still compile.darcsA dummy method so we can export/import PatchDebug(..) without triggering warnings/ Safe-Inferred%&)*/1679=8darcsCommuteFn is the basis of a general framework for building up commutation operations between different patch types in a generic manner. Unfortunately type classes are not well suited to the problem because of the multiple possible routes by which the commuter for (FL p1, FL p2) can be built out of the commuter for (p1, p2) - and more complicated problems when we start building multiple constructors on top of each other. The type class resolution machinery really can't cope with selecting some route, because it doesn't know that all possible routes should be equivalent.Note that a CommuteFn cannot be lazy i.e. commute patches only when the resulting sequences are demanded. This is because of the possibility of failure (F): all the commutes must be performed before we can know whether the overall commute succeeds.darcs&TODO document laziness or lack thereofdarcs&TODO document laziness or lack thereofdarcs&TODO document laziness or lack thereofdarcs&TODO document laziness or lack thereofdarcsMake use of the inverse-commute law to reduce the number of cases when defining commute for complicated patch types.0 Safe-Inferred%&)*/1679==darcs+Class of patches that that can be commuted.)Instances should obey the following laws: commute-symmetrycommute (p:>q) == Just (q':>p') <=> commute (q':>p') == Just (p':>q)invert-commuteIf patches are invertible, thencommute (p:>q) == Just (q':>p') <=> commute (invert q:>invert p) == Just (invert p':>invert q')The more general law square-commutecommute (p:>q) == Just (q':>p') => commute (invert p:>q') == Just (q:>invert p'):is valid in general only provided we know (a priori) that  (invert pq') succeeds, in other words, that p and q are not in conflict with each other. See Darcs.Patch.CommuteNoConflicts for an extended discussion.darcs commutes an  past an .darcs% commutes a RL past a single element.darcs% commutes a single element past a FL.darcsBuild a commuter between a patch and itself using the operation from the type class.1darcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679=Jdarcs9Patches that can always be merged, even if they conflict.)Instances should obey the following laws: symmetrymerge (p :\/: q) == q' :/\: p' <=> merge (q :\/: p) == p' :/\: q' merge-commutemerge (p :\/: q) == q' :/\: p' ==> commute (p :> q') == Just (q :> p');that is, the two branches of a merge commute to each other. extensioncleanMerge (p :\/: q) == Just (q' :/\: p') => merge (p :\/: q) == q' :/\: p' that is,  is an extension of .darcsClass of patches that can, possibly, be merged cleanly, that is, without conflict.,Every patch type can be made an instance of  in a trivial way by defining  _ = F0, which vacuously conforms to all required laws.)Instances should obey the following laws: symmetrycleanMerge (p :\/: q) == Just (q' :/\: p') <=> cleanMerge (q :\/: p) == Just (p' :/\: q')If an instance  p exists, then we also require  merge-commutecleanMerge (p :\/: q) == Just (q' :/\: p') ==> commute (p :> q') == Just (q :> p')that is, the two branches of a clean merge commute to each other.If an instance  p exists, then we also require  square-mergecleanMerge (p :\/: q) == Just (q' :/\: p') => cleanMerge (invert p :\/: q') == Just (q :/\: invert p')1Here is a picture that explains why we call this  square-merge:  A---p--->X A<--p^---X | | | | | | | | q q' => q q' | | | | v v v v Y---p'-->B Y<--p'^--Bdarcs%Cleanly merge a single patch with an  of patches.darcs Synonym for .darcsLift a merge function over p :/: q to a merge function over  p :/: FL qdarcsLift a merge function over p :/: q to a merge function over  FL p :/: qdarcsLift a merge function over p :/: q to a merge function over  FL p :/: FL qdarcsSwap the two patches, $, then swap again. Used to exploit  when defining .darcsSwap the two patches, apply an arbitrary merge function, then swap again.darcsSwap the two patches, $, then swap again. Used to exploit prop_cleanMergeSymmetric when defining .darcsCombine a list of patch sequences, all starting at the same state, into a single sequence that also starts at the same state, using cleanMerge. If the merge fails, we return the two sequences that could not be merged so we can issue more detailed error messages.darcsThis function serves no purpose except to demonstrate how merge together with the square commute law allows us to commute any pair of adjacent patches. Note that using this function introduces inverse conflictors if the regular commute would fail. This is problematic because it invalidates another global invariant we rely on, namely that we can always drop (obliterate or amend) patches from the end of a repo. This is because inverse conflictors contain references to patches that come after it, so dropping them would make the inverse conflictor inconsistent.darcs0Whether the given pair of patches satisfies the symmetry law.darcs0Whether the given pair of patches satisfies the  merge-commute law.2 Safe-Inferred%&)*/1679=X^darcs Split an  according to a predicate, using commutation as necessary, into those that satisfy the predicate and can be commuted to the left, and those that do not satisfy it and can be commuted to the right. Whatever remains stays in the middle.Note that the predicate p, should be invariant under commutation: if commute(x:>y)==Just(y':>x') then p x == p x' && p y == p y'.darcs Split an  according to a predicate, using commutation as necessary, into those that satisfy the predicate and can be commuted to the right, and those that do not satisfy it and can be commuted to the left. Whatever remains stays in the middle.Note that the predicate p, should be invariant under commutation: if commute(x:>y)==Just(y':>x') then p x == p x' && p y == p y'.darcs Split an  according to a predicate, using commutation as necessary, into those that satisfy the predicate and can be commuted to the right, and those that don't, i.e. either do not satisfy the predicate or cannot be commuted to the right.Note that the predicate p, should be invariant under commutation: if commute(x:>y)==Just(y':>x') then p x == p x' && p y == p y'.darcs x xs removes x from xs if x6 can be commuted to its head. Otherwise it returns Fdarcs is like  except with darcs ab abc returns Just c' where all the patches in ab 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 F.darcs is like removeSubsequenceFL except that it works on darcsThis is a minor variant of 2 with each permutation is simply returned as a darcs 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 cdarcs is like ", except that we operate on an  (in other words, we are pushing things to the end of a patch sequence instead of to the beginning).darcsAll permutations of an .darcsThis commutes patches in the RHS to bring them into the same order as the LHS.darcsThis commutes patches in the RHS to bring them into the same order as the LHS.darcs A variant of nub9 that is based on '=~/= i.e. ignores (internal) ordering.darcsPartition a list into the patches that merge cleanly with the given patch and those that don't (including dependencies)darcs=predicate; if true we would like the patch in the "left" listdarcsinput darcs"left", "middle" and "right"darcs>predicate; if true we would like the patch in the "right" listdarcsinput darcs"left" and "right" results3 Safe-Inferred%&)*/1679=eBdarcs.It is natural to think of conflicting patches p and q as a parallel pair (pq) because this is how conflicting patches arise. But then Darcs comes along and merges them anyway by converting one of them to a conflictor. Thus, inside a sequence of patches we may see them as a sequential pair (p  q'). In that case, > will always succeed, as expressed by the merge-commute law.  is a restricted version of  that should fail in this case but otherwise give the same result as .Primitive patch types have no conflictors, so for them we have  == .)Instances should obey the following laws:SymmetrycommuteNoConflicts (p:>q) == Just (q':>p') <=> commuteNoConflicts (q':>p') == Just (p':>q)Square-Commute (if an instance  p exists)commuteNoConflicts (p:>q) == Just (q':>p') => commuteNoConflicts (invert p:>q') == Just (q:>invert p') is a restriction of ?commuteNoConflicts (p:>q) == Just r => commute (p:>q) == Just rdarcsAn alternative to  to be used if correctness of your code depends on the validity of the square-commute law, or to determine whether patches are in conflict. A parallel pair of patches pq is conflicting if and only if (p^q)/ fails. Its main use is so that we can define  cleanly.darcsThe non-conflicting merge of (pq) tries to commute the inverse p^ of p with q. If it succeeds then the part of the result that corresponds to p^7 is re-inverted. This is also known as a "clean merge".Note that to maintain consistency in the presence of conflictors we must use use  here and not :. Otherwise we run into contradictions as explained below.Concretely, suppose we use  here and that q5 is a conflictor that represents the primitive patch r- and conflicts (only) with (primitive patch) p^ . That is, q results from the conflicted merge(rp^)=(sq), where s? is another conflictor. Now, according to merge-commute we get  commute(p^ q)=Just(rs) , and thus mergeNoConflict(p q)=Just(s^r)) in contradiction to our assumption that (p^q are in conflict i.e. mergeNoConflict(p^q) fails. (This argument takes for granted that the addition of conflictors to prim patches preserves their commute behavior. This is not yet stated as a law but all implementations obviously adhere to it.)?As a side note, the fact that we now get an inverse conflictor s^ as part of the result leads to further problems. For instance, whether our repo is conflicted now depends on the order of patches: (pr)$ is not conflicted, but its commute (qs^) obviously is. In fact, (qs^) is nothing else but the (identity-preserving) "force-commute" of (pr), see the thread at  https://lists.osuosl.org/pipermail/darcs-devel/2017-November/018403.html.4 Safe-Inferred%&)*/1679=fdarcsGiven an ssh URL or file path, split it into user@host, repodir, and the file (with any _darcs/ prefix removed)darcsReturn a canonical representation of an SSH repo in the format uhost:path Notably, this means the returned string does not contain: - an "ssh://" prefix - any redundant slashes (including all trailing ones)  5 Safe-Inferred%&)*/1679=jdarcsMethods to wrap and unwrap esdarcsCombined size and hash, where the size is optional. The invariant for a valid  size _ is that size >=0 and size < 'sizeLimit'darcs(External API for the various hash types.darcsThe  belonging to this type of hashdarcsCompute hash from file content.darcsSemantically, this is the type of hashed objects. Git has a type tag inside the hashed file itself, whereas in Darcs the type is determined by the subdirectory.darcsCheck that the given 8 is an encoding of some .darcs$Verify file content against a given .%2008 David Roundy GPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679=k  6 Safe-Inferred%&)*/1679=l> darcsA drop-in replacement for , which allows us to catch anything but a signal. Useful for situations where we don't want to inhibit ctrl-C.  7 Safe-Inferred%&)*/1679=qg darcsThe firstJustM returns the first Just entry in a list of monadic operations. This is close to `listToMaybe  sequence`, but the sequence operator evaluates all monadic members of the list before passing it along (i.e. sequence is strict). The firstJustM is lazy in that list member monads are only evaluated up to the point where the first Just entry is obtained. darcsThe firstJustIO is a slight modification to firstJustM: the entries in the list must be IO monad operations and the firstJustIO will silently turn any monad call that throws an exception into Nothing, basically causing it to be ignored. darcs,Terminate the program with an error message. darcsHandle only actual IO exceptions i.e. not "user errors" e.g. those raised by calling .We use  all over the place to signify erroneous conditions and we normally don't want to handle such errors. darcsHandle only non-existence. darcsHandle only non-existence. darcsLike  + but restricted to returning a given value. darcsLike  * but restricted to handling non-existence. darcsHandle only a those exceptions for which the predicate succeeds. 8 Safe-Inferred%&)*/1679=x darcs"Identifier (key) for a connection.darcsA re-usable connection to a remote darcs in transfer-mode. It contains the three standard handles.darcsExpected properties:2only ever runs once in the lifetime of the program"environment variables override alltries Putty first on Windowsfalls back to plain old sshdarcsGlobal mutable variable that contains open connections, identified by the repoid part of the ssh file name. Only one thread can use a connection at a time, which is why we stuff them behind their own s.>We distinguish between a failed connection (represented by a F entry in the map) and one that was never established (the repoid is not in the map). Once a connection fails, either when trying to establish it or during usage, it will not be tried again.darcsWait for an existing connection to become available or, if none is available, try to create a new one and cache it.darcsTry to create a new ssh connection to a remote darcs that runs the transfer-mode command. This is tried only once per repoid. darcsTerminate all child processes that run a remote "darcs transfer-mode" and remove them from the , causing subsequent   calls to start a fresh child.darcsMark any connection associated with the given ssh file path as failed, so it won't be tried again.darcs4Show a command and its arguments for debug messages. darcsReturn the command and arguments needed to run an ssh command First try the appropriate darcs environment variable and SSH_PORT defaulting to "ssh" and no specified port.darcsremote darcs commanddarcs destinationdarcswrapper for the action  9 Safe-Inferred%&)*/1679=yO  : Safe-Inferred%&)*/1679=9 darcsThis is a type of "sane" file paths. These are always canonic in the sense that there are no stray slashes, no ".." components and similar. They are usually used to refer to a location within a Tree, but a relative filesystem path works just as well. These are either constructed from individual name components (using "appendPath", "catPaths" and "makeName"), or converted from a FilePath ("unsafeFloatPath" -- but take care when doing that). darcsThis 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. darcsPaths which are relative to the local darcs repository and normalized. Note: These are understood not to have the dot in front. darcsFor displaying paths to the user. It should never be used for on-disk patch storage. This adds the "./" for consistency with how repo paths are displayed by  showPatch and friends, except for the root path which is displayed as plain ".". darcs Interpret an   as relative the current working directory. Intended for IO operations in the file system. Use with care! darcs  translates whitespace in filenames to a darcs-specific format (numerical representation according to  surrounded by backslashes). Note that backslashes are also escaped since they are used in the encoding. encodeWhite "hello there" == "hello\32\there" encodeWhite "hello\there" == "hello\92\there" darcs  interprets the Darcs-specific "encoded" filenames produced by  decodeWhite "hello\32\there" == Right "hello there" decodeWhite "hello\92\there" == Right "hello\there" decodeWhite "hello\there" == Left "malformed filename" darcsMake the second path relative to the first, if possible. Note that this returns an empty   if the inputs are equal. darcsInterpret a possibly relative path wrt the current working directory. This also canonicalizes the path, resolving symbolic links etc. darcs2The first argument must be the absolute path of a  directory', the second is an arbitrary absolute path. Find the longest prefix of path that points to the same  directory; if there is none, return F, else return G the remainder. darcsTake an absolute path and a string representing a (possibly relative) path and combine them into an absolute path. If the second argument is already absolute, then the first argument gets ignored. This function also takes care that the result is converted to Posix convention and normalized. Also, parent directories ("..") at the front of the string argument get canceled out against trailing directory parts of the absolute path argument.Regarding the last point, someone more familiar with how these functions are used should verify that this is indeed necessary or at least useful.darcsConvert to posix, remove trailing slashes, and (under Posix) reduce multiple leading slashes to one. darcsExecute either the first or the second argument action, depending on whether the given path is an   or stdin/stdout.darcsNormalize the path separator to Posix style (slash, not backslash). This only affects Windows systems.darcsReduce multiple leading slashes to one. This only affects Posix systems. darcsIteratively tries find first non-existing path generated by buildName, it feeds to buildName the number starting with -1. When it generates non-existing path and it isn't first, it displays the message created with buildMsg. Usually used for generation of the name like  path_ number when  path# already exist (e.g. darcs.net_0). darcs1Check whether a path is a prefix of another path. darcs'Append an element to the end of a path. darcsCatenate two paths together. Not very safe, but sometimes useful (e.g. when you are representing paths relative to a different point than a Tree root). darcs&Get parent (path) of a given path. foobarbaz -> foo/bar darcs.List all (proper) parents of a given path. foobarbaz -> [.,foo, foo/bar] darcsTake a "root" directory and an anchored path and produce a full . Moreover, you can use  anchorPath "" to get a relative . darcsMake a   from a 8. May fail if the input 84 is invalid, that is, "", ".", "..", or contains a . darcsTake a relative FilePath and turn it into an AnchoredPath. This is a partial function. Basically, by using unsafeFloatPath, you are testifying that the argument is a path relative to some common root -- i.e. the root of the associated Tree object. In particular, the input path may not contain any ocurrences of "." or ".." after normalising. You should sanitize any FilePaths before you declare them "good" by converting into AnchoredPath (using this function), especially if the FilePath come from any external source (command line, file, environment, network, etc)darcs A view on  s. darcs3Replace the second arg's parent with the first arg. darcsMake a   from a . darcsThe effect of renaming on paths. The first argument is the old path, the second is the new path, and the third is the possibly affected path we are interested in. darcsConstruct a filter from a list of AnchoredPaths, that will accept any path that is either a parent or a child of any of the listed paths, and discard everything else. darcs)Transform a SubPath into an AnchoredPath. darcsIs the given path in (or equal to) the _darcs metadata directory?4 4 ; Safe-Inferred%&)*/1679=0 darcsGiven  pred tree , produce a   that only has items for which pred returns True. The tree might contain stubs. When expanded, these will be subject to filtering as well. darcsAbstraction of a filesystem tree. Please note that the Tree returned by the respective read operations will have TreeStub items in it. To obtain a Tree without such stubs, call expand on it, eg.: (tree <- readDarcsPristine "." >>= expandWhen a Tree is expanded, it becomes "final". All stubs are forced and the Tree can be traversed purely. Access to actual file contents stays in IO though.A Tree may have a Hash associated with it. A pair of Tree's is identical whenever their hashes are (the reverse need not hold, since not all Trees come equipped with a hash). darcsGet hash of a Tree. This is guaranteed to uniquely identify the Tree (including any blob content), as far as cryptographic hashes are concerned. Sha256 is recommended. darcs)Get a hash of a TreeItem. May be Nothing. darcs Look up a  % item (an immediate subtree or blob). darcsFind a   by its path. Gives F if the path is invalid. darcsFind a   by its path. Gives F6 if the path is invalid, or does not point to a Blob. darcsFind a   by its path. Gives F6 if the path is invalid, or does not point to a Tree. darcsList all contents of a  . darcsLike  % but monadic and thus able to expand   s on the way. darcsLike   but for multiple paths. darcs>All paths in the tree that that have the given path as prefix.explodePath t p == Prelude.filter (p `isPrefix`) (map fst (list t)) darcsExpand a stubbed Tree into a one with no stubs in it. You might want to filter the tree before expanding to save IO. This is the basic implementation, which may be overriden by some Tree instances (this is especially true of the Index case). darcsUnfold a path in a (stubbed) Tree, such that the leaf node of the path is reachable without crossing any stubs. Moreover, the leaf ought not be a Stub in the resulting Tree. A non-existent path is expanded as far as it can be. darcsCheck the disk version of a Tree: expands it, and checks each hash. Returns either the expanded tree or a list of AnchoredPaths where there are problems. The first argument is the hashing function used to create the tree. darcsGiven two Trees, a guide and a tree., produces a new Tree that is a identical to tree5, but only has those items that are present in both tree and guide. The guide Tree may not contain any stubs. darcsRead a Blob into a Lazy ByteString. Might be backed by an mmap, use with care. darcsFor every pair of corresponding blobs from the two supplied trees, evaluate the supplied function and accumulate the results in a list. Hint: to get IO actions through, just use sequence on the resulting list. NB. This won't expand any stubs. darcsFor each file in each of the two supplied trees, evaluate the supplied function (supplying the corresponding file from the other tree, or Nothing) and accumulate the results in a list. Hint: to get IO actions through, just use sequence on the resulting list. NB. This won't expand any stubs.darcsHelper function for taking the union of AnchoredPath lists that are already sorted. This function does not check the precondition so use it carefully. darcsCautiously extracts differing subtrees from a pair of Trees. It will never do any unneccessary expanding. Tree hashes are used to cut the comparison as high up the Tree branches as possible. The result is a pair of trees that do not share any identical subtrees. They are derived from the first and second parameters respectively and they are always fully expanded. It might be advantageous to feed the result into   or  . darcs:Modify a Tree (by replacing, or removing or adding items). darcsDoes not expand the tree. darcsDoes not expand the tree. darcsLay one tree over another. The resulting Tree will look like the base (1st parameter) Tree, although any items also present in the overlay Tree will be taken from the overlay. It is not allowed to overlay a different kind of an object, nor it is allowed for the overlay to add new objects to base. This means that the overlay Tree should be a subset of the base Tree (although any extraneous items will be ignored by the implementation). darcs$Calculate and insert hashes for all  s contained in a  , including the argument  $ itself. If necessary, this expands  s. darcsSpecification of  6  6  < Safe-Inferred%&)*/1679= darcs Write out full tree to a plain directory structure. If you instead want to make incremental updates, refer to Darcs.Util.Tree.Monad.  = Safe-Inferred%&)*/1679=> darcs  specialized to B darcs,A monad transformer that adds state of type   and an environment of type .darcs!A procedure for dumping a single  + to disk. If the implementation uses item .es, it is also responsible to ensure that its  is up-to-date. It is not allowed to make any changes to the actual content of the  . darcsInternal state of the  . Keeps track of the current   content and unsync'd changes.darcs6Keep track of the size and age of changes to the tree. darcsRun a   action without storing any changes. This is useful for running monadic tree mutations for obtaining the resulting   (as opposed to their effect of writing a modified tree to disk). The actions can do both read and write -- reads are passed through to the actual filesystem, but the writes are held in memory in the form of a modified  . darcs  specialized to BdarcsModifies an item in the current Tree. This action keeps an account of the modified data, in changed and changesize, for subsequent flush operations. Any modifications (as in "modifyTree") are allowed.darcsReplace an item with a new version without modifying the content of the tree. This does not do any change tracking. Ought to be only used from a sync implementation for a particular storage format. The presumed use-case is that an existing in-memory Blob is replaced with a one referring to an on-disk file.darcsFlush a single item to disk. This is the only procedure that (directly) uses the Reader part of the environment (the procedure of type  m).darcs:If buffers are becoming large, sync, otherwise do nothing. darcsCheck for existence of a file. darcs#Check for existence of a directory. darcsCheck for existence of a node (file or directory, doesn't matter). darcs=Grab content of a file in the current Tree at the given path. darcsChange content of a file at a given path. The change will be eventually flushed to disk, but might be buffered for some time. darcsCreate a directory. darcsRemove the item at a path. darcsRename the item at a path. darcsCopy an item from some path to another path. Doing this with a SubTree is weird... it means copy recursively, but with lazy copy-on-write semantics. What happens when we flush that? Seems to work, though, as it is used in Darcs.UI.Commands.Convert.Import  > Safe-Inferred%&)*/1679= darcs"Badly named, since it is actually  , with all s turned into F. darcsWhether a path is an existing directory, but not a symlink to one. darcs Variant of 7 that doesn't throw exception when file does not exist. darcs?Return all files under given directory that aren't directories. darcsReturn all files under given directory that aren't directories. Unlike  % this function returns the full path. darcsVery much darcs-specific copying procedure. For local files it tries to hard-link, falling back to normal copy if it fails. Remote URLs are downloaded using either HTTP or SSH. For SSH, this tries to use the given remote darcs command to invoke it's transfer-mode command.darcs=Hard-link file, falling back to normal copying it that fails. darcsRecursively copy a directory, where the target directory is supposed to already exist.darcsRecursively copy a directory, where the target directory does not yet exist but it's parent does.darcsGeneric file fetching support function that takes care of downloading remote files to a temporary location if necessary before invoking the actual reading procedure. darcsfetchFilePS fileOrUrl cache returns the content of its argument (either a file or an URL). If it has to download an url, then it will use a cache as required by its second argument.We always use default remote darcs, since it is not fatal if the remote darcs does not exist or is too old -- anything that supports transfer-mode should do, and if not, we will fall back to SFTP or SCP. darcsfetchFileLazyPS fileOrUrl cache lazily reads the content of its argument (either a file or an URL). Warning: this function may constitute a fd leak; make sure to force consumption of file contents to avoid that. See "fetchFilePS" for details. darcsLike  0 but transparently handle gzip compressed files. darcsInitiate background file download for the given file path or URL to the given location. darcsInvoke the given action on a file that is temporarily created in the current directory, and removed afterwards. darcsInvoke the given action on a file that is temporarily created and opened in the current directory, and closed and removed afterwards. darcsremote darcs executabledarcs(path representing the origin file or URLdarcsdestination pathdarcs%tell whether file to copy is cachable    ? Safe-Inferred%&)*/1679= darcsTries to perform some task if it can obtain the lock, Otherwise, just gives up without doing the taskdarcsCreates a directory based on the path parameter; if a relative path is given the dir is created in the darcs temp dir. If an absolute path is given this dir will be created if it doesn't exist. If it is specified as a temporary dir, it is deleted after finishing the job. darcs  is like  :, except that it doesn't delete the directory afterwards. darcs  creates a temporary directory, runs the action and then removes the directory. The location of that directory is determined by the contents of _darcsprefs#tmpdir, if it exists, otherwise by  $DARCS_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 in the current directory, unless the current directory is under a _darcs directory, in which case the temporary directory in the parent of the highest _darcs directory to avoid accidentally corrupting darcs's internals. This should not fail, but if it does indeed fail, we go ahead and use the current directory anyway. If $DARCS_KEEP_TMPDIR variable is set temporary directory is not removed, this can be useful for debugging. darcsDo an action in a newly created directory of the given name. If the directory is successfully created but the action raises an exception, the directory and all its content is deleted. Caught exceptions are re-thrown.  @ Safe-Inferred%&)*/1679=ѓ darcsCache is an abstract type for hiding the underlying cache locations darcsSmart constructor for  . darcsFilter caches for remote repos. This affects only entries that are locally valid paths (i.e. not network URLs): they are removed if non-existent, or demoted to NotWritable if they are not actually writable in the file system.darcsCompares two caches, a remote cache is greater than a local one. The order of the comparison is given by: local < http < ssh darcs"fetchFileUsingCache cache dir hash receives a list of caches cache-, the directory for which that file belongs dir and the hash of the file to fetch. It tries to fetch the file from one of the sources, trying them in order one by one. If the file cannot be fetched from any of the sources, this operation fails. Otherwise we return the path where we found the file and its content. darcsThis keeps only     entries. darcs7The full filepath of a simple file name inside a given   under . darcsReturn whether the  = contains a file with the given hash in a writable position. darcsAdd pipelined downloads to the (low-priority) queue, for the rest it is a noop. darcsDo  5 for files not already in a writable cache position.darcsIf the first parameter of type  is , try to ensure that a file with the given name (hash) exists in a writable location (which means in particular that it is stored in the local file system). If it is , then merely schedule download of that file into such a location (the actual download will be executed asynchronously).If the file is already present in some writeable location, or if there is no writable location at all, this procedure does nothing.If the copy should occur between two locations of the same filesystem, a hard link is made.If the first parameter is , use   and try to find the file in any non-writable location. Otherwise (), use   and try only the first non-writable location (which makes sense since  > is asynchronous and thus can't fail in any interesting way).darcsChecks if a given cache entry is reachable or not. It receives an error caught during execution and the cache entry. If the caches is not reachable it is blacklisted and not longer tried for the rest of the session. If it is reachable it is whitelisted and future errors with such cache get ignore. To determine reachability: * For a local cache, if the given source doesn't exist anymore, it is blacklisted. * For remote sources if the error is timeout, it is blacklisted, if not, it checks if _darcs/hashed_inventory exist, if it does, the entry is whitelisted, if it doesn't, it is blacklisted.darcsReturns a list of reachables cache entries, removing blacklisted entries.darcs append a   to an  .darcsCalculate the next  when entering an . Works for the top-level  i.e. the root directory only because we handle that specially. darcsReturn a list containing all the file/folder names in an index, with their respective ItemType and FileID. darcsInitialize an  from the given index file. darcs$Add and remove entries in the given  to make it match the given  . If an object in the   does not exist in the current working directory, its index entry will have zero hash, size, aux, and fileID. For the hash this translates to F, see . darcsRead an &, starting with the root, to create a  . darcsCheck that a given file is an index file with a format we can handle. You should remove and re-create the index whenever this is not true. darcsFor a given path, get the corresponding fileID from the filesystem.  C Safe-Inferred%&)*/1679=W darcsLocation of the lock file. darcs Location of the prefs directory. darcs.Location of the (one and only) head inventory. darcs8Location of the (one and only) tentative head inventory. darcsLocation of parent inventories. darcsLocation of pristine trees. darcsLocation of patches. darcsLocation of index files. darcsLocation of the rebase patch darcsLocation of format file darcsLocation of pending files darcsLocation of unrevert bundle. darcs7Location of old style (unhashed) files and directories.  D Safe-Inferred"%&)*/1679= darcsRepresentation of the format of a repository. Each sublist corresponds to a line in the format file.darcsDefine string constants in one place, for reuse in show/parse functions.darcsDefine string constants in one place, for reuse in show/parse functions.darcsDefine string constants in one place, for reuse in show/parse functions.darcsDefine string constants in one place, for reuse in show/parse functions.darcsDefine string constants in one place, for reuse in show/parse functions.darcsDefine string constants in one place, for reuse in show/parse functions.darcsDefine string constants in one place, for reuse in show/parse functions.darcsDefine string constants in one place, for reuse in show/parse functions. darcs4Is a given property contained within a given format? darcs,Add a single property to an existing format. darcs1Remove a single property from an existing format. darcsIdentify the format of the repository at the given location (directory, URL, or SSH path). Fails if we weren't able to identify the format. darcsIdentify the format of the repository at the given location (directory, URL, or SSH path). Return I reason if it fails, where reason explains why we weren't able to identify the format. Note that we do no verification of the format, which is handled by   or   on the resulting  . darcsWrite the repo format to the given file. This is unsafe because we don't check that we are allowed to write to the repo. darcsCreate a repo format. The first argument specifies the patch format; the second says whether the repo has a working tree. darcs  source returns G: an error message if we cannot write to a repo in format source, or F if there's no such problem. darcs  source target returns G an error message if we cannot transfer patches from a repo in format source to a repo in format target, or F if there are no such problem. darcs  source returns G; an error message if we cannot read from a repo in format source, or F if there's no such problem.darcs applies a function that maps format-entries to an optional error message, to each repoformat entry. Returning any errors.darcs) +. Modulo newtype noise, this is the same as  type   f =  (  -> f)This is so we can pass a directory relative to which an option argument is interpreted (if it has the form of a relative path). darcsThis type synonym is here for brevity and because we want to import the data constructors (but not the type) of   qualified. darcs Construct a   with no arguments. darcs Construct a   with a 8 argument. darcs Construct a   with an optional 8 argument. darcs Construct a   with an   argument. darcs Construct a   with an   argument. darcs Construct a   with an optional   argument.darcsGet the short and long switch names from a raw option. Used to construct error and warning messages.darcsGiven a list of  *, find all flags that match a given value.darcsGiven a list of  , find all values that match a given flag list in the order in which they appear in the flag list.darcs?The first element of a list, or a default if the list is empty.darcsAppend " [DEFAULT" to the help text of options that match the default value. darcs Construct a  $ from a default value and a list of  .Precondition: the list must have an entry for each possible value (type v). darcs Construct a 7 valued option with a single flag that takes no arguments and has no default flag.The arguments are: short switches, long switches, flag value, help string. darcs Construct a > 80 valued option with a single flag that takes a 8" argument and has no default flag.The arguments are: short switches, long switches, flag constructor, single flag parser, help string. darcs Construct a >  1 valued option with a single flag that takes an  " argument and has no default flag.The arguments are: short switches, long switches, flag constructor, single flag parser, help string. darcs Similar to  , except that the flag can be given more than once. The flag arguments are collected in a list of 8s. darcs Similar to  ., except that the flag arguments are optional. darcs Similar to  , except that the flag can be given more than once. The flag arguments are collected in a list of  s.darcsA multi-arg option, defined in terms of a single-arg option, returning a list of single args.The parameters are: single argument description, short switches, long switches, flag constructor, flag list parser, arg name string, help string. darcsA deprecated option. If you want to deprecate only some flags and not the whole option, extract the  s out of the original option and create a new deprecated option. The strings in the first argument are appended to the automatically generated error message in case additional hints should be provided.  G Safe-Inferred%&)*/1679=  H Safe-Inferred%&)*/1679= darcs-The path of the global preference directory; ~/.darcs on Unix, and %APPDATA%/darcs on Windows. darcs6The relative path of the global preference directory; ~/.darcs on Unix, and %APPDATA%/darcs3 on Windows. This is used for online documentation.darcsosxCacheDir assumes ~LibraryCaches/ exists.darcsxdgCacheDir returns the $XDG_CACHE_HOME environment variable, or ~/.cache3 if undefined. See the FreeDesktop specification: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.htmldarcstryMakeBoringRegexp attempts to create a Regex from a given String. The evaluation is forced, to ensure any malformed exceptions are thrown here, and not later.darcsboringRegexps returns a list of the boring regexps, from the local and global prefs/boring files. Any invalid regexps are filtered, preventing an exception in (potentially) pure code, when the regexps are used.darcs%The lines that will be inserted into _darcsprefsbinaries when  darcs init is run. Hence, a list of comments, blank lines and regular expressions (ERE dialect).Note that while this matches .gz and .GZ, it will not match .gZ, i.e. it is not truly case insensitive.darcs(addRepoSource adds a new entry to _darcsprefs)repos and sets it as default in _darcsprefsdefaultrepo, unless --no-set-default or --dry-run is passed, or it is the same repository as the current one.darcsdelete references to other repositories. Used when cloning to a ssh destination. Assume the current working dir is the repository.darcs?Fetch and return the message of the day for a given repository.darcs6Display the message of the day for a given repository,)      )      I Safe-Inferred%&)*/1679= darcsA  Repository is a token representing the state of a repository on disk. It is parameterized by rt9the access type (whether we are in a transaction or not),pthe patch type,wUthe witness for the unrecorded state (what's in the working tree now).wRthe witness for1the recorded state when outside a transaction, or.the tentative state when inside a transaction.darcsPerform an action with the current working directory set to the .darcsBoth  and  are "unsafe" in the sense that they merely "coerce" the type but do not actually perform the steps (B actions) required to start or end a transaction (this is done by revertRepositoryChanges and finalizeRepositoryChanges>). Technically this is not an actual coercion like with e.g. , due to the singleton typed member, but in practical terms it is no less unsafe, because  vs.  changes whether wR refers to the recorded or the tentative state, respectively. In particular, you will get different results if you are inside a transaction and read the patchset with a "coerced" Repository of access type 'RO. The same holds for other state that is modified in a transaction, like the pending patch or the rebase state.J Safe-Inferred%&)*/1679=  K Safe-Inferred%&)*/1679=darcsWe require from such a key (an 5) that it has a canonical way to format itself to a :. For historical reasons, this takes a parameter of type .darcsGiven a state type (parameterized over a monad m :: * -> *), this gives us the type of the key with which we can lookup an item (or object) in the state.darcs Format a   to a  according to the given .NOTE: This is not only used for display but also to format patch files. This is why we have to do the white space encoding here. See ."Besides white space encoding, for  we just pack it into a . For  we must emulate the non-standard darcs-1 encoding of file paths: it is an UTF8 encoding of the raw byte stream, interpreted as code points. See also S.L Safe-Inferred%&)*/1679=Idarcs#An object is located by giving the  of the parent  and a  .  M Safe-Inferred%&)*/1679=N Safe-Inferred%&)*/1679=-ydarcsSee module documentation for Darcs.Patch.Choices.darcsA sequence of es where each patch is either , , or . The representation is optimized for the case where we start chosing patches from the left of the sequence: patches that are = are commuted to the head immediately, but patches that are  or - are mixed together; when a patch is marked , its dependencies are not updated until we retrieve the final result.darcsThis internal type tags a  with a 7, to distinguish  from  patches.darcsthe  in questiondarcsE = , H = darcsA patch with a  attached to it.darcs mp i acts as a temporary identifier to help us keep track of patches during the selection process. These are useful for finding patches that may have moved around during patch selection (being pushed forwards or backwards as dependencies arise).)The identifier is implemented as a tuple  Label mp i. The i is an integer, expected to be unique within the patches being scrutinised. The mp is motivated by patch splitting; it provides a convenient way to generate a new identifier from the patch being split. For example, if we split a patch identified as Label Nothing 56, the resulting sub-patches could be identified as Label (Just (Label Nothing 5))1,  Label (Just (Label Nothing 5)) 2, etc.IOW, " is a non-empty, reversed list of <s.darcsInternal function to tag a  as  or .darcs Create a  from a sequence of patches, so that all patches are initially .darcsLabel a sequence of patches, maybe using the given parent label.darcs Create a  from an already labelled sequence of patches, so that all patches are initially .darcsLike  but lumps together  and - patches. This is more efficient than using  and then catenating  and : sections because we have to commute less. (This is what  are optimized for.)separateFirstFromMiddleLast c == case getChoices c of f:>m:>l -> f:>m+>+ldarcsLike  but lumps together  and  patches.separateFirstMiddleFromLast c == case getChoices c of f:>m:>l -> f+>+m:>ldarcs'Retrieve the resulting sections from a . The result is a triple first:>middle:>last, such that all patches in first are , all patches in middle are , and all patches in last are .darcs3Internal function to commute patches in the common  segment so that all  patches are behind  ones. Patches  that depend on any  are promoted to .darcsUse the given monadic  transformer on the  section of a ., then fold the result back into the original .darcsGiven a * determine to which section of the given  it belongs. This is not trivial to compute, since a patch tagged as  may be forced to actually be 3 by dependencies. We return a possibly re-ordered , so as not to waste the commutation effort.darcs5Force all patches matching the given predicate to be , pulling any dependencies with them. This even forces any patches that were already tagged .darcs>Force all patches labelled with one of the given labels to be , pulling any dependencies with them. This even forces any patches that were already tagged .darcs9Force a single patch labelled with the given label to be , pulling any dependencies with them. This even forces any patches that were already tagged .darcs Make all  patches either  or . This does *not* modify any patches that are already determined to be  by dependencies.darcs Similar to % only that patches are forced to be % regardless of their previous status.darcsInternal function working directly on the constituent parts of a  and taking an accumulating  to build up a new $ section. It forces patches to be  or , depending on the 7 parameter (H means , E means ). It does this regardless of the previous status of patches and also pulls any dependent patches with it.darcs>Force all patches labelled with one of the given labels to be , pulling any dependencies with them. This even forces any patches that were previously tagged .darcs9Force a single patch labelled with the given label to be , pulling any dependencies with them, regardless of their previous status.darcsForce a patch with the given  to be , pulling any dependencies with it, regardless of their previous status.darcsTurn  patches into  ones and  into  ones.darcsTurn  patches into  and  patches into %. Does *not* pull dependencies into 0, instead patches that cannot be commuted past  patches stay .darcsSubstitute a single ? with an equivalent list of patches, preserving its status as ,  or -). The patch is looked up using equality of s.darcsaccumulator for  patchesdarcs original  sectiondarcs original  and  sectionO Safe-Inferred%&)*/1679=0darcstrackOrigRename takes an old and new name and attempts to apply the mapping to the OrigFileNameOf pair. If the old name is the most up-to-date name of the file in question, the first element of the OFNO will match, otherwise if the up-to-date name was originally old, the second element will match.darcswithFileNames takes a maybe list of existing rename-pairs, a list of filenames and an action, and returns the resulting triple of affected files, updated filename list and new rename details. If the rename-pairs are not present, a new list is generated from the filesnames.P Safe-Inferred%&)*/1679=2darcs;Apply patches, emitting warnings if there are any IO errorsdarcs"Apply patches, ignoring all errorsdarcsThe default mode of applying patches: fail if the directory is not as we expectQ2002-2005 David RoundyGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679=3}darcsApply a patch to a  , yielding a new  .darcsAttempts to apply a given patch to a Tree. If the apply fails, we return Nothing, otherwise we return the updated Tree.  R Safe-Inferred%&)*/1679=3S Safe-Inferred%&)*/1679=8TdarcsThis class is used only for user interaction, not for storage. The default implementations for  and  are suitable only for  PrimPatch and  RepoPatch types. Logically,  should default to  while  should default to /. We define them the other way around so that / gives reasonable results for all patch types.darcsShow a patch with context lines added, 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 .(Note that this applies the patch in the  given by the context. This is done in order to simplify showing multiple patches in a series, since each patch may change the context lines for later changes.0For a version that does not apply the patch see .darcsLike . but without applying the patch in the monad m.T Safe-Inferred%&)*/1679=J]darcsA PatchInfo value contains the metadata of a patch. The date, name, author and log fields are UTF-8 encoded text in darcs 2.4 and later, and just sequences of bytes (decoded with whatever is the locale when displayed) in earlier darcs.'The members with names that start with '_' are not supposed to be used directly in code that does not care how the patch info is stored._piLegacyIsInverted:Historically, the  isInverted; flag was used to indicate that a Named patch was inverted.)We no longer support direct inversion of # patches, except sometimes via the / wrapper which tracks inversion in the wrapper.However, going even further back in time, inverted patches could be written out by darcs rollback. This was changed in 2008 so any patches on disk with this flag set would have been written by a darcs from prior to then. As they still exist, including in the darcs repository itself, we need to support them.As far as current darcs is concerned, the flag should be treated like any other field in $ apart from never being set freshly:,There is no semantic relationship between a  with piLegacyIsInverted = False and the same  with piLegacyIsInverted = True5. For example they are not inverses of each other.:New or amended patches should never be written out with _piLegacyIsInverted = True.We do need to maintain backwards compatibility so we take care to preserve things like the hash, on-disk format etc. A patch with _piLegacyIsInverted = True4 should work with all the normal darcs operations.The flag is completely separate and orthogonal to the tracking of explicit inversion in the  wrapper. The  wrapper is only used in memory and never stored to disk so there should be no confusion when reading a patch from disk. Within the codebase they serve completely different purposes and should not interact at all.darcs:See the long description of this field in the docs above.darcs:The isAscii limitation is due to the use of BC.pack below.darcspatchinfo date name author log constructs a new  value with the given details, automatically assigning an Ignore-this header to guarantee the patch is unique. The function does not verify the date string's sanity.darcsaddJunk adds a line that contains a random number to make the patch unique.darcsGet the name, including an "UNDO: " prefix if the patch is a legacy inverted patch.darcsReturns the author of a patch.darcs&Returns the name of the patch. Unlike , it does not preprend "UNDO: " to the name if the patch has the legacy inverted flag set.darcsReturns the author of a patch.darcsRead the date from raw patch (meta) data and convert it to UTC. The raw data may contain timezone info. This is for compatibiltity with patches that were created before 2003-11, when darcs still created patches that contained localized date strings.darcsGet the log message of a patch.darcs.Get the tag name, if the patch is a tag patch.darcsConvert a metadata ByteString to a string. It first tries to convert using UTF-8, and if that fails, tries the locale encoding. We try UTF-8 first because UTF-8 is clearly recognizable, widely used, and people may have UTF-8 patches even when UTF-8 is not their locale.darcsHash on patch metadata (patch name, author, date, log, and the legacy "inverted" flag. Robust against context changes but does not guarantee patch contents. Usually used as matcher or patch identifier (see Darcs.Patch.Match).darcs(Patch is stored between square brackets. [ * (indented one) ]=note that below I assume the name has no newline in it. See  for the inverse operation. There are more assumptions, see validation functions above.darcs Parser for > as stored in patch bundles and inventory files, for example: [Document the foo interface John Doe **20110615084241 Ignore-this: 85b94f67d377c4ab671101266ef9c229 Nobody knows what a 'foo' is, so describe it. ]See  for the inverse operation.##U Safe-Inferred%&)*/1679=Kdarcs:Replace the pristine hash at the start of a raw, unparsed  or add it if none is present.darcsskipPristineHash drops the 'pristine: HASH' prefix line, if present.V Safe-Inferred%&)*/1679=N darcsThe PatchId identifies a patch and can be created from a PatchInfo with makePatchnamedarcsThe FileId for a file consists of the FilePath (creation name) and an index. The index denotes how many files with the same name have been added before (and subsequently deleted or moved)darcsConvert FileId to string  W Safe-Inferred%&)*/1679=^ darcsStorable identities.The methods here can be used to help implement ReadPatch and ShowPatch for a patch type containing the identity.:As with all Read/Show pairs, We expect that the output of showId ForStorage x can be parsed by  to produce x:='parse' 'readId' . 'renderPS' . 'showId' 'ForStorage' == 'id'darcsConstraint for patches that have an identity that is signed, i.e. can be positive (uninverted) or negative (inverted).Provided that an instance Invert0 exists, inverting a patch inverts its identity:-'ident' ('invert' p) = 'invertId' ('ident' p)darcsSigned identities.Like for class Invert, we require that  is self-inverse:'invertId' . 'invertId' = 'id'0We also require that inverting changes the sign:0'positiveId' . 'invertId' = 'not' . 'positiveId'Side remark: in mathematical terms, these properties can be expressed by stating that  is an involution and that  is a "homomorphism of sets with an involution" (there is no official term for this) from a9 to the simplest non-trivial set with involution, namely 7 with the involution r.darcs,Class of patches that have an identity/name.4Patches with an identity give rise to the notion of nominal equality, expressed by the operators  and .Laws:  ident-commute3Patch identity must be invariant under commutation:'commute' (p :> _) == 'Just' (_ :> p') => 'ident' p == 'ident' p'and thus (via symmetry of ):'commute' (_ :> q) == 'Just' (q' :> _) => 'ident' q == 'ident' q'Conversely, patches with the same identity result from a series of s:'ident' p == 'ident' p' => exists qs, qs' :: FL p. 'commuteFL' (p :> qs) == 'Just' (qs' :> p') ident-compareIn general, comparing patches via their identity is weaker than (semantic) equality:-'unsafeCompare' p q => 'ident' p == 'ident' qHowever, if the patches have a common context, then semantic and nominal equality should coincide, up to internal re-ordering:p '=\~/=' q <=> p '=\^/=' qp '=/~\=' q <=> p '=/^\=' q(Technical note: equality up to internal re-ordering is currently only defined for 2s, but it should be obvious how to generalize it.)Taken together, these laws express the assumption that recording a patch gives it a universally unique identity.Note that violations of this universal property are currently not detected in a reliable way. Fixing this is possible but far from easy.darcs+The reason this is not associated to class  is that for technical reasons we want to be able to define type instances for patches that don't have an identity and therefore cannot be lawful members of class .darcsNominal equality for patches with an identity in the same context. Usually quite a bit faster than structural equality.darcsRemove a patch from an FL of patches with an identity. The result is G3 whenever the patch has been found and removed and F otherwise. If the patch is not found at the head of the sequence we must first commute it to the head before we can remove it.We assume that this commute always succeeds. This is justified because patches are created with a (universally) unique identity, implying that if two patches have the same identity, then they have originally been the same patch; thus being at a different position must be due to commutation, meaning we can commute it back.For patch types that define semantic equality via nominal equality, this is only faster than removeFL if the patch does not occur in the sequence, otherwise we have to perform the same number of commutations.darcsSame as  only for .darcsFind the common and uncommon parts of two lists that start in a common context, using patch identity for comparison. Of the common patches, only one is retained, the other is discarded.darcs/Try to commute all patches matching any of the  s in the set to the head of an , i.e. backwards in history.X Safe-Inferred%&)*/1679=adarcsThis type exists for legacy support of on-disk format patch formats. It is a wrapper type that explicitly tracks the nesting of braces and parens in the on-disk representation of such patches. It is used as an intermediate form when reading such patches normally, and also for round-tripping such patches when checking the hash in bundles. It shouldn't be used for anything else.  Y Safe-Inferred%&)*/1679=adarcsThis class is used to decode patches from their binary representation.Z Safe-Inferred%&)*/1679=cdarcs is implemented by single patches that can be repaired (Prim, Patch, RepoPatchV2) There is a default so that patch types with no current legacy problems don't need to have an implementation.darcs and  deal with repairing old patches that were were written out due to bugs or that we no longer wish to support.  is implemented by collections of patches (FL, Named, PatchInfoAnd) that might need repairing.[ Safe-Inferred%&)*/1679=eydarcs&This is used to track changes to filesdarcsthis is used for duplicate patches that don't have any effect, but we still want to keep track of themdarcsApply a patch to set of  s, yielding the new set of  s and s  \ Safe-Inferred%&)*/1679=e] Safe-Inferred%&)*/1679=fP^ Safe-Inferred%&()*/1679=odarcsThis property states that no prefix of the context commutes with the rest of the  patch and that the context never contains a patch and its inverse.darcsThis property states that the first patch in the context must not commute with the rest of the  patch.darcs6This property states that patches in the context of a : patch as well as the patch itself are positive. It does not necessarily hold for all  patches.darcsThis property states that the inverse of the first patch in the context is not contained in the rest of the context.darcs This property states that equal  patches have equal content up to reorderings of the context patches.darcsIdentity of a contexted patch.darcsWether the first argument is contained (identity-wise) in the context of the second, in other words, the second depends on the first. This does not include equality, only proper dependency.darcs patches conflict with each other if the identity of one is in the context of the other or they cannot be merged cleanly.darcs(We sometimes want to pattern match on a  patch but still guard against violation of the invariants. So we export a view that is isomorphic to the 4 type but doesn't allow to manipulate the internals.darcs Convert a  patch into a plain  with the patch at the end.darcsA  patch with empty context.darcs Add a patch to the context of a  patch. This is the place where we take care of the invariants.darcsAdd an  of patches to the context.darcsAdd an / of patches to the context but invert it first.darcsAdd an  of patches to the context.darcs)(Definition 10.2) Commute a patch past a  patch. This commutes it past the context and then past the patch itself. If it succeeds, the patch that we commuted past gets dropped. Note that this does not* succeed if the inverted patch is in the  patch.darcs;Not defined in the paper but used in the commute algorithm.darcsEquality between  patches reduces to equality of the identifiers of the patches referred to if we look at them from the same context. (This assumes witnesses aren't coerced in an unsafe manner.)_ Safe-Inferred%&)*/1679=p` Safe-Inferred%&)*/1679=w darcs,Mangle conflicting alternatives if possible.darcs'Result of mangling a single Unravelled.darcsA list of conflicting alternatives. They form a connected component of the conflict graph i.e. one transitive conflict.darcsPrim patches that support "sifting". This is the process of eliminating changes from a sequence of prims that can be recovered by comparing states (normally the pristine and working states), except those that other changes depend on. In other words, changes to the content of (tracked) files. The implementation is allowed and expected to shrink and coalesce changes in the process.darcs)Whether a prim is a candidate for siftingdarcsTry to shrink the input sequence by getting rid of self-cancellations and identity patches or by coalescing patches. Also sort patches according to some internally defined order (specific to the patch type) as far as possible while respecting dependencies. A result of F* means that we could not shrink the input.This method is included in the class for optimization. Instances are free to use m.darcsThis is similar to  but always gives back a result: if the sequence could not be shrunk we merely give back a sorted version.This method is included in the class for optimization. Instances are free to use m.darcs6Coalesce adjacent patches to one with the same effect..apply (primCoalesce p q) == apply p >> apply qdarcsWhether prim patch has no effect at all and thus can be eliminated as far as coalescing is concerned.darcsProvide a total order between arbitrary patches that is consistent with :5unsafeCompare p q == IsEq <=> comparePrim p q == EQ""a Safe-Inferred%&)*/1679=xb Safe-Inferred%&)*/1679=yTc Safe-Inferred%&()*/1679=yd Safe-Inferred%&)*/1679=ye Safe-Inferred%&)*/1679=zCf Safe-Inferred%&)*/1679=zdarcsModify a binary file ;binary FILENAME oldhex *HEXHEXHEX ... newhex *HEXHEXHEX ...g Safe-Inferred%&()*/1679=|darcs1The state of a single file as far as we know it. F7 means we don't know the content of a particular line.darcs$An infinite list of undefined lines.darcs Note that (applyHunk p . applyHunk (invert p) /= id : it converts undefined lines (F) to defined ones (G the old content of p).darcsIterate .h Safe-Inferred%&)*/1679=|  i Safe-Inferred"%&()*/1679=}j Safe-Inferred%&)*/1679=}k Safe-Inferred%&)*/1679=~0l Safe-Inferred%&)*/1679=~}m Safe-Inferred%&)*/1679= darcsEither  or cancel inverses.?primCoalesce (p :> q) == Just r => apply r = apply p >> apply qdarcsConversion between (, a) and > a.darcs The heart of .darcsTry to coalesce the patch with any of the elements in the sequence, using commutation to push it down the list, until either new is K$ the next member of the list (using )commutation fails orcoalescing succeeds.In case (1) we push the patch further, trying to coalesce it with any of its successors and disregarding any ordering. If this is successful, we recurse with the result, otherwise we leave the patch where it was, so the sequence remains sorted.In case (3) we recursively continue with the result unless that is empty.The result is returned in the (,) monad to indicate whether it was able to shrink the patch sequence. To make this clear, we do not: track whether sorting has made progress, only shrinking.>The precondition is that the input sequence is already sorted.n Safe-Inferred%&)*/1679=darcsMap a monadic function over an  of s.Be careful which (4 to choose when using this function. For instance, > would return F if any of the calls failed to shrink their argument, which usually not what we want. A suitable candidate is (Any,).darcs p1 p2 tries to combine p1 and p2 into a single patch. For example, two hunk patches modifying adjacent lines can be coalesced into a bigger hunk patch. Or a patch which moves file A to file B can be coalesced with a patch that moves file B into file C, yielding a patch that moves file A to file C. Safe-Inferred%&)*/1679=Mo Safe-Inferred%&()*/1679=darcsIt can sometimes be handy to have a canonical representation of a given patch. We achieve this by defining a canonical form for each patch type, and a function  which takes a patch and puts it into canonical form. This routine is used by the diff function to create an optimal patch (based on an LCS algorithm) from a simple hunk describing the old and new version of a file.darcs8Put a sequence of primitive patches into canonical form.Even if the patches are just hunk patches, this is not necessarily the same set of results as you would get if you applied the sequence to a specific tree and recalculated a diff.XXX Why not? How does it differ? The implementation for Prim.V1 does sortCoalesceFL and then invokes the diff algorithm for each hunk. How can that be any different to applying the sequence and then taking the diff? Is this merely because diff does not sort by file path?Besides, diff and apply must be inverses in the sense that for any two states {start, end}, we have*diff start (apply (diff start end)) == end Safe-Inferred%&)*/1679=:##p Safe-Inferred%&()*/1679=darcsA splitter is something that can take a patch and (possibly) render it as text in some format of its own choosing. This text can then be presented to the user for editing, and the result given to the splitter for parsing. If the parse succeeds, the result is a list of patches that could replace the original patch in any context. Typically this list will contain the changed version of the patch, along with fixup pieces to ensure that the overall effect of the list is the same as the original patch. The individual elements of the list can then be offered separately to the user, allowing them to accept some and reject others.There's no immediate application for a splitter for anything other than Prim (you shouldn't go editing named patches, you'll break them!) However you might want to compose splitters for FilePatchType to make splitters for Prim etc, and the generality doesn't cost anything.darcsThis generic splitter just lets the user edit the printed representation of the patch. Should not be used expect for testing and experimentation.darcsNever splits. In other code we normally pass around Maybe Splitter instead of using this as the default, because it saves clients that don't care about splitting from having to import this module just to get noSplitter.darcsSplit a primitive hunk patch up by allowing the user to edit both the before and after lines, then insert fixup patches to clean up the mess.q Safe-Inferred%&)*/1679=O  r Safe-Inferred%&)*/1679=darcsThe format of a merger is ,Merger undos unwindings conflicting original.undos = the effect of the merger unwindings = TODO: eh? conflicting = the patch we conflict withoriginal = the patch we really ares Safe-Inferred%&)*/1679= t Safe-Inferred%&)*/1679=darcsGet hold of the underlying primitives for a given patch, placed in the context of the patch. If there are conflicts then context patches will be needed.darcsAn  represents a primitive patch, together with any other primitives that are required to place the primitive in a different context. Typically, the presence of context patches indicates that the underlying primitive would be in conflict in the given context.We have the following invariants: - if a context contains a patch, that context does not also contain the inverse of that patch (when commuted next to each other) - if either context contains a patch that commutes with the underlying patch, then neither context contains the inverse of that patch (when commuted next to each other) Another way of putting it is that all possible pairs of patch+inverse that can be reached by commutation are removed.darcsGiven a list of unwound patches, use commutation and cancellation of inverses to remove intermediate contexts. This is not guaranteed to be possible in general, but should be possible if the patches that were unwound were all originally recorded (unconflicted) in the same context, e.g. as part of the same .darcscontext beforedarcsunderlying primitivesdarcs context afteru Safe-Inferred%&)*/1679=darcs5High-level representation of a piece of patch summarydarcsThis type tags a patch with a . and also hides the context witnesses (as in Sealed2 ), so we can put them in a list.v Safe-Inferred"%&)*/1679=sw Safe-Inferred"%&)*/1679=x Safe-Inferred%&)*/1679=/y Safe-Inferred%&)*/1679=,darcsPatches whose concrete effect can be expressed as a list of primitive patches.(A minimal definition would be either of effect or effectRL.z Safe-Inferred%&)*/1679="darcsabstract over /darcsNonable represents the class of patches that can be turned into a Non.darcsA  stores a context with a Prim patch. It is a patch whose effect isn't visible - a Non-affecting patch.darcsunNon converts a Non into a FL of its context followed by the primitive patch.darcs3showNons creates a Doc representing a list of Nons.darcs)showNon creates a Doc representing a Non.darcs:readNons is a parser that attempts to read a list of Nons.darcs7readNon is a parser that attempts to read a single Non.darcs x cy tries to commute x past cy" and always returns some variant cy'. If commutation suceeds, the variant is just straightforwardly the commuted version. If commutation fails, the variant consists of x prepended to the context of cy.darcs 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'']darcscommutePrimsOrAddToCtx takes a WL of prims and attempts to commute them past a Non.darcscommuteOrRemFromCtx attempts to remove a given patch from a Non. If the patch was not in the Non, then the commute will succeed and the modified Non will be returned. If the commute fails then the patch is either in the Non context, or the Non patch itself; we attempt to remove the patch from the context and then return the non with the updated context.TODO: understand if there is any case where p is equal to the prim patch of the Non, in which case, we return the original Non, is that right?darcscommuteOrRemFromCtxFL attempts to remove a FL of patches from a Non, returning Nothing if any of the individual removes fail.darcs(*>) attemts to modify a Non by commuting it past a given patch.darcs(>*) attempts to modify a Non, by commuting a given patch past it.darcs(*>>) attempts to modify a Non by commuting it past a given WL of patches.darcs(>>*) attempts to modify a Non by commuting a given WL of patches past it.darcsNons are equal if their context patches are equal, and they have an equal prim patch.{ Safe-Inferred%&)*/1679=ndarcsThe first parameter is a context containing all patches preceding the ones for which we want to calculate the conflict resolution, which is the second parameter. Each element of the result list represents the resolution of one maximal set of transitively conflicting alternatives, in other words, a connected subset of the conflict graph. But the elements themselves must not conflict with each other, guaranteeing that they can be cleanly merged into a single  of prims.darcsFor one conflict (a connected set of conflicting prims), store the conflicting parts and, if possible, their mangled version.darcsBy definition, a conflicting patch is resolved if another patch (that is not itself conflicted) depends on the conflict. If the representation of conflicts is self-contained as it is for V1 and V2, then we can calculate the maximal set of conflicting alternatives for a conflict separately for each conflictor at the end of a repo. This function can then be used to lift this to an  of patches.So, when looking for conflicts in a list of patches, we go through the whole list looking for individual patches that represent a conflict. But then we try to commute them past all the patches we've already seen. If we fail, i.e. there's something that depends on the conflict, then we forget about the conflict; this is the Nothing case of the commuteNoConflictsFL call. Otherwise the patch is now in the correct position to extract the conflicting alternatives.darcsFind all patches in the context that conflict with a given patch, commuting them to the head (past the patch in question).This actually works by commuting the patch and its dependencies backward until it becomes unconflicted, then minimizing the trailing patches by re-commuting them backward as long as that keeps the patch unconflicted.?Precondition: the context must contain all conflicting patches.  | Safe-Inferred%&)*/1679= darcs xs ys cs0' represents two sequences of patches that have cs in common, in other words  xs +<+ cs and  ys +<+ csdarcs cs xs ys/ represents two sequences of patches that have cs in common, in other words  cs +>+ xs and  cs +>+ ysdarcs is used to represents prim patches that are duplicates of, or conflict with, another prim patch in the repository. Normal prim: A primitive patch Duplicate x!: This patch has no effect since x' is already present in the repository. !Etacilpud x: invert (Duplicate x)Conflictor ix xx x: ix0 is the set of patches: * that conflict with x and also conflict with another patch in the repository. * that conflict with a patch that conflict with xxx6 is the sequence of patches that conflict *only* with xx$ is the original, conflicting patch.ix and x are stored as Non objects, which include any necessary context to uniquely define the patch that is referred to.The 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)darcs p is True if p is either a  or  patch.darcs p is True if p is either an  or .darcs is used when converting from Darcs V1 patches (Mergers) to Darcs V2 patches (Conflictors).darcsmergeAfterConflicting3 takes as input a sequence of conflicting patches xxx (which therefore have no effect) and a sequence of primitive patches yyy that follow said sequence of conflicting patches, and may depend upon some of the conflicting patches (as a resolution).darcsIf xs consists only of  patches,  xs returns Just pxs those patches (so lengthFL pxs == lengthFL xs). Otherwise, it returns F.darcs returns the set of patches that can be commuted out of both xs and ys& along with the remnants of both listsdarcs xs ys returns the set of patches that can be commuted out of both xs and ys& along with the remnants of both lists   Safe-Inferred%&)*/1679=Z} Safe-Inferred%&)*/1679=darcs! attempts to commute two patches p1 and p2, in their original order, with the given commute function. If the commute function doesn't know how to handle the patches (i.e. it returns Unknown as a result), then we try again with  invert p2 and  invert p1( (inverting the results, if succesful).TODO: when can the first attempt fail, but the second not? What's so clever in this function?darcsAttempt to commute two patches, the first of which is a Merger patch.darcsmerger takes two patches, (which have been determined to conflict) and constructs a Merger patch to represent the conflict. p1' is considered to be conflicting with p2 (p1 is the "first" patch in the repo ordering), the resulting Merger is therefore a representation of p2.~ Safe-Inferred%&)*/1679=P Safe-Inferred%&)*/1679= Safe-Inferred%&)*/1679= Safe-Inferred%&)*/1679=9 Safe-Inferred%&)*/1679=NdarcsSupport for rebasedarcs2This slightly ad-hoc class is here so we can call  with patch types that wrap a  , such as  RebaseChange.darcsThe Named6 type adds a patch info about a patch, that is a name.NamedP info deps p represents patch p with name info. deps is a list of dependencies added at the named patch level, compared with the unnamed level (ie, dependencies added with darcs record --ask-deps).darcsThis instance takes care of handling the interaction between conflict resolution and explicit dependencies. A conflict involves a set of two or more patches and the general rule is that the conflict is considered resolved if there is another (later) patch that (transitively) depends on each of the (mutually) conflicting patches.8This principle extends to explicit dependencies between  patches. In particular, recording a tag has the effect of resolving any as yet unresolved conflicts in a repo. In general a  patch contains multiple changes ( a "changeset"). Consider the named patches  Named A [] a Named B [] (b1;b2) Named C [] c Named D [A,B] _ where, at the RepoPatch level, a conflicts with b1, and c with b2. D depends explicitly on both A and B*, so it fully covers the conflict between a and b1 and thus we would be justified to consider that particular conflict as resolved. Unfortunately we cannot detect this at the Named patch level because RepoPatchV1 and V2 have no notion of patch identities. Thus, at the Named level the two underlying conflicts appear as a single large conflict between the three named patches A, B, and C, and this means that patch D does not count as a (partial) resolution (even though it arguably should).When we decide that a set of conflicting Named patches is resolved, we move the RepoPatches contained in them to the context of the resolution. For all other named patches, we must commute as much of their contents as possible past the ones marked as resolved, using commutation at the RepoPatch level (i.e. ignoring explicit dependencies).  Safe-Inferred%&)*/1679=φdarcsA  encapsulates the concept of the name of a patch, without any contents. This allows us to track explicit dependencies in the rebase state, changing them to follow uses of amend-record or unsuspend on a depended-on patch, and warning the user if any are lost entirely.darcs Commute a  and a primitive patch. They trivially commute so this just involves changing the witnesses. This is unsafe if the patch being commuted actually has a name (e.g. Named or PatchInfo - PrimWithName is ok),darcs Commute a primitive patch and a . They trivially commute so this just involves changing the witnesses. This is unsafe if the patch being commuted actually has a name (e.g. Named or PatchInfo - PrimWithName is ok),darcsCommute an unnamed patch with a named patch. This is unsafe if the second patch actually does have a name (e.g. Named, PatchInfoAnd, etc), as it won't check the explicit dependencies.darcsCommute an unnamed patch with a named patch. This is unsafe if the first patch actually does have a name (e.g. Named, PatchInfoAnd, etc), as it won't check the explicit dependencies.darcsCommute a name patch and a named patch. In most cases this is trivial but we do need to check explicit dependencies.darcsCommute a named patch and a name patch. In most cases this is trivial but we do need to check explicit dependencies.   Safe-Inferred%&)*/1679=darcsA single rebase fixup, needed to ensure that the actual patches being stored in the rebase state have the correct context.darcs/Split a sequence of fixups into names and prims Safe-Inferred%&)*/1679= darcsUsing a special exception type here means that is is treated as regular failure, and not as a bug in Darcs.darcs p wA wB represents a hope we have to get a patch through its info. We're not sure we have the patch, but we know its info.darcsSimpleHopefully is a variant of  Either String adapted for type witnesses. Actually is the equivalent of Right , while  Unavailable is Left.darcs p C (x y) is D String (p C (x y))* in a form adapted to darcs patches. The C (x y) represents the type witness for the patch that should be there. The  Hopefully type just tells whether we expect the patch to be hashed or not, and " does the real work of emulating D.  Hopefully sh- represents an expected unhashed patch, and Hashed hash sh3 represents an expected hashed patch with its hash.darcs i p1 creates a PatchInfoAnd containing p with info i.darcsn2pia' creates a PatchInfoAnd representing a Named patch.darcs hp tries to get a patch from a  value. If it fails, it outputs an error "failed to read patch: ". We get the description of the patch from the info part of hpdarcs er hp! tries to extract a patch from a 7. If it fails, it applies the error handling function er2 to a description of the patch info component of hp. Note: this function must be lazy in its second argument, which is why we use a lazy pattern match.darcsReturn G the patch content or F if it is unavailable. Safe-Inferred%&)*/1679=߻ darcsA  is a single chunk of a  . It has a  representing a clean tag, the hash of the previous inventory (if it exists), and the list of patches since that previous inventory.darcsThe patches in a repository are stored in chunks broken up at "clean" tags. A tag is clean if the only patches before it in the current repository ordering are ones that the tag depends on (either directly or indirectly). Each chunk is stored in a separate inventory file on disk.A  represents a repo's history as the list of patches since the last clean tag, and then a list of patch lists each delimited by clean tags.Because the invariants about clean tags can only be maintained if a  contains the whole history, the first witness is always forced to be . The type still has two witnesses so it can easily be used with combinators like  and Fork.The history is lazily loaded from disk so does not normally need to be all kept in memory.darcs; is a type used to represent the initial context of a repo.darcs takes a # and returns an equivalent, linear  of patches.darcs takes a # and returns an equivalent, linear  of patches.darcs takes a  and a  of patches that "follow" the PatchSet, and concatenates the patches into the PatchSet.darcsRuns a progress action for each tag and patch in a given PatchSet, using the passed progress message. Does not alter the PatchSet.darcsThe tag names of all tags of a given .darcsSplit a  before the latest known clean tag. The left part is what comes before the tag, the right part is the tag and its non-dependencies.darcsDrop the last n patches from the given . Safe-Inferred%&)*/1679=\darcs Evaluate an  list and report progress.darcs Evaluate an  list and report progress.darcs Evaluate an  list and report progress. In addition to printing the number of patches we got, show the name of the last tag we got. Safe-Inferred%&)*/1679=darcs1Find clean tags that are common to both argument s and return a 8 with the common clean tags and whatever remains of the s. The two "uncommon" sequences may still have patches in common, even clean tags, since we look only at the "known clean" tags of the second argument, i.e. those that are the head of a  section.This is a pretty efficient function, because it makes use of the already-broken-up nature of s.Note that the first argument should be the repository that is more cheaply accessed (i.e. local), as  does its best to reduce the number of inventories that are accessed from its second argument.darcs takes a tag's , t0, and a  and attempts to find t0 in one of the -s in the PatchSet. If the tag is found, the  is split up, on that tag, such that all later patches are in the "since last tag" patch list. If the tag is not found, F- is returned. This is a simpler version of " that only looks at the heads of + sections and does not commute any patches.darcs Take a tag's , and a &, and attempt to find the tag in the . If found, return a new 6, in which the tag is now clean (and the last of the  list), while all patches that are not covered by the tag are in the trailing list of patches. If the tag is not in the  , we return F.darcs Reorder a ( such that the latest tag becomes clean.darcs Create a  section for every clean tag. For unclean tags we try to make them clean, but only if that doesn't make an earlier clean tag dirty. This means that the operation is idempotent and in particular monotonic, which justifies the "optimize" in the name.darcsTake a  and an adjacent tag and try to make the tag clean by commuting out trailing patches that are not covered by the tag.darcs unfolds a single Tagged object in a PatchSet, adding the tag and patches to the PatchSet's patch list.darcs Return the  for all the patches in a  that are not *explicitly* depended on by any tag (in the given ).This is exactly the set of patches that a new tag recorded on top of the  would explicitly depend on.Note that the result is not minimal with respect to dependencies, not even explicit dependencies: explicit dependencies of regular (non-tag) patches are completely ignored.darcs Create a new  section for the most recent clean tag found in the tail of un- patches without re-ordering patches. Note that earlier tags may remain un-! even if they are actually clean.darcs%The symmetric difference between two s, expressed as a ! consisting of the intersection = and the trailing lists of left-only and right-only patches.From a purely functional point of view this is a symmetric function. However, laziness effects make it asymmetric: the LHS is more likely to be evaluated fully, while the RHS is evaluated as sparingly as possible. For efficiency, the LHS should come from the local repo and the RHS from the remote one. This asymmetry can also have a semantic effect, namely if s have *unavailable* patches or inventories, for instance when we deal with a lazy clone of a repo that is no longer accessible. In this case the order of arguments may determine whether the command fails or succeeds.darcsA / consisting of the patches common to all input s. This is *undefined* for the empty list since intersection of s has no unit.darcsA : consisting of the patches contained in any of the input  s. The input 9s are merged in left to right order, left patches first.darcsTwo s are considered unrelated unless they share a common inventory, or either  has less than 5 patches, or they have at least one patch in common.darcsSplit a  at the latest clean tag. The left part is what comes before the tag, the right part is the tag and its non-dependencies.2010 Petr RockaiMITdarcs-devel@darcs.net experimentalportable Safe-Inferred"%&)*/1679=darcsThis constraint expresses what is needed for a repo patch to support the high-level interface to annotation (currently annotateFile and annotateDirectory) Safe-Inferred%&)*/1679= Safe-Inferred%&)*/1679=\ Safe-Inferred%&)*/1679=77 Safe-Inferred%&)*/1679=darcsWrapper type to allow formal inversion of patches which aren't really invertible.darcs#Wrap a patch to make it (formally) ). The result is initially positive i.e. .darcs!Get the underlying patch from an 9, assuming (as a precondition) that it is positive i.e. .darcs&Run a function on the patch inside an . The function has to be parametric in the witnesses, so we can run it with both a  and a  patch. Safe-Inferred%&)*/1679=darcsA  is a context together with some patches. The context consists of unavailable patches.darcs Interpret a  in the context of a ?. This means we match up a possible tag in the context of the +. This fails if the tag couldn't be found.darcsCreate a b16 encoded SHA1 of a given a FL of named patches. This allows us to ensure that the patches in a received bundle have not been modified in transit.darcs-Interpret a context file in the context of a . This means we match up a possible tag. This fails if the tag couldn't be found.darcsMinimize the context of an ' of patches to be packed into a bundle.darcs$Decode gpg clearsigned file content. Safe-Inferred%&)*/1679= Safe-Inferred%&)*/1679= Safe-Inferred%&)*/1679= darcsRead the contents of pending.darcs'Read the contents of tentative pending.darcsRead the pending file with the given suffix. CWD should be the repository directory. Unsafe!darcs(Write the contents of tentative pending.darcsRemove as much as possible of the given list of prim patches from the pending patch. It is used by record and amend to update pending.The "as much as possible" is due to --look-for-* options which cause changes that normally must be explicitly done by the user (such as add, move, and replace) to be inferred from the the diff between pristine and working. Also, before we present prims to the user to select for recording, we coalesce prims from pending and working, which is reason we have to use decoalescing.darcsIterate  for all recorded changes.darcs+Given an (inverted) single recorded change x and the old pending ys, for each prim y in pending either cancel x against y, or coalesce them. If they coalesce, either commute the result past pending, or continue with the rest of pending. If coalescing fails, commute x forward and try again with the next prim from pending. Repeat until we reach the end of pending or x/ becomes stuck, in which case we keep it there.The idea of this algorithm is best explained in terms of an analogy with arithmetic, where coalescing is addition. Let's say we start out with a in pending and b% in working and record the coalesced a+b#. We now want to remove (only) the a& from pending. To do that we coalesce -(a+b)+a# and the result (if successful) is -b. If this can be commuted past pending, we are done: the part that came from pending (a) is removed and the other part cancels against what remains in working.However, we should also guard against the possibility that we recorded a change that was coalesced from more than one prim in pending. For instance, suppose we recorded a+b+c, where a and b are both from pending and c( is form working; after coalescing with a we would be left with -(a+b+c)+a=-(b+c)1 which would then be stuck against the remaining b0. This is why we continue coalescing, giving us  -(b+c)+b=-c' which we again try to commute out etc.Finally, note that a change can legitimately be stuck in pending i.e. it can neither be coalesced nor commuted further. For instance, if we have a hunk in pending and some other prim that depends on it, such as a replace, and the user records (only) a split-off version of the hunk but not the replace. This will coalesce with the remaining hunk but then be stuck at the replace. This is how it should be and thus keeping it there is the correct behavior.darcs4Replace the pending patch with the tentative pendingdarcsCopy the pending patch to the tentative pending, or write a new empty tentative pending if regular pending does not exist.darcsOverwrites the pending patch with a new one, starting at the tentative state.darcsSimplify the candidate pending patch through a combination of looking for self-cancellations (sequences of patches followed by their inverses), coalescing, and getting rid of any hunk or binary patches we can commute out the back.!More abstractly, for an argument p, pristine state R, and working state U, define +unrecorded p = p +>+ diff (pureApply p R) UThen the resulting sequence p'" must maintain that equality, i.e. ,unrecorded p = unrecorded (siftForPending p)while trying to "minimize" p.GPL-2 Safe-Inferred%&')*/1679="^+darcsthe patch-indexdarcsall the s tracked by this patch index, with the most recent patch at the head of the list (note, stored in the reverse order on disk for backwards compatibility with an older format).darcs information file with a given IDdarcstimespans where a file with a certain id corresponds to given filenamesdarcstimespans where a certain filename corresponds to a file with a given iddarcsinfo about a given fileiddarcswhether file or dirdarcsfirst words of patch hashesdarcsOn-disk version of patch index version 1 is the one introduced in darcs 2.10 2 changes the pids order to newer-to-older 3 changes FileName to AnchoredPath everywhere, which has different Binary (and Ord) instances 4 adds all parent dirs of each file or dir as being touched by a patch 5 replaces Set Word32 with IntSetdarcs'applyPatchMods pmods pindex' applies a list of PatchMods to the given patch index pindexdarcs$create new filespan for created filedarcs?start new span for name fn for file fid starting with patch piddarcs"stop current span for file name fndarcs?start new span for name fn for file fid starting with patch piddarcs"stop current span for file name fndarcs)insert touching patchid for given file iddarcs)insert touching patchid for given file iddarcs7insert touching patchid for the parents of a given pathdarcslookup current fid of filepathdarcslookup current fid of filepatch, returning a Maybe to allow failuredarcsPatchSet of repository (in case we need to create patch-index)darcs8File(s) about which you want patches from given sequencedarcsFiltered sequence of patchesdarcsThe repositorydarcsPatchSet of patches of repository (in case patch-index needs to be created)darcs.PatchFilter ready to be used by SelectChanges.   Safe-Inferred%&)*/1679=$darcs0This makes darcs-1 (non-hashed repos) filenames.$The name consists of three segments:timestamp (ISO8601-compatible yyyymmmddHHMMSS; note that the old-fashioned (non-hashed) format expects this date to be exactly as in the patch, ignoring, any timezone info, which is why we use  here)SHA1 hash of the authorSHA1 hash of the patch name, author, date, log, and "inverted" flag. Safe-Inferred%&)*/1679=(darcsRead a - starting with a specific inventory inside a .darcsRead a complete  from a  , by following the chain of s, starting with the given one.darcsRead patches from a   as specified by a list of .darcs1We have to unseal and then reseal, otherwise the  has no effect.darcsRead a single patch from a   , given its  and . Fails with an error message if the patch file cannot be parsed.darcsRead an  from a file. Fails with an error message if file is not there or cannot be parsed.darcsWrite a  to disk and return an  i.e. the patch info and hash. However, if we patch already contains a hash, assume it has already been written to disk at some point and merely return the info and hash.darcsWrapper around   that takes a  instead of a  ByteString.# Safe-Inferred%&)*/1679=3OdarcsThe way patchfiles, inventories, and pristine trees are stored. , means all files are in the same directory.  means we create a second level of subdirectories, such that all files whose hash starts with the same two letters are in the same directory. Currently, only the global cache uses  while repositories use the .darcs2Remove unreferenced entries in the pristine cache.darcs+Set difference between two lists of hashes.darcs7Remove unreferenced files in the inventories directory.darcsList of special patch files that may exist in the directory _darcspatches. We must not clean those.darcs3Remove unreferenced files in the patches directory.darcsReturn a list of the inventories hashes. The first argument can be readInventory or readInventoryLocal. The second argument specifies whether the files are expected to be stored in plain or in bucketed format. The third argument is the directory of the parent inventory files. The fourth argument is the directory of the head inventory file.darcsReturn a list of the inventories hashes. This function attempts to retrieve missing inventory files from the cache.darcsReturn inventories hashes by following the head inventory. This function does not attempt to retrieve missing inventory files.darcs7Return a list of the inventories hashes. The argument repoDir is the directory of the repository from which we are going to read the head inventory file. The rest of hashed files are read from the global cache.darcsReturn a list of the patch filenames, extracted from inventory files, by starting with the head inventory and then following the chain of parent inventories.This function does not attempt to download missing inventory files.The first argument specifies whether the files are expected to be stored in plain or in bucketed format.=The second argument is the directory of the parent inventory.:The third argument is the directory of the head inventory.darcslistPatchesLocalBucketed is similar to listPatchesLocal, but it read the inventory directory under darcsDir in bucketed format.darcsRead the given inventory file if it exist, otherwise return an empty inventory. Used when we expect that some inventory files may be missing. Still fails with an error message if file cannot be parsed.darcsRead an inventory from a file. Fails with an error message if file is not there or cannot be parsed. Safe-Inferred"%&)*/1679=7 darcsApply a patch to the   identified by the given root 0, then return the root hash of the result. The ApplyDir: argument says whether to add or remove the changes. The  = argument specifies the possible locations for hashed files.darcs Apply an  of  patches tentative pristine tree, and update the tentative pristine hash. The patches need to be  so that we can use it when removing patches from the repository, too.darcsWrite the pristine tree into a plain directory at the given path.darcsObtains a Tree corresponding to the "recorded" state of the repository: this is the same as the pristine cache, which is the same as the result of applying all the repository's patches to an empty directory.darcsReplace the existing pristine with a new one (loaded up in a Tree object). Warning: If rt ~ 'RO this overwrites the recorded state, use only when creating a new repo!2009 Petr RockaiMITdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679=8< Safe-Inferred%&)*/1679=QdarcsFrom a repository and a list of AnchoredPath's, construct a filter that can be used on a Tree (recorded or unrecorded state) of this repository. This constructed filter will take pending into account, so the subpaths will be translated correctly relative to pending move patches. darcsLike 8 but with the pending patch passed as a parameter. The  parameter is not used, we need it only to avoid abiguous typing of p.darcs Construct a  that removes any boring files that are not also contained in the argument  .The standard use case is for the argument to be the recorded state, possibly with further patches applied, so as not to discard any files already known to darcs. The result is usually applied to the full working state.darcsConstruct a Tree filter that removes any darcs metadata files the Tree might have contained.darcs5For a repository and an optional list of paths (when F, take everything) compute a (forward) list of prims (i.e. a patch) going from the recorded state of the repository (pristine) to the unrecorded state of the repository (the working tree + pending). When a list of paths is given, at least the files that live under any of these paths in either recorded or unrecorded will be included in the resulting patch. NB. More patches may be included in this list, eg. the full contents of the pending patch. This is usually not a problem, since selectChanges will properly filter the results anyway.'This also depends on the options given:-look-for-moves: Detect pending file moves using the index. The resulting patches are added to pending and taken into consideration, when filtering the tree according to the given path list.-look-for-adds: Include files in the working state that do not exist in the recorded + pending state.+-include-boring: Include even boring files.-look-for-replaces: Detect pending replace patches. Like detected moves, these are added to the pending patch. Note that, like detected moves, these are mere proposals for the user to consider or reject.-ignore-times: Disables index usage completely -- for each file, we read both the unrecorded and the recorded copy and run a diff on them. This is very inefficient, although in extremely rare cases, the index could go out of sync (file is modified, index is updated and file is modified again within a single second).Note that use of the index is also disabled when we detect moves or replaces, since this implies that the index is out of date. darcsTrue iff any patches were removed, possibly filtered patches darcs0pending tree (including possibly detected moves)darcs working tree Safe-Inferred%&)*/1679=TdarcsLike  but it doesn't use the instance (Named p) because the traling list of patches may contain "fake" conflictors.darcs working treedarcsexternal merge tool commanddarcstell whether we want GUI pausedarcs our effectdarcs their effectdarcs them merged darcsexternal merge tool commanddarcstell whether we want GUI pausedarcspath to merge basedarcspath to side 1 of the mergedarcspath to side 2 of the mergedarcs%path where resolved content should go   Safe-Inferred%&)*/1679=f2 darcsUsing a special exception type here means that is is treated as regular failure, and not as a bug in Darcs. darcsA Matcher is made of a  + which we will use to match patches and a String representing it. darcsA type for predicates over patches which do not care about contextsdarcsConstraint for a patch type p that ensures  p is .darcsPatches that can be matched. darcs applyMatcher applies a matcher to a patch.darcs.The string that is emitted when the user runs darcs help patterns.darcshaveNonrangeMatch flags# tells whether there is a flag in flags: which corresponds to a match that is "non-range". Thus, --match, --patch, and --hash make haveNonrangeMatch true, but not  --from-patch or  --to-patch.darcs firstMatch fs tells whether fs implies a "first match", that is if we match against patches from a point in the past on, rather than against all patches since the creation of the repository.darcssecondMatch fs tells whether fs implies a "second match", that is if we match against patches up to a point in the past on, rather than against all patches until now. darcsstrictJust is a strict version of the Just constructor, used to ensure that if we claim we've got a pattern match, that the pattern will actually match (rathern than fail to compile properly). darcsnonrangeMatcher is the criterion that is used to match against patches in the interval. It is 'Just m' when the --patch, --match, --tag/ options are passed (or their plural variants). darcs firstMatcher returns the left bound of the matched interval. This left bound is also specified when we use the singular versions of --patch, --match and --tag . Otherwise,  firstMatcher returns Nothing.darcs"Whether a patch matches the given -s. This should be invariant under inversion:&matchAPatch (invert p) = matchAPatch p darcs hasLastn fs return the --last argument in fs , if any.darcsmatchFirstPatchset fs ps returns the part of ps before its first matcher, ie the one that comes first dependencywise. Hence, patches in matchFirstPatchset fs ps' are the context for the ones we want.darcsmatchSecondPatchset fs ps returns the part of ps before its second matcher, ie the one that comes last dependencywise.darcsSplit on the second matcher. Note that this picks up the first match starting from the earliest patch in a sequence, as opposed to ? which picks up the first match starting from the latest patchdarcsmatchAPatchset m ps returns a prefix of ps ending in a patch matching m , and calls s if there is none.darcsgetMatchingTag m ps, where m is a   which matches tags returns a 7 containing all patches in the last tag which matches m. Last tag means the most recent tag in repository order, i.e. the last one you'd see if you ran darcs log -t m . Calls s if there is no matching tag.darcs7Rollback (i.e. apply the inverse) of what remains of a  after we extract a . This is the counterpart of getOnePatchset and is used to create a matching state. In particular, if the match is --index=n then rollback the last (n-1) patches; if the match is --tag, then rollback patches that are not depended on by the tag; otherwise rollback patches that follow the latest matching patch. darcsapplyInvToMatcher, m ps applies the inverse of the patches in ps>, starting at the end, until we hit a patch that matches the   m. darcs applyNInv& n ps applies the inverse of the last n patches of ps.darcsmatchingHead returns the repository up to some tag. The tag t is the last tag such that there is a patch after t that is matched by the user's query. darcskeyword (operator), argument name, help description, list of examples, matcher functiondarcsThe first element is the patches before and including the first patch matching the second matcher, the second element is the patches after it** Safe-Inferred%&)*/1679=hdarcsUsed by: clonedarcsUsed by: amenddarcs:Used by: rebase pull/apply, send, push, pull, apply, fetchdarcsUsed by: rebase unsuspend/reifydarcs7Used by: unrecord, obliterate, rebase suspend, rollbackdarcs Used by: diffdarcsUsed by: show dependenciesdarcs Used by: logdarcs#show files/contents, dist, annotate!! Safe-Inferred%&)*/1679=m darcs3Options for darcs iself that act like sub-commands.darcs/ instantiates the first two type parameters of  to what we need in darcs.darcsTODO someone wrote here long ago that any time --dry-run is a possibility automated users should be able to examine the results more easily with --xml. See also issue2397. dryRun w/o xml is currently used in add, pull, and repair.darcsThis option is for when a new repo gets created. Used for clone, convert import, convert darcs-2, and initialize. For clone and initialize it has the same effect as giving the name as a normal argument.The  --repodir alias is there for compatibility, should be removed eventually.7TODO We need a way to deprecate options / option names.darcsconvert, clone, initdarcsTODO: see issue2395darcs&push, apply, rebase apply: default to darcspull, rebase pull: default to  darcs&pull, apply, rebase pull, rebase applydarcspush; same as # but with help descriptions swappeddarcspushdarcs:Deprecated flag, still present to output an error message. Safe-Inferred%&)*/1679=s Safe-Inferred%&)*/1679=sdarcsInstantiate a   with an       Safe-Inferred"%&)*/1679=darcsThis will become dis-entangled as soon as we inline these functions.darcs2Non-trivial interaction between options. Explicit -i or -a dominates, else --count, --xml, or  --dry-run imply -a, else use the def argument.darcsThe first argument is an  , the second a 8 that may be a file path or a URL. It returns either the URL, or an absolute version of the path, interpreted relative to the first argument.darcsUsed by commands that expect arguments to be paths in the current repo. Invalid paths are dropped and a warning is issued. This may leave no valid paths to return. Although these commands all fail if there are no remaining valid paths, they do so in various different ways, issuing error messages tailored to the command.darcsUsed by commands that interpret a set of optional path arguments as "restrict to these paths", which affects patch selection (e.g. in log command) or selection of subtrees (e.g. in record). Because of the special meaning of "no arguments", we must distinguish it from "no valid arguments". A result of F6 here means "no restriction to the set of paths". If G4 is returned, the set is guaranteed to be non-empty. darcs2maybeFixSubPaths (repo_path, orig_path) file_paths tries to turn  file_paths into SubPaths, taking into account the repository path and the original path from which darcs was invoked.A SubPath is a path under& (or inside) the repo path. This does not mean it must exist as a file or directory, nor that the path has been added to the repository; it merely means that it could be added.When converting a relative path to an absolute one, this function first tries to interpret the relative path with respect to the current working directory. If that fails, it tries to interpret it with respect to the repository directory. Only when that fails does it put a Nothing in the result at the position of the path that cannot be converted.?It is intended for validating file arguments to darcs commands.darcs takes a list of flags and returns the url of the repository specified by Repodir "directory" in that list of flags, if any. This flag is present if darcs was invoked with --repodir=DIRECTORYdarcs takes a list of flags and returns the author of the change specified by Author "Leo Tolstoy"/ in that list of flags, if any. Otherwise, if Pipe is present, asks the user who is the author and returns the answer. If neither are present, try to guess the author, from repository or global preference files or environment variables, and if it's not possible, ask the user.darcs try to guess the author, from repository or global preference files or environment variables, and if it's not possible or alwaysAsk parameter is true, ask the user. If store parameter is true, the new author is added into  _darcs/prefs.darcs tries to get the author name first from the repository preferences, then from global preferences, then from environment variables. Returns [] if it could not get it. Note that it may only return multiple possibilities when reading from global preferences.darcs 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. This flag is present if darcs was invoked with --sendmail-command=COMMAND! Alternatively the user can set $SENDMAIL. which will be used as a fallback if present.darcsAccessor for output option. Takes and returns IO actions so that the default value is only calculated if needed, as it might involve filesystem actions that can fail.darcs 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. This flag is present if darcs was invoked with --subject=SUBJECTdarcs 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. Returns the addresses as a comma separated string.? ?  Safe-Inferred%&)*/1679= darcs-if pipe to ssh, can choose to compress or not darcsotherwise, can specify printersdarcs5Get the name of the darcs executable (as supplied by getExecutablePath)darcsSend an email, optionally containing a patch bundle (more precisely, its description and the bundle itself) darcsGiven two shell commands as arguments, execute the former. The latter is then executed if the former failed because the executable wasn't found (code 127), wasn't executable (code 126) or some other exception occurred (save from a resource vanished/broken pipe error). Other failures (such as the user holding ^C) do not cause the second command to be tried.darcs editFile f lets the user edit a file which could but does not need to already exist. This function returns the exit code from the text editor and a flag indicating if the user made any changes.darcsOn Posix systems, GHC by default uses the user's locale encoding to determine how to decode/encode the raw byte sequences in the Posix API to/from 8. It also uses certain special variants of this encoding to determine how to handle encoding errors.See GHC.IO.Encoding for details.In particular, the default variant used for command line arguments and environment variables is /ROUNDTRIP, which means that any/ byte sequence can be decoded and re-encoded w/o failure or loss of information. To enable this, GHC uses code points that are outside the range of the regular unicode set. This is what you get with  .We need to preserve the raw bytes e.g. for file names passed in by the user and also when reading file names from disk; also when re-generating files from patches, and when we display them to the user.So we want to use this encoding variant for *all* IO and for (almost) all conversions between raw bytes and 8s. The encoding used for IO from and to handles is controlled by   which we use here to make it equal to the //ROUNDTRIP variant.setDarcsEncoding should be called before the first time any darcs operation is run, and again if anything else might have set those encodings to different values.Note that it isn't thread-safe and has a global effect on your program.darcsSigned patch identity. The % hash of the non-inverted meta data ( ) plus an < for the sequence number within the named patch, starting with 1. The < gets inverted together with the patch and must never be 0 else we could not distinguish between the patch and its inverse.darcsThis should only be used for testing, as it exposes the internal structure of a .darcs$Create an infinite list of positive s. Safe-Inferred%&)*/1679=˨ Safe-Inferred%&)*/1679=Ѵ darcsA patch, together with a list of patch names that it used to depend on, but were lost during the rebasing process. The UI can use this information to report them to the user.darcsGet hold of the  patch inside a  and wrap it in a .darcsSplit a list of rebase patches into those that will have conflicts if unsuspended and those that won't.darcsGiven a list of rebase items, try to push a new fixup as far as possible into the list as possible, using both commutation and coalescing. If the fixup commutes past all the ToEdit% patches then it is dropped entirely.darcsLike  but for a list of fixups. darcspushThrough (ps :> (qs :> te)) tries to commute as much of ps as possible through both qs and te , giving %psStuck :> (qs' :> te') :> psCommuted,. Anything that can be commuted ends up in  psCommuted" and anything that can't goes in psStuck. darcsForcibly commute a  with a patch, dropping any dependencies if necessary and recording them in the patchdarcsTurn a selected rebase patch back into a patch we can apply to the main repository, together with residual fixups that need to go back into the rebase state (unless the rebase is now finished). Any fixups associated with the patch will turn into conflicts.darcsLike 5, but any fixups are "reified" into a separate patch. Safe-Inferred%&)*/1679=darcsA single item in the rebase state consists of either a patch that is being edited, or a fixup that adjusts the context so that a subsequent patch that is being edited "makes sense".ToEdit/ holds a patch that is being edited. The name ( PatchInfo) of the patch will typically be the name the patch had before it was added to the rebase state; if it is moved back into the repository it must be given a fresh name to account for the fact that it will not necessarily have the same dependencies or content as the original patch. This is typically done by changing the  Ignore-This junk.Fixup* adjusts the context so that a subsequent ToEdit$ patch is correct. Where possible, Fixup changes are commuted as far as possible into the rebase state, so any remaining ones will typically cause a conflict when the ToEdit* patch is moved back into the repository. Safe-Inferred%&)*/1679=9darcsA  Suspended9 patch contains the entire rebase state, in the form of ?s. The end state is existientially quantified and thus hidden.darcs3add fixups for the name and effect of a patch to a darcsRemove fixups (actually, add their inverse) for the name and effect of a patch to a .darcsAdd  patches for editing to a . The patches to be suspended are renamed by replacing the junk in their  Patchinfo.The reason we rename patches immediately when suspending them is that the user may pull an identical copy from a clone, Which means we have the same patch name twice, once in the normal repo and once suspended. Furthermore, they can again suspend that copy, leaving us with multiple copies of the same patch in the rebase state. This is bad because it invalidates most of the invariants for RebaseName fixups. See issue2445 and tests/rebase-repull.sh for examples which lead to crashes when we don't do the renaming here.   Safe-Inferred%&)*/1679=darcsA patch that lives in a repository where an old-style rebase is in progress. Such a repository will consist of Normal! patches along with exactly one  Suspended patch.;It is here only so that we can upgrade an old-style rebase.NormalP represents a normal patch within a respository where a rebase is in progress.  NormalP p. is given the same on-disk representation as p, so a repository can be switched into and out of rebasing mode simply by adding or removing a RebaseP/ patch and setting the appropriate format flag.*Note that the witnesses are such that the RebaseP patch has no effect on the context of the rest of the repository; in a sense the patches within it are dangling off to one side from the main repository. Safe-Inferred"%&)*/1679=darcsFail if there is an old-style rebase present. To be called initially for every command except rebase upgrade.darcsFail unless we already have some suspended patches. Not essential, since all rebase commands should be happy to work with an empty rebase state.darcsReport the rebase status if there is (still) a rebase in progress after the command has finished running. To be called via finally for every RepoJob.darcsRebase format update for all commands that modify the repo, except rebase upgrade. This is called by finalizeRepositoryChanges.   Safe-Inferred"%&)*/1679= darcsrevertTentativeChanges swaps the tentative and "real" hashed inventory files, and then updates the tentative pristine with the "real" inventory hash.darcsfinalizeTentativeChanges trys to atomically swap the tentative inventory/pristine pointers with the "real" pointers; it first re-reads the inventory to optimize it, presumably to take account of any new tags, and then writes out the new tentative inventory, and finally does the atomic swap. In general, we can't clean the pristine cache at the same time, since a simultaneous get might be in progress.darcsAdd (append) a patch to the tentative inventory. Warning: this allows to add any arbitrary patch! Used by convert import and . darcsRead the recorded  of a hashed .darcsRead the tentative  of a (hashed) .darcsCopy the hashed inventory from the given location to the given repository, possibly using the given remote darcs binary.darcswriteAndReadPatch makes a patch lazy, by writing it out to disk (thus forcing it), and then re-reads the patch lazily.darcsWrite a  to the tentative inventory. darcsAttempt to remove an FL of patches from the tentative inventory.=Precondition: it must be possible to remove the patches, i.e.!the patches are in the repository'any necessary commutations will succeeddarcsWrites out a fresh copy of the inventory that minimizes the amount of inventory that need be downloaded when people pull from the repository. The exact beavior depends on the 3rd parameter:For  it breaks up the inventory on the most recent tag. This speeds up most commands when run remotely, both because a smaller file needs to be transfered (only the most recent inventory). It also gives a guarantee that all the patches prior to a given tag are included in that tag, so less commutation and history traversal is needed. This latter issue can become very important in large repositories.For , the whole repo is traversed, from oldest to newest patch. Every tag we encounter is made clean, but only if that doesn't make any previous clean tag unclean. Every clean tags gets its own inventory. This speeds up "deep" operations, too, such as cloning a specific tag. It does not necessarily make the latest tag clean, but the benefits are similar to the shallow case.darcs$Read inventories and patches from a  and return them as a 4. Note that patches and inventories are read lazily.darcsXOR of all hashes of the patches' metadata. It enables to quickly see whether two repositories have the same patches, independently of their order. It relies on the assumption that the same patch cannot be present twice in a repository. This checksum is not cryptographically secure, see  +http://robotics.stanford.edu/~xb/crypto06b/ . Safe-Inferred"%&)*/1679=darcsSlightly confusingly named: as well as throwing away any tentative changes, revertRepositoryChanges also re-initialises the tentative state. It's therefore used before makign any changes to the repo.darcsAtomically copy the tentative state to the recorded state, thereby committing the tentative changes that were made so far. This includes inventories, pending, rebase, and the index.darcsUpgrade a possible old-style rebase in progress to the new style. Safe-Inferred%&)*/1679=oGPL-2 Safe-Inferred%&)*/1679=2darcsCreate packs from the current recorded version of the repository. Safe-Inferred%&)*/1679= Safe-Inferred%&)*/1679=darcs)Return the pristine tree up to the given . In the typical case where the match is closer to the end of the repo than its beginning, this is (a lot) more efficient than applying the result of  to an empty tree.darcs#Return the patches up to the given . Safe-Inferred%&)*/1679= darcsSet the given paths executable if they are scripts. A script is any file that starts with the bytes #!/. This is used for --set-scripts-executable.GPL-2 Safe-Inferred%&)*/1679=darcs:The status of a given directory: is it a darcs repository?darcs'looks like a repository with some errordarcs safest guessdarcsTry to identify the repository at a given location, passed as a 8. If the lcation is ".", then we assume we are identifying the local repository. Otherwise we assume we are dealing with a remote repo, which could be a URL or an absolute path.darcs*identifyRepository identifies the repo at url. Warning: you have to know what kind of patches are found in that repo.darcsidentifyRepositoryFor repo url& identifies (and returns) the repo at url, but fails if it is not compatible for reading from and writing to.darcshunt upwards for the darcs repository This keeps changing up one parent directory, testing at each step if the current directory is a repository or not. The result is: Nothing, if no repository found Just (Left errorMessage), if bad repository found Just (Right ()), if good repository found. WARNING this changes the current directory for good if matchFn succeeds Safe-Inferred%&)*/1679= darcsThis is just an internal type to Darcs.Repository.Job for calling runJob in a strongly-typed waydarcsA RepoJob wraps up an action to be performed with a repository. Because repositories can contain different types of patches, such actions typically need to be polymorphic in the kind of patch they work on. RepoJob is used to wrap up the polymorphism, and the various functions that act on a RepoJob are responsible for instantiating the underlying action with the appropriate patch type.darcsThe most common 4; the underlying action can accept any patch whose  is  .darcs(A job that only works on darcs 1 patchesdarcs(A job that only works on darcs 2 patchesdarcs8A job that works on any repository where the patch type p has  p = . This was added to support darcsden, which inspects the internals of V1 prim patches. In future it should be replaced with a more abstract inspection API as part of  PrimPatch.darcsA job that works even if there is an old-style rebase in progress. darcsCheck multiple patch types against the constraints required by most repository jobs darcsCheck multiple patch types against the constraints required by darcs4apply a given RepoJob to a repository in a given urldarcsapply a given RepoJob to a repository in the current working directorydarcsApply a given RepoJob to a repository in the current working directory. However, before doing the job, take the repo lock and initializes a repo transaction.darcsrun a lock-taking job in an old-fashion repository. only used by `darcs optimize upgrade`.darcsApply a given RepoJob to a repository in the current working directory, taking a lock. If lock not takeable, do nothing. If old-fashioned repository, do nothing. The job must not touch pending or pending.tentative, because there is no call to revertRepositoryChanges. This entry point is currently only used for attemptCreatePatchIndex. Safe-Inferred%&')*/1679=" darcs working tree darcsrecorded and pending darcsunrecorded pathsdarcsReturn all files available under the original working directory regardless of their repo state.darcsReturn all files available under the original working directory that are unknown to darcs but could be added.darcsReturn all files available under the original working directory that are known to darcs (either recorded or pending).darcsReturn all files available under the original working directory that are modified (relative to the recorded state).darcs-Return the available prefs of the given kind.darcsReturn an empty list. darcsTurn an action that creates all possible completions into one that removes already given arguments.   Safe-Inferred%&)*/1679= Safe-Inferred%&)*/1679= darcsThis function fetches all patches that the given repository has with fetchFileUsingCache. Safe-Inferred%&)*/1679=   Safe-Inferred"%&)*./01679=#, darcsProgress of Bisect: current step, currently predicted total steps. The total steps prediction will increase if we run into untestable states. darcsA   is used to keep track of the set of patches a search strategy is currently working on, split at a given point with an explicit witness for that intermediate point (the focus:), so we can connect it to the state of the testing tree. darcsThe implementation type for a given "test strategy" like bisect, backoff, linear or once. It is given a sequence of patches we might want to search inside to identify the cause of a test failure, and also passed the initial testing result for the end of that sequence. darcsStrategyDone captures the final result of running a "test strategy" like bisect, backoff, linear or once. It has a slightly complicated type because of the witnesses and because we may want to run a continuation afterwards to minimise the result. Essentially it is just a . darcs  is a continuation passed to a test strategy indicating what should be done with the final result of the strategy. This for example allows a post-processing "minimise blame" pass to be run. The witnesses make it hard to wrap this up in a standard abstraction.darcs&The result of running a test strategy.darcsThe chosen strategy didn't find any passing states in the repository.darcsThe test didn't fail on head so there's no failure to track down.darcsThe failure was tracked down to the given patches. these two are just for oneTestdarcsThe single test run passed.darcs4The single test run failed with the given exit code.darcs is a sequence of patches, implemented as a binary tree, balanced in an arbitrary way depending on how it happened to be constructed. In the 'darcs test' implementation it is used to wrap up a single patch or group of patches that might be the cause of a failure. darcsA  + runs the test on a given repository state.darcs3A usable test result, i.e. not an untestable state.darcsThe test passed.darcs)The test failed with the given exit code.darcs&The result of running a test on state wX of the repository.darcsWe got a usable test result.darcsThe test result could not be identified as either pass or fail, for example it might have been a build failure. External test scripts report this by reporting exit code 125.darcs0An indexed monad that can be used to run tests.   is the only real implementation, the unit tests for testing are based on mock implementations.darcsOutput a messagedarcs/Output a message containing the name of a patchdarcs"Apply a patch to the testing tree.darcs%Unapply a patch from the testing treedarcsGet the current status (passskip=fail) of the testing tree, e.g. by running the test command.darcs$Flag that all testing has completed. darcsThe  / monad, augmented with configuration parametersdarcsOnce we've finished tracking down a test failure, we no longer care about tracking the actual state of the testing tree. This witness constant is never used in any patch, so once we use it for the state of the testing tree, in practice we can no longer do anything more with that tree.We could also use some kind of existential or different monad type to represent this, but it would make composing code with 'do' harder. darcsThis type is used to track the state of the testing tree. For example, 'Testing IO wX wY Int' requires that the testing tree start in state wX, and leaves it in state wY. darcsAfter a strategy has finished, untestable states might mean that it was only able to assign blame to a group of patches rather than a single patch. This function tries to reorder the group of patches (using commutation). The hope is that a reordered sequence will reveal a testable state, allowing us to cut down the group.The type is logically something like 'StrategyResult -> m StrategyResult', but is expressed as a transformation of a   to manage the witnesses. These are complicated because we want to re-use the testing tree left by the strategy. darcs+ newer', updating the testing tree to match, and call the given continuation. darcs7a buffer of patches that start with an untestable statedarcspatches we haven't visited yet darcsFailure witnessdarcsNumber of patches to skip.darcsPatches not yet skipped.## Safe-Inferred"%&)*/1679=(I darcsA + represents a command like add, record etc.darcs Construct  / from the command specific basic and advanced sdarcsFor the given  check the given  s for consistencydarcs Built-in default values for all  !s supported by the given commanddarcs9Option descriptions split into basic and advanced optionsdarcs#Option descriptions as required by  , i.e. resolved with the given  .darcsSet the DARCS_PATCHES and DARCS_PATCHES_XML environment variables with info about the given patches, for use in post-hooks.darcsSet the DARCS_FILES environment variable to the files touched by the given patch, one per line, for use in post-hooks. darcsSet some environment variable to the given value, unless said value is longer than 100K characters, in which case do nothing.darcs$To use for commandArgdefaults field.44 Safe-Inferred"%&)*/1679=)h Safe-Inferred"%&)*/1679=) Safe-Inferred"%&)*/1679=.darcs action flags patches prints a string 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" flags0 is the list of flags which were sent to darcs patches7 is the sequence of patches which would be touched by action.darcsGiven a repository and two common command options, classify the given list of paths according to whether they exist in the pristine or working tree. Paths which are neither in working nor pristine are reported and dropped. The result is a pair of path lists: those that exist only in the working tree, and those that exist in pristine or working. darcspatchFilename maps a patch description string to a safe (lowercased, spaces removed and only letters/digits) patch filename. darcs>Get the union of the set of patches in each specified location   Safe-Inferred"%&)*/1679=/} darcs Runs the  code darcsThe interactive part of darcs whatsnewdarcs An alias for , with implicit -l (and thus implicit -s) flags. We override the default description, to include these flags. Safe-Inferred%&)*/1679=/ Safe-Inferred"%&)*/1679=0& Safe-Inferred%&)*/1679=0 Safe-Inferred"%&)*/01679=0 Safe-Inferred%&)*/1679=1& Safe-Inferred%&)*/1679=1x Safe-Inferred%&)*/1679=1 Safe-Inferred%&)*/1679=2 Safe-Inferred%&)*/1679=2n Safe-Inferred%&)*/1679=2 Safe-Inferred"%&)*/1679=5 darcsA pair of (direct, indirect) dependencies. For the result we need only the direct dependencies. We store the indirect ones as an optimization to avoid doing commutes for which we already know that they cannot succeed. Note that the two sets are always disjoint. darcsA   from s to  . darcsDetermine the   of an  of patches. darcs Render a   in the Dot Language format. This function considers only the direct dependencies. Safe-Inferred%&)*/1679=5b Safe-Inferred%&)*/1679=5 Safe-Inferred%&)*/1679=6 Safe-Inferred%&)*/1679=6 darcs$A list of all valid preferences for _darcsprefsprefs. darcs(name, one line description) Safe-Inferred%&)*/1679=75 Safe-Inferred"%&)*/1679=7darcsAn alias for 'revert -l' i.e. remove every (non-boring) file or change that is not in pristine. Safe-Inferred%&)*/1679=: darcsGiven a set of characters and a string, returns true iff the string contains only characters from the set. A set beginning with a caret (^%) is treated as a complementary set. darcsThis function checks for  --token-chars on the command-line. If found, it validates the argument and returns it, without the surrounding square brackets. Otherwise, it returns either  or   as explained in  .Note: Limitations in the current replace patch file format prevents tokens and token-char specifiers from containing any whitespace. Safe-Inferred"%&)*/1679=;3darcs8check is an alias for repair, with implicit DryRun flag. Safe-Inferred%&)*/1679=>/ darcsmakeRemovePatch builds a list of patches to remove the given filepaths. This function does not recursively process directories. The  Recursive flag should be handled by the caller by adding all offspring of a directory to the files list. darcsTakes a file path and returns the FL of patches to remove that, wrapped in a  . Returns F in case the path cannot be removed (if it is not tracked, or if it's a directory and it's not tracked). The three   arguments are the recorded state, the unrecorded state excluding the removal of this file, and the unrecorded state including the removal of this file. Safe-Inferred"%&)*/1679=? darcscommit is an alias for record darcsCheck user specified patch name is not accidentally a command line flag Safe-Inferred"%&)*/1679=?` Safe-Inferred%&)*/1679=A; darcs*known to darcs, but absent in working tree darcsTakes two filenames (as Subpath), and tries to move the first into/onto the second. Needs to guess what that means: renaming or moving into a directory, and whether it is a post-hoc move. darcstree of the working directorydarcs$tree of recorded and pending changesdarcstree of recorded changes Safe-Inferred"%&)*/1679=D{ darcsA set of repository paths.   means every path in the repo, it usually originates from an empty list of path arguments. The list of  4s is always kept in sorted order with no duplicates.It uses lists because the number of elements is expected to be small. darcs  is isomorphic to >! but with the opposite semantics.About the name: I like the data constructor names, they are pretty suggestive. The data type name is up for grabs; a possible alternative is AtMost. darcs,This is mostly for conversion to legacy APIs darcsIntersection of two  s darcs Convert a   to a . Uses the English module to generate a nicely readable list of file names. Safe-Inferred%&)*/1679=G darcsTake a list of filenames and patches and produce a list of patches that actually touch the given files with a list of touched file names, a list of original-to-current filepath mappings, indicating the original names of the affected files and possibly an error. Additionaly, the function takes a "depth limit" -- maxcount, that could be Nothing (return everything) or "Just n" -- returns at most n patches touching the file (starting from the beginning of the patch list).darcschanges is an alias for log darcsmaxcountdarcspathsdarcspatches Safe-Inferred"%&)*/1679=G Safe-Inferred%&)*/1679=H*darcsThis is designed for use in an atexit handler, e.g. in Darcs.RunCommand2003 David RoundyGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679=I<darcs Flags/optionsdarcsThe path to the repositorydarcs,An action to perform on the archive contents Safe-Inferred%&)*/1679=J darcsReturns the command we should use for diff as a tuple (command, arguments). This will either be whatever the user specified via --diff-command or the default . Note that this potentially involves parsing the user's diff-command, hence the possibility for failure. Safe-Inferred"%&)*/1679=K  Safe-Inferred"%&)*/1679=K_ Safe-Inferred%&)*/1679=L darcsNeed this to make  work with a function that changes the last two (identical) witnesses at the same time. darcsThis part of the help is split out because it is used twice: in the help string, and in the prompt for confirmation. Safe-Inferred%&)*/1679=M Safe-Inferred%&)*/1679=N darcsMake sure that the remote directory does not exist, but all its parent directories do. darcsThe  command takes --to-patch and --to-match as arguments, but internally wants to handle them as if they were --patch and --match. This function does the conversion. Safe-Inferred"%&)*/1679=O/ darcsPOST the patch via HTTP darcssend patch via email Safe-Inferred"%&)*/1679=O Safe-Inferred"%&)*/1679=O2004, 2007 David RoundyGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred"%&)*/1679=P!darcscandidates for --ask-depsdarcsoriginal patchdarcschanges to adddarcspendingdarcsworking2002-2004 David RoundyGPLdarcs-devel@darcs.net experimentalportable Safe-Inferred%&)*/1679=Q Safe-Inferred%&)*/1679=R:darcs*This class is a hack to abstract over pullapply and rebase pullapply.   Safe-Inferred"%&)*/1679=R Safe-Inferred%&)*/1679=S Safe-Inferred%&)*/1679=W!darcsInject fixups into a ; and update the remainder of the rebase state. This is in B because it involves interactive selection of the fixups to inject. TODO: We currently offer only prim fixups, not name fixups, for injection. I think it would make sense to extend this to name fixups, so the user can explicitly resolve a lost dependency in cases where is clear that it won't re-appear.!darcsMap a cons-like operation that may change the end state over an .. Unfortunately this can't be generalized to foldrwFL;, even though it has exactly the same definition, because  doesn't have the right kind. We could play with a newtype wrapper to fix this but the ensuing wrapping and unwrapping would hardly make it clearer what's going on.!darcsSquash second patch with first, updating the rest of the rebase state. This can fail if the second patch has fixups that don't commute with the contents of the first patch.!darcschanges is an alias for log!darcsstack of undone edits, for redodarcs current statedarcsstack of past edits, for undo Safe-Inferred%&)*/1679=XdarcsThe commands that darcs knows about (e.g. whatsnew, record), organized into thematic groups. Note that hidden commands are also listed here. Safe-Inferred%&)*/1679=f !darcs A finite map from flag names to  s.!darcs:Result of parsing a defaults line: switch and argument(s).!darcs;Name of a normal command, or name of super and sub command.darcs-Apply defaults from all sources to a list of  s (e.g. from the command line), given the command (and possibly super command) name, and a list of all options for the command.Sources for defaults are"the builtin (hard-coded) defaults,2the defaults file in the user's configuration, and,the defaults file in the current repository.Note that the pseudo command ALL is allowed in defaults files to specify that an option should be the default for all commands to which it applies.The order of precedence for conflicting options (i.e. those belonging to same group of mutually exclusive options) is from less specific to more specific. In other words, options from the command line override all defaults, per-repo defaults override per-user defaults, which in turn override the built-in defaults. Inside the options from a defaults file, options for the given command override options for the ALL pseudo command.Conflicting options at the same level of precedence are not allowed.Errors encountered during processing of command line or defaults flags are formatted and added as (separate) strings to the list of error messages that are returned together with the resulting flag list.!darcsMake a !; from a possible super command name and a sub command name.!darcsTurn a ! into a 8. For a !% concatenate with a space in between.!darcsParse a list of lines from a defaults file, returning a list of  , given the current working directory, the command name, and a list of  DarcsOption for the command.In the result, defaults for the given command come first, then come defaults for ALL commands..We check that matching options actually exist.lines matching the command name: the option must exist in the command's option map.lines matching ALL: there must be at least *some* darcs command with that option.!darcsExtract !5s from lines of a defaults file that match the given !. The syntax is & supercmd subcmd [--]switch [args...] ,for (super) commands with a sub command, and # cmd default [--]default [args...] #for normal commands (including the ALL pseudo command).!darcsSearch an option list for a switch. If found, apply the flag constructor from the option to the arg, if any. The first parameter is the current working directory, which, depending on the option type, may be needed to create a flag from an argument.Fails if (default has argument /= corresponding option has argument).!darcs&Get all the flag names from an options!darcs Build an ! from a list of  DarcsOptions.!darcsList of option switches of all commands (except help but that has no options).darcsmaybe name of super commanddarcsthe darcs commanddarcsthe original working directory, i.e. the one from which darcs was invokeddarcslines from user defaultsdarcslines from repo defaultsdarcsflags from command line Safe-Inferred"%&)*/1679=hF!darcsReturns the working directory for the posthook. For most commands, the first parameter is returned. For the 'get' command, the path of the newly created repository is returned if it is not an ssh url.!darcsChecks if the number of extra arguments matches the number of extra arguments supported by the command as specified in . Extra arguments are arguments that follow the command but aren't considered a flag. In `darcs push xyz`, xyz would be an extra argument. Safe-Inferred%&)*/1679=h!!! Safe-Inferred"%&)*/1679=k!darcsStarting from a list of s, unwrap one level to get a list of command names together with their subcommands.!darcsGiven a list of (normal) arguments to the help command, produce a list of possible completions for the next (normal) argument.!darcs?Help on each environment variable in which Darcs is interested.!darcsThis function is responsible for emitting a darcs "man-page", a reference document used widely on Unix-like systems. Manpages are primarily used as a quick reference, or "memory jogger", so the output should be terser than the user manual.Before modifying the output, please be sure to read the man(7) and man-pages(7) manpages, as these respectively describe the relevant syntax and conventions.!                                  !!!!!!!"""""""""""""################$$$$$$$$$$$$%%%%% %% % % % % % %        & ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) * * * * * * * * * * * * * * + + + + + + , , , , , , , , - - - - - - - . . . . / / / / / / / / / / / / / / 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5  6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 : : : : : :: : : : : : : : : : : : : : : : : : : : :: : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : ; ;; ; ; ; ; ; ; ;; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; < < = = = = = = = = = = === = = = = = = > > > > > > > > > > > > > > > ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ @ A A A A A A A A B B B B B B B B B B B B B B B B B B B B B B C C C C C C C C C C C C C C C C C C C C C C C C C C C C C C D D D D D D D DD D D D D D D D D D D D D D D D EEE E E E E EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFGHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIIIIIJJJJJJJJJJJJJJKKKKKKLLLLLLL L LLLLLLLLLLLLLMMMMMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPQQQQQQQQQQQQRRRRSSSSSSSSSSSSSSSSTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUUUUUUUUUUUUUUVVVVVVVVVVVVVVVVVVVVWWWWWWWWWWWWWWWWWWWWWWWWWWWXXXXXXXXXXXYYYYYYYYYYZZZZZZZZZZ[[[[[[[[[[[[[[[[[[[\\\\\\\]]]]]]]^^^^^^^^^^^^^^^^^^^^^^^^___________________``````````````````````````````````aaaaaaaaaaaaaaaaaaaaaaaaaaaaaabcccccccdddddddeeefghhhhhhhhhhhhhhhhhhhhhhhhhhhiijkkllmmmmmnoppppppppqqqqqqqqqqqrrrrrrrrrrrrrrrsstttttttttttuuuuuuuuuuuuuuuuuuuuuuvvvvvvwwwwwwwxyyyyzzzzzzzzzzzzzzzzzzzzzzzz{{{{{{{{{{||||||||||||||||||||||||||||||||||||||}}}}}}}}}}}}}}}}}}}}}~         !!!!!!!!!!!!!!!!!!!!!!!!!!"%(1555788888888::::;======>>>?@@@@@@@@@AAABBBBBBBBBBBBBBBBBBBBBBDDDDDDDDDDFFFFFFFHHHHHNNNNNNNOTTTT^^fggggmnnouz||||||||}}                                                                                                                          !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!#darcs-2.18.2-IqKJ20uuqmC48imv6mv7BV Darcs.PreludeDarcs.Util.ParserDarcs.Util.RatifiedDarcs.Util.ByteStringDarcs.Util.WorkaroundDarcs.Util.RegexDarcs.Util.DateTimeDarcs.Patch.Witnesses.UnsafeDarcs.Patch.Witnesses.EqDarcs.Patch.RegCharsDarcs.Patch.TokenReplaceDarcs.Patch.FormatDarcs.Test.TestOnlyDarcs.UI.Options.IsoDarcs.UI.Options.CoreDarcs.Util.AtExitDarcs.Util.CommandLineDarcs.Util.EncodingDarcs.Util.GlobalDarcs.Util.Diff.MyersDarcs.Util.Diff.PatienceDarcs.Util.DiffDarcs.Repository.FlagsDarcs.Util.GraphDarcs.Util.HTTPDarcs.Util.HashDarcs.Util.IndexedMonadDarcs.Util.IsoDateDarcs.Util.DateMatcherDarcs.Util.PrinterDarcs.Util.EnglishDarcs.UI.EmailDarcs.Util.Printer.ColorDarcs.Util.ProgressDarcs.Util.ExecDarcs.Util.PromptDarcs.UI.PromptDarcs.Util.ShowDarcs.Patch.Witnesses.ShowDarcs.Patch.Witnesses.SealedDarcs.Patch.Witnesses.OrderedDarcs.Patch.Witnesses.WZipperDarcs.Patch.Witnesses.MaybeDarcs.Patch.Rebase.PushFixupDarcs.Patch.InvertDarcs.Patch.DebugDarcs.Patch.CommuteFnDarcs.Patch.CommuteDarcs.Patch.MergeDarcs.Patch.PermutationsDarcs.Patch.CommuteNoConflictsDarcs.Util.URLDarcs.Util.ValidHashDarcs.Util.SignalHandlerDarcs.Util.ExceptionDarcs.Util.SshDarcs.Util.CompatDarcs.Util.PathDarcs.Util.TreeDarcs.Util.Tree.PlainDarcs.Util.Tree.MonadDarcs.Util.FileDarcs.Util.LockDarcs.Util.CacheDarcs.Util.Tree.HashedDarcs.Util.IndexDarcs.Repository.PathsDarcs.Repository.FormatDarcs.UI.Options.FlagsDarcs.UI.Options.UtilDarcs.UI.Options.MarkdownDarcs.Repository.PrefsDarcs.Repository.InternalTypesDarcs.Patch.SummaryDataDarcs.Patch.Object#Darcs.Patch.Prim.FileUUID.ObjectMapDarcs.Patch.InspectDarcs.Patch.ChoicesDarcs.Patch.ApplyMonadDarcs.Repository.ApplyPatchesDarcs.Patch.ApplyDarcs.Patch.TouchesFilesDarcs.Patch.ShowDarcs.Patch.Info!Darcs.Repository.Inventory.FormatDarcs.Patch.Index.TypesDarcs.Patch.IdentDarcs.Patch.BracketedDarcs.Patch.ReadDarcs.Patch.RepairDarcs.Patch.Index.MonadDarcs.Patch.FileHunkDarcs.Patch.ViewingDarcs.Patch.V3.ContextedDarcs.Patch.Annotate.ClassDarcs.Patch.Prim.ClassDarcs.Patch.Prim.V1.CoreDarcs.Patch.Prim.V1.DetailsDarcs.Patch.Prim.V1.ShowDarcs.Patch.Prim.V1.CommuteDarcs.Patch.Prim.V1.ApplyDarcs.Patch.Prim.V1.ReadDarcs.Patch.Prim.V1.MangleDarcs.Patch.Prim.FileUUID.CoreDarcs.Patch.Prim.FileUUID.Read!Darcs.Patch.Prim.FileUUID.Details!Darcs.Patch.Prim.FileUUID.Commute"Darcs.Patch.Prim.FileUUID.CoalesceDarcs.Patch.Prim.CoalesceDarcs.Patch.Prim.V1.CoalesceDarcs.Patch.Prim.CanonizeDarcs.Patch.SplitDarcs.Patch.FromPrimDarcs.Patch.V1.CoreDarcs.Patch.V1.ShowDarcs.Patch.UnwindDarcs.Patch.SummaryDarcs.Patch.Prim.FileUUID.ShowDarcs.Patch.Prim.FileUUID.ApplyDarcs.Patch.Prim.FileUUIDDarcs.Patch.EffectDarcs.Patch.V2.NonDarcs.Patch.ConflictDarcs.Patch.V2.RepoPatchDarcs.Patch.V1.CommuteDarcs.Patch.V1.ReadDarcs.Patch.V1.ApplyDarcs.Patch.V1.ViewingDarcs.Patch.NamedDarcs.Patch.Rebase.NameDarcs.Patch.Rebase.FixupDarcs.Patch.PatchInfoAndDarcs.Patch.SetDarcs.Patch.ProgressDarcs.Patch.DependsDarcs.Patch.AnnotateDarcs.Patch.V2.PrimDarcs.Patch.V1.PrimDarcs.Patch.RepoPatchDarcs.Patch.InvertibleDarcs.Patch.BundleDarcs.Repository.UnrevertDarcs.Repository.PendingDarcs.Repository.PatchIndexDarcs.Repository.OldDarcs.Repository.InventoryDarcs.Repository.TraverseDarcs.Repository.PristineDarcs.Repository.DiffDarcs.Repository.StateDarcs.Repository.ResolutionDarcs.Patch.MatchDarcs.UI.Options.MatchingDarcs.UI.Options.AllDarcs.UI.RunHookDarcs.UI.OptionsDarcs.UI.FlagsDarcs.UI.ExternalDarcs.UI.PrintPatchDarcs.UI.SelectChangesDarcs.UI.PatchHeaderDarcs.UI.Commands.Convert.UtilDarcs.Patch.Prim.WithNameDarcs.Patch.V3.CoreDarcs.Patch.V3.ResolutionDarcs.Patch.Prim.NamedDarcs.Patch.V3Darcs.Patch.Rebase.ChangeDarcs.Patch.Rebase.Legacy.ItemDarcs.Patch.Rebase.Suspended!Darcs.Patch.Rebase.Legacy.WrappedDarcs.Repository.RebaseDarcs.Repository.HashedDarcs.Repository.TransactionDarcs.Repository.RepairDarcs.Repository.PacksDarcs.Repository.MergeDarcs.Repository.MatchDarcs.Repository.WorkingDarcs.Repository.IdentifyDarcs.Repository.JobDarcs.UI.CompletionDarcs.Repository.CreateDarcs.Repository.CloneDarcs.UI.Commands.Test.ImplDarcs.UI.CommandsDarcs.UI.UsageDarcs.UI.TestChangesDarcs.UI.Commands.UtilDarcs.UI.Commands.WhatsNewDarcs.UI.Commands.UnrevertDarcs.UI.Commands.UnrecordDarcs.UI.Commands.TransferModeDarcs.UI.Commands.TestDarcs.UI.Commands.TagDarcs.UI.Commands.ShowTagsDarcs.UI.Commands.ShowRepo Darcs.UI.Commands.ShowPatchIndexDarcs.UI.Commands.ShowIndexDarcs.UI.Commands.ShowFiles"Darcs.UI.Commands.ShowDependenciesDarcs.UI.Commands.ShowContentsDarcs.UI.Commands.ShowAuthorsDarcs.UI.Commands.ShowDarcs.UI.Commands.SetPrefDarcs.UI.Commands.RollbackDarcs.UI.Commands.RevertDarcs.UI.Commands.ReplaceDarcs.UI.Commands.RepairDarcs.UI.Commands.RemoveDarcs.UI.Commands.RecordDarcs.UI.Commands.OptimizeDarcs.UI.Commands.MoveDarcs.UI.Commands.MarkConflictsDarcs.UI.Commands.LogDarcs.UI.Commands.InitDarcs.UI.Commands.GZCRCsDarcs.UI.Commands.DistDarcs.UI.Commands.Diff Darcs.UI.Commands.Convert.Import Darcs.UI.Commands.Convert.Export Darcs.UI.Commands.Convert.Darcs2Darcs.UI.Commands.ConvertDarcs.UI.Commands.CloneDarcs.UI.Commands.SendDarcs.UI.Commands.PushDarcs.UI.Commands.AnnotateDarcs.UI.Commands.AmendDarcs.UI.Commands.AddDarcs.UI.ApplyPatchesDarcs.UI.Commands.PullDarcs.UI.Commands.ApplyDarcs.UI.Commands.RebaseDarcs.UI.TheCommandsDarcs.UI.DefaultsDarcs.UI.RunCommandDarcs.UI.Commands.Helpdarcs DarcsFlagSystem.Console.GetOptOptDescr DarcsOptDescr Data.FunctorFunctorsetEnvCautiouslyPreludefoldrDarcsUtil.Path AbsolutePathwritePatchIfNecessary readFileName showFriendlyNamed InvertibledefaultTryToShrinkdefaultSortCoalesceFLDarcs.Patch.Prim.V1Darcs.Patch.PrimDarcs.Patch.V2Darcs.Patch.V1 Darcs.PatchDarcs.RepositorySystem.Console.GetoptgetOptVersionbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint otherwisemap$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.Failfail fromIntegral realToFrac toInteger toRational<>memptymappendmconcat<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralMonadNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShow MonadFail Applicative Data.FoldableFoldableData.Traversable Traversable SemigroupMonoid GHC.TypesBoolStringCharDoubleFloatInt ghc-bignumGHC.Num.IntegerInteger GHC.MaybeMaybeOrderingRational~IOWord Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGTminBoundmaxBound/=sconcatstimes<|>manyliftA2idreadList<$>show<*<$mapM_(attoparsec-0.14.4-DFGT237QIvtGGjEoq1lAVmData.Attoparsec.Internal endOfInputData.Attoparsec.Combinatorchoiceoption lookAhead#Data.Attoparsec.ByteString.InternalParsertake Data.Attoparsec.ByteString.Char8anyChartakeTill skipWhile skipSpace Text.Readread.constcompare<<=>maxmin&&||notGHC.ErrerrorerrorWithoutStackTrace undefined=<<flip$!untilasTypeOf+*abssignumsubtract Data.Maybemaybeheadtaillastinitscanlscanl1scanrscanr1iteraterepeat replicatecycle takeWhile dropWhiledropsplitAtspanbreakreverse!!zip3zipWithzipWith3unzipunzip3 showsPrecshowListShowSshowsshowChar showString showParensucctoEnumfromEnumproperFractiontruncateroundceilingfloor/recipquotremdivmodquotRemdivModevenodd^^gcdlcm floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2expsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanh Data.TuplefstsndcurryuncurryText.ParserCombinators.ReadPReadS readsPrec readParenlexeitherreadsfoldMapfoldlfoldr1foldl1nulllengthelemmaximumminimumsumproduct sequence_concat concatMapandoranyallnotElem Data.OldListlinesunlineswordsunwordsGHC.IO.ExceptionIOError userErrorGHC.IOFilePathioErrorGHC.IO.Handle.Text hGetContentsputCharputStrputStrLngetChargetLine getContentsinteractreadFile writeFile appendFilereadLnreadIOControl.Applicativeoptionaltraverse sequenceAmapMsequencebytestring-0.11.5.2Data.ByteString intercalatedirectory-1.3.8.1System.DirectorygetCurrentDirectory)regex-tdfa-1.3.2.2-IBvfWWuhT9IK9rjHniv7kSText.Regex.TDFA.CommonRegex time-1.12.2Data.Time.Clock.POSIXgetCurrentTime unix-2.8.1.0System.Posix.SignalsHandlerDefaultIgnoreCatch CatchOnce CatchInfo CatchInfoOnceSignalsigABRTsigALRMsigHUPsigINTsigPIPEsigTERM raiseSignalinstallHandler unsafeCoercePunsafeCoercePStartunsafeCoercePEndunsafeCoerceP1Eq2 unsafeCompare=\/==/\=EqCheckIsEqNotEqisIsEq $fShowEqCheck $fEqEqCheckregChars tryTokReplaceforceTokReplaceannotateReplace breakToTokens defaultToksFileNameFormatFileNameFormatV1FileNameFormatV2FileNameFormatDisplay ListFormatListFormatDefault ListFormatV1 ListFormatV2 ListFormatV3PatchListFormatpatchListFormat$fEqFileNameFormat$fShowFileNameFormatTestOnly IsoFunctorimapIsoundercps PrimOptSpecOptSpecounparseoparseocheckodescOptMsg OptWarningOptErroroid^ onormalise defaultFlagsoimapoappendoempty parseFlags unparseOpt?$fIsoFunctorOptSpec$fMonoidOptSpec$fSemigroupOptSpecatexit withAtexitparseCmd addUrlencoded toSeconds startOfTimeformatDateTime parseDateTime fromClockTimeencodedecode encodeUtf8 decodeUtf8 setDebugMode whenDebugMode withDebugMode debugMessagesetTimingsMode addCRCWarninggetCRCWarningsresetCRCWarningsdarcsdirdefaultRemoteDarcsCmddarcsLastMessagedarcsSendMessagedarcsSendMessageFinal FileSegment dropSpaceisFunkyhashPSsubstrPS breakFirstPS breakLastPSlinesPS unlinesPS#prop_unlinesPS_linesPS_left_inverseprop_linesPS_lengthprop_unlinesPS_length gzDecompressisGZFile gzReadFilePS gzWriteFilePSgzWriteFilePSs gzWriteHandle gzReadStdin readSegment mmapFilePS fromPS2Hex fromHex2PSpropHexConversionbetweenLinesPSspec_betweenLinesPSisAsciiunpackPSFromUTF8packStringToUTF8 decodeLocale encodeLocalePArray getChangesgetSliceshiftBoundariesinitPaLen DiffAlgorithm PatienceDiff MyersDiff$fEqDiffAlgorithm$fShowDiffAlgorithm OptimizeDeepOptimizeShallowWithPrefsTemplatesNoPrefsTemplates PatchFormat PatchFormat1 PatchFormat2 PatchFormat3 ForgetParentYesForgetParentNoForgetParentWithWorkingDir NoWorkingDir WantGuiPauseYesWantGuiPauseNoWantGuiPauseWorkRepo WorkRepoDirWorkRepoPossibleURLWorkRepoCurrentDirResolveConflictsNoResolveConflicts MarkConflicts ExternalMergeAllowConflictsNoAllowConflictsYesAllowConflicts CloneKind LazyClone NormalClone CompleteCloneUseIndex IgnoreIndexInheritDefaultYesInheritDefaultNoInheritDefault SetDefault YesSetDefault NoSetDefault LeaveTestDirYesLeaveTestDirNoLeaveTestDirSetScriptsExecutableYesSetScriptsExecutableNoSetScriptsExecutableRunTest YesRunTest NoRunTestDiffOpts withIndex lookForAddslookForReplaces lookForMovesdiffAlg LookForMovesYesLookForMovesNoLookForMovesLookForReplacesYesLookForReplacesNoLookForReplaces LookForAdds NoLookForAddsYesLookForAddsEvenLookForBoringUMaskYesUMaskNoUMaskDryRun YesDryRunNoDryRunUseCache YesUseCache NoUseCache UpdatePendingYesUpdatePendingNoUpdatePendingReorder NoReorder RemoteDarcsDefaultRemoteDarcsWithPatchIndex YesPatchIndex NoPatchIndex VerbosityQuietNormalVerbosityVerbose remoteDarcs$fEqOptimizeDeep$fShowOptimizeDeep$fEqWithPrefsTemplates$fShowWithPrefsTemplates$fEqPatchFormat$fShowPatchFormat$fEqForgetParent$fShowForgetParent$fEqWithWorkingDir$fShowWithWorkingDir$fEqWantGuiPause$fShowWantGuiPause $fEqWorkRepo$fShowWorkRepo$fEqAllowConflicts$fShowAllowConflicts$fEqResolveConflicts$fShowResolveConflicts $fEqCloneKind$fShowCloneKind$fShowDiffOpts $fEqUseIndex$fShowUseIndex$fEqInheritDefault$fShowInheritDefault$fEqSetDefault$fShowSetDefault$fEqLeaveTestDir$fShowLeaveTestDir$fEqSetScriptsExecutable$fShowSetScriptsExecutable $fEqRunTest $fShowRunTest$fEqLookForMoves$fShowLookForMoves$fEqLookForReplaces$fShowLookForReplaces$fEqLookForAdds$fShowLookForAdds $fEqUMask $fShowUMask $fEqDryRun $fShowDryRun $fEqUseCache$fShowUseCache$fEqUpdatePending$fShowUpdatePending $fEqReorder$fEqRemoteDarcs$fShowRemoteDarcs$fEqWithPatchIndex$fShowWithPatchIndex $fEqVerbosity$fShowVerbosity ComponentGraph VertexSetVertexltmisbkmis genGraphs genComponents componentsprop_ltmis_eq_bkmis#prop_ltmis_maximal_independent_sets'prop_ltmis_all_maximal_independent_setsprop_components$fShowComponentCachable UncachableMaxAge copyRemotecopyRemoteLazyspeculateRemotepostUrl$fShowCachable $fEqCachableSHA1HashSHA256 decodeHash encodeHash encodeBase16 decodeBase16sha256 sha256sum sha256strictrawHashmkHashmatchshowHashsha1Xorsha1zero sha1shortsha1PS showAsHexsha1Readsha1Show $fBinarySHA1 $fShowSHA1$fEqSHA1 $fOrdSHA1 $fShowHash$fEqHash $fOrdHash $fReadHashReaderT runReaderT MonadReaderasklocalLiftIxliftIx ifThenElsewhenasks$fMonadReaderrReaderT$fMonadReaderT MCalendarTimemctYearmctMonthmctDaymctHourmctMinmctSec mctPicosecmctWDaymctYDay mctTZNamemctTZmctIsDSTmctWeek TimeInterval readUTCDatecleanLocalDate getLocalTzreadUTCDateOldFashioned parseDateshowIsoDateTimegetIsoDateTimeiso8601Intervaliso8601DurationenglishDateTimeenglishInterval englishLast theBeginningtoMCalendarTimeunsafeToCalendarTime addToMCalsubtractFromMCal resetCalendar unsetTime$fShowMCalendarTime DateMatcherDMparseDateMatcher getMatcherstestDate testDateAtwithPathparseAllparselexWordlexChar lexStringcharstringintunsigned takeTillChar checkConsumeslinesStartingWithlinesStartingWithEndingWithColorBlueRedGreenCyanMagentaPrinter Printers'PrinterscolorP invisiblePhiddenP userchunkPdefP lineColorT lineColorSDocunDoc PrintableSPSBothspacenewlineminusplus backslashlparenrparenparenssentencepathlist putDocWith putDocLnWithputDocputDocLn hPutDocWith hPutDocLnWithhPutDoc hPutDocLn hPutDocCompr debugDocLn renderStringrenderStringWithrenderPS renderPSs renderPSWith renderPSsWithprefix prefixLinesinsertBeforeLastline lineColor hiddenPrefix unsafeBothunsafeBothText packedStringunsafePackedString invisiblePS userchunkPS unsafeChartext unsafeText invisibleText hiddenText userchunkblueTextredText greenText magentaTextcyanText colorTextwrapText formatText formatWords printableinvisiblePrintablehiddenPrintableuserchunkPrintablesimplePrinters simplePrinterinvisiblePrinteremptydoc<+>$$$+$vcatvsephcathsepquoted $fMonoidDoc$fSemigroupDoc $fIsStringDocThisPronounItNoun Countablepluralsingular englishNum andClauses orClauses anyOfClauseitemizeVerticalitemizepresentParticiple capitalize$fCountableNoun$fCountablePronoun$fCountableThis formatHeader makeEmail readEmailprop_qp_roundtrip ePutDocLntraceDocunsafeRenderStringColored fancyPrintersenvironmentHelpColorenvironmentHelpEscapeWhiteenvironmentHelpEscape withProgresswithSizedProgress beginTedious endTedious tediousSizeminlist progressListprogressprogressKeepLatest finishedOne finishedOneIOsetProgressModewithoutProgress ExecExceptionRedirectAsIsNullFileStdout RedirectsrenderExecExceptionexecexecInteractivewithoutNonBlockreadInteractiveProcess$fShowExecException$fExceptionExecException$fShowRedirect PromptConfigpPromptpBasicCharacterspAdvancedCharacterspDefaultpHelpaskUseraskEnteraskUserListItem promptYorn promptCharpVerbpChoices PromptChoicepcKeypcWhenpcActionpcHelp runPromptmkRegexmkRegexWithOpts matchRegex$fMonadFailRegexFail$fFunctorRegexFail$fApplicativeRegexFail$fMonadRegexFailappPrecShow2 showDict2Show1 showDict1 showsPrec1show1 showsPrec2show2showOp2GapemptyGapfreeGapjoinGap FreeRightFreeLeftDup FlippedSealSealed2Sealedsealseal2flipSealunsealmapSeal mapFlippedunseal2mapSeal2 unsealFlipped unFreeLeft unFreeRight $fShowSealed $fEqSealed $fShowSealed2$fGapFreeRight $fGapFreeLeft:||:Fork:/\::\/:RL:<:NilRLFL:>:NilFL:>nullFLnullRL filterOutFLFL filterOutRLRLfilterRL+>++<+ reverseFL reverseRLconcatFLconcatRLspanFLspanFL_M splitAtFL splitAtRLbunchFLfoldFL_MfoldRL_MallFLanyFLallRLanyRLfoldrFLfoldlRLfoldrwFLfoldlwRLfoldlwFLfoldrwRLmapFL_FL mapFL_FL_M sequenceFL_ zipWithFLmapRL_RLmapFLfilterFLmapRLlengthFLlengthRLisShorterThanRL consGapFL joinGapsFL concatGapsFL dropWhileFL dropWhileRL takeWhileRLspanRLbreakRL+>>++<<+initsFL concatRLFL $fShow2:>$fEq:>$fEq2:>$fShow:> $fShow1:>$fEq2FL $fShow2FL $fShow1FL$fShowFL$fEq2RL $fShow2RL $fShow1RL$fShowRL $fShow2:\/: $fShow:\/: $fShow2:/\: $fShow:/\:FZipper flToZippernullFZlengthFZfocusclownsjokers rightmostrightleftmostlefttoEndtoStartMaybe2Nothing2Just2 maybeToFL maybeToRLmapMB_MB PushFixupFn dropFixupspushFixupFLFL_FLFLFLpushFixupFLFL_FLFLFLFLpushFixupFLMB_FLFLMBpushFixupIdFL_FLFLFLpushFixupIdMB_FLFLMBpushFixupIdMB_FLIdFLFLInvertinvertinvertFLinvertRL $fInvert:> $fInvertRL $fInvertFL PatchDebugpatchDebugDummy$fPatchDebugRL$fPatchDebugFLPartialMergeFnMergeFnTotalCommuteFn CommuteFn commuterIdRL commuterIdFL mergerIdFLtotalCommuterIdFL commuterFLId commuterRLId commuterRLFLtotalCommuterFLIdtotalCommuterFLFLinvertCommuterCommutecommute commuteRLFL commuteRL commuteFL selfCommuter $fCommuteRL $fCommuteFLMergemerge CleanMerge cleanMerge cleanMergeFL selfMergermergeFL mergerFLId mergerFLFL swapMerge swapMergerswapCleanMerge mergeListprop_mergeSymmetricprop_mergeCommute$fCleanMergeFL $fMergeFL partitionFL partitionFL' partitionRL' partitionRLcommuteWhatWeCanFLgenCommuteWhatWeCanFLcommuteWhatWeCanRLgenCommuteWhatWeCanRL removeCommonremoveFLremoveRLremoveSubsequenceFLremoveSubsequenceRLsimpleHeadPermutationsFLheadPermutationsFLheadPermutationsRLpermutationsRL=\~/==/~\=nubFLpartitionConflictingFLCommuteNoConflictscommuteNoConflictsmergeNoConflicts SshFilePathsshUhostsshReposshFile isRelative isAbsoluteisValidLocalPath isHttpUrlisSshUrl isSshNopath splitSshUrl sshFilePathOf sshCanonRepo PristineHash PatchHash InventoryHash ValidHashdirofValidHash calcValidHash HashedDirHashedPristineDirHashedPatchesDirHashedInventoriesDirencodeValidHashdecodeValidHashparseValidHashgetHashgetSizefromHashfromSizeAndHashokayHash checkHash$fIsSizeHashSizeHash$fValidHashPristineHash$fValidHashPatchHash$fValidHashInventoryHash$fEqInventoryHash$fShowInventoryHash$fIsSizeHashInventoryHash $fEqPatchHash$fShowPatchHash$fIsSizeHashPatchHash$fEqPristineHash$fShowPristineHash$fIsSizeHashPristineHash $fEqSizeHash$fShowSizeHash $fEqHashedDir setExecutable stdoutIsAPipewithSignalsHandledcatchNonSignalcatchInterrupt tryNonSignalwithSignalsBlocked$fExceptionSignalException$fShowSignalExceptioncatchall firstJustIO clarifyErrorsprettyException prettyErrordiehandleOnlyIOErrorhandleDoesNotExistErrorcatchDoesNotExistError ifIOErrorifDoesNotExistError handleOnlySSHCmdSSHSCPSFTP SshSettingssshscpsftpwindows defaultSshresetSshConnectionscopySSHtransferModeHeadergetSSHenvironmentHelpSshenvironmentHelpScpenvironmentHelpSshPort$fShowSshSettings$fEqSshSettings maybeRelinksloppyAtomicCreate atomicCreate AnchoredPathNameAbsoluteOrRemotePathAbsolutePathOrStdSubPath FilePathLike toFilePath FilePathOrURLtoPath displayPathrealPath encodeWhite decodeWhite makeSubPathOf simpleSubPath ioAbsolutemakeRelativeTo makeAbsolutemakeAbsoluteOrStdstdOutioAbsoluteOrStduseAbsoluteOrStdioAbsoluteOrRemoteisRemotesetCurrentDirectorygetUniquePathNameisPrefix appendPathcatPathsparentparents anchorPathname2fpflattenmakeNameunsafeFloatPath floatPath anchoredRoot replaceParent rawMakeName eqAnycaseencodeWhiteNamedecodeWhiteNamemovedirfilename filterPaths floatSubPath inDarcsdir darcsdirNameisRoot$fFilePathOrURLList$fFilePathLikeList $fShowSubPath$fFilePathLikeSubPath$fFilePathOrURLSubPath$fShowAbsolutePath$fFilePathLikeAbsolutePath$fFilePathOrURLAbsolutePath$fShowAbsolutePathOrStd$fShowAbsoluteOrRemotePath#$fFilePathOrURLAbsoluteOrRemotePath$fBinaryAnchoredPath$fEqAnchoredPath$fShowAnchoredPath$fOrdAnchoredPath $fBinaryName$fEqName $fShowName $fOrdName$fEqAbsoluteOrRemotePath$fOrdAbsoluteOrRemotePath$fEqAbsolutePathOrStd$fOrdAbsolutePathOrStd$fEqAbsolutePath$fOrdAbsolutePath $fEqSubPath $fOrdSubPath FilterTreeTreeitemstreeHashItemTypeTreeTypeBlobTypeTreeItemSubTreeStubBlob listImmediateitemHashitemType emptyTree emptyBlobmakeBlob makeBlobBSmakeTreemakeTreeWithHashlookupfindfindFilefindTreelistlocateisDirtreeHasAnycasetreeHas treeHasDir treeHasFile explodePaths explodePath expandUpdateexpand expandPath checkExpandrestrictreadBlobzipCommonFileszipFileszipTrees diffTrees modifyTreeupdateSubtrees updateTreepartiallyUpdateTreeoverlayaddMissingHashesprop_explodePath$fFilterTreeTreem$fShowItemType $fEqItemType $fOrdItemType readPlainTreewritePlainTreeTreeIO TreeMonad TreeStatetree runTreeMonadvirtualTreeMonad virtualTreeIO fileExistsdirectoryExistsexistscreateDirectoryunlinkrenamecopyfindM findTreeM findFileM getFileStatusdoesDirectoryReallyExistremoveFileMayNotExistgetRecursiveContentsgetRecursiveContentsFullPath copyFileOrUrlcopyTreebackupByRenamingbackupByCopying fetchFilePSfetchFileLazyPS gzFetchFilePSspeculateFileOrUrlwithTemp withOpenTempwithLockwithLockCanFailenvironmentHelpLocks tempdirLocenvironmentHelpTmpdirenvironmentHelpKeepTmpdir withPermDir withTempDirwithDelayedDir withNamedTemp readBinFile readTextFilereadDocBinFile appendBinFileappendTextFileappendDocBinFile writeBinFile writeTextFilewriteDocBinFilewriteAtomicFilePSgzWriteAtomicFilePSgzWriteAtomicFilePSsgzWriteDocFile addToErrorLocwithNewDirectoryCacheCacheLoc cacheType cacheWritable cacheSource CacheTypeRepo Directory WritableOrNotWritable NotWritable hashedDir allHashedDirsmkCache mkDirCache mkRepoCache cacheEntries showCacheLoc parseCacheLocfilterRemoteCachesfetchFileUsingCachewritable dropNonReposclosestWritableDirectory isThisRepo bucketFolderhashedFilePath peekInCachespeculateFileUsingCachespeculateFilesUsingCachewriteFileUsingCache cleanCachescleanCachesWithHintreportBadSources $fEqCacheLoc $fShowCache $fEqFromWhere$fEqOrOnlySpeculate$fShowOrOnlySpeculate $fEqCacheType$fShowCacheType$fEqWritableOrNot$fShowWritableOrNot darcsTreeHashdarcsUpdateHashesdarcsAddMissingHashesreadDarcsHashedreadDarcsHashedNosizewriteDarcsHashed hashedTreeIOfollowPristineHashes IndexEntryieSizeieAuxieFileIDieHashieTypeiePathIndex listFileIDs openIndexupdateIndexFrom treeFromIndexindexFormatValid getFileIDalign dumpIndex$fFilterTreeIndexMIO$fShowCorruptIndex$fExceptionCorruptIndex$fEqCorruptIndex $fShowItemmakeDarcsdirPathlockPathprefsDir prefsDirPathhashedInventoryhashedInventoryPathtentativeHashedInventorytentativeHashedInventoryPathinventoriesDirinventoriesDirPathtentativePristinePath pristineDirpristineDirPath patchesDirpatchesDirPath indexPathindexInvalidPath rebasePathtentativeRebasePath formatPath pendingPathtentativePendingPathnewPendingPath unrevertPathtentativeUnrevertPatholdPristineDirPatholdCurrentDirPatholdCheckpointDirPatholdInventoryPatholdTentativeInventoryPath RepoFormatRF RepoPropertyDarcs1Darcs2Darcs3HashedInventoryRebaseInProgressRebaseInProgress_2_16 UnknownFormat formatHas addToFormatremoveFromFormatidentifyRepoFormattryIdentifyRepoFormatunsafeWriteRepoFormatcreateRepoFormat writeProblemtransferProblem readProblem$fShowRepoProperty$fShowRepoFormat$fEqRepoProperty ExactVersion ListCommandsHelp ListOptionsNoTestTestOnlyChangesToFilesChangesToAllFilesTimingsDebug DebugHTTPToCcOutputOutputAutoNameMailSubject InReplyToCharset SendmailCmdAuthor SelectAuthor PatchNameOnePatch SeveralPatch AfterPatch UpToPatch OnePatternSeveralPattern AfterPattern UpToPatternOneHash AfterHashUpToHashOneTag SeveralTagAfterTagUpToTagLastNMaxCount IndexRangeOneIndex NumberPatches GenContextContextCountLogFile RmLogFile DontRmLogFileDistNameDistZipAll Recursive NoRecursiveMinimize NoMinimize RestrictPathsDontRestrictPathsAskDeps NoAskDeps IgnoreTimesDontIgnoreTimes UseMyersDiffUsePatienceDiff IntersectionUnion ComplementSignSignAsNoSignSignSSLHappyForwardingNoHappyForwardingVerify VerifySSLRemoteDarcsOptEditDescriptionNoEditDescriptionToksEditLongCommentNoEditLongCommentPromptLongCommentKeepDate NoKeepDate SkipConflictsBoring SkipBoring AllowCaseOnlyDontAllowCaseOnlyAllowWindowsReservedDontAllowWindowsReserved DontGrabDepsDontPromptForDependenciesPromptForDependenciesCompress NoCompress UnCompress WorkRepoUrlNewRepo NotInRemoteReplyApplyAsMachineReadable HumanReadablePipe InteractiveDiffCmdSummary NoSummary PauseForGui NoPauseForGuiUnified NonUnifiedReverseForwardCompleteLazy DiffFlags XMLOutput ForceReplaceNonApply NonVerifyNonForceDisableDontSetScriptsExecutableOnceLinearBackoffBisect ShrinkFailureNoShrinkFailureHashed UseFormat1 UseFormat2 UseFormat3UseNoWorkingDir UseWorkingDirSiblingFilesNoFiles Directories NoDirectoriesPending NoPending PosthookCmd NoPosthook AskPosthook RunPosthook PrehookCmd NoPrehook AskPrehook RunPrehook StoreInMemory ApplyOnDiskNoHTTPPipeliningPacksNoPacksNoCacheAllowUnrelatedReposCheckRepair JustThisRepo ReadMarks WriteMarksNullFlagNoAmendUnrecord AmendUnrecordPatchIndexFlagNoPatchIndexFlag EnumPatches NoEnumPatches $fEqDarcsFlag$fShowDarcsFlag RawOptSpecRawNoArg RawStrArg RawAbsPathArgRawAbsPathOrStdArgRawOptAbsPathArgPrimDarcsOptionFlagnoArgstrArg optStrArg absPathArgabsPathOrStdArg optAbsPathArg withDashes withDefault singleNoArg singleStrArgsingleAbsPathArg multiStrArgmultiOptStrArgmultiAbsPathArg deprecated parseIntArgparseIndexRangeArg showIntArgshowIndexRangeArg$fIsoFunctorRawOptSpec$fShowArgumentParseError$fExceptionArgumentParseError$fEqArgumentParseErroroptionsMarkdownPrefBinaries DefaultrepoDefaultsEmailMotdPostPrefsReposSourcesFileType BinaryFileTextFilewriteDefaultPrefsglobalPrefsDirglobalPrefsDirDocenvironmentHelpHome getGlobalglobalCacheDirisBoring getPrefLinesfiletypeFunction addToPreflist getPreflist setPreflist defPrefval getPrefval setPrefval changePrefvalgetDefaultRepo addRepoSource deleteSources getCachesgetMotdshowMotdprefsUrl prefsFilePathprefsFilesHelp$fEqPref $fOrdPref $fReadPref $fShowPref $fEqFileType Repository SAccessTypeSROSRW AccessTypeRORW PristineType NoPristine PlainPristineHashedPristine repoLocation withRepoDir repoFormatrepoPristineType repoCache modifyCacherepoAccessTypeunsafeCoerceRepoTypeunsafeCoercePatchType unsafeCoerceR unsafeCoerceUunsafeStartTransactionunsafeEndTransactionmkRepomodifyRepoFormat$fEqAccessType$fShowPristineType$fEqPristineTypeSummOpSummAddSummRmSummMod SummDetail SummAddDir SummRmDirSummFileSummMvSummNone$fOrdSummDetail$fEqSummDetail $fOrdSummOp $fEqSummOpObjectIdformatObjectId ObjectIdOfformatFileNameap2fp$fObjectIdAnchoredPath ObjectMap getObject putObject listObjectsObject DirContentLocationLUUID FileContentisBlob isDirectory $fEqLocation$fShowLocation$fEqUUID $fOrdUUID $fShowUUID PatchInspectlistTouchedFiles hunkMatches$fPatchInspectRL$fPatchInspectFLSlotInFirstInMiddleInLast PatchChoices LabelledPatchLabellabel getLabelIntunLabel patchChoices labelPatchesmkPatchChoicesseparateFirstFromMiddleLastseparateFirstMiddleFromLast getChoices refineChoices patchSlotforceMatchingFirst forceFirsts forceFirstselectAllMiddlesforceMatchingLast forceLasts forceLast forceMiddlemakeEverythingLatermakeEverythingSooner substitute$fPatchInspectLabelledPatch$fCommuteLabelledPatch$fInvertLabelledPatch$fPatchInspectPatchChoice$fCommutePatchChoice $fEqLabel ApplyMonad readFilePSApplyMonadTreemDoesDirectoryExistmDoesFileExist mReadFilePSmCreateDirectorymRemoveDirectory mCreateFile mRemoveFilemRename mModifyFilePS mChangePrefApplyMonadOperationsApplyMonadTransApplyMonadOver runApplyMonadevalApplyMonad withFileNames$fApplyMonadTreeRWST$fApplyMonadTreeRWST0$fApplyMonadTransTreem$fMonadThrowPure$fApplyMonadTreeStateT$fApplyMonadTreeStateT0 $fFunctorPure$fApplicativePure $fMonadPure DefaultIO runTolerantly runSilently runDefault$fApplyMonadTreeDefaultIO$fApplyMonadTreeDefaultIO0$fTolerantMonadTolerantIO$fTolerantMonadSilentIO$fApplyMonadTreeTolerantWrapper $fApplyMonadTreeTolerantWrapper0$fFunctorTolerantWrapper$fApplicativeTolerantWrapper$fMonadTolerantWrapper$fTolerantMonadTolerantWrapper$fFunctorSilentIO$fApplicativeSilentIO$fMonadSilentIO$fMonadThrowSilentIO$fFunctorTolerantIO$fApplicativeTolerantIO$fMonadTolerantIO$fMonadThrowTolerantIO$fFunctorDefaultIO$fApplicativeDefaultIO$fMonadDefaultIO$fMonadThrowDefaultIO$fMonadThrowTolerantWrapperObjectIdOfPatchApply ApplyStateapplyunapply effectOnPaths applyToPaths applyToTree applyToStatemaybeApplyToTree $fApplyRL $fApplyFLdeselectNotTouchingselectNotTouchingchooseTouching lookTouch ShowPatchcontent descriptionsummary summaryFLthingthingsShowContextPatchshowPatchWithContextAndApplyShowPatchBasic showPatch ShowPatchFor ForDisplay ForStorage displayPatchshowPatchWithContext PatchInfo_piDate_piName _piAuthor_piLog_piLegacyIsInverted validDate validDatePSvalidLog validLogPS validAuthor validAuthorPS rawPatchInfo patchinfoaddJunk replaceJunkjustName justAuthorjustLogdisplayPatchInfopiNamepiRenamepiAuthorisTagpiDate piDateStringpiLogpiTagtoXml toXmlShort escapeXML makePatchname showPatchInfo readPatchInfo $fEqPatchInfo$fOrdPatchInfo$fShowPatchInfoInventoryEntry InventoryinventoryParentinventoryPatches HeadInventoryinventoryPatchNamesemptyInventoryparseHeadInventoryparseInventory showInventoryshowInventoryPatchesshowInventoryEntrypokePristineHashpeekPristineHashskipPristineHash pristineNameprop_inventoryParseShowprop_peekPokePristineHashprop_skipPokePristineHash $fEqInventory$fShowInventoryPatchIdPIDpatchIdFileIdcnamecount showFileId pid2stringshortzero makePatchID$fBinaryFileId$fBinaryPatchId $fShowPatchId $fOrdPatchId $fEqPatchId $fEqFileId $fShowFileId $fOrdFileId StorableIdreadIdshowId SignedIdentSignedId positiveIdinvertIdIdentident=\^/==/^\= fastRemoveFL fastRemoveRLfastRemoveSubsequenceRL findCommonFLfindCommonWithThemFL findCommonRLfindCommonWithThemRLcommuteToPrefixprop_identInvariantUnderCommute"prop_sameIdentityImpliesCommutableprop_equalImpliesSameIdentityprop_sameIdentityImpliesEqual $fIdent:> $fIdentRL $fIdentFL BracketedFL Bracketed SingletonBracedParens unBracketed unBracketedFL mapBracketedmapBracketedFLFL$fShowPatchBasicBracketed$fPatchListFormatBracketed ReadPatch readPatch'readPatchPartial readPatch bracketedFLpeekfor $fReadPatchRL $fReadPatchFL$fReadPatchBracketed RepairToFLapplyAndTryToFixFLapplyAndTryToFixisInconsistent mapMaybeSnd $fCheckRL $fCheckFL $fRepairFLFileModPTouch PCreateFile PCreateDirPRenamePRemovePDuplicateTouch withPatchModsapplyToFileMods$fApplyMonadTreeFileModMonad$fApplyMonadTreeFileModMonad0$fFunctorFileModMonad$fApplicativeFileModMonad$fMonadFileModMonad$fMonadThrowFileModMonad$fMonadState(,)FileModMonad $fShowFileMod $fEqFileMod$fFunctorFileModIsHunkisHunkFileHunk showFileHunkshowContextFileHunk$fInvertFileHunkshowContextHunk $fShowPatchRL$fShowContextPatchRL$fShowPatchBasicRL $fShowPatchFL$fShowContextPatchFL$fShowPatchBasicFL Contextedprop_ctxInvariantsprop_ctxPositive prop_ctxEqctxId ctxDepends ctxNoConflictctxViewctxToFLctxctxAddctxAddRL ctxAddInvFLctxAddFL commutePast commutePastRL ctxTouchesctxHunkMatchesshowCtxreadCtx$fShow1Contexted$fShowContexted$fOrdContexted $fEqContextedAnnotateannotate AnnotatedM AnnotatedContent Annotated2 annotatedcurrent currentPath currentInfoContent2AnnotateResult$fShowAnnotated2$fEqAnnotated2$fShowContent2 $fEqContent2PrimMangleUnravelledmangleUnravelledMangled Unravelled PrimApply applyPrimFLPrimReadreadPrimPrimShowshowPrimshowPrimWithContextAndApply PrimDetails summarizePrimPrimSiftprimIsSiftable PrimCoalesce tryToShrinksortCoalesceFL primCoalesce isIdentity comparePrim PrimConstructaddfilermfileadddirrmdirmove changeprefhunk tokreplacebinary primFromHunk PrimPatchprimCleanMerge DirPatchTypeRmDirAddDir FilePatchTypeRmFileAddFileHunk TokReplaceBinaryPrimMoveDPFP ChangePref$fInvertFilePatchType$fEq2FilePatchType$fInvertDirPatchType$fEq2DirPatchType$fPrimSiftPrim$fEqPrim $fEq2Prim$fPatchDebugPrim$fPatchInspectPrim $fInvertPrim $fIsHunkPrim$fPrimConstructPrim$fEqDirPatchType$fOrdDirPatchType$fEqFilePatchType$fOrdFilePatchType$fPrimDetailsPrimshowHunk$fPrimShowPrim $fShow1Prim $fShow2Prim$fShowDirPatchType$fShowFilePatchType $fShowPrim$fCleanMergePrim $fCommutePrim$fMonadPlusPerhaps$fAlternativePerhaps$fMonadPerhaps$fApplicativePerhaps$fFunctorPerhaps$fPrimApplyPrim$fRepairToFLPrim $fApplyPrim$fPrimReadPrim$fPrimMangleUnravelledPrimHunkMoveManifest DemanifestIdentityHMH $fEq2Hunk $fShow2Hunk $fShow1Hunk $fEq2HunkMove $fEqHunkMove$fShowHunkMove$fEqHunk $fShowHunk$fReadPatchPrim$fPrimCoalescePrimcoalescewithAnyToMaybesortCoalesceFL2 canonizeFLSplitter applySplitter canonizeSplit rawSplitter noSplitter primSplitterreversePrimSplitter ToFromPrimToPrimtoPrimFromPrimfromAnonymousPrimfromPrim fromPrims PrimPatchBasePrimOf$fPrimPatchBaseRL$fPrimPatchBaseFL RepoPatchV1PPMergerRegremisMerger mergerUndo$fPatchDebugRepoPatchV1$fCheckRepoPatchV1$fPatchListFormatRepoPatchV1$fToPrimRepoPatchV1$fFromPrimRepoPatchV1$fPrimPatchBaseRepoPatchV1$fShow2RepoPatchV1$fShow1RepoPatchV1$fShowRepoPatchV1 showPatch_$fShowPatchBasicRepoPatchV1Unwind fullUnwindUnwound mkUnwound squashUnwound$fInvertUnwound$fShowPatchBasicUnwound$fShow2Unwound$fShow1Unwound $fShowUnwoundconflictedEffect ConflictStateOkay Conflicted DuplicatedIsConflictedPrimIsClistConflictedFilesplainSummaryPrimplainSummaryPrims plainSummaryplainSummaryFL xmlSummary$fShowIsConflictedPrim $fSummaryFL$fOrdSummChunk $fEqSummChunk$fEqConflictState$fOrdConflictState$fShowConflictState$fReadConflictState displayHunk$fShowPatchPrim$fShowContextPatchPrim$fShowPatchBasicPrim$fPatchListFormatPrimhunkEdit$fApplyMonadTransObjectMapm$fApplyMonadObjectMapStateT$fApplyMonadObjectMapStateT0Effecteffect $fEffectRL $fEffectFLNonablenonNonunNonshowNonsshowNonreadNonsreadNoncommuteOrAddToCtxcommuteOrAddToCtxRLcommutePrimsOrAddToCtxremNonscommuteOrRemFromCtxcommuteOrRemFromCtxFL>**>>>>*$fEqNon $fShow1Non $fShowNon$fWLRL$fWLFLConflict isConflictedresolveConflictsConflictDetailsconflictMangled conflictParts mangleOrFailcombineConflictsfindConflicting RepoPatchV2 Duplicate EtacilpudNormal Conflictor InvConflictor isDuplicate isForwardmergeUnravelled isConsistent$fIsHunkRepoPatchV2$fEffectRepoPatchV2$fNonableRepoPatchV2$fShow2RepoPatchV2$fShow1RepoPatchV2$fShowRepoPatchV2$fReadPatchRepoPatchV2$fShowPatchRepoPatchV2$fShowContextPatchRepoPatchV2$fShowPatchBasicRepoPatchV2$fPatchListFormatRepoPatchV2$fRepairToFLRepoPatchV2$fApplyRepoPatchV2$fPatchInspectRepoPatchV2$fCleanMergeRepoPatchV2$fCommuteRepoPatchV2$fInvertRepoPatchV2$fEq2RepoPatchV2$fToPrimRepoPatchV2$fFromPrimRepoPatchV2$fCheckRepoPatchV2$fCommuteNoConflictsRepoPatchV2$fUnwindRepoPatchV2$fConflictRepoPatchV2$fSummaryRepoPatchV2$fPatchDebugRepoPatchV2$fPrimPatchBaseRepoPatchV2$fMergeRepoPatchV2 publicUnravelunravelmerger$fEqRepoPatchV1$fEq2RepoPatchV1$fInvertRepoPatchV1$fIsHunkRepoPatchV1$fEffectRepoPatchV1$fSummaryRepoPatchV1$fUnwindRepoPatchV1$fConflictRepoPatchV1$fCommuteNoConflictsRepoPatchV1$fPatchInspectRepoPatchV1$fCommuteRepoPatchV1$fMergeRepoPatchV1$fCleanMergeRepoPatchV1$fReadPatchRepoPatchV1$fRepairToFLRepoPatchV1$fApplyRepoPatchV1$fShowPatchRepoPatchV1$fShowContextPatchRepoPatchV1 ShowWhichDepsShowNormalDepsShowDroppedDepsShowDepsFormatShowDepsVerboseShowDepsSummaryHasDepsgetdepsNamedP anonymous infopatchadddepssetinfopatch2patchinfo patchname patchcontents fmapNamed fmapFL_Named mergerIdNamedshowDependencies$fPatchDebugNamed $fShow2Named $fShow1Named$fShowContextPatchNamed$fShowPatchBasicNamed $fCheckNamed$fSummaryNamed$fPatchInspectNamed $fUnwindNamed$fConflictNamed $fMergeNamed$fCleanMergeNamed$fCommuteNamed $fEq2Named $fRepairNamed $fApplyNamed$fReadPatchNamed$fPatchListFormatNamed $fIsHunkNamed $fIdentNamed $fEffectNamed$fPrimPatchBaseNamed$fHasDepsNamed$fShowPatchNamed$fEqShowWhichDeps$fEqShowDepsFormat $fShowNamed RebaseNameAddNameDelNameRenamecommuteNamePrimcommutePrimNamecommuterIdNamedcommuterNamedIdcommuteNameNamedcommuteNamedName pushFixupName$fEq2RebaseName$fPatchInspectRebaseName$fInvertRebaseName$fCommuteRebaseName$fReadPatchRebaseName$fShowPatchRebaseName$fShowPatchBasicRebaseName$fShow2RebaseName$fShow1RebaseName$fEqRebaseName$fShowRebaseName RebaseFixup PrimFixup NameFixup namedToFixupspushFixupFixupflToNamesPrimscommuteNamedFixupcommuteFixupNamed$fCommuteRebaseFixup$fReadPatchRebaseFixup$fShowPatchBasicRebaseFixup$fPatchListFormatRebaseFixup$fPatchInspectRebaseFixup$fInvertRebaseFixup$fApplyRebaseFixup$fPrimPatchBaseRebaseFixup$fShow2RebaseFixup$fShow1RebaseFixup$fShowRebaseFixup PatchInfoAndG PatchInfoAnd Hopefullyinfo patchDescpiapn2piapatchInfoAndPatch fmapFLPIAPfmapPIAP hopefully hopefullyMactually createHashed extractHash unavailable$fEq2SimpleHopefully$fEq2Hopefully$fPatchDebugPatchInfoAndG$fIsHunkPatchInfoAndG$fEffectPatchInfoAndG$fReadPatchPatchInfoAndG$fApplyPatchInfoAndG$fPatchInspectPatchInfoAndG$fMergePatchInfoAndG$fCleanMergePatchInfoAndG$fCommutePatchInfoAndG$fShowPatchPatchInfoAndG$fShowContextPatchPatchInfoAndG$fShowPatchBasicPatchInfoAndG$fPatchListFormatPatchInfoAndG$fIdentPatchInfoAndG$fEq2PatchInfoAndG$fPrimPatchBasePatchInfoAndG$fConflictPatchInfoAndG$fRepairPatchInfoAndG$fShow2PatchInfoAndG$fShow1PatchInfoAndG$fShowPatchNotAvailable$fExceptionPatchNotAvailable$fShowPatchInfoAndG$fShowHopefully$fShowSimpleHopefullyTaggedPatchSetSealedPatchSetOrigin emptyPatchSet patchSet2RL patchSet2FL appendPSFLprogressPatchSetpatchSetInventoryHashes patchSetTags inOrderTags patchSetSnoc patchSetSplit patchSetDrop $fShow2Tagged $fShow1Tagged$fIdentPatchSet$fShow2PatchSet$fShow1PatchSet $fShowTagged$fShowPatchSet progressFL progressRLprogressRLShowTags splitOnTagcleanLatestTagfullyOptimizePatchSet getUncoveredslightlyOptimizePatchsetremoveFromPatchSet findCommonfindCommonWithThem findUncommon countUsThem patchSetMergepatchSetIntersection patchSetUnionareUnrelatedReposcontextPatches AnnotateRP annotateFileannotateDirectory machineFormatformat$fAnnotatePrim$fAnnotatePrim0$fShowFileOrDirectory$fEqFileOrDirectoryunPrim RepoPatch mkInvertiblefromPositiveInvertiblewithInvertible$fPatchListFormatInvertible$fShowContextPatchInvertible$fShowPatchInvertible$fShowPatchBasicInvertible$fPrimPatchBaseInvertible$fPatchInspectInvertible$fApplyInvertible$fEq2Invertible$fCommuteInvertible$fInvertInvertible$fIdentInvertible$fSignedIdInvertibleId$fEqInvertibleId$fOrdInvertibleIdBundleinterpretBundle makeBundle parseBundlereadContextFile minContextfinalizeTentativeUnrevertrevertTentativeUnrevert writeUnrevert readUnrevertremoveFromUnrevertContext readPendingreadTentativePendingwriteTentativePendingtentativelyRemoveFromPWfinalizePending revertPendingsetTentativePendingsiftForPending$fShowPatchBasicFLM$fReadPatchFLM PatchFilterdoesPatchIndexExistisPatchIndexDisabledcreateOrUpdatePatchIndexDiskcanUsePatchIndexcreatePIWithInterruptisPatchIndexInSyncdeletePatchIndexattemptCreatePatchIndexgetRelevantSubsequencemaybeFilterPatchesdumpPatchIndexpiTest$fShowFileInfo $fEqFileInfo $fOrdFileInfo$fShowFilePathSpan$fEqFilePathSpan$fOrdFilePathSpan$fShowFileIdSpan$fEqFileIdSpan$fOrdFileIdSpan readOldRepooldRepoFailMsgreadPatchesFromInventoryFilereadPatchesFromInventoryreadSinglePatchreadOneInventorywriteInventory writeHashFilecleanRepositorycleanPristineDirspecialPatcheslistInventorieslistInventoriesRepoDirlistPatchesLocalBucketedconvertSizePrefixedPristineapplyToTentativePristinereadHashedPristineRootcreatePristineDirectoryTree readPristine writePristinetreeDiff TreeFilterapplyTreeFilterrestrictSubpathsrestrictBoringrestrictDarcsdirunrecordedChangesreadPendingAndWorkingreadUnrecordedreadUnrecordedFiltered readWorkingreadPristineAndPending readIndex updateIndexfilterOutConflictsunsafeAddToPending addToPendingStandardResolutionmangled unmangledconflictedPathsstandardResolutionrebaseResolution warnUnmangled showUnmangledshowUnravelledannounceConflictsexternalResolutionpatchsetConflictResolutions PatchSetMatch IndexMatch PatchMatchTagMatch ContextMatch MatchFlag MatchableRP MatchablehelpOnMatchershaveNonrangeMatch patchSetMatch firstMatch secondMatchcheckMatchSyntax matchAPatch hasIndexRangematchFirstPatchsetmatchSecondPatchset splitSecondFLmatchAPatchsetgetMatchingTagrollbackToPatchSetMatch matchingHead $fShowMatcher$fShowMatchFailure$fExceptionMatchFailure$fShowMatchFlag matchUpToOnematchOneContextmatchOneNontag matchSeveral matchLastmatchSeveralOrFirstmatchSeveralOrLastmatchOneOrRange matchRangematchSeveralOrRange matchFrommatchAnycontext GzcrcsAction GzcrcsCheck GzcrcsRepair TestStrategy ChangesFormatGenXml CountPatches WithSummary YesSummary Compression NoCompressionGzipCompressionNoVerify VerifyKeyring HeaderFields_to_cc_from_subject _inReplyTo TestChanges NoTestChangesYesTestChanges ExternalDiffdiffCmd diffOptions diffUnified WithContext NoContext YesContextLogfile_logfile _rmlogfileAskLongCommentYesEditLongCommentRepoCombinatorNotInDefaultRepoNotInRemotePath SelectDepsNoDepsAutoDeps PromptDeps XmlOutputNoXmlYesXml HookConfigcmdprompt HooksConfigprepost StdCmdAction RootActionRootHelpYesEnumPatchesYesNoyesno DarcsOption rootActions stdCmdActionsdebug verbositytimings debugginghookspreHookpostHookuseCache xmlOutputdryRun dryRunXmlpipe interactive pauseForGuiaskDeps selectDepschangesReversemaxCountrepoDirnewRepopossiblyRemoteReponotInRemoteFlagName notInRemoterepoCombinatorallowUnrelatedRepos justThisRepowithWorkingDir setDefaultinheritDefaultwithPrefsTemplatesauthoraskLongCommentkeepDatelogfile lookforaddsmaybelookforaddslookforreplaces lookformovesuseIndex includeBoringallowProblematicFilenamesallowCaseDifferingFilenamesallowWindowsReservedFilenames onlyToFiles recursive diffAlgorithm withContextextDiff testChanges leaveTestDir headerFields sendToContextmail sendmailCmdminimizecharseteditDescriptionapplyAssignverify conflictsNo conflictsYesreorder reorderPushcompressusePacks patchIndexNo patchIndexYes storeInMemory optimizeDeepoutput withSummary maybeSummaryumasksetScriptsExecutable amendUnrecord selectAuthormachineReadable cloneKindmarks readMarks writeMarkshashed patchFormatdistnamedistzip changesFormattokens forceReplace testStrategy shrinkFailurefiles directoriespendingnullFlag enumPatches gzcrcsActionssiblings$fYesNoWithPrefsTemplates$fYesNoInheritDefault$fYesNoWithWorkingDir$fYesNoWantGuiPause$fYesNoUseIndex$fYesNoLeaveTestDir$fYesNoSetScriptsExecutable$fYesNoRunTest$fYesNoLookForMoves$fYesNoLookForReplaces$fYesNoLookForAdds $fYesNoDryRun$fYesNoUseCache$fYesNoReorder$fYesNoWithPatchIndex$fYesNoEnumPatches$fYesNoXmlOutput$fYesNoWithContext$fYesNoCompression$fYesNoWithSummary$fEqGzcrcsAction$fShowGzcrcsAction$fEqShrinkFailure$fShowShrinkFailure$fEqTestStrategy$fShowTestStrategy$fEqChangesFormat$fShowChangesFormat$fEqWithSummary$fShowWithSummary $fEqOutput $fShowOutput$fEqCompression$fShowCompression $fEqVerify $fShowVerify$fEqSign $fShowSign$fEqTestChanges$fEqExternalDiff$fShowExternalDiff$fEqWithContext$fShowWithContext$fEqAskLongComment$fShowAskLongComment$fEqRepoCombinator$fShowRepoCombinator$fEqSelectDeps$fShowSelectDeps $fEqXmlOutput$fShowXmlOutput$fEqStdCmdAction$fShowStdCmdAction$fEqRootAction$fShowRootAction$fEqEnumPatches$fShowEnumPatches runPosthook runPrehookConfigoptDescrverbosequietenumeratePatches diffingOpts wantGuiPause isInteractivewillRemoveLogFileallowConflictsfixUrl pathsFromArgspathSetFromArgs getRepourlfileHelpAuthorenvironmentHelpEmail getAuthor promptAuthor getEasyAuthorgetDateenvironmentHelpSendmailgetSendmailCmd getOutput getSubjectgetCc getInReplyTo hasXmlOutput hasLogfileworkRepo withNewRepo diffProgram darcsProgrampipeDoc pipeDocSSH sendEmail generateEmailcheckDefaultSendmail sendEmailDoc execDocPipe signStringverifyPSviewDoc viewDocWitheditTexteditFilesetDarcsEncodings printFriendlyshowWithSummary printSummary printContentprintContentWithPagercontextualPrintPatchWithPagerKeyPresskpkpHelpInteractiveSelectionMInteractiveSelectionStateISCtotallpschoicesSelectionConfig allowSkipAllPatchSelectionOptions matchFlags WhichChangesLast LastReversedFirst FirstReversedselectionConfigPrimselectionConfigselectionConfigGeneric runSelectionrunInvertibleSelection viewChangeshelpForkeysForwithSelectedPatchFromListinitialSelectionState currentPatch currentFiledecidedecideWholeFileskipOnebackOnebackAll isSingleFile promptUser skipMundaneaskAboutDepends$fEqWhichChanges$fShowWhichChangesPatchHeaderConfig AskAboutDepsNoAskAboutDepsHijackT HijackOptions IgnoreHijackRequestHijackPermissionAlwaysRequestHijackPermissiongetLogeditLog runHijackTpatchHeaderConfigupdatePatchHeaderMarks emptyMarkslastMarkgetMarkaddMark patchHash updatePending PrimWithNamewnNamewnPatch$fShowContextPatchPrimWithName$fShowPatchPrimWithName$fShowPatchBasicPrimWithName$fReadPatchPrimWithName$fCleanMergePrimWithName$fCommutePrimWithName$fPrimDetailsPrimWithName$fPrimApplyPrimWithName$fIsHunkPrimWithName$fAnnotatePrimWithName$fRepairToFLPrimWithName$fPatchListFormatPrimWithName$fApplyPrimWithName$fShow2PrimWithName$fShow1PrimWithName$fShowPrimWithName$fPatchInspectPrimWithName$fInvertPrimWithName$fEq2PrimWithName$fIdentPrimWithName RepoPatchV3 ConflictorPPrimP+|-|$fShowPatchBasicRepoPatchV3$fReadPatchRepoPatchV3$fShowContextPatchRepoPatchV3$fShowPatchRepoPatchV3$fRepairToFLRepoPatchV3$fCheckRepoPatchV3$fUnwindRepoPatchV3$fSummaryRepoPatchV3$fIsHunkRepoPatchV3$fPatchListFormatRepoPatchV3$fApplyRepoPatchV3$fPatchDebugRepoPatchV3$fToPrimRepoPatchV3$fPrimPatchBaseRepoPatchV3$fShow2RepoPatchV3$fShow1RepoPatchV3$fShowRepoPatchV3$fEq2RepoPatchV3$fPatchInspectRepoPatchV3$fCommuteRepoPatchV3$fCommuteNoConflictsRepoPatchV3$fMergeRepoPatchV3$fCleanMergeRepoPatchV3$fIdentRepoPatchV3$fEffectRepoPatchV3$fConflictRepoPatchV3 NamedPrim PrimPatchIdunsafePrimPatchIdprop_primPatchIdNonZeropositivePrimPatchIds namedPrimanonymousNamedPrim$fStorableIdPrimPatchId$fSignedIdPrimPatchId$fEqPrimPatchId$fOrdPrimPatchId$fShowPrimPatchId$fFromPrimRepoPatchV3WDDNamedWithDroppedDepswddPatch wddDependedOn RebaseChangeRCrcToPiapartitionUnconflicted simplifyPushsimplifyPushes commuterIdWDDextractRebaseChangereifyRebaseChangeaddNamedToRebase$fPatchListFormatRebaseChange$fIsHunkRebaseChange$fPatchInspectRebaseChange$fCommuteRebaseChange$fReadPatchRebaseChange$fShowContextPatchRebaseChange$fShowPatchRebaseChange$fShowPatchBasicRebaseChange$fSummaryRebaseChange$fApplyRebaseChange$fIdentRebaseChange$fHasDepsRebaseChange$fPatchDebugRebaseChange$fPrimPatchBaseRebaseChange$fShow2RebaseChange$fShow1RebaseChange$fEffectWithDroppedDeps$fPrimPatchBaseWithDroppedDeps$fShowRebaseChange RebaseItemToEditFixuptoRebaseChanges$fReadPatchRebaseItem$fShow2RebaseItem$fShow1RebaseItem$fShowRebaseItem SuspendedItems showSuspended readSuspended countToEditaddFixupsToSuspendedremoveFixupsFromSuspendedaddToEditsToSuspended$fShowSuspended WrappedNamedNormalPRebaseP fromRebasing$fReadPatchReadRebasing$fPatchListFormatReadRebasing$fReadPatchWrappedNamedwithManualRebaseUpdatecheckOldStyleRebaseStatuscheckHasRebasedisplayRebaseStatusupdateRebaseFormatwithTentativeRebasereadTentativeRebasewriteTentativeRebase readRebaserevertTentativeRebasefinalizeTentativeRebaseextractOldStyleRebaseUpdatePristineDontUpdatePristineDontUpdatePristineNorRevertrevertTentativeChangesfinalizeTentativeChangesaddToTentativeInventoryreadTentativePatchescopyHashedInventorywriteAndReadPatchwriteTentativeInventorytentativelyAddPatchtentativelyAddPatchestentativelyAddPatches_tentativelyAddPatch_tentativelyRemovePatchestentativelyRemovePatches_reorderInventory readPatchesrepoXor$fEqUpdatePristinerevertRepositoryChangesfinalizeRepositoryChangesupgradeOldStyleRebaseRepositoryConsistency fixedPristine fixedPatches fixedPendingreplayRepositoryInTempreplayRepository checkIndexpacksDirfetchAndUnpackPatchesfetchAndUnpackBasic createPackstentativelyMergePatchesconsiderMergeToWorking$fEqMakeChangesgetPristineUpToMatchgetOnePatchsetapplyToWorkingsetAllScriptsExecutablesetScriptsExecutablePatchesReadingOrWritingReadingWriting IdentifyRepo BadRepository NonRepositoryGoodRepositorymaybeIdentifyRepositoryidentifyRepositoryidentifyRepositoryForamInRepositoryamInHashedRepositoryseekRepoamNotInRepositoryfindRepositoryIsPrimV1toPrimV1RepoJobV1JobV2Job PrimV1Job OldRebaseJob withUMaskFlagwithRepositoryLocationwithRepository withRepoLockwithOldRepoLockwithRepoLockCanFail$fIsPrimV1Prim$fIsPrimV1Prim0fileArgsunknownFileArgs knownFileArgsmodifiedFileArgsprefArgsnoArgsEmptyRepositorycreateRepositorycreateRepositoryV1createRepositoryV2cloneRepositoryStrategyResultStrategyResultRawNoPassesNoFailureOnHeadBlame RunSuccess RunFailedPatchSeqSingleJoined TestFailureTestResultValidSuccessFailure TestResultTestable Untestable TestRunnerApplyPatchReqsDisplayPatchReqswriteMsg mentionPatch applyPatch unapplyPatchgetCurrentTestResultfinishedTesting TestingDone runTestingEnvexitCodeToTestResult mkTestCmd patchTreeToFL runStrategy runTestableexplanatoryTextFor$fLiftIxTesting$fMonadTesting$fLiftIxTestingEnv$fTestRunnerTestingEnv$fPatchInspectPatchSeq$fApplyPatchSeq$fShow2PatchSeq$fShow1PatchSeq$fShowPatchSeq$fEqStrategyResultRaw$fShowStrategyResultRaw$fFunctorStrategyResultRaw$$fMonadReaderTestingParamsTestingEnv$fMonadTestingEnv CommandArgs CommandOnlySuperCommandOnlySuperCommandSub DarcsCommand SuperCommandcommandProgramName commandName commandHelpcommandDescriptioncommandExtraArgscommandExtraArgHelpcommandCommand commandPrereqcommandCompleteArgscommandArgdefaultscommandOptionscommandSubCommandsCommandControl CommandData HiddenCommand GroupNameextractCommandsextractAllCommands normalCommand hiddenCommand commandGroup withStdOptscommandCheckOptionscommandDefaultscommandAlloptionscommandOptDescr nodefaultsgetSubcommands commandAlias commandStub superNamedisambiguateCommands putVerboseputInfo putFinished putWarningputVerboseWarningabortRunsetEnvDarcsPatchessetEnvDarcsFiles defaultRepousagesubusagegetCommandMiniHelpgetCommandHelpgetSuperCommandHelptestTree announceFilestestTentativeAndMaybeExitprintDryRunMessageAndExitfilterExistingPathsgetUniqueRepositoryNamegetUniqueDPatchNamecheckUnrelatedReposgetLastPatchespreselectPatcheshistoryEditHelpcommonHelpWithPrefsTemplateswhatsnewstatusunrevertunrecordunpull obliterate transferModetesttagshowTagsshowReposhowPatchIndex showIndex showPristine showFilesshowDeps showContentsSpelling showAuthors rankAuthorscanonizeAuthorcompiledAuthorSpellings showCommandsetprefrollbackrevertcleanreplacerepaircheckremovermunaddrecordcommitoptimizemv$fShowFileStatus$fShowFileKind $fEqFileKind markconflicts$fTraversableOnly$fFoldableOnly $fFunctorOnly$fEqOnly $fOrdOnly $fShowOnlylog logInfoFL simpleLogInfo changelogchanges initialize initializeCmd doCRCWarningsgzcrcsdist doFastZip doFastZip' diffCommand convertImport $fShowState $fShowObject$fShowCopyRenameNames $fShowRefId convertExportcleanPatchAuthorcleanPatchAuthorTestCases convertDarcs2convertclonegetput cloneToSSH makeRepoNameotherHelpInheritDefaultsendpushamend amendrecordaddStandardPatchApplier PatchApplierrepoJob applyPatches PatchProxyapplyPatchesStartapplyPatchesFinish"$fPatchApplierStandardPatchApplierfetchpullpullCmd fetchPatchesapplyCmdgetPatchBundlerebase $fPatchApplierRebasePatchAppliercommandControlList applyDefaults runTheCommand runWithHookshelpCmdlistAvailableCommands printVersion unescapeCharsnormalRegChars breakOutTokenFTableData.ByteString.Internal.Type ByteStringmarkColldiffArrcmpseqfindDiagfindOne findSnake findOneRev findSnakeRev nextUnchangedskipOneUnChangednextUnchangedN nextChanged prevUnchangedlcus patientLcslcsHelper&vector-0.13.1.0-3iwp0ZpVFXd2eoMdapVrKn Data.VectorVector neighboursgsizeprop_is_independent_setprop_is_maximal_independent_setprop_is_partitionprop_self_containedprop_connectedprop_connected_component'old-time-1.1.0.4-AMitDc381sTFfBdOk6gZUs System.Time CalendarTimereadDatedateTimecaseCharparsec-3.1.16.1Text.Parsec.Char caseStringmanyNmanyNtoM cvsDateTimeiso8601DateTime oldDateTimerfc2822DateTime iso8601Date iso8601TimeoptchainmySpacesdayNameyearmonthNum intToMonth monthNamedayhourminutesecondzone englishDate englishTime englishAgoenglishDuration multiplyDiff copyCalendar withinDay dateRange cDateRangewithinsamePartialDate tryMatchers testDateAtCal showMatcherDocumentStspacePnewlinePhPrintPrintableshPrintPrintable renderWithsimplePrinters'appendqEncodePolicypoColorpoEscape poLineColor poAltColor poIsprintpo8bitpoNoEscXpoEscX poTrailingpoCRpoSpace getPolicylineColorTransescapenoEscapeisPrintableAscii quoteChar markEscapecolor makeAsciiart resetColor withColorsetColormakeBold makeInvert _progressData RegexFailPoly _forceCommute IsSizeHashSizeHashWithSizecatch firstJustMRepoId Connection detectSshsshConnectionsGHC.MVarMVargetSshConnectionnewSshConnectiondropSshConnectionshowCommandLineord simpleClean pathToPosix normSlashes parentChild sortedUnionDumpItemChanged modifyItem replaceItem flushItem flushSomeSystem.Posix.FilesgetSymbolicLinkStatus removeFile copyLocal copySubTreecopyAndReadFilewithDircompareByLocalitycopyFileUsingCacheOrOnlySpeculate ActuallyCopy OnlySpeculatecheckCacheReachabilityfilterBadSources checkHashedInventoryReachabilityfetchFileUsingCachePrivatenubreadDarcsHashedDirreadDarcsHashed'fsCreateHashedFilenextFresitemF_fileIDschangednexttreeitemresitemState dirlengthpathstartItemindex_endianness_indicator createItempeekItem updateItem mmapIndexnameofmaybeAppendName substateofIndexMiHash' darcs1Format darcs2Format darcs3FormathashedInventoryFormatnoWorkingDirFormatrebaseInProgressFormatrebaseInProgress_2_16newStyleRebaseInProgress findProblemsisKnownSingleArgOptDescr switchNames rawUnparserawParsedefHeadaddDefaultHelpmultiArg osxCacheDir xdgCacheDirtryMakeBoringRegexp boringRegexpsdefaultBinaries PatchChoicepcPatch _pcIsLast pcSetLast pushLastspcsMiddleLastsforceMatchingMiddleOrLasttrackOrigRenamevalidCharForDate readPatchDatemetadataToStringstorePatchInfoprop_ctxNotComprop_ctxNotInv readBinary FileStateunknownFileState applyHunk applyHunksData.Semigroup.InternalAnypushCoalescePatch mapPrimFL coalescePaircanonize SummChunkWLCommonRLCommonmergeAfterConflicting allNormalcommuteConflictingallConflictsWith pullCommon pullCommonRL cleverCommute mergerCommutePatchNotAvailableSimpleHopefullyconscientiouslytaggedIntersectionmaybeSplitSetOnTag makeCleanunwrapOneTaggedFwdRev hashBundleinterpretContextdecodeGpgClearsignedreadPendingFileupdatePendingRL PatchIndexpidsInfoMap FilePathSpans FileIdSpansFileInfoisFiletouchingversionapplyPatchModscreateFidStartSpan startFpSpan stopFpSpan startFidSpan stopFidSpan createInfo insertTouchinsertParentsTouch lookupFid lookupFid'createPatchIndexDiskpatches2fileModsfpSpans2fileNamesremovePidSuffixupdatePatchIndexDiskcreatePatchIndexFromloadPatchIndexloadSafePatchIndexstorePatchIndexfpSpans2filePaths canCreatePIFpSpanFidSpan makeFilenamereadPatchesFromInventoryEntries delaySealed GHC.IO.UnsafeunsafeInterleaveIOreadInventoryPrivate DirLayout PlainLayoutBucketedLayout cleanPristine diffHashListscleanInventories cleanPatcheslistInventoriesWithlistInventoriesLocallistPatchesLocalreadInventoryLocal readInventoryapplyToHashedPristinerestrictSubpathsAfterfilteredWorkingworkDirLessRepoWitnessinternalUpdateIndexgetMoves getReplacesexternallyResolveFile MatchFailureMatcherMatchFun applyMatcher strictJustnonrangeMatcher firstMatcherhasLastnapplyInvToMatcher applyNInvprimitiveMatchersmaybeFixSubPaths PipeToSsh PipeToOther ortryrunningGHC.IO.EncodinggetFileSystemEncodingsetLocaleEncodingMatchCriterionbackwardreversedtriviswantedwspfr liftChoicesjustDone textSelecttodo modifyChoices postponeNext splitCurrent printSelectedskipAll textSelectOne printCurrenttextView getDefaultindependentPatchIdscontainers-0.6.7Data.Set.InternalinsertdeletefindComponents joinOrAddNew pushThroughforceCommuteNamereadPatchesHashedremoveFromTentativeInventorysetScriptsExecutable_ RepoPatchType checkTree checkPrimV1haveknownnew notYetListedfetchPatchesIfNecessaryBisectProgress TestingStateStrategy StrategyDone WithResultTestCmd TestingEnvIO TestingEnvTesting minimiseBlame strategyDoneoneTest trackLineartrackNextLinear trackBackofftrackNextBackofffindTestableTowardsNewer trackBisect initialBisecttrackNextBisectcheckAndReturnFinalBisectResult runNextBisect moveHalfNewer moveToMiddleCommandOptions patchFilename remotePatchesrunInteractiveinteractiveHunksDeps DepsGraphData.Map.InternalMap depsGraphrenderDepsGraphAsDot validPrefDataisTok chooseToks filenameToks replaceHelpmakeRemovePatch makeRemoveGapcheckNameIsNotOptionShadowmoveFile fileStatusPathSet EverythingOnlyfromOnly isectPathSet showPathSetfilterPatchesByNamesgetDiffCmdAndArgsW2convertDarcs2Help'prepareRemoteDirconvertUpToToOnePostHttpSendMailaddChangesToPatch injectOne foldSealedFL squashOneinteractiveEdit OptionMapCmdName mkCmdName showCmdNameSuperCmd parseDefaultsparseDefaultsLines defaultToFlagoptionSwitches optionMapallOptionSwitchesgetPosthookDirextraArgumentsErrorweakhash unwrapTree completeArgsenvironmentHelpmanpage