-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | a distributed, interactive, smart revision control system
--
-- Darcs is a free, open source revision control system. It is:
--
--
-- - Distributed: Darcs was one of the first revision control systems
-- in which every user has access to the full command set, removing
-- boundaries between server and client or committer and
-- non-committers.
-- - Interactive: Darcs is easy to learn and efficient to use because
-- it asks you questions in response to simple commands, giving you
-- choices in your work flow. You can choose to record one change in a
-- file, while ignoring another. As you update from upstream, you can
-- review each patch, picking and choosing which patches are
-- appropriate.
-- - Smart: Darcs is different from most revision control systems in
-- that it is based on the notion of change (or patch), rather than
-- version. An underlying algebra of patches determines whether changes
-- can be re-ordered. The laws of this algebra guarantee that the result
-- of merging depends only on the final set of patches applied in a
-- repository and not on their order.
-- - Simple: As a consequence, Darcs offers a conceptually simpler view
-- of the state of a repository: it is given by the set of patches it
-- contains. Pulling and pushing patches merely transfers them from one
-- set to another. So called "cherry-picking" is the default mode of
-- operation, and it fully preserves the identity of patches.
--
@package darcs
@version 2.18.2
module Darcs.Patch.Witnesses.Unsafe
unsafeCoerceP :: a wX wY -> a wB wC
unsafeCoercePStart :: a wX1 wY -> a wX2 wY
unsafeCoercePEnd :: a wX wY1 -> a wX wY2
unsafeCoerceP1 :: a wX -> a wY
module Darcs.Prelude
data () => Bool
False :: Bool
True :: Bool
-- | The character type Char is an enumeration whose values
-- represent Unicode (or equivalently ISO/IEC 10646) code points (i.e.
-- characters, see http://www.unicode.org/ for details). This set
-- extends the ISO 8859-1 (Latin-1) character set (the first 256
-- characters), which is itself an extension of the ASCII character set
-- (the first 128 characters). A character literal in Haskell has type
-- Char.
--
-- To convert a Char to or from the corresponding Int value
-- defined by Unicode, use toEnum and fromEnum from the
-- Enum class respectively (or equivalently ord and
-- chr).
data () => Char
-- | Double-precision floating point numbers. It is desirable that this
-- type be at least equal in range and precision to the IEEE
-- double-precision type.
data () => Double
-- | Single-precision floating point numbers. It is desirable that this
-- type be at least equal in range and precision to the IEEE
-- single-precision type.
data () => Float
-- | A fixed-precision integer type with at least the range [-2^29 ..
-- 2^29-1]. The exact range for a given implementation can be
-- determined by using minBound and maxBound from the
-- Bounded class.
data () => Int
-- | A Word is an unsigned integral type, with the same size as
-- Int.
data () => Word
data () => Ordering
LT :: Ordering
EQ :: Ordering
GT :: Ordering
-- | The Maybe type encapsulates an optional value. A value of type
-- Maybe a either contains a value of type a
-- (represented as Just a), or it is empty (represented
-- as Nothing). Using Maybe is a good way to deal with
-- errors or exceptional cases without resorting to drastic measures such
-- as error.
--
-- The Maybe type is also a monad. It is a simple kind of error
-- monad, where all errors are represented by Nothing. A richer
-- error monad can be built using the Either type.
data () => Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
-- | Lifted, homogeneous equality. By lifted, we mean that it can be bogus
-- (deferred type error). By homogeneous, the two types a and
-- b must have the same kinds.
class a ~# b => (a :: k) ~ (b :: k)
infix 4 ~
-- | Arbitrary precision integers. In contrast with fixed-size integral
-- types such as Int, the Integer type represents the
-- entire infinite range of integers.
--
-- Integers are stored in a kind of sign-magnitude form, hence do not
-- expect two's complement form when using bit operations.
--
-- If the value is small (fit into an Int), IS constructor
-- is used. Otherwise Integer and IN constructors are used
-- to store a BigNat representing respectively the positive or the
-- negative value magnitude.
--
-- Invariant: Integer and IN are used iff value doesn't fit
-- in IS
data () => Integer
-- | Conversion of values to readable Strings.
--
-- Derived instances of Show have the following properties, which
-- are compatible with derived instances of Read:
--
--
-- - The result of show is a syntactically correct Haskell
-- expression containing only constants, given the fixity declarations in
-- force at the point where the type is declared. It contains only the
-- constructor names defined in the data type, parentheses, and spaces.
-- When labelled constructor fields are used, braces, commas, field
-- names, and equal signs are also used.
-- - If the constructor is defined to be an infix operator, then
-- showsPrec will produce infix applications of the
-- constructor.
-- - the representation will be enclosed in parentheses if the
-- precedence of the top-level constructor in x is less than
-- d (associativity is ignored). Thus, if d is
-- 0 then the result is never surrounded in parentheses; if
-- d is 11 it is always surrounded in parentheses,
-- unless it is an atomic expression.
-- - If the constructor is defined using record syntax, then
-- show will produce the record-syntax form, with the fields given
-- in the same order as the original declaration.
--
--
-- For example, given the declarations
--
--
-- infixr 5 :^:
-- data Tree a = Leaf a | Tree a :^: Tree a
--
--
-- the derived instance of Show is equivalent to
--
--
-- instance (Show a) => Show (Tree a) where
--
-- showsPrec d (Leaf m) = showParen (d > app_prec) $
-- showString "Leaf " . showsPrec (app_prec+1) m
-- where app_prec = 10
--
-- showsPrec d (u :^: v) = showParen (d > up_prec) $
-- showsPrec (up_prec+1) u .
-- showString " :^: " .
-- showsPrec (up_prec+1) v
-- where up_prec = 5
--
--
-- Note that right-associativity of :^: is ignored. For example,
--
--
-- - show (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the
-- string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".
--
class () => Show a
-- | Convert a value to a readable String.
--
-- showsPrec should satisfy the law
--
--
-- showsPrec d x r ++ s == showsPrec d x (r ++ s)
--
--
-- Derived instances of Read and Show satisfy the
-- following:
--
--
--
-- That is, readsPrec parses the string produced by
-- showsPrec, and delivers the value that showsPrec started
-- with.
showsPrec :: Show a => Int -> a -> ShowS
-- | A specialised variant of showsPrec, using precedence context
-- zero, and returning an ordinary String.
show :: Show a => a -> String
-- | The method showList is provided to allow the programmer to give
-- a specialised way of showing lists of values. For example, this is
-- used by the predefined Show instance of the Char type,
-- where values of type String should be shown in double quotes,
-- rather than between square brackets.
showList :: Show a => [a] -> ShowS
-- | The Bounded class is used to name the upper and lower limits of
-- a type. Ord is not a superclass of Bounded since types
-- that are not totally ordered may also have upper and lower bounds.
--
-- The Bounded class may be derived for any enumeration type;
-- minBound is the first constructor listed in the data
-- declaration and maxBound is the last. Bounded may also
-- be derived for single-constructor datatypes whose constituent types
-- are in Bounded.
class () => Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a
-- | Class Enum defines operations on sequentially ordered types.
--
-- The enumFrom... methods are used in Haskell's translation of
-- arithmetic sequences.
--
-- Instances of Enum may be derived for any enumeration type
-- (types whose constructors have no fields). The nullary constructors
-- are assumed to be numbered left-to-right by fromEnum from
-- 0 through n-1. See Chapter 10 of the Haskell
-- Report for more details.
--
-- For any type that is an instance of class Bounded as well as
-- Enum, the following should hold:
--
--
--
--
-- enumFrom x = enumFromTo x maxBound
-- enumFromThen x y = enumFromThenTo x y bound
-- where
-- bound | fromEnum y >= fromEnum x = maxBound
-- | otherwise = minBound
--
class () => Enum a
-- | the successor of a value. For numeric types, succ adds 1.
succ :: Enum a => a -> a
-- | Convert from an Int.
toEnum :: Enum a => Int -> a
-- | Convert to an Int. It is implementation-dependent what
-- fromEnum returns when applied to a value that is too large to
-- fit in an Int.
fromEnum :: Enum a => a -> Int
-- | Used in Haskell's translation of [n..] with [n..] =
-- enumFrom n, a possible implementation being enumFrom n = n :
-- enumFrom (succ n). For example:
--
--
-- enumFrom 4 :: [Integer] = [4,5,6,7,...]
enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound ::
-- Int]
enumFrom :: Enum a => a -> [a]
-- | Used in Haskell's translation of [n,n'..] with [n,n'..] =
-- enumFromThen n n', a possible implementation being
-- enumFromThen n n' = n : n' : worker (f x) (f x n'),
-- worker s v = v : worker s (s v), x = fromEnum n' -
-- fromEnum n and f n y | n > 0 = f (n - 1) (succ y) | n <
-- 0 = f (n + 1) (pred y) | otherwise = y For example:
--
--
-- enumFromThen 4 6 :: [Integer] = [4,6,8,10...]
enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound ::
-- Int]
enumFromThen :: Enum a => a -> a -> [a]
-- | Used in Haskell's translation of [n..m] with [n..m] =
-- enumFromTo n m, a possible implementation being enumFromTo n
-- m | n <= m = n : enumFromTo (succ n) m | otherwise = []. For
-- example:
--
--
-- enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
enumFromTo 42 1 :: [Integer] = []
enumFromTo :: Enum a => a -> a -> [a]
-- | Used in Haskell's translation of [n,n'..m] with [n,n'..m]
-- = enumFromThenTo n n' m, a possible implementation being
-- enumFromThenTo n n' m = worker (f x) (c x) n m, x =
-- fromEnum n' - fromEnum n, c x = bool (>=) ((x
-- 0) f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n +
-- 1) (pred y) | otherwise = y and worker s c v m | c v m = v :
-- worker s c (s v) m | otherwise = [] For example:
--
--
-- enumFromThenTo 4 2 -6 :: [Integer] =
-- [4,2,0,-2,-4,-6]
enumFromThenTo 6 8 2 :: [Int] = []
enumFromThenTo :: Enum a => a -> a -> a -> [a]
-- | Extracting components of fractions.
class (Real a, Fractional a) => RealFrac a
-- | The function properFraction takes a real fractional number
-- x and returns a pair (n,f) such that x =
-- n+f, and:
--
--
-- - n is an integral number with the same sign as x;
-- and
-- - f is a fraction with the same type and sign as
-- x, and with absolute value less than 1.
--
--
-- The default definitions of the ceiling, floor,
-- truncate and round functions are in terms of
-- properFraction.
properFraction :: (RealFrac a, Integral b) => a -> (b, a)
-- | truncate x returns the integer nearest x
-- between zero and x
truncate :: (RealFrac a, Integral b) => a -> b
-- | round x returns the nearest integer to x; the
-- even integer if x is equidistant between two integers
round :: (RealFrac a, Integral b) => a -> b
-- | ceiling x returns the least integer not less than
-- x
ceiling :: (RealFrac a, Integral b) => a -> b
-- | floor x returns the greatest integer not greater than
-- x
floor :: (RealFrac a, Integral b) => a -> b
-- | Integral numbers, supporting integer division.
--
-- The Haskell Report defines no laws for Integral. However,
-- Integral instances are customarily expected to define a
-- Euclidean domain and have the following properties for the
-- div/mod and quot/rem pairs, given suitable
-- Euclidean functions f and g:
--
--
-- - x = y * quot x y + rem x y with rem x y
-- = fromInteger 0 or g (rem x y) < g
-- y
-- - x = y * div x y + mod x y with mod x y
-- = fromInteger 0 or f (mod x y) < f
-- y
--
--
-- An example of a suitable Euclidean function, for Integer's
-- instance, is abs.
--
-- In addition, toInteger should be total, and fromInteger
-- should be a left inverse for it, i.e. fromInteger (toInteger i) =
-- i.
class (Real a, Enum a) => Integral a
-- | integer division truncated toward zero
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
quot :: Integral a => a -> a -> a
-- | integer remainder, satisfying
--
--
-- (x `quot` y)*y + (x `rem` y) == x
--
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
rem :: Integral a => a -> a -> a
-- | integer division truncated toward negative infinity
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
div :: Integral a => a -> a -> a
-- | integer modulus, satisfying
--
--
-- (x `div` y)*y + (x `mod` y) == x
--
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
mod :: Integral a => a -> a -> a
-- | simultaneous quot and rem
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
quotRem :: Integral a => a -> a -> (a, a)
-- | simultaneous div and mod
--
-- WARNING: This function is partial (because it throws when 0 is passed
-- as the divisor) for all the integer types in base.
divMod :: Integral a => a -> a -> (a, a)
-- | conversion to Integer
toInteger :: Integral a => a -> Integer
infixl 7 `quot`
infixl 7 `rem`
infixl 7 `div`
infixl 7 `mod`
-- | Parsing of Strings, producing values.
--
-- Derived instances of Read make the following assumptions, which
-- derived instances of Show obey:
--
--
-- - If the constructor is defined to be an infix operator, then the
-- derived Read instance will parse only infix applications of the
-- constructor (not the prefix form).
-- - Associativity is not used to reduce the occurrence of parentheses,
-- although precedence may be.
-- - If the constructor is defined using record syntax, the derived
-- Read will parse only the record-syntax form, and furthermore,
-- the fields must be given in the same order as the original
-- declaration.
-- - The derived Read instance allows arbitrary Haskell
-- whitespace between tokens of the input string. Extra parentheses are
-- also allowed.
--
--
-- For example, given the declarations
--
--
-- infixr 5 :^:
-- data Tree a = Leaf a | Tree a :^: Tree a
--
--
-- the derived instance of Read in Haskell 2010 is equivalent to
--
--
-- instance (Read a) => Read (Tree a) where
--
-- readsPrec d r = readParen (d > app_prec)
-- (\r -> [(Leaf m,t) |
-- ("Leaf",s) <- lex r,
-- (m,t) <- readsPrec (app_prec+1) s]) r
--
-- ++ readParen (d > up_prec)
-- (\r -> [(u:^:v,w) |
-- (u,s) <- readsPrec (up_prec+1) r,
-- (":^:",t) <- lex s,
-- (v,w) <- readsPrec (up_prec+1) t]) r
--
-- where app_prec = 10
-- up_prec = 5
--
--
-- Note that right-associativity of :^: is unused.
--
-- The derived instance in GHC is equivalent to
--
--
-- instance (Read a) => Read (Tree a) where
--
-- readPrec = parens $ (prec app_prec $ do
-- Ident "Leaf" <- lexP
-- m <- step readPrec
-- return (Leaf m))
--
-- +++ (prec up_prec $ do
-- u <- step readPrec
-- Symbol ":^:" <- lexP
-- v <- step readPrec
-- return (u :^: v))
--
-- where app_prec = 10
-- up_prec = 5
--
-- readListPrec = readListPrecDefault
--
--
-- Why do both readsPrec and readPrec exist, and why does
-- GHC opt to implement readPrec in derived Read instances
-- instead of readsPrec? The reason is that readsPrec is
-- based on the ReadS type, and although ReadS is mentioned
-- in the Haskell 2010 Report, it is not a very efficient parser data
-- structure.
--
-- readPrec, on the other hand, is based on a much more efficient
-- ReadPrec datatype (a.k.a "new-style parsers"), but its
-- definition relies on the use of the RankNTypes language
-- extension. Therefore, readPrec (and its cousin,
-- readListPrec) are marked as GHC-only. Nevertheless, it is
-- recommended to use readPrec instead of readsPrec
-- whenever possible for the efficiency improvements it brings.
--
-- As mentioned above, derived Read instances in GHC will
-- implement readPrec instead of readsPrec. The default
-- implementations of readsPrec (and its cousin, readList)
-- will simply use readPrec under the hood. If you are writing a
-- Read instance by hand, it is recommended to write it like so:
--
--
-- instance Read T where
-- readPrec = ...
-- readListPrec = readListPrecDefault
--
class () => Read a
-- | attempts to parse a value from the front of the string, returning a
-- list of (parsed value, remaining string) pairs. If there is no
-- successful parse, the returned list is empty.
--
-- Derived instances of Read and Show satisfy the
-- following:
--
--
--
-- That is, readsPrec parses the string produced by
-- showsPrec, and delivers the value that showsPrec started
-- with.
readsPrec :: Read a => Int -> ReadS a
-- | The method readList is provided to allow the programmer to give
-- a specialised way of parsing lists of values. For example, this is
-- used by the predefined Read instance of the Char type,
-- where values of type String should be are expected to use
-- double quotes, rather than square brackets.
readList :: Read a => ReadS [a]
-- | A value of type IO a is a computation which, when
-- performed, does some I/O before returning a value of type a.
--
-- There is really only one way to "perform" an I/O action: bind it to
-- Main.main in your program. When your program is run, the I/O
-- will be performed. It isn't possible to perform I/O from an arbitrary
-- function, unless that function is itself in the IO monad and
-- called at some point, directly or indirectly, from Main.main.
--
-- IO is a monad, so IO actions can be combined using
-- either the do-notation or the >> and >>=
-- operations from the Monad class.
data () => IO a
-- | The Ord class is used for totally ordered datatypes.
--
-- Instances of Ord can be derived for any user-defined datatype
-- whose constituent types are in Ord. The declared order of the
-- constructors in the data declaration determines the ordering in
-- derived Ord instances. The Ordering datatype allows a
-- single comparison to determine the precise ordering of two objects.
--
-- Ord, as defined by the Haskell report, implements a total order
-- and has the following properties:
--
--
-- - Comparability x <= y || y <= x =
-- True
-- - Transitivity if x <= y && y <=
-- z = True, then x <= z = True
-- - Reflexivity x <= x = True
-- - Antisymmetry if x <= y && y <=
-- x = True, then x == y = True
--
--
-- The following operator interactions are expected to hold:
--
--
-- - x >= y = y <= x
-- - x < y = x <= y && x /= y
-- - x > y = y < x
-- - x < y = compare x y == LT
-- - x > y = compare x y == GT
-- - x == y = compare x y == EQ
-- - min x y == if x <= y then x else y = True
-- - max x y == if x >= y then x else y = True
--
--
-- Note that (7.) and (8.) do not require min and
-- max to return either of their arguments. The result is merely
-- required to equal one of the arguments in terms of (==).
--
-- Minimal complete definition: either compare or <=.
-- Using compare can be more efficient for complex types.
class Eq a => Ord a
compare :: Ord a => a -> a -> Ordering
(<) :: Ord a => a -> a -> Bool
(<=) :: Ord a => a -> a -> Bool
(>) :: Ord a => a -> a -> Bool
(>=) :: Ord a => a -> a -> Bool
max :: Ord a => a -> a -> a
min :: Ord a => a -> a -> a
infix 4 >=
infix 4 <
infix 4 <=
infix 4 >
-- | A String is a list of characters. String constants in Haskell
-- are values of type String.
--
-- See Data.List for operations on lists.
type String = [Char]
-- | Arbitrary-precision rational numbers, represented as a ratio of two
-- Integer values. A rational number may be constructed using the
-- % operator.
type Rational = Ratio Integer
-- | Fractional numbers, supporting real division.
--
-- The Haskell Report defines no laws for Fractional. However,
-- (+) and (*) are customarily expected
-- to define a division ring and have the following properties:
--
--
--
-- Note that it isn't customarily expected that a type instance of
-- Fractional implement a field. However, all instances in
-- base do.
class Num a => Fractional a
-- | Fractional division.
(/) :: Fractional a => a -> a -> a
-- | Reciprocal fraction.
recip :: Fractional a => a -> a
-- | Conversion from a Rational (that is Ratio
-- Integer). A floating literal stands for an application of
-- fromRational to a value of type Rational, so such
-- literals have type (Fractional a) => a.
fromRational :: Fractional a => Rational -> a
infixl 7 /
-- | Real numbers.
--
-- The Haskell report defines no laws for Real, however
-- Real instances are customarily expected to adhere to the
-- following law:
--
--
class (Num a, Ord a) => Real a
-- | the rational equivalent of its real argument with full precision
toRational :: Real a => a -> Rational
-- | The Eq class defines equality (==) and inequality
-- (/=). All the basic datatypes exported by the Prelude
-- are instances of Eq, and Eq may be derived for any
-- datatype whose constituents are also instances of Eq.
--
-- The Haskell Report defines no laws for Eq. However, instances
-- are encouraged to follow these properties:
--
--
-- - Reflexivity x == x = True
-- - Symmetry x == y = y == x
-- - Transitivity if x == y && y == z =
-- True, then x == z = True
-- - Extensionality if x == y = True and
-- f is a function whose return type is an instance of
-- Eq, then f x == f y = True
-- - Negation x /= y = not (x ==
-- y)
--
--
-- Minimal complete definition: either == or /=.
class () => Eq a
(==) :: Eq a => a -> a -> Bool
(/=) :: Eq a => a -> a -> Bool
infix 4 ==
infix 4 /=
-- | A type f is a Functor if it provides a function fmap
-- which, given any types a and b lets you apply any
-- function from (a -> b) to turn an f a into an
-- f b, preserving the structure of f. Furthermore
-- f needs to adhere to the following:
--
--
--
-- Note, that the second law follows from the free theorem of the type
-- fmap and the first law, so you need only check that the former
-- condition holds. See
-- https://www.schoolofhaskell.com/user/edwardk/snippets/fmap or
-- https://github.com/quchen/articles/blob/master/second_functor_law.md
-- for an explanation.
class () => Functor (f :: Type -> Type)
-- | fmap is used to apply a function of type (a -> b)
-- to a value of type f a, where f is a functor, to produce a
-- value of type f b. Note that for any type constructor with
-- more than one parameter (e.g., Either), only the last type
-- parameter can be modified with fmap (e.g., b in
-- `Either a b`).
--
-- Some type constructors with two parameters or more have a
-- Bifunctor instance that allows both the last and the
-- penultimate parameters to be mapped over.
--
-- Examples
--
-- Convert from a Maybe Int to a Maybe String
-- using show:
--
--
-- >>> fmap show Nothing
-- Nothing
--
-- >>> fmap show (Just 3)
-- Just "3"
--
--
-- Convert from an Either Int Int to an Either Int
-- String using show:
--
--
-- >>> fmap show (Left 17)
-- Left 17
--
-- >>> fmap show (Right 17)
-- Right "17"
--
--
-- Double each element of a list:
--
--
-- >>> fmap (*2) [1,2,3]
-- [2,4,6]
--
--
-- Apply even to the second element of a pair:
--
--
-- >>> fmap even (2,2)
-- (2,True)
--
--
-- It may seem surprising that the function is only applied to the last
-- element of the tuple compared to the list example above which applies
-- it to every element in the list. To understand, remember that tuples
-- are type constructors with multiple type parameters: a tuple of 3
-- elements (a,b,c) can also be written (,,) a b c and
-- its Functor instance is defined for Functor ((,,) a
-- b) (i.e., only the third parameter is free to be mapped over with
-- fmap).
--
-- It explains why fmap can be used with tuples containing
-- values of different types as in the following example:
--
--
-- >>> fmap even ("hello", 1.0, 4)
-- ("hello",1.0,True)
--
fmap :: Functor f => (a -> b) -> f a -> f b
-- | Replace all locations in the input with the same value. The default
-- definition is fmap . const, but this may be
-- overridden with a more efficient version.
--
-- Examples
--
-- Perform a computation with Maybe and replace the result with a
-- constant value if it is Just:
--
--
-- >>> 'a' <$ Just 2
-- Just 'a'
--
-- >>> 'a' <$ Nothing
-- Nothing
--
(<$) :: Functor f => a -> f b -> f a
infixl 4 <$
-- | The Monad class defines the basic operations over a
-- monad, a concept from a branch of mathematics known as
-- category theory. From the perspective of a Haskell programmer,
-- however, it is best to think of a monad as an abstract datatype
-- of actions. Haskell's do expressions provide a convenient
-- syntax for writing monadic expressions.
--
-- Instances of Monad should satisfy the following:
--
--
--
-- Furthermore, the Monad and Applicative operations should
-- relate as follows:
--
--
--
-- The above laws imply:
--
--
--
-- and that pure and (<*>) satisfy the applicative
-- functor laws.
--
-- The instances of Monad for lists, Maybe and IO
-- defined in the Prelude satisfy these laws.
class Applicative m => Monad (m :: Type -> Type)
-- | Sequentially compose two actions, passing any value produced by the
-- first as an argument to the second.
--
-- 'as >>= bs' can be understood as the do
-- expression
--
--
-- do a <- as
-- bs a
--
(>>=) :: Monad m => m a -> (a -> m b) -> m b
-- | Sequentially compose two actions, discarding any value produced by the
-- first, like sequencing operators (such as the semicolon) in imperative
-- languages.
--
-- 'as >> bs' can be understood as the do
-- expression
--
--
-- do as
-- bs
--
(>>) :: Monad m => m a -> m b -> m b
-- | Inject a value into the monadic type.
return :: Monad m => a -> m a
infixl 1 >>=
infixl 1 >>
-- | The Either type represents values with two possibilities: a
-- value of type Either a b is either Left
-- a or Right b.
--
-- The Either type is sometimes used to represent a value which is
-- either correct or an error; by convention, the Left constructor
-- is used to hold an error value and the Right constructor is
-- used to hold a correct value (mnemonic: "right" also means "correct").
--
-- Examples
--
-- The type Either String Int is the type
-- of values which can be either a String or an Int. The
-- Left constructor can be used only on Strings, and the
-- Right constructor can be used only on Ints:
--
--
-- >>> let s = Left "foo" :: Either String Int
--
-- >>> s
-- Left "foo"
--
-- >>> let n = Right 3 :: Either String Int
--
-- >>> n
-- Right 3
--
-- >>> :type s
-- s :: Either String Int
--
-- >>> :type n
-- n :: Either String Int
--
--
-- The fmap from our Functor instance will ignore
-- Left values, but will apply the supplied function to values
-- contained in a Right:
--
--
-- >>> let s = Left "foo" :: Either String Int
--
-- >>> let n = Right 3 :: Either String Int
--
-- >>> fmap (*2) s
-- Left "foo"
--
-- >>> fmap (*2) n
-- Right 6
--
--
-- The Monad instance for Either allows us to chain
-- together multiple actions which may fail, and fail overall if any of
-- the individual steps failed. First we'll write a function that can
-- either parse an Int from a Char, or fail.
--
--
-- >>> import Data.Char ( digitToInt, isDigit )
--
-- >>> :{
-- let parseEither :: Char -> Either String Int
-- parseEither c
-- | isDigit c = Right (digitToInt c)
-- | otherwise = Left "parse error"
--
-- >>> :}
--
--
-- The following should work, since both '1' and '2'
-- can be parsed as Ints.
--
--
-- >>> :{
-- let parseMultiple :: Either String Int
-- parseMultiple = do
-- x <- parseEither '1'
-- y <- parseEither '2'
-- return (x + y)
--
-- >>> :}
--
--
--
-- >>> parseMultiple
-- Right 3
--
--
-- But the following should fail overall, since the first operation where
-- we attempt to parse 'm' as an Int will fail:
--
--
-- >>> :{
-- let parseMultiple :: Either String Int
-- parseMultiple = do
-- x <- parseEither 'm'
-- y <- parseEither '2'
-- return (x + y)
--
-- >>> :}
--
--
--
-- >>> parseMultiple
-- Left "parse error"
--
data () => Either a b
Left :: a -> Either a b
Right :: b -> Either a b
-- | The Foldable class represents data structures that can be reduced to a
-- summary value one element at a time. Strict left-associative folds are
-- a good fit for space-efficient reduction, while lazy right-associative
-- folds are a good fit for corecursive iteration, or for folds that
-- short-circuit after processing an initial subsequence of the
-- structure's elements.
--
-- Instances can be derived automatically by enabling the
-- DeriveFoldable extension. For example, a derived instance for
-- a binary tree might be:
--
--
-- {-# LANGUAGE DeriveFoldable #-}
-- data Tree a = Empty
-- | Leaf a
-- | Node (Tree a) a (Tree a)
-- deriving Foldable
--
--
-- A more detailed description can be found in the Overview
-- section of Data.Foldable#overview.
--
-- For the class laws see the Laws section of
-- Data.Foldable#laws.
class () => Foldable (t :: Type -> Type)
-- | Map each element of the structure into a monoid, and combine the
-- results with (<>). This fold is
-- right-associative and lazy in the accumulator. For strict
-- left-associative folds consider foldMap' instead.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> foldMap Sum [1, 3, 5]
-- Sum {getSum = 9}
--
--
--
-- >>> foldMap Product [1, 3, 5]
-- Product {getProduct = 15}
--
--
--
-- >>> foldMap (replicate 3) [1, 2, 3]
-- [1,1,1,2,2,2,3,3,3]
--
--
-- When a Monoid's (<>) is lazy in its second
-- argument, foldMap can return a result even from an unbounded
-- structure. For example, lazy accumulation enables
-- Data.ByteString.Builder to efficiently serialise large data
-- structures and produce the output incrementally:
--
--
-- >>> import qualified Data.ByteString.Lazy as L
--
-- >>> import qualified Data.ByteString.Builder as B
--
-- >>> let bld :: Int -> B.Builder; bld i = B.intDec i <> B.word8 0x20
--
-- >>> let lbs = B.toLazyByteString $ foldMap bld [0..]
--
-- >>> L.take 64 lbs
-- "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24"
--
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
-- | Right-associative fold of a structure, lazy in the accumulator.
--
-- In the case of lists, foldr, when applied to a binary operator,
-- a starting value (typically the right-identity of the operator), and a
-- list, reduces the list using the binary operator, from right to left:
--
--
-- foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
--
--
-- Note that since the head of the resulting expression is produced by an
-- application of the operator to the first element of the list, given an
-- operator lazy in its right argument, foldr can produce a
-- terminating expression from an unbounded list.
--
-- For a general Foldable structure this should be semantically
-- identical to,
--
--
-- foldr f z = foldr f z . toList
--
--
-- Examples
--
-- Basic usage:
--
--
-- >>> foldr (||) False [False, True, False]
-- True
--
--
--
-- >>> foldr (||) False []
-- False
--
--
--
-- >>> foldr (\c acc -> acc ++ [c]) "foo" ['a', 'b', 'c', 'd']
-- "foodcba"
--
--
-- Infinite structures
--
-- ⚠️ Applying foldr to infinite structures usually doesn't
-- terminate.
--
-- It may still terminate under one of the following conditions:
--
--
-- - the folding function is short-circuiting
-- - the folding function is lazy on its second argument
--
--
-- Short-circuiting
--
-- (||) short-circuits on True values, so the
-- following terminates because there is a True value finitely far
-- from the left side:
--
--
-- >>> foldr (||) False (True : repeat False)
-- True
--
--
-- But the following doesn't terminate:
--
--
-- >>> foldr (||) False (repeat False ++ [True])
-- * Hangs forever *
--
--
-- Laziness in the second argument
--
-- Applying foldr to infinite structures terminates when the
-- operator is lazy in its second argument (the initial accumulator is
-- never used in this case, and so could be left undefined, but
-- [] is more clear):
--
--
-- >>> take 5 $ foldr (\i acc -> i : fmap (+3) acc) [] (repeat 1)
-- [1,4,7,10,13]
--
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
-- | Left-associative fold of a structure, lazy in the accumulator. This is
-- rarely what you want, but can work well for structures with efficient
-- right-to-left sequencing and an operator that is lazy in its left
-- argument.
--
-- In the case of lists, foldl, when applied to a binary operator,
-- a starting value (typically the left-identity of the operator), and a
-- list, reduces the list using the binary operator, from left to right:
--
--
-- foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
--
--
-- Note that to produce the outermost application of the operator the
-- entire input list must be traversed. Like all left-associative folds,
-- foldl will diverge if given an infinite list.
--
-- If you want an efficient strict left-fold, you probably want to use
-- foldl' instead of foldl. The reason for this is that the
-- latter does not force the inner results (e.g. z `f` x1
-- in the above example) before applying them to the operator (e.g. to
-- (`f` x2)). This results in a thunk chain O(n) elements
-- long, which then must be evaluated from the outside-in.
--
-- For a general Foldable structure this should be semantically
-- identical to:
--
--
-- foldl f z = foldl f z . toList
--
--
-- Examples
--
-- The first example is a strict fold, which in practice is best
-- performed with foldl'.
--
--
-- >>> foldl (+) 42 [1,2,3,4]
-- 52
--
--
-- Though the result below is lazy, the input is reversed before
-- prepending it to the initial accumulator, so corecursion begins only
-- after traversing the entire input string.
--
--
-- >>> foldl (\acc c -> c : acc) "abcd" "efgh"
-- "hgfeabcd"
--
--
-- A left fold of a structure that is infinite on the right cannot
-- terminate, even when for any finite input the fold just returns the
-- initial accumulator:
--
--
-- >>> foldl (\a _ -> a) 0 $ repeat 1
-- * Hangs forever *
--
--
-- WARNING: When it comes to lists, you always want to use either
-- foldl' or foldr instead.
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
-- | A variant of foldr that has no base case, and thus may only be
-- applied to non-empty structures.
--
-- This function is non-total and will raise a runtime exception if the
-- structure happens to be empty.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> foldr1 (+) [1..4]
-- 10
--
--
--
-- >>> foldr1 (+) []
-- Exception: Prelude.foldr1: empty list
--
--
--
-- >>> foldr1 (+) Nothing
-- *** Exception: foldr1: empty structure
--
--
--
-- >>> foldr1 (-) [1..4]
-- -2
--
--
--
-- >>> foldr1 (&&) [True, False, True, True]
-- False
--
--
--
-- >>> foldr1 (||) [False, False, True, True]
-- True
--
--
--
-- >>> foldr1 (+) [1..]
-- * Hangs forever *
--
foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
-- | A variant of foldl that has no base case, and thus may only be
-- applied to non-empty structures.
--
-- This function is non-total and will raise a runtime exception if the
-- structure happens to be empty.
--
--
-- foldl1 f = foldl1 f . toList
--
--
-- Examples
--
-- Basic usage:
--
--
-- >>> foldl1 (+) [1..4]
-- 10
--
--
--
-- >>> foldl1 (+) []
-- *** Exception: Prelude.foldl1: empty list
--
--
--
-- >>> foldl1 (+) Nothing
-- *** Exception: foldl1: empty structure
--
--
--
-- >>> foldl1 (-) [1..4]
-- -8
--
--
--
-- >>> foldl1 (&&) [True, False, True, True]
-- False
--
--
--
-- >>> foldl1 (||) [False, False, True, True]
-- True
--
--
--
-- >>> foldl1 (+) [1..]
-- * Hangs forever *
--
foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
-- | Test whether the structure is empty. The default implementation is
-- Left-associative and lazy in both the initial element and the
-- accumulator. Thus optimised for structures where the first element can
-- be accessed in constant time. Structures where this is not the case
-- should have a non-default implementation.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> null []
-- True
--
--
--
-- >>> null [1]
-- False
--
--
-- null is expected to terminate even for infinite structures. The
-- default implementation terminates provided the structure is bounded on
-- the left (there is a leftmost element).
--
--
-- >>> null [1..]
-- False
--
null :: Foldable t => t a -> Bool
-- | Returns the size/length of a finite structure as an Int. The
-- default implementation just counts elements starting with the
-- leftmost. Instances for structures that can compute the element count
-- faster than via element-by-element counting, should provide a
-- specialised implementation.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> length []
-- 0
--
--
--
-- >>> length ['a', 'b', 'c']
-- 3
--
-- >>> length [1..]
-- * Hangs forever *
--
length :: Foldable t => t a -> Int
-- | Does the element occur in the structure?
--
-- Note: elem is often used in infix form.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> 3 `elem` []
-- False
--
--
--
-- >>> 3 `elem` [1,2]
-- False
--
--
--
-- >>> 3 `elem` [1,2,3,4,5]
-- True
--
--
-- For infinite structures, the default implementation of elem
-- terminates if the sought-after value exists at a finite distance from
-- the left side of the structure:
--
--
-- >>> 3 `elem` [1..]
-- True
--
--
--
-- >>> 3 `elem` ([4..] ++ [3])
-- * Hangs forever *
--
elem :: (Foldable t, Eq a) => a -> t a -> Bool
-- | The largest element of a non-empty structure.
--
-- This function is non-total and will raise a runtime exception if the
-- structure happens to be empty. A structure that supports random access
-- and maintains its elements in order should provide a specialised
-- implementation to return the maximum in faster than linear time.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> maximum [1..10]
-- 10
--
--
--
-- >>> maximum []
-- *** Exception: Prelude.maximum: empty list
--
--
--
-- >>> maximum Nothing
-- *** Exception: maximum: empty structure
--
--
-- WARNING: This function is partial for possibly-empty structures like
-- lists.
maximum :: (Foldable t, Ord a) => t a -> a
-- | The least element of a non-empty structure.
--
-- This function is non-total and will raise a runtime exception if the
-- structure happens to be empty. A structure that supports random access
-- and maintains its elements in order should provide a specialised
-- implementation to return the minimum in faster than linear time.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> minimum [1..10]
-- 1
--
--
--
-- >>> minimum []
-- *** Exception: Prelude.minimum: empty list
--
--
--
-- >>> minimum Nothing
-- *** Exception: minimum: empty structure
--
--
-- WARNING: This function is partial for possibly-empty structures like
-- lists.
minimum :: (Foldable t, Ord a) => t a -> a
-- | The sum function computes the sum of the numbers of a
-- structure.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> sum []
-- 0
--
--
--
-- >>> sum [42]
-- 42
--
--
--
-- >>> sum [1..10]
-- 55
--
--
--
-- >>> sum [4.1, 2.0, 1.7]
-- 7.8
--
--
--
-- >>> sum [1..]
-- * Hangs forever *
--
sum :: (Foldable t, Num a) => t a -> a
-- | The product function computes the product of the numbers of a
-- structure.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> product []
-- 1
--
--
--
-- >>> product [42]
-- 42
--
--
--
-- >>> product [1..10]
-- 3628800
--
--
--
-- >>> product [4.1, 2.0, 1.7]
-- 13.939999999999998
--
--
--
-- >>> product [1..]
-- * Hangs forever *
--
product :: (Foldable t, Num a) => t a -> a
infix 4 `elem`
-- | When a value is bound in do-notation, the pattern on the left
-- hand side of <- might not match. In this case, this class
-- provides a function to recover.
--
-- A Monad without a MonadFail instance may only be used in
-- conjunction with pattern that always match, such as newtypes, tuples,
-- data types with only a single data constructor, and irrefutable
-- patterns (~pat).
--
-- Instances of MonadFail should satisfy the following law:
-- fail s should be a left zero for >>=,
--
--
-- fail s >>= f = fail s
--
--
-- If your Monad is also MonadPlus, a popular definition is
--
--
-- fail _ = mzero
--
--
-- fail s should be an action that runs in the monad itself, not
-- an exception (except in instances of MonadIO). In particular,
-- fail should not be implemented in terms of error.
class Monad m => MonadFail (m :: Type -> Type)
fail :: MonadFail m => String -> m a
-- | Functors representing data structures that can be transformed to
-- structures of the same shape by performing an
-- Applicative (or, therefore, Monad) action on each
-- element from left to right.
--
-- A more detailed description of what same shape means, the
-- various methods, how traversals are constructed, and example advanced
-- use-cases can be found in the Overview section of
-- Data.Traversable#overview.
--
-- For the class laws see the Laws section of
-- Data.Traversable#laws.
class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
-- | Evaluate each action in the structure from left to right, and collect
-- the results. For a version that ignores the results see
-- sequenceA_.
--
-- Examples
--
-- Basic usage:
--
-- For the first two examples we show sequenceA fully evaluating a a
-- structure and collecting the results.
--
--
-- >>> sequenceA [Just 1, Just 2, Just 3]
-- Just [1,2,3]
--
--
--
-- >>> sequenceA [Right 1, Right 2, Right 3]
-- Right [1,2,3]
--
--
-- The next two example show Nothing and Just will short
-- circuit the resulting structure if present in the input. For more
-- context, check the Traversable instances for Either and
-- Maybe.
--
--
-- >>> sequenceA [Just 1, Just 2, Just 3, Nothing]
-- Nothing
--
--
--
-- >>> sequenceA [Right 1, Right 2, Right 3, Left 4]
-- Left 4
--
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
-- | Map each element of a structure to a monadic action, evaluate these
-- actions from left to right, and collect the results. For a version
-- that ignores the results see mapM_.
--
-- Examples
--
-- mapM is literally a traverse with a type signature
-- restricted to Monad. Its implementation may be more efficient
-- due to additional power of Monad.
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
-- | Evaluate each monadic action in the structure from left to right, and
-- collect the results. For a version that ignores the results see
-- sequence_.
--
-- Examples
--
-- Basic usage:
--
-- The first two examples are instances where the input and and output of
-- sequence are isomorphic.
--
--
-- >>> sequence $ Right [1,2,3,4]
-- [Right 1,Right 2,Right 3,Right 4]
--
--
--
-- >>> sequence $ [Right 1,Right 2,Right 3,Right 4]
-- Right [1,2,3,4]
--
--
-- The following examples demonstrate short circuit behavior for
-- sequence.
--
--
-- >>> sequence $ Left [1,2,3,4]
-- Left [1,2,3,4]
--
--
--
-- >>> sequence $ [Left 0, Right 1,Right 2,Right 3,Right 4]
-- Left 0
--
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
-- | The Haskell 2010 type for exceptions in the IO monad. Any I/O
-- operation may raise an IOException instead of returning a
-- result. For a more general type of exception, including also those
-- that arise in pure code, see Exception.
--
-- In Haskell 2010, this is an opaque type.
type IOError = IOException
-- | Trigonometric and hyperbolic functions and related functions.
--
-- The Haskell Report defines no laws for Floating. However,
-- (+), (*) and exp are
-- customarily expected to define an exponential field and have the
-- following properties:
--
--
-- - exp (a + b) = exp a * exp b
-- - exp (fromInteger 0) = fromInteger 1
--
class Fractional a => Floating a
exp :: Floating a => a -> a
sqrt :: Floating a => a -> a
(**) :: Floating a => a -> a -> a
logBase :: Floating a => a -> a -> a
sin :: Floating a => a -> a
cos :: Floating a => a -> a
tan :: Floating a => a -> a
asin :: Floating a => a -> a
acos :: Floating a => a -> a
atan :: Floating a => a -> a
sinh :: Floating a => a -> a
cosh :: Floating a => a -> a
tanh :: Floating a => a -> a
asinh :: Floating a => a -> a
acosh :: Floating a => a -> a
atanh :: Floating a => a -> a
infixr 8 **
-- | Basic numeric class.
--
-- The Haskell Report defines no laws for Num. However,
-- (+) and (*) are customarily expected
-- to define a ring and have the following properties:
--
--
-- - Associativity of (+) (x + y) +
-- z = x + (y + z)
-- - Commutativity of (+) x + y
-- = y + x
-- - fromInteger 0 is the additive
-- identity x + fromInteger 0 = x
-- - negate gives the additive inverse x +
-- negate x = fromInteger 0
-- - Associativity of (*) (x * y) *
-- z = x * (y * z)
-- - fromInteger 1 is the multiplicative
-- identity x * fromInteger 1 = x and
-- fromInteger 1 * x = x
-- - Distributivity of (*) with respect to
-- (+) a * (b + c) = (a * b) + (a *
-- c) and (b + c) * a = (b * a) + (c * a)
-- - Coherence with toInteger if the type also
-- implements Integral, then fromInteger is a left inverse
-- for toInteger, i.e. fromInteger (toInteger i) ==
-- i
--
--
-- Note that it isn't customarily expected that a type instance of
-- both Num and Ord implement an ordered ring. Indeed, in
-- base only Integer and Rational do.
class () => Num a
(+) :: Num a => a -> a -> a
(-) :: Num a => a -> a -> a
(*) :: Num a => a -> a -> a
-- | Unary negation.
negate :: Num a => a -> a
-- | Absolute value.
abs :: Num a => a -> a
-- | Sign of a number. The functions abs and signum should
-- satisfy the law:
--
--
-- abs x * signum x == x
--
--
-- For real numbers, the signum is either -1 (negative),
-- 0 (zero) or 1 (positive).
signum :: Num a => a -> a
-- | Conversion from an Integer. An integer literal represents the
-- application of the function fromInteger to the appropriate
-- value of type Integer, so such literals have type
-- (Num a) => a.
fromInteger :: Num a => Integer -> a
infixl 6 -
infixl 6 +
infixl 7 *
-- | Efficient, machine-independent access to the components of a
-- floating-point number.
class (RealFrac a, Floating a) => RealFloat a
-- | a constant function, returning the radix of the representation (often
-- 2)
floatRadix :: RealFloat a => a -> Integer
-- | a constant function, returning the number of digits of
-- floatRadix in the significand
floatDigits :: RealFloat a => a -> Int
-- | a constant function, returning the lowest and highest values the
-- exponent may assume
floatRange :: RealFloat a => a -> (Int, Int)
-- | The function decodeFloat applied to a real floating-point
-- number returns the significand expressed as an Integer and an
-- appropriately scaled exponent (an Int). If
-- decodeFloat x yields (m,n), then x
-- is equal in value to m*b^^n, where b is the
-- floating-point radix, and furthermore, either m and
-- n are both zero or else b^(d-1) <= abs m <
-- b^d, where d is the value of floatDigits
-- x. In particular, decodeFloat 0 = (0,0). If the
-- type contains a negative zero, also decodeFloat (-0.0) =
-- (0,0). The result of decodeFloat x is
-- unspecified if either of isNaN x or
-- isInfinite x is True.
decodeFloat :: RealFloat a => a -> (Integer, Int)
-- | encodeFloat performs the inverse of decodeFloat in the
-- sense that for finite x with the exception of -0.0,
-- uncurry encodeFloat (decodeFloat x) = x.
-- encodeFloat m n is one of the two closest
-- representable floating-point numbers to m*b^^n (or
-- ±Infinity if overflow occurs); usually the closer, but if
-- m contains too many bits, the result may be rounded in the
-- wrong direction.
encodeFloat :: RealFloat a => Integer -> Int -> a
-- | exponent corresponds to the second component of
-- decodeFloat. exponent 0 = 0 and for finite
-- nonzero x, exponent x = snd (decodeFloat x)
-- + floatDigits x. If x is a finite floating-point
-- number, it is equal in value to significand x * b ^^
-- exponent x, where b is the floating-point radix.
-- The behaviour is unspecified on infinite or NaN values.
exponent :: RealFloat a => a -> Int
-- | The first component of decodeFloat, scaled to lie in the open
-- interval (-1,1), either 0.0 or of absolute
-- value >= 1/b, where b is the floating-point
-- radix. The behaviour is unspecified on infinite or NaN
-- values.
significand :: RealFloat a => a -> a
-- | multiplies a floating-point number by an integer power of the radix
scaleFloat :: RealFloat a => Int -> a -> a
-- | True if the argument is an IEEE "not-a-number" (NaN) value
isNaN :: RealFloat a => a -> Bool
-- | True if the argument is an IEEE infinity or negative infinity
isInfinite :: RealFloat a => a -> Bool
-- | True if the argument is too small to be represented in
-- normalized format
isDenormalized :: RealFloat a => a -> Bool
-- | True if the argument is an IEEE negative zero
isNegativeZero :: RealFloat a => a -> Bool
-- | True if the argument is an IEEE floating point number
isIEEE :: RealFloat a => a -> Bool
-- | a version of arctangent taking two real floating-point arguments. For
-- real floating x and y, atan2 y x
-- computes the angle (from the positive x-axis) of the vector from the
-- origin to the point (x,y). atan2 y x returns
-- a value in the range [-pi, pi]. It follows the
-- Common Lisp semantics for the origin when signed zeroes are supported.
-- atan2 y 1, with y in a type that is
-- RealFloat, should return the same value as atan
-- y. A default definition of atan2 is provided, but
-- implementors can provide a more accurate implementation.
atan2 :: RealFloat a => a -> a -> a
-- | The shows functions return a function that prepends the
-- output String to an existing String. This allows
-- constant-time concatenation of results using function composition.
type ShowS = String -> String
-- | A parser for a type a, represented as a function that takes a
-- String and returns a list of possible parses as
-- (a,String) pairs.
--
-- Note that this kind of backtracking parser is very inefficient;
-- reading a large structure may be quite slow (cf ReadP).
type ReadS a = String -> [(a, String)]
-- | File and directory names are values of type String, whose
-- precise meaning is operating system dependent. Files can be opened,
-- yielding a handle which can then be used to operate on the contents of
-- that file.
type FilePath = String
-- | General coercion to Fractional types.
--
-- WARNING: This function goes through the Rational type, which
-- does not have values for NaN for example. This means it does
-- not round-trip.
--
-- For Double it also behaves differently with or without -O0:
--
--
-- Prelude> realToFrac nan -- With -O0
-- -Infinity
-- Prelude> realToFrac nan
-- NaN
--
realToFrac :: (Real a, Fractional b) => a -> b
-- | General coercion from Integral types.
--
-- WARNING: This function performs silent truncation if the result type
-- is not at least as big as the argument's type.
fromIntegral :: (Integral a, Num b) => a -> b
-- | Application operator. This operator is redundant, since ordinary
-- application (f x) means the same as (f $ x).
-- However, $ has low, right-associative binding precedence, so it
-- sometimes allows parentheses to be omitted; for example:
--
--
-- f $ g $ h x = f (g (h x))
--
--
-- It is also useful in higher-order situations, such as map
-- ($ 0) xs, or zipWith ($) fs xs.
--
-- Note that ($) is representation-polymorphic in its
-- result type, so that foo $ True where foo :: Bool
-- -> Int# is well-typed.
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
infixr 0 $
-- | otherwise is defined as the value True. It helps to make
-- guards more readable. eg.
--
--
-- f x | x < 0 = ...
-- | otherwise = ...
--
otherwise :: Bool
-- | Append two lists, i.e.,
--
--
-- [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
-- [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
--
--
-- If the first list is not finite, the result is the first list.
--
-- WARNING: This function takes linear time in the number of elements of
-- the first list.
(++) :: [a] -> [a] -> [a]
infixr 5 ++
-- | <math>. map f xs is the list obtained by
-- applying f to each element of xs, i.e.,
--
--
-- map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
-- map f [x1, x2, ...] == [f x1, f x2, ...]
--
--
--
-- >>> map (+1) [1, 2, 3]
-- [2,3,4]
--
map :: (a -> b) -> [a] -> [b]
-- | <math>. filter, applied to a predicate and a list,
-- returns the list of those elements that satisfy the predicate; i.e.,
--
--
-- filter p xs = [ x | x <- xs, p x]
--
--
--
-- >>> filter odd [1, 2, 3]
-- [1,3]
--
filter :: (a -> Bool) -> [a] -> [a]
-- | Identity function.
--
--
-- id x = x
--
id :: a -> a
-- | The value of seq a b is bottom if a is
-- bottom, and otherwise equal to b. In other words, it
-- evaluates the first argument a to weak head normal form
-- (WHNF). seq is usually introduced to improve performance by
-- avoiding unneeded laziness.
--
-- A note on evaluation order: the expression seq a b
-- does not guarantee that a will be evaluated before
-- b. The only guarantee given by seq is that the both
-- a and b will be evaluated before seq returns
-- a value. In particular, this means that b may be evaluated
-- before a. If you need to guarantee a specific order of
-- evaluation, you must use the function pseq from the
-- "parallel" package.
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
infixr 0 `seq`
-- | Map each element of a structure to a monadic action, evaluate these
-- actions from left to right, and ignore the results. For a version that
-- doesn't ignore the results see mapM.
--
-- mapM_ is just like traverse_, but specialised to monadic
-- actions.
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
-- | takeWhile, applied to a predicate p and a list
-- xs, returns the longest prefix (possibly empty) of
-- xs of elements that satisfy p.
--
--
-- >>> takeWhile (< 3) [1,2,3,4,1,2,3,4]
-- [1,2]
--
-- >>> takeWhile (< 9) [1,2,3]
-- [1,2,3]
--
-- >>> takeWhile (< 0) [1,2,3]
-- []
--
takeWhile :: (a -> Bool) -> [a] -> [a]
-- | take n, applied to a list xs, returns the
-- prefix of xs of length n, or xs itself if
-- n >= length xs.
--
--
-- >>> take 5 "Hello World!"
-- "Hello"
--
-- >>> take 3 [1,2,3,4,5]
-- [1,2,3]
--
-- >>> take 3 [1,2]
-- [1,2]
--
-- >>> take 3 []
-- []
--
-- >>> take (-1) [1,2]
-- []
--
-- >>> take 0 [1,2]
-- []
--
--
-- It is an instance of the more general genericTake, in which
-- n may be of any integral type.
take :: Int -> [a] -> [a]
-- | The read function reads input from a string, which must be
-- completely consumed by the input process. read fails with an
-- error if the parse is unsuccessful, and it is therefore
-- discouraged from being used in real applications. Use readMaybe
-- or readEither for safe alternatives.
--
--
-- >>> read "123" :: Int
-- 123
--
--
--
-- >>> read "hello" :: Int
-- *** Exception: Prelude.read: no parse
--
read :: Read a => String -> a
-- | Function composition.
(.) :: (b -> c) -> (a -> b) -> a -> c
infixr 9 .
-- | const x y always evaluates to x, ignoring its second
-- argument.
--
--
-- >>> const 42 "hello"
-- 42
--
--
--
-- >>> map (const 42) [0..3]
-- [42,42,42,42]
--
const :: a -> b -> a
-- | error stops execution and displays an error message.
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
-- | <math>. zipWith generalises zip by zipping with
-- the function given as the first argument, instead of a tupling
-- function.
--
--
-- zipWith (,) xs ys == zip xs ys
-- zipWith f [x1,x2,x3..] [y1,y2,y3..] == [f x1 y1, f x2 y2, f x3 y3..]
--
--
-- For example, zipWith (+) is applied to two lists to
-- produce the list of corresponding sums:
--
--
-- >>> zipWith (+) [1, 2, 3] [4, 5, 6]
-- [5,7,9]
--
--
-- zipWith is right-lazy:
--
--
-- >>> let f = undefined
--
-- >>> zipWith f [] undefined
-- []
--
--
-- zipWith is capable of list fusion, but it is restricted to its
-- first list argument and its resulting list.
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
even :: Integral a => a -> Bool
-- | Extract the first component of a pair.
fst :: (a, b) -> a
-- | uncurry converts a curried function to a function on pairs.
--
-- Examples
--
--
-- >>> uncurry (+) (1,2)
-- 3
--
--
--
-- >>> uncurry ($) (show, 1)
-- "1"
--
--
--
-- >>> map (uncurry max) [(1,2), (3,4), (6,8)]
-- [2,4,8]
--
uncurry :: (a -> b -> c) -> (a, b) -> c
-- | <math>. Extract the first element of a list, which must be
-- non-empty.
--
--
-- >>> head [1, 2, 3]
-- 1
--
-- >>> head [1..]
-- 1
--
-- >>> head []
-- *** Exception: Prelude.head: empty list
--
--
-- WARNING: This function is partial. You can use case-matching,
-- uncons or listToMaybe instead.
head :: HasCallStack => [a] -> a
-- | The computation writeFile file str function writes the
-- string str, to the file file.
writeFile :: FilePath -> String -> IO ()
-- | Read a line from the standard input device (same as hGetLine
-- stdin).
getLine :: IO String
-- | The same as putStr, but adds a newline character.
putStrLn :: String -> IO ()
-- | cycle ties a finite list into a circular one, or equivalently,
-- the infinite repetition of the original list. It is the identity on
-- infinite lists.
--
--
-- >>> cycle []
-- *** Exception: Prelude.cycle: empty list
--
-- >>> cycle [42]
-- [42,42,42,42,42,42,42,42,42,42...
--
-- >>> cycle [2, 5, 7]
-- [2,5,7,2,5,7,2,5,7,2,5,7...
--
cycle :: HasCallStack => [a] -> [a]
-- | The concatenation of all the elements of a container of lists.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> concat (Just [1, 2, 3])
-- [1,2,3]
--
--
--
-- >>> concat (Left 42)
-- []
--
--
--
-- >>> concat [[1, 2, 3], [4, 5], [6], []]
-- [1,2,3,4,5,6]
--
concat :: Foldable t => t [a] -> [a]
-- | <math>. zip takes two lists and returns a list of
-- corresponding pairs.
--
--
-- >>> zip [1, 2] ['a', 'b']
-- [(1,'a'),(2,'b')]
--
--
-- If one input list is shorter than the other, excess elements of the
-- longer list are discarded, even if one of the lists is infinite:
--
--
-- >>> zip [1] ['a', 'b']
-- [(1,'a')]
--
-- >>> zip [1, 2] ['a']
-- [(1,'a')]
--
-- >>> zip [] [1..]
-- []
--
-- >>> zip [1..] []
-- []
--
--
-- zip is right-lazy:
--
--
-- >>> zip [] undefined
-- []
--
-- >>> zip undefined []
-- *** Exception: Prelude.undefined
-- ...
--
--
-- zip is capable of list fusion, but it is restricted to its
-- first list argument and its resulting list.
zip :: [a] -> [b] -> [(a, b)]
-- | The print function outputs a value of any printable type to the
-- standard output device. Printable types are those that are instances
-- of class Show; print converts values to strings for
-- output using the show operation and adds a newline.
--
-- For example, a program to print the first 20 integers and their powers
-- of 2 could be written as:
--
--
-- main = print ([(n, 2^n) | n <- [0..19]])
--
print :: Show a => a -> IO ()
-- | Boolean "and", lazy in the second argument
(&&) :: Bool -> Bool -> Bool
infixr 3 &&
-- | Boolean "or", lazy in the second argument
(||) :: Bool -> Bool -> Bool
infixr 2 ||
-- | Boolean "not"
not :: Bool -> Bool
-- | A variant of error that does not produce a stack trace.
errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a
-- | A special case of error. It is expected that compilers will
-- recognize this and insert error messages which are more appropriate to
-- the context in which undefined appears.
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
-- | Same as >>=, but with the arguments interchanged.
(=<<) :: Monad m => (a -> m b) -> m a -> m b
infixr 1 =<<
-- | flip f takes its (first) two arguments in the reverse
-- order of f.
--
--
-- >>> flip (++) "hello" "world"
-- "worldhello"
--
flip :: (a -> b -> c) -> b -> a -> c
-- | Strict (call-by-value) application operator. It takes a function and
-- an argument, evaluates the argument to weak head normal form (WHNF),
-- then calls the function with that value.
($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
infixr 0 $!
-- | until p f yields the result of applying f
-- until p holds.
until :: (a -> Bool) -> (a -> a) -> a -> a
-- | asTypeOf is a type-restricted version of const. It is
-- usually used as an infix operator, and its typing forces its first
-- argument (which is usually overloaded) to have the same type as the
-- second.
asTypeOf :: a -> a -> a
-- | the same as flip (-).
--
-- Because - is treated specially in the Haskell grammar,
-- (- e) is not a section, but an application of
-- prefix negation. However, (subtract
-- exp) is equivalent to the disallowed section.
subtract :: Num a => a -> a -> a
-- | The maybe function takes a default value, a function, and a
-- Maybe value. If the Maybe value is Nothing, the
-- function returns the default value. Otherwise, it applies the function
-- to the value inside the Just and returns the result.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> maybe False odd (Just 3)
-- True
--
--
--
-- >>> maybe False odd Nothing
-- False
--
--
-- Read an integer from a string using readMaybe. If we succeed,
-- return twice the integer; that is, apply (*2) to it. If
-- instead we fail to parse an integer, return 0 by default:
--
--
-- >>> import Text.Read ( readMaybe )
--
-- >>> maybe 0 (*2) (readMaybe "5")
-- 10
--
-- >>> maybe 0 (*2) (readMaybe "")
-- 0
--
--
-- Apply show to a Maybe Int. If we have Just n,
-- we want to show the underlying Int n. But if we have
-- Nothing, we return the empty string instead of (for example)
-- "Nothing":
--
--
-- >>> maybe "" show (Just 5)
-- "5"
--
-- >>> maybe "" show Nothing
-- ""
--
maybe :: b -> (a -> b) -> Maybe a -> b
-- | <math>. Extract the elements after the head of a list, which
-- must be non-empty.
--
--
-- >>> tail [1, 2, 3]
-- [2,3]
--
-- >>> tail [1]
-- []
--
-- >>> tail []
-- *** Exception: Prelude.tail: empty list
--
--
-- WARNING: This function is partial. You can use case-matching or
-- uncons instead.
tail :: HasCallStack => [a] -> [a]
-- | <math>. Extract the last element of a list, which must be finite
-- and non-empty.
--
--
-- >>> last [1, 2, 3]
-- 3
--
-- >>> last [1..]
-- * Hangs forever *
--
-- >>> last []
-- *** Exception: Prelude.last: empty list
--
--
-- WARNING: This function is partial. You can use reverse with
-- case-matching, uncons or listToMaybe instead.
last :: HasCallStack => [a] -> a
-- | <math>. Return all the elements of a list except the last one.
-- The list must be non-empty.
--
--
-- >>> init [1, 2, 3]
-- [1,2]
--
-- >>> init [1]
-- []
--
-- >>> init []
-- *** Exception: Prelude.init: empty list
--
--
-- WARNING: This function is partial. You can use reverse with
-- case-matching or uncons instead.
init :: HasCallStack => [a] -> [a]
-- | <math>. scanl is similar to foldl, but returns a
-- list of successive reduced values from the left:
--
--
-- scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
--
--
-- Note that
--
--
-- last (scanl f z xs) == foldl f z xs
--
--
--
-- >>> scanl (+) 0 [1..4]
-- [0,1,3,6,10]
--
-- >>> scanl (+) 42 []
-- [42]
--
-- >>> scanl (-) 100 [1..4]
-- [100,99,97,94,90]
--
-- >>> scanl (\reversedString nextChar -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
-- ["foo","afoo","bafoo","cbafoo","dcbafoo"]
--
-- >>> scanl (+) 0 [1..]
-- * Hangs forever *
--
scanl :: (b -> a -> b) -> b -> [a] -> [b]
-- | <math>. scanl1 is a variant of scanl that has no
-- starting value argument:
--
--
-- scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
--
--
--
-- >>> scanl1 (+) [1..4]
-- [1,3,6,10]
--
-- >>> scanl1 (+) []
-- []
--
-- >>> scanl1 (-) [1..4]
-- [1,-1,-4,-8]
--
-- >>> scanl1 (&&) [True, False, True, True]
-- [True,False,False,False]
--
-- >>> scanl1 (||) [False, False, True, True]
-- [False,False,True,True]
--
-- >>> scanl1 (+) [1..]
-- * Hangs forever *
--
scanl1 :: (a -> a -> a) -> [a] -> [a]
-- | <math>. scanr is the right-to-left dual of scanl.
-- Note that the order of parameters on the accumulating function are
-- reversed compared to scanl. Also note that
--
--
-- head (scanr f z xs) == foldr f z xs.
--
--
--
-- >>> scanr (+) 0 [1..4]
-- [10,9,7,4,0]
--
-- >>> scanr (+) 42 []
-- [42]
--
-- >>> scanr (-) 100 [1..4]
-- [98,-97,99,-96,100]
--
-- >>> scanr (\nextChar reversedString -> nextChar : reversedString) "foo" ['a', 'b', 'c', 'd']
-- ["abcdfoo","bcdfoo","cdfoo","dfoo","foo"]
--
-- >>> force $ scanr (+) 0 [1..]
-- *** Exception: stack overflow
--
scanr :: (a -> b -> b) -> b -> [a] -> [b]
-- | <math>. scanr1 is a variant of scanr that has no
-- starting value argument.
--
--
-- >>> scanr1 (+) [1..4]
-- [10,9,7,4]
--
-- >>> scanr1 (+) []
-- []
--
-- >>> scanr1 (-) [1..4]
-- [-2,3,-1,4]
--
-- >>> scanr1 (&&) [True, False, True, True]
-- [False,False,True,True]
--
-- >>> scanr1 (||) [True, True, False, False]
-- [True,True,False,False]
--
-- >>> force $ scanr1 (+) [1..]
-- *** Exception: stack overflow
--
scanr1 :: (a -> a -> a) -> [a] -> [a]
-- | iterate f x returns an infinite list of repeated
-- applications of f to x:
--
--
-- iterate f x == [x, f x, f (f x), ...]
--
--
-- Note that iterate is lazy, potentially leading to thunk
-- build-up if the consumer doesn't force each iterate. See
-- iterate' for a strict variant of this function.
--
--
-- >>> take 10 $ iterate not True
-- [True,False,True,False...
--
-- >>> take 10 $ iterate (+3) 42
-- [42,45,48,51,54,57,60,63...
--
iterate :: (a -> a) -> a -> [a]
-- | repeat x is an infinite list, with x the
-- value of every element.
--
--
-- >>> repeat 17
-- [17,17,17,17,17,17,17,17,17...
--
repeat :: a -> [a]
-- | replicate n x is a list of length n with
-- x the value of every element. It is an instance of the more
-- general genericReplicate, in which n may be of any
-- integral type.
--
--
-- >>> replicate 0 True
-- []
--
-- >>> replicate (-1) True
-- []
--
-- >>> replicate 4 True
-- [True,True,True,True]
--
replicate :: Int -> a -> [a]
-- | dropWhile p xs returns the suffix remaining after
-- takeWhile p xs.
--
--
-- >>> dropWhile (< 3) [1,2,3,4,5,1,2,3]
-- [3,4,5,1,2,3]
--
-- >>> dropWhile (< 9) [1,2,3]
-- []
--
-- >>> dropWhile (< 0) [1,2,3]
-- [1,2,3]
--
dropWhile :: (a -> Bool) -> [a] -> [a]
-- | drop n xs returns the suffix of xs after the
-- first n elements, or [] if n >= length
-- xs.
--
--
-- >>> drop 6 "Hello World!"
-- "World!"
--
-- >>> drop 3 [1,2,3,4,5]
-- [4,5]
--
-- >>> drop 3 [1,2]
-- []
--
-- >>> drop 3 []
-- []
--
-- >>> drop (-1) [1,2]
-- [1,2]
--
-- >>> drop 0 [1,2]
-- [1,2]
--
--
-- It is an instance of the more general genericDrop, in which
-- n may be of any integral type.
drop :: Int -> [a] -> [a]
-- | splitAt n xs returns a tuple where first element is
-- xs prefix of length n and second element is the
-- remainder of the list:
--
--
-- >>> splitAt 6 "Hello World!"
-- ("Hello ","World!")
--
-- >>> splitAt 3 [1,2,3,4,5]
-- ([1,2,3],[4,5])
--
-- >>> splitAt 1 [1,2,3]
-- ([1],[2,3])
--
-- >>> splitAt 3 [1,2,3]
-- ([1,2,3],[])
--
-- >>> splitAt 4 [1,2,3]
-- ([1,2,3],[])
--
-- >>> splitAt 0 [1,2,3]
-- ([],[1,2,3])
--
-- >>> splitAt (-1) [1,2,3]
-- ([],[1,2,3])
--
--
-- It is equivalent to (take n xs, drop n xs) when
-- n is not _|_ (splitAt _|_ xs = _|_).
-- splitAt is an instance of the more general
-- genericSplitAt, in which n may be of any integral
-- type.
splitAt :: Int -> [a] -> ([a], [a])
-- | span, applied to a predicate p and a list xs,
-- returns a tuple where first element is longest prefix (possibly empty)
-- of xs of elements that satisfy p and second element
-- is the remainder of the list:
--
--
-- >>> span (< 3) [1,2,3,4,1,2,3,4]
-- ([1,2],[3,4,1,2,3,4])
--
-- >>> span (< 9) [1,2,3]
-- ([1,2,3],[])
--
-- >>> span (< 0) [1,2,3]
-- ([],[1,2,3])
--
--
-- span p xs is equivalent to (takeWhile p xs,
-- dropWhile p xs)
span :: (a -> Bool) -> [a] -> ([a], [a])
-- | break, applied to a predicate p and a list
-- xs, returns a tuple where first element is longest prefix
-- (possibly empty) of xs of elements that do not satisfy
-- p and second element is the remainder of the list:
--
--
-- >>> break (> 3) [1,2,3,4,1,2,3,4]
-- ([1,2,3],[4,1,2,3,4])
--
-- >>> break (< 9) [1,2,3]
-- ([],[1,2,3])
--
-- >>> break (> 9) [1,2,3]
-- ([1,2,3],[])
--
--
-- break p is equivalent to span (not .
-- p).
break :: (a -> Bool) -> [a] -> ([a], [a])
-- | reverse xs returns the elements of xs in
-- reverse order. xs must be finite.
--
--
-- >>> reverse []
-- []
--
-- >>> reverse [42]
-- [42]
--
-- >>> reverse [2,5,7]
-- [7,5,2]
--
-- >>> reverse [1..]
-- * Hangs forever *
--
reverse :: [a] -> [a]
-- | and returns the conjunction of a container of Bools. For the
-- result to be True, the container must be finite; False,
-- however, results from a False value finitely far from the left
-- end.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> and []
-- True
--
--
--
-- >>> and [True]
-- True
--
--
--
-- >>> and [False]
-- False
--
--
--
-- >>> and [True, True, False]
-- False
--
--
--
-- >>> and (False : repeat True) -- Infinite list [False,True,True,True,...
-- False
--
--
--
-- >>> and (repeat True)
-- * Hangs forever *
--
and :: Foldable t => t Bool -> Bool
-- | or returns the disjunction of a container of Bools. For the
-- result to be False, the container must be finite; True,
-- however, results from a True value finitely far from the left
-- end.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> or []
-- False
--
--
--
-- >>> or [True]
-- True
--
--
--
-- >>> or [False]
-- False
--
--
--
-- >>> or [True, True, False]
-- True
--
--
--
-- >>> or (True : repeat False) -- Infinite list [True,False,False,False,...
-- True
--
--
--
-- >>> or (repeat False)
-- * Hangs forever *
--
or :: Foldable t => t Bool -> Bool
-- | Determines whether any element of the structure satisfies the
-- predicate.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> any (> 3) []
-- False
--
--
--
-- >>> any (> 3) [1,2]
-- False
--
--
--
-- >>> any (> 3) [1,2,3,4,5]
-- True
--
--
--
-- >>> any (> 3) [1..]
-- True
--
--
--
-- >>> any (> 3) [0, -1..]
-- * Hangs forever *
--
any :: Foldable t => (a -> Bool) -> t a -> Bool
-- | Determines whether all elements of the structure satisfy the
-- predicate.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> all (> 3) []
-- True
--
--
--
-- >>> all (> 3) [1,2]
-- False
--
--
--
-- >>> all (> 3) [1,2,3,4,5]
-- False
--
--
--
-- >>> all (> 3) [1..]
-- False
--
--
--
-- >>> all (> 3) [4..]
-- * Hangs forever *
--
all :: Foldable t => (a -> Bool) -> t a -> Bool
-- | notElem is the negation of elem.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> 3 `notElem` []
-- True
--
--
--
-- >>> 3 `notElem` [1,2]
-- True
--
--
--
-- >>> 3 `notElem` [1,2,3,4,5]
-- False
--
--
-- For infinite structures, notElem terminates if the value exists
-- at a finite distance from the left side of the structure:
--
--
-- >>> 3 `notElem` [1..]
-- False
--
--
--
-- >>> 3 `notElem` ([4..] ++ [3])
-- * Hangs forever *
--
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
infix 4 `notElem`
-- | Map a function over all the elements of a container and concatenate
-- the resulting lists.
--
-- Examples
--
-- Basic usage:
--
--
-- >>> concatMap (take 3) [[1..], [10..], [100..], [1000..]]
-- [1,2,3,10,11,12,100,101,102,1000,1001,1002]
--
--
--
-- >>> concatMap (take 3) (Just [1..])
-- [1,2,3]
--
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
-- | List index (subscript) operator, starting from 0. It is an instance of
-- the more general genericIndex, which takes an index of any
-- integral type.
--
--
-- >>> ['a', 'b', 'c'] !! 0
-- 'a'
--
-- >>> ['a', 'b', 'c'] !! 2
-- 'c'
--
-- >>> ['a', 'b', 'c'] !! 3
-- *** Exception: Prelude.!!: index too large
--
-- >>> ['a', 'b', 'c'] !! (-1)
-- *** Exception: Prelude.!!: negative index
--
--
-- WARNING: This function is partial. You can use atMay instead.
(!!) :: HasCallStack => [a] -> Int -> a
infixl 9 !!
-- | zip3 takes three lists and returns a list of triples, analogous
-- to zip. It is capable of list fusion, but it is restricted to
-- its first list argument and its resulting list.
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
-- | The zipWith3 function takes a function which combines three
-- elements, as well as three lists and returns a list of the function
-- applied to corresponding elements, analogous to zipWith. It is
-- capable of list fusion, but it is restricted to its first list
-- argument and its resulting list.
--
--
-- zipWith3 (,,) xs ys zs == zip3 xs ys zs
-- zipWith3 f [x1,x2,x3..] [y1,y2,y3..] [z1,z2,z3..] == [f x1 y1 z1, f x2 y2 z2, f x3 y3 z3..]
--
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
-- | unzip transforms a list of pairs into a list of first
-- components and a list of second components.
--
--
-- >>> unzip []
-- ([],[])
--
-- >>> unzip [(1, 'a'), (2, 'b')]
-- ([1,2],"ab")
--
unzip :: [(a, b)] -> ([a], [b])
-- | The unzip3 function takes a list of triples and returns three
-- lists, analogous to unzip.
--
--
-- >>> unzip3 []
-- ([],[],[])
--
-- >>> unzip3 [(1, 'a', True), (2, 'b', False)]
-- ([1,2],"ab",[True,False])
--
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
-- | equivalent to showsPrec with a precedence of 0.
shows :: Show a => a -> ShowS
-- | utility function converting a Char to a show function that
-- simply prepends the character unchanged.
showChar :: Char -> ShowS
-- | utility function converting a String to a show function that
-- simply prepends the string unchanged.
showString :: String -> ShowS
-- | utility function that surrounds the inner show function with
-- parentheses when the Bool parameter is True.
showParen :: Bool -> ShowS -> ShowS
odd :: Integral a => a -> Bool
-- | raise a number to an integral power
(^^) :: (Fractional a, Integral b) => a -> b -> a
infixr 8 ^^
-- | gcd x y is the non-negative factor of both x
-- and y of which every common factor of x and
-- y is also a factor; for example gcd 4 2 = 2,
-- gcd (-4) 6 = 2, gcd 0 4 = 4.
-- gcd 0 0 = 0. (That is, the common divisor
-- that is "greatest" in the divisibility preordering.)
--
-- Note: Since for signed fixed-width integer types, abs
-- minBound < 0, the result may be negative if one of the
-- arguments is minBound (and necessarily is if the other
-- is 0 or minBound) for such types.
gcd :: Integral a => a -> a -> a
-- | lcm x y is the smallest positive integer that both
-- x and y divide.
lcm :: Integral a => a -> a -> a
-- | Extract the second component of a pair.
snd :: (a, b) -> b
-- | curry converts an uncurried function to a curried function.
--
-- Examples
--
--
-- >>> curry fst 1 2
-- 1
--
curry :: ((a, b) -> c) -> a -> b -> c
-- | The lex function reads a single lexeme from the input,
-- discarding initial white space, and returning the characters that
-- constitute the lexeme. If the input string contains only white space,
-- lex returns a single successful `lexeme' consisting of the
-- empty string. (Thus lex "" = [("","")].) If there is
-- no legal lexeme at the beginning of the input string, lex fails
-- (i.e. returns []).
--
-- This lexer is not completely faithful to the Haskell lexical syntax in
-- the following respects:
--
--
-- - Qualified names are not handled properly
-- - Octal and hexadecimal numerics are not recognized as a single
-- token
-- - Comments are not treated properly
--
lex :: ReadS String
-- | readParen True p parses what p parses,
-- but surrounded with parentheses.
--
-- readParen False p parses what p
-- parses, but optionally surrounded with parentheses.
readParen :: Bool -> ReadS a -> ReadS a
-- | Case analysis for the Either type. If the value is
-- Left a, apply the first function to a; if it
-- is Right b, apply the second function to b.
--
-- Examples
--
-- We create two values of type Either String
-- Int, one using the Left constructor and another
-- using the Right constructor. Then we apply "either" the
-- length function (if we have a String) or the "times-two"
-- function (if we have an Int):
--
--
-- >>> let s = Left "foo" :: Either String Int
--
-- >>> let n = Right 3 :: Either String Int
--
-- >>> either length (*2) s
-- 3
--
-- >>> either length (*2) n
-- 6
--
either :: (a -> c) -> (b -> c) -> Either a b -> c
-- | equivalent to readsPrec with a precedence of 0.
reads :: Read a => ReadS a
-- | Evaluate each monadic action in the structure from left to right, and
-- ignore the results. For a version that doesn't ignore the results see
-- sequence.
--
-- sequence_ is just like sequenceA_, but specialised to
-- monadic actions.
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
-- | Splits the argument into a list of lines stripped of their
-- terminating \n characters. The \n terminator is
-- optional in a final non-empty line of the argument string.
--
-- For example:
--
--
-- >>> lines "" -- empty input contains no lines
-- []
--
-- >>> lines "\n" -- single empty line
-- [""]
--
-- >>> lines "one" -- single unterminated line
-- ["one"]
--
-- >>> lines "one\n" -- single non-empty line
-- ["one"]
--
-- >>> lines "one\n\n" -- second line is empty
-- ["one",""]
--
-- >>> lines "one\ntwo" -- second line is unterminated
-- ["one","two"]
--
-- >>> lines "one\ntwo\n" -- two non-empty lines
-- ["one","two"]
--
--
-- When the argument string is empty, or ends in a \n character,
-- it can be recovered by passing the result of lines to the
-- unlines function. Otherwise, unlines appends the missing
-- terminating \n. This makes unlines . lines
-- idempotent:
--
--
-- (unlines . lines) . (unlines . lines) = (unlines . lines)
--
lines :: String -> [String]
-- | Appends a \n character to each input string, then
-- concatenates the results. Equivalent to foldMap (s ->
-- s ++ "\n").
--
--
-- >>> unlines ["Hello", "World", "!"]
-- "Hello\nWorld\n!\n"
--
--
-- Note that unlines . lines /=
-- id when the input is not \n-terminated:
--
--
-- >>> unlines . lines $ "foo\nbar"
-- "foo\nbar\n"
--
unlines :: [String] -> String
-- | words breaks a string up into a list of words, which were
-- delimited by white space (as defined by isSpace). This function
-- trims any white spaces at the beginning and at the end.
--
--
-- >>> words "Lorem ipsum\ndolor"
-- ["Lorem","ipsum","dolor"]
--
-- >>> words " foo bar "
-- ["foo","bar"]
--
words :: String -> [String]
-- | unwords joins words with separating spaces (U+0020 SPACE).
--
--
-- >>> unwords ["Lorem", "ipsum", "dolor"]
-- "Lorem ipsum dolor"
--
--
-- unwords is neither left nor right inverse of words:
--
--
-- >>> words (unwords [" "])
-- []
--
-- >>> unwords (words "foo\nbar")
-- "foo bar"
--
unwords :: [String] -> String
-- | Construct an IOException value with a string describing the
-- error. The fail method of the IO instance of the
-- Monad class raises a userError, thus:
--
--
-- instance Monad IO where
-- ...
-- fail s = ioError (userError s)
--
userError :: String -> IOError
-- | Raise an IOException in the IO monad.
ioError :: IOError -> IO a
-- | Write a character to the standard output device (same as
-- hPutChar stdout).
putChar :: Char -> IO ()
-- | Write a string to the standard output device (same as hPutStr
-- stdout).
putStr :: String -> IO ()
-- | Read a character from the standard input device (same as
-- hGetChar stdin).
getChar :: IO Char
-- | The getContents operation returns all user input as a single
-- string, which is read lazily as it is needed (same as
-- hGetContents stdin).
getContents :: IO String
-- | The interact function takes a function of type
-- String->String as its argument. The entire input from the
-- standard input device is passed to this function as its argument, and
-- the resulting string is output on the standard output device.
interact :: (String -> String) -> IO ()
-- | The readFile function reads a file and returns the contents of
-- the file as a string. The file is read lazily, on demand, as with
-- getContents.
readFile :: FilePath -> IO String
-- | The computation appendFile file str function appends
-- the string str, to the file file.
--
-- Note that writeFile and appendFile write a literal
-- string to a file. To write a value of any printable type, as with
-- print, use the show function to convert the value to a
-- string first.
--
--
-- main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])
--
appendFile :: FilePath -> String -> IO ()
-- | The readLn function combines getLine and readIO.
readLn :: Read a => IO a
-- | The readIO function is similar to read except that it
-- signals parse failure to the IO monad instead of terminating
-- the program.
readIO :: Read a => String -> IO a
-- | A functor with application, providing operations to
--
--
-- - embed pure expressions (pure), and
-- - sequence computations and combine their results (<*>
-- and liftA2).
--
--
-- A minimal complete definition must include implementations of
-- pure and of either <*> or liftA2. If it
-- defines both, then they must behave the same as their default
-- definitions:
--
--
-- (<*>) = liftA2 id
--
--
--
-- liftA2 f x y = f <$> x <*> y
--
--
-- Further, any definition must satisfy the following:
--
--
--
-- The other methods have the following default definitions, which may be
-- overridden with equivalent specialized implementations:
--
--
--
-- As a consequence of these laws, the Functor instance for
-- f will satisfy
--
--
--
-- It may be useful to note that supposing
--
--
-- forall x y. p (q x y) = f x . g y
--
--
-- it follows from the above that
--
--
-- liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v
--
--
-- If f is also a Monad, it should satisfy
--
--
--
-- (which implies that pure and <*> satisfy the
-- applicative functor laws).
class Functor f => Applicative (f :: Type -> Type)
-- | Lift a value.
pure :: Applicative f => a -> f a
-- | Sequential application.
--
-- A few functors support an implementation of <*> that is
-- more efficient than the default one.
--
-- Example
--
-- Used in combination with (<$>),
-- (<*>) can be used to build a record.
--
--
-- >>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}
--
--
--
-- >>> produceFoo :: Applicative f => f Foo
--
--
--
-- >>> produceBar :: Applicative f => f Bar
--
-- >>> produceBaz :: Applicative f => f Baz
--
--
--
-- >>> mkState :: Applicative f => f MyState
--
-- >>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz
--
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
-- | Lift a binary function to actions.
--
-- Some functors support an implementation of liftA2 that is more
-- efficient than the default one. In particular, if fmap is an
-- expensive operation, it is likely better to use liftA2 than to
-- fmap over the structure and then use <*>.
--
-- This became a typeclass method in 4.10.0.0. Prior to that, it was a
-- function defined in terms of <*> and fmap.
--
-- Example
--
--
-- >>> liftA2 (,) (Just 3) (Just 5)
-- Just (3,5)
--
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
-- | Sequence actions, discarding the value of the first argument.
--
-- Examples
--
-- If used in conjunction with the Applicative instance for Maybe,
-- you can chain Maybe computations, with a possible "early return" in
-- case of Nothing.
--
--
-- >>> Just 2 *> Just 3
-- Just 3
--
--
--
-- >>> Nothing *> Just 3
-- Nothing
--
--
-- Of course a more interesting use case would be to have effectful
-- computations instead of just returning pure values.
--
--
-- >>> import Data.Char
--
-- >>> import Text.ParserCombinators.ReadP
--
-- >>> let p = string "my name is " *> munch1 isAlpha <* eof
--
-- >>> readP_to_S p "my name is Simon"
-- [("Simon","")]
--
(*>) :: Applicative f => f a -> f b -> f b
-- | Sequence actions, discarding the value of the second argument.
(<*) :: Applicative f => f a -> f b -> f a
infixl 4 <*>
infixl 4 *>
infixl 4 <*
-- | An infix synonym for fmap.
--
-- The name of this operator is an allusion to $. Note the
-- similarities between their types:
--
--
-- ($) :: (a -> b) -> a -> b
-- (<$>) :: Functor f => (a -> b) -> f a -> f b
--
--
-- Whereas $ is function application, <$> is function
-- application lifted over a Functor.
--
-- Examples
--
-- Convert from a Maybe Int to a Maybe
-- String using show:
--
--
-- >>> show <$> Nothing
-- Nothing
--
-- >>> show <$> Just 3
-- Just "3"
--
--
-- Convert from an Either Int Int to an
-- Either Int String using show:
--
--
-- >>> show <$> Left 17
-- Left 17
--
-- >>> show <$> Right 17
-- Right "17"
--
--
-- Double each element of a list:
--
--
-- >>> (*2) <$> [1,2,3]
-- [2,4,6]
--
--
-- Apply even to the second element of a pair:
--
--
-- >>> even <$> (2,2)
-- (2,True)
--
(<$>) :: Functor f => (a -> b) -> f a -> f b
infixl 4 <$>
-- | The class of monoids (types with an associative binary operation that
-- has an identity). Instances should satisfy the following:
--
--
--
-- You can alternatively define mconcat instead of mempty,
-- in which case the laws are:
--
--
--
-- The method names refer to the monoid of lists under concatenation, but
-- there are many other instances.
--
-- Some types can be viewed as a monoid in more than one way, e.g. both
-- addition and multiplication on numbers. In such cases we often define
-- newtypes and make those instances of Monoid, e.g.
-- Sum and Product.
--
-- NOTE: Semigroup is a superclass of Monoid since
-- base-4.11.0.0.
class Semigroup a => Monoid a
-- | Identity of mappend
--
--
-- >>> "Hello world" <> mempty
-- "Hello world"
--
mempty :: Monoid a => a
-- | An associative operation
--
-- NOTE: This method is redundant and has the default
-- implementation mappend = (<>) since
-- base-4.11.0.0. Should it be implemented manually, since
-- mappend is a synonym for (<>), it is expected that
-- the two functions are defined the same way. In a future GHC release
-- mappend will be removed from Monoid.
mappend :: Monoid a => a -> a -> a
-- | Fold a list using the monoid.
--
-- For most types, the default definition for mconcat will be
-- used, but the function is included in the class definition so that an
-- optimized version can be provided for specific types.
--
--
-- >>> mconcat ["Hello", " ", "Haskell", "!"]
-- "Hello Haskell!"
--
mconcat :: Monoid a => [a] -> a
-- | The class of semigroups (types with an associative binary operation).
--
-- Instances should satisfy the following:
--
--
-- - Associativity x <> (y <> z) =
-- (x <> y) <> z
--
--
-- You can alternatively define sconcat instead of
-- (<>), in which case the laws are:
--
--
class () => Semigroup a
-- | An associative operation.
--
--
-- >>> [1,2,3] <> [4,5,6]
-- [1,2,3,4,5,6]
--
(<>) :: Semigroup a => a -> a -> a
-- | Reduce a non-empty list with <>
--
-- The default definition should be sufficient, but this can be
-- overridden for efficiency.
--
--
-- >>> import Data.List.NonEmpty (NonEmpty (..))
--
-- >>> sconcat $ "Hello" :| [" ", "Haskell", "!"]
-- "Hello Haskell!"
--
sconcat :: Semigroup a => NonEmpty a -> a
-- | Repeat a value n times.
--
-- Given that this works on a Semigroup it is allowed to fail if
-- you request 0 or fewer repetitions, and the default definition will do
-- so.
--
-- By making this a member of the class, idempotent semigroups and
-- monoids can upgrade this to execute in <math> by picking
-- stimes = stimesIdempotent or stimes =
-- stimesIdempotentMonoid respectively.
--
--
-- >>> stimes 4 [1]
-- [1,1,1,1]
--
stimes :: (Semigroup a, Integral b) => b -> a -> a
infixr 6 <>
-- | Map each element of a structure to an action, evaluate these actions
-- from left to right, and collect the results. For a version that
-- ignores the results see traverse_.
--
-- Examples
--
-- Basic usage:
--
-- In the first two examples we show each evaluated action mapping to the
-- output structure.
--
--
-- >>> traverse Just [1,2,3,4]
-- Just [1,2,3,4]
--
--
--
-- >>> traverse id [Right 1, Right 2, Right 3, Right 4]
-- Right [1,2,3,4]
--
--
-- In the next examples, we show that Nothing and Left
-- values short circuit the created structure.
--
--
-- >>> traverse (const Nothing) [1,2,3,4]
-- Nothing
--
--
--
-- >>> traverse (\x -> if odd x then Just x else Nothing) [1,2,3,4]
-- Nothing
--
--
--
-- >>> traverse id [Right 1, Right 2, Right 3, Right 4, Left 0]
-- Left 0
--
traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
module Darcs.Patch.Witnesses.Eq
-- | EqCheck is used to pass around evidence (or lack thereof) of
-- two witness types being equal.
data EqCheck wA wB
[IsEq] :: EqCheck wA wA
[NotEq] :: EqCheck wA wB
-- | An witness aware equality class. A minimal definition defines any one
-- of unsafeCompare, =\/= and =/\=.
class Eq2 p
-- | It 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 context
unsafeCompare :: Eq2 p => p wA wB -> p wC wD -> Bool
-- | Compare two things with the same starting witness. If the things
-- compare equal, evidence of the ending witnesses being equal will be
-- returned.
(=\/=) :: Eq2 p => p wA wB -> p wA wC -> EqCheck wB wC
-- | Compare two things with the same ending witness. If the things compare
-- equal, evidence of the starting witnesses being equal will be
-- returned.
(=/\=) :: Eq2 p => p wA wC -> p wB wC -> EqCheck wA wB
infix 4 =\/=
infix 4 =/\=
isIsEq :: EqCheck wA wB -> Bool
instance GHC.Classes.Eq (Darcs.Patch.Witnesses.Eq.EqCheck wA wB)
instance GHC.Show.Show (Darcs.Patch.Witnesses.Eq.EqCheck wA wB)
module Darcs.Patch.RegChars
-- | regChars 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 . (dot) is allowed to be escaped. It has no special
-- meaning if it is not escaped, but the default filename_toks
-- in Darcs.Commands.Replace uses an escaped dot (WHY?).
regChars :: String -> Char -> Bool
module Darcs.Patch.TokenReplace
-- | tryTokReplace tokChars old new input tries to find the token
-- old and replace it with the token new everywhere in
-- the input, returning Just the modified input,
-- unless the token new is already in the input in
-- which case Nothing 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.
tryTokReplace :: String -> ByteString -> ByteString -> ByteString -> Maybe ByteString
-- | forceTokReplace tokChars old new input replaces all
-- occurrences of the old token with the new one,
-- throughout the input.
forceTokReplace :: String -> ByteString -> ByteString -> ByteString -> ByteString
-- | Check if a token replace operation touches the given line.
annotateReplace :: String -> ByteString -> ByteString -> ByteString -> Bool
-- | Break a Bytestring into tokens, according to
-- defaultToks, discarding non-tokens.
breakToTokens :: ByteString -> [ByteString]
defaultToks :: String
module Darcs.Patch.Format
-- | Showing and reading lists of patches. This class allows us to control
-- how lists of patches are formatted on disk. For legacy reasons V1
-- patches have their own special treatment (see ListFormat).
-- 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.
class PatchListFormat p
patchListFormat :: PatchListFormat p => ListFormat p
-- | This 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.
data ListFormat (p :: (* -> * -> *))
-- | Show and read lists without braces.
ListFormatDefault :: ListFormat (p :: * -> * -> *)
-- | Show lists with a single layer of braces around the outside, except
-- for singletons which have no braces. Read with arbitrary nested braces
-- and parens and flatten them out.
ListFormatV1 :: ListFormat (p :: * -> * -> *)
-- | Show lists without braces. Read with arbitrary nested parens and
-- flatten them out.
ListFormatV2 :: ListFormat (p :: * -> * -> *)
-- | Temporary hack to disable use of showContextSeries for darcs-3
-- patches, until I find out how to fix this.
ListFormatV3 :: ListFormat (p :: * -> * -> *)
data FileNameFormat
-- | on-disk format for V1 patches
FileNameFormatV1 :: FileNameFormat
-- | on-disk format for V2 patches
FileNameFormatV2 :: FileNameFormat
-- | display format
FileNameFormatDisplay :: FileNameFormat
instance GHC.Show.Show Darcs.Patch.Format.FileNameFormat
instance GHC.Classes.Eq Darcs.Patch.Format.FileNameFormat
module Darcs.Test.TestOnly
-- | This nullary type class flags code that should only be used for the
-- tests. No instance of it should be defined in either the darcs library
-- or the main darcs executable.
class TestOnly
module Darcs.UI.Options.Iso
-- | Lightweight type ismomorphisms (a.k.a. invertible functions). If
--
--
-- Iso fw bw :: Iso a b
--
--
-- then fw and bw are supposed to satisfy
--
--
-- fw . bw = id = bw . fw
--
data Iso a b
Iso :: (a -> b) -> (b -> a) -> Iso a b
-- | Lift an isomorphism between a and b to one between
-- f a and f b. Like Functor, except we can only
-- map invertible functions (i.e. an Isomorphisms).
class IsoFunctor f
imap :: IsoFunctor f => Iso a b -> f a -> f b
-- | Apply an iso under a functor.
under :: Functor f => Iso a b -> Iso (f a) (f b)
-- | Apply an iso under cps (which is a cofunctor).
cps :: Iso a b -> Iso (a -> c) (b -> c)
-- | Option specifications using continuations with a changing answer type.
--
-- Based on
--
--
-- www.is.ocha.ac.jp/~asai/papers/tr08-2.pdf
--
--
-- with additional inspiration provided by
--
--
-- http://okmij.org/ftp/typed-formatting/FPrintScan.html#DSL-FIn
--
--
-- which shows how the same format specifiers can be used for both
-- sprintf and sscanf.
--
-- The OptSpec type corresponds to the format specifiers for the
-- sprintf and sscanf functions, which I called ounparse and
-- oparse here; they no longer work on Strings but instead
-- on any list (the intention is, of course, that this is a list of
-- flags).
--
-- As explained in the original paper by Kenichi Asai, we cannot use
-- Cont, even with the recent additions of the shift and
-- reset combinators, since Cont requires that the answer
-- type remains the same over the whole computation, while the trick used
-- here requires that the answer type can change.
--
-- Besides parsing and unparsing, the OptSpec type contains two
-- more members: odesc is the list of OptDescr that
-- getOpt needs as input for parsing the command line and for
-- generating the usage help, while ocheck takes a list of flags
-- and returns a list of error messages, which can be used to check for
-- conflicting options.
module Darcs.UI.Options.Core
data OptMsg
OptWarning :: String -> OptMsg
OptError :: String -> OptMsg
-- | 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 Maybe with default Nothing
-- 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 OptSpec type is heavily parameterized. The type arguments
-- are:
--
--
--
-- Abstracting over these types is not technically necessary: for the
-- intended application in Darcs, we could as well fix them as
-- d=DarcsOptDescr, and f=DarcsFlag,
-- saving two type parameters. However, doing that here would only
-- obscure what's going on, making the code harder to understand, not
-- easier. Besides, the resulting more general type signatures give us
-- additional guarantees, known as "free theorems" (free as in beer, not
-- in speak).
--
-- In contrast, the type parameters
--
--
-- - a, b are necessary to make chaining of
-- options a la typed printf/scanf possible. In a nutshell, 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 ounparse and oparse 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 PrimOptSpec 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 oparse and ounparse 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
--
--
-- o1 ^ o2 ^ ... :: OptSpec d f a (v1 -> v2 -> ... -> a)
--
--
-- that is, b gets instantiated to
--
--
-- v1 -> v2 -> ... -> a
--
--
-- To use such an option (primitive or combined), you pass in the
-- consumer. A typical consumer of option values is a command
-- implementation. Given
--
--
-- cmd :: v1 -> v2 -> ... -> [String] -> IO ()
--
--
-- we can parse the flags and pass the results to cmd:
--
--
-- oparse (o1 ^ o2 ^ ...) cmd flags
--
data OptSpec d f a b
OptSpec :: (([f] -> a) -> b) -> (b -> [f] -> a) -> ([f] -> [OptMsg]) -> [d f] -> OptSpec d f a b
-- | Convert option value (back) to flag list, in CPS.
[ounparse] :: OptSpec d f a b -> ([f] -> a) -> b
-- | Convert flag list to option value, in CPS. Note: as a pure function,
-- it is not supposed to fail.
[oparse] :: OptSpec d f a b -> b -> [f] -> a
-- | Check for erros in a flag list, returns error messages.
[ocheck] :: OptSpec d f a b -> [f] -> [OptMsg]
-- | Descriptions, one for each flag that makes up the option.
[odesc] :: OptSpec d f a b -> [d f]
-- | Identity OptSpec, unit for ^
oid :: OptSpec d f a a
-- | OptSpec composition, associative
(^) :: OptSpec d f b c -> OptSpec d f a b -> OptSpec d f a c
-- | Normalise a flag list by parsing and then unparsing it. This adds all
-- implicit (default) flags to the list.
--
--
-- onormalise opts = (oparse opts . ounparse opts) id
--
onormalise :: OptSpec d f [f] b -> [f] -> [f]
-- | The list of default flags for an OptSpec.
--
--
-- defaultFlags opts = onormalise opts []
--
defaultFlags :: OptSpec d f [f] b -> [f]
-- | Lift an isomorphism between b and c to one between
-- OptSpec d f a b and OptSpec d f a c.
--
-- The forward component of the Iso is needed for ounparse,
-- the backward component for oparse. For the other two components
-- this is the identity.
oimap :: Iso b c -> OptSpec d f a b -> OptSpec d f a c
-- | Type 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.
type PrimOptSpec d f a v = OptSpec d f a (v -> a)
-- | Combine two list valued options of the same type "in parellel". This
-- is done by concatenating the resulting option values (oparse),
-- flags (ounparse), errors (ocheck), and descriptors
-- (odesc), respectively, of the input options.
oappend :: PrimOptSpec d f a [v] -> PrimOptSpec d f a [v] -> PrimOptSpec d f a [v]
-- | Unit for oappend.
oempty :: PrimOptSpec d f a [v]
-- | Parse a list of flags against a primitive option spec, returning the
-- value associated with the option. As noted above, this cannot fail
-- because options always have a default value.
--
--
-- parseFlags o fs = oparse o id fs
--
parseFlags :: (forall a. PrimOptSpec d f a v) -> [f] -> v
-- | Unparse a primitive option spec and append it to a list of flags.
unparseOpt :: (forall a. PrimOptSpec d f a v) -> v -> [f] -> [f]
-- | Operator version of parseFlags
--
--
-- opt ? flags = parseFlags opt flags
--
(?) :: (forall a. PrimOptSpec d f a v) -> [f] -> v
infix 5 ?
instance GHC.Base.Semigroup (Darcs.UI.Options.Core.PrimOptSpec d f a [v])
instance GHC.Base.Monoid (Darcs.UI.Options.Core.PrimOptSpec d f a [v])
instance Darcs.UI.Options.Iso.IsoFunctor (Darcs.UI.Options.Core.OptSpec d f a)
-- | This was originally Tomasz Zielonka's AtExit module, slightly
-- generalised to include global variables. Here, we attempt to cover
-- broad, global features, such as exit handlers. These features slightly
-- break the Haskellian purity of darcs, in favour of programming
-- convenience.
module Darcs.Util.AtExit
-- | Registers an IO action to run just before darcs exits. Useful for
-- removing temporary files and directories, for example. Referenced in
-- Issue1914.
atexit :: IO () -> IO ()
withAtexit :: IO a -> IO a
-- | |A parser for commandlines, returns an arg list and expands format
-- strings given in a translation table. Additionally the commandline can
-- end with "%<" specifying that the command expects input on stdin.
--
-- See Darcs.Test.Misc.CommandLine for tests.
module Darcs.Util.CommandLine
-- | parse a commandline returning a list of strings (intended to be used
-- as argv) and a bool value which specifies if the command expects input
-- on stdin format specifiers with a mapping in ftable are accepted and
-- replaced by the given strings. E.g. if the ftable is
-- [(s,"Some subject")], then "%s" is replaced by "Some subject"
parseCmd :: FTable -> String -> Either ParseError ([String], Bool)
-- | for every mapping (c,s), add a mapping with uppercase c and the
-- urlencoded string s
addUrlencoded :: FTable -> FTable
module Darcs.Util.DateTime
-- | Get the current UTCTime from the system clock.
getCurrentTime :: IO UTCTime
toSeconds :: UTCTime -> Integer
formatDateTime :: String -> UTCTime -> String
fromClockTime :: ClockTime -> UTCTime
parseDateTime :: String -> String -> Maybe UTCTime
startOfTime :: UTCTime
module Darcs.Util.Encoding
-- | Encode a String into a ByteString according to the
-- user's locale with the ghc specific //ROUNDTRIP feature added. This
-- means the argument is allowed to contain non-Unicode Chars as
-- produced by decode.
encode :: String -> IO ByteString
-- | Decode a ByteString into a String according to the
-- user's locale with the ghc specific //ROUNDTRIP feature added. This
-- means the result may contain Chars that are not valid Unicode
-- in case decoding with the user's locale fails.
decode :: ByteString -> IO String
encodeUtf8 :: String -> IO ByteString
decodeUtf8 :: ByteString -> IO String
-- | This was originally Tomasz Zielonka's AtExit module, slightly
-- generalised to include global variables. Here, we attempt to cover
-- broad, global features, such as exit handlers. These features slightly
-- break the Haskellian purity of darcs, in favour of programming
-- convenience.
module Darcs.Util.Global
setTimingsMode :: IO ()
whenDebugMode :: IO () -> IO ()
withDebugMode :: (Bool -> IO a) -> IO a
setDebugMode :: IO ()
debugMessage :: String -> IO ()
addCRCWarning :: FilePath -> IO ()
getCRCWarnings :: IO [FilePath]
resetCRCWarnings :: IO ()
darcsdir :: String
darcsLastMessage :: String
darcsSendMessage :: String
darcsSendMessageFinal :: String
defaultRemoteDarcsCmd :: String
-- | GZIp and MMap IO for ByteStrings, encoding utilities, and
-- miscellaneous functions for Data.ByteString
module Darcs.Util.ByteString
-- | Read an entire file, which may or may not be gzip compressed, directly
-- into a ByteString.
gzReadFilePS :: FilePath -> IO ByteString
-- | Like readFilePS, this reads an entire file directly into a
-- ByteString, but it is even more efficient. It involves directly
-- mapping the file to memory. This has the advantage that the contents
-- of the file never need to be copied. Also, under memory pressure the
-- page may simply be discarded, wile in the case of readFilePS it would
-- need to be written to swap. If you read many small files, mmapFilePS
-- will be less memory-efficient than readFilePS, since each mmapFilePS
-- takes up a separate page of memory. Also, you can run into bus errors
-- if the file is modified.
mmapFilePS :: FilePath -> IO ByteString
gzWriteFilePS :: FilePath -> ByteString -> IO ()
gzWriteFilePSs :: FilePath -> [ByteString] -> IO ()
-- | Read standard input, which may or may not be gzip compressed, directly
-- into a ByteString.
gzReadStdin :: IO ByteString
gzWriteHandle :: Handle -> [ByteString] -> IO ()
-- | Pointer to a filesystem, possibly with start/end offsets. Supposed to
-- be fed to (uncurry mmapFileByteString) or similar.
type FileSegment = (FilePath, Maybe (Int64, Int))
-- | Read in a FileSegment into a Lazy ByteString. Implemented using mmap.
readSegment :: FileSegment -> IO ByteString
isGZFile :: FilePath -> IO (Maybe Int)
-- | Decompress the given bytestring into a lazy list of chunks, along with
-- a boolean flag indicating (if True) that the CRC was corrupted.
-- Inspecting the flag will cause the entire list of chunks to be
-- evaluated (but if you throw away the list immediately this should run
-- in constant space).
gzDecompress :: Maybe Int -> ByteString -> ([ByteString], Bool)
-- | Drop leading white space, where white space is defined as consisting
-- of ' ', 't', 'n', or 'r'.
dropSpace :: ByteString -> ByteString
-- | Split the input into lines, that is, sections separated by 'n' bytes,
-- unless it is empty, in which case the result has one empty line.
linesPS :: ByteString -> [ByteString]
-- | Concatenate the inputs with 'n' bytes in interspersed.
unlinesPS :: [ByteString] -> ByteString
hashPS :: ByteString -> Int32
breakFirstPS :: Char -> ByteString -> Maybe (ByteString, ByteString)
breakLastPS :: Char -> ByteString -> Maybe (ByteString, ByteString)
substrPS :: ByteString -> ByteString -> Maybe Int
isFunky :: ByteString -> Bool
fromHex2PS :: ByteString -> Either String ByteString
fromPS2Hex :: ByteString -> ByteString
-- | Return the B.ByteString between the two lines given, or Nothing if
-- either of them does not appear.
--
-- Precondition: the first two arguments (start and end line) must be
-- non-empty and contain no newline bytes.
betweenLinesPS :: ByteString -> ByteString -> ByteString -> Maybe ByteString
-- | O(n) The intercalate function takes a ByteString
-- and a list of ByteStrings and concatenates the list after
-- interspersing the first argument between each element of the list.
intercalate :: ByteString -> [ByteString] -> ByteString
-- | Test if a ByteString is made of ascii characters
isAscii :: ByteString -> Bool
-- | Decode a ByteString to a String according to the
-- current locale, using lone surrogates for un-decodable bytes.
decodeLocale :: ByteString -> String
-- | Encode a String to a ByteString according to the
-- current locale, converting lone surrogates back to the original byte.
-- If that fails (because the locale does not support the full unicode
-- range) then encode using utf-8, assuming that the un-ecodable
-- characters come from patch meta data.
--
-- See also setEnvCautiously.
encodeLocale :: String -> ByteString
-- | Decode a ByteString containing UTF-8 to a String.
-- Decoding errors are flagged with the U+FFFD character.
unpackPSFromUTF8 :: ByteString -> String
-- | Encode a String to a ByteString using UTF-8.
packStringToUTF8 :: String -> ByteString
prop_unlinesPS_linesPS_left_inverse :: ByteString -> Bool
prop_linesPS_length :: ByteString -> Bool
prop_unlinesPS_length :: [ByteString] -> Bool
propHexConversion :: ByteString -> Bool
-- | Simpler but less efficient variant of betweenLinesPS. Note that
-- this is only equivalent under the stated preconditions.
spec_betweenLinesPS :: ByteString -> ByteString -> ByteString -> Maybe ByteString
-- | LCS stands for Longest Common Subsequence, and it is a relatively
-- challenging problem to find an LCS efficiently. This module implements
-- the algorithm described in:
--
-- "An O(ND) Difference Algorithm and its Variations", Eugene Myers,
-- Algorithmica Vol. 1 No. 2, 1986, pp. 251-266; especially the variation
-- described in section 4.2 and most refinements implemented in GNU diff
-- (D is the edit-distance).
--
-- There is currently no heuristic to reduce the running time and produce
-- suboptimal output for large inputs with many differences. It behaves
-- like GNU diff with the -d option in this regard.
--
-- In the first step, a hash value for every line is calculated and
-- collisions are marked with a special value. This reduces a string
-- comparison to an int comparison for line tuples where at least one of
-- the hash values is not equal to the special value. After that, lines
-- which only exists in one of the files are removed and marked as
-- changed which reduces the running time of the following difference
-- algorithm. GNU diff additionally removes lines that appear very often
-- in the other file in some cases. The last step tries to create longer
-- changed regions and line up deletions in the first file to insertions
-- in the second by shifting changed lines forward and backward.
module Darcs.Util.Diff.Myers
-- | create a list of changes between a and b, each change has the form
-- (starta, lima, startb, limb) which means that a[starta, lima) has to
-- be replaced by b[startb, limb)
getChanges :: [ByteString] -> [ByteString] -> [(Int, [ByteString], [ByteString])]
-- | try to create nicer diffs by shifting around regions of changed lines
shiftBoundaries :: BSTArray s -> BSTArray s -> PArray -> Int -> Int -> ST s ()
initP :: [ByteString] -> PArray
aLen :: IArray a e => a Int e -> Int
type PArray = Array Int ByteString
getSlice :: PArray -> Int -> Int -> [ByteString]
module Darcs.Util.Diff.Patience
getChanges :: [ByteString] -> [ByteString] -> [(Int, [ByteString], [ByteString])]
module Darcs.Util.Diff
getChanges :: DiffAlgorithm -> [ByteString] -> [ByteString] -> [(Int, [ByteString], [ByteString])]
data DiffAlgorithm
PatienceDiff :: DiffAlgorithm
MyersDiff :: DiffAlgorithm
instance GHC.Show.Show Darcs.Util.Diff.DiffAlgorithm
instance GHC.Classes.Eq Darcs.Util.Diff.DiffAlgorithm
module Darcs.Repository.Flags
data RemoteDarcs
RemoteDarcs :: String -> RemoteDarcs
DefaultRemoteDarcs :: RemoteDarcs
remoteDarcs :: RemoteDarcs -> String
data Reorder
NoReorder :: Reorder
Reorder :: Reorder
data Verbosity
Quiet :: Verbosity
NormalVerbosity :: Verbosity
Verbose :: Verbosity
data UpdatePending
YesUpdatePending :: UpdatePending
NoUpdatePending :: UpdatePending
data UseCache
YesUseCache :: UseCache
NoUseCache :: UseCache
data DryRun
YesDryRun :: DryRun
NoDryRun :: DryRun
data UMask
YesUMask :: String -> UMask
NoUMask :: UMask
data LookForAdds
NoLookForAdds :: LookForAdds
YesLookForAdds :: LookForAdds
EvenLookForBoring :: LookForAdds
data LookForReplaces
YesLookForReplaces :: LookForReplaces
NoLookForReplaces :: LookForReplaces
data DiffAlgorithm
PatienceDiff :: DiffAlgorithm
MyersDiff :: DiffAlgorithm
data LookForMoves
YesLookForMoves :: LookForMoves
NoLookForMoves :: LookForMoves
data DiffOpts
DiffOpts :: UseIndex -> LookForAdds -> LookForReplaces -> LookForMoves -> DiffAlgorithm -> DiffOpts
[withIndex] :: DiffOpts -> UseIndex
[lookForAdds] :: DiffOpts -> LookForAdds
[lookForReplaces] :: DiffOpts -> LookForReplaces
[lookForMoves] :: DiffOpts -> LookForMoves
[diffAlg] :: DiffOpts -> DiffAlgorithm
data RunTest
YesRunTest :: RunTest
NoRunTest :: RunTest
data SetScriptsExecutable
YesSetScriptsExecutable :: SetScriptsExecutable
NoSetScriptsExecutable :: SetScriptsExecutable
data LeaveTestDir
YesLeaveTestDir :: LeaveTestDir
NoLeaveTestDir :: LeaveTestDir
data SetDefault
YesSetDefault :: Bool -> SetDefault
NoSetDefault :: Bool -> SetDefault
data InheritDefault
YesInheritDefault :: InheritDefault
NoInheritDefault :: InheritDefault
data UseIndex
UseIndex :: UseIndex
IgnoreIndex :: UseIndex
data CloneKind
-- | Just copy pristine and inventories
LazyClone :: CloneKind
-- | First do a lazy clone then copy everything
NormalClone :: CloneKind
-- | Same as Normal but omit telling user they can interrumpt
CompleteClone :: CloneKind
data AllowConflicts
NoAllowConflicts :: AllowConflicts
YesAllowConflicts :: ResolveConflicts -> AllowConflicts
data ResolveConflicts
NoResolveConflicts :: ResolveConflicts
MarkConflicts :: ResolveConflicts
ExternalMerge :: String -> ResolveConflicts
data WorkRepo
WorkRepoDir :: String -> WorkRepo
WorkRepoPossibleURL :: String -> WorkRepo
WorkRepoCurrentDir :: WorkRepo
data WantGuiPause
YesWantGuiPause :: WantGuiPause
NoWantGuiPause :: WantGuiPause
data WithPatchIndex
YesPatchIndex :: WithPatchIndex
NoPatchIndex :: WithPatchIndex
data WithWorkingDir
WithWorkingDir :: WithWorkingDir
NoWorkingDir :: WithWorkingDir
data ForgetParent
YesForgetParent :: ForgetParent
NoForgetParent :: ForgetParent
data PatchFormat
PatchFormat1 :: PatchFormat
PatchFormat2 :: PatchFormat
PatchFormat3 :: PatchFormat
data WithPrefsTemplates
WithPrefsTemplates :: WithPrefsTemplates
NoPrefsTemplates :: WithPrefsTemplates
data OptimizeDeep
OptimizeShallow :: OptimizeDeep
OptimizeDeep :: OptimizeDeep
instance GHC.Show.Show Darcs.Repository.Flags.Verbosity
instance GHC.Classes.Eq Darcs.Repository.Flags.Verbosity
instance GHC.Show.Show Darcs.Repository.Flags.WithPatchIndex
instance GHC.Classes.Eq Darcs.Repository.Flags.WithPatchIndex
instance GHC.Show.Show Darcs.Repository.Flags.RemoteDarcs
instance GHC.Classes.Eq Darcs.Repository.Flags.RemoteDarcs
instance GHC.Classes.Eq Darcs.Repository.Flags.Reorder
instance GHC.Show.Show Darcs.Repository.Flags.UpdatePending
instance GHC.Classes.Eq Darcs.Repository.Flags.UpdatePending
instance GHC.Show.Show Darcs.Repository.Flags.UseCache
instance GHC.Classes.Eq Darcs.Repository.Flags.UseCache
instance GHC.Show.Show Darcs.Repository.Flags.DryRun
instance GHC.Classes.Eq Darcs.Repository.Flags.DryRun
instance GHC.Show.Show Darcs.Repository.Flags.UMask
instance GHC.Classes.Eq Darcs.Repository.Flags.UMask
instance GHC.Show.Show Darcs.Repository.Flags.LookForAdds
instance GHC.Classes.Eq Darcs.Repository.Flags.LookForAdds
instance GHC.Show.Show Darcs.Repository.Flags.LookForReplaces
instance GHC.Classes.Eq Darcs.Repository.Flags.LookForReplaces
instance GHC.Show.Show Darcs.Repository.Flags.LookForMoves
instance GHC.Classes.Eq Darcs.Repository.Flags.LookForMoves
instance GHC.Show.Show Darcs.Repository.Flags.RunTest
instance GHC.Classes.Eq Darcs.Repository.Flags.RunTest
instance GHC.Show.Show Darcs.Repository.Flags.SetScriptsExecutable
instance GHC.Classes.Eq Darcs.Repository.Flags.SetScriptsExecutable
instance GHC.Show.Show Darcs.Repository.Flags.LeaveTestDir
instance GHC.Classes.Eq Darcs.Repository.Flags.LeaveTestDir
instance GHC.Show.Show Darcs.Repository.Flags.SetDefault
instance GHC.Classes.Eq Darcs.Repository.Flags.SetDefault
instance GHC.Show.Show Darcs.Repository.Flags.InheritDefault
instance GHC.Classes.Eq Darcs.Repository.Flags.InheritDefault
instance GHC.Show.Show Darcs.Repository.Flags.UseIndex
instance GHC.Classes.Eq Darcs.Repository.Flags.UseIndex
instance GHC.Show.Show Darcs.Repository.Flags.DiffOpts
instance GHC.Show.Show Darcs.Repository.Flags.CloneKind
instance GHC.Classes.Eq Darcs.Repository.Flags.CloneKind
instance GHC.Show.Show Darcs.Repository.Flags.ResolveConflicts
instance GHC.Classes.Eq Darcs.Repository.Flags.ResolveConflicts
instance GHC.Show.Show Darcs.Repository.Flags.AllowConflicts
instance GHC.Classes.Eq Darcs.Repository.Flags.AllowConflicts
instance GHC.Show.Show Darcs.Repository.Flags.WorkRepo
instance GHC.Classes.Eq Darcs.Repository.Flags.WorkRepo
instance GHC.Show.Show Darcs.Repository.Flags.WantGuiPause
instance GHC.Classes.Eq Darcs.Repository.Flags.WantGuiPause
instance GHC.Show.Show Darcs.Repository.Flags.WithWorkingDir
instance GHC.Classes.Eq Darcs.Repository.Flags.WithWorkingDir
instance GHC.Show.Show Darcs.Repository.Flags.ForgetParent
instance GHC.Classes.Eq Darcs.Repository.Flags.ForgetParent
instance GHC.Show.Show Darcs.Repository.Flags.PatchFormat
instance GHC.Classes.Eq Darcs.Repository.Flags.PatchFormat
instance GHC.Show.Show Darcs.Repository.Flags.WithPrefsTemplates
instance GHC.Classes.Eq Darcs.Repository.Flags.WithPrefsTemplates
instance GHC.Show.Show Darcs.Repository.Flags.OptimizeDeep
instance GHC.Classes.Eq Darcs.Repository.Flags.OptimizeDeep
module Darcs.Util.Graph
-- | Undirected graph represented as a Vector of adjacency
-- VertexSets.
type Graph = Vector VertexSet
-- | Vertices are represented as Int.
type Vertex = Int
-- | Set of vertices, represented as a list for efficiency (yes, indeed).
type VertexSet = [Vertex]
data Component
Component :: Graph -> VertexSet -> Component
-- | Determine the maximal independent sets in a Component of a
-- Graph.
ltmis :: (Bool, Bool) -> Component -> [VertexSet]
-- | The classic Bron-Kerbosch algorithm for determining the maximal
-- independent sets in a Graph.
bkmis :: Graph -> [VertexSet]
-- | Split a Graph into connected components. For efficiency we
-- don't represent the result as a list of Graphs, but rather of
-- VertexSets.
components :: Graph -> [Component]
-- | Enumerate all (simple) graphs of a given size (number of vertices).
genGraphs :: Int -> [Graph]
genComponents :: Int -> [Component]
-- | Whether ltmis is equivalent to bkmis.
prop_ltmis_eq_bkmis :: Graph -> Bool
-- | Whether ltmis generates only maximal independent sets.
prop_ltmis_maximal_independent_sets :: Component -> Bool
-- | Whether ltmis generates all maximal independent sets.
prop_ltmis_all_maximal_independent_sets :: Component -> Bool
-- | Complete specification of the components function.
prop_components :: Graph -> Bool
instance GHC.Show.Show Darcs.Util.Graph.Component
module Darcs.Util.HTTP
data Cachable
Cachable :: Cachable
Uncachable :: Cachable
MaxAge :: !CInt -> Cachable
copyRemote :: String -> FilePath -> Cachable -> IO ()
copyRemoteLazy :: String -> Cachable -> IO ByteString
speculateRemote :: String -> FilePath -> IO ()
postUrl :: String -> ByteString -> String -> IO ()
instance GHC.Classes.Eq Darcs.Util.HTTP.Cachable
instance GHC.Show.Show Darcs.Util.HTTP.Cachable
module Darcs.Util.Hash
newtype Hash
SHA256 :: ShortByteString -> Hash
-- | Produce a base16 (ascii-hex) encoded string from a hash. This can be
-- turned back into a Hash (see "decodeBase16". This is a loss-less
-- process.
encodeBase16 :: Hash -> ByteString
-- | Take a base16-encoded string and decode it as a Hash. If the
-- string is malformed, yields Nothing.
decodeBase16 :: ByteString -> Maybe Hash
-- | Compute a sha256 of a (lazy) ByteString.
sha256 :: ByteString -> Hash
sha256strict :: ByteString -> Hash
-- | Same as previous but general purpose.
sha256sum :: ByteString -> String
rawHash :: Hash -> ByteString
mkHash :: ByteString -> Hash
match :: Maybe Hash -> Maybe Hash -> Bool
encodeHash :: Hash -> String
decodeHash :: String -> Maybe Hash
showHash :: Maybe Hash -> String
sha1PS :: ByteString -> SHA1
data SHA1
SHA1 :: !Word32 -> !Word32 -> !Word32 -> !Word32 -> !Word32 -> SHA1
showAsHex :: Word32 -> String
sha1Xor :: SHA1 -> SHA1 -> SHA1
sha1zero :: SHA1
sha1short :: SHA1 -> Word32
sha1Show :: SHA1 -> ByteString
-- | Parse a SHA1 directly from its B16 encoding, given as a
-- ByteString, or return Nothing. The implementation is
-- quite low-level and optimized because the current implementation of
-- RepoPatchV3 has to read lots of SHA1 hashes, and profiling
-- showed that this is a bottleneck.
sha1Read :: ByteString -> Maybe SHA1
instance GHC.Read.Read Darcs.Util.Hash.Hash
instance GHC.Classes.Ord Darcs.Util.Hash.Hash
instance GHC.Classes.Eq Darcs.Util.Hash.Hash
instance GHC.Show.Show Darcs.Util.Hash.Hash
instance GHC.Classes.Ord Darcs.Util.Hash.SHA1
instance GHC.Classes.Eq Darcs.Util.Hash.SHA1
instance GHC.Show.Show Darcs.Util.Hash.SHA1
instance Data.Binary.Class.Binary Darcs.Util.Hash.SHA1
module Darcs.Util.IndexedMonad
-- | An alternative monad class, indexed by a "from" and "to" state.
class Monad m
return :: Monad m => a -> m i i a
(>>=) :: Monad m => m i j a -> (a -> m j k b) -> m i k b
(>>) :: Monad m => m i j a -> m j k b -> m i k b
-- | A class for indexed monad transformers, going from normal Haskell
-- monads into our indexed monads.
class LiftIx t
liftIx :: LiftIx t => m a -> t m i i a
when :: Monad m => Bool -> m i i () -> m i i ()
ifThenElse :: Bool -> a -> a -> a
-- | An indexed version of the standard MonadReader class
class Monad m => MonadReader r m | m -> r
ask :: MonadReader r m => m i i r
local :: MonadReader r m => (r -> r) -> m i i a -> m i i a
-- | An indexed version of the standard ReaderT transformer
newtype ReaderT r m i j a
ReaderT :: (r -> m i j a) -> ReaderT r m i j a
[runReaderT] :: ReaderT r m i j a -> r -> m i j a
asks :: MonadReader r m => (r -> a) -> m i i a
instance Darcs.Util.IndexedMonad.Monad m => Darcs.Util.IndexedMonad.Monad (Darcs.Util.IndexedMonad.ReaderT r m)
instance Darcs.Util.IndexedMonad.Monad m => Darcs.Util.IndexedMonad.MonadReader r (Darcs.Util.IndexedMonad.ReaderT r m)
module Darcs.Util.IsoDate
-- | The current time in the format returned by showIsoDateTime
getIsoDateTime :: IO String
-- | Read/interpret a date string, assuming UTC if timezone is not
-- specified in the string (see readDate) Warning! This errors out
-- if we fail to interpret the date
readUTCDate :: String -> CalendarTime
-- | Similar to readUTCDate, except we ignore timezone info
-- in the input string. This is incorrect and ugly. The only reason it
-- still exists is so we can generate file names for old-fashioned
-- repositories in the same way that old darcs versions expected them.
-- You should not use this function except for the above stated purpose.
readUTCDateOldFashioned :: String -> CalendarTime
-- | Parse a date string, assuming a default timezone if the date string
-- does not specify one. The date formats understood are those of
-- showIsoDateTime and dateTime
parseDate :: Int -> String -> Either ParseError MCalendarTime
-- | Return the local timezone offset from UTC in seconds
getLocalTz :: IO Int
-- | In English, either a date followed by a time, or vice-versa, e.g,
--
--
-- - yesterday at noon
-- - yesterday tea time
-- - 12:00 yesterday
--
--
-- See englishDate and englishTime Uses its first argument
-- as "now", i.e. the time relative to which "yesterday", "today" etc are
-- to be interpreted
englishDateTime :: CalendarTime -> CharParser a CalendarTime
-- | English expressions for intervals of time,
--
--
-- - before tea time (i.e. from the beginning of time)
-- - after 14:00 last month (i.e. till now)
-- - between last year and last month
-- - in the last three months (i.e. from then till now)
-- - 4 months ago (i.e. till now; see englishAgo)
--
englishInterval :: CalendarTime -> CharParser a TimeInterval
-- | Durations in English that begin with the word "last", E.g. "last 4
-- months" is treated as the duration between 4 months ago and now
englishLast :: CalendarTime -> CharParser a (CalendarTime, CalendarTime)
-- | Intervals in ISO 8601, e.g.,
--
--
-- - 2008-09/2012-08-17T16:30
-- - 2008-09/P2Y11MT16H30M
-- - P2Y11MT16H30M/2012-08-17T16:30
--
--
-- See iso8601Duration
iso8601Interval :: Int -> CharParser a (Either TimeDiff (MCalendarTime, MCalendarTime))
-- | Durations in ISO 8601, e.g.,
--
--
-- - P4Y (four years)
-- - P5M (five months)
-- - P4Y5M (four years and five months)
-- - P4YT3H6S (four years, three hours and six seconds)
--
iso8601Duration :: CharParser a TimeDiff
-- | Convert a date string into ISO 8601 format (yyyymmdd variant) assuming
-- local timezone if not specified in the string Warning! This errors out
-- if we fail to interpret the date
cleanLocalDate :: String -> IO String
-- | Set 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)
resetCalendar :: CalendarTime -> CalendarTime
-- | An MCalenderTime is an underspecified CalendarTime It
-- is used for parsing dates. For example, if you want to parse the date
-- '4 January', it may be useful to underspecify the year by setting it
-- to Nothing. This uses almost the same fields as
-- CalendarTime, a notable exception being that we introduce
-- mctWeek to indicate if a weekday was specified or not
data MCalendarTime
MCalendarTime :: Maybe Int -> Maybe Month -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Int -> Maybe Integer -> Maybe Day -> Maybe Int -> Maybe String -> Maybe Int -> Maybe Bool -> Bool -> MCalendarTime
[mctYear] :: MCalendarTime -> Maybe Int
[mctMonth] :: MCalendarTime -> Maybe Month
[mctDay] :: MCalendarTime -> Maybe Int
[mctHour] :: MCalendarTime -> Maybe Int
[mctMin] :: MCalendarTime -> Maybe Int
[mctSec] :: MCalendarTime -> Maybe Int
[mctPicosec] :: MCalendarTime -> Maybe Integer
[mctWDay] :: MCalendarTime -> Maybe Day
[mctYDay] :: MCalendarTime -> Maybe Int
[mctTZName] :: MCalendarTime -> Maybe String
[mctTZ] :: MCalendarTime -> Maybe Int
[mctIsDST] :: MCalendarTime -> Maybe Bool
[mctWeek] :: MCalendarTime -> Bool
subtractFromMCal :: TimeDiff -> MCalendarTime -> MCalendarTime
addToMCal :: TimeDiff -> MCalendarTime -> MCalendarTime
-- | Trivially convert a CalendarTime to a fully specified
-- MCalendarTime (note that this sets the mctWeek flag to
-- False
toMCalendarTime :: CalendarTime -> MCalendarTime
-- | Returns the first CalendarTime that falls within a
-- MCalendarTime 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
-- resetCalendar
unsafeToCalendarTime :: MCalendarTime -> CalendarTime
-- | Zero the time fields of a CalendarTime
unsetTime :: CalendarTime -> CalendarTime
type TimeInterval = (Maybe CalendarTime, Maybe CalendarTime)
-- | Display a CalendarTime in the ISO 8601 format without any
-- separators, e.g. 20080825142503
showIsoDateTime :: CalendarTime -> String
-- | The very beginning of time, i.e. 1970-01-01
theBeginning :: CalendarTime
instance GHC.Show.Show Darcs.Util.IsoDate.MCalendarTime
module Darcs.Util.DateMatcher
-- | parseDateMatcher s return the first matcher in
-- getMatchers that can parse s
parseDateMatcher :: String -> IO (CalendarTime -> Bool)
-- | A DateMatcher 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.
data DateMatcher
DM :: String -> Either ParseError d -> (d -> CalendarTime -> Bool) -> DateMatcher
-- | getMatchers d 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.
getMatchers :: String -> IO [DateMatcher]
-- | testDate d shows the possible interpretations for the
-- date string d and how they match against the current date
testDate :: String -> IO ()
-- | testDate iso d shows the possible interpretations for
-- the date string d and how they match against the date
-- represented by the ISO 8601 string iso
testDateAt :: String -> String -> IO ()
module Darcs.Util.Parser
type Parser = Parser ByteString
-- | Match any character.
anyChar :: Parser Char
char :: Char -> Parser ()
checkConsumes :: Parser a -> Parser a
-- | choice ps tries to apply the actions in the list ps
-- in order, until one of them succeeds. Returns the value of the
-- succeeding action.
choice :: Alternative f => [f a] -> f a
-- | Match only if all input has been consumed.
endOfInput :: Chunk t => Parser t ()
int :: Parser Int
lexChar :: Char -> Parser ()
lexString :: ByteString -> Parser ()
linesStartingWith :: Char -> Parser [ByteString]
linesStartingWithEndingWith :: Char -> Char -> Parser [ByteString]
lexWord :: Parser ByteString
-- | Apply a parser without consuming any input.
lookAhead :: Parser i a -> Parser i a
-- | Zero or more.
many :: Alternative f => f a -> f [a]
-- | option x p tries to apply action p. If p
-- fails without consuming input, it returns the value x,
-- otherwise the value returned by p.
--
--
-- priority = option 0 (digitToInt <$> digit)
--
option :: Alternative f => a -> f a -> f a
-- | One or none.
--
-- It is useful for modelling any computation that is allowed to fail.
--
-- Examples
--
-- Using the Alternative instance of Control.Monad.Except,
-- the following functions:
--
--
-- >>> import Control.Monad.Except
--
--
--
-- >>> canFail = throwError "it failed" :: Except String Int
--
-- >>> final = return 42 :: Except String Int
--
--
-- Can be combined by allowing the first function to fail:
--
--
-- >>> runExcept $ canFail *> final
-- Left "it failed"
--
-- >>> runExcept $ optional canFail *> final
-- Right 42
--
optional :: Alternative f => f a -> f (Maybe a)
parse :: Parser a -> ByteString -> Either String (a, ByteString)
parseAll :: Parser a -> ByteString -> Either String a
-- | Skip over white space.
skipSpace :: Parser ()
-- | Skip past input for as long as the predicate returns True.
skipWhile :: (Char -> Bool) -> Parser ()
string :: ByteString -> Parser ()
-- | Consume exactly n bytes of input.
take :: Int -> Parser ByteString
-- | Consume input as long as the predicate returns False (i.e.
-- until it returns True), and return the consumed input.
--
-- This parser does not fail. It will return an empty string if the
-- predicate returns True on the first byte of input.
--
-- Note: Because this parser does not fail, do not use it with
-- combinators such as many, because such parsers loop until a
-- failure occurs. Careless use will thus result in an infinite loop.
takeTill :: (Char -> Bool) -> Parser ByteString
takeTillChar :: Char -> Parser ByteString
unsigned :: Integral a => Parser a
withPath :: FilePath -> Either String a -> Either String a
-- | An associative binary operation
(<|>) :: Alternative f => f a -> f a -> f a
infixl 3 <|>
-- | Darcs pretty printing library
--
-- The combinator names are taken from HughesPJ, although the
-- behaviour of the two libraries is slightly different.
--
-- This code was made generic in the element type by Juliusz Chroboczek.
module Darcs.Util.Printer
-- | A Doc is a bit of enriched text. Docs are concatenated
-- using <> from class Monoid, which is
-- right-associative.
newtype Doc
Doc :: (St -> Document) -> Doc
[unDoc] :: Doc -> St -> Document
-- | The empty Doc
empty :: Doc
-- | An associative operation.
--
--
-- >>> [1,2,3] <> [4,5,6]
-- [1,2,3,4,5,6]
--
(<>) :: Semigroup a => a -> a -> a
infixr 6 <>
-- | a <?> b is a <> b if
-- a is not empty, else empty
() :: Doc -> Doc -> Doc
-- | a <+> b is a followed by b
-- with a space in between if both are non-empty
(<+>) :: Doc -> Doc -> Doc
infixr 6 <+>
-- | a $$ b is a above b
($$) :: Doc -> Doc -> Doc
infixr 5 $$
-- | a $+$ b is a above b with an empty
-- line in between if both are non-empty
($+$) :: Doc -> Doc -> Doc
infixr 5 $+$
-- | Pile Docs vertically
vcat :: [Doc] -> Doc
-- | Pile Docs vertically, with a blank line in between
vsep :: [Doc] -> Doc
-- | Concatenate Docs horizontally
hcat :: [Doc] -> Doc
-- | Concatenate Docs horizontally with a space as separator
hsep :: [Doc] -> Doc
-- | A Doc representing a "-"
minus :: Doc
-- | A Doc representing a newline
newline :: Doc
-- | A Doc representing a "+"
plus :: Doc
-- | A Doc representing a space (" ")
space :: Doc
-- | A Doc representing a "\"
backslash :: Doc
-- | A Doc that represents "("
lparen :: Doc
-- | A Doc that represents ")"
rparen :: Doc
-- |
-- parens d = lparen <> d <> rparen
--
parens :: Doc -> Doc
-- | Turn a Doc into a sentence. This appends a ".".
sentence :: Doc -> Doc
-- | text creates a Doc from a String, using
-- printable.
text :: String -> Doc
-- | hiddenText creates a Doc containing hidden text from a
-- String
hiddenText :: String -> Doc
-- | invisibleText creates a Doc containing invisible text
-- from a String
invisibleText :: String -> Doc
-- | wrapText n s is a Doc representing s
-- line-wrapped at n characters
wrapText :: Int -> String -> Doc
-- | Quote a string for screen output
quoted :: String -> Doc
-- | Given a list of Strings representing the words of a paragraph,
-- format the paragraphs using wrapText and separate them with an
-- empty line.
formatText :: Int -> [String] -> Doc
-- | A variant of wrapText that takes a list of strings as input.
-- Useful when {-# LANGUAGE CPP #-} makes it impossible to use
-- multiline string literals.
formatWords :: [String] -> Doc
-- | Format a list of FilePaths 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.
pathlist :: [FilePath] -> Doc
-- | Create a Doc containing a userchunk from a String.
--
-- Userchunks are used for printing arbitrary bytes stored in prim
-- patches:
--
--
-- - old and new preference values in ChangePref prims
-- - tokenChars, old token and new token in TokReplace prims
-- - old and new content lines in Hunk prims
--
--
-- In 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).
userchunk :: String -> Doc
-- | packedString builds a Doc from a ByteString using
-- printable
packedString :: ByteString -> Doc
prefix :: String -> Doc -> Doc
hiddenPrefix :: String -> Doc -> Doc
insertBeforeLastline :: Doc -> Doc -> Doc
prefixLines :: Doc -> Doc -> Doc
-- | invisiblePS creates a Doc with invisible text from a
-- ByteString
invisiblePS :: ByteString -> Doc
-- | Create a Doc representing a user chunk from a
-- ByteString; see userchunk for details.
userchunkPS :: ByteString -> Doc
-- | renders a Doc into a String with control codes for the
-- special features of the Doc.
renderString :: Doc -> String
-- | renders a Doc into a String using a given set of
-- printers. If content is only available as ByteString, decode
-- according to the current locale.
renderStringWith :: Printers' -> Doc -> String
-- | renders a Doc into ByteString with control codes for the
-- special features of the Doc. See also readerString.
renderPS :: Doc -> ByteString
-- | renders a Doc into a ByteString using a given set of
-- printers.
renderPSWith :: Printers' -> Doc -> ByteString
-- | renders a Doc into a list of PackedStrings, one for
-- each line.
renderPSs :: Doc -> [ByteString]
-- | renders a Doc into a list of PackedStrings, one for
-- each chunk of text that was added to the Doc, using the given
-- set of printers.
renderPSsWith :: Printers' -> Doc -> [ByteString]
type Printers = Handle -> IO Printers'
-- | A set of printers to print different types of text to a handle.
data Printers'
Printers :: !Color -> Printer -> !Printer -> !Printer -> !Printer -> !Printer -> !Color -> Doc -> Doc -> ![Printable] -> [Printable] -> Printers'
[colorP] :: Printers' -> !Color -> Printer
[invisibleP] :: Printers' -> !Printer
[hiddenP] :: Printers' -> !Printer
[userchunkP] :: Printers' -> !Printer
[defP] :: Printers' -> !Printer
[lineColorT] :: Printers' -> !Color -> Doc -> Doc
[lineColorS] :: Printers' -> ![Printable] -> [Printable]
type Printer = Printable -> St -> Document
-- | simplePrinters is a Printers which uses the set
-- 'simplePriners'' on any handle.
simplePrinters :: Printers
-- | invisiblePrinter is the Printer for hidden text. It just
-- replaces the document with empty. 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.
invisiblePrinter :: Printer
-- | simplePrinter is the simplest Printer: it just
-- concatenates together the pieces of the Doc
simplePrinter :: Printer
-- | A Printable is either a String, a packed string, or a chunk of
-- text with both representations.
data Printable
S :: !String -> Printable
PS :: !ByteString -> Printable
Both :: !String -> !ByteString -> Printable
doc :: ([Printable] -> [Printable]) -> Doc
-- | Creates a Doc from any Printable.
printable :: Printable -> Doc
-- | Creates an invisible Doc from any Printable.
invisiblePrintable :: Printable -> Doc
-- | Creates a hidden Doc from any Printable.
hiddenPrintable :: Printable -> Doc
-- | Creates a userchunk from any Printable; see userchunk
-- for details.
userchunkPrintable :: Printable -> Doc
data Color
Blue :: Color
Red :: Color
Green :: Color
Cyan :: Color
Magenta :: Color
blueText :: String -> Doc
redText :: String -> Doc
greenText :: String -> Doc
magentaText :: String -> Doc
cyanText :: String -> Doc
-- | colorText creates a Doc containing colored text from a
-- String
colorText :: Color -> String -> Doc
lineColor :: Color -> Doc -> Doc
-- | hputDoc puts a Doc on the given handle using
-- simplePrinters
hPutDoc :: Handle -> Doc -> IO ()
-- | hputDocLn puts a Doc, followed by a newline on the
-- given handle using simplePrinters.
hPutDocLn :: Handle -> Doc -> IO ()
-- | putDoc puts a Doc on stdout using the simple printer
-- simplePrinters.
putDoc :: Doc -> IO ()
-- | putDocLn puts a Doc, followed by a newline on stdout
-- using simplePrinters
putDocLn :: Doc -> IO ()
-- | hputDocWith puts a Doc on the given handle using the
-- given printer.
hPutDocWith :: Printers -> Handle -> Doc -> IO ()
-- | hputDocLnWith puts a Doc, followed by a newline on the
-- given handle using the given printer.
hPutDocLnWith :: Printers -> Handle -> Doc -> IO ()
-- | putDocWith puts a Doc on stdout using the given printer.
putDocWith :: Printers -> Doc -> IO ()
-- | putDocLnWith puts a Doc, followed by a newline on stdout
-- using the given printer.
putDocLnWith :: Printers -> Doc -> IO ()
-- | like hPutDoc but with compress data before writing
hPutDocCompr :: Handle -> Doc -> IO ()
-- | Write a Doc to stderr if debugging is turned on.
debugDocLn :: Doc -> IO ()
-- | unsafeText creates a Doc from a String, using
-- simplePrinter directly
unsafeText :: String -> Doc
-- | unsafeBoth builds a Doc from a String and a
-- ByteString representing the same text, but does not check that
-- they do.
unsafeBoth :: String -> ByteString -> Doc
-- | unsafeBothText builds a Doc from a String. The
-- string is stored in the Doc as both a String and a ByteString.
unsafeBothText :: String -> Doc
-- | unsafeChar creates a Doc containing just one character.
unsafeChar :: Char -> Doc
-- | unsafePackedString builds a Doc from a ByteString
-- using simplePrinter
unsafePackedString :: ByteString -> Doc
instance Data.String.IsString Darcs.Util.Printer.Doc
instance GHC.Base.Semigroup Darcs.Util.Printer.Doc
instance GHC.Base.Monoid Darcs.Util.Printer.Doc
-- | This modules provides rudimentary natural language generation (NLG)
-- utilities. That is, generating natural language from a machine
-- representation. Initially, only English is supported at all.
-- Representations are implemented for:
--
--
-- - countable nouns (plurality); and
-- - lists of clauses (foo, bar and/or baz).
--
module Darcs.Util.English
-- |
-- englishNum 0 (Noun "watch") "" == "watches"
-- englishNum 1 (Noun "watch") "" == "watch"
-- englishNum 2 (Noun "watch") "" == "watches"
--
englishNum :: Countable n => Int -> n -> ShowS
-- | Things that have a plural and singular spelling
class Countable a
plural :: Countable a => a -> ShowS
singular :: Countable a => a -> ShowS
-- | This only distinguishes between nouns with a final -ch, and nouns
-- which do not. More irregular nouns will just need to have their own
-- type
--
--
-- plural (Noun "batch") "" == "batches"
-- plural (Noun "bat") "" == "bats"
-- plural (Noun "mouse") "" == "mouses" -- :-(
--
newtype Noun
Noun :: String -> Noun
data Pronoun
It :: Pronoun
-- |
-- singular This (Noun "batch") "" == "this batch"
-- plural This (Noun "batch") "" == "these batches"
--
data This
This :: Noun -> This
-- | Given a list of things, combine them thusly:
--
--
-- orClauses ["foo", "bar", "baz"] == "foo, bar or baz"
--
andClauses :: [String] -> String
-- | Given a list of things, combine them thusly:
--
--
-- orClauses ["foo", "bar", "baz"] == "foo, bar or baz"
--
orClauses :: [String] -> String
anyOfClause :: [String] -> Doc
itemizeVertical :: Int -> [String] -> Doc
itemize :: String -> [String] -> String
presentParticiple :: String -> String
-- | Capitalize the first letter of a word
capitalize :: String -> String
instance Darcs.Util.English.Countable Darcs.Util.English.This
instance Darcs.Util.English.Countable Darcs.Util.English.Pronoun
instance Darcs.Util.English.Countable Darcs.Util.English.Noun
module Darcs.UI.Email
makeEmail :: String -> [(String, String)] -> Maybe Doc -> Maybe String -> Doc -> Maybe String -> Doc
readEmail :: ByteString -> ByteString
-- | Formats an e-mail header by encoding any non-ascii characters using
-- UTF-8 and Q-encoding, and folding lines at appropriate points. It
-- doesn't do more than that, so the header name and header value should
-- be well-formatted give or take line length and encoding. So no
-- non-ASCII characters within quoted-string, quoted-pair, or atom; no
-- semantically meaningful signs in names; no non-ASCII characters in the
-- header name; etcetera.
formatHeader :: String -> String -> ByteString
prop_qp_roundtrip :: ByteString -> Bool
module Darcs.Util.Printer.Color
unsafeRenderStringColored :: Doc -> String
traceDoc :: Doc -> a -> a
-- | fancyPrinters h returns a set of printers suitable for
-- outputting to h
fancyPrinters :: Printers
environmentHelpColor :: ([String], [String])
environmentHelpEscape :: ([String], [String])
environmentHelpEscapeWhite :: ([String], [String])
-- | eputDocLn puts a Doc, followed by a newline to stderr
-- using fancyPrinters. 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.
ePutDocLn :: Doc -> IO ()
-- | Utility functions for tracking progress of long-running actions.
module Darcs.Util.Progress
-- | beginTedious k starts a tedious process and registers it in
-- _progressData 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?
beginTedious :: String -> IO ()
-- | endTedious k unregisters the tedious process with key
-- k, printing Done if such a tedious process exists.
endTedious :: String -> IO ()
tediousSize :: String -> Int -> IO ()
withProgress :: String -> (String -> IO a) -> IO a
withSizedProgress :: String -> Int -> (String -> IO a) -> IO a
debugMessage :: String -> IO ()
withoutProgress :: IO a -> IO a
progress :: String -> a -> a
progressKeepLatest :: String -> a -> a
finishedOne :: String -> String -> a -> a
finishedOneIO :: String -> String -> IO ()
progressList :: String -> [a] -> [a]
-- | XXX: document this constant
minlist :: Int
setProgressMode :: Bool -> IO ()
module Darcs.Util.Exec
exec :: String -> [String] -> Redirects -> IO ExitCode
execInteractive :: String -> Maybe String -> IO ExitCode
readInteractiveProcess :: FilePath -> [String] -> IO (ExitCode, String)
renderExecException :: ExecException -> String
withoutNonBlock :: IO a -> IO a
type Redirects = (Redirect, Redirect, Redirect)
data Redirect
AsIs :: Redirect
Null :: Redirect
File :: FilePath -> Redirect
Stdout :: Redirect
data ExecException
ExecException :: String -> [String] -> Redirects -> String -> ExecException
instance GHC.Show.Show Darcs.Util.Exec.Redirect
instance GHC.Exception.Type.Exception Darcs.Util.Exec.ExecException
instance GHC.Show.Show Darcs.Util.Exec.ExecException
module Darcs.Util.Prompt
-- | Ask the user to press Enter
askEnter :: String -> IO ()
-- | Ask the user for a line of input.
askUser :: String -> IO String
-- | askUserListItem prompt xs enumerates xs on the
-- screen, allowing the user to choose one of the items
askUserListItem :: String -> [String] -> IO String
data PromptConfig
PromptConfig :: String -> [Char] -> [Char] -> Maybe Char -> [Char] -> PromptConfig
[pPrompt] :: PromptConfig -> String
[pBasicCharacters] :: PromptConfig -> [Char]
-- | only shown on help
[pAdvancedCharacters] :: PromptConfig -> [Char]
[pDefault] :: PromptConfig -> Maybe Char
[pHelp] :: PromptConfig -> [Char]
-- | Prompt the user for a yes or no
promptYorn :: String -> IO Bool
-- | Prompt 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.
promptChar :: PromptConfig -> IO Char
-- | A more high-level API for what Darcs.Util.Prompt offers
module Darcs.UI.Prompt
data PromptChoice a
PromptChoice :: Char -> Bool -> IO a -> String -> PromptChoice a
[pcKey] :: PromptChoice a -> Char
[pcWhen] :: PromptChoice a -> Bool
[pcAction] :: PromptChoice a -> IO a
[pcHelp] :: PromptChoice a -> String
data PromptConfig a
PromptConfig :: String -> String -> [[PromptChoice a]] -> Maybe Char -> PromptConfig a
[pPrompt] :: PromptConfig a -> String
[pVerb] :: PromptConfig a -> String
[pChoices] :: PromptConfig a -> [[PromptChoice a]]
[pDefault] :: PromptConfig a -> Maybe Char
runPrompt :: PromptConfig a -> IO a
module Darcs.Util.Ratified
-- | The readFile function reads a file and returns the contents of
-- the file as a string. The file is read lazily, on demand, as with
-- getContents.
readFile :: FilePath -> IO String
-- | Computation hGetContents hdl returns the list of
-- characters corresponding to the unread portion of the channel or file
-- managed by hdl, which is put into an intermediate state,
-- semi-closed. In this state, hdl is effectively closed,
-- but items are read from hdl on demand and accumulated in a
-- special list returned by hGetContents hdl.
--
-- Any operation that fails because a handle is closed, also fails if a
-- handle is semi-closed. The only exception is hClose. A
-- semi-closed handle becomes closed:
--
--
-- - if hClose is applied to it;
-- - if an I/O error occurs when reading an item from the handle;
-- - or once the entire contents of the handle has been read.
--
--
-- Once a semi-closed handle becomes closed, the contents of the
-- associated list becomes fixed. The contents of this final list is only
-- partially specified: it will contain at least all the items of the
-- stream that were evaluated prior to the handle becoming closed.
--
-- Any I/O errors encountered while a handle is semi-closed are simply
-- discarded.
--
-- This operation may fail with:
--
--
-- - isEOFError if the end of file has been reached.
--
hGetContents :: Handle -> IO String
-- | This module is a subset of the defunct regex-compat-tdfa.
module Darcs.Util.Regex
-- | The TDFA backend specific Regex type, used by this module's
-- RegexOptions and RegexMaker.
data () => Regex
-- | Makes 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).
mkRegex :: String -> Regex
-- | Makes a regular expression, where the multi-line and case-sensitive
-- options can be changed from the default settings.
mkRegexWithOpts :: String -> Bool -> Bool -> Regex
-- | Match a regular expression against a string
matchRegex :: Regex -> String -> Maybe [String]
instance GHC.Base.Monad Darcs.Util.Regex.RegexFail
instance GHC.Base.Applicative Darcs.Util.Regex.RegexFail
instance GHC.Base.Functor Darcs.Util.Regex.RegexFail
instance Control.Monad.Fail.MonadFail Darcs.Util.Regex.RegexFail
module Darcs.Util.Show
appPrec :: Int
module Darcs.Patch.Witnesses.Show
class Show1 a
showDict1 :: Show1 a => Dict (Show (a wX))
showDict1 :: (Show1 a, Show (a wX)) => ShowDict (a wX)
class Show2 a
showDict2 :: Show2 a => ShowDict (a wX wY)
showDict2 :: (Show2 a, Show (a wX wY)) => ShowDict (a wX wY)
show1 :: Show1 a => a wX -> String
showsPrec1 :: Show1 a => Int -> a wX -> ShowS
show2 :: Show2 a => a wX wY -> String
showsPrec2 :: Show2 a => Int -> a wX wY -> ShowS
showOp2 :: (Show2 a, Show2 b) => Int -> String -> Int -> a wW wX -> b wY wZ -> String -> String
appPrec :: Int
module Darcs.Patch.Witnesses.Sealed
-- | A Sealed 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.
data Sealed a
[Sealed] :: a wX -> Sealed a
seal :: a wX -> Sealed a
-- | The same as Sealed but for two parameters (wX and wY).
data Sealed2 a
[Sealed2] :: !a wX wY -> Sealed2 a
seal2 :: a wX wY -> Sealed2 a
data FlippedSeal a wY
[FlippedSeal] :: !a wX wY -> FlippedSeal a wY
flipSeal :: a wX wY -> FlippedSeal a wY
unseal :: (forall wX. a wX -> b) -> Sealed a -> b
mapSeal :: (forall wX. a wX -> b wX) -> Sealed a -> Sealed b
mapFlipped :: (forall wX. a wX wY -> b wX wZ) -> FlippedSeal a wY -> FlippedSeal b wZ
unseal2 :: (forall wX wY. a wX wY -> b) -> Sealed2 a -> b
mapSeal2 :: (forall wX wY. a wX wY -> b wX wY) -> Sealed2 a -> Sealed2 b
unsealFlipped :: (forall wX wY. a wX wY -> b) -> FlippedSeal a wZ -> b
-- | Duplicate 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 Sealed (Dup p wX) is isomorphic to
-- p wX.
data Dup p wX wY
[Dup] :: p wX -> Dup p wX wX
-- | FreeLeft 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 Stepped is
-- needed, rather than writing the more obvious Sealed
-- (Poly p) which would notionally have the same quantification of
-- the type witnesses.
data FreeLeft p
-- | FreeRight 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.
data FreeRight p
-- | Unwrap a FreeLeft value
unFreeLeft :: FreeLeft p -> Sealed (p wX)
-- | Unwrap a FreeRight value
unFreeRight :: FreeRight p -> FlippedSeal p wX
-- | Gap abstracts over FreeLeft and FreeRight for
-- code constructing these values
class Gap w
-- | An empty Gap, e.g. NilFL or NilRL
emptyGap :: Gap w => (forall wX. p wX wX) -> w p
-- | A Gap constructed from a completely polymorphic value, for
-- example the constructors for primitive patches
freeGap :: Gap w => (forall wX wY. p wX wY) -> w p
-- | Compose two Gap values together in series, e.g. 'joinGap
-- (+>+)' or 'joinGap (:>:)'
joinGap :: Gap w => (forall wX wY wZ. p wX wY -> q wY wZ -> r wX wZ) -> w p -> w q -> w r
instance Darcs.Patch.Witnesses.Sealed.Gap Darcs.Patch.Witnesses.Sealed.FreeLeft
instance Darcs.Patch.Witnesses.Sealed.Gap Darcs.Patch.Witnesses.Sealed.FreeRight
instance Darcs.Patch.Witnesses.Show.Show2 a => GHC.Show.Show (Darcs.Patch.Witnesses.Sealed.Sealed2 a)
instance Darcs.Patch.Witnesses.Eq.Eq2 a => GHC.Classes.Eq (Darcs.Patch.Witnesses.Sealed.Sealed (a wX))
instance Darcs.Patch.Witnesses.Show.Show1 a => GHC.Show.Show (Darcs.Patch.Witnesses.Sealed.Sealed a)
module Darcs.Patch.Witnesses.Ordered
-- | Directed Forward Pairs
data ( a1 :> a2 ) wX wY
(:>) :: a1 wX wZ -> a2 wZ wY -> (:>) a1 a2 wX wY
infixr 1 :>
infixr 1 :>
-- | Forward lists
data FL a wX wZ
[:>:] :: a wX wY -> FL a wY wZ -> FL a wX wZ
[NilFL] :: FL a wX wX
infixr 5 :>:
-- | Reverse lists
data RL a wX wZ
[:<:] :: RL a wX wY -> a wY wZ -> RL a wX wZ
[NilRL] :: RL a wX wX
infixl 5 :<:
-- | Forking Pairs (Implicit starting context)
data ( a1 :\/: a2 ) wX wY
(:\/:) :: a1 wZ wX -> a2 wZ wY -> (:\/:) a1 a2 wX wY
infix 1 :\/:
infix 1 :\/:
-- | Joining Pairs
data ( a3 :/\: a4 ) wX wY
(:/\:) :: a3 wX wZ -> a4 wY wZ -> (:/\:) a3 a4 wX wY
infix 1 :/\:
infix 1 :/\:
-- | Parallel Pairs
data ( a1 :||: a2 ) wX wY
(:||:) :: a1 wX wY -> a2 wX wY -> (:||:) a1 a2 wX wY
infix 1 :||:
infix 1 :||:
-- | Forking Pair (Explicit starting context)
--
--
-- wX wY
-- \ /
-- \ /
-- \ /
-- wU
-- |
-- |
-- |
-- wA
--
data Fork common left right wA wX wY
Fork :: common wA wU -> left wU wX -> right wU wY -> Fork common left right wA wX wY
nullFL :: FL a wX wZ -> Bool
nullRL :: RL a wX wZ -> Bool
lengthFL :: FL a wX wZ -> Int
lengthRL :: RL a wX wZ -> Int
mapFL :: (forall wW wZ. a wW wZ -> b) -> FL a wX wY -> [b]
mapRL :: (forall wW wZ. a wW wZ -> b) -> RL a wX wY -> [b]
mapFL_FL :: (forall wW wY. a wW wY -> b wW wY) -> FL a wX wZ -> FL b wX wZ
mapRL_RL :: (forall wW wY. a wW wY -> b wW wY) -> RL a wX wZ -> RL b wX wZ
-- | The "natural" fold over an FL i.e. associating to the right.
-- Like foldr only with the more useful order of arguments.
foldrFL :: (forall wA wB. p wA wB -> r -> r) -> FL p wX wY -> r -> r
-- | The "natural" fold over an RL i.e. associating to the left.
foldlRL :: (forall wA wB. r -> p wA wB -> r) -> r -> RL p wX wY -> r
-- | Right associative fold for FLs that transforms a witnessed
-- state in the direction opposite to the FL. This is the
-- "natural" fold for FLs i.e. the one which replaces the
-- :>: with the passed operator.
foldrwFL :: (forall wA wB. p wA wB -> r wB -> r wA) -> FL p wX wY -> r wY -> r wX
-- | The analog of foldrwFL for RLs. This is the "natural"
-- fold for RLs i.e. the one which replaces the :<: with
-- the (flipped) passed operator.
foldlwRL :: (forall wA wB. p wA wB -> r wA -> r wB) -> RL p wX wY -> r wX -> r wY
-- | Strict left associative fold for FLs that transforms a
-- witnessed state in the direction of the patches. This is for
-- apply-like functions that transform the witnesses in forward
-- direction.
foldlwFL :: (forall wA wB. p wA wB -> r wA -> r wB) -> FL p wX wY -> r wX -> r wY
-- | Strict right associative fold for RLs 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.
foldrwRL :: (forall wA wB. p wA wB -> r wB -> r wA) -> RL p wX wY -> r wY -> r wX
allFL :: (forall wX wY. a wX wY -> Bool) -> FL a wW wZ -> Bool
allRL :: (forall wA wB. a wA wB -> Bool) -> RL a wX wY -> Bool
anyFL :: (forall wX wY. a wX wY -> Bool) -> FL a wW wZ -> Bool
anyRL :: (forall wA wB. a wA wB -> Bool) -> RL a wX wY -> Bool
filterFL :: (forall wX wY. a wX wY -> Bool) -> FL a wW wZ -> [Sealed2 a]
filterRL :: (forall wX wY. p wX wY -> Bool) -> RL p wA wB -> [Sealed2 p]
-- | Monadic fold over an FL associating to the left, sequencing
-- effects from left to right. The order of arguments follows the
-- standard foldM from base.
foldFL_M :: Monad m => (forall wA wB. r wA -> p wA wB -> m (r wB)) -> r wX -> FL p wX wY -> m (r wY)
-- | Monadic fold over an FL 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.
foldRL_M :: Monad m => (forall wA wB. p wA wB -> r wB -> m (r wA)) -> RL p wX wY -> r wY -> m (r wX)
splitAtFL :: Int -> FL a wX wZ -> (FL a :> FL a) wX wZ
splitAtRL :: Int -> RL a wX wZ -> (RL a :> RL a) wX wZ
-- | filterOutFLFL 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)
filterOutFLFL :: (forall wX wY. p wX wY -> EqCheck wX wY) -> FL p wW wZ -> FL p wW wZ
filterOutRLRL :: (forall wX wY. p wX wY -> EqCheck wX wY) -> RL p wW wZ -> RL p wW wZ
reverseFL :: FL a wX wZ -> RL a wX wZ
reverseRL :: RL a wX wZ -> FL a wX wZ
-- | Concatenate two FLs. This traverses only the left hand side.
(+>+) :: FL a wX wY -> FL a wY wZ -> FL a wX wZ
infixr 5 +>+
-- | Concatenate two RLs. This traverses only the right hand side.
(+<+) :: RL a wX wY -> RL a wY wZ -> RL a wX wZ
infixl 5 +<+
-- | Prepend an RL to an FL. This traverses only the left
-- hand side.
(+>>+) :: RL p wX wY -> FL p wY wZ -> FL p wX wZ
infixr 5 +>>+
-- | Append an FL to an RL. This traverses only the right
-- hand side.
(+<<+) :: RL p wX wY -> FL p wY wZ -> RL p wX wZ
infixl 5 +<<+
concatFL :: FL (FL a) wX wZ -> FL a wX wZ
concatRL :: RL (RL a) wX wZ -> RL a wX wZ
dropWhileFL :: (forall wX wY. a wX wY -> Bool) -> FL a wR wV -> FlippedSeal (FL a) wV
dropWhileRL :: (forall wX wY. a wX wY -> Bool) -> RL a wR wV -> Sealed (RL a wR)
bunchFL :: Int -> FL a wX wY -> FL (FL a) wX wY
spanFL :: (forall wW wY. a wW wY -> Bool) -> FL a wX wZ -> (FL a :> FL a) wX wZ
spanFL_M :: forall a m wX wZ. Monad m => (forall wW wY. a wW wY -> m Bool) -> FL a wX wZ -> m ((FL a :> FL a) wX wZ)
zipWithFL :: (forall wX wY. a -> p wX wY -> q wX wY) -> [a] -> FL p wW wZ -> FL q wW wZ
consGapFL :: Gap w => (forall wX wY. p wX wY) -> w (FL p) -> w (FL p)
concatGapsFL :: Gap w => [w (FL p)] -> w (FL p)
joinGapsFL :: Gap w => [w p] -> w (FL p)
mapFL_FL_M :: Monad m => (forall wW wY. a wW wY -> m (b wW wY)) -> FL a wX wZ -> m (FL b wX wZ)
sequenceFL_ :: Monad m => (forall wW wZ. a wW wZ -> m b) -> FL a wX wY -> m ()
initsFL :: FL p wX wY -> [Sealed ((p :> FL p) wX)]
isShorterThanRL :: RL a wX wY -> Int -> Bool
-- | Like span only for RLs. This function is supposed to be
-- lazy: elements before the split point should not be touched.
spanRL :: (forall wA wB. p wA wB -> Bool) -> RL p wX wY -> (RL p :> RL p) wX wY
-- | Like break only for RLs. This function is supposed to be
-- lazy: elements before the split point should not be touched.
breakRL :: (forall wA wB. p wA wB -> Bool) -> RL p wX wY -> (RL p :> RL p) wX wY
-- | Like takeWhile only for RLs. This function is supposed
-- to be lazy: elements before the split point should not be touched.
takeWhileRL :: (forall wA wB. a wA wB -> Bool) -> RL a wX wY -> FlippedSeal (RL a) wY
concatRLFL :: RL (FL p) wX wY -> RL p wX wY
instance (Darcs.Patch.Witnesses.Show.Show2 a, Darcs.Patch.Witnesses.Show.Show2 b) => GHC.Show.Show ((Darcs.Patch.Witnesses.Ordered.:/\:) a b wX wY)
instance (Darcs.Patch.Witnesses.Show.Show2 a, Darcs.Patch.Witnesses.Show.Show2 b) => Darcs.Patch.Witnesses.Show.Show2 (a Darcs.Patch.Witnesses.Ordered.:/\: b)
instance (Darcs.Patch.Witnesses.Show.Show2 a, Darcs.Patch.Witnesses.Show.Show2 b) => GHC.Show.Show ((Darcs.Patch.Witnesses.Ordered.:\/:) a b wX wY)
instance (Darcs.Patch.Witnesses.Show.Show2 a, Darcs.Patch.Witnesses.Show.Show2 b) => Darcs.Patch.Witnesses.Show.Show2 (a Darcs.Patch.Witnesses.Ordered.:\/: b)
instance Darcs.Patch.Witnesses.Show.Show2 a => GHC.Show.Show (Darcs.Patch.Witnesses.Ordered.RL a wX wZ)
instance Darcs.Patch.Witnesses.Show.Show2 a => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Witnesses.Ordered.RL a wX)
instance Darcs.Patch.Witnesses.Show.Show2 a => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.Witnesses.Ordered.RL a)
instance Darcs.Patch.Witnesses.Eq.Eq2 p => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.Witnesses.Ordered.RL p)
instance Darcs.Patch.Witnesses.Show.Show2 a => GHC.Show.Show (Darcs.Patch.Witnesses.Ordered.FL a wX wZ)
instance Darcs.Patch.Witnesses.Show.Show2 a => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Witnesses.Ordered.FL a wX)
instance Darcs.Patch.Witnesses.Show.Show2 a => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.Witnesses.Ordered.FL a)
instance Darcs.Patch.Witnesses.Eq.Eq2 p => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.Witnesses.Ordered.FL p)
instance (Darcs.Patch.Witnesses.Show.Show2 a, Darcs.Patch.Witnesses.Show.Show2 b) => Darcs.Patch.Witnesses.Show.Show1 ((Darcs.Patch.Witnesses.Ordered.:>) a b wX)
instance (Darcs.Patch.Witnesses.Show.Show2 a, Darcs.Patch.Witnesses.Show.Show2 b) => GHC.Show.Show ((Darcs.Patch.Witnesses.Ordered.:>) a b wX wY)
instance (Darcs.Patch.Witnesses.Eq.Eq2 a, Darcs.Patch.Witnesses.Eq.Eq2 b) => Darcs.Patch.Witnesses.Eq.Eq2 (a Darcs.Patch.Witnesses.Ordered.:> b)
instance (Darcs.Patch.Witnesses.Eq.Eq2 a, Darcs.Patch.Witnesses.Eq.Eq2 b) => GHC.Classes.Eq ((Darcs.Patch.Witnesses.Ordered.:>) a b wX wY)
instance (Darcs.Patch.Witnesses.Show.Show2 a, Darcs.Patch.Witnesses.Show.Show2 b) => Darcs.Patch.Witnesses.Show.Show2 (a Darcs.Patch.Witnesses.Ordered.:> b)
module Darcs.Patch.Witnesses.WZipper
data FZipper a wX wZ
[FZipper] :: RL a wX wY -> FL a wY wZ -> FZipper a wX wZ
focus :: FZipper a wX wY -> Maybe (Sealed2 a)
leftmost :: FZipper p wX wY -> Bool
left :: FZipper p wX wY -> FZipper p wX wY
rightmost :: FZipper p wX wY -> Bool
right :: FZipper p wX wY -> FZipper p wX wY
-- | See clowns
jokers :: FZipper a wX wY -> FlippedSeal (FL a) wY
-- | "Clowns to the left of me, jokers to the right. Here I am, stuck in
-- the middle of you"
-- http://en.wikipedia.org/wiki/Stuck_in_the_Middle
clowns :: FZipper a wX wY -> Sealed (RL a wX)
flToZipper :: FL a wX wY -> FZipper a wX wY
lengthFZ :: FZipper a wX wY -> Int
nullFZ :: FZipper a wX wY -> Bool
toEnd :: FZipper p wX wY -> FZipper p wX wY
toStart :: FZipper p wX wY -> FZipper p wX wY
module Darcs.Patch.Witnesses.Maybe
data Maybe2 p wX wY
[Nothing2] :: Maybe2 p wX wX
[Just2] :: p wX wY -> Maybe2 p wX wY
maybeToFL :: Maybe2 p wX wY -> FL p wX wY
maybeToRL :: Maybe2 p wX wY -> RL p wX wY
mapMB_MB :: (p wX wY -> q wX wY) -> Maybe2 p wX wY -> Maybe2 q wX wY
module Darcs.Patch.Rebase.PushFixup
-- | During a rebase, we use "fixup" patches to maintain the correct
-- context for the real "items" that are being stored in the rebase that
-- the user wants to keep. As the context of the rebase changes, new
-- fixups get added to the beginning that then need to be pushed past as
-- many items as possible.
--
-- There are multiple fixup types and multiple ways of representing the
-- items being stored in the rebase, so this is polymorphic in both
-- types. Also, the structure of the results varies - in some cases it
-- will be a single value, sometimes an FL, or sometimes zero or one
-- values (Maybe2), so the output types are separate variables. A typical
-- instantiation would be something like PushFixupFn Fixup Item (FL Item)
-- (FL Fixup).
type PushFixupFn fixupIn itemIn itemOut fixupOut = forall wX wY. (fixupIn :> itemIn) wX wY -> (itemOut :> fixupOut) wX wY
dropFixups :: (item :> fixup) wX wY -> Sealed (item wX)
pushFixupFLFL_FLFLFL :: PushFixupFn fixup item (FL item) (FL fixup) -> PushFixupFn fixup (FL item) (FL item) (FL fixup)
pushFixupFLFL_FLFLFLFL :: PushFixupFn fixup item (FL item) (FL fixup) -> PushFixupFn (FL fixup) (FL item) (FL item) (FL fixup)
pushFixupFLMB_FLFLMB :: PushFixupFn fixup item (FL item) (Maybe2 fixup) -> PushFixupFn fixup (FL item) (FL item) (Maybe2 fixup)
pushFixupIdFL_FLFLFL :: PushFixupFn fixup item item (FL fixup) -> PushFixupFn fixup (FL item) (FL item) (FL fixup)
pushFixupIdMB_FLFLMB :: PushFixupFn fixup item item (Maybe2 fixup) -> PushFixupFn fixup (FL item) (FL item) (Maybe2 fixup)
pushFixupIdMB_FLIdFLFL :: PushFixupFn fixup item item (Maybe2 fixup) -> PushFixupFn (FL fixup) item item (FL fixup)
module Darcs.Patch.Invert
-- | The invert operation must be self-inverse, i.e. an involution:
--
--
-- invert . invert = id
--
class Invert p
invert :: Invert p => p wX wY -> p wY wX
invertFL :: Invert p => FL p wX wY -> RL p wY wX
invertRL :: Invert p => RL p wX wY -> FL p wY wX
instance Darcs.Patch.Invert.Invert p => Darcs.Patch.Invert.Invert (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Invert.Invert p => Darcs.Patch.Invert.Invert (Darcs.Patch.Witnesses.Ordered.RL p)
instance Darcs.Patch.Invert.Invert p => Darcs.Patch.Invert.Invert (p Darcs.Patch.Witnesses.Ordered.:> p)
module Darcs.Patch.Debug
-- | PatchDebug is a hook class for temporarily adding debug information.
-- To use it, add any methods that are required, implement those methods
-- where needed, and then make it available in the relevant contexts. For
-- example it can be temporarily added as a superclass of
-- Patchy. The advantage of having it here already is that
-- everything is (or should be) declared as an instance of it, so you can
-- use defaulting or just leave out declarations of instance methods and
-- code will still compile.
class PatchDebug p
-- | A dummy method so we can export/import PatchDebug(..) without
-- triggering warnings
patchDebugDummy :: PatchDebug p => p wX wY -> ()
instance Darcs.Patch.Debug.PatchDebug p => Darcs.Patch.Debug.PatchDebug (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Debug.PatchDebug p => Darcs.Patch.Debug.PatchDebug (Darcs.Patch.Witnesses.Ordered.RL p)
module Darcs.Patch.CommuteFn
-- | CommuteFn 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 (Nothing): all the commutes must be
-- performed before we can know whether the overall commute succeeds.
type CommuteFn p1 p2 = forall wX wY. (p1 :> p2) wX wY -> Maybe ((p2 :> p1) wX wY)
commuterIdFL :: CommuteFn p1 p2 -> CommuteFn p1 (FL p2)
commuterFLId :: CommuteFn p1 p2 -> CommuteFn (FL p1) p2
commuterIdRL :: CommuteFn p1 p2 -> CommuteFn p1 (RL p2)
commuterRLId :: CommuteFn p1 p2 -> CommuteFn (RL p1) p2
commuterRLFL :: forall p1 p2. CommuteFn p1 p2 -> CommuteFn (RL p1) (FL p2)
type MergeFn p1 p2 = forall wX wY. (p1 :\/: p2) wX wY -> (p2 :/\: p1) wX wY
type PartialMergeFn p1 p2 = forall wX wY. (p1 :\/: p2) wX wY -> Maybe ((p2 :/\: p1) wX wY)
-- | TODO document laziness or lack thereof
mergerIdFL :: MergeFn p1 p2 -> MergeFn p1 (FL p2)
type TotalCommuteFn p1 p2 = forall wX wY. (p1 :> p2) wX wY -> (p2 :> p1) wX wY
-- | TODO document laziness or lack thereof
totalCommuterIdFL :: TotalCommuteFn p1 p2 -> TotalCommuteFn p1 (FL p2)
-- | TODO document laziness or lack thereof
totalCommuterFLId :: TotalCommuteFn p1 p2 -> TotalCommuteFn (FL p1) p2
-- | TODO document laziness or lack thereof
totalCommuterFLFL :: TotalCommuteFn p1 p2 -> TotalCommuteFn (FL p1) (FL p2)
-- | Make use of the inverse-commute law to reduce the number of cases when
-- defining commute for complicated patch types.
invertCommuter :: (Invert p, Invert q) => CommuteFn p q -> CommuteFn q p
module Darcs.Patch.Commute
-- | Class of patches that that can be commuted.
--
-- Instances should obey the following laws:
--
--
--
-- The more general law
--
--
--
-- is valid in general only provided we know (a priori) that
-- commute (invert p:>q') succeeds, in
-- other words, that p and q are not in conflict with each other. See
-- Darcs.Patch.CommuteNoConflicts for an extended discussion.
class Commute p
commute :: Commute p => (p :> p) wX wY -> Maybe ((p :> p) wX wY)
-- | commuteFL commutes a single element past a FL.
commuteFL :: Commute p => (p :> FL p) wX wY -> Maybe ((FL p :> p) wX wY)
-- | commuteRL commutes a RL past a single element.
commuteRL :: Commute p => (RL p :> p) wX wY -> Maybe ((p :> RL p) wX wY)
-- | commuteRLFL commutes an RL past an FL.
commuteRLFL :: Commute p => (RL p :> FL p) wX wY -> Maybe ((FL p :> RL p) wX wY)
-- | Build a commuter between a patch and itself using the operation from
-- the type class.
selfCommuter :: Commute p => CommuteFn p p
instance Darcs.Patch.Commute.Commute p => Darcs.Patch.Commute.Commute (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Commute.Commute p => Darcs.Patch.Commute.Commute (Darcs.Patch.Witnesses.Ordered.RL p)
module Darcs.Patch.Merge
-- | Class of patches that can, possibly, be merged cleanly, that is,
-- without conflict.
--
-- Every patch type can be made an instance of CleanMerge in a
-- trivial way by defining cleanMerge _ = Nothing,
-- which vacuously conforms to all required laws.
--
-- Instances should obey the following laws:
--
--
--
-- If an instance Commute p exists, then we also require
--
--
--
-- If an instance Invert p exists, then we also require
--
--
class CleanMerge p
cleanMerge :: CleanMerge p => (p :\/: p) wX wY -> Maybe ((p :/\: p) wX wY)
-- | Patches that can always be merged, even if they conflict.
--
-- Instances should obey the following laws:
--
--
-- - symmetry
merge (p :\/: q) == q' :/\: p'
-- <=> merge (q :\/: p) == p' :/\: q'
-- - merge-commute
merge (p :\/: q) == q' :/\: p'
-- ==> commute (p :> q') == Just (q :> p')
that is, the two
-- branches of a merge commute to each other.
-- - extension
cleanMerge (p :\/: q) == Just (q'
-- :/\: p') => merge (p :\/: q) == q' :/\: p'
that is,
-- merge is an extension of cleanMerge.
--
class CleanMerge p => Merge p
merge :: Merge p => (p :\/: p) wX wY -> (p :/\: p) wX wY
-- | Synonym for merge.
selfMerger :: Merge p => MergeFn p p
-- | Swap the two patches, apply an arbitrary merge function, then swap
-- again.
swapMerger :: MergeFn p q -> MergeFn q p
-- | Lift a merge function over p :/: q to a merge function over
-- p :/: FL q
mergerIdFL :: MergeFn p q -> MergeFn p (FL q)
-- | Lift a merge function over p :/: q to a merge function over
-- FL p :/: q
mergerFLId :: MergeFn p q -> MergeFn (FL p) q
-- | Lift a merge function over p :/: q to a merge function over
-- FL p :/: FL q
mergerFLFL :: MergeFn p q -> MergeFn (FL p) (FL q)
-- | Cleanly merge a single patch with an FL of patches.
cleanMergeFL :: CleanMerge p => PartialMergeFn p (FL p)
mergeFL :: Merge p => (p :\/: FL p) wX wY -> (FL p :/\: p) wX wY
-- | Swap the two patches, merge, then swap again. Used to exploit
-- prop_mergeSymmetric when defining merge.
swapMerge :: Merge p => (p :\/: p) wX wY -> (p :/\: p) wX wY
-- | Swap the two patches, cleanMerge, then swap again. Used to
-- exploit prop_cleanMergeSymmetric when defining
-- cleanMerge.
swapCleanMerge :: CleanMerge p => (p :\/: p) wX wY -> Maybe ((p :/\: p) wX wY)
-- | Combine a list of patch sequences, all starting at the same state,
-- into a single sequence that also starts at the same state, using
-- cleanMerge. If the merge fails, we return the two sequences that could
-- not be merged so we can issue more detailed error messages.
mergeList :: CleanMerge p => [Sealed (FL p wX)] -> Either (Sealed (FL p wX), Sealed (FL p wX)) (Sealed (FL p wX))
-- | Whether the given pair of patches satisfies the symmetry law.
prop_mergeSymmetric :: (Eq2 p, Merge p) => (p :\/: p) wX wY -> Bool
-- | Whether the given pair of patches satisfies the merge-commute
-- law.
prop_mergeCommute :: (Commute p, Eq2 p, Merge p) => (p :\/: p) wX wY -> Bool
instance Darcs.Patch.Merge.Merge p => Darcs.Patch.Merge.Merge (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Merge.CleanMerge p => Darcs.Patch.Merge.CleanMerge (Darcs.Patch.Witnesses.Ordered.FL p)
module Darcs.Patch.Permutations
-- | removeFL x xs removes x from xs if
-- x can be commuted to its head. Otherwise it returns
-- Nothing
removeFL :: (Eq2 p, Commute p) => p wX wY -> FL p wX wZ -> Maybe (FL p wY wZ)
-- | removeRL is like removeFL except with RL
removeRL :: (Eq2 p, Commute p) => p wY wZ -> RL p wX wZ -> Maybe (RL p wX wY)
removeCommon :: (Eq2 p, Commute p) => (FL p :\/: FL p) wX wY -> (FL p :\/: FL p) wX wY
commuteWhatWeCanFL :: Commute p => (p :> FL p) wX wY -> (FL p :> (p :> FL p)) wX wY
commuteWhatWeCanRL :: Commute p => (RL p :> p) wX wY -> (RL p :> (p :> RL p)) wX wY
genCommuteWhatWeCanRL :: Commute p => CommuteFn p q -> (RL p :> q) wX wY -> (RL p :> (q :> RL p)) wX wY
genCommuteWhatWeCanFL :: Commute q => CommuteFn p q -> (p :> FL q) wX wY -> (FL q :> (p :> FL q)) wX wY
-- | Split an FL 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'.
partitionFL :: Commute p => (forall wU wV. p wU wV -> Bool) -> FL p wX wY -> (FL p :> (FL p :> FL p)) wX wY
-- | Split an RL 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'.
partitionRL :: forall p wX wY. Commute p => (forall wU wV. p wU wV -> Bool) -> RL p wX wY -> (RL p :> RL p) wX wY
partitionFL' :: Commute p => (forall wU wV. p wU wV -> Bool) -> RL p wA wB -> RL p wB wC -> FL p wC wD -> (FL p :> (RL p :> RL p)) wA wD
-- | Split an RL 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'.
partitionRL' :: forall p wX wY. Commute p => (forall wU wV. p wU wV -> Bool) -> RL p wX wY -> (FL p :> (FL p :> RL p)) wX wY
-- | This is a minor variant of headPermutationsFL with each
-- permutation is simply returned as a FL
simpleHeadPermutationsFL :: Commute p => FL p wX wY -> [FL p wX wY]
-- | headPermutationsRL is like headPermutationsFL, except
-- that we operate on an RL (in other words, we are pushing things
-- to the end of a patch sequence instead of to the beginning).
headPermutationsRL :: Commute p => RL p wX wY -> [RL p wX wY]
-- | headPermutationsFL p:>:ps returns all the
-- permutations of the list in which one element of ps is
-- commuted past p
--
-- Suppose we have a sequence of patches
--
--
-- X h a y s-t-c k
--
--
-- Suppose furthermore that the patch c depends on t,
-- which in turn depends on s. This function will return
--
--
-- X :> h a y s t c k
-- h :> X a y s t c k
-- a :> X h y s t c k
-- y :> X h a s t c k
-- s :> X h a y t c k
-- k :> X h a y s t c
--
headPermutationsFL :: Commute p => FL p wX wY -> [(p :> FL p) wX wY]
-- | All permutations of an RL.
permutationsRL :: Commute p => RL p wX wY -> [RL p wX wY]
-- | removeSubsequenceFL 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 Nothing.
removeSubsequenceFL :: (Eq2 p, Commute p) => FL p wA wB -> FL p wA wC -> Maybe (FL p wB wC)
-- | removeSubsequenceRL is like removeSubsequenceFL except
-- that it works on RL
removeSubsequenceRL :: (Eq2 p, Commute p) => RL p wAb wAbc -> RL p wA wAbc -> Maybe (RL p wA wAb)
-- | Partition a list into the patches that merge cleanly with the given
-- patch and those that don't (including dependencies)
partitionConflictingFL :: forall p wX wY wZ. (Commute p, CleanMerge p) => FL p wX wY -> FL p wX wZ -> (FL p :> FL p) wX wY
-- | This commutes patches in the RHS to bring them into the same order as
-- the LHS.
(=\~/=) :: forall p wA wB wC. (Commute p, Eq2 p) => FL p wA wB -> FL p wA wC -> EqCheck wB wC
-- | This commutes patches in the RHS to bring them into the same order as
-- the LHS.
(=/~\=) :: forall p wA wB wC. (Commute p, Eq2 p) => RL p wA wC -> RL p wB wC -> EqCheck wA wB
-- | A variant of nub that is based on '=~/= i.e. ignores
-- (internal) ordering.
nubFL :: (Commute p, Eq2 p) => [Sealed (FL p wX)] -> [Sealed (FL p wX)]
module Darcs.Patch.CommuteNoConflicts
-- | It is natural to think of conflicting patches p and
-- q as a parallel pair (p:\/:q) because this is
-- how conflicting patches arise. But then Darcs comes along and merges
-- them anyway by converting one of them to a conflictor. Thus, inside a
-- sequence of patches we may see them as a sequential pair (p
-- :> q'). In that case, commute will always
-- succeed, as expressed by the merge-commute law.
-- commuteNoConflicts is a restricted version of commute
-- that should fail in this case but otherwise give the same result as
-- commute.
--
-- Primitive patch types have no conflictors, so for them we have
-- commute == commuteNoConflicts.
--
-- Instances should obey the following laws:
--
--
-- - Symmetry
commuteNoConflicts (p:>q) == Just (q':>p')
-- <=> commuteNoConflicts (q':>p') == Just (p':>q)
-- - Square-Commute (if an instance Invert p
-- exists)
commuteNoConflicts (p:>q) == Just (q':>p') =>
-- commuteNoConflicts (invert p:>q') == Just (q:>invert
-- p')
-- - commuteNoConflicts is a restriction of
-- commute
commuteNoConflicts (p:>q) == Just r =>
-- commute (p:>q) == Just r
--
class Commute p => CommuteNoConflicts p
-- | An alternative to commute to be used if correctness of your
-- code depends on the validity of the square-commute law, or to
-- determine whether patches are in conflict. A parallel pair of patches
-- p:\/:q is conflicting if and only if
-- commuteNoConflicts(p^:>q) fails. Its main
-- use is so that we can define mergeNoConflicts cleanly.
commuteNoConflicts :: CommuteNoConflicts p => (p :> p) wX wY -> Maybe ((p :> p) wX wY)
-- | The non-conflicting merge of (p:\/:q) tries to commute
-- the inverse p^ of p with q. If it succeeds
-- then the part of the result that corresponds to p^ 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 commuteNoConflicts here and not commute.
-- Otherwise we run into contradictions as explained below.
--
-- Concretely, suppose we use commute here and that q is
-- a conflictor that represents the primitive patch r and
-- conflicts (only) with (primitive patch) p^. That is,
-- q results from the conflicted
-- merge(r:\/:p^)=(s:/\:q), where s is
-- another conflictor. Now, according to merge-commute we get
-- commute(p^:>q)=Just(r:>s), and thus
-- mergeNoConflict(p:\/:q)=Just(s^:/\:r) in
-- contradiction to our assumption that (p^:\/:q are in
-- conflict i.e. mergeNoConflict(p^:\/:q) fails. (This
-- argument takes for granted that the addition of conflictors to prim
-- patches preserves their commute behavior. This is not yet stated as a
-- law but all implementations obviously adhere to it.)
--
-- As a side note, the fact that we now get an inverse conflictor
-- s^ as part of the result leads to further problems. For
-- instance, whether our repo is conflicted now depends on the order of
-- patches: (p:>r) is not conflicted, but its commute
-- (q:>s^) obviously is. In fact,
-- (q:>s^) is nothing else but the
-- (identity-preserving) "force-commute" of (p:>r),
-- see the thread at
-- https://lists.osuosl.org/pipermail/darcs-devel/2017-November/018403.html.
mergeNoConflicts :: (Invert p, CommuteNoConflicts p) => (p :\/: p) wX wY -> Maybe ((p :/\: p) wX wY)
-- | Path resolving:
--
--
-- - An http URL contains the sequence "http(s)://".
-- - A local filepath does not contain colons, except as second
-- character (windows drives) when this filepath is meant to be used as
-- repository name
-- - A path that is neither an http URL nor a local file is an
-- ssh-path.
--
--
-- Examples:
--
--
-- /usr/repo/foo -- local file
-- c:/src/darcs -- local file
-- http://darcs.net/ -- URL
-- peter@host:/path -- ssh
-- droundy@host: -- ssh
-- host:/path -- ssh
--
--
-- This means that single-letter hosts in ssh-paths do not work, unless a
-- username is provided.
--
-- Perhaps ssh-paths should use "ssh://user@host/path"-syntax
-- instead?
--
-- TODO: This whole module should be re-written using a regex matching
-- library! The way we do this here is error-prone and inefficient.
module Darcs.Util.URL
isValidLocalPath :: String -> Bool
isHttpUrl :: String -> Bool
isSshUrl :: String -> Bool
isRelative :: String -> Bool
isAbsolute :: String -> Bool
isSshNopath :: String -> Bool
data SshFilePath
sshRepo :: SshFilePath -> String
sshUhost :: SshFilePath -> String
sshFile :: SshFilePath -> String
sshFilePathOf :: SshFilePath -> String
-- | Given an ssh URL or file path, split it into user@host, repodir, and
-- the file (with any _darcs/ prefix removed)
splitSshUrl :: String -> SshFilePath
-- | Return 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)
sshCanonRepo :: SshFilePath -> String
module Darcs.Util.ValidHash
-- | External API for the various hash types.
class (Eq h, IsSizeHash h) => ValidHash h
-- | The HashedDir belonging to this type of hash
dirofValidHash :: ValidHash h => h -> HashedDir
-- | Compute hash from file content.
calcValidHash :: ValidHash h => ByteString -> h
data InventoryHash
data PatchHash
data PristineHash
-- | Semantically, 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.
data HashedDir
HashedPristineDir :: HashedDir
HashedPatchesDir :: HashedDir
HashedInventoriesDir :: HashedDir
encodeValidHash :: ValidHash h => h -> String
decodeValidHash :: ValidHash h => String -> Maybe h
parseValidHash :: ValidHash h => Parser h
getHash :: ValidHash h => h -> Hash
getSize :: ValidHash h => h -> Maybe Int
fromHash :: ValidHash h => Hash -> h
fromSizeAndHash :: ValidHash h => Int -> Hash -> h
-- | Verify file content against a given ValidHash.
checkHash :: ValidHash h => h -> ByteString -> Bool
-- | Check that the given String is an encoding of some
-- ValidHash.
okayHash :: String -> Bool
instance GHC.Classes.Eq Darcs.Util.ValidHash.HashedDir
instance GHC.Show.Show Darcs.Util.ValidHash.SizeHash
instance GHC.Classes.Eq Darcs.Util.ValidHash.SizeHash
instance Darcs.Util.ValidHash.IsSizeHash Darcs.Util.ValidHash.PristineHash
instance GHC.Show.Show Darcs.Util.ValidHash.PristineHash
instance GHC.Classes.Eq Darcs.Util.ValidHash.PristineHash
instance Darcs.Util.ValidHash.IsSizeHash Darcs.Util.ValidHash.PatchHash
instance GHC.Show.Show Darcs.Util.ValidHash.PatchHash
instance GHC.Classes.Eq Darcs.Util.ValidHash.PatchHash
instance Darcs.Util.ValidHash.IsSizeHash Darcs.Util.ValidHash.InventoryHash
instance GHC.Show.Show Darcs.Util.ValidHash.InventoryHash
instance GHC.Classes.Eq Darcs.Util.ValidHash.InventoryHash
instance Darcs.Util.ValidHash.ValidHash Darcs.Util.ValidHash.InventoryHash
instance Darcs.Util.ValidHash.ValidHash Darcs.Util.ValidHash.PatchHash
instance Darcs.Util.ValidHash.ValidHash Darcs.Util.ValidHash.PristineHash
instance Darcs.Util.ValidHash.IsSizeHash Darcs.Util.ValidHash.SizeHash
module Darcs.Util.Workaround
setExecutable :: FilePath -> Bool -> IO ()
-- | Obtain the current working directory as an absolute path.
--
-- In a multithreaded program, the current working directory is a global
-- state shared among all threads of the process. Therefore, when
-- performing filesystem operations from multiple threads, it is highly
-- recommended to use absolute rather than relative paths (see:
-- makeAbsolute).
--
-- Note that getCurrentDirectory is not guaranteed to return the
-- same path received by setCurrentDirectory. On POSIX systems,
-- the path returned will always be fully dereferenced (not contain any
-- symbolic links). For more information, refer to the documentation of
-- getcwd.
--
-- The operation may fail with:
--
--
-- - HardwareFault A physical I/O error has occurred.
-- [EIO]
-- - isDoesNotExistError There is no path referring to the
-- working directory. [EPERM, ENOENT, ESTALE...]
-- - isPermissionError The process has insufficient privileges
-- to perform the operation. [EACCES]
-- - isFullError Insufficient resources are available to perform
-- the operation.
-- - UnsupportedOperation The operating system has no notion
-- of current working directory.
--
getCurrentDirectory :: IO FilePath
-- | installHandler int handler iset calls sigaction to
-- install an interrupt handler for signal int. If
-- handler is Default, SIG_DFL is installed;
-- if handler is Ignore, SIG_IGN is installed;
-- if handler is Catch action, a handler is installed
-- which will invoke action in a new thread when (or shortly
-- after) the signal is received. If iset is Just s,
-- then the sa_mask of the sigaction structure is set
-- to s; otherwise it is cleared. The previously installed
-- signal handler for int is returned
installHandler :: Signal -> Handler -> Maybe SignalSet -> IO Handler
-- | raiseSignal int calls kill to signal the current
-- process with interrupt signal int.
raiseSignal :: Signal -> IO ()
-- | The actions to perform when a signal is received.
data () => Handler
-- | Sets the disposition of the signal to SIG_DFL, which means we
-- want the default action associated with the signal. For example, the
-- default action for SIGTERM (and various other signals) is to
-- terminate the process.
Default :: Handler
-- | Set the disposition of the signal to SIG_IGN, which means we
-- want to ignore the signal. Ignored signals will not be
-- delivered to the process, and if also blocked will not be added
-- to the pending set for later delivery (if/when unblocked). Some
-- signals (e.g. SIGSTOP and SIGKILL) cannot be caught
-- or ignored. not yet: | Hold
Ignore :: Handler
-- | signal handler is not reset
Catch :: IO () -> Handler
-- | signal handler is automatically reset (via SA_RESETHAND)
CatchOnce :: IO () -> Handler
CatchInfo :: (SignalInfo -> IO ()) -> Handler
CatchInfoOnce :: (SignalInfo -> IO ()) -> Handler
type Signal = CInt
-- | Terminal interrupt signal.
sigINT :: CInt
-- | Hangup.
sigHUP :: CInt
-- | Process abort signal.
sigABRT :: CInt
-- | Alarm clock.
sigALRM :: CInt
-- | Termination signal.
sigTERM :: CInt
-- | Write on a pipe with no one to read it.
sigPIPE :: CInt
module Darcs.Util.SignalHandler
withSignalsHandled :: IO a -> IO a
withSignalsBlocked :: IO a -> IO a
catchInterrupt :: IO a -> IO a -> IO a
-- | A drop-in replacement for catch, which allows us to catch
-- anything but a signal. Useful for situations where we don't want to
-- inhibit ctrl-C.
catchNonSignal :: IO a -> (SomeException -> IO a) -> IO a
tryNonSignal :: IO a -> IO (Either SomeException a)
stdoutIsAPipe :: IO Bool
instance GHC.Show.Show Darcs.Util.SignalHandler.SignalException
instance GHC.Exception.Type.Exception Darcs.Util.SignalHandler.SignalException
module Darcs.Util.Exception
-- | The firstJustIO is a slight modification to firstJustM: the entries in
-- the list must be IO monad operations and the firstJustIO will silently
-- turn any monad call that throws an exception into Nothing, basically
-- causing it to be ignored.
firstJustIO :: [IO (Maybe a)] -> IO (Maybe a)
catchall :: IO a -> IO a -> IO a
clarifyErrors :: IO a -> String -> IO a
prettyException :: SomeException -> String
prettyError :: IOError -> String
-- | Terminate the program with an error message.
die :: String -> IO a
-- | Handle only a those exceptions for which the predicate succeeds.
handleOnly :: Exception e => (e -> Bool) -> IO a -> IO a -> IO a
-- | Handle only actual IO exceptions i.e. not "user errors" e.g. those
-- raised by calling fail.
--
-- We use fail all over the place to signify erroneous conditions
-- and we normally don't want to handle such errors.
handleOnlyIOError :: IO a -> IO a -> IO a
-- | Handle only non-existence.
catchDoesNotExistError :: IO a -> IO a -> IO a
-- | Handle only non-existence.
handleDoesNotExistError :: IO a -> IO a -> IO a
-- | Like handleOnlyIOError but restricted to returning a given
-- value.
ifIOError :: a -> IO a -> IO a
-- | Like ifIOError but restricted to handling non-existence.
ifDoesNotExistError :: a -> IO a -> IO a
module Darcs.Util.Ssh
data SshSettings
SshSettings :: String -> String -> String -> SshSettings
[ssh] :: SshSettings -> String
[scp] :: SshSettings -> String
[sftp] :: SshSettings -> String
defaultSsh :: SshSettings
windows :: Bool
copySSH :: String -> SshFilePath -> FilePath -> IO ()
data SSHCmd
SSH :: SSHCmd
SCP :: SSHCmd
SFTP :: SSHCmd
-- | Return the command and arguments needed to run an ssh command First
-- try the appropriate darcs environment variable and SSH_PORT defaulting
-- to "ssh" and no specified port.
getSSH :: SSHCmd -> IO (String, [String])
environmentHelpSsh :: ([String], [String])
environmentHelpScp :: ([String], [String])
environmentHelpSshPort :: ([String], [String])
transferModeHeader :: String
-- | Terminate all child processes that run a remote "darcs transfer-mode"
-- and remove them from the sshConnections, causing subsequent
-- copySSH calls to start a fresh child.
resetSshConnections :: IO ()
instance GHC.Classes.Eq Darcs.Util.Ssh.SshSettings
instance GHC.Show.Show Darcs.Util.Ssh.SshSettings
module Darcs.Util.Compat
stdoutIsAPipe :: IO Bool
maybeRelink :: String -> String -> IO Bool
atomicCreate :: FilePath -> IO ()
sloppyAtomicCreate :: FilePath -> IO ()
module Darcs.Util.Path
-- | encodeWhite translates whitespace in filenames to a
-- darcs-specific format (numerical representation according to
-- ord 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"
--
encodeWhite :: FilePath -> String
-- | decodeWhite interprets the Darcs-specific "encoded" filenames
-- produced by encodeWhite
--
--
-- decodeWhite "hello\32\there" == Right "hello there"
-- decodeWhite "hello\92\there" == Right "hello\there"
-- decodeWhite "hello\there" == Left "malformed filename"
--
decodeWhite :: String -> Either String FilePath
encodeWhiteName :: Name -> ByteString
decodeWhiteName :: ByteString -> Either String Name
data AbsolutePath
-- | Take an absolute path and a string representing a (possibly relative)
-- path and combine them into an absolute path. If the second argument is
-- already absolute, then the first argument gets ignored. This function
-- also takes care that the result is converted to Posix convention and
-- normalized. Also, parent directories ("..") at the front of the string
-- argument get canceled out against trailing directory parts of the
-- absolute path argument.
--
-- Regarding the last point, someone more familiar with how these
-- functions are used should verify that this is indeed necessary or at
-- least useful.
makeAbsolute :: AbsolutePath -> FilePath -> AbsolutePath
-- | Interpret a possibly relative path wrt the current working directory.
-- This also canonicalizes the path, resolving symbolic links etc.
ioAbsolute :: FilePath -> IO AbsolutePath
-- | This is for situations where a string (e.g. a command line argument)
-- may take the value "-" to mean stdin or stdout (which one depends on
-- context) instead of a normal file path.
data AbsolutePathOrStd
makeAbsoluteOrStd :: AbsolutePath -> String -> AbsolutePathOrStd
ioAbsoluteOrStd :: String -> IO AbsolutePathOrStd
-- | Execute either the first or the second argument action, depending on
-- whether the given path is an AbsolutePath or stdin/stdout.
useAbsoluteOrStd :: (AbsolutePath -> a) -> a -> AbsolutePathOrStd -> a
stdOut :: AbsolutePathOrStd
data AbsoluteOrRemotePath
ioAbsoluteOrRemote :: String -> IO AbsoluteOrRemotePath
isRemote :: AbsoluteOrRemotePath -> Bool
-- | Paths which are relative to the local darcs repository and normalized.
-- Note: These are understood not to have the dot in front.
data SubPath
-- | Make the second path relative to the first, if possible. Note that
-- this returns an empty SubPath if the inputs are equal.
makeSubPathOf :: AbsolutePath -> AbsolutePath -> Maybe SubPath
simpleSubPath :: HasCallStack => FilePath -> Maybe SubPath
-- | Transform a SubPath into an AnchoredPath.
floatSubPath :: SubPath -> Either String AnchoredPath
-- | The 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 Nothing, else return Just the
-- remainder.
makeRelativeTo :: HasCallStack => AbsolutePath -> AbsolutePath -> IO (Maybe SubPath)
class FilePathOrURL a
toPath :: FilePathOrURL a => a -> String
class FilePathOrURL a => FilePathLike a
toFilePath :: FilePathLike a => a -> FilePath
getCurrentDirectory :: IO AbsolutePath
setCurrentDirectory :: HasCallStack => FilePathLike p => p -> IO ()
-- | Iteratively tries find first non-existing path generated by buildName,
-- it feeds to buildName the number starting with -1. When it generates
-- non-existing path and it isn't first, it displays the message created
-- with buildMsg. Usually used for generation of the name like
-- path_number when path already exist (e.g.
-- darcs.net_0).
getUniquePathName :: Bool -> (FilePath -> String) -> (Int -> FilePath) -> IO FilePath
-- | Construct a filter from a list of AnchoredPaths, that will accept any
-- path that is either a parent or a child of any of the listed paths,
-- and discard everything else.
filterPaths :: [AnchoredPath] -> AnchoredPath -> t -> Bool
data Name
name2fp :: Name -> FilePath
-- | Make a Name from a String. May fail if the input
-- String is invalid, that is, "", ".", "..", or contains a
-- /.
makeName :: String -> Either String Name
-- | Make a Name from a ByteString.
rawMakeName :: ByteString -> Either String Name
eqAnycase :: Name -> Name -> Bool
-- | This is a type of "sane" file paths. These are always canonic in the
-- sense that there are no stray slashes, no ".." components and similar.
-- They are usually used to refer to a location within a Tree, but a
-- relative filesystem path works just as well. These are either
-- constructed from individual name components (using "appendPath",
-- "catPaths" and "makeName"), or converted from a FilePath
-- ("unsafeFloatPath" -- but take care when doing that).
newtype AnchoredPath
AnchoredPath :: [Name] -> AnchoredPath
anchoredRoot :: AnchoredPath
-- | Append an element to the end of a path.
appendPath :: AnchoredPath -> Name -> AnchoredPath
-- | Take a "root" directory and an anchored path and produce a full
-- FilePath. Moreover, you can use anchorPath "" to get a
-- relative FilePath.
anchorPath :: FilePath -> AnchoredPath -> FilePath
-- | Check whether a path is a prefix of another path.
isPrefix :: AnchoredPath -> AnchoredPath -> Bool
-- | The effect of renaming on paths. The first argument is the old path,
-- the second is the new path, and the third is the possibly affected
-- path we are interested in.
movedirfilename :: AnchoredPath -> AnchoredPath -> AnchoredPath -> AnchoredPath
-- | Get parent (path) of a given path. foobarbaz -> foo/bar
parent :: AnchoredPath -> Maybe AnchoredPath
-- | List all (proper) parents of a given path. foobarbaz ->
-- [.,foo, foo/bar]
parents :: AnchoredPath -> [AnchoredPath]
-- | Replace the second arg's parent with the first arg.
replaceParent :: AnchoredPath -> AnchoredPath -> Maybe AnchoredPath
-- | Catenate two paths together. Not very safe, but sometimes useful (e.g.
-- when you are representing paths relative to a different point than a
-- Tree root).
catPaths :: AnchoredPath -> AnchoredPath -> AnchoredPath
flatten :: AnchoredPath -> ByteString
-- | Is the given path in (or equal to) the _darcs metadata directory?
inDarcsdir :: AnchoredPath -> Bool
-- | For displaying paths to the user. It should never be used for on-disk
-- patch storage. This adds the "./" for consistency with how repo paths
-- are displayed by showPatch and friends, except for the root
-- path which is displayed as plain ".".
displayPath :: AnchoredPath -> FilePath
-- | Interpret an AnchoredPath as relative the current working
-- directory. Intended for IO operations in the file system. Use with
-- care!
realPath :: AnchoredPath -> FilePath
isRoot :: AnchoredPath -> Bool
darcsdirName :: Name
floatPath :: FilePath -> Either String AnchoredPath
-- | Take 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)
unsafeFloatPath :: HasCallStack => FilePath -> AnchoredPath
instance GHC.Classes.Ord Darcs.Util.Path.SubPath
instance GHC.Classes.Eq Darcs.Util.Path.SubPath
instance GHC.Classes.Ord Darcs.Util.Path.AbsolutePath
instance GHC.Classes.Eq Darcs.Util.Path.AbsolutePath
instance GHC.Classes.Ord Darcs.Util.Path.AbsolutePathOrStd
instance GHC.Classes.Eq Darcs.Util.Path.AbsolutePathOrStd
instance GHC.Classes.Ord Darcs.Util.Path.AbsoluteOrRemotePath
instance GHC.Classes.Eq Darcs.Util.Path.AbsoluteOrRemotePath
instance GHC.Classes.Ord Darcs.Util.Path.Name
instance GHC.Show.Show Darcs.Util.Path.Name
instance GHC.Classes.Eq Darcs.Util.Path.Name
instance Data.Binary.Class.Binary Darcs.Util.Path.Name
instance GHC.Classes.Ord Darcs.Util.Path.AnchoredPath
instance GHC.Show.Show Darcs.Util.Path.AnchoredPath
instance GHC.Classes.Eq Darcs.Util.Path.AnchoredPath
instance Data.Binary.Class.Binary Darcs.Util.Path.AnchoredPath
instance Darcs.Util.Path.FilePathOrURL Darcs.Util.Path.AbsoluteOrRemotePath
instance GHC.Show.Show Darcs.Util.Path.AbsoluteOrRemotePath
instance GHC.Show.Show Darcs.Util.Path.AbsolutePathOrStd
instance Darcs.Util.Path.FilePathOrURL Darcs.Util.Path.AbsolutePath
instance Darcs.Util.Path.FilePathLike Darcs.Util.Path.AbsolutePath
instance GHC.Show.Show Darcs.Util.Path.AbsolutePath
instance Darcs.Util.Path.FilePathOrURL Darcs.Util.Path.SubPath
instance Darcs.Util.Path.FilePathLike Darcs.Util.Path.SubPath
instance GHC.Show.Show Darcs.Util.Path.SubPath
instance Darcs.Util.Path.FilePathLike GHC.IO.FilePath
instance Darcs.Util.Path.FilePathOrURL GHC.IO.FilePath
-- | The abstract representation of a Tree and useful abstract utilities to
-- handle those.
module Darcs.Util.Tree
-- | Abstraction of a filesystem tree. Please note that the Tree returned
-- by the respective read operations will have TreeStub items in it. To
-- obtain a Tree without such stubs, call expand on it, eg.:
--
--
-- tree <- readDarcsPristine "." >>= expand
--
--
-- When a Tree is expanded, it becomes "final". All stubs are forced and
-- the Tree can be traversed purely. Access to actual file contents stays
-- in IO though.
--
-- A Tree may have a Hash associated with it. A pair of Tree's is
-- identical whenever their hashes are (the reverse need not hold, since
-- not all Trees come equipped with a hash).
data Tree m
data Blob m
Blob :: !m ByteString -> !Maybe Hash -> Blob m
data TreeItem m
File :: !Blob m -> TreeItem m
SubTree :: !Tree m -> TreeItem m
Stub :: !m (Tree m) -> !Maybe Hash -> TreeItem m
data ItemType
TreeType :: ItemType
BlobType :: ItemType
data Hash
makeTree :: [(Name, TreeItem m)] -> Tree m
makeTreeWithHash :: [(Name, TreeItem m)] -> Hash -> Tree m
emptyTree :: Tree m
emptyBlob :: Monad m => Blob m
makeBlob :: Monad m => ByteString -> Blob m
makeBlobBS :: Monad m => ByteString -> Blob m
expandUpdate :: Monad m => (AnchoredPath -> Tree m -> m (Tree m)) -> Tree m -> m (Tree m)
-- | Expand a stubbed Tree into a one with no stubs in it. You might want
-- to filter the tree before expanding to save IO. This is the basic
-- implementation, which may be overriden by some Tree instances (this is
-- especially true of the Index case).
expand :: Monad m => Tree m -> m (Tree m)
-- | Unfold a path in a (stubbed) Tree, such that the leaf node of the path
-- is reachable without crossing any stubs. Moreover, the leaf ought not
-- be a Stub in the resulting Tree. A non-existent path is expanded as
-- far as it can be.
expandPath :: Monad m => Tree m -> AnchoredPath -> m (Tree m)
-- | Check the disk version of a Tree: expands it, and checks each hash.
-- Returns either the expanded tree or a list of AnchoredPaths where
-- there are problems. The first argument is the hashing function used to
-- create the tree.
checkExpand :: (TreeItem IO -> IO Hash) -> Tree IO -> IO (Either [(AnchoredPath, Maybe Hash, Maybe Hash)] (Tree IO))
items :: Tree m -> Map Name (TreeItem m)
-- | List all contents of a Tree.
list :: Tree m -> [(AnchoredPath, TreeItem m)]
listImmediate :: Tree m -> [(Name, TreeItem m)]
-- | Get hash of a Tree. This is guaranteed to uniquely identify the Tree
-- (including any blob content), as far as cryptographic hashes are
-- concerned. Sha256 is recommended.
treeHash :: Tree m -> Maybe Hash
-- | Look up a Tree item (an immediate subtree or blob).
lookup :: Tree m -> Name -> Maybe (TreeItem m)
-- | Find a TreeItem by its path. Gives Nothing if the path
-- is invalid.
find :: Tree m -> AnchoredPath -> Maybe (TreeItem m)
-- | Find a Blob by its path. Gives Nothing if the path is
-- invalid, or does not point to a Blob.
findFile :: Tree m -> AnchoredPath -> Maybe (Blob m)
-- | Find a Tree by its path. Gives Nothing if the path is
-- invalid, or does not point to a Tree.
findTree :: Tree m -> AnchoredPath -> Maybe (Tree m)
-- | Get a hash of a TreeItem. May be Nothing.
itemHash :: TreeItem m -> Maybe Hash
itemType :: TreeItem m -> ItemType
-- | For every pair of corresponding blobs from the two supplied trees,
-- evaluate the supplied function and accumulate the results in a list.
-- Hint: to get IO actions through, just use sequence on the resulting
-- list. NB. This won't expand any stubs.
zipCommonFiles :: (AnchoredPath -> Blob m -> Blob m -> a) -> Tree m -> Tree m -> [a]
-- | For each file in each of the two supplied trees, evaluate the supplied
-- function (supplying the corresponding file from the other tree, or
-- Nothing) and accumulate the results in a list. Hint: to get IO actions
-- through, just use sequence on the resulting list. NB. This won't
-- expand any stubs.
zipFiles :: (AnchoredPath -> Maybe (Blob m) -> Maybe (Blob m) -> a) -> Tree m -> Tree m -> [a]
zipTrees :: (AnchoredPath -> Maybe (TreeItem m) -> Maybe (TreeItem m) -> a) -> Tree m -> Tree m -> [a]
-- | Cautiously extracts differing subtrees from a pair of Trees. It will
-- never do any unneccessary expanding. Tree hashes are used to cut the
-- comparison as high up the Tree branches as possible. The result is a
-- pair of trees that do not share any identical subtrees. They are
-- derived from the first and second parameters respectively and they are
-- always fully expanded. It might be advantageous to feed the result
-- into zipFiles or zipTrees.
diffTrees :: forall m. Monad m => Tree m -> Tree m -> m (Tree m, Tree m)
-- | All paths in the tree that that have the given path as prefix.
--
--
-- explodePath t p == Prelude.filter (p `isPrefix`) (map fst (list t))
--
explodePath :: Tree m -> AnchoredPath -> [AnchoredPath]
-- | Like explodePath but for multiple paths.
explodePaths :: Tree IO -> [AnchoredPath] -> [AnchoredPath]
-- | Like find but monadic and thus able to expand Stubs on
-- the way.
locate :: Monad m => Tree m -> AnchoredPath -> m (Maybe (TreeItem m))
isDir :: TreeItem m -> Bool
treeHas :: Monad m => Tree m -> AnchoredPath -> m Bool
treeHasDir :: Monad m => Tree m -> AnchoredPath -> m Bool
treeHasFile :: Monad m => Tree m -> AnchoredPath -> m Bool
treeHasAnycase :: Monad m => Tree m -> AnchoredPath -> m Bool
-- | Read a Blob into a Lazy ByteString. Might be backed by an mmap, use
-- with care.
readBlob :: Blob m -> m ByteString
class (Monad m) => FilterTree a m
-- | Given pred tree, produce a Tree that only has items
-- for which pred returns True. The tree might contain
-- stubs. When expanded, these will be subject to filtering as well.
filter :: FilterTree a m => (AnchoredPath -> TreeItem m -> Bool) -> a m -> a m
-- | Given two Trees, a guide and a tree, produces a new
-- Tree that is a identical to tree, but only has those items
-- that are present in both tree and guide. The
-- guide Tree may not contain any stubs.
restrict :: FilterTree t m => Tree n -> t m -> t m
-- | Modify a Tree (by replacing, or removing or adding items).
modifyTree :: Monad m => Tree m -> AnchoredPath -> Maybe (TreeItem m) -> Tree m
-- | Does not expand the tree.
updateTree :: Monad m => (TreeItem m -> m (TreeItem m)) -> Tree m -> m (Tree m)
-- | Does not expand the tree.
partiallyUpdateTree :: Monad m => (TreeItem m -> m (TreeItem m)) -> (AnchoredPath -> TreeItem m -> Bool) -> Tree m -> m (Tree m)
updateSubtrees :: (Tree m -> Tree m) -> Tree m -> Tree m
-- | Lay one tree over another. The resulting Tree will look like the base
-- (1st parameter) Tree, although any items also present in the overlay
-- Tree will be taken from the overlay. It is not allowed to overlay a
-- different kind of an object, nor it is allowed for the overlay to add
-- new objects to base. This means that the overlay Tree should be a
-- subset of the base Tree (although any extraneous items will be ignored
-- by the implementation).
overlay :: Applicative m => Tree m -> Tree m -> Tree m
-- | Calculate and insert hashes for all TreeItems contained in a
-- Tree, including the argument Tree itself. If necessary,
-- this expands Stubs.
addMissingHashes :: Monad m => (TreeItem m -> m Hash) -> Tree m -> m (Tree m)
-- | Specification of explodePath
prop_explodePath :: Tree m -> AnchoredPath -> Bool
instance GHC.Classes.Ord Darcs.Util.Tree.ItemType
instance GHC.Classes.Eq Darcs.Util.Tree.ItemType
instance GHC.Show.Show Darcs.Util.Tree.ItemType
instance GHC.Base.Monad m => Darcs.Util.Tree.FilterTree Darcs.Util.Tree.Tree m
-- | The plain format implementation resides in this module. The plain
-- format does not use any hashing and basically just wraps a normal
-- filesystem tree in the hashed-storage API.
--
-- NB. The read function on Blobs coming from a plain tree is
-- susceptible to file content changes. Since we use mmap in read,
-- this will break referential transparency and produce unexpected
-- results. Please always make sure that all parallel access to the
-- underlying filesystem tree never mutates files. Unlink + recreate is
-- fine though (in other words, the writePlainTree implemented in
-- this module is safe in this respect).
module Darcs.Util.Tree.Plain
readPlainTree :: FilePath -> IO (Tree IO)
-- | Write out full tree to a plain directory structure. If you
-- instead want to make incremental updates, refer to
-- Darcs.Util.Tree.Monad.
writePlainTree :: Tree IO -> FilePath -> IO ()
-- | A monad transformer for Tree mutation. The main idea is to
-- simulate IO-ish manipulation of real filesystem (that's the state part
-- of the monad), and to keep memory usage down by reasonably often
-- dumping the intermediate data to disk and forgetting it.
--
-- The implementation is configured by passing a procedure of type
-- DumpItem to runTreeMonad.
--
-- This module provides the pre-configured virtualTreeIO that
-- never writes any changes, but may trigger filesystem reads as
-- appropriate.
module Darcs.Util.Tree.Monad
-- | A monad transformer that adds state of type TreeState and an
-- environment of type DumpItem.
type TreeMonad m = RWST (DumpItem m) () (TreeState m) m
-- | Internal state of the TreeMonad. Keeps track of the current
-- Tree content and unsync'd changes.
data TreeState m
runTreeMonad :: Monad m => TreeMonad m a -> Tree m -> DumpItem m -> m (a, Tree m)
-- | Run a TreeMonad action without storing any changes. This is
-- useful for running monadic tree mutations for obtaining the resulting
-- Tree (as opposed to their effect of writing a modified tree to
-- disk). The actions can do both read and write -- reads are passed
-- through to the actual filesystem, but the writes are held in memory in
-- the form of a modified Tree.
virtualTreeMonad :: Monad m => TreeMonad m a -> Tree m -> m (a, Tree m)
-- | TreeMonad specialized to IO
type TreeIO = TreeMonad IO
-- | virtualTreeMonad specialized to IO
virtualTreeIO :: TreeIO a -> Tree IO -> IO (a, Tree IO)
-- | Grab content of a file in the current Tree at the given path.
readFile :: MonadThrow m => AnchoredPath -> TreeMonad m ByteString
-- | Check for existence of a node (file or directory, doesn't matter).
exists :: MonadThrow m => AnchoredPath -> TreeMonad m Bool
-- | Check for existence of a directory.
directoryExists :: Monad m => AnchoredPath -> TreeMonad m Bool
-- | Check for existence of a file.
fileExists :: Monad m => AnchoredPath -> TreeMonad m Bool
-- | Change content of a file at a given path. The change will be
-- eventually flushed to disk, but might be buffered for some time.
writeFile :: MonadThrow m => AnchoredPath -> ByteString -> TreeMonad m ()
-- | Create a directory.
createDirectory :: Monad m => AnchoredPath -> TreeMonad m ()
-- | Remove the item at a path.
unlink :: Monad m => AnchoredPath -> TreeMonad m ()
-- | Rename the item at a path.
rename :: MonadThrow m => AnchoredPath -> AnchoredPath -> TreeMonad m ()
-- | Copy 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
copy :: MonadThrow m => AnchoredPath -> AnchoredPath -> TreeMonad m ()
findM :: Monad m => Tree m -> AnchoredPath -> m (Maybe (TreeItem m))
findFileM :: Monad m => Tree m -> AnchoredPath -> m (Maybe (Blob m))
findTreeM :: Monad m => Tree m -> AnchoredPath -> m (Maybe (Tree m))
module Darcs.Util.File
-- | Badly named, since it is actually getSymbolicLinkStatus, with
-- all IOErrors turned into Nothing.
getFileStatus :: FilePath -> IO (Maybe FileStatus)
-- | Whether a path is an existing directory, but not a symlink to one.
doesDirectoryReallyExist :: FilePath -> IO Bool
-- | Variant of removeFile that doesn't throw exception when file
-- does not exist.
removeFileMayNotExist :: FilePathLike p => p -> IO ()
-- | Return all files under given directory that aren't directories.
getRecursiveContents :: FilePath -> IO [FilePath]
-- | Return all files under given directory that aren't directories. Unlike
-- getRecursiveContents this function returns the full path.
getRecursiveContentsFullPath :: FilePath -> IO [FilePath]
-- | Recursively copy a directory, where the target directory is supposed
-- to already exist.
copyTree :: FilePath -> FilePath -> IO ()
-- | fetchFilePS 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.
fetchFilePS :: String -> Cachable -> IO ByteString
-- | fetchFileLazyPS 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.
fetchFileLazyPS :: String -> Cachable -> IO ByteString
-- | Like fetchFilePS but transparently handle gzip compressed
-- files.
gzFetchFilePS :: String -> Cachable -> IO ByteString
-- | Initiate background file download for the given file path or URL to
-- the given location.
speculateFileOrUrl :: String -> FilePath -> IO ()
-- | Very 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.
copyFileOrUrl :: String -> String -> FilePath -> Cachable -> IO ()
data Cachable
Cachable :: Cachable
Uncachable :: Cachable
MaxAge :: !CInt -> Cachable
backupByRenaming :: FilePath -> IO ()
backupByCopying :: FilePath -> IO ()
-- | Invoke the given action on a file that is temporarily created in the
-- current directory, and removed afterwards.
withTemp :: (FilePath -> IO a) -> IO a
-- | Invoke the given action on a file that is temporarily created and
-- opened in the current directory, and closed and removed afterwards.
withOpenTemp :: ((Handle, FilePath) -> IO a) -> IO a
module Darcs.Util.Lock
withLock :: String -> IO a -> IO a
-- | Tries to perform some task if it can obtain the lock, Otherwise, just
-- gives up without doing the task
withLockCanFail :: String -> IO a -> IO (Either () a)
environmentHelpLocks :: ([String], [String])
-- | withTempDir creates a temporary directory, runs the action and
-- then removes the directory. The location of that directory is
-- determined by the contents of _darcsprefstmpdir, 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.
withTempDir :: FilePath -> (AbsolutePath -> IO a) -> IO a
-- | withPermDir is like withTempDir, except that it doesn't
-- delete the directory afterwards.
withPermDir :: FilePath -> (AbsolutePath -> IO a) -> IO a
withDelayedDir :: FilePath -> (AbsolutePath -> IO a) -> IO a
withNamedTemp :: FilePath -> (FilePath -> IO a) -> IO a
writeBinFile :: FilePathLike p => p -> ByteString -> IO ()
writeTextFile :: FilePathLike p => p -> String -> IO ()
writeDocBinFile :: FilePathLike p => p -> Doc -> IO ()
appendBinFile :: FilePathLike p => p -> ByteString -> IO ()
appendTextFile :: FilePathLike p => p -> String -> IO ()
appendDocBinFile :: FilePathLike p => p -> Doc -> IO ()
readBinFile :: FilePathLike p => p -> IO ByteString
readTextFile :: FilePathLike p => p -> IO [String]
readDocBinFile :: FilePathLike p => p -> IO Doc
writeAtomicFilePS :: FilePathLike p => p -> ByteString -> IO ()
gzWriteAtomicFilePS :: FilePathLike p => p -> ByteString -> IO ()
gzWriteAtomicFilePSs :: FilePathLike p => p -> [ByteString] -> IO ()
gzWriteDocFile :: FilePathLike p => p -> Doc -> IO ()
-- | Variant of removeFile that doesn't throw exception when file
-- does not exist.
removeFileMayNotExist :: FilePathLike p => p -> IO ()
maybeRelink :: String -> String -> IO Bool
tempdirLoc :: IO FilePath
environmentHelpTmpdir :: ([String], [String])
environmentHelpKeepTmpdir :: ([String], [String])
addToErrorLoc :: IOException -> String -> IOException
-- | Do an action in a newly created directory of the given name. If the
-- directory is successfully created but the action raises an exception,
-- the directory and all its content is deleted. Caught exceptions are
-- re-thrown.
withNewDirectory :: FilePath -> IO () -> IO ()
module Darcs.Util.Cache
-- | Cache is an abstract type for hiding the underlying cache locations
data Cache
-- | Smart constructor for CacheLoc.
mkCache :: [CacheLoc] -> Cache
mkDirCache :: FilePath -> Cache
mkRepoCache :: FilePath -> Cache
cacheEntries :: Cache -> [CacheLoc]
data CacheType
Repo :: CacheType
Directory :: CacheType
data CacheLoc
Cache :: !CacheType -> !WritableOrNot -> !String -> CacheLoc
[cacheType] :: CacheLoc -> !CacheType
[cacheWritable] :: CacheLoc -> !WritableOrNot
[cacheSource] :: CacheLoc -> !String
data WritableOrNot
Writable :: WritableOrNot
NotWritable :: WritableOrNot
-- | Semantically, 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.
data HashedDir
HashedPristineDir :: HashedDir
HashedPatchesDir :: HashedDir
HashedInventoriesDir :: HashedDir
hashedDir :: HashedDir -> FilePath
bucketFolder :: FilePath -> FilePath
-- | Filter 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.
filterRemoteCaches :: Cache -> IO Cache
cleanCaches :: Cache -> HashedDir -> IO ()
cleanCachesWithHint :: Cache -> HashedDir -> [String] -> IO ()
-- | 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.
fetchFileUsingCache :: ValidHash h => Cache -> h -> IO (FilePath, ByteString)
-- | Add pipelined downloads to the (low-priority) queue, for the rest it
-- is a noop.
speculateFileUsingCache :: ValidHash h => Cache -> h -> IO ()
-- | Do speculateFilesUsingCache for files not already in a writable
-- cache position.
speculateFilesUsingCache :: ValidHash h => Cache -> [h] -> IO ()
-- | Write file content, except if it is already in the cache, in which
-- case merely create a hard link to that file. The returned value is the
-- size and hash of the content.
writeFileUsingCache :: ValidHash h => Cache -> ByteString -> IO h
-- | Return whether the CacheLoc contains a file with the given hash
-- in a writable position.
peekInCache :: ValidHash h => Cache -> h -> IO Bool
parseCacheLoc :: String -> Maybe CacheLoc
showCacheLoc :: CacheLoc -> String
writable :: CacheLoc -> Bool
isThisRepo :: CacheLoc -> Bool
-- | The full filepath of a simple file name inside a given CacheLoc
-- under HashedDir.
hashedFilePath :: CacheLoc -> HashedDir -> FilePath -> FilePath
allHashedDirs :: [HashedDir]
-- | Prints an error message with a list of bad caches.
reportBadSources :: IO ()
closestWritableDirectory :: Cache -> Maybe String
-- | This keeps only Repo NotWritable entries.
dropNonRepos :: Cache -> Cache
instance GHC.Show.Show Darcs.Util.Cache.WritableOrNot
instance GHC.Classes.Eq Darcs.Util.Cache.WritableOrNot
instance GHC.Show.Show Darcs.Util.Cache.CacheType
instance GHC.Classes.Eq Darcs.Util.Cache.CacheType
instance GHC.Show.Show Darcs.Util.Cache.OrOnlySpeculate
instance GHC.Classes.Eq Darcs.Util.Cache.OrOnlySpeculate
instance GHC.Classes.Eq Darcs.Util.Cache.FromWhere
instance GHC.Show.Show Darcs.Util.Cache.Cache
instance GHC.Classes.Eq Darcs.Util.Cache.CacheLoc
-- | A few darcs-specific utility functions. These are used for reading and
-- writing darcs and darcs-compatible hashed trees.
module Darcs.Util.Tree.Hashed
readDarcsHashed :: Cache -> PristineHash -> IO (Tree IO)
-- | Write a Tree into a darcs-style hashed directory.
writeDarcsHashed :: Tree IO -> Cache -> IO PristineHash
-- | Run a TreeIO action in a hashed setting. Any changes
-- will be written out to the cache. Please note that actual filesystem
-- files are never removed.
hashedTreeIO :: TreeIO a -> Tree IO -> Cache -> IO (a, Tree IO)
readDarcsHashedNosize :: Cache -> PristineHash -> IO (Tree IO)
darcsAddMissingHashes :: Monad m => Tree m -> m (Tree m)
-- | Compute a darcs-compatible hash value for a tree-like structure.
darcsTreeHash :: Tree m -> Hash
darcsUpdateHashes :: Monad m => Tree m -> m (Tree m)
-- | Return all PristineHashes reachable from the given root set,
-- which must consist of directory hashes only.
followPristineHashes :: Cache -> [PristineHash] -> IO [PristineHash]
-- | This module contains plain tree indexing code. The index itself is a
-- CACHE: you should only ever use it as an optimisation and never as a
-- primary storage. In practice, this means that when we change index
-- format, the application is expected to throw the old index away and
-- build a fresh index. Please note that tracking index validity is out
-- of scope for this module: this is responsibility of your application.
-- It is advisable that in your validity tracking code, you also check
-- for format validity (see indexFormatValid) and scrap and
-- re-create index when needed.
--
-- The index is a binary file that overlays a hashed tree over the
-- working copy. This means that every working file and directory has an
-- entry in the index, that contains its path and hash and validity data.
-- The validity data is a timestamp plus the file size. The file hashes
-- are sha256's of the file's content. It also contains the fileid to
-- track moved files.
--
-- There are two entry types, a file entry and a directory entry. Both
-- have a common binary format (see Item). The on-disk format is
-- described by the section Index format below.
--
-- For each file, the index has a copy of the file's last modification
-- timestamp taken at the instant when the hash has been computed. This
-- means that when file size and timestamp of a file in working tree
-- matches those in the index, we assume that the hash stored in the
-- index for given file is valid. These hashes are then exposed in the
-- resulting Tree object, and can be leveraged by eg.
-- diffTrees to compare many files quickly.
--
-- You may have noticed that we also keep hashes of directories. These
-- are assumed to be valid whenever the complete subtree has been valid.
-- At any point, as soon as a size or timestamp mismatch is found, the
-- working file in question is opened, its hash (and timestamp and size)
-- is recomputed and updated in-place in the index file (everything lives
-- at a fixed offset and is fixed size, so this isn't an issue). This is
-- also true of directories: when a file in a directory changes hash,
-- this triggers recomputation of all of its parent directory hashes;
-- moreover this is done efficiently -- each directory is updated at most
-- once during an update run.
--
-- Endianness
--
-- Since version 6 (magic == HSI6), the file format depends on the
-- endianness of the architecture. To account for the (rare) case where
-- darcs executables from different architectures operate on the same
-- repo, we make an additional check in indexFormatValid to detect
-- whether the file's endianness differs from what we expect. If this is
-- detected, the file is considered invalid and will be re-created.
--
-- Index format
--
-- The index starts with a header consisting of a 4 bytes magic word,
-- followed by a 4 byte word to indicate the endianness of the encoding.
-- This word should, when read directly from the mmapped file, be equal
-- to 1.
--
-- After the header comes the actual content of the index, which is a
-- sequence of Items. An Item consists of:
--
--
-- - size: item size, 8 bytes
-- - aux: timestamp (for file) or offset to sibling (for dir), 8
-- bytes
-- - fileid: inode or fhandle of the item, 8 bytes
-- - hash: sha256 of content, 32 bytes
-- - descriptor length: >= 2 due to type and null, 4 bytes
-- - descriptor:
-- - type: D or F, one byte
-- - path: flattened path, variable >= 0
-- - null: terminating null byte
-- - alignment padding: 0 to 3 bytes
--
--
-- Each Item is 4 byte aligned. Thus the descriptor length must be
-- rounded up to get the position of the next item using align.
-- Similar, when determining the aux (offset to sibling) for dir items.
--
-- With directories, the aux holds the offset of the next sibling item in
-- the index, so we can efficiently skip reading the whole subtree
-- starting at a given directory (by just seeking aux bytes forward). The
-- items are pre-ordered with respect to directory structure -- the
-- directory comes first and after it come all its items. Cf.
-- openIndex.
--
-- For files, the aux field holds a timestamp.
--
-- Internally, the item is stored as a pointer to the first field (iBase)
-- from which we directly read off the first three fields (size, aux,
-- fileid), and a ByteString for the rest (iHashAndDescriptor), up to but
-- not including the terminating null byte.
--
-- TODO
--
-- The null byte terminator seems useless.
--
-- We could as well use a single plain pointer for the item. The
-- dumpIndex function demonstrates how this could be done.
--
-- Another possible improvement is to store only the Name of an item, not
-- the full path. We need to keep track of the current path anyway when
-- traversing the index.
module Darcs.Util.Index
-- | Initialize an IndexM from the given index file.
openIndex :: FilePath -> IO Index
-- | Add and remove entries in the given IndexM to make it match the
-- given Tree. If an object in the Tree 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 Nothing,
-- see iHash'.
updateIndexFrom :: FilePath -> Tree IO -> IO Index
-- | Check that a given file is an index file with a format we can handle.
-- You should remove and re-create the index whenever this is not true.
indexFormatValid :: FilePath -> IO Bool
-- | Read an IndexM, starting with the root, to create a
-- Tree.
treeFromIndex :: Index -> IO (Tree IO)
-- | Return a list containing all the file/folder names in an index, with
-- their respective ItemType and FileID.
listFileIDs :: Index -> IO [((AnchoredPath, ItemType), FileID)]
type Index = IndexM IO
-- | Given pred tree, produce a Tree that only has items
-- for which pred returns True. The tree might contain
-- stubs. When expanded, these will be subject to filtering as well.
filter :: FilterTree a m => (AnchoredPath -> TreeItem m -> Bool) -> a m -> a m
-- | For a given path, get the corresponding fileID from the filesystem.
getFileID :: AnchoredPath -> IO (Maybe FileID)
data IndexEntry
IndexEntry :: Int64 -> Int64 -> FileID -> Maybe Hash -> Char -> AnchoredPath -> IndexEntry
[ieSize] :: IndexEntry -> Int64
[ieAux] :: IndexEntry -> Int64
[ieFileID] :: IndexEntry -> FileID
[ieHash] :: IndexEntry -> Maybe Hash
[ieType] :: IndexEntry -> Char
[iePath] :: IndexEntry -> AnchoredPath
dumpIndex :: FilePath -> IO [IndexEntry]
align :: Integral a => a -> a -> a
instance GHC.Show.Show Darcs.Util.Index.Item
instance GHC.Classes.Eq Darcs.Util.Index.CorruptIndex
instance GHC.Exception.Type.Exception Darcs.Util.Index.CorruptIndex
instance GHC.Show.Show Darcs.Util.Index.CorruptIndex
instance Darcs.Util.Tree.FilterTree Darcs.Util.Index.IndexM GHC.Types.IO
module Darcs.Repository.Paths
makeDarcsdirPath :: String -> String
-- | Location of the lock file.
lockPath :: String
-- | Location of the prefs directory.
prefsDir :: String
prefsDirPath :: String
-- | Location of the (one and only) head inventory.
hashedInventory :: String
hashedInventoryPath :: String
-- | Location of the (one and only) tentative head inventory.
tentativeHashedInventory :: String
tentativeHashedInventoryPath :: String
-- | Location of parent inventories.
inventoriesDir :: FilePath
inventoriesDirPath :: String
-- | Location of pristine trees.
tentativePristinePath :: String
pristineDir :: FilePath
pristineDirPath :: String
-- | Location of patches.
patchesDir :: FilePath
patchesDirPath :: String
-- | Location of index files.
indexPath :: FilePath
indexInvalidPath :: FilePath
-- | Location of the rebase patch
rebasePath :: String
tentativeRebasePath :: String
-- | Location of format file
formatPath :: String
-- | Location of pending files
pendingPath :: FilePath
tentativePendingPath :: FilePath
newPendingPath :: FilePath
-- | Location of unrevert bundle.
unrevertPath :: FilePath
tentativeUnrevertPath :: FilePath
-- | Location of old style (unhashed) files and directories.
oldPristineDirPath :: String
oldCurrentDirPath :: String
oldCheckpointDirPath :: String
oldInventoryPath :: String
oldTentativeInventoryPath :: String
-- | The format file.
--
-- The purpose of the format file is to check compatibility between
-- repositories in different formats and to allow the addition of new
-- features without risking corruption by old darcs versions that do not
-- yet know about these features.
--
-- This allows a limited form of forward compatibility between darcs
-- versions. Old versions of darcs that are unaware of features added in
-- later versions will fail with a decent error message instead of
-- crashing or misbehaving or even corrupting new repos.
--
-- The format file lives at _darcs/format and must only contain printable
-- ASCII characters and must not contain the characters < and
-- >.
--
-- (We currently do not strip whitespace from the lines, but may want to
-- do so in the future.)
--
-- The file consists of format properties. A format property can contain
-- any allowed ASCII character except the vertical bar (|) and
-- newlines. Empty lines are ignored and multiple properties on the same
-- line are separated with a |.
--
-- If multiple properties appear on the same line (separated by vertical
-- bars), then this indicates alternative format properties. These have a
-- generic meaning:
--
--
-- - If we know *any* of these properties, then we can read the
-- repo.
-- - If we know *all* of them, we can also write the repo.
--
--
-- The above rules are necessary conditions, not sufficient ones. It is
-- allowed to further restrict read and/or write access for specific
-- commands, but care should be taken to not unnecessarily break forward
-- compatibility. It is not recommended, but sometimes necessary, to
-- impose ad-hoc restrictions on the format, see transferProblem
-- and readProblem for examples.
--
-- The no-working-dir property is an example for how to use alternative
-- properties. An old darcs version that does not know this format can
-- perform most read-only operations correctly even if there is no
-- working tree; however, whatsnew will report that the whole tree was
-- removed, so the solution is not perfect.
--
-- When you add a new property as an alternative to an existing one, you
-- should make sure that the old format remains to be updated in parallel
-- to the new one, so that reading the repo with old darcs versions
-- behaves correctly. If this cannot be guaranteed, it is better to add
-- the new format on a separate line.
--
-- It is not advisable for commands to modify an existing format file.
-- However, sometimes compatibility requirements may leave us no other
-- choice. In this case make sure to write the format file only after
-- having checked that the existing repo format allows modification of
-- the repo, and that you have taken the repo lock.
module Darcs.Repository.Format
-- | Representation of the format of a repository. Each sublist corresponds
-- to a line in the format file.
newtype RepoFormat
RF :: [[RepoProperty]] -> RepoFormat
data RepoProperty
Darcs1 :: RepoProperty
Darcs2 :: RepoProperty
Darcs3 :: RepoProperty
HashedInventory :: RepoProperty
NoWorkingDir :: RepoProperty
RebaseInProgress :: RepoProperty
RebaseInProgress_2_16 :: RepoProperty
UnknownFormat :: ByteString -> RepoProperty
-- | Identify the format of the repository at the given location
-- (directory, URL, or SSH path). Fails if we weren't able to identify
-- the format.
identifyRepoFormat :: String -> IO RepoFormat
-- | Identify the format of the repository at the given location
-- (directory, URL, or SSH path). Return Left 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 readProblem or writeProblem on the
-- resulting RepoFormat.
tryIdentifyRepoFormat :: String -> IO (Either String RepoFormat)
-- | Create a repo format. The first argument specifies the patch format;
-- the second says whether the repo has a working tree.
createRepoFormat :: PatchFormat -> WithWorkingDir -> RepoFormat
-- | Write the repo format to the given file. This is unsafe because we
-- don't check that we are allowed to write to the repo.
unsafeWriteRepoFormat :: RepoFormat -> FilePath -> IO ()
-- | writeProblem source returns Just an error
-- message if we cannot write to a repo in format source, or
-- Nothing if there's no such problem.
writeProblem :: RepoFormat -> Maybe String
-- | readProblem source returns Just an error
-- message if we cannot read from a repo in format source, or
-- Nothing if there's no such problem.
readProblem :: RepoFormat -> Maybe String
-- | transferProblem source target returns Just an
-- error message if we cannot transfer patches from a repo in format
-- source to a repo in format target, or Nothing
-- if there are no such problem.
transferProblem :: RepoFormat -> RepoFormat -> Maybe String
-- | Is a given property contained within a given format?
formatHas :: RepoProperty -> RepoFormat -> Bool
-- | Add a single property to an existing format.
addToFormat :: RepoProperty -> RepoFormat -> RepoFormat
-- | Remove a single property from an existing format.
removeFromFormat :: RepoProperty -> RepoFormat -> RepoFormat
instance GHC.Classes.Eq Darcs.Repository.Format.RepoProperty
instance GHC.Show.Show Darcs.Repository.Format.RepoFormat
instance GHC.Show.Show Darcs.Repository.Format.RepoProperty
-- | This module should only be imported by Darcs.UI.Options.* and by
-- Flags. Other modules needing access to DarcsFlag should
-- import Flags
module Darcs.UI.Options.Flags
-- | The DarcsFlag type is a list of all flags that can ever be
-- passed to darcs, or to one of its commands.
data DarcsFlag
Version :: DarcsFlag
ExactVersion :: DarcsFlag
ListCommands :: DarcsFlag
Help :: DarcsFlag
ListOptions :: DarcsFlag
NoTest :: DarcsFlag
Test :: DarcsFlag
OnlyChangesToFiles :: DarcsFlag
ChangesToAllFiles :: DarcsFlag
LeaveTestDir :: DarcsFlag
NoLeaveTestDir :: DarcsFlag
Timings :: DarcsFlag
Debug :: DarcsFlag
DebugHTTP :: DarcsFlag
Verbose :: DarcsFlag
NormalVerbosity :: DarcsFlag
Quiet :: DarcsFlag
To :: String -> DarcsFlag
Cc :: String -> DarcsFlag
Output :: AbsolutePathOrStd -> DarcsFlag
OutputAutoName :: AbsolutePath -> DarcsFlag
Mail :: DarcsFlag
Subject :: String -> DarcsFlag
InReplyTo :: String -> DarcsFlag
Charset :: String -> DarcsFlag
SendmailCmd :: String -> DarcsFlag
Author :: String -> DarcsFlag
SelectAuthor :: DarcsFlag
PatchName :: String -> DarcsFlag
OnePatch :: String -> DarcsFlag
SeveralPatch :: String -> DarcsFlag
AfterPatch :: String -> DarcsFlag
UpToPatch :: String -> DarcsFlag
OnePattern :: String -> DarcsFlag
SeveralPattern :: String -> DarcsFlag
AfterPattern :: String -> DarcsFlag
UpToPattern :: String -> DarcsFlag
OneHash :: String -> DarcsFlag
AfterHash :: String -> DarcsFlag
UpToHash :: String -> DarcsFlag
OneTag :: String -> DarcsFlag
SeveralTag :: String -> DarcsFlag
AfterTag :: String -> DarcsFlag
UpToTag :: String -> DarcsFlag
LastN :: String -> DarcsFlag
MaxCount :: String -> DarcsFlag
IndexRange :: String -> DarcsFlag
OneIndex :: String -> DarcsFlag
NumberPatches :: DarcsFlag
GenContext :: DarcsFlag
Context :: AbsolutePath -> DarcsFlag
Count :: DarcsFlag
LogFile :: AbsolutePath -> DarcsFlag
RmLogFile :: DarcsFlag
DontRmLogFile :: DarcsFlag
DistName :: String -> DarcsFlag
DistZip :: DarcsFlag
All :: DarcsFlag
Recursive :: DarcsFlag
NoRecursive :: DarcsFlag
Minimize :: DarcsFlag
NoMinimize :: DarcsFlag
Reorder :: DarcsFlag
NoReorder :: DarcsFlag
RestrictPaths :: DarcsFlag
DontRestrictPaths :: DarcsFlag
AskDeps :: DarcsFlag
NoAskDeps :: DarcsFlag
IgnoreTimes :: DarcsFlag
DontIgnoreTimes :: DarcsFlag
LookForAdds :: DarcsFlag
NoLookForAdds :: DarcsFlag
LookForMoves :: DarcsFlag
NoLookForMoves :: DarcsFlag
LookForReplaces :: DarcsFlag
NoLookForReplaces :: DarcsFlag
UseMyersDiff :: DarcsFlag
UsePatienceDiff :: DarcsFlag
Intersection :: DarcsFlag
Union :: DarcsFlag
Complement :: DarcsFlag
Sign :: DarcsFlag
SignAs :: String -> DarcsFlag
NoSign :: DarcsFlag
SignSSL :: String -> DarcsFlag
HappyForwarding :: DarcsFlag
NoHappyForwarding :: DarcsFlag
Verify :: AbsolutePath -> DarcsFlag
VerifySSL :: AbsolutePath -> DarcsFlag
RemoteDarcsOpt :: String -> DarcsFlag
EditDescription :: DarcsFlag
NoEditDescription :: DarcsFlag
Toks :: String -> DarcsFlag
EditLongComment :: DarcsFlag
NoEditLongComment :: DarcsFlag
PromptLongComment :: DarcsFlag
KeepDate :: DarcsFlag
NoKeepDate :: DarcsFlag
AllowConflicts :: DarcsFlag
MarkConflicts :: DarcsFlag
NoAllowConflicts :: DarcsFlag
SkipConflicts :: DarcsFlag
Boring :: DarcsFlag
SkipBoring :: DarcsFlag
AllowCaseOnly :: DarcsFlag
DontAllowCaseOnly :: DarcsFlag
AllowWindowsReserved :: DarcsFlag
DontAllowWindowsReserved :: DarcsFlag
DontGrabDeps :: DarcsFlag
DontPromptForDependencies :: DarcsFlag
PromptForDependencies :: DarcsFlag
Compress :: DarcsFlag
NoCompress :: DarcsFlag
UnCompress :: DarcsFlag
WorkRepoDir :: String -> DarcsFlag
WorkRepoUrl :: String -> DarcsFlag
NewRepo :: String -> DarcsFlag
NotInRemote :: Maybe String -> DarcsFlag
Reply :: String -> DarcsFlag
ApplyAs :: String -> DarcsFlag
MachineReadable :: DarcsFlag
HumanReadable :: DarcsFlag
Pipe :: DarcsFlag
Interactive :: DarcsFlag
DiffCmd :: String -> DarcsFlag
ExternalMerge :: String -> DarcsFlag
Summary :: DarcsFlag
NoSummary :: DarcsFlag
PauseForGui :: DarcsFlag
NoPauseForGui :: DarcsFlag
Unified :: DarcsFlag
NonUnified :: DarcsFlag
Reverse :: DarcsFlag
Forward :: DarcsFlag
Complete :: DarcsFlag
Lazy :: DarcsFlag
DiffFlags :: String -> DarcsFlag
XMLOutput :: DarcsFlag
ForceReplace :: DarcsFlag
NonApply :: DarcsFlag
NonVerify :: DarcsFlag
NonForce :: DarcsFlag
DryRun :: DarcsFlag
InheritDefault :: DarcsFlag
NoInheritDefault :: DarcsFlag
SetDefault :: DarcsFlag
NoSetDefault :: DarcsFlag
Disable :: DarcsFlag
SetScriptsExecutable :: DarcsFlag
DontSetScriptsExecutable :: DarcsFlag
Once :: DarcsFlag
Linear :: DarcsFlag
Backoff :: DarcsFlag
Bisect :: DarcsFlag
ShrinkFailure :: DarcsFlag
NoShrinkFailure :: DarcsFlag
Hashed :: DarcsFlag
UseFormat1 :: DarcsFlag
UseFormat2 :: DarcsFlag
UseFormat3 :: DarcsFlag
UseNoWorkingDir :: DarcsFlag
UseWorkingDir :: DarcsFlag
Sibling :: AbsolutePath -> DarcsFlag
Files :: DarcsFlag
NoFiles :: DarcsFlag
Directories :: DarcsFlag
NoDirectories :: DarcsFlag
Pending :: DarcsFlag
NoPending :: DarcsFlag
PosthookCmd :: String -> DarcsFlag
NoPosthook :: DarcsFlag
AskPosthook :: DarcsFlag
RunPosthook :: DarcsFlag
PrehookCmd :: String -> DarcsFlag
NoPrehook :: DarcsFlag
AskPrehook :: DarcsFlag
RunPrehook :: DarcsFlag
UMask :: String -> DarcsFlag
StoreInMemory :: DarcsFlag
ApplyOnDisk :: DarcsFlag
NoHTTPPipelining :: DarcsFlag
Packs :: DarcsFlag
NoPacks :: DarcsFlag
NoCache :: DarcsFlag
AllowUnrelatedRepos :: DarcsFlag
Check :: DarcsFlag
Repair :: DarcsFlag
JustThisRepo :: DarcsFlag
ReadMarks :: AbsolutePath -> DarcsFlag
WriteMarks :: AbsolutePath -> DarcsFlag
NullFlag :: DarcsFlag
NoAmendUnrecord :: DarcsFlag
AmendUnrecord :: DarcsFlag
PatchIndexFlag :: DarcsFlag
NoPatchIndexFlag :: DarcsFlag
EnumPatches :: DarcsFlag
NoEnumPatches :: DarcsFlag
WithPrefsTemplates :: DarcsFlag
NoPrefsTemplates :: DarcsFlag
OptimizeDeep :: DarcsFlag
OptimizeShallow :: DarcsFlag
instance GHC.Show.Show Darcs.UI.Options.Flags.DarcsFlag
instance GHC.Classes.Eq Darcs.UI.Options.Flags.DarcsFlag
-- | Constructing OptSpecs and OptDescrs
module Darcs.UI.Options.Util
-- | This type synonym is here for brevity and because we want to import
-- the data constructors (but not the type) of DarcsFlag
-- qualified.
type Flag = DarcsFlag
-- | We do not instantiate the d in OptSpec d f
-- directly with OptDescr. Instead we (post-) compose it with
-- (->) AbsolutePath. Modulo newtype noise, this is
-- the same as
--
--
-- type DarcsOptDescr f = OptDescr (AbsolutePath -> 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).
type DarcsOptDescr = Compose OptDescr ((->) AbsolutePath)
-- | This is PrimOptSpec instantiated with DarcsOptDescr and
-- Flag.
type PrimDarcsOption v = forall a. PrimOptSpec DarcsOptDescr Flag a v
-- | Construct a DarcsOptDescr with no arguments.
noArg :: [Char] -> [String] -> f -> String -> DarcsOptDescr f
-- | Construct a DarcsOptDescr with a String argument.
strArg :: SingleArgOptDescr String f
-- | Construct a DarcsOptDescr with an optional String
-- argument.
optStrArg :: SingleArgOptDescr (Maybe String) f
-- | Construct a DarcsOptDescr with an AbsolutePath argument.
absPathArg :: SingleArgOptDescr AbsolutePath f
-- | Construct a DarcsOptDescr with an AbsolutePathOrStd
-- argument.
absPathOrStdArg :: SingleArgOptDescr AbsolutePathOrStd f
-- | Construct a DarcsOptDescr with an optional AbsolutePath
-- argument.
optAbsPathArg :: [Char] -> [String] -> String -> (AbsolutePath -> f) -> String -> String -> DarcsOptDescr f
-- | The raw material from which multi-valued options are built. See
-- withDefault.
data RawOptSpec f v
RawNoArg :: [Char] -> [String] -> f -> v -> String -> RawOptSpec f v
RawStrArg :: [Char] -> [String] -> (String -> f) -> (f -> [String]) -> (String -> v) -> (v -> [String]) -> String -> String -> RawOptSpec f v
RawAbsPathArg :: [Char] -> [String] -> (AbsolutePath -> f) -> (f -> [AbsolutePath]) -> (AbsolutePath -> v) -> (v -> [AbsolutePath]) -> String -> String -> RawOptSpec f v
RawAbsPathOrStdArg :: [Char] -> [String] -> (AbsolutePathOrStd -> f) -> (f -> [AbsolutePathOrStd]) -> (AbsolutePathOrStd -> v) -> (v -> [AbsolutePathOrStd]) -> String -> String -> RawOptSpec f v
RawOptAbsPathArg :: [Char] -> [String] -> (AbsolutePath -> f) -> (f -> [AbsolutePath]) -> (AbsolutePath -> v) -> (v -> [AbsolutePath]) -> String -> String -> String -> RawOptSpec f v
-- | Construct a PrimDarcsOption from a default value and a list of
-- RawOptSpec.
--
-- Precondition: the list must have an entry for each possible value
-- (type v).
withDefault :: Eq v => v -> [RawOptSpec Flag v] -> PrimDarcsOption v
-- | Construct a Bool 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.
singleNoArg :: [Char] -> [String] -> Flag -> String -> PrimDarcsOption Bool
-- | Construct a Maybe String valued option with a
-- single flag that takes a String argument and has no default
-- flag.
--
-- The arguments are: short switches, long switches, flag constructor,
-- single flag parser, help string.
singleStrArg :: [Char] -> [String] -> (String -> Flag) -> (Flag -> Maybe String) -> String -> String -> PrimDarcsOption (Maybe String)
-- | Similar to singleStrArg, except that the flag can be given more
-- than once. The flag arguments are collected in a list of
-- Strings.
multiStrArg :: [Char] -> [String] -> (String -> Flag) -> ([Flag] -> [String]) -> String -> String -> PrimDarcsOption [String]
-- | Similar to multiStrArg, except that the flag arguments are
-- optional.
multiOptStrArg :: [Char] -> [String] -> (Maybe String -> Flag) -> ([Flag] -> [Maybe String]) -> String -> String -> PrimDarcsOption [Maybe String]
-- | Construct a Maybe AbsolutePath valued option
-- with a single flag that takes an AbsolutePath argument and has
-- no default flag.
--
-- The arguments are: short switches, long switches, flag constructor,
-- single flag parser, help string.
singleAbsPathArg :: [Char] -> [String] -> (AbsolutePath -> Flag) -> (Flag -> Maybe AbsolutePath) -> String -> String -> PrimDarcsOption (Maybe AbsolutePath)
-- | Similar to singleAbsPathArg, except that the flag can be given
-- more than once. The flag arguments are collected in a list of
-- AbsolutePaths.
multiAbsPathArg :: [Char] -> [String] -> (AbsolutePath -> Flag) -> ([Flag] -> [AbsolutePath]) -> String -> String -> PrimDarcsOption [AbsolutePath]
-- | A deprecated option. If you want to deprecate only some flags and not
-- the whole option, extract the RawOptSpecs 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.
deprecated :: [String] -> [RawOptSpec Flag v] -> PrimDarcsOption ()
parseIntArg :: String -> (Int -> Bool) -> String -> Int
parseIndexRangeArg :: String -> (Int, Int)
showIntArg :: Int -> String
showIndexRangeArg :: (Int, Int) -> String
withDashes :: [Char] -> [String] -> [String]
data AbsolutePath
-- | This is for situations where a string (e.g. a command line argument)
-- may take the value "-" to mean stdin or stdout (which one depends on
-- context) instead of a normal file path.
data AbsolutePathOrStd
instance GHC.Classes.Eq Darcs.UI.Options.Util.ArgumentParseError
instance GHC.Exception.Type.Exception Darcs.UI.Options.Util.ArgumentParseError
instance GHC.Show.Show Darcs.UI.Options.Util.ArgumentParseError
instance Darcs.UI.Options.Iso.IsoFunctor (Darcs.UI.Options.Util.RawOptSpec f)
module Darcs.UI.Options.Markdown
optionsMarkdown :: [DarcsOptDescr f] -> String
module Darcs.Repository.Prefs
data Pref
Author :: Pref
Binaries :: Pref
Boring :: Pref
Defaultrepo :: Pref
Defaults :: Pref
Email :: Pref
Motd :: Pref
Post :: Pref
Prefs :: Pref
Repos :: Pref
Sources :: Pref
addToPreflist :: Pref -> String -> IO ()
-- | delete references to other repositories. Used when cloning to a ssh
-- destination. Assume the current working dir is the repository.
deleteSources :: IO ()
getPreflist :: Pref -> IO [String]
setPreflist :: Pref -> [String] -> IO ()
getGlobal :: Pref -> IO [String]
environmentHelpHome :: ([String], [String])
getDefaultRepo :: IO (Maybe String)
-- | addRepoSource adds a new entry to _darcsprefsrepos 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.
addRepoSource :: String -> DryRun -> SetDefault -> InheritDefault -> Bool -> IO ()
getPrefval :: String -> IO (Maybe String)
setPrefval :: String -> String -> IO ()
changePrefval :: String -> String -> String -> IO ()
defPrefval :: String -> String -> IO String
writeDefaultPrefs :: WithPrefsTemplates -> IO ()
isBoring :: IO (FilePath -> Bool)
data FileType
BinaryFile :: FileType
TextFile :: FileType
filetypeFunction :: IO (FilePath -> FileType)
getCaches :: UseCache -> Maybe AbsoluteOrRemotePath -> IO Cache
globalCacheDir :: IO (Maybe FilePath)
-- | The relative path of the global preference directory;
-- ~/.darcs on Unix, and %APPDATA%/darcs on Windows.
-- This is used for online documentation.
globalPrefsDirDoc :: String
-- | The path of the global preference directory; ~/.darcs on
-- Unix, and %APPDATA%/darcs on Windows.
globalPrefsDir :: IO (Maybe FilePath)
-- | Fetch and return the message of the day for a given repository.
getMotd :: String -> IO ByteString
-- | Display the message of the day for a given repository,
showMotd :: String -> IO ()
prefsUrl :: String -> Pref -> String
prefsDirPath :: String
prefsFilePath :: FilePath
getPrefLines :: FilePath -> IO [String]
prefsFilesHelp :: [(String, String)]
instance GHC.Classes.Eq Darcs.Repository.Prefs.FileType
instance GHC.Show.Show Darcs.Repository.Prefs.Pref
instance GHC.Read.Read Darcs.Repository.Prefs.Pref
instance GHC.Classes.Ord Darcs.Repository.Prefs.Pref
instance GHC.Classes.Eq Darcs.Repository.Prefs.Pref
module Darcs.Repository.InternalTypes
-- | A Repository is a token representing the state of a
-- repository on disk. It is parameterized by
--
--
-- - rt the access type (whether we are in a
-- transaction or not),
-- - p the patch type,
-- - wU the witness for the unrecorded state (what's in
-- the working tree now).
-- - wR the witness for
- the recorded state when
-- outside a transaction, or
- the tentative state when inside a
-- transaction.
--
data Repository (rt :: AccessType) (p :: * -> * -> *) wU wR
data PristineType
NoPristine :: PristineType
PlainPristine :: PristineType
HashedPristine :: PristineType
data AccessType
RO :: AccessType
RW :: AccessType
data SAccessType (rt :: AccessType)
[SRO] :: SAccessType 'RO
[SRW] :: SAccessType 'RW
repoAccessType :: Repository rt p wU wR -> SAccessType rt
repoCache :: Repository rt p wU wR -> Cache
modifyCache :: (Cache -> Cache) -> Repository rt p wU wR -> Repository rt p wU wR
repoFormat :: Repository rt p wU wR -> RepoFormat
modifyRepoFormat :: (RepoFormat -> RepoFormat) -> Repository 'RW p wU wR -> IO (Repository 'RW p wU wR)
repoLocation :: Repository rt p wU wR -> String
-- | Perform an action with the current working directory set to the
-- repoLocation.
withRepoDir :: Repository rt p wU wR -> IO a -> IO a
repoPristineType :: Repository rt p wU wR -> PristineType
unsafeCoerceRepoType :: Repository rt p wU wR -> Repository rt' p wU wR
unsafeCoercePatchType :: Repository rt p wU wR -> Repository rt p' wU wR
unsafeCoerceR :: Repository rt p wU wR -> Repository rt p wU wR'
unsafeCoerceU :: Repository rt p wU wR -> Repository rt p wU' wR
unsafeEndTransaction :: Repository 'RW p wU wR -> Repository 'RO p wU wR
-- | Both unsafeStartTransaction and unsafeEndTransaction are
-- "unsafe" in the sense that they merely "coerce" the type but do not
-- actually perform the steps (IO 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. unsafeCoerceR, due to the
-- singleton typed member, but in practical terms it is no less unsafe,
-- because RO vs. RW 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.
unsafeStartTransaction :: Repository 'RO p wU wR -> Repository 'RW p wU wR
mkRepo :: AbsoluteOrRemotePath -> RepoFormat -> PristineType -> Cache -> Repository 'RO p wU wR
instance GHC.Classes.Eq Darcs.Repository.InternalTypes.PristineType
instance GHC.Show.Show Darcs.Repository.InternalTypes.PristineType
instance GHC.Classes.Eq Darcs.Repository.InternalTypes.AccessType
module Darcs.Patch.SummaryData
data SummDetail
SummAddDir :: AnchoredPath -> SummDetail
SummRmDir :: AnchoredPath -> SummDetail
SummFile :: SummOp -> AnchoredPath -> Int -> Int -> Int -> SummDetail
SummMv :: AnchoredPath -> AnchoredPath -> SummDetail
SummNone :: SummDetail
data SummOp
SummAdd :: SummOp
SummRm :: SummOp
SummMod :: SummOp
instance GHC.Classes.Eq Darcs.Patch.SummaryData.SummOp
instance GHC.Classes.Ord Darcs.Patch.SummaryData.SummOp
instance GHC.Classes.Eq Darcs.Patch.SummaryData.SummDetail
instance GHC.Classes.Ord Darcs.Patch.SummaryData.SummDetail
module Darcs.Patch.Object
-- | Given 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.
type family ObjectIdOf (state :: (* -> *) -> *)
-- | We require from such a key (an ObjectId) that it has a
-- canonical way to format itself to a Doc. For historical
-- reasons, this takes a parameter of type FileNameFormat.
class Eq oid => ObjectId oid
formatObjectId :: ObjectId oid => FileNameFormat -> oid -> Doc
-- | Format a AnchoredPath to a Doc according to the given
-- FileNameFormat.
--
-- 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
-- writePatchIfNecessary.
--
-- Besides white space encoding, for FileNameFormatV2 we just pack
-- it into a Doc. For FileNameFormatV1 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 readFileName.
formatFileName :: FileNameFormat -> AnchoredPath -> Doc
ap2fp :: AnchoredPath -> FilePath
instance Darcs.Patch.Object.ObjectId Darcs.Util.Path.AnchoredPath
module Darcs.Patch.Prim.FileUUID.ObjectMap
newtype UUID
UUID :: ByteString -> UUID
-- | An object is located by giving the UUID of the parent
-- Directory and a Name.
data Location
L :: !UUID -> !Name -> Location
data Object (m :: * -> *)
Directory :: DirContent -> Object (m :: * -> *)
Blob :: m FileContent -> !Maybe Hash -> Object (m :: * -> *)
data ObjectMap (m :: * -> *)
ObjectMap :: (UUID -> m (Maybe (Object m))) -> (UUID -> Object m -> m (ObjectMap m)) -> m [UUID] -> ObjectMap (m :: * -> *)
[getObject] :: ObjectMap (m :: * -> *) -> UUID -> m (Maybe (Object m))
[putObject] :: ObjectMap (m :: * -> *) -> UUID -> Object m -> m (ObjectMap m)
[listObjects] :: ObjectMap (m :: * -> *) -> m [UUID]
type DirContent = Map Name UUID
type FileContent = ByteString
isBlob :: Object m -> Bool
isDirectory :: Object m -> Bool
data Name
instance GHC.Show.Show Darcs.Patch.Prim.FileUUID.ObjectMap.UUID
instance GHC.Classes.Ord Darcs.Patch.Prim.FileUUID.ObjectMap.UUID
instance GHC.Classes.Eq Darcs.Patch.Prim.FileUUID.ObjectMap.UUID
instance GHC.Show.Show Darcs.Patch.Prim.FileUUID.ObjectMap.Location
instance GHC.Classes.Eq Darcs.Patch.Prim.FileUUID.ObjectMap.Location
module Darcs.Patch.Inspect
class PatchInspect p
listTouchedFiles :: PatchInspect p => p wX wY -> [AnchoredPath]
hunkMatches :: PatchInspect p => (ByteString -> Bool) -> p wX wY -> Bool
instance Darcs.Patch.Inspect.PatchInspect p => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Inspect.PatchInspect p => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.Witnesses.Ordered.RL p)
-- | The purpose of this module is to deal with many of the common cases
-- that come up when choosing a subset of a group of patches.
--
-- The idea is to divide a sequence of candidate patches into an initial
-- section named InFirst, a final section named InLast, and
-- between them a third section of not yet decided patches named
-- InMiddle. The reason for the neutral terminology
-- InFirst, InMiddle, and InLast, is that which of
-- InFirst and InLast counts as selected or
-- deselected depends on what we want to achive, that is, on the
-- command and its options. See Darcs.UI.SelectChanges for
-- examples of how to use the functions from this module.
--
-- Obviously if there are dependencies between the patches that will put
-- a constraint on how you can choose to divide them up. Unless stated
-- otherwise, functions that move patches from one section to another
-- pull all dependent patches with them.
--
-- Internally, we don't necessarily reorder patches immediately, but
-- merely tag them with the desired status, and thus postpone the actual
-- commutation. This saves a lot of unnecessary work, especially when
-- choices are made interactively, where the user can revise earlier
-- decisions.
module Darcs.Patch.Choices
-- | A sequence of LabelledPatches where each patch is either
-- InFirst, InMiddle, or InLast. The representation
-- is optimized for the case where we start chosing patches from the left
-- of the sequence: patches that are InFirst are commuted to the
-- head immediately, but patches that are InMiddle or
-- InLast are mixed together; when a patch is marked
-- InLast, its dependencies are not updated until we retrieve the
-- final result.
data PatchChoices p wX wY
-- | See module documentation for Darcs.Patch.Choices.
data Slot
InFirst :: Slot
InMiddle :: Slot
InLast :: Slot
-- | Create a PatchChoices from a sequence of patches, so that all
-- patches are initially InMiddle.
patchChoices :: FL p wX wY -> PatchChoices p wX wY
-- | Create a PatchChoices from an already labelled sequence of
-- patches, so that all patches are initially InMiddle.
mkPatchChoices :: FL (LabelledPatch p) wX wY -> PatchChoices p wX wY
-- | Given a LabelledPatch determine to which section of the given
-- PatchChoices it belongs. This is not trivial to compute, since
-- a patch tagged as InMiddle may be forced to actually be
-- InLast by dependencies. We return a possibly re-ordered
-- PatchChoices so as not to waste the commutation effort.
patchSlot :: forall p wA wB wX wY. Commute p => LabelledPatch p wA wB -> PatchChoices p wX wY -> (Slot, PatchChoices p wX wY)
-- | Retrieve the resulting sections from a PatchChoice. The result
-- is a triple first:>middle:>last, such that all patches
-- in first are InFirst, all patches in middle
-- are InMiddle, and all patches in last are
-- InLast.
getChoices :: Commute p => PatchChoices p wX wY -> (FL (LabelledPatch p) :> (FL (LabelledPatch p) :> FL (LabelledPatch p))) wX wY
-- | Like getChoices but lumps together InFirst and
-- InMiddle patches.
--
--
-- separateFirstMiddleFromLast c == case getChoices c of f:>m:>l -> f+>+m:>l
--
separateFirstMiddleFromLast :: Commute p => PatchChoices p wX wZ -> (FL (LabelledPatch p) :> FL (LabelledPatch p)) wX wZ
-- | Like getChoices but lumps together InMiddle and
-- InLast patches. This is more efficient than using
-- getChoices and then catenating InMiddle and
-- InLast sections because we have to commute less. (This is what
-- PatchChoices are optimized for.)
--
--
-- separateFirstFromMiddleLast c == case getChoices c of f:>m:>l -> f:>m+>+l
--
separateFirstFromMiddleLast :: PatchChoices p wX wZ -> (FL (LabelledPatch p) :> FL (LabelledPatch p)) wX wZ
-- | Force all patches matching the given predicate to be InFirst,
-- pulling any dependencies with them. This even forces any patches that
-- were already tagged InLast.
forceMatchingFirst :: forall p wA wB. Commute p => (forall wX wY. LabelledPatch p wX wY -> Bool) -> PatchChoices p wA wB -> PatchChoices p wA wB
-- | Force all patches labelled with one of the given labels to be
-- InFirst, pulling any dependencies with them. This even forces
-- any patches that were already tagged InLast.
forceFirsts :: Commute p => [Label] -> PatchChoices p wA wB -> PatchChoices p wA wB
-- | Force a single patch labelled with the given label to be
-- InFirst, pulling any dependencies with them. This even forces
-- any patches that were already tagged InLast.
forceFirst :: Commute p => Label -> PatchChoices p wA wB -> PatchChoices p wA wB
-- | Similar to forceMatchingFirst only that patches are forced to
-- be InLast regardless of their previous status.
forceMatchingLast :: Commute p => (forall wX wY. LabelledPatch p wX wY -> Bool) -> PatchChoices p wA wB -> PatchChoices p wA wB
-- | Force all patches labelled with one of the given labels to be
-- InLast, pulling any dependencies with them. This even forces
-- any patches that were previously tagged InFirst.
forceLasts :: Commute p => [Label] -> PatchChoices p wA wB -> PatchChoices p wA wB
-- | Force a single patch labelled with the given label to be
-- InLast, pulling any dependencies with them, regardless of their
-- previous status.
forceLast :: Commute p => Label -> PatchChoices p wA wB -> PatchChoices p wA wB
-- | Force a patch with the given Label to be InMiddle,
-- pulling any dependencies with it, regardless of their previous status.
forceMiddle :: Commute p => Label -> PatchChoices p wA wB -> PatchChoices p wA wB
-- | Turn InMiddle patches into InFirst and InLast
-- patches into InMiddle. Does *not* pull dependencies into
-- InFirst, instead patches that cannot be commuted past
-- InLast patches stay InMiddle.
makeEverythingSooner :: forall p wX wY. Commute p => PatchChoices p wX wY -> PatchChoices p wX wY
-- | Turn InFirst patches into InMiddle ones and
-- InMiddle into InLast ones.
makeEverythingLater :: PatchChoices p wX wY -> PatchChoices p wX wY
-- | Make all InMiddle patches either InFirst or
-- InLast. This does *not* modify any patches that are already
-- determined to be InLast by dependencies.
selectAllMiddles :: forall p wX wY. Commute p => Bool -> PatchChoices p wX wY -> PatchChoices p wX wY
-- | Use the given monadic PatchChoices transformer on the
-- InMiddle section of a PatchChoices, then fold the result
-- back into the original PatchChoices.
refineChoices :: (Commute p, Monad m) => (forall wU wV. FL (LabelledPatch p) wU wV -> PatchChoices p wU wV -> m (PatchChoices p wU wV)) -> PatchChoices p wX wY -> m (PatchChoices p wX wY)
-- | Substitute a single LabelledPatch with an equivalent list of
-- patches, preserving its status as InFirst, InMiddle or
-- InLast). The patch is looked up using equality of
-- Labels.
substitute :: forall p wX wY. Sealed2 (LabelledPatch p :||: FL (LabelledPatch p)) -> PatchChoices p wX wY -> PatchChoices p wX wY
-- | A patch with a Label attached to it.
data LabelledPatch p wX wY
-- | Label 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 5, the resulting sub-patches could be identified as
-- Label (Just (Label Nothing 5))1, Label (Just (Label
-- Nothing 5)) 2, etc.
--
-- IOW, Label is a non-empty, reversed list of Ints.
data Label
label :: LabelledPatch p wX wY -> Label
unLabel :: LabelledPatch p wX wY -> p wX wY
-- | Label a sequence of patches, maybe using the given parent label.
labelPatches :: Maybe Label -> FL p wX wY -> FL (LabelledPatch p) wX wY
getLabelInt :: Label -> Int
instance GHC.Classes.Eq Darcs.Patch.Choices.Label
instance Darcs.Patch.Commute.Commute p => Darcs.Patch.Commute.Commute (Darcs.Patch.Choices.PatchChoice p)
instance Darcs.Patch.Inspect.PatchInspect p => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.Choices.PatchChoice p)
instance Darcs.Patch.Invert.Invert p => Darcs.Patch.Invert.Invert (Darcs.Patch.Choices.LabelledPatch p)
instance Darcs.Patch.Commute.Commute p => Darcs.Patch.Commute.Commute (Darcs.Patch.Choices.LabelledPatch p)
instance Darcs.Patch.Inspect.PatchInspect p => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.Choices.LabelledPatch p)
module Darcs.Patch.ApplyMonad
class (Monad m, ApplyMonadOperations state m) => ApplyMonad (state :: (* -> *) -> *) m | m -> state
readFilePS :: ApplyMonad state m => ObjectIdOf state -> m ByteString
class (Monad m, ApplyMonad state (ApplyMonadOver state m)) => ApplyMonadTrans state m where {
type ApplyMonadOver state m :: * -> *;
}
runApplyMonad :: ApplyMonadTrans state m => ApplyMonadOver state m x -> state m -> m (x, state m)
type family ApplyMonadOperations (state :: (* -> *) -> *) :: (* -> *) -> Constraint
-- | withFileNames takes a maybe list of existing rename-pairs, a list of
-- filenames and an action, and returns the resulting triple of affected
-- files, updated filename list and new rename details. If the
-- rename-pairs are not present, a new list is generated from the
-- filesnames.
withFileNames :: Maybe [OrigFileNameOf] -> [AnchoredPath] -> FilePathMonad a -> FilePathMonadState
class MonadThrow m => ApplyMonadTree m
mDoesDirectoryExist :: ApplyMonadTree m => AnchoredPath -> m Bool
mDoesFileExist :: ApplyMonadTree m => AnchoredPath -> m Bool
mReadFilePS :: ApplyMonadTree m => AnchoredPath -> m ByteString
mCreateDirectory :: ApplyMonadTree m => AnchoredPath -> m ()
mRemoveDirectory :: ApplyMonadTree m => AnchoredPath -> m ()
mCreateFile :: ApplyMonadTree m => AnchoredPath -> m ()
mRemoveFile :: ApplyMonadTree m => AnchoredPath -> m ()
mRename :: ApplyMonadTree m => AnchoredPath -> AnchoredPath -> m ()
mModifyFilePS :: ApplyMonadTree m => AnchoredPath -> (ByteString -> m ByteString) -> m ()
mChangePref :: ApplyMonadTree m => String -> String -> String -> m ()
evalApplyMonad :: ApplyMonadTrans state m => ApplyMonadOver state m a -> state m -> m a
instance GHC.Base.Monad Darcs.Patch.ApplyMonad.Pure
instance GHC.Base.Applicative Darcs.Patch.ApplyMonad.Pure
instance GHC.Base.Functor Darcs.Patch.ApplyMonad.Pure
instance Darcs.Patch.ApplyMonad.ApplyMonad Darcs.Util.Tree.Tree Darcs.Patch.ApplyMonad.FilePathMonad
instance Darcs.Patch.ApplyMonad.ApplyMonadTree Darcs.Patch.ApplyMonad.FilePathMonad
instance Control.Monad.Catch.MonadThrow Darcs.Patch.ApplyMonad.Pure
instance Control.Monad.Catch.MonadThrow m => Darcs.Patch.ApplyMonad.ApplyMonadTrans Darcs.Util.Tree.Tree m
instance Control.Monad.Catch.MonadThrow m => Darcs.Patch.ApplyMonad.ApplyMonad Darcs.Util.Tree.Tree (Darcs.Util.Tree.Monad.TreeMonad m)
instance Control.Monad.Catch.MonadThrow m => Darcs.Patch.ApplyMonad.ApplyMonadTree (Darcs.Util.Tree.Monad.TreeMonad m)
module Darcs.Repository.ApplyPatches
-- | Apply patches, emitting warnings if there are any IO errors
runTolerantly :: TolerantWrapper TolerantIO a -> IO a
-- | Apply patches, ignoring all errors
runSilently :: TolerantWrapper SilentIO a -> IO a
data DefaultIO a
-- | The default mode of applying patches: fail if the directory is not as
-- we expect
runDefault :: DefaultIO a -> IO a
instance Control.Monad.Catch.MonadThrow Darcs.Repository.ApplyPatches.DefaultIO
instance GHC.Base.Monad Darcs.Repository.ApplyPatches.DefaultIO
instance GHC.Base.Applicative Darcs.Repository.ApplyPatches.DefaultIO
instance GHC.Base.Functor Darcs.Repository.ApplyPatches.DefaultIO
instance Control.Monad.Catch.MonadThrow Darcs.Repository.ApplyPatches.TolerantIO
instance GHC.Base.Monad Darcs.Repository.ApplyPatches.TolerantIO
instance GHC.Base.Applicative Darcs.Repository.ApplyPatches.TolerantIO
instance GHC.Base.Functor Darcs.Repository.ApplyPatches.TolerantIO
instance Control.Monad.Catch.MonadThrow Darcs.Repository.ApplyPatches.SilentIO
instance GHC.Base.Monad Darcs.Repository.ApplyPatches.SilentIO
instance GHC.Base.Applicative Darcs.Repository.ApplyPatches.SilentIO
instance GHC.Base.Functor Darcs.Repository.ApplyPatches.SilentIO
instance Darcs.Repository.ApplyPatches.TolerantMonad m => Darcs.Repository.ApplyPatches.TolerantMonad (Darcs.Repository.ApplyPatches.TolerantWrapper m)
instance GHC.Base.Monad m => GHC.Base.Monad (Darcs.Repository.ApplyPatches.TolerantWrapper m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Darcs.Repository.ApplyPatches.TolerantWrapper m)
instance GHC.Base.Functor m => GHC.Base.Functor (Darcs.Repository.ApplyPatches.TolerantWrapper m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Darcs.Repository.ApplyPatches.TolerantWrapper m)
instance Darcs.Repository.ApplyPatches.TolerantMonad m => Darcs.Patch.ApplyMonad.ApplyMonad Darcs.Util.Tree.Tree (Darcs.Repository.ApplyPatches.TolerantWrapper m)
instance Darcs.Repository.ApplyPatches.TolerantMonad m => Darcs.Patch.ApplyMonad.ApplyMonadTree (Darcs.Repository.ApplyPatches.TolerantWrapper m)
instance Darcs.Repository.ApplyPatches.TolerantMonad Darcs.Repository.ApplyPatches.SilentIO
instance Darcs.Repository.ApplyPatches.TolerantMonad Darcs.Repository.ApplyPatches.TolerantIO
instance Darcs.Patch.ApplyMonad.ApplyMonad Darcs.Util.Tree.Tree Darcs.Repository.ApplyPatches.DefaultIO
instance Darcs.Patch.ApplyMonad.ApplyMonadTree Darcs.Repository.ApplyPatches.DefaultIO
module Darcs.Patch.Apply
class Apply p where {
type ApplyState p :: (* -> *) -> *;
}
apply :: (Apply p, ApplyMonad (ApplyState p) m) => p wX wY -> m ()
unapply :: (Apply p, ApplyMonad (ApplyState p) m) => p wX wY -> m ()
unapply :: (Apply p, ApplyMonad (ApplyState p) m, Invert p) => p wX wY -> m ()
type ObjectIdOfPatch p = ObjectIdOf (ApplyState p)
applyToPaths :: (Apply p, ApplyState p ~ Tree) => p wX wY -> Maybe [(AnchoredPath, AnchoredPath)] -> [AnchoredPath] -> ([AnchoredPath], [AnchoredPath], [(AnchoredPath, AnchoredPath)])
-- | Apply a patch to a Tree, yielding a new Tree.
applyToTree :: (Apply p, MonadThrow m, ApplyState p ~ Tree) => p wX wY -> Tree m -> m (Tree m)
applyToState :: forall p m wX wY. (Apply p, ApplyMonadTrans (ApplyState p) m) => p wX wY -> ApplyState p m -> m (ApplyState p m)
-- | Attempts to apply a given patch to a Tree. If the apply fails, we
-- return Nothing, otherwise we return the updated Tree.
maybeApplyToTree :: (Apply p, ApplyState p ~ Tree, MonadCatch m) => p wX wY -> Tree m -> m (Maybe (Tree m))
effectOnPaths :: (Apply p, ApplyState p ~ Tree) => p wX wY -> [AnchoredPath] -> [AnchoredPath]
instance Darcs.Patch.Apply.Apply p => Darcs.Patch.Apply.Apply (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Apply.Apply p => Darcs.Patch.Apply.Apply (Darcs.Patch.Witnesses.Ordered.RL p)
module Darcs.Patch.TouchesFiles
lookTouch :: (Apply p, ApplyState p ~ Tree) => Maybe [(AnchoredPath, AnchoredPath)] -> [AnchoredPath] -> p wX wY -> (Bool, [AnchoredPath], [AnchoredPath], [(AnchoredPath, AnchoredPath)])
chooseTouching :: (Apply p, Commute p, PatchInspect p, ApplyState p ~ Tree) => Maybe [AnchoredPath] -> FL p wX wY -> Sealed (FL p wX)
deselectNotTouching :: (Apply p, Commute p, PatchInspect p, ApplyState p ~ Tree) => Maybe [AnchoredPath] -> PatchChoices p wX wY -> PatchChoices p wX wY
selectNotTouching :: (Apply p, Commute p, PatchInspect p, ApplyState p ~ Tree) => Maybe [AnchoredPath] -> PatchChoices p wX wY -> PatchChoices p wX wY
module Darcs.Patch.Show
class ShowPatchBasic p
showPatch :: ShowPatchBasic p => ShowPatchFor -> p wX wY -> Doc
displayPatch :: ShowPatchBasic p => p wX wY -> Doc
data ShowPatchFor
ForDisplay :: ShowPatchFor
ForStorage :: ShowPatchFor
-- | This class is used only for user interaction, not for storage. The
-- default implementations for description and content are
-- suitable only for PrimPatch and RepoPatch types.
-- Logically, description should default to mempty while
-- content should default to displayPatch. We define them
-- the other way around so that showFriendly gives reasonable
-- results for all patch types.
class ShowPatchBasic p => ShowPatch p
content :: ShowPatch p => p wX wY -> Doc
description :: ShowPatch p => p wX wY -> Doc
summary :: ShowPatch p => p wX wY -> Doc
summaryFL :: ShowPatch p => FL p wX wY -> Doc
thing :: ShowPatch p => p wX wY -> String
things :: ShowPatch p => p wX wY -> String
class ShowPatchBasic p => ShowContextPatch p
-- | Show 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 ApplyState.
--
-- Note that this applies the patch in the ApplyMonad 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.
--
-- For a version that does not apply the patch see
-- showPatchWithContext.
showPatchWithContextAndApply :: (ShowContextPatch p, ApplyMonad (ApplyState p) m) => ShowPatchFor -> p wX wY -> m Doc
-- | Like showPatchWithContextAndApply but without applying the
-- patch in the monad m.
showPatchWithContext :: (ApplyMonadTrans (ApplyState p) m, ShowContextPatch p) => ShowPatchFor -> ApplyState p m -> p wX wY -> m Doc
-- | Format a AnchoredPath to a Doc according to the given
-- FileNameFormat.
--
-- 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
-- writePatchIfNecessary.
--
-- Besides white space encoding, for FileNameFormatV2 we just pack
-- it into a Doc. For FileNameFormatV1 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 readFileName.
formatFileName :: FileNameFormat -> AnchoredPath -> Doc
module Darcs.Patch.Info
-- | A PatchInfo value contains the metadata of a patch. The date, name,
-- author and log fields are UTF-8 encoded text in darcs 2.4 and later,
-- and just sequences of bytes (decoded with whatever is the locale when
-- displayed) in earlier darcs.
--
-- The members with names that start with '_' are not supposed to be used
-- directly in code that does not care how the patch info is stored.
--
-- _piLegacyIsInverted:
--
-- Historically, the isInverted flag was used to indicate that a
-- Named patch was inverted.
--
-- We no longer support direct inversion of Named patches, except
-- sometimes via the Invertible 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 PatchInfo apart from never being set
-- freshly:
--
--
-- - There is no semantic relationship between a PatchInfo with
-- piLegacyIsInverted = False and the same PatchInfo with
-- piLegacyIsInverted = True. 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 = True should work with
-- all the normal darcs operations.
--
--
-- The flag is completely separate and orthogonal to the tracking of
-- explicit inversion in the Invertible wrapper. The
-- Invertible 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.
data PatchInfo
PatchInfo :: !ByteString -> !ByteString -> !ByteString -> ![ByteString] -> !Bool -> PatchInfo
[_piDate] :: PatchInfo -> !ByteString
[_piName] :: PatchInfo -> !ByteString
[_piAuthor] :: PatchInfo -> !ByteString
[_piLog] :: PatchInfo -> ![ByteString]
-- | See the long description of this field in the docs above.
[_piLegacyIsInverted] :: PatchInfo -> !Bool
rawPatchInfo :: TestOnly => String -> String -> String -> [String] -> Bool -> PatchInfo
-- | patchinfo date name author log constructs a new
-- PatchInfo 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.
patchinfo :: String -> String -> String -> [String] -> IO PatchInfo
-- | addJunk adds a line that contains a random number to make the patch
-- unique.
addJunk :: PatchInfo -> IO PatchInfo
replaceJunk :: PatchInfo -> IO PatchInfo
-- | Hash on patch metadata (patch name, author, date, log, and the legacy
-- "inverted" flag. Robust against context changes but does not guarantee
-- patch contents. Usually used as matcher or patch identifier (see
-- Darcs.Patch.Match).
makePatchname :: PatchInfo -> SHA1
-- | Parser for PatchInfo as stored in patch bundles and inventory
-- files, for example:
--
--
-- [Document the foo interface
-- John Doe <john.doe@example.com>**20110615084241
-- Ignore-this: 85b94f67d377c4ab671101266ef9c229
-- Nobody knows what a 'foo' is, so describe it.
-- ]
--
--
-- See showPatchInfo for the inverse operation.
readPatchInfo :: Parser PatchInfo
-- | Get the name, including an "UNDO: " prefix if the patch is a legacy
-- inverted patch.
justName :: PatchInfo -> String
-- | Returns the author of a patch.
justAuthor :: PatchInfo -> String
justLog :: PatchInfo -> String
displayPatchInfo :: PatchInfo -> Doc
toXml :: PatchInfo -> Doc
toXmlShort :: PatchInfo -> Doc
piDate :: PatchInfo -> CalendarTime
piDateString :: PatchInfo -> String
-- | Returns the name of the patch. Unlike justName, it does not
-- preprend "UNDO: " to the name if the patch has the legacy inverted
-- flag set.
piName :: PatchInfo -> String
piRename :: PatchInfo -> String -> PatchInfo
-- | Returns the author of a patch.
piAuthor :: PatchInfo -> String
-- | Get the tag name, if the patch is a tag patch.
piTag :: PatchInfo -> Maybe String
-- | Get the log message of a patch.
piLog :: PatchInfo -> [String]
showPatchInfo :: ShowPatchFor -> PatchInfo -> Doc
isTag :: PatchInfo -> Bool
escapeXML :: String -> Doc
validDate :: String -> Bool
validLog :: String -> Bool
validAuthor :: String -> Bool
validDatePS :: ByteString -> Bool
validLogPS :: ByteString -> Bool
validAuthorPS :: ByteString -> Bool
instance GHC.Show.Show Darcs.Patch.Info.PatchInfo
instance GHC.Classes.Ord Darcs.Patch.Info.PatchInfo
instance GHC.Classes.Eq Darcs.Patch.Info.PatchInfo
module Darcs.Repository.Inventory.Format
data Inventory
Inventory :: Maybe InventoryHash -> [InventoryEntry] -> Inventory
[inventoryParent] :: Inventory -> Maybe InventoryHash
[inventoryPatches] :: Inventory -> [InventoryEntry]
type HeadInventory = (PristineHash, Inventory)
type InventoryEntry = (PatchInfo, PatchHash)
-- | External API for the various hash types.
class (Eq h, IsSizeHash h) => ValidHash h
-- | The HashedDir belonging to this type of hash
dirofValidHash :: ValidHash h => h -> HashedDir
-- | Compute hash from file content.
calcValidHash :: ValidHash h => ByteString -> h
decodeValidHash :: ValidHash h => String -> Maybe h
encodeValidHash :: ValidHash h => h -> String
data InventoryHash
data PatchHash
data PristineHash
inventoryPatchNames :: Inventory -> [String]
parseInventory :: ByteString -> Either String Inventory
parseHeadInventory :: ByteString -> Either String HeadInventory
showInventory :: Inventory -> Doc
showInventoryPatches :: [InventoryEntry] -> Doc
showInventoryEntry :: InventoryEntry -> Doc
emptyInventory :: Inventory
-- | Replace the pristine hash at the start of a raw, unparsed
-- HeadInventory or add it if none is present.
pokePristineHash :: PristineHash -> ByteString -> Doc
peekPristineHash :: ByteString -> PristineHash
-- | skipPristineHash drops the 'pristine: HASH' prefix line, if present.
skipPristineHash :: ByteString -> ByteString
pristineName :: ByteString
prop_inventoryParseShow :: Inventory -> Bool
prop_peekPokePristineHash :: (PristineHash, ByteString) -> Bool
prop_skipPokePristineHash :: (PristineHash, ByteString) -> Bool
instance GHC.Show.Show Darcs.Repository.Inventory.Format.Inventory
instance GHC.Classes.Eq Darcs.Repository.Inventory.Format.Inventory
module Darcs.Patch.Index.Types
-- | The FileId for a file consists of the FilePath (creation name) and an
-- index. The index denotes how many files with the same name have been
-- added before (and subsequently deleted or moved)
data FileId
FileId :: AnchoredPath -> Int -> FileId
[cname] :: FileId -> AnchoredPath
[count] :: FileId -> Int
-- | Convert FileId to string
showFileId :: FileId -> String
-- | The PatchId identifies a patch and can be created from a PatchInfo
-- with makePatchname
newtype PatchId
PID :: SHA1 -> PatchId
[patchId] :: PatchId -> SHA1
pid2string :: PatchId -> String
short :: PatchId -> Int
zero :: PatchId
makePatchID :: PatchInfo -> PatchId
instance GHC.Classes.Ord Darcs.Patch.Index.Types.FileId
instance GHC.Show.Show Darcs.Patch.Index.Types.FileId
instance GHC.Classes.Eq Darcs.Patch.Index.Types.FileId
instance GHC.Classes.Eq Darcs.Patch.Index.Types.PatchId
instance GHC.Classes.Ord Darcs.Patch.Index.Types.PatchId
instance GHC.Show.Show Darcs.Patch.Index.Types.PatchId
instance Data.Binary.Class.Binary Darcs.Patch.Index.Types.PatchId
instance Data.Binary.Class.Binary Darcs.Patch.Index.Types.FileId
module Darcs.Patch.Ident
-- | Class of patches that have an identity/name.
--
-- Patches with an identity give rise to the notion of nominal
-- equality, expressed by the operators =\^/= and
-- =/^\=.
--
-- Laws:
--
--
-- - ident-commute Patch identity must be invariant under
-- commutation:
'commute' (p :> _) == 'Just' (_ :> p') =>
-- 'ident' p == 'ident' p'
and thus (via symmetry of
-- commute):'commute' (_ :> q) == 'Just' (q' :> _)
-- => 'ident' q == 'ident' q'
Conversely, patches with the same
-- identity result from a series of commutes:'ident' p ==
-- 'ident' p' => exists qs, qs' :: FL p. 'commuteFL' (p :> qs) ==
-- 'Just' (qs' :> p')
-- - ident-compare In general, comparing patches via
-- their identity is weaker than (semantic) equality:
'unsafeCompare'
-- p q => 'ident' p == 'ident' q
However, if the patches have a
-- common context, then semantic and nominal equality should coincide, up
-- to internal re-ordering:p '=\~/=' q <=> p '=\^/='
-- q
p '=/~\=' q <=> p '=/^\=' q
(Technical note:
-- equality up to internal re-ordering is currently only defined for
-- FLs, 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.
class Ord (PatchId p) => Ident p
ident :: Ident p => p wX wY -> PatchId p
-- | Constraint for patches that have an identity that is signed, i.e. can
-- be positive (uninverted) or negative (inverted).
--
-- Provided that an instance Invert exists, inverting a patch
-- inverts its identity:
--
--
-- 'ident' ('invert' p) = 'invertId' ('ident' p)
--
type SignedIdent p = (Ident p, SignedId (PatchId p))
-- | The reason this is not associated to class Ident 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 Ident.
type family PatchId (p :: * -> * -> *)
-- | Nominal equality for patches with an identity in the same context.
-- Usually quite a bit faster than structural equality.
(=\^/=) :: Ident p => p wA wB -> p wA wC -> EqCheck wB wC
(=/^\=) :: Ident p => p wA wC -> p wB wC -> EqCheck wA wB
-- | Signed identities.
--
-- Like for class Invert, we require that invertId is
-- self-inverse:
--
--
-- 'invertId' . 'invertId' = 'id'
--
--
-- We also require that inverting changes the sign:
--
--
-- 'positiveId' . 'invertId' = 'not' . 'positiveId'
--
--
-- Side remark: in mathematical terms, these properties can be expressed
-- by stating that invertId is an involution and that
-- positiveId is a "homomorphism of sets with an involution"
-- (there is no official term for this) from a to the simplest
-- non-trivial set with involution, namely Bool with the
-- involution not.
class Ord a => SignedId a
positiveId :: SignedId a => a -> Bool
invertId :: SignedId a => a -> a
-- | Storable 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 readId to produce
-- x:
--
--
-- 'parse' 'readId' . 'renderPS' . 'showId' 'ForStorage' == 'id'
--
class StorableId a
readId :: StorableId a => Parser a
showId :: StorableId a => ShowPatchFor -> a -> Doc
-- | Remove a patch from an FL of patches with an identity. The result is
-- Just whenever the patch has been found and removed and
-- Nothing 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.
fastRemoveFL :: forall p wX wY wZ. (Commute p, Ident p) => p wX wY -> FL p wX wZ -> Maybe (FL p wY wZ)
-- | Same as fastRemoveFL only for RL.
fastRemoveRL :: forall p wX wY wZ. (Commute p, Ident p) => p wY wZ -> RL p wX wZ -> Maybe (RL p wX wY)
fastRemoveSubsequenceRL :: (Commute p, Ident p) => RL p wY wZ -> RL p wX wZ -> Maybe (RL p wX wY)
-- | Find the common and uncommon parts of two lists that start in a common
-- context, using patch identity for comparison. Of the common patches,
-- only one is retained, the other is discarded.
findCommonFL :: (Commute p, Ident p) => FL p wX wY -> FL p wX wZ -> Fork (FL p) (FL p) (FL p) wX wY wZ
findCommonRL :: (Commute p, Ident p) => RL p wX wY -> RL p wX wZ -> Fork (RL p) (RL p) (RL p) wX wY wZ
findCommonWithThemFL :: (Commute p, Ident p) => FL p wX wY -> FL p wX wZ -> (FL p :> FL p) wX wY
findCommonWithThemRL :: (Commute p, Ident p) => RL p wX wY -> RL p wX wZ -> (RL p :> RL p) wX wY
-- | Try to commute all patches matching any of the PatchIds in the
-- set to the head of an FL, i.e. backwards in history.
commuteToPrefix :: (Commute p, Ident p) => Set (PatchId p) -> FL p wX wY -> Maybe ((FL p :> RL p) wX wY)
prop_identInvariantUnderCommute :: (Commute p, Ident p) => (p :> p) wX wY -> Maybe Bool
prop_sameIdentityImpliesCommutable :: (Commute p, Eq2 p, Ident p) => (p :\/: (RL p :> p)) wX wY -> Maybe Bool
prop_equalImpliesSameIdentity :: (Eq2 p, Ident p) => p wA wB -> p wC wD -> Maybe Bool
prop_sameIdentityImpliesEqual :: (Eq2 p, Ident p) => (p :\/: p) wX wY -> Maybe Bool
instance Darcs.Patch.Ident.Ident p => Darcs.Patch.Ident.Ident (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Ident.Ident p => Darcs.Patch.Ident.Ident (Darcs.Patch.Witnesses.Ordered.RL p)
instance Darcs.Patch.Ident.Ident p => Darcs.Patch.Ident.Ident (p Darcs.Patch.Witnesses.Ordered.:> p)
module Darcs.Patch.Bracketed
-- | This type exists for legacy support of on-disk format patch formats.
-- It is a wrapper type that explicitly tracks the nesting of braces and
-- parens in the on-disk representation of such patches. It is used as an
-- intermediate form when reading such patches normally, and also for
-- round-tripping such patches when checking the hash in bundles. It
-- shouldn't be used for anything else.
data Bracketed p wX wY
[Singleton] :: p wX wY -> Bracketed p wX wY
[Braced] :: BracketedFL p wX wY -> Bracketed p wX wY
[Parens] :: BracketedFL p wX wY -> Bracketed p wX wY
mapBracketed :: (forall wA wB. p wA wB -> q wA wB) -> Bracketed p wX wY -> Bracketed q wX wY
unBracketed :: Bracketed p wX wY -> FL p wX wY
type BracketedFL p wX wY = FL (Bracketed p) wX wY
mapBracketedFLFL :: (forall wA wB. p wA wB -> q wA wB) -> BracketedFL p wX wY -> BracketedFL q wX wY
unBracketedFL :: BracketedFL p wX wY -> FL p wX wY
instance Darcs.Patch.Format.PatchListFormat (Darcs.Patch.Bracketed.Bracketed p)
instance Darcs.Patch.Show.ShowPatchBasic p => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.Bracketed.Bracketed p)
module Darcs.Patch.Read
-- | This class is used to decode patches from their binary representation.
class ReadPatch p
readPatch' :: ReadPatch p => Parser (Sealed (p wX))
readPatch :: ReadPatch p => ByteString -> Either String (Sealed (p wX))
readPatchPartial :: ReadPatch p => ByteString -> Either String (Sealed (p wX), ByteString)
bracketedFL :: forall p wX. (forall wY. Parser (Sealed (p wY))) -> Char -> Char -> Parser (Sealed (FL p wX))
peekfor :: ByteString -> Parser a -> Parser a -> Parser a
readFileName :: HasCallStack => FileNameFormat -> Parser AnchoredPath
instance Darcs.Patch.Read.ReadPatch p => Darcs.Patch.Read.ReadPatch (Darcs.Patch.Bracketed.Bracketed p)
instance (Darcs.Patch.Read.ReadPatch p, Darcs.Patch.Format.PatchListFormat p) => Darcs.Patch.Read.ReadPatch (Darcs.Patch.Witnesses.Ordered.FL p)
instance (Darcs.Patch.Read.ReadPatch p, Darcs.Patch.Format.PatchListFormat p) => Darcs.Patch.Read.ReadPatch (Darcs.Patch.Witnesses.Ordered.RL p)
module Darcs.Patch.Repair
-- | Repair and RepairToFL deal with repairing old patches
-- that were were written out due to bugs or that we no longer wish to
-- support. Repair is implemented by collections of patches (FL,
-- Named, PatchInfoAnd) that might need repairing.
class Repair p
applyAndTryToFix :: (Repair p, ApplyMonad (ApplyState p) m) => p wX wY -> m (Maybe (String, p wX wY))
-- | RepairToFL 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.
class Apply p => RepairToFL p
applyAndTryToFixFL :: (RepairToFL p, ApplyMonad (ApplyState p) m) => p wX wY -> m (Maybe (String, FL p wX wY))
mapMaybeSnd :: (a -> b) -> Maybe (c, a) -> Maybe (c, b)
class Check p
isInconsistent :: Check p => p wX wY -> Maybe Doc
instance Darcs.Patch.Repair.RepairToFL p => Darcs.Patch.Repair.Repair (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Repair.Check p => Darcs.Patch.Repair.Check (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Repair.Check p => Darcs.Patch.Repair.Check (Darcs.Patch.Witnesses.Ordered.RL p)
module Darcs.Patch.Index.Monad
withPatchMods :: FileModMonad a -> Set AnchoredPath -> FileModState
-- | Apply a patch to set of AnchoredPaths, yielding the new set of
-- AnchoredPaths and FileMods
applyToFileMods :: (Apply p, ApplyState p ~ Tree) => p wX wY -> Set AnchoredPath -> FileModState
-- | This is used to track changes to files
data FileMod a
PTouch :: a -> FileMod a
PCreateFile :: a -> FileMod a
PCreateDir :: a -> FileMod a
PRename :: a -> a -> FileMod a
PRemove :: a -> FileMod a
-- | this is used for duplicate patches that don't have any effect, but we
-- still want to keep track of them
PDuplicateTouch :: a -> FileMod a
instance GHC.Base.Functor Darcs.Patch.Index.Monad.FileMod
instance GHC.Classes.Eq a => GHC.Classes.Eq (Darcs.Patch.Index.Monad.FileMod a)
instance GHC.Show.Show a => GHC.Show.Show (Darcs.Patch.Index.Monad.FileMod a)
instance Control.Monad.State.Class.MonadState Darcs.Patch.Index.Monad.FileModState Darcs.Patch.Index.Monad.FileModMonad
instance Control.Monad.Catch.MonadThrow Darcs.Patch.Index.Monad.FileModMonad
instance GHC.Base.Monad Darcs.Patch.Index.Monad.FileModMonad
instance GHC.Base.Applicative Darcs.Patch.Index.Monad.FileModMonad
instance GHC.Base.Functor Darcs.Patch.Index.Monad.FileModMonad
instance Darcs.Patch.ApplyMonad.ApplyMonad Darcs.Util.Tree.Tree Darcs.Patch.Index.Monad.FileModMonad
instance Darcs.Patch.ApplyMonad.ApplyMonadTree Darcs.Patch.Index.Monad.FileModMonad
module Darcs.Patch.FileHunk
data FileHunk oid wX wY
FileHunk :: oid -> !Int -> [ByteString] -> [ByteString] -> FileHunk oid wX wY
class IsHunk p
isHunk :: IsHunk p => p wX wY -> Maybe (FileHunk (ObjectIdOfPatch p) wX wY)
showFileHunk :: ObjectId oid => FileNameFormat -> FileHunk oid wX wY -> Doc
showContextFileHunk :: ObjectId oid => FileNameFormat -> [ByteString] -> FileHunk oid wB wC -> [ByteString] -> Doc
instance Darcs.Patch.Invert.Invert (Darcs.Patch.FileHunk.FileHunk oid)
module Darcs.Patch.Viewing
showContextHunk :: (ApplyMonad state m, oid ~ ObjectIdOf state, ObjectId oid) => FileNameFormat -> FileHunk oid wX wY -> m Doc
instance (Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Show.ShowPatchBasic p) => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.Witnesses.Ordered.FL p)
instance (Darcs.Patch.Apply.Apply p, Darcs.Patch.FileHunk.IsHunk p, Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Show.ShowContextPatch p, Darcs.Patch.Object.ObjectId (Darcs.Patch.Apply.ObjectIdOfPatch p)) => Darcs.Patch.Show.ShowContextPatch (Darcs.Patch.Witnesses.Ordered.FL p)
instance (Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Show.ShowPatch p) => Darcs.Patch.Show.ShowPatch (Darcs.Patch.Witnesses.Ordered.FL p)
instance (Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Show.ShowPatchBasic p) => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.Witnesses.Ordered.RL p)
instance (Darcs.Patch.Show.ShowContextPatch p, Darcs.Patch.Apply.Apply p, Darcs.Patch.FileHunk.IsHunk p, Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Object.ObjectId (Darcs.Patch.Apply.ObjectIdOfPatch p)) => Darcs.Patch.Show.ShowContextPatch (Darcs.Patch.Witnesses.Ordered.RL p)
instance (Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Show.ShowPatch p) => Darcs.Patch.Show.ShowPatch (Darcs.Patch.Witnesses.Ordered.RL p)
-- | Contexted patches.
module Darcs.Patch.V3.Contexted
data Contexted p wX
-- | Identity of a contexted patch.
ctxId :: Ident p => Contexted p wX -> PatchId p
-- | We sometimes want to pattern match on a Contexted patch but
-- still guard against violation of the invariants. So we export a view
-- that is isomorphic to the Contexted type but doesn't allow to
-- manipulate the internals.
ctxView :: Contexted p wX -> Sealed ((FL p :> p) wX)
-- | Contexted patches conflict with each other if the identity of
-- one is in the context of the other or they cannot be merged cleanly.
ctxNoConflict :: (CleanMerge p, Commute p, Ident p) => Contexted p wX -> Contexted p wX -> Bool
-- | Convert a Contexted patch into a plain FL with the patch
-- at the end.
ctxToFL :: Contexted p wX -> Sealed (FL p wX)
-- | Wether 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.
ctxDepends :: Ident p => Contexted p wX -> Contexted p wX -> Bool
-- | A Contexted patch with empty context.
ctx :: p wX wY -> Contexted p wX
-- | Add a patch to the context of a Contexted patch. This is the
-- place where we take care of the invariants.
ctxAdd :: (Commute p, Invert p, Ident p) => p wX wY -> Contexted p wY -> Contexted p wX
-- | Add an RL of patches to the context.
ctxAddRL :: (Commute p, Invert p, Ident p) => RL p wX wY -> Contexted p wY -> Contexted p wX
-- | Add an FL of patches to the context but invert it first.
ctxAddInvFL :: (Commute p, Invert p, Ident p) => FL p wX wY -> Contexted p wX -> Contexted p wY
-- | Add an FL of patches to the context.
ctxAddFL :: (Commute p, Invert p, Ident p) => FL p wX wY -> Contexted p wY -> Contexted p wX
-- | (Definition 10.2) Commute a patch past a Contexted 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
-- Contexted patch.
commutePast :: Commute p => p wX wY -> Contexted p wY -> Maybe (Contexted p wX)
-- | Not defined in the paper but used in the commute algorithm.
commutePastRL :: Commute p => RL p wX wY -> Contexted p wY -> Maybe (Contexted p wX)
ctxTouches :: PatchInspect p => Contexted p wX -> [AnchoredPath]
ctxHunkMatches :: PatchInspect p => (ByteString -> Bool) -> Contexted p wX -> Bool
showCtx :: (ShowPatchBasic p, PatchListFormat p) => ShowPatchFor -> Contexted p wX -> Doc
readCtx :: (ReadPatch p, PatchListFormat p) => Parser (Contexted p wX)
-- | This property states that no prefix of the context commutes with the
-- rest of the Contexted patch and that the context never contains
-- a patch and its inverse.
prop_ctxInvariants :: (Commute p, Invert p, SignedIdent p) => Contexted p wX -> Bool
-- | This property states that equal Contexted patches have equal
-- content up to reorderings of the context patches.
prop_ctxEq :: (Commute p, Eq2 p, Ident p) => Contexted p wX -> Contexted p wX -> Bool
-- | This property states that patches in the context of a Contexted
-- patch as well as the patch itself are positive. It does not
-- necessarily hold for all Contexted patches.
prop_ctxPositive :: SignedIdent p => Contexted p wX -> Bool
instance Darcs.Patch.Ident.Ident p => GHC.Classes.Eq (Darcs.Patch.V3.Contexted.Contexted p wX)
instance Darcs.Patch.Ident.Ident p => GHC.Classes.Ord (Darcs.Patch.V3.Contexted.Contexted p wX)
instance Darcs.Patch.Witnesses.Show.Show2 p => GHC.Show.Show (Darcs.Patch.V3.Contexted.Contexted p wX)
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.V3.Contexted.Contexted p)
module Darcs.Patch.Annotate.Class
type AnnotateResult = Vector (Maybe PatchInfo, ByteString)
data Content2 f g
FileContent :: f (g ByteString) -> Content2 f g
DirContent :: f (g AnchoredPath) -> Content2 f g
data Annotated2 f g
Annotated2 :: !AnnotateResult -> !Content2 f g -> Maybe AnchoredPath -> PatchInfo -> Annotated2 f g
[annotated] :: Annotated2 f g -> !AnnotateResult
[current] :: Annotated2 f g -> !Content2 f g
[currentPath] :: Annotated2 f g -> Maybe AnchoredPath
[currentInfo] :: Annotated2 f g -> PatchInfo
type Content = Content2 [] ((,) Int)
type Annotated = Annotated2 [] ((,) Int)
type AnnotatedM = State Annotated
class Annotate p
annotate :: Annotate p => p wX wY -> AnnotatedM ()
instance GHC.Classes.Eq Darcs.Patch.Annotate.Class.Content
instance GHC.Show.Show Darcs.Patch.Annotate.Class.Content
instance GHC.Classes.Eq Darcs.Patch.Annotate.Class.Annotated
instance GHC.Show.Show Darcs.Patch.Annotate.Class.Annotated
module Darcs.Patch.Prim.Class
class PrimConstruct prim
addfile :: PrimConstruct prim => AnchoredPath -> prim wX wY
rmfile :: PrimConstruct prim => AnchoredPath -> prim wX wY
adddir :: PrimConstruct prim => AnchoredPath -> prim wX wY
rmdir :: PrimConstruct prim => AnchoredPath -> prim wX wY
move :: PrimConstruct prim => AnchoredPath -> AnchoredPath -> prim wX wY
changepref :: PrimConstruct prim => String -> String -> String -> prim wX wY
hunk :: PrimConstruct prim => AnchoredPath -> Int -> [ByteString] -> [ByteString] -> prim wX wY
tokreplace :: PrimConstruct prim => AnchoredPath -> String -> String -> String -> prim wX wY
binary :: PrimConstruct prim => AnchoredPath -> ByteString -> ByteString -> prim wX wY
primFromHunk :: PrimConstruct prim => FileHunk (ObjectIdOfPatch prim) wX wY -> prim wX wY
class (Commute prim, Eq2 prim, Invert prim) => PrimCoalesce prim
-- | Try 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
-- Nothing means that we could not shrink the input.
--
-- This method is included in the class for optimization. Instances are
-- free to use defaultTryToShrink.
tryToShrink :: PrimCoalesce prim => FL prim wX wY -> Maybe (FL prim wX wY)
-- | This is similar to tryToShrink 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 defaultSortCoalesceFL.
sortCoalesceFL :: PrimCoalesce prim => FL prim wX wY -> FL prim wX wY
-- | Coalesce adjacent patches to one with the same effect.
--
--
-- apply (primCoalesce p q) == apply p >> apply q
--
primCoalesce :: PrimCoalesce prim => prim wX wY -> prim wY wZ -> Maybe (prim wX wZ)
-- | Whether prim patch has no effect at all and thus can be eliminated as
-- far as coalescing is concerned.
isIdentity :: PrimCoalesce prim => prim wX wY -> EqCheck wX wY
-- | Provide a total order between arbitrary patches that is consistent
-- with Eq2:
--
--
-- unsafeCompare p q == IsEq <=> comparePrim p q == EQ
--
comparePrim :: PrimCoalesce prim => prim wA wB -> prim wC wD -> Ordering
class PrimDetails prim
summarizePrim :: PrimDetails prim => prim wX wY -> [SummDetail]
-- | Prim 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.
class PrimSift prim
-- | Whether a prim is a candidate for sifting
primIsSiftable :: PrimSift prim => prim wX wY -> Bool
class PrimShow prim
showPrim :: PrimShow prim => FileNameFormat -> prim wA wB -> Doc
showPrimWithContextAndApply :: (PrimShow prim, ApplyMonad (ApplyState prim) m) => FileNameFormat -> prim wA wB -> m Doc
class PrimRead prim
readPrim :: PrimRead prim => FileNameFormat -> Parser (Sealed (prim wX))
class PrimApply prim
applyPrimFL :: (PrimApply prim, ApplyMonad (ApplyState prim) m) => FL prim wX wY -> m ()
type PrimPatch prim = (Annotate prim, Apply prim, CleanMerge prim, Commute prim, Invert prim, Eq2 prim, IsHunk prim, PatchInspect prim, RepairToFL prim, Show2 prim, PrimConstruct prim, PrimCoalesce prim, PrimDetails prim, PrimApply prim, PrimSift prim, PrimMangleUnravelled prim, ReadPatch prim, ShowPatch prim, ShowContextPatch prim, PatchListFormat prim)
class PrimMangleUnravelled prim
-- | Mangle conflicting alternatives if possible.
mangleUnravelled :: PrimMangleUnravelled prim => Unravelled prim wX -> Maybe (Mangled prim wX)
-- | Result of mangling a single Unravelled.
type Mangled prim wX = Sealed (FL prim wX)
-- | A list of conflicting alternatives. They form a connected component of
-- the conflict graph i.e. one transitive conflict.
type Unravelled prim wX = [Sealed (FL prim wX)]
primCleanMerge :: (Commute prim, Invert prim) => PartialMergeFn prim prim
module Darcs.Patch.Prim.V1.Core
data Prim wX wY
[Move] :: !AnchoredPath -> !AnchoredPath -> Prim wX wY
[DP] :: !AnchoredPath -> !DirPatchType wX wY -> Prim wX wY
[FP] :: !AnchoredPath -> !FilePatchType wX wY -> Prim wX wY
[ChangePref] :: !String -> !String -> !String -> Prim wX wY
data DirPatchType wX wY
RmDir :: DirPatchType wX wY
AddDir :: DirPatchType wX wY
data FilePatchType wX wY
RmFile :: FilePatchType wX wY
AddFile :: FilePatchType wX wY
Hunk :: !Int -> [ByteString] -> [ByteString] -> FilePatchType wX wY
TokReplace :: !String -> !String -> !String -> FilePatchType wX wY
Binary :: ByteString -> ByteString -> FilePatchType wX wY
instance GHC.Classes.Ord (Darcs.Patch.Prim.V1.Core.FilePatchType wX wY)
instance GHC.Classes.Eq (Darcs.Patch.Prim.V1.Core.FilePatchType wX wY)
instance GHC.Classes.Ord (Darcs.Patch.Prim.V1.Core.DirPatchType wX wY)
instance GHC.Classes.Eq (Darcs.Patch.Prim.V1.Core.DirPatchType wX wY)
instance (Darcs.Patch.Object.ObjectIdOf (Darcs.Patch.Apply.ApplyState Darcs.Patch.Prim.V1.Core.Prim) GHC.Types.~ Darcs.Util.Path.AnchoredPath) => Darcs.Patch.Prim.Class.PrimConstruct Darcs.Patch.Prim.V1.Core.Prim
instance (Darcs.Patch.Object.ObjectIdOf (Darcs.Patch.Apply.ApplyState Darcs.Patch.Prim.V1.Core.Prim) GHC.Types.~ Darcs.Util.Path.AnchoredPath) => Darcs.Patch.FileHunk.IsHunk Darcs.Patch.Prim.V1.Core.Prim
instance Darcs.Patch.Invert.Invert Darcs.Patch.Prim.V1.Core.Prim
instance Darcs.Patch.Inspect.PatchInspect Darcs.Patch.Prim.V1.Core.Prim
instance Darcs.Patch.Debug.PatchDebug Darcs.Patch.Prim.V1.Core.Prim
instance Darcs.Patch.Witnesses.Eq.Eq2 Darcs.Patch.Prim.V1.Core.Prim
instance GHC.Classes.Eq (Darcs.Patch.Prim.V1.Core.Prim wX wY)
instance Darcs.Patch.Prim.Class.PrimSift Darcs.Patch.Prim.V1.Core.Prim
instance Darcs.Patch.Witnesses.Eq.Eq2 Darcs.Patch.Prim.V1.Core.DirPatchType
instance Darcs.Patch.Invert.Invert Darcs.Patch.Prim.V1.Core.DirPatchType
instance Darcs.Patch.Witnesses.Eq.Eq2 Darcs.Patch.Prim.V1.Core.FilePatchType
instance Darcs.Patch.Invert.Invert Darcs.Patch.Prim.V1.Core.FilePatchType
module Darcs.Patch.Prim.V1.Details
instance Darcs.Patch.Prim.Class.PrimDetails Darcs.Patch.Prim.V1.Core.Prim
module Darcs.Patch.Prim.V1.Show
showHunk :: FileNameFormat -> AnchoredPath -> Int -> [ByteString] -> [ByteString] -> Doc
instance GHC.Show.Show (Darcs.Patch.Prim.V1.Core.Prim wX wY)
instance GHC.Show.Show (Darcs.Patch.Prim.V1.Core.FilePatchType wX wY)
instance GHC.Show.Show (Darcs.Patch.Prim.V1.Core.DirPatchType wX wY)
instance Darcs.Patch.Witnesses.Show.Show2 Darcs.Patch.Prim.V1.Core.Prim
instance Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Prim.V1.Core.Prim wX)
instance (Darcs.Patch.Apply.Apply Darcs.Patch.Prim.V1.Core.Prim, Darcs.Patch.Apply.ApplyState Darcs.Patch.Prim.V1.Core.Prim GHC.Types.~ Darcs.Util.Tree.Tree, Darcs.Patch.Apply.ObjectIdOfPatch Darcs.Patch.Prim.V1.Core.Prim GHC.Types.~ Darcs.Util.Path.AnchoredPath) => Darcs.Patch.Prim.Class.PrimShow Darcs.Patch.Prim.V1.Core.Prim
module Darcs.Patch.Prim.V1.Commute
instance GHC.Base.Functor Darcs.Patch.Prim.V1.Commute.Perhaps
instance GHC.Base.Applicative Darcs.Patch.Prim.V1.Commute.Perhaps
instance GHC.Base.Monad Darcs.Patch.Prim.V1.Commute.Perhaps
instance GHC.Base.Alternative Darcs.Patch.Prim.V1.Commute.Perhaps
instance GHC.Base.MonadPlus Darcs.Patch.Prim.V1.Commute.Perhaps
instance Darcs.Patch.Commute.Commute Darcs.Patch.Prim.V1.Core.Prim
instance Darcs.Patch.Merge.CleanMerge Darcs.Patch.Prim.V1.Core.Prim
module Darcs.Patch.Prim.V1.Apply
instance Darcs.Patch.Apply.Apply Darcs.Patch.Prim.V1.Core.Prim
instance Darcs.Patch.Repair.RepairToFL Darcs.Patch.Prim.V1.Core.Prim
instance Darcs.Patch.Prim.Class.PrimApply Darcs.Patch.Prim.V1.Core.Prim
module Darcs.Patch.Prim.V1.Read
instance Darcs.Patch.Prim.Class.PrimRead Darcs.Patch.Prim.V1.Core.Prim
module Darcs.Patch.Prim.V1.Mangle
instance Darcs.Patch.Prim.Class.PrimMangleUnravelled Darcs.Patch.Prim.V1.Core.Prim
module Darcs.Patch.Prim.FileUUID.Core
data Prim wX wY
[Hunk] :: !UUID -> !Hunk wX wY -> Prim wX wY
[HunkMove] :: !HunkMove wX wY -> Prim wX wY
[Manifest] :: !UUID -> !Location -> Prim wX wY
[Demanifest] :: !UUID -> !Location -> Prim wX wY
[Identity] :: Prim wX wX
data Hunk wX wY
H :: !Int -> !FileContent -> !FileContent -> Hunk wX wY
data HunkMove wX wY
HM :: !UUID -> !Int -> !UUID -> !Int -> !FileContent -> HunkMove wX wY
data Object (m :: * -> *)
Directory :: DirContent -> Object (m :: * -> *)
Blob :: m FileContent -> !Maybe Hash -> Object (m :: * -> *)
newtype UUID
UUID :: ByteString -> UUID
-- | An object is located by giving the UUID of the parent
-- Directory and a Name.
data Location
L :: !UUID -> !Name -> Location
data Name
type FileContent = ByteString
instance GHC.Show.Show (Darcs.Patch.Prim.FileUUID.Core.Hunk wX wY)
instance GHC.Classes.Eq (Darcs.Patch.Prim.FileUUID.Core.Hunk wX wY)
instance GHC.Show.Show (Darcs.Patch.Prim.FileUUID.Core.HunkMove wX wY)
instance GHC.Classes.Eq (Darcs.Patch.Prim.FileUUID.Core.HunkMove wX wY)
instance GHC.Classes.Eq (Darcs.Patch.Prim.FileUUID.Core.Prim wX wY)
instance GHC.Show.Show (Darcs.Patch.Prim.FileUUID.Core.Prim wX wY)
instance Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Prim.FileUUID.Core.Prim wX)
instance Darcs.Patch.Witnesses.Show.Show2 Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Prim.Class.PrimConstruct Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.FileHunk.IsHunk Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Invert.Invert Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Inspect.PatchInspect Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Witnesses.Eq.Eq2 Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Witnesses.Eq.Eq2 Darcs.Patch.Prim.FileUUID.Core.HunkMove
instance Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Prim.FileUUID.Core.Hunk wX)
instance Darcs.Patch.Witnesses.Show.Show2 Darcs.Patch.Prim.FileUUID.Core.Hunk
instance Darcs.Patch.Witnesses.Eq.Eq2 Darcs.Patch.Prim.FileUUID.Core.Hunk
module Darcs.Patch.Prim.FileUUID.Read
instance Darcs.Patch.Prim.Class.PrimRead Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Read.ReadPatch Darcs.Patch.Prim.FileUUID.Core.Prim
module Darcs.Patch.Prim.FileUUID.Details
instance Darcs.Patch.Prim.Class.PrimDetails Darcs.Patch.Prim.FileUUID.Core.Prim
module Darcs.Patch.Prim.FileUUID.Commute
instance Darcs.Patch.Commute.Commute Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Merge.CleanMerge Darcs.Patch.Prim.FileUUID.Core.Prim
module Darcs.Patch.Prim.FileUUID.Coalesce
instance Darcs.Patch.Prim.Class.PrimCoalesce Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Prim.Class.PrimSift Darcs.Patch.Prim.FileUUID.Core.Prim
-- | Generic coalesce functions
--
-- Some of the algorithms in this module do complex recursive operations
-- on sequences of patches in order to simplify them. These algorithms
-- require that we know whether some intermediate step has made any
-- progress. If not, we want to terminate or try something different.
--
-- We capture this as an effect by tagging intermediate data with the
-- Any monoid, a newtype wrapper for Bool with disjunction
-- as mappend. The standard instance Monoid a =>
-- Monad (a,)' defined in the base package then gives use the
-- desired semantics. That is, when we sequence operations using
-- >>=, the result tells us whether Any of the two
-- operations have made progress.
module Darcs.Patch.Prim.Coalesce
-- | Either primCoalesce or cancel inverses.
--
--
-- primCoalesce (p :> q) == Just r => apply r = apply p >> apply q
--
coalesce :: PrimCoalesce prim => (prim :> prim) wX wY -> Maybe (Maybe2 prim wX wY)
defaultTryToShrink :: PrimCoalesce prim => FL prim wX wY -> Maybe (FL prim wX wY)
defaultSortCoalesceFL :: PrimCoalesce prim => FL prim wX wY -> FL prim wX wY
-- | Conversion between (Any, a) and Maybe
-- a.
withAnyToMaybe :: (Any, a) -> Maybe a
-- | The heart of sortCoalesceFL.
sortCoalesceFL2 :: PrimCoalesce prim => FL prim wX wY -> (Any, FL prim wX wY)
module Darcs.Patch.Prim.V1.Coalesce
instance Darcs.Patch.Prim.Class.PrimCoalesce Darcs.Patch.Prim.V1.Core.Prim
module Darcs.Patch.Prim.V1
data Prim wX wY
module Darcs.Patch.Prim.Canonize
-- | Put 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
--
canonizeFL :: (IsHunk prim, PrimCoalesce prim, PrimConstruct prim) => DiffAlgorithm -> FL prim wX wY -> FL prim wX wY
module Darcs.Patch.Prim
class PrimApply prim
applyPrimFL :: (PrimApply prim, ApplyMonad (ApplyState prim) m) => FL prim wX wY -> m ()
class (Commute prim, Eq2 prim, Invert prim) => PrimCoalesce prim
-- | Try 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
-- Nothing means that we could not shrink the input.
--
-- This method is included in the class for optimization. Instances are
-- free to use defaultTryToShrink.
tryToShrink :: PrimCoalesce prim => FL prim wX wY -> Maybe (FL prim wX wY)
-- | This is similar to tryToShrink 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 defaultSortCoalesceFL.
sortCoalesceFL :: PrimCoalesce prim => FL prim wX wY -> FL prim wX wY
-- | Coalesce adjacent patches to one with the same effect.
--
--
-- apply (primCoalesce p q) == apply p >> apply q
--
primCoalesce :: PrimCoalesce prim => prim wX wY -> prim wY wZ -> Maybe (prim wX wZ)
-- | Whether prim patch has no effect at all and thus can be eliminated as
-- far as coalescing is concerned.
isIdentity :: PrimCoalesce prim => prim wX wY -> EqCheck wX wY
-- | Provide a total order between arbitrary patches that is consistent
-- with Eq2:
--
--
-- unsafeCompare p q == IsEq <=> comparePrim p q == EQ
--
comparePrim :: PrimCoalesce prim => prim wA wB -> prim wC wD -> Ordering
class PrimConstruct prim
addfile :: PrimConstruct prim => AnchoredPath -> prim wX wY
rmfile :: PrimConstruct prim => AnchoredPath -> prim wX wY
adddir :: PrimConstruct prim => AnchoredPath -> prim wX wY
rmdir :: PrimConstruct prim => AnchoredPath -> prim wX wY
move :: PrimConstruct prim => AnchoredPath -> AnchoredPath -> prim wX wY
changepref :: PrimConstruct prim => String -> String -> String -> prim wX wY
hunk :: PrimConstruct prim => AnchoredPath -> Int -> [ByteString] -> [ByteString] -> prim wX wY
tokreplace :: PrimConstruct prim => AnchoredPath -> String -> String -> String -> prim wX wY
binary :: PrimConstruct prim => AnchoredPath -> ByteString -> ByteString -> prim wX wY
primFromHunk :: PrimConstruct prim => FileHunk (ObjectIdOfPatch prim) wX wY -> prim wX wY
class PrimDetails prim
summarizePrim :: PrimDetails prim => prim wX wY -> [SummDetail]
class PrimMangleUnravelled prim
-- | Mangle conflicting alternatives if possible.
mangleUnravelled :: PrimMangleUnravelled prim => Unravelled prim wX -> Maybe (Mangled prim wX)
type PrimPatch prim = (Annotate prim, Apply prim, CleanMerge prim, Commute prim, Invert prim, Eq2 prim, IsHunk prim, PatchInspect prim, RepairToFL prim, Show2 prim, PrimConstruct prim, PrimCoalesce prim, PrimDetails prim, PrimApply prim, PrimSift prim, PrimMangleUnravelled prim, ReadPatch prim, ShowPatch prim, ShowContextPatch prim, PatchListFormat prim)
class PrimRead prim
readPrim :: PrimRead prim => FileNameFormat -> Parser (Sealed (prim wX))
class PrimShow prim
showPrim :: PrimShow prim => FileNameFormat -> prim wA wB -> Doc
showPrimWithContextAndApply :: (PrimShow prim, ApplyMonad (ApplyState prim) m) => FileNameFormat -> prim wA wB -> m Doc
-- | Prim 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.
class PrimSift prim
-- | Whether a prim is a candidate for sifting
primIsSiftable :: PrimSift prim => prim wX wY -> Bool
-- | Result of mangling a single Unravelled.
type Mangled prim wX = Sealed (FL prim wX)
-- | A list of conflicting alternatives. They form a connected component of
-- the conflict graph i.e. one transitive conflict.
type Unravelled prim wX = [Sealed (FL prim wX)]
-- | Put 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
--
canonizeFL :: (IsHunk prim, PrimCoalesce prim, PrimConstruct prim) => DiffAlgorithm -> FL prim wX wY -> FL prim wX wY
-- | Either primCoalesce or cancel inverses.
--
--
-- primCoalesce (p :> q) == Just r => apply r = apply p >> apply q
--
coalesce :: PrimCoalesce prim => (prim :> prim) wX wY -> Maybe (Maybe2 prim wX wY)
module Darcs.Patch.Split
-- | A splitter is something that can take a patch and (possibly) render it
-- as text in some format of its own choosing. This text can then be
-- presented to the user for editing, and the result given to the
-- splitter for parsing. If the parse succeeds, the result is a list of
-- patches that could replace the original patch in any context.
-- Typically this list will contain the changed version of the patch,
-- along with fixup pieces to ensure that the overall effect of the list
-- is the same as the original patch. The individual elements of the list
-- can then be offered separately to the user, allowing them to accept
-- some and reject others.
--
-- There's no immediate application for a splitter for anything other
-- than Prim (you shouldn't go editing named patches, you'll break them!)
-- However you might want to compose splitters for FilePatchType to make
-- splitters for Prim etc, and the generality doesn't cost anything.
data Splitter p
Splitter :: (forall wX wY. p wX wY -> Maybe (ByteString, ByteString -> Maybe (FL p wX wY))) -> (forall wX wY. FL p wX wY -> FL p wX wY) -> Splitter p
[applySplitter] :: Splitter p -> forall wX wY. p wX wY -> Maybe (ByteString, ByteString -> Maybe (FL p wX wY))
[canonizeSplit] :: Splitter p -> forall wX wY. FL p wX wY -> FL p wX wY
-- | This generic splitter just lets the user edit the printed
-- representation of the patch. Should not be used expect for testing and
-- experimentation.
rawSplitter :: (ShowPatch p, ReadPatch p, Invert p) => Splitter p
-- | Never splits. In other code we normally pass around Maybe Splitter
-- instead of using this as the default, because it saves clients that
-- don't care about splitting from having to import this module just to
-- get noSplitter.
noSplitter :: Splitter p
-- | Split a primitive hunk patch up by allowing the user to edit both the
-- before and after lines, then insert fixup patches to clean up the
-- mess.
primSplitter :: PrimPatch p => DiffAlgorithm -> Splitter p
reversePrimSplitter :: PrimPatch prim => DiffAlgorithm -> Splitter prim
module Darcs.Patch.FromPrim
class PrimPatch (PrimOf p) => PrimPatchBase p where {
type PrimOf (p :: (* -> * -> *)) :: (* -> * -> *);
}
class FromPrim p
fromAnonymousPrim :: FromPrim p => PrimOf p wX wY -> p wX wY
fromPrim :: FromPrim p => PatchId p -> PrimOf p wX wY -> p wX wY
fromPrims :: FromPrim p => PatchInfo -> FL (PrimOf p) wX wY -> FL p wX wY
fromPrim :: (FromPrim p, PatchId p ~ ()) => PatchId p -> PrimOf p wX wY -> p wX wY
fromPrims :: (FromPrim p, PatchId p ~ ()) => PatchInfo -> FL (PrimOf p) wX wY -> FL p wX wY
class ToPrim p
toPrim :: ToPrim p => p wX wY -> Maybe (PrimOf p wX wY)
type ToFromPrim p = (FromPrim p, ToPrim p)
instance Darcs.Patch.FromPrim.PrimPatchBase p => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.FromPrim.PrimPatchBase p => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.Witnesses.Ordered.RL p)
module Darcs.Patch.V1.Core
-- | The format of a merger is Merger undos unwindings conflicting
-- original.
--
-- undos = the effect of the merger
--
-- unwindings = TODO: eh?
--
-- conflicting = the patch we conflict with
--
-- original = the patch we really are
data RepoPatchV1 prim wX wY
[PP] :: prim wX wY -> RepoPatchV1 prim wX wY
[Merger] :: FL (RepoPatchV1 prim) wX wY -> RL (RepoPatchV1 prim) wX wB -> RepoPatchV1 prim wC wX -> RepoPatchV1 prim wC wD -> RepoPatchV1 prim wX wY
[Regrem] :: FL (RepoPatchV1 prim) wX wY -> RL (RepoPatchV1 prim) wX wB -> RepoPatchV1 prim wC wX -> RepoPatchV1 prim wC wD -> RepoPatchV1 prim wY wX
isMerger :: RepoPatchV1 prim wA wB -> Bool
mergerUndo :: RepoPatchV1 prim wX wY -> FL (RepoPatchV1 prim) wX wY
instance Darcs.Patch.Witnesses.Show.Show2 prim => GHC.Show.Show (Darcs.Patch.V1.Core.RepoPatchV1 prim wX wY)
instance Darcs.Patch.Witnesses.Show.Show2 prim => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.V1.Core.RepoPatchV1 prim wX)
instance Darcs.Patch.Witnesses.Show.Show2 prim => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.FromPrim.FromPrim (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.FromPrim.ToPrim (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Format.PatchListFormat (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Repair.Check (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Debug.PatchDebug prim => Darcs.Patch.Debug.PatchDebug (Darcs.Patch.V1.Core.RepoPatchV1 prim)
module Darcs.Patch.V1.Show
showPatch_ :: ShowPatchBasic prim => prim wX wY -> Doc
instance Darcs.Patch.Show.ShowPatchBasic prim => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.V1.Core.RepoPatchV1 prim)
module Darcs.Patch.Unwind
class Unwind p
-- | Get hold of the underlying primitives for a given patch, placed in the
-- context of the patch. If there are conflicts then context patches will
-- be needed.
fullUnwind :: Unwind p => p wX wY -> Unwound (PrimOf p) wX wY
-- | An Unwound 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.
data Unwound prim wX wY
[Unwound] :: FL prim wA wB -> FL prim wB wC -> RL prim wC wD -> Unwound prim wA wD
mkUnwound :: (Commute prim, Invert prim, Eq2 prim) => FL prim wA wB -> FL prim wB wC -> FL prim wC wD -> Unwound prim wA wD
-- | Given 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 Named.
squashUnwound :: (Show2 prim, Commute prim, Eq2 prim, Invert prim) => FL (Unwound prim) wX wY -> Unwound prim wX wY
instance Darcs.Patch.Witnesses.Show.Show2 prim => GHC.Show.Show (Darcs.Patch.Unwind.Unwound prim wX wY)
instance Darcs.Patch.Witnesses.Show.Show2 prim => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Unwind.Unwound prim wX)
instance Darcs.Patch.Witnesses.Show.Show2 prim => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.Unwind.Unwound prim)
instance (Darcs.Patch.Format.PatchListFormat prim, Darcs.Patch.Show.ShowPatchBasic prim) => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.Unwind.Unwound prim)
instance Darcs.Patch.Invert.Invert prim => Darcs.Patch.Invert.Invert (Darcs.Patch.Unwind.Unwound prim)
module Darcs.Patch.Summary
plainSummary :: (Summary e, PrimDetails (PrimOf e)) => e wX wY -> Doc
plainSummaryFL :: (Summary e, PrimDetails (PrimOf e)) => FL e wX wY -> Doc
plainSummaryPrim :: PrimDetails prim => prim wX wY -> Doc
plainSummaryPrims :: PrimDetails prim => Bool -> FL prim wX wY -> Doc
xmlSummary :: (Summary p, PrimDetails (PrimOf p)) => p wX wY -> Doc
class Summary p
conflictedEffect :: Summary p => p wX wY -> [IsConflictedPrim (PrimOf p)]
data ConflictState
Okay :: ConflictState
Conflicted :: ConflictState
Duplicated :: ConflictState
-- | This type tags a patch with a ConflictState and also hides the
-- context witnesses (as in Sealed2), so we can put them in a
-- list.
data IsConflictedPrim prim
[IsC] :: !ConflictState -> !prim wX wY -> IsConflictedPrim prim
listConflictedFiles :: (Summary p, PatchInspect (PrimOf p)) => p wX wY -> [AnchoredPath]
instance GHC.Read.Read Darcs.Patch.Summary.ConflictState
instance GHC.Show.Show Darcs.Patch.Summary.ConflictState
instance GHC.Classes.Ord Darcs.Patch.Summary.ConflictState
instance GHC.Classes.Eq Darcs.Patch.Summary.ConflictState
instance GHC.Classes.Eq Darcs.Patch.Summary.SummChunk
instance GHC.Classes.Ord Darcs.Patch.Summary.SummChunk
instance Darcs.Patch.Summary.Summary p => Darcs.Patch.Summary.Summary (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Witnesses.Show.Show2 prim => GHC.Show.Show (Darcs.Patch.Summary.IsConflictedPrim prim)
module Darcs.Patch.Prim.FileUUID.Show
displayHunk :: Maybe UUID -> Hunk wX wY -> Doc
instance Darcs.Patch.Format.PatchListFormat Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Show.ShowPatchBasic Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Apply.Apply Darcs.Patch.Prim.FileUUID.Core.Prim => Darcs.Patch.Show.ShowContextPatch Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Show.ShowPatch Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Prim.Class.PrimShow Darcs.Patch.Prim.FileUUID.Core.Prim
module Darcs.Patch.Prim.FileUUID.Apply
hunkEdit :: Hunk wX wY -> FileContent -> Either String FileContent
data ObjectMap (m :: * -> *)
ObjectMap :: (UUID -> m (Maybe (Object m))) -> (UUID -> Object m -> m (ObjectMap m)) -> m [UUID] -> ObjectMap (m :: * -> *)
[getObject] :: ObjectMap (m :: * -> *) -> UUID -> m (Maybe (Object m))
[putObject] :: ObjectMap (m :: * -> *) -> UUID -> Object m -> m (ObjectMap m)
[listObjects] :: ObjectMap (m :: * -> *) -> m [UUID]
instance Darcs.Patch.Apply.Apply Darcs.Patch.Prim.FileUUID.Core.Prim
instance Control.Monad.Catch.MonadThrow m => Darcs.Patch.Prim.FileUUID.Apply.ApplyMonadObjectMap (Control.Monad.Trans.State.Lazy.StateT (Darcs.Patch.Prim.FileUUID.ObjectMap.ObjectMap m) m)
instance Darcs.Patch.Repair.RepairToFL Darcs.Patch.Prim.FileUUID.Core.Prim
instance Darcs.Patch.Prim.Class.PrimApply Darcs.Patch.Prim.FileUUID.Core.Prim
instance Control.Monad.Catch.MonadThrow m => Darcs.Patch.ApplyMonad.ApplyMonad Darcs.Patch.Prim.FileUUID.ObjectMap.ObjectMap (Control.Monad.Trans.State.Lazy.StateT (Darcs.Patch.Prim.FileUUID.ObjectMap.ObjectMap m) m)
instance Control.Monad.Catch.MonadThrow m => Darcs.Patch.ApplyMonad.ApplyMonadTrans Darcs.Patch.Prim.FileUUID.ObjectMap.ObjectMap m
module Darcs.Patch.Prim.FileUUID
data Prim wX wY
instance Darcs.Patch.Prim.Class.PrimMangleUnravelled Darcs.Patch.Prim.FileUUID.Core.Prim
module Darcs.Patch.Effect
-- | Patches whose concrete effect can be expressed as a list of primitive
-- patches.
--
-- A minimal definition would be either of effect or
-- effectRL.
class Effect p
effect :: Effect p => p wX wY -> FL (PrimOf p) wX wY
instance Darcs.Patch.Effect.Effect p => Darcs.Patch.Effect.Effect (Darcs.Patch.Witnesses.Ordered.FL p)
instance Darcs.Patch.Effect.Effect p => Darcs.Patch.Effect.Effect (Darcs.Patch.Witnesses.Ordered.RL p)
module Darcs.Patch.V2.Non
-- | A Non stores a context with a Prim patch. It is a
-- patch whose effect isn't visible - a Non-affecting patch.
data Non p wX
[Non] :: FL p wX wY -> PrimOf p wY wZ -> Non p wX
-- | Nonable represents the class of patches that can be turned into a Non.
class Nonable p
non :: Nonable p => p wX wY -> Non p wX
-- | unNon converts a Non into a FL of its context followed by the
-- primitive patch.
unNon :: FromPrim p => Non p wX -> Sealed (FL p wX)
-- | showNon creates a Doc representing a Non.
showNon :: (ShowPatchBasic p, PatchListFormat p, PrimPatchBase p) => ShowPatchFor -> Non p wX -> Doc
-- | showNons creates a Doc representing a list of Nons.
showNons :: (ShowPatchBasic p, PatchListFormat p, PrimPatchBase p) => ShowPatchFor -> [Non p wX] -> Doc
-- | readNon is a parser that attempts to read a single Non.
readNon :: (ReadPatch p, PatchListFormat p, PrimPatchBase p) => Parser (Non p wX)
-- | readNons is a parser that attempts to read a list of Nons.
readNons :: (ReadPatch p, PatchListFormat p, PrimPatchBase p) => Parser [Non p wX]
-- | commutePrimsOrAddToCtx takes a WL of prims and attempts to commute
-- them past a Non.
commutePrimsOrAddToCtx :: (WL l, Apply p, Commute p, Invert p, ToFromPrim p) => l (PrimOf p) wX wY -> Non p wY -> Non p wX
-- | commuteOrAddToCtx 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.
commuteOrAddToCtx :: (Commute p, ToFromPrim p) => p wX wY -> Non p wY -> Non p wX
-- | commuteOrRemFromCtx 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?
commuteOrRemFromCtx :: (Commute p, Invert p, Eq2 p, ToFromPrim p) => p wX wY -> Non p wX -> Maybe (Non p wY)
-- | commuteOrAddToCtxRL 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'']
commuteOrAddToCtxRL :: (Apply p, Commute p, Invert p, ToFromPrim p) => RL p wX wY -> Non p wY -> Non p wX
-- | commuteOrRemFromCtxFL attempts to remove a FL of patches from a Non,
-- returning Nothing if any of the individual removes fail.
commuteOrRemFromCtxFL :: (Apply p, Commute p, Invert p, Eq2 p, ToFromPrim p) => FL p wX wY -> Non p wX -> Maybe (Non p wY)
remNons :: (Nonable p, Effect p, Apply p, Commute p, Invert p, Eq2 p, ToFromPrim p, PrimPatchBase p) => [Non p wX] -> Non p wX -> Non p wX
-- | (*>) attemts to modify a Non by commuting it past a given patch.
(*>) :: (Commute p, Invert p, ToFromPrim p) => Non p wX -> p wX wY -> Maybe (Non p wY)
-- | (>*) attempts to modify a Non, by commuting a given patch past it.
(>*) :: (Commute p, ToFromPrim p) => p wX wY -> Non p wY -> Maybe (Non p wX)
-- | (*>>) attempts to modify a Non by commuting it past a given WL
-- of patches.
(*>>) :: (WL l, Apply p, Commute p, Invert p, ToFromPrim p, PrimPatchBase p) => Non p wX -> l (PrimOf p) wX wY -> Maybe (Non p wY)
-- | (>>*) attempts to modify a Non by commuting a given WL of
-- patches past it.
(>>*) :: (WL l, Apply p, Commute p, Invert p, ToFromPrim p) => l (PrimOf p) wX wY -> Non p wY -> Maybe (Non p wX)
instance Darcs.Patch.V2.Non.WL Darcs.Patch.Witnesses.Ordered.FL
instance Darcs.Patch.V2.Non.WL Darcs.Patch.Witnesses.Ordered.RL
instance (Darcs.Patch.Witnesses.Show.Show2 p, Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.FromPrim.PrimOf p)) => GHC.Show.Show (Darcs.Patch.V2.Non.Non p wX)
instance (Darcs.Patch.Witnesses.Show.Show2 p, Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.FromPrim.PrimOf p)) => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.V2.Non.Non p)
instance (Darcs.Patch.Commute.Commute p, Darcs.Patch.Witnesses.Eq.Eq2 p, Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.FromPrim.PrimOf p)) => GHC.Classes.Eq (Darcs.Patch.V2.Non.Non p wX)
module Darcs.Patch.Conflict
class Conflict p
isConflicted :: Conflict p => p wX wY -> Bool
-- | The first parameter is a context containing all patches preceding the
-- ones for which we want to calculate the conflict resolution, which is
-- the second parameter. Each element of the result list represents the
-- resolution of one maximal set of transitively conflicting
-- alternatives, in other words, a connected subset of the conflict
-- graph. But the elements themselves must not conflict with each other,
-- guaranteeing that they can be cleanly merged into a single FL
-- of prims.
resolveConflicts :: Conflict p => RL p wO wX -> RL p wX wY -> [ConflictDetails (PrimOf p) wY]
data ConflictDetails prim wX
ConflictDetails :: Maybe (Mangled prim wX) -> Unravelled prim wX -> ConflictDetails prim wX
[conflictMangled] :: ConflictDetails prim wX -> Maybe (Mangled prim wX)
[conflictParts] :: ConflictDetails prim wX -> Unravelled prim wX
-- | Result of mangling a single Unravelled.
type Mangled prim wX = Sealed (FL prim wX)
-- | A list of conflicting alternatives. They form a connected component of
-- the conflict graph i.e. one transitive conflict.
type Unravelled prim wX = [Sealed (FL prim wX)]
-- | For one conflict (a connected set of conflicting prims), store the
-- conflicting parts and, if possible, their mangled version.
mangleOrFail :: PrimMangleUnravelled prim => Unravelled prim wX -> ConflictDetails prim wX
-- | By definition, a conflicting patch is resolved if another patch (that
-- is not itself conflicted) depends on the conflict. If the
-- representation of conflicts is self-contained as it is for V1 and V2,
-- then we can calculate the maximal set of conflicting alternatives for
-- a conflict separately for each conflictor at the end of a repo. This
-- function can then be used to lift this to an RL 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.
combineConflicts :: forall p wX wY. CommuteNoConflicts p => (forall wA wB. p wA wB -> [Unravelled (PrimOf p) wB]) -> RL p wX wY -> [Unravelled (PrimOf p) wY]
-- | Find 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.
findConflicting :: forall p wX wY wZ. (Commute p, Conflict p, ShowPatch p) => RL p wX wY -> p wY wZ -> (RL p :> (p :> RL p)) wX wZ
module Darcs.Patch.V2.RepoPatch
-- | RepoPatchV2 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: ix 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 x
--
-- xx is the sequence of patches that conflict *only* with
-- x
--
-- x is the original, conflicting patch.
--
-- ix and x are stored as Non objects, which
-- include any necessary context to uniquely define the patch that is
-- referred to.
--
-- 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)
data RepoPatchV2 prim wX wY
[Duplicate] :: Non (RepoPatchV2 prim) wX -> RepoPatchV2 prim wX wX
[Etacilpud] :: Non (RepoPatchV2 prim) wX -> RepoPatchV2 prim wX wX
[Normal] :: prim wX wY -> RepoPatchV2 prim wX wY
[Conflictor] :: [Non (RepoPatchV2 prim) wX] -> FL prim wX wY -> Non (RepoPatchV2 prim) wX -> RepoPatchV2 prim wY wX
[InvConflictor] :: [Non (RepoPatchV2 prim) wX] -> FL prim wX wY -> Non (RepoPatchV2 prim) wX -> RepoPatchV2 prim wX wY
-- | This is used for unit-testing and for internal sanity checks
isConsistent :: PrimPatch prim => RepoPatchV2 prim wX wY -> Maybe Doc
-- | isForward p is True if p is either
-- an InvConflictor or Etacilpud.
isForward :: PrimPatch prim => RepoPatchV2 prim wS wY -> Maybe Doc
-- | isDuplicate p is True if p is either
-- a Duplicate or Etacilpud patch.
isDuplicate :: RepoPatchV2 prim wS wY -> Bool
-- | mergeUnravelled is used when converting from Darcs V1 patches
-- (Mergers) to Darcs V2 patches (Conflictors).
mergeUnravelled :: PrimPatch prim => [Sealed (FL prim wX)] -> Maybe (FlippedSeal (RepoPatchV2 prim) wX)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Merge.Merge (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Debug.PatchDebug prim => Darcs.Patch.Debug.PatchDebug (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Summary.Summary (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Conflict.Conflict (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Unwind.Unwind (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.CommuteNoConflicts.CommuteNoConflicts (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Repair.Check (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.FromPrim.FromPrim (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.FromPrim.ToPrim (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Invert.Invert prim => Darcs.Patch.Invert.Invert (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Commute.Commute (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Merge.CleanMerge (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Inspect.PatchInspect prim => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Apply.Apply (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Repair.RepairToFL (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Format.PatchListFormat (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Show.ShowContextPatch (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Show.ShowPatch (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Read.ReadPatch (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Witnesses.Show.Show2 prim => GHC.Show.Show (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim wX wY)
instance Darcs.Patch.Witnesses.Show.Show2 prim => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim wX)
instance Darcs.Patch.Witnesses.Show.Show2 prim => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.V2.Non.Nonable (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Effect.Effect (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
instance Darcs.Patch.FileHunk.IsHunk prim => Darcs.Patch.FileHunk.IsHunk (Darcs.Patch.V2.RepoPatch.RepoPatchV2 prim)
module Darcs.Patch.V2
-- | RepoPatchV2 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: ix 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 x
--
-- xx is the sequence of patches that conflict *only* with
-- x
--
-- x is the original, conflicting patch.
--
-- ix and x are stored as Non objects, which
-- include any necessary context to uniquely define the patch that is
-- referred to.
--
-- 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)
data RepoPatchV2 prim wX wY
module Darcs.Patch.V1.Commute
merge :: Merge p => (p :\/: p) wX wY -> (p :/\: p) wX wY
-- | merger takes two patches, (which have been determined to conflict) and
-- constructs a Merger patch to represent the conflict. p1 is
-- considered to be conflicting with p2 (p1 is the
-- "first" patch in the repo ordering), the resulting Merger is therefore
-- a representation of p2.
merger :: PrimPatch prim => String -> RepoPatchV1 prim wX wY -> RepoPatchV1 prim wX wZ -> Sealed (RepoPatchV1 prim wY)
unravel :: PrimPatch prim => RepoPatchV1 prim wX wY -> [Sealed (FL prim wX)]
publicUnravel :: PrimPatch prim => RepoPatchV1 prim wX wY -> [Sealed (FL prim wY)]
instance GHC.Base.Functor Darcs.Patch.V1.Commute.Perhaps
instance GHC.Base.Applicative Darcs.Patch.V1.Commute.Perhaps
instance GHC.Base.Monad Darcs.Patch.V1.Commute.Perhaps
instance GHC.Base.Alternative Darcs.Patch.V1.Commute.Perhaps
instance GHC.Base.MonadPlus Darcs.Patch.V1.Commute.Perhaps
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Merge.CleanMerge (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Merge.Merge (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Commute.Commute (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.CommuteNoConflicts.CommuteNoConflicts (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Conflict.Conflict (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Unwind.Unwind (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Summary.Summary (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Effect.Effect (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance (Darcs.Patch.Prim.Class.PrimPatch prim, Darcs.Patch.Apply.ApplyState prim GHC.Types.~ Darcs.Patch.Apply.ApplyState (Darcs.Patch.V1.Core.RepoPatchV1 prim)) => Darcs.Patch.FileHunk.IsHunk (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Invert.Invert prim => Darcs.Patch.Invert.Invert (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Witnesses.Eq.Eq2 prim => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Witnesses.Eq.Eq2 prim => GHC.Classes.Eq (Darcs.Patch.V1.Core.RepoPatchV1 prim wX wY)
module Darcs.Patch.V1.Read
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Read.ReadPatch (Darcs.Patch.V1.Core.RepoPatchV1 prim)
module Darcs.Patch.V1.Apply
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Apply.Apply (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Repair.RepairToFL (Darcs.Patch.V1.Core.RepoPatchV1 prim)
module Darcs.Patch.V1.Viewing
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Show.ShowContextPatch (Darcs.Patch.V1.Core.RepoPatchV1 prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Show.ShowPatch (Darcs.Patch.V1.Core.RepoPatchV1 prim)
module Darcs.Patch.V1
-- | The format of a merger is Merger undos unwindings conflicting
-- original.
--
-- undos = the effect of the merger
--
-- unwindings = TODO: eh?
--
-- conflicting = the patch we conflict with
--
-- original = the patch we really are
data RepoPatchV1 prim wX wY
-- | Named patches group a set of changes with meta data
-- (PatchInfo) and explicit dependencies (created using `darcs
-- tag` or using --ask-deps).
--
-- While the data constructor NamedP is exported for technical
-- reasons, code outside this modules should (and generally does) treat
-- it as an abstract data type. The only exception is the rebase
-- implementation i.e. the modules under Darcs.Patch.Rebase.
module Darcs.Patch.Named
-- | The Named 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).
data Named p wX wY
[NamedP] :: !PatchInfo -> ![PatchInfo] -> !FL p wX wY -> Named p wX wY
infopatch :: forall p wX wY. FromPrim p => PatchInfo -> FL (PrimOf p) wX wY -> Named p wX wY
adddeps :: Named p wX wY -> [PatchInfo] -> Named p wX wY
setinfo :: PatchInfo -> Named p wX wY -> Named p wX wY
anonymous :: FromPrim p => FL (PrimOf p) wX wY -> IO (Named p wX wY)
-- | This slightly ad-hoc class is here so we can call getdeps with
-- patch types that wrap a Named, such as RebaseChange.
class HasDeps p
getdeps :: HasDeps p => p wX wY -> [PatchInfo]
patch2patchinfo :: Named p wX wY -> PatchInfo
patchname :: Named p wX wY -> String
patchcontents :: Named p wX wY -> FL p wX wY
fmapNamed :: (forall wA wB. p wA wB -> q wA wB) -> Named p wX wY -> Named q wX wY
fmapFL_Named :: (FL p wA wB -> FL q wC wD) -> Named p wA wB -> Named q wC wD
mergerIdNamed :: MergeFn p1 p2 -> MergeFn p1 (Named p2)
data ShowDepsFormat
ShowDepsVerbose :: ShowDepsFormat
ShowDepsSummary :: ShowDepsFormat
-- | Support for rebase
data ShowWhichDeps
ShowNormalDeps :: ShowWhichDeps
ShowDroppedDeps :: ShowWhichDeps
showDependencies :: ShowWhichDeps -> ShowDepsFormat -> [PatchInfo] -> Doc
instance Darcs.Patch.Witnesses.Show.Show2 p => GHC.Show.Show (Darcs.Patch.Named.Named p wX wY)
instance GHC.Classes.Eq Darcs.Patch.Named.ShowDepsFormat
instance GHC.Classes.Eq Darcs.Patch.Named.ShowWhichDeps
instance (Darcs.Patch.Summary.Summary p, Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.FromPrim.PrimPatchBase p, Darcs.Patch.Show.ShowPatch p) => Darcs.Patch.Show.ShowPatch (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Named.HasDeps (Darcs.Patch.Named.Named p)
instance Darcs.Patch.FromPrim.PrimPatchBase p => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Effect.Effect p => Darcs.Patch.Effect.Effect (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Ident.Ident (Darcs.Patch.Named.Named p)
instance Darcs.Patch.FileHunk.IsHunk (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Format.PatchListFormat (Darcs.Patch.Named.Named p)
instance (Darcs.Patch.Read.ReadPatch p, Darcs.Patch.Format.PatchListFormat p) => Darcs.Patch.Read.ReadPatch (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Apply.Apply p => Darcs.Patch.Apply.Apply (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Repair.RepairToFL p => Darcs.Patch.Repair.Repair (Darcs.Patch.Named.Named p)
instance (Darcs.Patch.Commute.Commute p, Darcs.Patch.Witnesses.Eq.Eq2 p) => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Commute.Commute p => Darcs.Patch.Commute.Commute (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Merge.CleanMerge p => Darcs.Patch.Merge.CleanMerge (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Merge.Merge p => Darcs.Patch.Merge.Merge (Darcs.Patch.Named.Named p)
instance (Darcs.Patch.Commute.Commute p, Darcs.Patch.Conflict.Conflict p, Darcs.Patch.Summary.Summary p, Darcs.Patch.FromPrim.PrimPatchBase p, Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Show.ShowPatch p) => Darcs.Patch.Conflict.Conflict (Darcs.Patch.Named.Named p)
instance (Darcs.Patch.FromPrim.PrimPatchBase p, Darcs.Patch.Unwind.Unwind p) => Darcs.Patch.Unwind.Unwind (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Inspect.PatchInspect p => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Summary.Summary p => Darcs.Patch.Summary.Summary (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Repair.Check p => Darcs.Patch.Repair.Check (Darcs.Patch.Named.Named p)
instance (Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Show.ShowPatchBasic p) => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.Named.Named p)
instance (Darcs.Patch.Apply.Apply p, Darcs.Patch.FileHunk.IsHunk p, Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Object.ObjectId (Darcs.Patch.Apply.ObjectIdOfPatch p), Darcs.Patch.Show.ShowContextPatch p) => Darcs.Patch.Show.ShowContextPatch (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Named.Named p wX)
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.Named.Named p)
instance Darcs.Patch.Debug.PatchDebug p => Darcs.Patch.Debug.PatchDebug (Darcs.Patch.Named.Named p)
module Darcs.Patch.Rebase.Name
-- | A RebaseName 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.
data RebaseName wX wY
[AddName] :: PatchInfo -> RebaseName wX wY
[DelName] :: PatchInfo -> RebaseName wX wY
[Rename] :: PatchInfo -> PatchInfo -> RebaseName wX wY
-- | Commute a RebaseName 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),
commuteNamePrim :: (RebaseName :> prim) wX wY -> (prim :> RebaseName) wX wY
-- | Commute a primitive patch and a RebaseName. 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),
commutePrimName :: (prim :> RebaseName) wX wY -> (RebaseName :> prim) wX wY
-- | Commute an unnamed patch with a named patch. This is unsafe if the
-- second patch actually does have a name (e.g. Named, PatchInfoAnd,
-- etc), as it won't check the explicit dependencies.
commuterIdNamed :: CommuteFn p1 p2 -> CommuteFn p1 (Named p2)
-- | Commute an unnamed patch with a named patch. This is unsafe if the
-- first patch actually does have a name (e.g. Named, PatchInfoAnd, etc),
-- as it won't check the explicit dependencies.
commuterNamedId :: CommuteFn p1 p2 -> CommuteFn (Named p1) p2
-- | Commute a name patch and a named patch. In most cases this is trivial
-- but we do need to check explicit dependencies.
commuteNameNamed :: CommuteFn RebaseName (Named p)
-- | Commute a named patch and a name patch. In most cases this is trivial
-- but we do need to check explicit dependencies.
commuteNamedName :: CommuteFn (Named p) RebaseName
pushFixupName :: PushFixupFn RebaseName RebaseName (FL RebaseName) (Maybe2 RebaseName)
instance GHC.Show.Show (Darcs.Patch.Rebase.Name.RebaseName wX wY)
instance GHC.Classes.Eq (Darcs.Patch.Rebase.Name.RebaseName wX wY)
instance Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Rebase.Name.RebaseName wX)
instance Darcs.Patch.Witnesses.Show.Show2 Darcs.Patch.Rebase.Name.RebaseName
instance Darcs.Patch.Show.ShowPatchBasic Darcs.Patch.Rebase.Name.RebaseName
instance Darcs.Patch.Show.ShowPatch Darcs.Patch.Rebase.Name.RebaseName
instance Darcs.Patch.Read.ReadPatch Darcs.Patch.Rebase.Name.RebaseName
instance Darcs.Patch.Commute.Commute Darcs.Patch.Rebase.Name.RebaseName
instance Darcs.Patch.Invert.Invert Darcs.Patch.Rebase.Name.RebaseName
instance Darcs.Patch.Inspect.PatchInspect Darcs.Patch.Rebase.Name.RebaseName
instance Darcs.Patch.Witnesses.Eq.Eq2 Darcs.Patch.Rebase.Name.RebaseName
module Darcs.Patch.Rebase.Fixup
-- | A single rebase fixup, needed to ensure that the actual patches being
-- stored in the rebase state have the correct context.
data RebaseFixup prim wX wY
[PrimFixup] :: prim wX wY -> RebaseFixup prim wX wY
[NameFixup] :: RebaseName wX wY -> RebaseFixup prim wX wY
commuteNamedFixup :: Commute prim => (Named prim :> RebaseFixup prim) wX wY -> Maybe ((RebaseFixup prim :> Named prim) wX wY)
commuteFixupNamed :: Commute prim => (RebaseFixup prim :> Named prim) wX wY -> Maybe ((Named prim :> RebaseFixup prim) wX wY)
pushFixupFixup :: PrimPatch prim => DiffAlgorithm -> PushFixupFn (RebaseFixup prim) (RebaseFixup prim) (FL (RebaseFixup prim)) (Maybe2 (RebaseFixup prim))
-- | Split a sequence of fixups into names and prims
flToNamesPrims :: FL (RebaseFixup prim) wX wY -> (FL RebaseName :> FL prim) wX wY
namedToFixups :: Effect p => Named p wX wY -> FL (RebaseFixup (PrimOf p)) wX wY
instance Darcs.Patch.Witnesses.Show.Show2 prim => GHC.Show.Show (Darcs.Patch.Rebase.Fixup.RebaseFixup prim wX wY)
instance Darcs.Patch.Witnesses.Show.Show2 prim => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Rebase.Fixup.RebaseFixup prim wX)
instance Darcs.Patch.Witnesses.Show.Show2 prim => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.Rebase.Fixup.RebaseFixup prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.Rebase.Fixup.RebaseFixup prim)
instance Darcs.Patch.Apply.Apply prim => Darcs.Patch.Apply.Apply (Darcs.Patch.Rebase.Fixup.RebaseFixup prim)
instance Darcs.Patch.Invert.Invert prim => Darcs.Patch.Invert.Invert (Darcs.Patch.Rebase.Fixup.RebaseFixup prim)
instance Darcs.Patch.Inspect.PatchInspect prim => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.Rebase.Fixup.RebaseFixup prim)
instance Darcs.Patch.Format.PatchListFormat (Darcs.Patch.Rebase.Fixup.RebaseFixup prim)
instance Darcs.Patch.Show.ShowPatchBasic prim => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.Rebase.Fixup.RebaseFixup prim)
instance Darcs.Patch.Read.ReadPatch prim => Darcs.Patch.Read.ReadPatch (Darcs.Patch.Rebase.Fixup.RebaseFixup prim)
instance Darcs.Patch.Commute.Commute prim => Darcs.Patch.Commute.Commute (Darcs.Patch.Rebase.Fixup.RebaseFixup prim)
module Darcs.Patch.PatchInfoAnd
-- | Hopefully p C (x y) is Either
-- 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
-- SimpleHopefully does the real work of emulating Either.
-- Hopefully sh represents an expected unhashed patch, and
-- Hashed hash sh represents an expected hashed patch with its
-- hash.
data Hopefully a wX wY
type PatchInfoAnd p = PatchInfoAndG (Named p)
-- | PatchInfoAnd 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.
data PatchInfoAndG p wA wB
-- | piap i p creates a PatchInfoAnd containing p with info
-- i.
piap :: PatchInfo -> p wA wB -> PatchInfoAndG p wA wB
-- | n2pia creates a PatchInfoAnd representing a Named
-- patch.
n2pia :: (Ident p, PatchId p ~ PatchInfo) => p wX wY -> PatchInfoAndG p wX wY
patchInfoAndPatch :: PatchInfo -> Hopefully p wA wB -> PatchInfoAndG p wA wB
fmapPIAP :: (p wX wY -> q wX wY) -> PatchInfoAndG p wX wY -> PatchInfoAndG q wX wY
fmapFLPIAP :: (FL p wX wY -> FL q wX wY) -> PatchInfoAnd p wX wY -> PatchInfoAnd q wX wY
-- | hopefully hp tries to get a patch from a
-- PatchInfoAnd value. If it fails, it outputs an error "failed to
-- read patch: <description of the patch>". We get the description
-- of the patch from the info part of hp
hopefully :: PatchInfoAndG p wA wB -> p wA wB
info :: PatchInfoAndG p wA wB -> PatchInfo
-- | Return Just the patch content or Nothing if it is
-- unavailable.
hopefullyM :: PatchInfoAndG p wA wB -> Maybe (p wA wB)
createHashed :: PatchHash -> (PatchHash -> IO (Sealed (a wX))) -> IO (Sealed (Hopefully a wX))
extractHash :: PatchInfoAndG p wA wB -> Either (p wA wB) PatchHash
actually :: a wX wY -> Hopefully a wX wY
unavailable :: String -> Hopefully a wX wY
patchDesc :: forall p wX wY. PatchInfoAnd p wX wY -> String
instance GHC.Show.Show (a wX wY) => GHC.Show.Show (Darcs.Patch.PatchInfoAnd.SimpleHopefully a wX wY)
instance GHC.Show.Show (a wX wY) => GHC.Show.Show (Darcs.Patch.PatchInfoAnd.Hopefully a wX wY)
instance GHC.Show.Show (p wA wB) => GHC.Show.Show (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p wA wB)
instance GHC.Exception.Type.Exception Darcs.Patch.PatchInfoAnd.PatchNotAvailable
instance GHC.Show.Show Darcs.Patch.PatchInfoAnd.PatchNotAvailable
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.PatchInfoAnd.PatchInfoAnd p wX)
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.PatchInfoAnd.PatchInfoAnd p)
instance Darcs.Patch.Repair.RepairToFL p => Darcs.Patch.Repair.Repair (Darcs.Patch.PatchInfoAnd.PatchInfoAnd p)
instance (Darcs.Patch.Commute.Commute p, Darcs.Patch.Conflict.Conflict p, Darcs.Patch.Summary.Summary p, Darcs.Patch.FromPrim.PrimPatchBase p, Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Show.ShowPatch p) => Darcs.Patch.Conflict.Conflict (Darcs.Patch.PatchInfoAnd.PatchInfoAnd p)
instance Darcs.Patch.FromPrim.PrimPatchBase p => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.Witnesses.Eq.Eq2 p => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.Ident.Ident (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.Format.PatchListFormat (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.Show.ShowPatchBasic p => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.Show.ShowContextPatch p => Darcs.Patch.Show.ShowContextPatch (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance (Darcs.Patch.Summary.Summary p, Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Show.ShowPatch p) => Darcs.Patch.Show.ShowPatch (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance (Darcs.Patch.Ident.PatchId p GHC.Types.~ Darcs.Patch.Info.PatchInfo, Darcs.Patch.Commute.Commute p) => Darcs.Patch.Commute.Commute (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance (Darcs.Patch.Ident.PatchId p GHC.Types.~ Darcs.Patch.Info.PatchInfo, Darcs.Patch.Merge.CleanMerge p) => Darcs.Patch.Merge.CleanMerge (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance (Darcs.Patch.Ident.PatchId p GHC.Types.~ Darcs.Patch.Info.PatchInfo, Darcs.Patch.Merge.Merge p) => Darcs.Patch.Merge.Merge (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.Inspect.PatchInspect p => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.Apply.Apply p => Darcs.Patch.Apply.Apply (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance (Darcs.Patch.Read.ReadPatch p, Darcs.Patch.Ident.Ident p, Darcs.Patch.Ident.PatchId p GHC.Types.~ Darcs.Patch.Info.PatchInfo) => Darcs.Patch.Read.ReadPatch (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.Effect.Effect p => Darcs.Patch.Effect.Effect (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.FileHunk.IsHunk (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.Debug.PatchDebug p => Darcs.Patch.Debug.PatchDebug (Darcs.Patch.PatchInfoAnd.PatchInfoAndG p)
instance Darcs.Patch.Witnesses.Eq.Eq2 p => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.PatchInfoAnd.Hopefully p)
instance Darcs.Patch.Witnesses.Eq.Eq2 p => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.PatchInfoAnd.SimpleHopefully p)
module Darcs.Patch.Set
-- | The patches in a repository are stored in chunks broken up at "clean"
-- tags. A tag is clean if the only patches before it in the current
-- repository ordering are ones that the tag depends on (either directly
-- or indirectly). Each chunk is stored in a separate inventory file on
-- disk.
--
-- A PatchSet 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
-- PatchSet contains the whole history, the first witness is
-- always forced to be Origin. 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.
data PatchSet p wStart wY
[PatchSet] :: RL (Tagged p) Origin wX -> RL (PatchInfoAnd p) wX wY -> PatchSet p Origin wY
-- | A Tagged is a single chunk of a PatchSet. It has a
-- PatchInfo representing a clean tag, the hash of the previous
-- inventory (if it exists), and the list of patches since that previous
-- inventory.
data Tagged p wX wZ
[Tagged] :: RL (PatchInfoAnd p) wX wY -> PatchInfoAnd p wY wZ -> Maybe InventoryHash -> Tagged p wX wZ
type SealedPatchSet p wStart = Sealed ((PatchSet p) wStart)
-- | Origin is a type used to represent the initial context of a
-- repo.
data Origin
-- | Runs a progress action for each tag and patch in a given PatchSet,
-- using the passed progress message. Does not alter the PatchSet.
progressPatchSet :: String -> PatchSet p wStart wX -> PatchSet p wStart wX
patchSetInventoryHashes :: PatchSet p wX wY -> [Maybe InventoryHash]
-- | The tag names of all tags of a given PatchSet.
patchSetTags :: PatchSet p wX wY -> [String]
emptyPatchSet :: PatchSet p Origin Origin
-- | appendPSFL takes a PatchSet and a FL of patches
-- that "follow" the PatchSet, and concatenates the patches into the
-- PatchSet.
appendPSFL :: PatchSet p wStart wX -> FL (PatchInfoAnd p) wX wY -> PatchSet p wStart wY
-- | patchSet2RL takes a PatchSet and returns an equivalent,
-- linear RL of patches.
patchSet2RL :: PatchSet p wStart wX -> RL (PatchInfoAnd p) wStart wX
-- | patchSet2FL takes a PatchSet and returns an equivalent,
-- linear FL of patches.
patchSet2FL :: PatchSet p wStart wX -> FL (PatchInfoAnd p) wStart wX
inOrderTags :: PatchSet p wS wX -> [PatchInfo]
patchSetSnoc :: PatchSet p wX wY -> PatchInfoAnd p wY wZ -> PatchSet p wX wZ
-- | Split a PatchSet 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.
patchSetSplit :: PatchSet p wX wY -> (PatchSet p :> RL (PatchInfoAnd p)) wX wY
-- | Drop the last n patches from the given PatchSet.
patchSetDrop :: Int -> PatchSet p wStart wX -> SealedPatchSet p wStart
instance Darcs.Patch.Witnesses.Show.Show2 p => GHC.Show.Show (Darcs.Patch.Set.PatchSet p wStart wY)
instance Darcs.Patch.Witnesses.Show.Show2 p => GHC.Show.Show (Darcs.Patch.Set.Tagged p wX wZ)
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Set.PatchSet p wStart)
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.Set.PatchSet p)
instance Darcs.Patch.Ident.Ident (Darcs.Patch.Set.PatchSet p)
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Set.Tagged p wX)
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.Set.Tagged p)
module Darcs.Patch.Progress
-- | Evaluate an RL list and report progress.
progressRL :: String -> RL a wX wY -> RL a wX wY
-- | Evaluate an FL list and report progress.
progressFL :: String -> FL a wX wY -> FL a wX wY
-- | Evaluate an RL list and report progress. In addition to
-- printing the number of patches we got, show the name of the last tag
-- we got.
progressRLShowTags :: String -> RL (PatchInfoAnd p) wX wY -> RL (PatchInfoAnd p) wX wY
-- | Definitions used in this module:
--
--
-- - Explicit dependencies The set of patches that a (named)
-- patch depends on "by name", i.e. irrespective of (non-)commutation
-- (non commuting patches are implicit dependencies). The most important
-- example are tags, but non-tag patches can also have explicit
-- dependencies by recording them with --ask-deps.
-- - Covered A patch p is covered by a tag t
-- if t explicitly depends on p or a tag covered by
-- t explicitly depends on p. In other words, the
-- transitive closure of the relation "is depended on", restricted to
-- situations where the right hand side is a tag. Note that it does
-- not take explicit dependencies of non-tag patches into account
-- at all.
-- - Clean A tag t in a repository is clean if all
-- patches prior to the tag are covered by t. Tags normally
-- start out as clean tags (the exception is if --ask-deps is used). It
-- typically becomes unclean when it is merged into another repo (here
-- the exceptions are if --reorder-patches is used, or if the target repo
-- is actually a subset of the source repo).
--
module Darcs.Patch.Depends
-- | Return the PatchInfo for all the patches in a PatchSet
-- that are not *explicitly* depended on by any tag (in the given
-- PatchSet).
--
-- This is exactly the set of patches that a new tag recorded on top of
-- the PatchSet 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.
getUncovered :: PatchSet p wStart wX -> [PatchInfo]
-- | Two PatchSets are considered unrelated unless they share a
-- common inventory, or either PatchSet has less than 5 patches,
-- or they have at least one patch in common.
areUnrelatedRepos :: Commute p => PatchSet p Origin wX -> PatchSet p Origin wY -> Bool
-- | The symmetric difference between two PatchSets, expressed as a
-- Fork consisting of the intersection PatchSet 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 PatchSets 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.
findCommon :: Commute p => PatchSet p Origin wX -> PatchSet p Origin wY -> Fork (PatchSet p) (FL (PatchInfoAnd p)) (FL (PatchInfoAnd p)) Origin wX wY
findCommonWithThem :: Commute p => PatchSet p Origin wX -> PatchSet p Origin wY -> (PatchSet p :> FL (PatchInfoAnd p)) Origin wX
findUncommon :: Commute p => PatchSet p Origin wX -> PatchSet p Origin wY -> (FL (PatchInfoAnd p) :\/: FL (PatchInfoAnd p)) wX wY
patchSetMerge :: (Commute p, Merge p) => PatchSet p Origin wX -> PatchSet p Origin wY -> (FL (PatchInfoAnd p) :/\: FL (PatchInfoAnd p)) wX wY
countUsThem :: Commute p => PatchSet p Origin wX -> PatchSet p Origin wY -> (Int, Int)
removeFromPatchSet :: (Commute p, Eq2 p) => FL (PatchInfoAnd p) wX wY -> PatchSet p wStart wY -> Maybe (PatchSet p wStart wX)
-- | Create a new Tagged section for the most recent clean tag found
-- in the tail of un-Tagged patches without re-ordering patches.
-- Note that earlier tags may remain un-Tagged even if they are
-- actually clean.
slightlyOptimizePatchset :: PatchSet p wStart wX -> PatchSet p wStart wX
-- | Create a Tagged 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.
fullyOptimizePatchSet :: forall p wZ. Commute p => PatchSet p Origin wZ -> PatchSet p Origin wZ
-- | Take a tag's PatchInfo, and a PatchSet, and attempt to
-- find the tag in the PatchSet. If found, return a new
-- PatchSet, in which the tag is now clean (and the last of the
-- Tagged 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
-- PatchSet, we return Nothing.
splitOnTag :: Commute p => PatchInfo -> PatchSet p wStart wX -> Maybe (PatchSet p wStart wX)
-- | A PatchSet consisting of the patches contained in any of the
-- input PatchSets. The input PatchSets are merged in left
-- to right order, left patches first.
patchSetUnion :: (Commute p, Merge p) => [SealedPatchSet p Origin] -> SealedPatchSet p Origin
-- | A PatchSet consisting of the patches common to all input
-- PatchSets. This is *undefined* for the empty list since
-- intersection of PatchSets has no unit.
patchSetIntersection :: Commute p => [SealedPatchSet p Origin] -> SealedPatchSet p Origin
-- | Reorder a PatchSet such that the latest tag becomes clean.
cleanLatestTag :: Commute p => PatchSet p wStart wX -> PatchSet p wStart wX
-- | Split a PatchSet at the latest clean tag. The left part is what
-- comes before the tag, the right part is the tag and its
-- non-dependencies.
contextPatches :: PatchSet p wX wY -> (PatchSet p :> RL (PatchInfoAnd p)) wX wY
module Darcs.Patch.Annotate
annotateFile :: AnnotateRP p => RL (PatchInfoAnd p) wX wY -> AnchoredPath -> ByteString -> AnnotateResult
annotateDirectory :: AnnotateRP p => RL (PatchInfoAnd p) wX wY -> AnchoredPath -> [AnchoredPath] -> AnnotateResult
format :: ByteString -> AnnotateResult -> String
machineFormat :: ByteString -> AnnotateResult -> String
type AnnotateResult = Vector (Maybe PatchInfo, ByteString)
class Annotate p
annotate :: Annotate p => p wX wY -> AnnotatedM ()
-- | This constraint expresses what is needed for a repo patch to support
-- the high-level interface to annotation (currently annotateFile and
-- annotateDirectory)
type AnnotateRP p = (Annotate (PrimOf p), Invert (PrimOf p), Effect p)
instance GHC.Classes.Eq Darcs.Patch.Annotate.FileOrDirectory
instance GHC.Show.Show Darcs.Patch.Annotate.FileOrDirectory
instance Darcs.Patch.Annotate.Class.Annotate Darcs.Patch.Prim.V1.Core.Prim
instance Darcs.Patch.Annotate.Class.Annotate Darcs.Patch.Prim.FileUUID.Core.Prim
module Darcs.Patch.V2.Prim
newtype Prim x y
Prim :: Prim x y -> Prim x y
[unPrim] :: Prim x y -> Prim x y
instance GHC.Show.Show (Darcs.Patch.V2.Prim.Prim x y)
instance Darcs.Patch.Prim.Class.PrimSift Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Prim.Class.PrimMangleUnravelled Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Prim.Class.PrimDetails Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Prim.Class.PrimConstruct Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Prim.Class.PrimCoalesce Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Prim.Class.PrimApply Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Inspect.PatchInspect Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Witnesses.Eq.Eq2 Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.FileHunk.IsHunk Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Invert.Invert Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Commute.Commute Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Merge.CleanMerge Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Apply.Apply Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Annotate.Class.Annotate Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.V2.Prim.Prim wX)
instance Darcs.Patch.Witnesses.Show.Show2 Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Read.ReadPatch Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Show.ShowPatchBasic Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Show.ShowContextPatch Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Show.ShowPatch Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Format.PatchListFormat Darcs.Patch.V2.Prim.Prim
instance Darcs.Patch.Repair.RepairToFL Darcs.Patch.V2.Prim.Prim
module Darcs.Patch.V1.Prim
newtype Prim x y
Prim :: Prim x y -> Prim x y
[unPrim] :: Prim x y -> Prim x y
instance GHC.Show.Show (Darcs.Patch.V1.Prim.Prim x y)
instance Darcs.Patch.Prim.Class.PrimSift Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Prim.Class.PrimMangleUnravelled Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Prim.Class.PrimDetails Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Prim.Class.PrimConstruct Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Prim.Class.PrimCoalesce Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Prim.Class.PrimApply Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Inspect.PatchInspect Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Witnesses.Eq.Eq2 Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.FileHunk.IsHunk Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Invert.Invert Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Commute.Commute Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Merge.CleanMerge Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Apply.Apply Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Annotate.Class.Annotate Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.V1.Prim.Prim wX)
instance Darcs.Patch.Witnesses.Show.Show2 Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Read.ReadPatch Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Show.ShowPatchBasic Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Show.ShowContextPatch Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Show.ShowPatch Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Format.PatchListFormat Darcs.Patch.V1.Prim.Prim
instance Darcs.Patch.Repair.RepairToFL Darcs.Patch.V1.Prim.Prim
module Darcs.Patch.RepoPatch
type RepoPatch p = (AnnotateRP p, Apply p, ApplyState p ~ ApplyState (PrimOf p), Check p, Commute p, Conflict p, Effect p, Eq2 p, FromPrim p, IsHunk p, IsHunk (PrimOf p), Merge p, PatchInspect p, PatchListFormat p, PrimPatchBase p, ReadPatch p, RepairToFL p, ShowContextPatch p, ShowPatch p, Summary p, ToPrim p, Unwind p)
-- | This constraint expresses what is needed for a repo patch to support
-- the high-level interface to annotation (currently annotateFile and
-- annotateDirectory)
type AnnotateRP p = (Annotate (PrimOf p), Invert (PrimOf p), Effect p)
class Apply p where {
type ApplyState p :: (* -> *) -> *;
}
apply :: (Apply p, ApplyMonad (ApplyState p) m) => p wX wY -> m ()
unapply :: (Apply p, ApplyMonad (ApplyState p) m) => p wX wY -> m ()
unapply :: (Apply p, ApplyMonad (ApplyState p) m, Invert p) => p wX wY -> m ()
class Check p
isInconsistent :: Check p => p wX wY -> Maybe Doc
-- | Class of patches that that can be commuted.
--
-- Instances should obey the following laws:
--
--
--
-- The more general law
--
--
--
-- is valid in general only provided we know (a priori) that
-- commute (invert p:>q') succeeds, in
-- other words, that p and q are not in conflict with each other. See
-- Darcs.Patch.CommuteNoConflicts for an extended discussion.
class Commute p
commute :: Commute p => (p :> p) wX wY -> Maybe ((p :> p) wX wY)
class Conflict p
isConflicted :: Conflict p => p wX wY -> Bool
-- | The first parameter is a context containing all patches preceding the
-- ones for which we want to calculate the conflict resolution, which is
-- the second parameter. Each element of the result list represents the
-- resolution of one maximal set of transitively conflicting
-- alternatives, in other words, a connected subset of the conflict
-- graph. But the elements themselves must not conflict with each other,
-- guaranteeing that they can be cleanly merged into a single FL
-- of prims.
resolveConflicts :: Conflict p => RL p wO wX -> RL p wX wY -> [ConflictDetails (PrimOf p) wY]
-- | Patches whose concrete effect can be expressed as a list of primitive
-- patches.
--
-- A minimal definition would be either of effect or
-- effectRL.
class Effect p
effect :: Effect p => p wX wY -> FL (PrimOf p) wX wY
-- | An witness aware equality class. A minimal definition defines any one
-- of unsafeCompare, =\/= and =/\=.
class Eq2 p
-- | It 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 context
unsafeCompare :: Eq2 p => p wA wB -> p wC wD -> Bool
-- | Compare two things with the same starting witness. If the things
-- compare equal, evidence of the ending witnesses being equal will be
-- returned.
(=\/=) :: Eq2 p => p wA wB -> p wA wC -> EqCheck wB wC
-- | Compare two things with the same ending witness. If the things compare
-- equal, evidence of the starting witnesses being equal will be
-- returned.
(=/\=) :: Eq2 p => p wA wC -> p wB wC -> EqCheck wA wB
infix 4 =\/=
infix 4 =/\=
class FromPrim p
fromAnonymousPrim :: FromPrim p => PrimOf p wX wY -> p wX wY
fromPrim :: FromPrim p => PatchId p -> PrimOf p wX wY -> p wX wY
fromPrims :: FromPrim p => PatchInfo -> FL (PrimOf p) wX wY -> FL p wX wY
fromPrim :: (FromPrim p, PatchId p ~ ()) => PatchId p -> PrimOf p wX wY -> p wX wY
fromPrims :: (FromPrim p, PatchId p ~ ()) => PatchInfo -> FL (PrimOf p) wX wY -> FL p wX wY
class IsHunk p
isHunk :: IsHunk p => p wX wY -> Maybe (FileHunk (ObjectIdOfPatch p) wX wY)
-- | Patches that can always be merged, even if they conflict.
--
-- Instances should obey the following laws:
--
--
-- - symmetry
merge (p :\/: q) == q' :/\: p'
-- <=> merge (q :\/: p) == p' :/\: q'
-- - merge-commute
merge (p :\/: q) == q' :/\: p'
-- ==> commute (p :> q') == Just (q :> p')
that is, the two
-- branches of a merge commute to each other.
-- - extension
cleanMerge (p :\/: q) == Just (q'
-- :/\: p') => merge (p :\/: q) == q' :/\: p'
that is,
-- merge is an extension of cleanMerge.
--
class CleanMerge p => Merge p
merge :: Merge p => (p :\/: p) wX wY -> (p :/\: p) wX wY
class PatchInspect p
listTouchedFiles :: PatchInspect p => p wX wY -> [AnchoredPath]
hunkMatches :: PatchInspect p => (ByteString -> Bool) -> p wX wY -> Bool
-- | Showing and reading lists of patches. This class allows us to control
-- how lists of patches are formatted on disk. For legacy reasons V1
-- patches have their own special treatment (see ListFormat).
-- 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.
class PatchListFormat p
patchListFormat :: PatchListFormat p => ListFormat p
class PrimPatch (PrimOf p) => PrimPatchBase p where {
type PrimOf (p :: (* -> * -> *)) :: (* -> * -> *);
}
-- | This class is used to decode patches from their binary representation.
class ReadPatch p
readPatch' :: ReadPatch p => Parser (Sealed (p wX))
-- | RepairToFL 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.
class Apply p => RepairToFL p
applyAndTryToFixFL :: (RepairToFL p, ApplyMonad (ApplyState p) m) => p wX wY -> m (Maybe (String, FL p wX wY))
class ShowPatchBasic p => ShowContextPatch p
-- | Show 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 ApplyState.
--
-- Note that this applies the patch in the ApplyMonad 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.
--
-- For a version that does not apply the patch see
-- showPatchWithContext.
showPatchWithContextAndApply :: (ShowContextPatch p, ApplyMonad (ApplyState p) m) => ShowPatchFor -> p wX wY -> m Doc
-- | This class is used only for user interaction, not for storage. The
-- default implementations for description and content are
-- suitable only for PrimPatch and RepoPatch types.
-- Logically, description should default to mempty while
-- content should default to displayPatch. We define them
-- the other way around so that showFriendly gives reasonable
-- results for all patch types.
class ShowPatchBasic p => ShowPatch p
content :: ShowPatch p => p wX wY -> Doc
description :: ShowPatch p => p wX wY -> Doc
summary :: ShowPatch p => p wX wY -> Doc
summaryFL :: ShowPatch p => FL p wX wY -> Doc
thing :: ShowPatch p => p wX wY -> String
things :: ShowPatch p => p wX wY -> String
class ShowPatchBasic p
showPatch :: ShowPatchBasic p => ShowPatchFor -> p wX wY -> Doc
class Summary p
conflictedEffect :: Summary p => p wX wY -> [IsConflictedPrim (PrimOf p)]
class ToPrim p
toPrim :: ToPrim p => p wX wY -> Maybe (PrimOf p wX wY)
class Unwind p
-- | Get hold of the underlying primitives for a given patch, placed in the
-- context of the patch. If there are conflicts then context patches will
-- be needed.
fullUnwind :: Unwind p => p wX wY -> Unwound (PrimOf p) wX wY
-- | Formal inverses for patches that aren't really invertible. Note that
-- most the mixed {Fwd,Rev} cases for Commute and
-- Eq2 are just errors.
module Darcs.Patch.Invertible
-- | Wrapper type to allow formal inversion of patches which aren't really
-- invertible.
data Invertible p wX wY
-- | Wrap a patch to make it (formally) Invertible. The result is
-- initially positive i.e. Fwd.
mkInvertible :: p wX wY -> Invertible p wX wY
-- | Get the underlying patch from an Invertible, assuming (as a
-- precondition) that it is positive i.e. Fwd.
fromPositiveInvertible :: Invertible p wX wY -> p wX wY
-- | Run a function on the patch inside an Invertible. The function
-- has to be parametric in the witnesses, so we can run it with both a
-- Fwd and a Rev patch.
withInvertible :: (forall wA wB. p wA wB -> r) -> Invertible p wX wY -> r
instance GHC.Classes.Ord ident => GHC.Classes.Ord (Darcs.Patch.Invertible.InvertibleId ident)
instance GHC.Classes.Eq ident => GHC.Classes.Eq (Darcs.Patch.Invertible.InvertibleId ident)
instance GHC.Classes.Ord ident => Darcs.Patch.Ident.SignedId (Darcs.Patch.Invertible.InvertibleId ident)
instance Darcs.Patch.Ident.Ident p => Darcs.Patch.Ident.Ident (Darcs.Patch.Invertible.Invertible p)
instance Darcs.Patch.Invert.Invert (Darcs.Patch.Invertible.Invertible p)
instance Darcs.Patch.Commute.Commute p => Darcs.Patch.Commute.Commute (Darcs.Patch.Invertible.Invertible p)
instance Darcs.Patch.Witnesses.Eq.Eq2 p => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.Invertible.Invertible p)
instance Darcs.Patch.Apply.Apply p => Darcs.Patch.Apply.Apply (Darcs.Patch.Invertible.Invertible p)
instance Darcs.Patch.Inspect.PatchInspect p => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.Invertible.Invertible p)
instance Darcs.Patch.FromPrim.PrimPatchBase p => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.Invertible.Invertible p)
instance Darcs.Patch.Show.ShowPatchBasic p => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.Invertible.Invertible p)
instance Darcs.Patch.Show.ShowPatch p => Darcs.Patch.Show.ShowPatch (Darcs.Patch.Invertible.Invertible p)
instance Darcs.Patch.Show.ShowContextPatch p => Darcs.Patch.Show.ShowContextPatch (Darcs.Patch.Invertible.Invertible p)
instance Darcs.Patch.Format.PatchListFormat p => Darcs.Patch.Format.PatchListFormat (Darcs.Patch.Invertible.Invertible p)
module Darcs.Patch.Bundle
-- | A Bundle is a context together with some patches. The context
-- consists of unavailable patches.
data Bundle p wX wY
[Bundle] :: (FL (PatchInfoAnd p) :> FL (PatchInfoAnd p)) wX wY -> Bundle p wX wY
makeBundle :: (RepoPatch p, ApplyMonadTrans (ApplyState p) IO, ObjectId (ObjectIdOfPatch p)) => Maybe (ApplyState p IO) -> PatchSet p wStart wX -> FL (Named p) wX wY -> IO Doc
parseBundle :: RepoPatch p => ByteString -> Either String (Sealed (Bundle p wX))
-- | Interpret a Bundle in the context of a PatchSet. This
-- means we match up a possible tag in the context of the Bundle.
-- This fails if the tag couldn't be found.
interpretBundle :: Commute p => PatchSet p Origin wT -> Bundle p wA wB -> Either String (PatchSet p Origin wB)
readContextFile :: Commute p => PatchSet p Origin wX -> FilePath -> IO (SealedPatchSet p Origin)
-- | Minimize the context of an FL of patches to be packed into a
-- bundle.
minContext :: RepoPatch p => PatchSet p wStart wB -> FL (PatchInfoAnd p) wB wC -> Sealed ((PatchSet p :> FL (PatchInfoAnd p)) wStart)
module Darcs.Patch
class PrimPatch (PrimOf p) => PrimPatchBase p where {
type PrimOf (p :: (* -> * -> *)) :: (* -> * -> *);
}
-- | The Named 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).
data Named p wX wY
type ApplyState p :: (* -> *) -> *
rmfile :: PrimConstruct prim => AnchoredPath -> prim wX wY
addfile :: PrimConstruct prim => AnchoredPath -> prim wX wY
rmdir :: PrimConstruct prim => AnchoredPath -> prim wX wY
adddir :: PrimConstruct prim => AnchoredPath -> prim wX wY
move :: PrimConstruct prim => AnchoredPath -> AnchoredPath -> prim wX wY
hunk :: PrimConstruct prim => AnchoredPath -> Int -> [ByteString] -> [ByteString] -> prim wX wY
tokreplace :: PrimConstruct prim => AnchoredPath -> String -> String -> String -> prim wX wY
anonymous :: FromPrim p => FL (PrimOf p) wX wY -> IO (Named p wX wY)
binary :: PrimConstruct prim => AnchoredPath -> ByteString -> ByteString -> prim wX wY
description :: ShowPatch p => p wX wY -> Doc
-- | Like showPatchWithContextAndApply but without applying the
-- patch in the monad m.
showPatchWithContext :: (ApplyMonadTrans (ApplyState p) m, ShowContextPatch p) => ShowPatchFor -> ApplyState p m -> p wX wY -> m Doc
data ShowPatchFor
ForDisplay :: ShowPatchFor
ForStorage :: ShowPatchFor
showPatch :: ShowPatchBasic p => ShowPatchFor -> p wX wY -> Doc
displayPatch :: ShowPatchBasic p => p wX wY -> Doc
content :: ShowPatch p => p wX wY -> Doc
infopatch :: forall p wX wY. FromPrim p => PatchInfo -> FL (PrimOf p) wX wY -> Named p wX wY
changepref :: PrimConstruct prim => String -> String -> String -> prim wX wY
thing :: ShowPatch p => p wX wY -> String
things :: ShowPatch p => p wX wY -> String
merge :: Merge p => (p :\/: p) wX wY -> (p :/\: p) wX wY
commute :: Commute p => (p :> p) wX wY -> Maybe ((p :> p) wX wY)
listTouchedFiles :: PatchInspect p => p wX wY -> [AnchoredPath]
hunkMatches :: PatchInspect p => (ByteString -> Bool) -> p wX wY -> Bool
-- | forceTokReplace tokChars old new input replaces all
-- occurrences of the old token with the new one,
-- throughout the input.
forceTokReplace :: String -> ByteString -> ByteString -> ByteString -> ByteString
type PrimPatch prim = (Annotate prim, Apply prim, CleanMerge prim, Commute prim, Invert prim, Eq2 prim, IsHunk prim, PatchInspect prim, RepairToFL prim, Show2 prim, PrimConstruct prim, PrimCoalesce prim, PrimDetails prim, PrimApply prim, PrimSift prim, PrimMangleUnravelled prim, ReadPatch prim, ShowPatch prim, ShowContextPatch prim, PatchListFormat prim)
-- | The first parameter is a context containing all patches preceding the
-- ones for which we want to calculate the conflict resolution, which is
-- the second parameter. Each element of the result list represents the
-- resolution of one maximal set of transitively conflicting
-- alternatives, in other words, a connected subset of the conflict
-- graph. But the elements themselves must not conflict with each other,
-- guaranteeing that they can be cleanly merged into a single FL
-- of prims.
resolveConflicts :: Conflict p => RL p wO wX -> RL p wX wY -> [ConflictDetails (PrimOf p) wY]
-- | Patches whose concrete effect can be expressed as a list of primitive
-- patches.
--
-- A minimal definition would be either of effect or
-- effectRL.
class Effect p
effect :: Effect p => p wX wY -> FL (PrimOf p) wX wY
invert :: Invert p => p wX wY -> p wY wX
invertFL :: Invert p => FL p wX wY -> RL p wY wX
invertRL :: Invert p => RL p wX wY -> FL p wY wX
-- | commuteFL commutes a single element past a FL.
commuteFL :: Commute p => (p :> FL p) wX wY -> Maybe ((FL p :> p) wX wY)
-- | commuteRL commutes a RL past a single element.
commuteRL :: Commute p => (RL p :> p) wX wY -> Maybe ((p :> RL p) wX wY)
readPatch :: ReadPatch p => ByteString -> Either String (Sealed (p wX))
readPatchPartial :: ReadPatch p => ByteString -> Either String (Sealed (p wX), ByteString)
-- | Put 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
--
canonizeFL :: (IsHunk prim, PrimCoalesce prim, PrimConstruct prim) => DiffAlgorithm -> FL prim wX wY -> FL prim wX wY
-- | This is similar to tryToShrink 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 defaultSortCoalesceFL.
sortCoalesceFL :: PrimCoalesce prim => FL prim wX wY -> FL prim wX wY
-- | Try 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
-- Nothing means that we could not shrink the input.
--
-- This method is included in the class for optimization. Instances are
-- free to use defaultTryToShrink.
tryToShrink :: PrimCoalesce prim => FL prim wX wY -> Maybe (FL prim wX wY)
patchname :: Named p wX wY -> String
patchcontents :: Named p wX wY -> FL p wX wY
apply :: (Apply p, ApplyMonad (ApplyState p) m) => p wX wY -> m ()
-- | Apply a patch to a Tree, yielding a new Tree.
applyToTree :: (Apply p, MonadThrow m, ApplyState p ~ Tree) => p wX wY -> Tree m -> m (Tree m)
-- | Attempts to apply a given patch to a Tree. If the apply fails, we
-- return Nothing, otherwise we return the updated Tree.
maybeApplyToTree :: (Apply p, ApplyState p ~ Tree, MonadCatch m) => p wX wY -> Tree m -> m (Maybe (Tree m))
effectOnPaths :: (Apply p, ApplyState p ~ Tree) => p wX wY -> [AnchoredPath] -> [AnchoredPath]
patch2patchinfo :: Named p wX wY -> PatchInfo
summary :: ShowPatch p => p wX wY -> Doc
summaryFL :: ShowPatch p => FL p wX wY -> Doc
plainSummary :: (Summary e, PrimDetails (PrimOf e)) => e wX wY -> Doc
xmlSummary :: (Summary p, PrimDetails (PrimOf p)) => p wX wY -> Doc
plainSummaryPrims :: PrimDetails prim => Bool -> FL prim wX wY -> Doc
adddeps :: Named p wX wY -> [PatchInfo] -> Named p wX wY
getdeps :: HasDeps p => p wX wY -> [PatchInfo]
listConflictedFiles :: (Summary p, PatchInspect (PrimOf p)) => p wX wY -> [AnchoredPath]
isInconsistent :: Check p => p wX wY -> Maybe Doc
type RepoPatch p = (AnnotateRP p, Apply p, ApplyState p ~ ApplyState (PrimOf p), Check p, Commute p, Conflict p, Effect p, Eq2 p, FromPrim p, IsHunk p, IsHunk (PrimOf p), Merge p, PatchInspect p, PatchListFormat p, PrimPatchBase p, ReadPatch p, RepairToFL p, ShowContextPatch p, ShowPatch p, Summary p, ToPrim p, Unwind p)
type PatchInfoAnd p = PatchInfoAndG (Named p)
-- | hopefully hp tries to get a patch from a
-- PatchInfoAnd value. If it fails, it outputs an error "failed to
-- read patch: <description of the patch>". We get the description
-- of the patch from the info part of hp
hopefully :: PatchInfoAndG p wA wB -> p wA wB
info :: PatchInfoAndG p wA wB -> PatchInfo
module Darcs.Repository.Unrevert
finalizeTentativeUnrevert :: IO ()
revertTentativeUnrevert :: IO ()
writeUnrevert :: (RepoPatch p, ApplyState p ~ Tree) => PatchSet p Origin wR -> FL (PrimOf p) wR wX -> IO ()
readUnrevert :: RepoPatch p => PatchSet p Origin wR -> IO (SealedPatchSet p Origin)
removeFromUnrevertContext :: forall p wR wX. (RepoPatch p, ApplyState p ~ Tree) => PatchSet p Origin wR -> FL (PatchInfoAnd p) wX wR -> IO ()
module Darcs.Repository.Pending
-- | Read the contents of pending.
readPending :: RepoPatch p => Repository rt p wU wR -> IO (Sealed (FL (PrimOf p) wR))
-- | Read the contents of tentative pending.
readTentativePending :: RepoPatch p => Repository 'RW p wU wR -> IO (Sealed (FL (PrimOf p) wR))
-- | Write the contents of tentative pending.
writeTentativePending :: RepoPatch p => Repository 'RW p wU wR -> FL (PrimOf p) wR wP -> IO ()
-- | Simplify 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) U
--
--
-- Then the resulting sequence p' must maintain that equality,
-- i.e.
--
--
-- unrecorded p = unrecorded (siftForPending p)
--
--
-- while trying to "minimize" p.
siftForPending :: (PrimCoalesce prim, PrimSift prim) => FL prim wX wY -> Sealed (FL prim wX)
-- | Remove 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.
tentativelyRemoveFromPW :: forall p wR wO wP wU. RepoPatch p => Repository 'RW p wU wR -> FL (PrimOf p) wO wR -> FL (PrimOf p) wO wP -> FL (PrimOf p) wP wU -> IO ()
-- | Copy the pending patch to the tentative pending, or write a new empty
-- tentative pending if regular pending does not exist.
revertPending :: RepoPatch p => Repository 'RO p wU wR -> IO ()
-- | Replace the pending patch with the tentative pending
finalizePending :: Repository 'RW p wU wR -> IO ()
-- | Overwrites the pending patch with a new one, starting at the tentative
-- state.
setTentativePending :: forall p wU wR wP. RepoPatch p => Repository 'RW p wU wR -> FL (PrimOf p) wR wP -> IO ()
instance Darcs.Patch.Read.ReadPatch p => Darcs.Patch.Read.ReadPatch (Darcs.Repository.Pending.FLM p)
instance Darcs.Patch.Show.ShowPatchBasic p => Darcs.Patch.Show.ShowPatchBasic (Darcs.Repository.Pending.FLM p)
-- | The patch-index stores additional information that is extracted from
-- the PatchSet for the repository to speed up certain commands (namely
-- log and annotate). More precisely, for every file
-- tracked by the repository, it stores the list of patches that touch
-- it.
--
-- When created, patch-index lives in _darcs/patch_index/, and
-- it should be automatically maintained each time the set of patches of
-- the repository is updated.
--
-- Patch-index can also be explicitely disabled by creating a file
-- _darcs/no_patch_index. "Explicitely disabed" means that no
-- command should attempt to automatically create the patch-index.
--
-- See http://darcs.net/Internals/PatchIndex for more information.
module Darcs.Repository.PatchIndex
-- | Read-only. Checks if patch-index exists for this repository it works
-- by checking if:
--
--
-- - _darcs/patch_index/ and its corresponding files are all
-- present
-- - patch index version is the one handled by this version of
-- Darcs
--
doesPatchIndexExist :: FilePath -> IO Bool
-- | Read-only. Checks if _darcs/noPatchIndex exists, that is, if
-- patch-index is explicitely disabled.
isPatchIndexDisabled :: FilePath -> IO Bool
-- | Checks if patch-index exists and is in sync with repository. That is,
-- checks if patch-index can be used as it is now.
isPatchIndexInSync :: Repository rt p wU wR -> IO Bool
-- | Read-only. Checks the two following things:
--
--
-- - doesPatchIndexExist
-- - isPatchIndexDisabled
--
--
-- Then only if it exists and it is not explicitely disabled, returns
-- True, else returns False (or an error if it exists
-- and is explicitely disabled at the same time).
canUsePatchIndex :: Repository rt p wU wR -> IO Bool
-- | Creates patch-index (ignoring whether it is explicitely disabled). If
-- it is ctrl-c'ed, then aborts, delete patch-index and mark it as
-- disabled.
createPIWithInterrupt :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> PatchSet p Origin wR -> IO ()
-- | Create or update patch index
--
--
-- - if _darcs/no_patch_index exists, delete it
-- - if patch index exists, update it
-- - if not, create it from scratch
--
createOrUpdatePatchIndexDisk :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> PatchSet p Origin wR -> IO ()
-- | Deletes patch-index (_darcs/patch_index/ and its contents)
-- and mark repository as disabled (creates
-- _darcs/no_patch_index).
deletePatchIndex :: FilePath -> IO ()
-- | Checks if patch index can be created and build it with interrupt.
attemptCreatePatchIndex :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> PatchSet p Origin wR -> IO ()
type PatchFilter p = [AnchoredPath] -> [Sealed2 (PatchInfoAnd p)] -> IO [Sealed2 (PatchInfoAnd p)]
-- | If a patch index is available, returns a filter that takes a list of
-- files and returns a PatchFilter that only keeps patches that
-- modify the given list of files. If patch-index cannot be used, return
-- the original input. If patch-index does not exist and is not
-- explicitely disabled, silently create it. (Also, if it is out-of-sync,
-- which should not happen, silently update it).
maybeFilterPatches :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> PatchSet p Origin wR -> PatchFilter p
-- | Returns an RL in which the order of patches matters. Useful for the
-- annotate command. If patch-index does not exist and is not
-- explicitely disabled, silently create it. (Also, if it is out-of-sync,
-- which should not happen, silently update it).
getRelevantSubsequence :: (RepoPatch p, ApplyState p ~ Tree, a ~ PatchInfoAnd p) => Sealed (RL a wK) -> Repository rt p wU wR -> PatchSet p Origin wR -> [AnchoredPath] -> IO (Sealed (RL a Origin))
-- | Dump information in patch index. Patch-index should be checked to
-- exist beforehand. Read-only.
dumpPatchIndex :: FilePath -> IO ()
-- | Read-only sanity check on patch-index. Patch-index should be checked
-- to exist beforehand. It may not be in sync with repository.
piTest :: FilePath -> IO ()
instance GHC.Classes.Ord Darcs.Repository.PatchIndex.FileIdSpan
instance GHC.Classes.Eq Darcs.Repository.PatchIndex.FileIdSpan
instance GHC.Show.Show Darcs.Repository.PatchIndex.FileIdSpan
instance GHC.Classes.Ord Darcs.Repository.PatchIndex.FilePathSpan
instance GHC.Classes.Eq Darcs.Repository.PatchIndex.FilePathSpan
instance GHC.Show.Show Darcs.Repository.PatchIndex.FilePathSpan
instance GHC.Classes.Ord Darcs.Repository.PatchIndex.FileInfo
instance GHC.Classes.Eq Darcs.Repository.PatchIndex.FileInfo
instance GHC.Show.Show Darcs.Repository.PatchIndex.FileInfo
module Darcs.Repository.Old
readOldRepo :: RepoPatch p => String -> IO (SealedPatchSet p Origin)
oldRepoFailMsg :: String
module Darcs.Repository.Inventory
-- | Read a PatchSet starting with a specific inventory inside a
-- Repository.
readPatchesFromInventoryFile :: (PatchListFormat p, ReadPatch p) => FilePath -> Repository rt p wU wR -> IO (PatchSet p Origin wS)
-- | Read a complete PatchSet from a Cache, by following the
-- chain of Inventorys, starting with the given one.
readPatchesFromInventory :: (PatchListFormat p, ReadPatch p) => Cache -> Inventory -> IO (SealedPatchSet p Origin)
-- | Read a single patch from a Cache, given its PatchInfo
-- and PatchHash. Fails with an error message if the patch file
-- cannot be parsed.
readSinglePatch :: ReadPatch p => Cache -> PatchInfo -> PatchHash -> IO (Sealed (p wX))
readOneInventory :: ReadPatch p => Cache -> FilePath -> IO (Sealed (RL (PatchInfoAndG p) wX))
writeInventory :: RepoPatch p => String -> Cache -> PatchSet p Origin wX -> IO InventoryHash
-- | Write a PatchInfoAnd to disk and return an
-- InventoryEntry 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.
writePatchIfNecessary :: RepoPatch p => Cache -> PatchInfoAnd p wX wY -> IO InventoryEntry
-- | Wrapper around writeFileUsingCache that takes a Doc
-- instead of a ByteString.
writeHashFile :: ValidHash h => Cache -> Doc -> IO h
module Darcs.Repository.Traverse
cleanRepository :: Repository 'RW p wU wR -> IO ()
cleanPristineDir :: Cache -> [PristineHash] -> IO ()
-- | Return a list of the inventories hashes. This function attempts to
-- retrieve missing inventory files from the cache.
listInventories :: IO [String]
-- | Return 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.
listInventoriesRepoDir :: String -> IO [String]
-- | listPatchesLocalBucketed is similar to listPatchesLocal, but it read
-- the inventory directory under darcsDir in bucketed format.
listPatchesLocalBucketed :: String -> String -> IO [String]
-- | List of special patch files that may exist in the directory
-- _darcspatches. We must not clean those.
specialPatches :: [FilePath]
module Darcs.Repository.Pristine
-- | Apply an FL of Invertible patches tentative pristine
-- tree, and update the tentative pristine hash. The patches need to be
-- Invertible so that we can use it when removing patches from the
-- repository, too.
applyToTentativePristine :: (ApplyState p ~ Tree, RepoPatch p) => Repository 'RW p wU wR -> Invertible (FL (PatchInfoAnd p)) wR wY -> IO ()
readHashedPristineRoot :: Repository rt p wU wR -> IO PristineHash
-- | Replace the pristine hash at the start of a raw, unparsed
-- HeadInventory or add it if none is present.
pokePristineHash :: PristineHash -> ByteString -> Doc
peekPristineHash :: ByteString -> PristineHash
-- | Write the pristine tree into a plain directory at the given path.
createPristineDirectoryTree :: Repository rt p wU wR -> FilePath -> WithWorkingDir -> IO ()
-- | Obtains a Tree corresponding to the "recorded" state of the
-- repository: this is the same as the pristine cache, which is the same
-- as the result of applying all the repository's patches to an empty
-- directory.
readPristine :: Repository rt p wU wR -> IO (Tree IO)
-- | Replace 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!
writePristine :: Repository rt p wU wR -> Tree IO -> IO PristineHash
convertSizePrefixedPristine :: Cache -> PristineHash -> IO PristineHash
module Darcs.Repository.Diff
treeDiff :: forall m w prim. (Monad m, Gap w, PrimPatch prim) => DiffAlgorithm -> (FilePath -> FileType) -> Tree m -> Tree m -> m (w (FL prim))
module Darcs.Repository.State
-- | From a repository and a list of AnchoredPath's, construct a filter
-- that can be used on a Tree (recorded or unrecorded state) of this
-- repository. This constructed filter will take pending into account, so
-- the subpaths will be translated correctly relative to pending move
-- patches.
restrictSubpaths :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> [AnchoredPath] -> IO (TreeFilter m)
-- | Construct a TreeFilter that removes any boring files that are
-- not also contained in the argument Tree.
--
-- 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.
restrictBoring :: Tree m -> IO (TreeFilter m)
newtype TreeFilter m
TreeFilter :: (forall tr. FilterTree tr m => tr m -> tr m) -> TreeFilter m
[applyTreeFilter] :: TreeFilter m -> forall tr. FilterTree tr m => tr m -> tr m
-- | Construct a Tree filter that removes any darcs metadata files the Tree
-- might have contained.
restrictDarcsdir :: TreeFilter m
-- | For a repository and an optional list of paths (when Nothing,
-- 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.
unrecordedChanges :: (RepoPatch p, ApplyState p ~ Tree) => DiffOpts -> Repository rt p wU wR -> Maybe [AnchoredPath] -> IO (FL (PrimOf p) wR wU)
-- | Obtains a Tree corresponding to the "recorded" state of the
-- repository: this is the same as the pristine cache, which is the same
-- as the result of applying all the repository's patches to an empty
-- directory.
readPristine :: Repository rt p wU wR -> IO (Tree IO)
-- | Obtains a Tree corresponding to the "unrecorded" state of the
-- repository: the modified files of the working tree plus the "pending"
-- patch. The optional list of paths allows to restrict the query to a
-- subtree.
--
-- Limiting the query may be more efficient, since hashes on the
-- uninteresting parts of the index do not need to go through an
-- up-to-date check (which involves a relatively expensive lstat(2) per
-- file.
readUnrecorded :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> UseIndex -> Maybe [AnchoredPath] -> IO (Tree IO)
-- | Obtains the recorded Tree with the pending patch applied.
readPristineAndPending :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> IO (Tree IO)
-- | Obtains the relevant (according to the given filter) part of the
-- working tree.
readWorking :: TreeFilter IO -> IO (Tree IO)
readPendingAndWorking :: (RepoPatch p, ApplyState p ~ Tree) => DiffOpts -> Repository rt p wU wR -> Maybe [AnchoredPath] -> IO ((FL (PrimOf p) :> FL (PrimOf p)) wR wU)
-- | A variant of readUnrecorded that takes the UseIndex and
-- LookForAdds options into account, similar to
-- readPendingAndWorking. We are only interested in the resulting
-- tree, not the patch, so the DiffAlgorithm option is irrelevant.
readUnrecordedFiltered :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> UseIndex -> LookForAdds -> LookForMoves -> Maybe [AnchoredPath] -> IO (Tree IO)
-- | Open the index or re-create it in case it is invalid or non-existing.
readIndex :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> IO Index
-- | Update the index so that it matches pristine+pending. If the index
-- does not exist or is invalid, create a new one.
--
-- This has to be called whenever the listing of pristine+pending
-- changes. Note that this only concerns files added and removed or
-- renamed: changes to file content in either pristine or working are
-- handled transparently by the index reading code.
updateIndex :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> IO ()
-- | Remove any patches (+dependencies) from a sequence that conflict with
-- the recorded or unrecorded changes in a repo
filterOutConflicts :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> UseIndex -> FL (PatchInfoAnd p) wX wR -> FL (PatchInfoAnd p) wX wZ -> IO (Bool, Sealed (FL (PatchInfoAnd p) wX))
-- | Add an FL of patches started from the pending state to the
-- pending patch.
unsafeAddToPending :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> FreeLeft (FL (PrimOf p)) -> IO ()
-- | Add an FL of patches starting from the working state to the
-- pending patch, including as much extra context as is necessary
-- (context meaning dependencies), by commuting the patches to be added
-- past as much of the changes between pending and working as is
-- possible, and including anything that doesn't commute, and the patch
-- itself in the new pending patch.
addToPending :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> DiffOpts -> FL (PrimOf p) wU wY -> IO ()
module Darcs.Repository.Resolution
standardResolution :: RepoPatch p => RL (PatchInfoAnd p) wO wX -> RL (PatchInfoAnd p) wX wY -> StandardResolution (PrimOf p) wY
-- | Like standardResolution but it doesn't use the instance
-- (Named p) because the traling list of patches may contain "fake"
-- conflictors.
rebaseResolution :: (Conflict p, PrimPatch (PrimOf p)) => RL (PatchInfoAnd p) wO wX -> RL (Named p) wX wY -> StandardResolution (PrimOf p) wY
externalResolution :: forall p wX wY wZ wA. (RepoPatch p, ApplyState p ~ Tree) => DiffAlgorithm -> Tree IO -> String -> WantGuiPause -> FL (PrimOf p) wX wY -> FL (PrimOf p) wX wZ -> FL p wY wA -> IO (Sealed (FL (PrimOf p) wA))
patchsetConflictResolutions :: RepoPatch p => PatchSet p Origin wX -> StandardResolution (PrimOf p) wX
data StandardResolution prim wX
StandardResolution :: Mangled prim wX -> [Unravelled prim wX] -> [AnchoredPath] -> StandardResolution prim wX
[mangled] :: StandardResolution prim wX -> Mangled prim wX
[unmangled] :: StandardResolution prim wX -> [Unravelled prim wX]
[conflictedPaths] :: StandardResolution prim wX -> [AnchoredPath]
announceConflicts :: PrimPatch prim => String -> AllowConflicts -> StandardResolution prim wX -> IO Bool
warnUnmangled :: PrimPatch prim => Maybe [AnchoredPath] -> StandardResolution prim wX -> IO ()
showUnmangled :: PrimPatch prim => Maybe [AnchoredPath] -> [Unravelled prim wX] -> Doc
showUnravelled :: PrimPatch prim => Doc -> Unravelled prim wX -> Doc
-- | First matcher, Second matcher and Nonrange matcher
--
-- When we match for patches, we have a PatchSet, of which we want a
-- subset. This subset is formed by the patches in a given interval which
-- match a given criterion. If we represent time going left to right,
-- then we have (up to) three Matchers:
--
--
module Darcs.Patch.Match
-- | The string that is emitted when the user runs darcs help
-- patterns.
helpOnMatchers :: [String]
-- | matchFirstPatchset 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.
matchFirstPatchset :: MatchableRP p => [MatchFlag] -> PatchSet p wStart wX -> Maybe (SealedPatchSet p wStart)
-- | matchSecondPatchset fs ps returns the part of ps
-- before its second matcher, ie the one that comes last dependencywise.
matchSecondPatchset :: MatchableRP p => [MatchFlag] -> PatchSet p wStart wX -> Maybe (SealedPatchSet p wStart)
-- | Split on the second matcher. Note that this picks up the first match
-- starting from the earliest patch in a sequence, as opposed to
-- matchSecondPatchset which picks up the first match starting
-- from the latest patch
splitSecondFL :: Matchable p => (forall wA wB. q wA wB -> Sealed2 p) -> [MatchFlag] -> FL q wX wY -> (FL q :> FL q) wX wY
-- | Whether a patch matches the given MatchFlags. This should be
-- invariant under inversion:
--
--
-- matchAPatch (invert p) = matchAPatch p
--
matchAPatch :: Matchable p => [MatchFlag] -> p wX wY -> Bool
-- | Rollback (i.e. apply the inverse) of what remains of a PatchSet
-- after we extract a PatchSetMatch. 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.
rollbackToPatchSetMatch :: (ApplyMonad (ApplyState p) m, MatchableRP p, ApplyState p ~ Tree) => PatchSetMatch -> PatchSet p Origin wX -> m ()
-- | 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.
firstMatch :: [MatchFlag] -> Bool
-- | secondMatch 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.
secondMatch :: [MatchFlag] -> Bool
-- | haveNonrangeMatch 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.
haveNonrangeMatch :: [MatchFlag] -> Bool
data PatchSetMatch
IndexMatch :: Int -> PatchSetMatch
PatchMatch :: Matcher -> PatchSetMatch
TagMatch :: Matcher -> PatchSetMatch
ContextMatch :: AbsolutePath -> PatchSetMatch
patchSetMatch :: [MatchFlag] -> Maybe PatchSetMatch
checkMatchSyntax :: [MatchFlag] -> IO ()
hasIndexRange :: [MatchFlag] -> Maybe (Int, Int)
-- | getMatchingTag m ps, where m is a Matcher
-- which matches tags returns a SealedPatchSet 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 error if there is no
-- matching tag.
getMatchingTag :: MatchableRP p => Matcher -> PatchSet p wStart wX -> SealedPatchSet p wStart
-- | matchAPatchset m ps returns a prefix of ps ending in
-- a patch matching m, and calls error if there is none.
matchAPatchset :: MatchableRP p => Matcher -> PatchSet p wStart wX -> SealedPatchSet p wStart
data MatchFlag
OnePattern :: String -> MatchFlag
SeveralPattern :: String -> MatchFlag
AfterPattern :: String -> MatchFlag
UpToPattern :: String -> MatchFlag
OnePatch :: String -> MatchFlag
SeveralPatch :: String -> MatchFlag
AfterPatch :: String -> MatchFlag
UpToPatch :: String -> MatchFlag
OneHash :: String -> MatchFlag
AfterHash :: String -> MatchFlag
UpToHash :: String -> MatchFlag
OneTag :: String -> MatchFlag
SeveralTag :: String -> MatchFlag
AfterTag :: String -> MatchFlag
UpToTag :: String -> MatchFlag
LastN :: Int -> MatchFlag
OneIndex :: Int -> MatchFlag
IndexRange :: Int -> Int -> MatchFlag
Context :: AbsolutePath -> MatchFlag
-- | matchingHead returns the repository up to some tag. The tag t is the
-- last tag such that there is a patch after t that is matched by the
-- user's query.
matchingHead :: forall p wR. MatchableRP p => [MatchFlag] -> PatchSet p Origin wR -> (PatchSet p :> FL (PatchInfoAnd p)) Origin wR
-- | Patches that can be matched.
type Matchable p = (Apply p, PatchInspect p, Ident p, PatchId p ~ PatchInfo)
-- | Constraint for a patch type p that ensures
-- PatchInfoAnd p is Matchable.
type MatchableRP p = (Apply p, Commute p, PatchInspect p)
instance GHC.Show.Show Darcs.Patch.Match.MatchFlag
instance GHC.Exception.Type.Exception Darcs.Patch.Match.MatchFailure
instance GHC.Show.Show Darcs.Patch.Match.MatchFailure
instance GHC.Show.Show Darcs.Patch.Match.Matcher
-- | Patch matching options.
--
-- These are all of the same type MatchOption defined below.
--
-- Multiple flags per option are allowed and do not raise a conflict
-- error. This is how Darcs currently operates, even though I suspect
-- that it ignores all but the first MatchFlag (since it does so
-- for many other options).
--
-- Given a suitable semantics (and documentation thereof), for instance
-- "all the given patterns must match", this could be turned into a
-- useful feature.
module Darcs.UI.Options.Matching
data MatchFlag
OnePattern :: String -> MatchFlag
SeveralPattern :: String -> MatchFlag
AfterPattern :: String -> MatchFlag
UpToPattern :: String -> MatchFlag
OnePatch :: String -> MatchFlag
SeveralPatch :: String -> MatchFlag
AfterPatch :: String -> MatchFlag
UpToPatch :: String -> MatchFlag
OneHash :: String -> MatchFlag
AfterHash :: String -> MatchFlag
UpToHash :: String -> MatchFlag
OneTag :: String -> MatchFlag
SeveralTag :: String -> MatchFlag
AfterTag :: String -> MatchFlag
UpToTag :: String -> MatchFlag
LastN :: Int -> MatchFlag
OneIndex :: Int -> MatchFlag
IndexRange :: Int -> Int -> MatchFlag
Context :: AbsolutePath -> MatchFlag
matchUpToOne :: MatchOption
-- | Used by: clone
matchOneContext :: MatchOption
-- | Used by: amend
matchOneNontag :: MatchOption
-- | Used by: rebase pull/apply, send, push, pull, apply, fetch
matchSeveral :: MatchOption
-- | Used by: rebase unsuspend/reify
matchSeveralOrFirst :: MatchOption
-- | Used by: unrecord, obliterate, rebase suspend, rollback
matchSeveralOrLast :: MatchOption
-- | Used by: show dependencies
matchRange :: MatchOption
-- | Used by: diff
matchOneOrRange :: MatchOption
-- | Used by: log
matchSeveralOrRange :: MatchOption
context :: MatchOption
matchLast :: MatchOption
matchFrom :: MatchOption
matchAny :: MatchOption
-- | All the concrete options.
--
-- Notes:
--
--
-- - The term "option" refers to a flag or combination of flags that
-- together form a part of a command's configuration. Ideally, options
-- should be orthogonal to each other, so we can freely combine
-- them.
-- - A primitive (indivisible) option has an associate value type.
-- - An option named "xyzActions" represents a set of flags that act as
-- mutually exclusive sub-commands. They typically have a dedicated value
-- type named "XyzAction".
-- - This module is probably best imported qualified. This is in
-- contrast to the current practice of using subtly differing names to
-- avoid name clashes for closely related items. For instance, the data
-- constructors for an option's value type and the corresponding data
-- constructors in DarcsFlag may coincide. This is also why we
-- import Darcs.UI.Flags qualified here.
-- - When the new options system is finally in place, no code other
-- than the one for constructing options should directly refer to
-- DarcsFlag constructors.
--
module Darcs.UI.Options.All
-- | DarcsOption instantiates the first two type parameters of
-- OptSpec to what we need in darcs.
type DarcsOption = OptSpec DarcsOptDescr Flag
class YesNo a
yes :: YesNo a => a -> Bool
no :: YesNo a => a -> Bool
-- | Options for darcs iself that act like sub-commands.
data RootAction
RootHelp :: RootAction
Version :: RootAction
ExactVersion :: RootAction
ListCommands :: RootAction
rootActions :: PrimDarcsOption (Maybe RootAction)
data StdCmdAction
Help :: StdCmdAction
ListOptions :: StdCmdAction
Disable :: StdCmdAction
stdCmdActions :: PrimDarcsOption (Maybe StdCmdAction)
debug :: PrimDarcsOption Bool
data Verbosity
Quiet :: Verbosity
NormalVerbosity :: Verbosity
Verbose :: Verbosity
verbosity :: PrimDarcsOption Verbosity
timings :: PrimDarcsOption Bool
debugging :: DarcsOption a (Bool -> Bool -> a)
data HooksConfig
HooksConfig :: HookConfig -> HookConfig -> HooksConfig
[pre] :: HooksConfig -> HookConfig
[post] :: HooksConfig -> HookConfig
data HookConfig
HookConfig :: Maybe String -> Bool -> HookConfig
[cmd] :: HookConfig -> Maybe String
[prompt] :: HookConfig -> Bool
preHook :: DarcsOption a (HookConfig -> a)
postHook :: DarcsOption a (HookConfig -> a)
hooks :: DarcsOption a (HooksConfig -> a)
data UseCache
YesUseCache :: UseCache
NoUseCache :: UseCache
useCache :: PrimDarcsOption UseCache
data XmlOutput
NoXml :: XmlOutput
YesXml :: XmlOutput
xmlOutput :: PrimDarcsOption XmlOutput
data DryRun
YesDryRun :: DryRun
NoDryRun :: DryRun
-- | TODO someone wrote here long ago that any time --dry-run is a
-- possibility automated users should be able to examine the results more
-- easily with --xml. See also issue2397. dryRun w/o xml is currently
-- used in add, pull, and repair.
dryRun :: PrimDarcsOption DryRun
dryRunXml :: DarcsOption a (DryRun -> XmlOutput -> a)
interactive :: PrimDarcsOption (Maybe Bool)
pipe :: PrimDarcsOption Bool
data WantGuiPause
YesWantGuiPause :: WantGuiPause
NoWantGuiPause :: WantGuiPause
pauseForGui :: PrimDarcsOption WantGuiPause
askDeps :: PrimDarcsOption Bool
data SelectDeps
NoDeps :: SelectDeps
AutoDeps :: SelectDeps
PromptDeps :: SelectDeps
selectDeps :: PrimDarcsOption SelectDeps
changesReverse :: PrimDarcsOption Bool
maxCount :: PrimDarcsOption (Maybe Int)
repoDir :: PrimDarcsOption (Maybe String)
possiblyRemoteRepo :: PrimDarcsOption (Maybe String)
-- | This option is for when a new repo gets created. Used for clone,
-- convert import, convert darcs-2, and initialize. For clone and
-- initialize it has the same effect as giving the name as a normal
-- argument.
--
-- The --repodir alias is there for compatibility, should be
-- removed eventually.
--
-- TODO We need a way to deprecate options / option names.
newRepo :: PrimDarcsOption (Maybe String)
data NotInRemote
NotInDefaultRepo :: NotInRemote
NotInRemotePath :: String -> NotInRemote
notInRemote :: PrimDarcsOption [NotInRemote]
notInRemoteFlagName :: String
data RepoCombinator
Intersection :: RepoCombinator
Union :: RepoCombinator
Complement :: RepoCombinator
repoCombinator :: PrimDarcsOption RepoCombinator
allowUnrelatedRepos :: PrimDarcsOption Bool
justThisRepo :: PrimDarcsOption Bool
data WithWorkingDir
WithWorkingDir :: WithWorkingDir
NoWorkingDir :: WithWorkingDir
-- | convert, clone, init
withWorkingDir :: PrimDarcsOption WithWorkingDir
data SetDefault
YesSetDefault :: Bool -> SetDefault
NoSetDefault :: Bool -> SetDefault
setDefault :: PrimDarcsOption (Maybe Bool)
data InheritDefault
YesInheritDefault :: InheritDefault
NoInheritDefault :: InheritDefault
inheritDefault :: PrimDarcsOption InheritDefault
data WithPrefsTemplates
WithPrefsTemplates :: WithPrefsTemplates
NoPrefsTemplates :: WithPrefsTemplates
withPrefsTemplates :: PrimDarcsOption WithPrefsTemplates
patchname :: PrimDarcsOption (Maybe String)
author :: PrimDarcsOption (Maybe String)
data AskLongComment
NoEditLongComment :: AskLongComment
YesEditLongComment :: AskLongComment
PromptLongComment :: AskLongComment
askLongComment :: PrimDarcsOption (Maybe AskLongComment)
keepDate :: PrimDarcsOption Bool
data Logfile
Logfile :: Maybe AbsolutePath -> Bool -> Logfile
[_logfile] :: Logfile -> Maybe AbsolutePath
[_rmlogfile] :: Logfile -> Bool
logfile :: PrimDarcsOption Logfile
data UseIndex
UseIndex :: UseIndex
IgnoreIndex :: UseIndex
includeBoring :: PrimDarcsOption Bool
data LookForAdds
NoLookForAdds :: LookForAdds
YesLookForAdds :: LookForAdds
EvenLookForBoring :: LookForAdds
data LookForMoves
YesLookForMoves :: LookForMoves
NoLookForMoves :: LookForMoves
data LookForReplaces
YesLookForReplaces :: LookForReplaces
NoLookForReplaces :: LookForReplaces
data DiffOpts
DiffOpts :: UseIndex -> LookForAdds -> LookForReplaces -> LookForMoves -> DiffAlgorithm -> DiffOpts
[withIndex] :: DiffOpts -> UseIndex
[lookForAdds] :: DiffOpts -> LookForAdds
[lookForReplaces] :: DiffOpts -> LookForReplaces
[lookForMoves] :: DiffOpts -> LookForMoves
[diffAlg] :: DiffOpts -> DiffAlgorithm
lookforadds :: PrimDarcsOption LookForAdds
maybelookforadds :: LookForAdds -> PrimDarcsOption LookForAdds
lookforreplaces :: PrimDarcsOption LookForReplaces
lookformoves :: PrimDarcsOption LookForMoves
allowProblematicFilenames :: DarcsOption a (Bool -> Bool -> a)
allowCaseDifferingFilenames :: PrimDarcsOption Bool
allowWindowsReservedFilenames :: PrimDarcsOption Bool
-- | TODO: see issue2395
onlyToFiles :: PrimDarcsOption Bool
useIndex :: PrimDarcsOption UseIndex
recursive :: PrimDarcsOption Bool
data DiffAlgorithm
PatienceDiff :: DiffAlgorithm
MyersDiff :: DiffAlgorithm
diffAlgorithm :: PrimDarcsOption DiffAlgorithm
data WithContext
NoContext :: WithContext
YesContext :: WithContext
withContext :: PrimDarcsOption WithContext
data ExternalDiff
ExternalDiff :: Maybe String -> [String] -> Bool -> ExternalDiff
[diffCmd] :: ExternalDiff -> Maybe String
[diffOptions] :: ExternalDiff -> [String]
[diffUnified] :: ExternalDiff -> Bool
extDiff :: PrimDarcsOption ExternalDiff
data TestChanges
NoTestChanges :: TestChanges
YesTestChanges :: LeaveTestDir -> TestChanges
testChanges :: PrimDarcsOption TestChanges
data RunTest
YesRunTest :: RunTest
NoRunTest :: RunTest
data LeaveTestDir
YesLeaveTestDir :: LeaveTestDir
NoLeaveTestDir :: LeaveTestDir
leaveTestDir :: PrimDarcsOption LeaveTestDir
data HeaderFields
HeaderFields :: [String] -> Maybe String -> HeaderFields
[_to, _cc] :: HeaderFields -> [String]
[_from, _subject, _inReplyTo] :: HeaderFields -> Maybe String
headerFields :: PrimDarcsOption HeaderFields
sendToContext :: PrimDarcsOption (Maybe AbsolutePath)
mail :: PrimDarcsOption Bool
sendmailCmd :: PrimDarcsOption (Maybe String)
charset :: PrimDarcsOption (Maybe String)
editDescription :: PrimDarcsOption Bool
applyAs :: PrimDarcsOption (Maybe String)
data Sign
NoSign :: Sign
Sign :: Sign
SignAs :: String -> Sign
SignSSL :: String -> Sign
sign :: PrimDarcsOption Sign
data Verify
NoVerify :: Verify
VerifyKeyring :: AbsolutePath -> Verify
VerifySSL :: AbsolutePath -> Verify
verify :: PrimDarcsOption Verify
data AllowConflicts
NoAllowConflicts :: AllowConflicts
YesAllowConflicts :: ResolveConflicts -> AllowConflicts
-- | push, apply, rebase apply: default to NoAllowConflicts
conflictsNo :: PrimDarcsOption (Maybe AllowConflicts)
-- | pull, rebase pull: default to YesAllowConflicts
-- MarkConflicts
conflictsYes :: PrimDarcsOption (Maybe AllowConflicts)
data ResolveConflicts
NoResolveConflicts :: ResolveConflicts
MarkConflicts :: ResolveConflicts
ExternalMerge :: String -> ResolveConflicts
-- | pull, apply, rebase pull, rebase apply
reorder :: PrimDarcsOption Reorder
-- | push; same as reorder but with help descriptions swapped
reorderPush :: PrimDarcsOption Reorder
data Compression
NoCompression :: Compression
GzipCompression :: Compression
-- | push
compress :: PrimDarcsOption Compression
usePacks :: PrimDarcsOption Bool
data WithPatchIndex
YesPatchIndex :: WithPatchIndex
NoPatchIndex :: WithPatchIndex
patchIndexNo :: PrimDarcsOption WithPatchIndex
patchIndexYes :: PrimDarcsOption WithPatchIndex
data Reorder
NoReorder :: Reorder
Reorder :: Reorder
minimize :: PrimDarcsOption Bool
storeInMemory :: PrimDarcsOption Bool
data OptimizeDeep
OptimizeShallow :: OptimizeDeep
OptimizeDeep :: OptimizeDeep
optimizeDeep :: PrimDarcsOption OptimizeDeep
data Output
Output :: AbsolutePathOrStd -> Output
OutputAutoName :: AbsolutePath -> Output
output :: PrimDarcsOption (Maybe Output)
data WithSummary
NoSummary :: WithSummary
YesSummary :: WithSummary
withSummary :: PrimDarcsOption WithSummary
maybeSummary :: Maybe WithSummary -> PrimDarcsOption (Maybe WithSummary)
data RemoteDarcs
RemoteDarcs :: String -> RemoteDarcs
DefaultRemoteDarcs :: RemoteDarcs
remoteDarcs :: PrimDarcsOption RemoteDarcs
data UMask
YesUMask :: String -> UMask
NoUMask :: UMask
umask :: PrimDarcsOption UMask
data SetScriptsExecutable
YesSetScriptsExecutable :: SetScriptsExecutable
NoSetScriptsExecutable :: SetScriptsExecutable
setScriptsExecutable :: PrimDarcsOption SetScriptsExecutable
amendUnrecord :: PrimDarcsOption Bool
selectAuthor :: PrimDarcsOption Bool
machineReadable :: PrimDarcsOption Bool
data CloneKind
-- | Just copy pristine and inventories
LazyClone :: CloneKind
-- | First do a lazy clone then copy everything
NormalClone :: CloneKind
-- | Same as Normal but omit telling user they can interrumpt
CompleteClone :: CloneKind
cloneKind :: PrimDarcsOption CloneKind
distname :: PrimDarcsOption (Maybe String)
distzip :: PrimDarcsOption Bool
marks :: DarcsOption a (Maybe AbsolutePath -> Maybe AbsolutePath -> a)
readMarks :: PrimDarcsOption (Maybe AbsolutePath)
writeMarks :: PrimDarcsOption (Maybe AbsolutePath)
data PatchFormat
PatchFormat1 :: PatchFormat
PatchFormat2 :: PatchFormat
PatchFormat3 :: PatchFormat
patchFormat :: PrimDarcsOption PatchFormat
-- | Deprecated flag, still present to output an error message.
hashed :: PrimDarcsOption ()
data ChangesFormat
HumanReadable :: ChangesFormat
MachineReadable :: ChangesFormat
GenContext :: ChangesFormat
GenXml :: ChangesFormat
NumberPatches :: ChangesFormat
CountPatches :: ChangesFormat
changesFormat :: PrimDarcsOption (Maybe ChangesFormat)
tokens :: PrimDarcsOption (Maybe String)
forceReplace :: PrimDarcsOption Bool
data TestStrategy
Once :: TestStrategy
Linear :: TestStrategy
Backoff :: TestStrategy
Bisect :: TestStrategy
testStrategy :: PrimDarcsOption TestStrategy
data ShrinkFailure
ShrinkFailure :: ShrinkFailure
NoShrinkFailure :: ShrinkFailure
shrinkFailure :: PrimDarcsOption ShrinkFailure
files :: PrimDarcsOption Bool
directories :: PrimDarcsOption Bool
pending :: PrimDarcsOption Bool
nullFlag :: PrimDarcsOption Bool
data EnumPatches
NoEnumPatches :: EnumPatches
YesEnumPatches :: EnumPatches
enumPatches :: PrimDarcsOption EnumPatches
data GzcrcsAction
GzcrcsCheck :: GzcrcsAction
GzcrcsRepair :: GzcrcsAction
gzcrcsActions :: PrimDarcsOption (Maybe GzcrcsAction)
siblings :: PrimDarcsOption [AbsolutePath]
instance GHC.Show.Show Darcs.UI.Options.All.EnumPatches
instance GHC.Classes.Eq Darcs.UI.Options.All.EnumPatches
instance GHC.Show.Show Darcs.UI.Options.All.RootAction
instance GHC.Classes.Eq Darcs.UI.Options.All.RootAction
instance GHC.Show.Show Darcs.UI.Options.All.StdCmdAction
instance GHC.Classes.Eq Darcs.UI.Options.All.StdCmdAction
instance GHC.Show.Show Darcs.UI.Options.All.XmlOutput
instance GHC.Classes.Eq Darcs.UI.Options.All.XmlOutput
instance GHC.Show.Show Darcs.UI.Options.All.SelectDeps
instance GHC.Classes.Eq Darcs.UI.Options.All.SelectDeps
instance GHC.Show.Show Darcs.UI.Options.All.RepoCombinator
instance GHC.Classes.Eq Darcs.UI.Options.All.RepoCombinator
instance GHC.Show.Show Darcs.UI.Options.All.AskLongComment
instance GHC.Classes.Eq Darcs.UI.Options.All.AskLongComment
instance GHC.Show.Show Darcs.UI.Options.All.WithContext
instance GHC.Classes.Eq Darcs.UI.Options.All.WithContext
instance GHC.Show.Show Darcs.UI.Options.All.ExternalDiff
instance GHC.Classes.Eq Darcs.UI.Options.All.ExternalDiff
instance GHC.Classes.Eq Darcs.UI.Options.All.TestChanges
instance GHC.Show.Show Darcs.UI.Options.All.Sign
instance GHC.Classes.Eq Darcs.UI.Options.All.Sign
instance GHC.Show.Show Darcs.UI.Options.All.Verify
instance GHC.Classes.Eq Darcs.UI.Options.All.Verify
instance GHC.Show.Show Darcs.UI.Options.All.Compression
instance GHC.Classes.Eq Darcs.UI.Options.All.Compression
instance GHC.Show.Show Darcs.UI.Options.All.Output
instance GHC.Classes.Eq Darcs.UI.Options.All.Output
instance GHC.Show.Show Darcs.UI.Options.All.WithSummary
instance GHC.Classes.Eq Darcs.UI.Options.All.WithSummary
instance GHC.Show.Show Darcs.UI.Options.All.ChangesFormat
instance GHC.Classes.Eq Darcs.UI.Options.All.ChangesFormat
instance GHC.Show.Show Darcs.UI.Options.All.TestStrategy
instance GHC.Classes.Eq Darcs.UI.Options.All.TestStrategy
instance GHC.Show.Show Darcs.UI.Options.All.ShrinkFailure
instance GHC.Classes.Eq Darcs.UI.Options.All.ShrinkFailure
instance GHC.Show.Show Darcs.UI.Options.All.GzcrcsAction
instance GHC.Classes.Eq Darcs.UI.Options.All.GzcrcsAction
instance Darcs.UI.Options.All.YesNo Darcs.UI.Options.All.WithSummary
instance Darcs.UI.Options.All.YesNo Darcs.UI.Options.All.Compression
instance Darcs.UI.Options.All.YesNo Darcs.UI.Options.All.WithContext
instance Darcs.UI.Options.All.YesNo Darcs.UI.Options.All.XmlOutput
instance Darcs.UI.Options.All.YesNo Darcs.UI.Options.All.EnumPatches
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.WithPatchIndex
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.Reorder
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.UseCache
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.DryRun
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.LookForAdds
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.LookForReplaces
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.LookForMoves
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.RunTest
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.SetScriptsExecutable
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.LeaveTestDir
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.UseIndex
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.WantGuiPause
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.WithWorkingDir
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.InheritDefault
instance Darcs.UI.Options.All.YesNo Darcs.Repository.Flags.WithPrefsTemplates
module Darcs.UI.RunHook
runPosthook :: HookConfig -> Verbosity -> AbsolutePath -> IO ExitCode
runPrehook :: HookConfig -> Verbosity -> AbsolutePath -> IO ExitCode
module Darcs.UI.Options
-- | DarcsOption instantiates the first two type parameters of
-- OptSpec to what we need in darcs.
type DarcsOption = OptSpec DarcsOptDescr Flag
-- | This is PrimOptSpec instantiated with DarcsOptDescr and
-- Flag.
type PrimDarcsOption v = forall a. PrimOptSpec DarcsOptDescr Flag a v
-- | We do not instantiate the d in OptSpec d f
-- directly with OptDescr. Instead we (post-) compose it with
-- (->) AbsolutePath. Modulo newtype noise, this is
-- the same as
--
--
-- type DarcsOptDescr f = OptDescr (AbsolutePath -> 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).
type DarcsOptDescr = Compose OptDescr ((->) AbsolutePath)
-- | Instantiate a DarcsOptDescr with an AbsolutePath
optDescr :: AbsolutePath -> DarcsOptDescr f -> OptDescr f
type Config = [Flag]
withDashes :: [Char] -> [String] -> [String]
-- | Helper functions to access option contents. Some of them are here only
-- to ease the transition from the legacy system where we manually parsed
-- the flag list to the new(er) option system. At some point this module
-- should be renamed and the re-exports from Darcs.UI.Options.All
-- removed.
module Darcs.UI.Flags
-- | The DarcsFlag type is a list of all flags that can ever be
-- passed to darcs, or to one of its commands.
data DarcsFlag
diffingOpts :: Config -> DiffOpts
-- | This will become dis-entangled as soon as we inline these functions.
wantGuiPause :: Config -> WantGuiPause
-- | Non-trivial interaction between options. Explicit -i or
-- -a dominates, else --count, --xml, or
-- --dry-run imply -a, else use the def argument.
isInteractive :: Bool -> Config -> Bool
willRemoveLogFile :: Config -> Bool
setDefault :: Bool -> Config -> SetDefault
allowConflicts :: Config -> AllowConflicts
hasXmlOutput :: Config -> Bool
hasLogfile :: Config -> Maybe AbsolutePath
quiet :: Config -> Bool
verbose :: Config -> Bool
enumeratePatches :: Config -> Bool
-- | The first argument is an AbsolutePath, the second a
-- String 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.
fixUrl :: AbsolutePath -> String -> IO String
-- | Used 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.
pathsFromArgs :: (AbsolutePath, AbsolutePath) -> [String] -> IO [AnchoredPath]
-- | Used 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 Nothing here means "no
-- restriction to the set of paths". If Just is returned, the set
-- is guaranteed to be non-empty.
pathSetFromArgs :: (AbsolutePath, AbsolutePath) -> [String] -> IO (Maybe [AnchoredPath])
-- | getRepourl 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=DIRECTORY
getRepourl :: Config -> Maybe String
-- | getAuthor 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.
getAuthor :: Maybe String -> Bool -> IO String
-- | promptAuthor 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.
promptAuthor :: Bool -> Bool -> IO String
-- | getEasyAuthor 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.
getEasyAuthor :: IO [String]
-- | getSendmailCmd 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.
getSendmailCmd :: Config -> IO (Maybe String)
fileHelpAuthor :: [String]
environmentHelpEmail :: ([String], [String])
-- | getSubject 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=SUBJECT
getSubject :: Config -> Maybe String
getInReplyTo :: Config -> Maybe String
-- | getCc 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.
getCc :: Config -> String
environmentHelpSendmail :: ([String], [String])
-- | Accessor 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.
getOutput :: Config -> IO FilePath -> Maybe (IO AbsolutePathOrStd)
getDate :: Bool -> IO String
workRepo :: Config -> WorkRepo
withNewRepo :: String -> Config -> Config
diffAlgorithm :: PrimDarcsOption DiffAlgorithm
-- | pull, apply, rebase pull, rebase apply
reorder :: PrimDarcsOption Reorder
minimize :: PrimDarcsOption Bool
editDescription :: PrimDarcsOption Bool
maxCount :: PrimDarcsOption (Maybe Int)
matchAny :: MatchOption
withContext :: PrimDarcsOption WithContext
allowCaseDifferingFilenames :: PrimDarcsOption Bool
allowWindowsReservedFilenames :: PrimDarcsOption Bool
changesReverse :: PrimDarcsOption Bool
usePacks :: PrimDarcsOption Bool
-- | TODO: see issue2395
onlyToFiles :: PrimDarcsOption Bool
amendUnrecord :: PrimDarcsOption Bool
verbosity :: PrimDarcsOption Verbosity
useCache :: PrimDarcsOption UseCache
useIndex :: PrimDarcsOption UseIndex
umask :: PrimDarcsOption UMask
-- | TODO someone wrote here long ago that any time --dry-run is a
-- possibility automated users should be able to examine the results more
-- easily with --xml. See also issue2397. dryRun w/o xml is currently
-- used in add, pull, and repair.
dryRun :: PrimDarcsOption DryRun
testChanges :: PrimDarcsOption TestChanges
setScriptsExecutable :: PrimDarcsOption SetScriptsExecutable
-- | convert, clone, init
withWorkingDir :: PrimDarcsOption WithWorkingDir
leaveTestDir :: PrimDarcsOption LeaveTestDir
cloneKind :: PrimDarcsOption CloneKind
patchIndexNo :: PrimDarcsOption WithPatchIndex
patchIndexYes :: PrimDarcsOption WithPatchIndex
xmlOutput :: PrimDarcsOption XmlOutput
selectDeps :: PrimDarcsOption SelectDeps
author :: PrimDarcsOption (Maybe String)
patchFormat :: PrimDarcsOption PatchFormat
charset :: PrimDarcsOption (Maybe String)
siblings :: PrimDarcsOption [AbsolutePath]
applyAs :: PrimDarcsOption (Maybe String)
enumPatches :: PrimDarcsOption EnumPatches
module Darcs.UI.External
sendEmail :: String -> String -> String -> String -> Maybe String -> String -> IO ()
generateEmail :: Handle -> String -> String -> String -> String -> Doc -> IO ()
-- | Send an email, optionally containing a patch bundle (more precisely,
-- its description and the bundle itself)
sendEmailDoc :: String -> String -> String -> String -> Maybe String -> Maybe (Doc, Doc) -> Doc -> IO ()
signString :: Sign -> Doc -> IO Doc
verifyPS :: Verify -> ByteString -> IO (Maybe ByteString)
execDocPipe :: String -> [String] -> Doc -> IO Doc
pipeDoc :: String -> [String] -> Doc -> IO ExitCode
pipeDocSSH :: Compression -> SshFilePath -> [String] -> Doc -> IO ExitCode
viewDoc :: Doc -> IO ()
viewDocWith :: Printers -> Doc -> IO ()
checkDefaultSendmail :: IO ()
diffProgram :: IO String
-- | Get the name of the darcs executable (as supplied by
-- getExecutablePath)
darcsProgram :: IO String
editText :: String -> ByteString -> IO ByteString
-- | 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.
editFile :: FilePathLike p => p -> IO (ExitCode, Bool)
-- | On Posix systems, GHC by default uses the user's locale encoding to
-- determine how to decode/encode the raw byte sequences in the Posix API
-- to/from String. 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
-- getFileSystemEncoding.
--
-- 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 Strings. The encoding
-- used for IO from and to handles is controlled by
-- setLocaleEncoding 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.
--
-- On Windows, this function does (and should) not do anything.
setDarcsEncodings :: IO ()
module Darcs.UI.PrintPatch
-- | Print a patch, together with its context, on standard output, using a
-- pager.
contextualPrintPatchWithPager :: (ApplyMonadTrans (ApplyState p) IO, ShowContextPatch p) => ApplyState p IO -> p wX wY -> IO ()
printContent :: ShowPatch p => p wX wY -> IO ()
printContentWithPager :: ShowPatch p => p wX wY -> IO ()
-- | printFriendly opts patch prints patch in
-- accordance with the flags in opts, ie, whether --verbose or
-- --summary were passed at the command-line.
printFriendly :: ShowPatch p => Verbosity -> WithSummary -> p wX wY -> IO ()
printSummary :: ShowPatch p => p wX wY -> IO ()
-- | showFriendly flags patch returns a Doc
-- representing the right way to show patch given the list
-- flags of flags darcs was invoked with.
showFriendly :: ShowPatch p => Verbosity -> WithSummary -> p wX wY -> Doc
showWithSummary :: ShowPatch p => p wX wY -> Doc
module Darcs.UI.SelectChanges
-- | When asking about patches, we either ask about them in oldest-first or
-- newest first (with respect to the current ordering of the repository),
-- and we either want an initial segment or a final segment of the poset
-- of patches.
--
-- First: ask for an initial segment, first patches first (default
-- for all pull-like commands)
--
-- FirstReversed: ask for an initial segment, last patches first
-- (used to ask about dependencies in record, and for pull-like commands
-- with the --reverse flag).
--
-- LastReversed: ask for a final segment, last patches first.
-- (default for unpull-like commands, except for selecting *primitive*
-- patches in rollback)
--
-- Last: ask for a final segment, first patches first. (used for
-- selecting primitive patches in rollback, and for unpull-like commands
-- with the --reverse flag
--
-- IOW: First = initial segment Last = final segment Reversed = start
-- with the newest patch instead of oldest As usual, terminology is not,
-- ahem, very intuitive.
data WhichChanges
Last :: WhichChanges
LastReversed :: WhichChanges
First :: WhichChanges
FirstReversed :: WhichChanges
-- | The equivalent of runSelection for the darcs log
-- command
viewChanges :: (ShowPatch p, ShowContextPatch p, ApplyState p ~ Tree) => PatchSelectionOptions -> [Sealed2 p] -> IO ()
-- | The function for selecting a patch to amend record. Read at your own
-- risks.
withSelectedPatchFromList :: (Commute p, Matchable p, ShowPatch p, ShowContextPatch p, ApplyState p ~ Tree) => String -> RL p wX wY -> PatchSelectionOptions -> ((RL p :> p) wX wY -> IO ()) -> IO ()
-- | Run a PatchSelection action in the given
-- SelectionConfig, without assuming that patches are invertible.
runSelection :: (MatchableRP p, ShowPatch p, ShowContextPatch p, ApplyState p ~ Tree, ApplyState p ~ ApplyState (PrimOf p)) => FL p wX wY -> SelectionConfig p -> IO ((FL p :> FL p) wX wY)
-- | Run a PatchSelection action in the given
-- SelectionConfig, assuming patches are invertible.
runInvertibleSelection :: forall p wX wY. (Invert p, MatchableRP p, ShowPatch p, ShowContextPatch p, ApplyState p ~ Tree) => FL p wX wY -> SelectionConfig p -> IO ((FL p :> FL p) wX wY)
-- | A SelectionConfig for selecting Prim patches.
selectionConfigPrim :: WhichChanges -> String -> PatchSelectionOptions -> Maybe (Splitter prim) -> Maybe [AnchoredPath] -> SelectionConfig prim
-- | A generic SelectionConfig.
selectionConfigGeneric :: Matchable p => (forall wX wY. q wX wY -> Sealed2 p) -> WhichChanges -> String -> PatchSelectionOptions -> Maybe [AnchoredPath] -> SelectionConfig q
-- | A SelectionConfig for selecting full (Matchable) patches
selectionConfig :: Matchable p => WhichChanges -> String -> PatchSelectionOptions -> Maybe (Splitter p) -> Maybe [AnchoredPath] -> SelectionConfig p
-- | All the static settings for selecting patches.
data SelectionConfig p
data PatchSelectionOptions
PatchSelectionOptions :: Verbosity -> [MatchFlag] -> Bool -> SelectDeps -> WithSummary -> PatchSelectionOptions
[verbosity] :: PatchSelectionOptions -> Verbosity
[matchFlags] :: PatchSelectionOptions -> [MatchFlag]
[interactive] :: PatchSelectionOptions -> Bool
[selectDeps] :: PatchSelectionOptions -> SelectDeps
[withSummary] :: PatchSelectionOptions -> WithSummary
type InteractiveSelectionM p wX wY a = StateT (InteractiveSelectionState p wX wY) (PatchSelectionM p IO) a
-- | The dynamic parameters for interactive selection of patches.
data InteractiveSelectionState p wX wY
ISC :: Int -> Int -> FZipper (LabelledPatch p) wX wY -> PatchChoices p wX wY -> InteractiveSelectionState p wX wY
-- | total number of patches
[total] :: InteractiveSelectionState p wX wY -> Int
-- | number of already-seen patches
[current] :: InteractiveSelectionState p wX wY -> Int
-- | the patches we offer
[lps] :: InteractiveSelectionState p wX wY -> FZipper (LabelledPatch p) wX wY
-- | the user's choices
[choices] :: InteractiveSelectionState p wX wY -> PatchChoices p wX wY
initialSelectionState :: FL (LabelledPatch p) wX wY -> PatchChoices p wX wY -> InteractiveSelectionState p wX wY
-- | Returns a Sealed2 version of the patch we are asking the user
-- about.
currentPatch :: InteractiveSelectionM p wX wY (Maybe (Sealed2 (LabelledPatch p)))
-- | Skips patches we should not ask the user about
skipMundane :: (Commute p, ShowPatch p) => InteractiveSelectionM p wX wY ()
-- | Focus the next patch.
skipOne :: InteractiveSelectionM p wX wY ()
-- | Focus the previous patch.
backOne :: InteractiveSelectionM p wX wY ()
backAll :: InteractiveSelectionM p wX wY ()
-- | decide True selects the current patch, and decide
-- False deselects it.
decide :: Commute p => Bool -> LabelledPatch p wA wB -> InteractiveSelectionM p wX wY ()
-- | like decide, but for all patches touching file
decideWholeFile :: (Commute p, PatchInspect p) => AnchoredPath -> Bool -> InteractiveSelectionM p wX wY ()
isSingleFile :: PatchInspect p => p wX wY -> Bool
-- | returns Just f if the currentPatch only modifies
-- f, Nothing otherwise.
currentFile :: PatchInspect p => InteractiveSelectionM p wX wY (Maybe AnchoredPath)
-- | Asks the user about one patch, returns their answer.
promptUser :: ShowPatch p => Bool -> Char -> InteractiveSelectionM p wX wY Char
-- | The question to ask about one patch.
prompt :: ShowPatch p => InteractiveSelectionM p wX wY String
-- | The type of the answers to a "shall I [wiggle] that [foo]?" question
-- They are found in a [[KeyPress]] bunch, each list representing a set
-- of answers which belong together
data KeyPress
KeyPress :: Char -> String -> KeyPress
[kp] :: KeyPress -> Char
[kpHelp] :: KeyPress -> String
-- | The keys used by a list of keyPress groups.
keysFor :: [[KeyPress]] -> [Char]
-- | Generates the help for a set of basic and advanced KeyPress
-- groups.
helpFor :: String -> [[KeyPress]] -> [[KeyPress]] -> String
-- | For a given sequence of preceding patches to choose from, and a
-- sequence of prims which will become a new named patch, let the user
-- select a subset such that the new patch will explicitly depend on
-- them. The patches offered include only those that the new patch does
-- not already depend on. To support amend, we pass in the old
-- dependencies, too.
askAboutDepends :: (RepoPatch p, ApplyState p ~ Tree) => RL (PatchInfoAnd p) wX wR -> FL (PrimOf p) wR wT -> PatchSelectionOptions -> [PatchInfo] -> IO [PatchInfo]
instance GHC.Show.Show Darcs.UI.SelectChanges.WhichChanges
instance GHC.Classes.Eq Darcs.UI.SelectChanges.WhichChanges
module Darcs.UI.PatchHeader
-- | Get the patch name and long description from one of
--
--
-- - the configuration (flags, defaults, hard-coded)
-- - an existing log file
-- - stdin (e.g. a pipe)
-- - a text editor
--
--
-- It ensures the patch name is not empty nor starts with the prefix TAG.
--
-- The last result component is a possible path to a temporary file that
-- should be removed later.
getLog :: Maybe String -> Bool -> Logfile -> Maybe AskLongComment -> Maybe (String, [String]) -> Doc -> IO (String, [String], Maybe String)
-- | getAuthor tries to return the updated author for the patch.
-- There are two different scenarios:
--
--
-- - [explicit] Either we want to override the patch author, be it by
-- prompting the user (select) or having them pass it in from
-- the UI (new_author), or
-- - [implicit] We want to keep the original author, in which case we
-- also double-check that we are not inadvertently "hijacking" somebody
-- else's patch (if the patch author is not the same as the repository
-- author, we give them a chance to abort the whole operation)
--
getAuthor :: String -> Bool -> Maybe String -> PatchInfo -> HijackT IO String
editLog :: Named prim wX wY -> IO (Named prim wX wY)
-- | Update the metadata for a patch. This potentially involves a bit of
-- interactivity, so we may return Nothing if there is cause to
-- abort what we're doing along the way
updatePatchHeader :: forall p wX wY wZ. (RepoPatch p, ApplyState p ~ Tree) => String -> AskAboutDeps p wX -> PatchSelectionOptions -> PatchHeaderConfig -> Named (PrimOf p) wX wY -> FL (PrimOf p) wY wZ -> HijackT IO (Maybe String, PatchInfoAnd p wX wZ)
-- | Specify whether to ask about dependencies with respect to a particular
-- PatchSet, or not
data AskAboutDeps p wX
[AskAboutDeps] :: RL (PatchInfoAnd p) w wX -> AskAboutDeps p wX
[NoAskAboutDeps] :: AskAboutDeps p wX
data PatchHeaderConfig
patchHeaderConfig :: Config -> PatchHeaderConfig
-- | Transformer for interactions with a hijack warning state that we need
-- to thread through
type HijackT = StateT HijackOptions
-- | Options for how to deal with the situation where we are somehow
-- modifying a patch that is not our own
data HijackOptions
-- | accept all hijack requests
IgnoreHijack :: HijackOptions
-- | prompt once, accepting subsequent hijacks if yes
RequestHijackPermission :: HijackOptions
-- | always prompt
AlwaysRequestHijackPermission :: HijackOptions
-- | Run a job that involves a hijack confirmation prompt.
--
-- See RequestHijackPermission for initial values
runHijackT :: Monad m => HijackOptions -> HijackT m a -> m a
module Darcs.UI.Commands.Convert.Util
type Marks = IntMap ByteString
emptyMarks :: Marks
addMark :: Marks -> Int -> ByteString -> Marks
getMark :: Marks -> Int -> Maybe ByteString
lastMark :: Marks -> Int
readMarks :: FilePath -> IO Marks
writeMarks :: FilePath -> Marks -> IO ()
patchHash :: PatchInfoAnd p cX cY -> ByteString
updatePending :: [DarcsFlag] -> UpdatePending
-- | Generic wrapper for prim patches to give them an identity.
module Darcs.Patch.Prim.WithName
-- | A PrimWithName is a general way of associating an identity with
-- an underlying (presumably unnamed) primitive type. This is required,
-- for example, for V3 patches. Normally the members of the name
-- type will be generated in some way when a patch is initially created,
-- to guarantee global unqiueness across all repositories.
data PrimWithName name p wX wY
PrimWithName :: !name -> !p wX wY -> PrimWithName name p wX wY
[wnName] :: PrimWithName name p wX wY -> !name
[wnPatch] :: PrimWithName name p wX wY -> !p wX wY
instance Darcs.Patch.Ident.SignedId name => Darcs.Patch.Ident.Ident (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance (GHC.Classes.Eq name, Darcs.Patch.Witnesses.Eq.Eq2 p) => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance (Darcs.Patch.Invert.Invert p, Darcs.Patch.Ident.SignedId name) => Darcs.Patch.Invert.Invert (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance Darcs.Patch.Inspect.PatchInspect p => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance (Darcs.Patch.Witnesses.Show.Show2 p, GHC.Show.Show name) => GHC.Show.Show (Darcs.Patch.Prim.WithName.PrimWithName name p wX wY)
instance (Darcs.Patch.Witnesses.Show.Show2 p, GHC.Show.Show name) => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Prim.WithName.PrimWithName name p wX)
instance (Darcs.Patch.Witnesses.Show.Show2 p, GHC.Show.Show name) => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance Darcs.Patch.Apply.Apply p => Darcs.Patch.Apply.Apply (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance Darcs.Patch.Format.PatchListFormat (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance Darcs.Patch.Apply.Apply p => Darcs.Patch.Repair.RepairToFL (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance Darcs.Patch.Annotate.Class.Annotate p => Darcs.Patch.Annotate.Class.Annotate (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance Darcs.Patch.FileHunk.IsHunk p => Darcs.Patch.FileHunk.IsHunk (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance Darcs.Patch.Prim.Class.PrimApply p => Darcs.Patch.Prim.Class.PrimApply (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance Darcs.Patch.Prim.Class.PrimDetails p => Darcs.Patch.Prim.Class.PrimDetails (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Commute.Commute p) => Darcs.Patch.Commute.Commute (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Merge.CleanMerge p) => Darcs.Patch.Merge.CleanMerge (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance (Darcs.Patch.Ident.StorableId name, Darcs.Patch.Read.ReadPatch p) => Darcs.Patch.Read.ReadPatch (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance (Darcs.Patch.Ident.StorableId name, Darcs.Patch.Show.ShowPatchBasic p) => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance (Darcs.Patch.Ident.StorableId name, Darcs.Patch.Prim.Class.PrimDetails p, Darcs.Patch.Show.ShowPatchBasic p) => Darcs.Patch.Show.ShowPatch (Darcs.Patch.Prim.WithName.PrimWithName name p)
instance (Darcs.Patch.Ident.StorableId name, Darcs.Patch.Show.ShowContextPatch p) => Darcs.Patch.Show.ShowContextPatch (Darcs.Patch.Prim.WithName.PrimWithName name p)
-- | Conflictors a la camp.
--
-- Similar to the camp paper, but with a few differences:
--
--
-- - no reverse conflictors and no Invert instance
-- - instead we directly implement cleanMerge
-- - minor details of merge and commute due to bug fixes
--
--
-- The proofs in this module assume that whenever we create a conflictor
-- we maintain the following invariants:
--
--
-- - A conflictor reverts a patch in its context iff it is the first
-- patch that conflicts with it. This implies that any patch a conflictor
-- reverts exists in its context as an unconflicted Prim.
-- - If v depends on u and p conflicts with u then it also conflicts
-- with v.
--
module Darcs.Patch.V3.Core
data RepoPatchV3 name prim wX wY
[Prim] :: PrimWithName name prim wX wY -> RepoPatchV3 name prim wX wY
[Conflictor] :: FL (PrimWithName name prim) wX wY -> Set (Contexted (PrimWithName name prim) wY) -> Contexted (PrimWithName name prim) wY -> RepoPatchV3 name prim wX wY
pattern PrimP :: TestOnly => PrimWithName name prim wX wY -> RepoPatchV3 name prim wX wY
pattern ConflictorP :: TestOnly => FL (PrimWithName name prim) wX wY -> Set (Contexted (PrimWithName name prim) wY) -> Contexted (PrimWithName name prim) wY -> RepoPatchV3 name prim wX wY
-- | A handy synonym for insert.
(+|) :: Ord a => a -> Set a -> Set a
infixr 9 +|
-- | A handy synonym for delete.
(-|) :: Ord a => a -> Set a -> Set a
infixr 9 -|
instance Darcs.Patch.Effect.Effect (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.Ident.SignedId name => Darcs.Patch.Ident.Ident (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Ident.StorableId name, Darcs.Patch.Prim.Class.PrimPatch prim) => Darcs.Patch.Merge.CleanMerge (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Ident.StorableId name, Darcs.Patch.Prim.Class.PrimPatch prim) => Darcs.Patch.Merge.Merge (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Ident.StorableId name, Darcs.Patch.Prim.Class.PrimPatch prim) => Darcs.Patch.CommuteNoConflicts.CommuteNoConflicts (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Ident.StorableId name, Darcs.Patch.Prim.Class.PrimPatch prim) => Darcs.Patch.Commute.Commute (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.Inspect.PatchInspect prim => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Witnesses.Eq.Eq2 prim, Darcs.Patch.Commute.Commute prim) => Darcs.Patch.Witnesses.Eq.Eq2 (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (GHC.Show.Show name, Darcs.Patch.Witnesses.Show.Show2 prim) => GHC.Show.Show (Darcs.Patch.V3.Core.RepoPatchV3 name prim wX wY)
instance (GHC.Show.Show name, Darcs.Patch.Witnesses.Show.Show2 prim) => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.V3.Core.RepoPatchV3 name prim wX)
instance (GHC.Show.Show name, Darcs.Patch.Witnesses.Show.Show2 prim) => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.FromPrim.ToPrim (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.Debug.PatchDebug prim => Darcs.Patch.Debug.PatchDebug (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Apply.Apply (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.Format.PatchListFormat (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.FileHunk.IsHunk prim => Darcs.Patch.FileHunk.IsHunk (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.Summary.Summary (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (Darcs.Patch.Invert.Invert prim, Darcs.Patch.Commute.Commute prim, Darcs.Patch.Witnesses.Eq.Eq2 prim) => Darcs.Patch.Unwind.Unwind (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Repair.Check (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Repair.RepairToFL (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Ident.StorableId name, Darcs.Patch.Prim.Class.PrimPatch prim) => Darcs.Patch.Show.ShowPatch (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Ident.StorableId name, Darcs.Patch.Prim.Class.PrimPatch prim) => Darcs.Patch.Show.ShowContextPatch (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Ident.StorableId name, Darcs.Patch.Prim.Class.PrimPatch prim) => Darcs.Patch.Read.ReadPatch (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Ident.StorableId name, Darcs.Patch.Prim.Class.PrimPatch prim) => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
-- | Conflict resolution for RepoPatchV3
module Darcs.Patch.V3.Resolution
instance (Darcs.Patch.Ident.SignedId name, Darcs.Patch.Ident.StorableId name, Darcs.Patch.Prim.Class.PrimPatch prim) => Darcs.Patch.Conflict.Conflict (Darcs.Patch.V3.Core.RepoPatchV3 name prim)
-- | Wrapper for prim patches to give them an identity derived from the
-- identity of the containined Named patch.
module Darcs.Patch.Prim.Named
type NamedPrim = PrimWithName PrimPatchId
-- | Signed patch identity. The SHA1 hash of the non-inverted meta
-- data (PatchInfo) plus an Int for the sequence number
-- within the named patch, starting with 1. The Int gets inverted
-- together with the patch and must never be 0 else we could not
-- distinguish between the patch and its inverse.
data PrimPatchId
namedPrim :: PrimPatchId -> p wX wY -> NamedPrim p wX wY
-- | Create an infinite list of positive PrimPatchIds.
positivePrimPatchIds :: PatchInfo -> [PrimPatchId]
anonymousNamedPrim :: p wX wY -> NamedPrim p wX wY
-- | This should only be used for testing, as it exposes the internal
-- structure of a PrimPatchId.
unsafePrimPatchId :: TestOnly => Int -> SHA1 -> PrimPatchId
prop_primPatchIdNonZero :: PrimPatchId -> Bool
instance GHC.Show.Show Darcs.Patch.Prim.Named.PrimPatchId
instance GHC.Classes.Ord Darcs.Patch.Prim.Named.PrimPatchId
instance GHC.Classes.Eq Darcs.Patch.Prim.Named.PrimPatchId
instance Darcs.Patch.Ident.SignedId Darcs.Patch.Prim.Named.PrimPatchId
instance Darcs.Patch.Ident.StorableId Darcs.Patch.Prim.Named.PrimPatchId
module Darcs.Patch.V3
type RepoPatchV3 = RepoPatchV3 PrimPatchId
instance Darcs.Patch.FromPrim.FromPrim (Darcs.Patch.V3.RepoPatchV3 prim)
module Darcs.Patch.Rebase.Change
data RebaseChange prim wX wY
[RC] :: FL (RebaseFixup prim) wX wY -> Named prim wY wZ -> RebaseChange prim wX wZ
-- | Turn a selected rebase patch back into a patch we can apply to the
-- main repository, together with residual fixups that need to go back
-- into the rebase state (unless the rebase is now finished). Any fixups
-- associated with the patch will turn into conflicts.
extractRebaseChange :: forall p wX wY. RepoPatch p => DiffAlgorithm -> FL (RebaseChange (PrimOf p)) wX wY -> (FL (WDDNamed p) :> FL (RebaseFixup (PrimOf p))) wX wY
-- | Like extractRebaseChange, but any fixups are "reified" into a
-- separate patch.
reifyRebaseChange :: FromPrim p => String -> FL (RebaseChange (PrimOf p)) wX wY -> IO ((FL (WDDNamed p) :> FL (RebaseFixup (PrimOf p))) wX wY)
-- | Split a list of rebase patches into those that will have conflicts if
-- unsuspended and those that won't.
partitionUnconflicted :: Commute prim => FL (RebaseChange prim) wX wY -> (FL (RebaseChange prim) :> RL (RebaseChange prim)) wX wY
-- | Get hold of the Named patch inside a RebaseChange and
-- wrap it in a PatchInfoAnd.
rcToPia :: RebaseChange prim wX wY -> Sealed2 (PatchInfoAnd prim)
-- | A patch, together with a list of patch names that it used to depend
-- on, but were lost during the rebasing process. The UI can use this
-- information to report them to the user.
data WithDroppedDeps p wX wY
WithDroppedDeps :: p wX wY -> [PatchInfo] -> WithDroppedDeps p wX wY
[wddPatch] :: WithDroppedDeps p wX wY -> p wX wY
[wddDependedOn] :: WithDroppedDeps p wX wY -> [PatchInfo]
type WDDNamed p = WithDroppedDeps (Named p)
commuterIdWDD :: CommuteFn p q -> CommuteFn p (WithDroppedDeps q)
-- | Given a list of rebase items, try to push a new fixup as far as
-- possible into the list as possible, using both commutation and
-- coalescing. If the fixup commutes past all the ToEdit patches
-- then it is dropped entirely.
simplifyPush :: PrimPatch prim => DiffAlgorithm -> RebaseFixup prim wX wY -> FL (RebaseChange prim) wY wZ -> Sealed (FL (RebaseChange prim) wX)
-- | Like simplifyPush but for a list of fixups.
simplifyPushes :: PrimPatch prim => DiffAlgorithm -> FL (RebaseFixup prim) wX wY -> FL (RebaseChange prim) wY wZ -> Sealed (FL (RebaseChange prim) wX)
addNamedToRebase :: RepoPatch p => DiffAlgorithm -> Named p wX wY -> FL (RebaseChange (PrimOf p)) wY wZ -> Sealed (FL (RebaseChange (PrimOf p)) wX)
instance Darcs.Patch.Witnesses.Show.Show2 prim => GHC.Show.Show (Darcs.Patch.Rebase.Change.RebaseChange prim wX wY)
instance Darcs.Patch.FromPrim.PrimPatchBase p => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.Rebase.Change.WithDroppedDeps p)
instance Darcs.Patch.Effect.Effect p => Darcs.Patch.Effect.Effect (Darcs.Patch.Rebase.Change.WithDroppedDeps p)
instance Darcs.Patch.Witnesses.Show.Show2 prim => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Rebase.Change.RebaseChange prim wX)
instance Darcs.Patch.Witnesses.Show.Show2 prim => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.FromPrim.PrimPatchBase (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Debug.PatchDebug prim => Darcs.Patch.Debug.PatchDebug (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Named.HasDeps (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Ident.Ident (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Apply.Apply prim => Darcs.Patch.Apply.Apply (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Commute.Commute prim => Darcs.Patch.Summary.Summary (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Show.ShowPatchBasic (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Show.ShowPatch (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Prim.Class.PrimPatch prim => Darcs.Patch.Show.ShowContextPatch (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance (Darcs.Patch.Read.ReadPatch prim, Darcs.Patch.Format.PatchListFormat prim) => Darcs.Patch.Read.ReadPatch (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Commute.Commute prim => Darcs.Patch.Commute.Commute (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Inspect.PatchInspect prim => Darcs.Patch.Inspect.PatchInspect (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.FileHunk.IsHunk (Darcs.Patch.Rebase.Change.RebaseChange prim)
instance Darcs.Patch.Format.PatchListFormat (Darcs.Patch.Rebase.Change.RebaseChange prim)
module Darcs.Patch.Rebase.Legacy.Item
-- | A single item in the rebase state consists of either a patch that is
-- being edited, or a fixup that adjusts the context so that a subsequent
-- patch that is being edited "makes sense".
--
-- ToEdit holds a patch that is being edited. The name
-- (PatchInfo) 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.
data RebaseItem p wX wY
[ToEdit] :: Named p wX wY -> RebaseItem p wX wY
[Fixup] :: RebaseFixup (PrimOf p) wX wY -> RebaseItem p wX wY
toRebaseChanges :: RepoPatch p => FL (RebaseItem p) wX wY -> Sealed (FL (RebaseChange (PrimOf p)) wX)
instance (Darcs.Patch.Witnesses.Show.Show2 p, Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.FromPrim.PrimOf p)) => GHC.Show.Show (Darcs.Patch.Rebase.Legacy.Item.RebaseItem p wX wY)
instance (Darcs.Patch.Witnesses.Show.Show2 p, Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.FromPrim.PrimOf p)) => Darcs.Patch.Witnesses.Show.Show1 (Darcs.Patch.Rebase.Legacy.Item.RebaseItem p wX)
instance (Darcs.Patch.Witnesses.Show.Show2 p, Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.FromPrim.PrimOf p)) => Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.Rebase.Legacy.Item.RebaseItem p)
instance (Darcs.Patch.FromPrim.PrimPatchBase p, Darcs.Patch.Format.PatchListFormat p, Darcs.Patch.Read.ReadPatch p) => Darcs.Patch.Read.ReadPatch (Darcs.Patch.Rebase.Legacy.Item.RebaseItem p)
module Darcs.Patch.Rebase.Suspended
-- | A Suspended patch contains the entire rebase state, in the
-- form of RebaseChanges. The end state is existientially
-- quantified and thus hidden.
data Suspended p wX
[Items] :: FL (RebaseChange (PrimOf p)) wX wY -> Suspended p wX
countToEdit :: Suspended p wX -> Int
simplifyPush :: PrimPatchBase p => DiffAlgorithm -> RebaseFixup (PrimOf p) wX wY -> Suspended p wY -> Suspended p wX
simplifyPushes :: PrimPatchBase p => DiffAlgorithm -> FL (RebaseFixup (PrimOf p)) wX wY -> Suspended p wY -> Suspended p wX
-- | add fixups for the name and effect of a patch to a Suspended
addFixupsToSuspended :: (PrimPatchBase p, Effect p) => Named p wX wY -> Suspended p wY -> Suspended p wX
-- | Remove fixups (actually, add their inverse) for the name and effect of
-- a patch to a Suspended.
removeFixupsFromSuspended :: (PrimPatchBase p, Effect p) => Named p wX wY -> Suspended p wX -> Suspended p wY
-- | Add Named patches for editing to a Suspended. 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.
addToEditsToSuspended :: RepoPatch p => DiffAlgorithm -> FL (Named p) wX wY -> Suspended p wY -> IO (Suspended p wX)
readSuspended :: forall p wX. RepoPatch p => Parser (Suspended p wX)
showSuspended :: PrimPatchBase p => ShowPatchFor -> Suspended p wX -> Doc
instance (Darcs.Patch.Witnesses.Show.Show2 p, Darcs.Patch.Witnesses.Show.Show2 (Darcs.Patch.FromPrim.PrimOf p)) => GHC.Show.Show (Darcs.Patch.Rebase.Suspended.Suspended p wX)
module Darcs.Patch.Rebase.Legacy.Wrapped
-- | A 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.
data WrappedNamed p wX wY
[NormalP] :: !Named p wX wY -> WrappedNamed p wX wY
[RebaseP] :: (PrimPatchBase p, FromPrim p, Effect p) => !PatchInfo -> !Suspended p wX -> WrappedNamed p wX wX
fromRebasing :: WrappedNamed p wX wY -> Named p wX wY
instance Darcs.Patch.RepoPatch.RepoPatch p => Darcs.Patch.Read.ReadPatch (Darcs.Patch.Rebase.Legacy.Wrapped.WrappedNamed p)
instance Darcs.Patch.Format.PatchListFormat p => Darcs.Patch.Format.PatchListFormat (Darcs.Patch.Rebase.Legacy.Wrapped.ReadRebasing p)
instance Darcs.Patch.RepoPatch.RepoPatch p => Darcs.Patch.Read.ReadPatch (Darcs.Patch.Rebase.Legacy.Wrapped.ReadRebasing p)
module Darcs.Repository.Rebase
readTentativeRebase :: RepoPatch p => Repository rt p wU wR -> IO (Suspended p wR)
writeTentativeRebase :: RepoPatch p => Repository rt p wU wR -> Suspended p wR -> IO ()
withTentativeRebase :: RepoPatch p => Repository rt p wU wR -> Repository rt p wU wR' -> (Suspended p wR -> Suspended p wR') -> IO ()
readRebase :: RepoPatch p => Repository rt p wU wR -> IO (Suspended p wR)
finalizeTentativeRebase :: IO ()
revertTentativeRebase :: RepoPatch p => Repository rt p wU wR -> IO ()
withManualRebaseUpdate :: RepoPatch p => Repository rt p wU wR -> (Repository rt p wU wR -> IO (Repository rt p wU wR', FL (RebaseFixup (PrimOf p)) wR' wR, x)) -> IO (Repository rt p wU wR', x)
-- | Fail unless we already have some suspended patches. Not essential,
-- since all rebase commands should be happy to work with an empty rebase
-- state.
checkHasRebase :: Repository rt p wU wR -> IO ()
-- | Report 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.
displayRebaseStatus :: RepoPatch p => Repository rt p wU wR -> IO ()
-- | Rebase format update for all commands that modify the repo, except
-- rebase upgrade. This is called by finalizeRepositoryChanges.
updateRebaseFormat :: RepoPatch p => Repository 'RW p wU wR -> IO ()
extractOldStyleRebase :: forall p wA wB. RepoPatch p => RL (PiaW p) wA wB -> Maybe ((RL (PatchInfoAnd p) :> Dup (Suspended p)) wA wB)
-- | Fail if there is an old-style rebase present. To be called initially
-- for every command except rebase upgrade.
checkOldStyleRebaseStatus :: Repository rt p wU wR -> IO ()
module Darcs.Repository.Hashed
-- | revertTentativeChanges swaps the tentative and "real" hashed inventory
-- files, and then updates the tentative pristine with the "real"
-- inventory hash.
revertTentativeChanges :: Repository 'RO p wU wR -> IO ()
-- | finalizeTentativeChanges trys to atomically swap the tentative
-- inventory/pristine pointers with the "real" pointers; it first
-- re-reads the inventory to optimize it, presumably to take account of
-- any new tags, and then writes out the new tentative inventory, and
-- finally does the atomic swap. In general, we can't clean the pristine
-- cache at the same time, since a simultaneous get might be in progress.
finalizeTentativeChanges :: RepoPatch p => Repository 'RW p wU wR -> IO ()
-- | Add (append) a patch to the tentative inventory. Warning: this allows
-- to add any arbitrary patch! Used by convert import and
-- tentativelyAddPatch_.
addToTentativeInventory :: RepoPatch p => Cache -> PatchInfoAnd p wX wY -> IO ()
-- | Read inventories and patches from a Repository and return them
-- as a PatchSet. Note that patches and inventories are read
-- lazily.
readPatches :: RepoPatch p => Repository rt p wU wR -> IO (PatchSet p Origin wR)
-- | Read the tentative PatchSet of a (hashed) Repository.
readTentativePatches :: (PatchListFormat p, ReadPatch p) => Repository 'RW p wU wR -> IO (PatchSet p Origin wR)
-- | writeAndReadPatch makes a patch lazy, by writing it out to disk (thus
-- forcing it), and then re-reads the patch lazily.
writeAndReadPatch :: RepoPatch p => Cache -> PatchInfoAnd p wX wY -> IO (PatchInfoAnd p wX wY)
-- | Write a PatchSet to the tentative inventory.
writeTentativeInventory :: RepoPatch p => Repository 'RW p wU wR -> PatchSet p Origin wX -> IO ()
-- | Copy the hashed inventory from the given location to the given
-- repository, possibly using the given remote darcs binary.
copyHashedInventory :: Repository 'RO p wU wR -> RemoteDarcs -> String -> IO ()
-- | Write a PatchInfoAnd to disk and return an
-- InventoryEntry 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.
writePatchIfNecessary :: RepoPatch p => Cache -> PatchInfoAnd p wX wY -> IO InventoryEntry
tentativelyAddPatch :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> UpdatePending -> PatchInfoAnd p wR wY -> IO (Repository 'RW p wU wY)
tentativelyRemovePatches :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> UpdatePending -> FL (PatchInfoAnd p) wX wR -> IO (Repository 'RW p wU wX)
tentativelyRemovePatches_ :: (RepoPatch p, ApplyState p ~ Tree) => UpdatePristine -> Repository 'RW p wU wR -> UpdatePending -> FL (PatchInfoAnd p) wX wR -> IO (Repository 'RW p wU wX)
tentativelyAddPatch_ :: (RepoPatch p, ApplyState p ~ Tree) => UpdatePristine -> Repository 'RW p wU wR -> UpdatePending -> PatchInfoAnd p wR wY -> IO (Repository 'RW p wU wY)
tentativelyAddPatches :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> UpdatePending -> FL (PatchInfoAnd p) wR wY -> IO (Repository 'RW p wU wY)
tentativelyAddPatches_ :: (RepoPatch p, ApplyState p ~ Tree) => UpdatePristine -> Repository 'RW p wU wR -> UpdatePending -> FL (PatchInfoAnd p) wR wY -> IO (Repository 'RW p wU wY)
-- | Writes 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 OptimizeShallow 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 OptimizeDeep, 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.
reorderInventory :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> OptimizeDeep -> IO ()
data UpdatePristine
UpdatePristine :: UpdatePristine
DontUpdatePristine :: UpdatePristine
DontUpdatePristineNorRevert :: UpdatePristine
-- | XOR of all hashes of the patches' metadata. It enables to quickly see
-- whether two repositories have the same patches, independently of their
-- order. It relies on the assumption that the same patch cannot be
-- present twice in a repository. This checksum is not cryptographically
-- secure, see http://robotics.stanford.edu/~xb/crypto06b/ .
repoXor :: RepoPatch p => Repository rt p wU wR -> IO SHA1
instance GHC.Classes.Eq Darcs.Repository.Hashed.UpdatePristine
module Darcs.Repository.Transaction
-- | Slightly confusingly named: as well as throwing away any tentative
-- changes, revertRepositoryChanges also re-initialises the tentative
-- state. It's therefore used before makign any changes to the repo.
revertRepositoryChanges :: RepoPatch p => Repository 'RO p wU wR -> IO (Repository 'RW p wU wR)
-- | Atomically 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.
finalizeRepositoryChanges :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> DryRun -> IO (Repository 'RO p wU wR)
-- | Upgrade a possible old-style rebase in progress to the new style.
upgradeOldStyleRebase :: forall p wU wR. (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> IO ()
module Darcs.Repository.Repair
replayRepository :: (RepoPatch p, ApplyState p ~ Tree) => DiffAlgorithm -> Repository rt p wU wR -> Verbosity -> (RepositoryConsistency p wR -> IO a) -> IO a
checkIndex :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> Bool -> IO Bool
replayRepositoryInTemp :: (RepoPatch p, ApplyState p ~ Tree) => DiffAlgorithm -> Repository rt p wU wR -> Verbosity -> IO (RepositoryConsistency p wR)
data RepositoryConsistency p wR
RepositoryConsistency :: Maybe (Tree IO, Sealed (FL (PrimOf p) wR)) -> Maybe (PatchSet p Origin wR) -> Maybe (Sealed (FL (PrimOf p) wR)) -> RepositoryConsistency p wR
[fixedPristine] :: RepositoryConsistency p wR -> Maybe (Tree IO, Sealed (FL (PrimOf p) wR))
[fixedPatches] :: RepositoryConsistency p wR -> Maybe (PatchSet p Origin wR)
[fixedPending] :: RepositoryConsistency p wR -> Maybe (Sealed (FL (PrimOf p) wR))
-- | Packs are an optimization that enable faster repository cloning over
-- HTTP. A pack is actually a tar.gz file that contains many
-- files that would otherwise have to be transfered one by one (which is
-- much slower over HTTP).
--
-- Two packs are created at the same time by createPacks:
--
--
-- - The basic pack, contains the pristine tree.
-- - The patches pack, contains the set of patches of the
-- repository.
--
--
-- The paths of these files are _darcs/packs/basic.tar.gz and
-- _darcs/packs/patches.tar.gz. There is also
-- _darcs/packs/pristine which indicates the pristine hash at
-- the moment of the creation of the packs. This last file is useful to
-- determine whether the basic pack is in sync with the current pristine
-- of the repository.
module Darcs.Repository.Packs
fetchAndUnpackBasic :: Cache -> FilePath -> IO ()
fetchAndUnpackPatches :: [InventoryHash] -> [PatchHash] -> Cache -> FilePath -> IO ()
packsDir :: String
-- | Create packs from the current recorded version of the repository.
createPacks :: RepoPatch p => Repository 'RW p wU wR -> IO ()
module Darcs.Repository.Merge
tentativelyMergePatches :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> String -> AllowConflicts -> WantGuiPause -> Reorder -> DiffOpts -> Fork (PatchSet p) (FL (PatchInfoAnd p)) (FL (PatchInfoAnd p)) Origin wR wY -> IO (Sealed (FL (PrimOf p) wU))
considerMergeToWorking :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> String -> AllowConflicts -> WantGuiPause -> Reorder -> DiffOpts -> Fork (PatchSet p) (FL (PatchInfoAnd p)) (FL (PatchInfoAnd p)) Origin wR wY -> IO (Sealed (FL (PrimOf p) wU))
instance GHC.Classes.Eq Darcs.Repository.Merge.MakeChanges
module Darcs.Repository.Match
-- | Return the pristine tree up to the given PatchSetMatch. 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
-- getOnePatchset to an empty tree.
getPristineUpToMatch :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> PatchSetMatch -> IO (Tree IO)
-- | Return the patches up to the given PatchSetMatch.
getOnePatchset :: RepoPatch p => Repository rt p wU wR -> PatchSetMatch -> IO (SealedPatchSet p Origin)
module Darcs.Repository.Working
applyToWorking :: (ApplyState p ~ Tree, RepoPatch p) => Repository rt p wU wR -> Verbosity -> FL (PrimOf p) wU wY -> IO (Repository rt p wY wR)
setAllScriptsExecutable :: IO ()
setScriptsExecutablePatches :: PatchInspect p => p wX wY -> IO ()
-- | A set of functions to identify and find Darcs repositories from a
-- given URL or a given filesystem path.
module Darcs.Repository.Identify
-- | Try to identify the repository at a given location, passed as a
-- String. 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.
maybeIdentifyRepository :: UseCache -> String -> IO (IdentifyRepo 'RO p wU wR)
-- | identifyRepository identifies the repo at url. Warning: you
-- have to know what kind of patches are found in that repo.
identifyRepository :: UseCache -> String -> IO (Repository 'RO p wU wR)
-- | identifyRepositoryFor repo url identifies (and returns) the
-- repo at url, but fails if it is not compatible for reading
-- from and writing to.
identifyRepositoryFor :: ReadingOrWriting -> Repository rt p wU wR -> UseCache -> String -> IO (Repository 'RO p vR vU)
-- | The status of a given directory: is it a darcs repository?
data IdentifyRepo rt p wU wR
-- | looks like a repository with some error
BadRepository :: String -> IdentifyRepo rt p wU wR
-- | safest guess
NonRepository :: String -> IdentifyRepo rt p wU wR
GoodRepository :: Repository rt p wU wR -> IdentifyRepo rt p wU wR
data ReadingOrWriting
Reading :: ReadingOrWriting
Writing :: ReadingOrWriting
findRepository :: WorkRepo -> IO (Either String ())
amInRepository :: WorkRepo -> IO (Either String ())
amNotInRepository :: WorkRepo -> IO (Either String ())
amInHashedRepository :: WorkRepo -> IO (Either String ())
-- | hunt upwards for the darcs repository This keeps changing up one
-- parent directory, testing at each step if the current directory is a
-- repository or not. The result is: Nothing, if no repository found Just
-- (Left errorMessage), if bad repository found Just (Right ()), if good
-- repository found. WARNING this changes the current directory for good
-- if matchFn succeeds
seekRepo :: IO (Maybe (Either String ()))
module Darcs.Repository.Job
-- | A 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.
data RepoJob rt a
-- | The most common RepoJob; the underlying action can accept any
-- patch whose ApplyState is Tree.
RepoJob :: TreePatchJob rt a -> RepoJob rt a
-- | A job that only works on darcs 1 patches
V1Job :: V1PatchJob rt a -> RepoJob rt a
-- | A job that only works on darcs 2 patches
V2Job :: V2PatchJob rt a -> RepoJob rt a
-- | A job that works on any repository where the patch type p has
-- PrimOf p = Prim. 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.
PrimV1Job :: PrimV1PatchJob rt a -> RepoJob rt a
-- | A job that works even if there is an old-style rebase in progress.
OldRebaseJob :: TreePatchJob rt a -> RepoJob rt a
class IsPrimV1 p
toPrimV1 :: IsPrimV1 p => p wX wY -> Prim wX wY
-- | Apply a given RepoJob to a repository in the current working
-- directory. However, before doing the job, take the repo lock and
-- initializes a repo transaction.
withRepoLock :: UseCache -> UMask -> RepoJob 'RW a -> IO a
-- | run a lock-taking job in an old-fashion repository. only used by
-- `darcs optimize upgrade`.
withOldRepoLock :: RepoJob 'RW a -> IO a
-- | Apply 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.
withRepoLockCanFail :: UseCache -> RepoJob 'RO () -> IO ()
-- | apply a given RepoJob to a repository in the current working directory
withRepository :: UseCache -> RepoJob 'RO a -> IO a
-- | apply a given RepoJob to a repository in a given url
withRepositoryLocation :: UseCache -> String -> RepoJob 'RO a -> IO a
withUMaskFlag :: UMask -> IO a -> IO a
instance Darcs.Repository.Job.IsPrimV1 Darcs.Patch.V1.Prim.Prim
instance Darcs.Repository.Job.IsPrimV1 Darcs.Patch.V2.Prim.Prim
-- | How to complete arguments
module Darcs.UI.Completion
-- | Return all files available under the original working directory
-- regardless of their repo state.
fileArgs :: (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO [FilePath]
-- | Return all files available under the original working directory that
-- are known to darcs (either recorded or pending).
knownFileArgs :: (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO [FilePath]
-- | Return all files available under the original working directory that
-- are unknown to darcs but could be added.
unknownFileArgs :: (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO [FilePath]
-- | Return all files available under the original working directory that
-- are modified (relative to the recorded state).
modifiedFileArgs :: (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO [FilePath]
-- | Return an empty list.
noArgs :: (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO [String]
data Pref
Author :: Pref
Binaries :: Pref
Boring :: Pref
Defaultrepo :: Pref
Defaults :: Pref
Email :: Pref
Motd :: Pref
Post :: Pref
Prefs :: Pref
Repos :: Pref
Sources :: Pref
-- | Return the available prefs of the given kind.
prefArgs :: Pref -> (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO [String]
module Darcs.Repository.Create
createRepository :: PatchFormat -> WithWorkingDir -> WithPatchIndex -> UseCache -> WithPrefsTemplates -> IO EmptyRepository
createRepositoryV1 :: WithWorkingDir -> WithPatchIndex -> UseCache -> WithPrefsTemplates -> IO (Repository 'RO (RepoPatchV1 Prim) Origin Origin)
createRepositoryV2 :: WithWorkingDir -> WithPatchIndex -> UseCache -> WithPrefsTemplates -> IO (Repository 'RO (RepoPatchV2 Prim) Origin Origin)
data EmptyRepository
[EmptyRepository] :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RO p Origin Origin -> EmptyRepository
module Darcs.Repository.Clone
cloneRepository :: String -> String -> Verbosity -> UseCache -> CloneKind -> UMask -> RemoteDarcs -> SetScriptsExecutable -> SetDefault -> InheritDefault -> [MatchFlag] -> RepoFormat -> WithWorkingDir -> WithPatchIndex -> Bool -> ForgetParent -> WithPrefsTemplates -> IO ()
module Darcs.Repository
-- | A Repository is a token representing the state of a
-- repository on disk. It is parameterized by
--
--
-- - rt the access type (whether we are in a
-- transaction or not),
-- - p the patch type,
-- - wU the witness for the unrecorded state (what's in
-- the working tree now).
-- - wR the witness for
- the recorded state when
-- outside a transaction, or
- the tentative state when inside a
-- transaction.
--
data Repository (rt :: AccessType) (p :: * -> * -> *) wU wR
data AccessType
RO :: AccessType
RW :: AccessType
repoLocation :: Repository rt p wU wR -> String
repoFormat :: Repository rt p wU wR -> RepoFormat
repoPristineType :: Repository rt p wU wR -> PristineType
repoCache :: Repository rt p wU wR -> Cache
data PristineType
NoPristine :: PristineType
PlainPristine :: PristineType
HashedPristine :: PristineType
-- | Semantically, 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.
data HashedDir
HashedPristineDir :: HashedDir
HashedPatchesDir :: HashedDir
HashedInventoriesDir :: HashedDir
-- | Cache is an abstract type for hiding the underlying cache locations
data Cache
data CacheLoc
Cache :: !CacheType -> !WritableOrNot -> !String -> CacheLoc
[cacheType] :: CacheLoc -> !CacheType
[cacheWritable] :: CacheLoc -> !WritableOrNot
[cacheSource] :: CacheLoc -> !String
data CacheType
Repo :: CacheType
Directory :: CacheType
data WritableOrNot
Writable :: WritableOrNot
NotWritable :: WritableOrNot
cacheEntries :: Cache -> [CacheLoc]
-- | Smart constructor for CacheLoc.
mkCache :: [CacheLoc] -> Cache
-- | Prints an error message with a list of bad caches.
reportBadSources :: IO ()
-- | A 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.
data RepoJob rt a
-- | The most common RepoJob; the underlying action can accept any
-- patch whose ApplyState is Tree.
RepoJob :: TreePatchJob rt a -> RepoJob rt a
-- | A job that only works on darcs 1 patches
V1Job :: V1PatchJob rt a -> RepoJob rt a
-- | A job that only works on darcs 2 patches
V2Job :: V2PatchJob rt a -> RepoJob rt a
-- | A job that works on any repository where the patch type p has
-- PrimOf p = Prim. 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.
PrimV1Job :: PrimV1PatchJob rt a -> RepoJob rt a
-- | A job that works even if there is an old-style rebase in progress.
OldRebaseJob :: TreePatchJob rt a -> RepoJob rt a
-- | Try to identify the repository at a given location, passed as a
-- String. 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.
maybeIdentifyRepository :: UseCache -> String -> IO (IdentifyRepo 'RO p wU wR)
-- | identifyRepositoryFor repo url identifies (and returns) the
-- repo at url, but fails if it is not compatible for reading
-- from and writing to.
identifyRepositoryFor :: ReadingOrWriting -> Repository rt p wU wR -> UseCache -> String -> IO (Repository 'RO p vR vU)
data ReadingOrWriting
Reading :: ReadingOrWriting
Writing :: ReadingOrWriting
-- | Apply a given RepoJob to a repository in the current working
-- directory. However, before doing the job, take the repo lock and
-- initializes a repo transaction.
withRepoLock :: UseCache -> UMask -> RepoJob 'RW a -> IO a
-- | Apply 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.
withRepoLockCanFail :: UseCache -> RepoJob 'RO () -> IO ()
-- | apply a given RepoJob to a repository in the current working directory
withRepository :: UseCache -> RepoJob 'RO a -> IO a
-- | apply a given RepoJob to a repository in a given url
withRepositoryLocation :: UseCache -> String -> RepoJob 'RO a -> IO a
withUMaskFlag :: UMask -> IO a -> IO a
findRepository :: WorkRepo -> IO (Either String ())
amInRepository :: WorkRepo -> IO (Either String ())
amNotInRepository :: WorkRepo -> IO (Either String ())
amInHashedRepository :: WorkRepo -> IO (Either String ())
-- | Replace 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!
writePristine :: Repository rt p wU wR -> Tree IO -> IO PristineHash
-- | Read inventories and patches from a Repository and return them
-- as a PatchSet. Note that patches and inventories are read
-- lazily.
readPatches :: RepoPatch p => Repository rt p wU wR -> IO (PatchSet p Origin wR)
prefsUrl :: String -> Pref -> String
-- | Add an FL of patches starting from the working state to the
-- pending patch, including as much extra context as is necessary
-- (context meaning dependencies), by commuting the patches to be added
-- past as much of the changes between pending and working as is
-- possible, and including anything that doesn't commute, and the patch
-- itself in the new pending patch.
addToPending :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> DiffOpts -> FL (PrimOf p) wU wY -> IO ()
-- | Add an FL of patches started from the pending state to the
-- pending patch.
unsafeAddToPending :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> FreeLeft (FL (PrimOf p)) -> IO ()
tentativelyAddPatch :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> UpdatePending -> PatchInfoAnd p wR wY -> IO (Repository 'RW p wU wY)
tentativelyAddPatches :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> UpdatePending -> FL (PatchInfoAnd p) wR wY -> IO (Repository 'RW p wU wY)
tentativelyRemovePatches :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> UpdatePending -> FL (PatchInfoAnd p) wX wR -> IO (Repository 'RW p wU wX)
-- | Overwrites the pending patch with a new one, starting at the tentative
-- state.
setTentativePending :: forall p wU wR wP. RepoPatch p => Repository 'RW p wU wR -> FL (PrimOf p) wR wP -> IO ()
-- | Remove 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.
tentativelyRemoveFromPW :: forall p wR wO wP wU. RepoPatch p => Repository 'RW p wU wR -> FL (PrimOf p) wO wR -> FL (PrimOf p) wO wP -> FL (PrimOf p) wP wU -> IO ()
withManualRebaseUpdate :: RepoPatch p => Repository rt p wU wR -> (Repository rt p wU wR -> IO (Repository rt p wU wR', FL (RebaseFixup (PrimOf p)) wR' wR, x)) -> IO (Repository rt p wU wR', x)
tentativelyMergePatches :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> String -> AllowConflicts -> WantGuiPause -> Reorder -> DiffOpts -> Fork (PatchSet p) (FL (PatchInfoAnd p)) (FL (PatchInfoAnd p)) Origin wR wY -> IO (Sealed (FL (PrimOf p) wU))
considerMergeToWorking :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> String -> AllowConflicts -> WantGuiPause -> Reorder -> DiffOpts -> Fork (PatchSet p) (FL (PatchInfoAnd p)) (FL (PatchInfoAnd p)) Origin wR wY -> IO (Sealed (FL (PrimOf p) wU))
-- | Slightly confusingly named: as well as throwing away any tentative
-- changes, revertRepositoryChanges also re-initialises the tentative
-- state. It's therefore used before makign any changes to the repo.
revertRepositoryChanges :: RepoPatch p => Repository 'RO p wU wR -> IO (Repository 'RW p wU wR)
data UpdatePending
YesUpdatePending :: UpdatePending
NoUpdatePending :: UpdatePending
-- | Atomically 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.
finalizeRepositoryChanges :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> DryRun -> IO (Repository 'RO p wU wR)
createRepository :: PatchFormat -> WithWorkingDir -> WithPatchIndex -> UseCache -> WithPrefsTemplates -> IO EmptyRepository
createRepositoryV1 :: WithWorkingDir -> WithPatchIndex -> UseCache -> WithPrefsTemplates -> IO (Repository 'RO (RepoPatchV1 Prim) Origin Origin)
createRepositoryV2 :: WithWorkingDir -> WithPatchIndex -> UseCache -> WithPrefsTemplates -> IO (Repository 'RO (RepoPatchV2 Prim) Origin Origin)
data EmptyRepository
[EmptyRepository] :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RO p Origin Origin -> EmptyRepository
cloneRepository :: String -> String -> Verbosity -> UseCache -> CloneKind -> UMask -> RemoteDarcs -> SetScriptsExecutable -> SetDefault -> InheritDefault -> [MatchFlag] -> RepoFormat -> WithWorkingDir -> WithPatchIndex -> Bool -> ForgetParent -> WithPrefsTemplates -> IO ()
applyToWorking :: (ApplyState p ~ Tree, RepoPatch p) => Repository rt p wU wR -> Verbosity -> FL (PrimOf p) wU wY -> IO (Repository rt p wY wR)
-- | Write the pristine tree into a plain directory at the given path.
createPristineDirectoryTree :: Repository rt p wU wR -> FilePath -> WithWorkingDir -> IO ()
-- | Writes 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 OptimizeShallow 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 OptimizeDeep, 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.
reorderInventory :: (RepoPatch p, ApplyState p ~ Tree) => Repository 'RW p wU wR -> OptimizeDeep -> IO ()
cleanRepository :: Repository 'RW p wU wR -> IO ()
-- | The patches in a repository are stored in chunks broken up at "clean"
-- tags. A tag is clean if the only patches before it in the current
-- repository ordering are ones that the tag depends on (either directly
-- or indirectly). Each chunk is stored in a separate inventory file on
-- disk.
--
-- A PatchSet 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
-- PatchSet contains the whole history, the first witness is
-- always forced to be Origin. 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.
data PatchSet p wStart wY
type SealedPatchSet p wStart = Sealed ((PatchSet p) wStart)
type PatchInfoAnd p = PatchInfoAndG (Named p)
setAllScriptsExecutable :: IO ()
setScriptsExecutablePatches :: PatchInspect p => p wX wY -> IO ()
modifyCache :: (Cache -> Cache) -> Repository rt p wU wR -> Repository rt p wU wR
-- | Obtains a Tree corresponding to the "recorded" state of the
-- repository: this is the same as the pristine cache, which is the same
-- as the result of applying all the repository's patches to an empty
-- directory.
readPristine :: Repository rt p wU wR -> IO (Tree IO)
-- | Obtains a Tree corresponding to the "unrecorded" state of the
-- repository: the modified files of the working tree plus the "pending"
-- patch. The optional list of paths allows to restrict the query to a
-- subtree.
--
-- Limiting the query may be more efficient, since hashes on the
-- uninteresting parts of the index do not need to go through an
-- up-to-date check (which involves a relatively expensive lstat(2) per
-- file.
readUnrecorded :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> UseIndex -> Maybe [AnchoredPath] -> IO (Tree IO)
-- | For a repository and an optional list of paths (when Nothing,
-- 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.
unrecordedChanges :: (RepoPatch p, ApplyState p ~ Tree) => DiffOpts -> Repository rt p wU wR -> Maybe [AnchoredPath] -> IO (FL (PrimOf p) wR wU)
readPendingAndWorking :: (RepoPatch p, ApplyState p ~ Tree) => DiffOpts -> Repository rt p wU wR -> Maybe [AnchoredPath] -> IO ((FL (PrimOf p) :> FL (PrimOf p)) wR wU)
-- | Remove any patches (+dependencies) from a sequence that conflict with
-- the recorded or unrecorded changes in a repo
filterOutConflicts :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> UseIndex -> FL (PatchInfoAnd p) wX wR -> FL (PatchInfoAnd p) wX wZ -> IO (Bool, Sealed (FL (PatchInfoAnd p) wX))
-- | Obtains the recorded Tree with the pending patch applied.
readPristineAndPending :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> IO (Tree IO)
module Darcs.UI.Commands.Test.Impl
-- | An indexed monad that can be used to run tests. TestingEnvIO is
-- the only real implementation, the unit tests for testing are based on
-- mock implementations.
class Monad m => TestRunner m where {
type ApplyPatchReqs m (p :: * -> * -> *) :: Constraint;
type DisplayPatchReqs m (p :: * -> * -> *) :: Constraint;
}
-- | Output a message
writeMsg :: TestRunner m => String -> m wX wX ()
-- | Output a message containing the name of a patch
mentionPatch :: (TestRunner m, DisplayPatchReqs m p) => p wA wB -> m wX wX ()
-- | Apply a patch to the testing tree.
applyPatch :: (TestRunner m, ApplyPatchReqs m p) => p wX wY -> m wX wY ()
-- | Unapply a patch from the testing tree
unapplyPatch :: (TestRunner m, ApplyPatchReqs m p) => p wX wY -> m wY wX ()
-- | Get the current status (passskipfail) of the testing tree, e.g.
-- by running the test command.
getCurrentTestResult :: TestRunner m => m wX wX (TestResult wX)
-- | Flag that all testing has completed.
finishedTesting :: TestRunner m => a -> m wX TestingDone a
runStrategy :: TestablePatch m p => TestStrategy -> ShrinkFailure -> RL p wOlder wNewer -> m wNewer TestingDone (StrategyResultSealed p)
-- | The result of running a test on state wX of the repository.
data TestResult wX
-- | We got a usable test result.
Testable :: TestResultValid wX -> TestResult wX
-- | The 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.
Untestable :: TestResult wX
-- | A usable test result, i.e. not an untestable state.
data TestResultValid wX
-- | The test passed.
Success :: TestResultValid wX
-- | The test failed with the given exit code.
Failure :: TestFailure wX -> TestResultValid wX
data TestFailure wX
TestFailure :: Int -> TestFailure wX
-- | Once 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.
data TestingDone
-- | PatchSeq 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.
data PatchSeq p wX wY
[Single] :: p wX wY -> PatchSeq p wX wY
[Joined] :: PatchSeq p wX wY -> PatchSeq p wY wZ -> PatchSeq p wX wZ
patchTreeToFL :: PatchSeq p wX wY -> FL p wX wY
type StrategyResult p wSuccess wFailure = StrategyResultRaw (PatchSeq p wSuccess wFailure)
-- | The result of running a test strategy.
data StrategyResultRaw patches
-- | The chosen strategy didn't find any passing states in the repository.
NoPasses :: StrategyResultRaw patches
-- | The test didn't fail on head so there's no failure to track down.
NoFailureOnHead :: StrategyResultRaw patches
-- | The failure was tracked down to the given patches. these two are just
-- for oneTest
Blame :: patches -> StrategyResultRaw patches
-- | The single test run passed.
RunSuccess :: StrategyResultRaw patches
-- | The single test run failed with the given exit code.
RunFailed :: Int -> StrategyResultRaw patches
explanatoryTextFor :: TestStrategy -> String
runTestingEnv :: TestingParams -> TestingEnv m wA TestingDone a -> m a
exitCodeToTestResult :: ExitCode -> TestResult wX
mkTestCmd :: (forall (wX :: *). IO (TestResult wX)) -> TestCmd
runTestable :: (Commute p, TestRunner (TestingEnv m), TestRunnerPatchReqs (TestingEnv m) p) => SetScriptsExecutable -> TestCmd -> TestStrategy -> ShrinkFailure -> RL p wStart wA -> m (StrategyResultSealed p)
instance GHC.Base.Functor Darcs.UI.Commands.Test.Impl.StrategyResultRaw
instance GHC.Show.Show patches => GHC.Show.Show (Darcs.UI.Commands.Test.Impl.StrategyResultRaw patches)
instance GHC.Classes.Eq patches => GHC.Classes.Eq (Darcs.UI.Commands.Test.Impl.StrategyResultRaw patches)
instance GHC.Base.Monad m => Darcs.Util.IndexedMonad.Monad (Darcs.UI.Commands.Test.Impl.TestingEnv m)
instance GHC.Base.Monad m => Darcs.Util.IndexedMonad.MonadReader Darcs.UI.Commands.Test.Impl.TestingParams (Darcs.UI.Commands.Test.Impl.TestingEnv m)
instance Darcs.Patch.Witnesses.Show.Show2 p => GHC.Show.Show (Darcs.UI.Commands.Test.Impl.PatchSeq p wX wY)
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show1 (Darcs.UI.Commands.Test.Impl.PatchSeq p wX)
instance Darcs.Patch.Witnesses.Show.Show2 p => Darcs.Patch.Witnesses.Show.Show2 (Darcs.UI.Commands.Test.Impl.PatchSeq p)
instance Darcs.Patch.Apply.Apply p => Darcs.Patch.Apply.Apply (Darcs.UI.Commands.Test.Impl.PatchSeq p)
instance Darcs.Patch.Inspect.PatchInspect p => Darcs.Patch.Inspect.PatchInspect (Darcs.UI.Commands.Test.Impl.PatchSeq p)
instance Darcs.UI.Commands.Test.Impl.TestRunner Darcs.UI.Commands.Test.Impl.TestingEnvIO
instance Darcs.Util.IndexedMonad.LiftIx Darcs.UI.Commands.Test.Impl.TestingEnv
instance GHC.Base.Monad m => Darcs.Util.IndexedMonad.Monad (Darcs.UI.Commands.Test.Impl.Testing m)
instance Darcs.Util.IndexedMonad.LiftIx Darcs.UI.Commands.Test.Impl.Testing
module Darcs.UI.Commands
data CommandControl
CommandData :: DarcsCommand -> CommandControl
HiddenCommand :: DarcsCommand -> CommandControl
GroupName :: String -> CommandControl
-- | A DarcsCommand represents a command like add, record etc.
data DarcsCommand
DarcsCommand :: String -> Doc -> String -> Int -> [String] -> ((AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO ()) -> ([DarcsFlag] -> IO (Either String ())) -> ((AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO [String]) -> ([DarcsFlag] -> AbsolutePath -> [String] -> IO [String]) -> CommandOptions -> DarcsCommand
[commandProgramName, commandName] :: DarcsCommand -> String
[commandHelp] :: DarcsCommand -> Doc
[commandDescription] :: DarcsCommand -> String
[commandExtraArgs] :: DarcsCommand -> Int
[commandExtraArgHelp] :: DarcsCommand -> [String]
[commandCommand] :: DarcsCommand -> (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO ()
[commandPrereq] :: DarcsCommand -> [DarcsFlag] -> IO (Either String ())
[commandCompleteArgs] :: DarcsCommand -> (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO [String]
[commandArgdefaults] :: DarcsCommand -> [DarcsFlag] -> AbsolutePath -> [String] -> IO [String]
[commandOptions] :: DarcsCommand -> CommandOptions
SuperCommand :: String -> Doc -> String -> ([DarcsFlag] -> IO (Either String ())) -> [CommandControl] -> DarcsCommand
[commandProgramName, commandName] :: DarcsCommand -> String
[commandHelp] :: DarcsCommand -> Doc
[commandDescription] :: DarcsCommand -> String
[commandPrereq] :: DarcsCommand -> [DarcsFlag] -> IO (Either String ())
[commandSubCommands] :: DarcsCommand -> [CommandControl]
commandAlias :: String -> Maybe DarcsCommand -> DarcsCommand -> DarcsCommand
commandStub :: String -> Doc -> String -> DarcsCommand -> DarcsCommand
-- | Construct CommandOptions from the command specific basic and
-- advanced DarcsOptions
withStdOpts :: DarcsOption (Maybe StdCmdAction -> Verbosity -> b) c -> DarcsOption (UseCache -> UseIndex -> HooksConfig -> Bool -> Bool -> [DarcsFlag]) b -> CommandOptions
-- | Option descriptions as required by getOpt, i.e. resolved with
-- the given AbsolutePath.
commandOptDescr :: AbsolutePath -> DarcsCommand -> [OptDescr DarcsFlag]
-- | Option descriptions split into basic and advanced options
commandAlloptions :: DarcsCommand -> ([DarcsOptDescr DarcsFlag], [DarcsOptDescr DarcsFlag])
-- | Built-in default values for all DarcsFlags supported by the
-- given command
commandDefaults :: DarcsCommand -> [DarcsFlag]
-- | For the given DarcsCommand check the given DarcsFlags
-- for consistency
commandCheckOptions :: DarcsCommand -> [DarcsFlag] -> [OptMsg]
disambiguateCommands :: [CommandControl] -> String -> [String] -> Either String (CommandArgs, [String])
data CommandArgs
CommandOnly :: DarcsCommand -> CommandArgs
SuperCommandOnly :: DarcsCommand -> CommandArgs
SuperCommandSub :: DarcsCommand -> DarcsCommand -> CommandArgs
getSubcommands :: DarcsCommand -> [CommandControl]
extractCommands :: [CommandControl] -> [DarcsCommand]
extractAllCommands :: [CommandControl] -> [DarcsCommand]
normalCommand :: DarcsCommand -> CommandControl
hiddenCommand :: DarcsCommand -> CommandControl
commandGroup :: String -> CommandControl
superName :: Maybe DarcsCommand -> String
nodefaults :: [DarcsFlag] -> AbsolutePath -> [String] -> IO [String]
putInfo :: [DarcsFlag] -> Doc -> IO ()
putVerbose :: [DarcsFlag] -> Doc -> IO ()
putWarning :: [DarcsFlag] -> Doc -> IO ()
putVerboseWarning :: [DarcsFlag] -> Doc -> IO ()
putFinished :: [DarcsFlag] -> String -> IO ()
abortRun :: [DarcsFlag] -> Doc -> IO ()
-- | Set the DARCS_PATCHES and DARCS_PATCHES_XML environment variables with
-- info about the given patches, for use in post-hooks.
setEnvDarcsPatches :: RepoPatch p => FL (PatchInfoAnd p) wX wY -> IO ()
-- | Set the DARCS_FILES environment variable to the files touched by the
-- given patch, one per line, for use in post-hooks.
setEnvDarcsFiles :: PatchInspect p => p wX wY -> IO ()
-- | To use for commandArgdefaults field.
defaultRepo :: [DarcsFlag] -> AbsolutePath -> [String] -> IO [String]
amInHashedRepository :: [DarcsFlag] -> IO (Either String ())
amInRepository :: [DarcsFlag] -> IO (Either String ())
amNotInRepository :: [DarcsFlag] -> IO (Either String ())
findRepository :: [DarcsFlag] -> IO (Either String ())
module Darcs.UI.Usage
getCommandHelp :: Maybe DarcsCommand -> DarcsCommand -> Doc
getSuperCommandHelp :: DarcsCommand -> Doc
getCommandMiniHelp :: Maybe DarcsCommand -> DarcsCommand -> String
usage :: [CommandControl] -> Doc
subusage :: DarcsCommand -> Doc
module Darcs.UI.TestChanges
testTree :: Config -> Tree IO -> IO ExitCode
module Darcs.UI.Commands.Util
announceFiles :: Verbosity -> Maybe [AnchoredPath] -> String -> IO ()
-- | Given a repository and two common command options, classify the given
-- list of paths according to whether they exist in the pristine or
-- working tree. Paths which are neither in working nor pristine are
-- reported and dropped. The result is a pair of path lists: those that
-- exist only in the working tree, and those that exist in pristine or
-- working.
filterExistingPaths :: (RepoPatch p, ApplyState p ~ Tree) => Repository rt p wU wR -> Verbosity -> DiffOpts -> [AnchoredPath] -> IO ([AnchoredPath], [AnchoredPath])
testTentativeAndMaybeExit :: Tree IO -> [DarcsFlag] -> String -> String -> Maybe String -> IO ()
-- | printDryRunMessageAndExit 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" flags is the list of flags which
-- were sent to darcs patches is the sequence of patches which
-- would be touched by action.
printDryRunMessageAndExit :: RepoPatch p => String -> Verbosity -> WithSummary -> DryRun -> XmlOutput -> Bool -> FL (PatchInfoAnd p) wX wY -> IO ()
getUniqueRepositoryName :: Bool -> FilePath -> IO FilePath
getUniqueDPatchName :: FilePath -> IO FilePath
doesDirectoryReallyExist :: FilePath -> IO Bool
checkUnrelatedRepos :: RepoPatch p => Bool -> PatchSet p Origin wX -> PatchSet p Origin wY -> IO ()
preselectPatches :: RepoPatch p => [DarcsFlag] -> Repository rt p wU wR -> IO ((PatchSet p :> FL (PatchInfoAnd p)) Origin wR)
getLastPatches :: RepoPatch p => [MatchFlag] -> PatchSet p Origin wR -> (PatchSet p :> FL (PatchInfoAnd p)) Origin wR
matchRange :: MatchableRP p => [MatchFlag] -> PatchSet p Origin wY -> Sealed2 (FL (PatchInfoAnd p))
historyEditHelp :: Doc
commonHelpWithPrefsTemplates :: Doc
module Darcs.UI.Commands.WhatsNew
whatsnew :: DarcsCommand
-- | An alias for whatsnew, with implicit -l (and thus
-- implicit -s) flags. We override the default description, to
-- include these flags.
status :: DarcsCommand
module Darcs.UI.Commands.Unrevert
unrevert :: DarcsCommand
module Darcs.UI.Commands.Unrecord
unrecord :: DarcsCommand
unpull :: DarcsCommand
obliterate :: DarcsCommand
module Darcs.UI.Commands.TransferMode
transferMode :: DarcsCommand
module Darcs.UI.Commands.Test
test :: DarcsCommand
module Darcs.UI.Commands.Tag
tag :: DarcsCommand
module Darcs.UI.Commands.ShowTags
showTags :: DarcsCommand
module Darcs.UI.Commands.ShowRepo
showRepo :: DarcsCommand
module Darcs.UI.Commands.ShowPatchIndex
showPatchIndex :: DarcsCommand
module Darcs.UI.Commands.ShowIndex
showIndex :: DarcsCommand
showPristine :: DarcsCommand
module Darcs.UI.Commands.ShowFiles
showFiles :: DarcsCommand
module Darcs.UI.Commands.ShowDependencies
showDeps :: DarcsCommand
module Darcs.UI.Commands.ShowContents
showContents :: DarcsCommand
module Darcs.UI.Commands.ShowAuthors
showAuthors :: DarcsCommand
data Spelling
compiledAuthorSpellings :: [DarcsFlag] -> IO [Spelling]
canonizeAuthor :: [Spelling] -> String -> String
rankAuthors :: [Spelling] -> [String] -> [String]
module Darcs.UI.Commands.Show
showCommand :: DarcsCommand
module Darcs.UI.Commands.SetPref
setpref :: DarcsCommand
module Darcs.UI.Commands.Rollback
rollback :: DarcsCommand
module Darcs.UI.Commands.Revert
revert :: DarcsCommand
-- | An alias for 'revert -l' i.e. remove every (non-boring) file or change
-- that is not in pristine.
clean :: DarcsCommand
module Darcs.UI.Commands.Replace
replace :: DarcsCommand
defaultToks :: String
module Darcs.UI.Commands.Repair
repair :: DarcsCommand
-- | check is an alias for repair, with implicit DryRun flag.
check :: DarcsCommand
module Darcs.UI.Commands.Remove
remove :: DarcsCommand
rm :: DarcsCommand
unadd :: DarcsCommand
module Darcs.UI.Commands.Record
record :: DarcsCommand
-- | commit is an alias for record
commit :: DarcsCommand
module Darcs.UI.Commands.Optimize
optimize :: DarcsCommand
module Darcs.UI.Commands.Move
move :: DarcsCommand
mv :: DarcsCommand
instance GHC.Classes.Eq Darcs.UI.Commands.Move.FileKind
instance GHC.Show.Show Darcs.UI.Commands.Move.FileKind
instance GHC.Show.Show Darcs.UI.Commands.Move.FileStatus
module Darcs.UI.Commands.MarkConflicts
markconflicts :: DarcsCommand
instance GHC.Show.Show a => GHC.Show.Show (Darcs.UI.Commands.MarkConflicts.Only a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Darcs.UI.Commands.MarkConflicts.Only a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Darcs.UI.Commands.MarkConflicts.Only a)
instance GHC.Base.Functor Darcs.UI.Commands.MarkConflicts.Only
instance Data.Foldable.Foldable Darcs.UI.Commands.MarkConflicts.Only
instance Data.Traversable.Traversable Darcs.UI.Commands.MarkConflicts.Only
module Darcs.UI.Commands.Log
-- | changes is an alias for log
changes :: DarcsCommand
log :: DarcsCommand
changelog :: forall p wStart wX. (ShowPatch p, PatchListFormat p, Summary p, HasDeps p, PrimDetails (PrimOf p)) => [DarcsFlag] -> RL (PatchInfoAndG p) wStart wX -> LogInfo (PatchInfoAndG p) -> Doc
logInfoFL :: FL p wX wY -> LogInfo p
simpleLogInfo :: (MatchableRP p, ApplyState p ~ Tree) => AnchoredPath -> PatchFilter p -> PatchSet p Origin wY -> IO [Sealed2 (PatchInfoAnd p)]
module Darcs.UI.Commands.Init
initialize :: DarcsCommand
initializeCmd :: (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO ()
module Darcs.UI.Commands.GZCRCs
gzcrcs :: DarcsCommand
-- | This is designed for use in an atexit handler, e.g. in
-- Darcs.RunCommand
doCRCWarnings :: Bool -> IO ()
module Darcs.UI.Commands.Dist
dist :: DarcsCommand
doFastZip :: [DarcsFlag] -> IO ()
doFastZip' :: [DarcsFlag] -> FilePath -> (ByteString -> IO a) -> IO a
module Darcs.UI.Commands.Diff
diffCommand :: DarcsCommand
module Darcs.UI.Commands.Convert.Import
convertImport :: DarcsCommand
instance GHC.Show.Show Darcs.UI.Commands.Convert.Import.RefId
instance GHC.Show.Show Darcs.UI.Commands.Convert.Import.CopyRenameNames
instance GHC.Show.Show Darcs.UI.Commands.Convert.Import.Object
instance GHC.Show.Show (Darcs.UI.Commands.Convert.Import.State p)
module Darcs.UI.Commands.Convert.Export
convertExport :: DarcsCommand
cleanPatchAuthor :: String -> String
cleanPatchAuthorTestCases :: [(String, String)]
module Darcs.UI.Commands.Convert.Darcs2
convertDarcs2 :: DarcsCommand
module Darcs.UI.Commands.Convert
convert :: DarcsCommand
module Darcs.UI.Commands.Clone
get :: DarcsCommand
put :: DarcsCommand
clone :: DarcsCommand
makeRepoName :: Bool -> [DarcsFlag] -> FilePath -> IO String
cloneToSSH :: [DarcsFlag] -> Maybe String
otherHelpInheritDefault :: Doc
module Darcs.UI.Commands.Send
send :: DarcsCommand
module Darcs.UI.Commands.Push
push :: DarcsCommand
module Darcs.UI.Commands.Annotate
annotate :: DarcsCommand
module Darcs.UI.Commands.Amend
amend :: DarcsCommand
amendrecord :: DarcsCommand
module Darcs.UI.Commands.Add
add :: DarcsCommand
module Darcs.UI.ApplyPatches
-- | This class is a hack to abstract over pullapply and rebase
-- pullapply.
class PatchApplier pa
repoJob :: PatchApplier pa => pa -> (forall p wR wU. (RepoPatch p, ApplyState p ~ Tree) => PatchProxy p -> Repository 'RW p wU wR -> IO ()) -> RepoJob 'RW ()
applyPatches :: forall p wR wU wZ. (PatchApplier pa, RepoPatch p, ApplyState p ~ Tree) => pa -> PatchProxy p -> String -> [DarcsFlag] -> Repository 'RW p wU wR -> Fork (PatchSet p) (FL (PatchInfoAnd p)) (FL (PatchInfoAnd p)) Origin wR wZ -> IO ()
data PatchProxy (p :: * -> * -> *)
PatchProxy :: PatchProxy (p :: * -> * -> *)
data StandardPatchApplier
StandardPatchApplier :: StandardPatchApplier
applyPatchesStart :: (RepoPatch p, ApplyState p ~ Tree) => String -> [DarcsFlag] -> FL (PatchInfoAnd p) wX wY -> IO ()
applyPatchesFinish :: (RepoPatch p, ApplyState p ~ Tree) => String -> [DarcsFlag] -> Repository 'RW p wU wR -> FL (PrimOf p) wU wY -> Bool -> IO ()
instance Darcs.UI.ApplyPatches.PatchApplier Darcs.UI.ApplyPatches.StandardPatchApplier
module Darcs.UI.Commands.Pull
pull :: DarcsCommand
fetch :: DarcsCommand
pullCmd :: PatchApplier pa => pa -> (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO ()
data StandardPatchApplier
fetchPatches :: (RepoPatch p, ApplyState p ~ Tree) => AbsolutePath -> [DarcsFlag] -> [String] -> String -> Repository 'RW p wU wR -> IO (Sealed (Fork (PatchSet p) (FL (PatchInfoAnd p)) (FL (PatchInfoAnd p)) Origin wR))
module Darcs.UI.Commands.Apply
apply :: DarcsCommand
applyCmd :: PatchApplier pa => pa -> (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO ()
getPatchBundle :: RepoPatch p => [DarcsFlag] -> PatchSet p Origin wR -> ByteString -> IO (Either String (SealedPatchSet p Origin))
module Darcs.UI.Commands.Rebase
rebase :: DarcsCommand
instance Darcs.UI.ApplyPatches.PatchApplier Darcs.UI.Commands.Rebase.RebasePatchApplier
module Darcs.UI.TheCommands
-- | The commands that darcs knows about (e.g. whatsnew, record), organized
-- into thematic groups. Note that hidden commands are also listed here.
commandControlList :: [CommandControl]
module Darcs.UI.Defaults
-- | Apply defaults from all sources to a list of DarcsFlags (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,
-- - the 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.
applyDefaults :: Maybe String -> DarcsCommand -> AbsolutePath -> [String] -> [String] -> [DarcsFlag] -> ([DarcsFlag], ([String], [String]))
-- | This is the actual heavy lifter code, which is responsible for parsing
-- the arguments and then running the command itself.
module Darcs.UI.RunCommand
runTheCommand :: [CommandControl] -> String -> [String] -> IO ()
runWithHooks :: DarcsCommand -> (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO ()
module Darcs.UI.Commands.Help
helpCmd :: (AbsolutePath, AbsolutePath) -> [DarcsFlag] -> [String] -> IO ()
commandControlList :: [CommandControl]
printVersion :: IO ()
listAvailableCommands :: IO ()