{-| 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
    ( MatchFlag(..) -- re-export
    , matchUpToOne
    , matchOneContext
    , matchOneNontag
    , matchSeveral
    , matchSeveralOrFirst
    , matchSeveralOrLast
    , matchRange
    , matchOneOrRange
    , matchSeveralOrRange
    -- * exported for for checking
    , context
    , matchLast
    , matchFrom
    , matchAny -- temporary hack
    ) where

import Darcs.Prelude hiding ( last )

import Darcs.Patch.Match ( MatchFlag(..) )
import qualified Darcs.UI.Options.Flags as F ( DarcsFlag(..) )
import Darcs.UI.Options.Core
import Darcs.UI.Options.Util

-- * Type instantiations

type MatchOption = PrimDarcsOption [MatchFlag]

-- * Combined matching options

matchUpToOne :: MatchOption -- ^ show files/contents, dist, annotate
matchUpToOne :: MatchOption
matchUpToOne = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
match, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tag, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
index]

-- | Used by: clone
matchOneContext :: MatchOption
matchOneContext :: MatchOption
matchOneContext = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toMatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toPatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toHash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tag, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
context]

-- [NOTE --index removed from matchOneNontag because issue1926]
-- The --index option was removed for 2.5 release because it isn't handled
-- by amend-record (see issue1926).
--
-- At this moment, amend-record is the only command that uses 'matchOneNontag',
-- so there is no other command affected.

-- | Used by: amend
matchOneNontag :: MatchOption
matchOneNontag :: MatchOption
matchOneNontag =  PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
match PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patch PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash

-- | Used by: rebase pull/apply, send, push, pull, apply, fetch
matchSeveral :: MatchOption
matchSeveral :: MatchOption
matchSeveral = PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matches PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patches PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tags PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash

matchLast :: MatchOption
matchLast :: MatchOption
matchLast = PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last

-- | Used by: rebase unsuspend/reify
matchSeveralOrFirst :: MatchOption
matchSeveralOrFirst :: MatchOption
matchSeveralOrFirst = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchTo, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tags, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash ]

-- | Used by: unrecord, obliterate, rebase suspend, rollback
matchSeveralOrLast :: MatchOption
matchSeveralOrLast :: MatchOption
matchSeveralOrLast = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchFrom, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tags, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash ]

-- | Used by: diff
matchOneOrRange :: MatchOption
matchOneOrRange :: MatchOption
matchOneOrRange = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
match, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash ] PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchRange

-- | Used by: show dependencies
matchRange :: MatchOption
matchRange :: MatchOption
matchRange = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchTo, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchFrom, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
indexes ]

-- | Used by: log
matchSeveralOrRange :: MatchOption
matchSeveralOrRange :: MatchOption
matchSeveralOrRange = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat
  [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchTo, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matchFrom, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
indexes, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tags, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash ]

matchTo :: MatchOption
matchTo :: MatchOption
matchTo = PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toMatch PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toPatch PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toHash PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toTag

matchFrom :: MatchOption
matchFrom :: MatchOption
matchFrom = PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromMatch PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromPatch PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromHash PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Semigroup a => a -> a -> a
<> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromTag

matchAny :: MatchOption
matchAny :: MatchOption
matchAny = [PrimOptSpec DarcsOptDescr Flag a [MatchFlag]]
-> PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
forall a. Monoid a => [a] -> a
mconcat [ PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toMatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toPatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toHash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
toTag,
  PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromMatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromPatch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromHash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
fromTag,
  PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tag, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
tags, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patch, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
patches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
hash, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
match, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
matches, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
index, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
indexes, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
context, PrimOptSpec DarcsOptDescr Flag a [MatchFlag]
MatchOption
last ]

-- * Primitive matching options

toMatch, toPatch, toHash, toTag,
  fromMatch, fromPatch, fromHash, fromTag,
  tag, tags,
  patch, patches,
  hash,
  match, matches,
  index, indexes,
  context, last :: MatchOption

toMatch :: MatchOption
toMatch = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.UpToPattern String
s | UpToPattern String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
UpToPattern String
s | F.UpToPattern String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"to-match"] String -> Flag
F.UpToPattern String
"PATTERN"
    String
"select changes up to a patch matching PATTERN" ]

toPatch :: MatchOption
toPatch = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.UpToPatch String
s | UpToPatch String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
UpToPatch String
s | F.UpToPatch String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"to-patch"] String -> Flag
F.UpToPatch String
"REGEXP"
    String
"select changes up to a patch matching REGEXP" ]

toHash :: MatchOption
toHash = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.UpToHash String
s | UpToHash String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
UpToHash String
s | F.UpToHash String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"to-hash"] String -> Flag
F.UpToHash String
"HASH"
    String
"select changes up to a patch whose hash prefix matches HASH" ]

context :: MatchOption
context = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ AbsolutePath -> Flag
F.Context AbsolutePath
p | Context AbsolutePath
p <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ AbsolutePath -> MatchFlag
Context AbsolutePath
p | F.Context AbsolutePath
p <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr AbsolutePath Flag
forall f. SingleArgOptDescr AbsolutePath f
absPathArg [] [String
"context"] AbsolutePath -> Flag
F.Context String
"FILENAME"
    String
"version specified by the context in FILENAME" ]

toTag :: MatchOption
toTag = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.UpToTag String
s | UpToTag String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
UpToTag String
s | F.UpToTag String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"to-tag"] String -> Flag
F.UpToTag String
"REGEXP"
    String
"select changes up to a tag matching REGEXP" ]

fromMatch :: MatchOption
fromMatch = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.AfterPattern String
s | AfterPattern String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
AfterPattern String
s | F.AfterPattern String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"from-match"] String -> Flag
F.AfterPattern String
"PATTERN"
    String
"select changes starting with a patch matching PATTERN" ]

fromPatch :: MatchOption
fromPatch = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.AfterPatch String
s | AfterPatch String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
AfterPatch String
s | F.AfterPatch String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"from-patch"] String -> Flag
F.AfterPatch String
"REGEXP"
    String
"select changes starting with a patch matching REGEXP" ]

fromHash :: MatchOption
fromHash = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.AfterHash String
s | AfterHash String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
AfterHash String
s | F.AfterHash String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"from-hash"] String -> Flag
F.AfterHash String
"HASH"
    String
"select changes starting with a patch whose hash prefix matches HASH" ]

fromTag :: MatchOption
fromTag = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.AfterTag String
s | AfterTag String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
AfterTag String
s | F.AfterTag String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"from-tag"] String -> Flag
F.AfterTag String
"REGEXP"
    String
"select changes starting with a tag matching REGEXP" ]

tag :: MatchOption
tag = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OneTag String
s | OneTag String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
OneTag String
s | F.OneTag String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [Char
't'] [String
"tag"] String -> Flag
F.OneTag String
"REGEXP" String
"select tag matching REGEXP" ]

tags :: MatchOption
tags = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.SeveralTag String
s | SeveralTag String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
SeveralTag String
s | F.SeveralTag String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [Char
't'] [String
"tags"] String -> Flag
F.SeveralTag String
"REGEXP" String
"select tags matching REGEXP" ]

patch :: MatchOption
patch = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OnePatch String
s | OnePatch String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
OnePatch String
s | F.OnePatch String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [Char
'p'] [String
"patch"] String -> Flag
F.OnePatch String
"REGEXP"
    String
"select a single patch matching REGEXP" ]

patches :: MatchOption
patches = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.SeveralPatch String
s | SeveralPatch String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
SeveralPatch String
s | F.SeveralPatch String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [Char
'p'] [String
"patches"] String -> Flag
F.SeveralPatch String
"REGEXP"
    String
"select patches matching REGEXP" ]

hash :: MatchOption
hash = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OneHash String
s | OneHash String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
OneHash String
s | F.OneHash String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [Char
'h'] [String
"hash"] String -> Flag
F.OneHash String
"HASH"
    String
"select a single patch whose hash prefix matches HASH" ]

match :: MatchOption
match = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OnePattern String
s | OnePattern String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
OnePattern String
s | F.OnePattern String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"match"] String -> Flag
F.OnePattern String
"PATTERN"
    String
"select a single patch matching PATTERN" ]

matches :: MatchOption
matches = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.SeveralPattern String
s | SeveralPattern String
s <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ String -> MatchFlag
SeveralPattern String
s | F.SeveralPattern String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"matches"] String -> Flag
F.SeveralPattern String
"PATTERN"
    String
"select patches matching PATTERN" ]

last :: MatchOption
last = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.LastN (Int -> String
showIntArg Int
n) | LastN Int
n <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ Int -> MatchFlag
LastN (String -> Int
argparse String
s) | F.LastN String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [] [String
"last"] String -> Flag
F.LastN String
"NUMBER" String
"select the last NUMBER patches" ]
  argparse :: String -> Int
argparse = String -> (Int -> Bool) -> String -> Int
parseIntArg String
"count" (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>=Int
0)

index :: MatchOption
index = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.OneIndex (Int -> String
showIntArg Int
n) | OneIndex Int
n <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ Int -> MatchFlag
OneIndex (String -> Int
argparse String
s) | F.OneIndex String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [Char
'n'] [String
"index"] String -> Flag
F.OneIndex String
"N" String
"select one patch" ]
  argparse :: String -> Int
argparse = String -> (Int -> Bool) -> String -> Int
parseIntArg String
"index" (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
0)

indexes :: MatchOption
indexes = OptSpec {[Compose OptDescr ((->) AbsolutePath) Flag]
[Flag] -> [OptMsg]
([Flag] -> a) -> [MatchFlag] -> a
([MatchFlag] -> a) -> [Flag] -> a
forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
forall {p} {a}. p -> [a]
ounparse :: ([Flag] -> a) -> [MatchFlag] -> a
oparse :: ([MatchFlag] -> a) -> [Flag] -> a
ocheck :: [Flag] -> [OptMsg]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
ounparse :: forall {t}. ([Flag] -> t) -> [MatchFlag] -> t
oparse :: forall {t}. ([MatchFlag] -> t) -> [Flag] -> t
ocheck :: forall {p} {a}. p -> [a]
odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
..} where
  ounparse :: ([Flag] -> t) -> [MatchFlag] -> t
ounparse [Flag] -> t
k [MatchFlag]
mfs = [Flag] -> t
k [ String -> Flag
F.IndexRange ((Int, Int) -> String
showIndexRangeArg (Int
n,Int
m)) | IndexRange Int
n Int
m <- [MatchFlag]
mfs ]
  oparse :: ([MatchFlag] -> t) -> [Flag] -> t
oparse [MatchFlag] -> t
k [Flag]
fs = [MatchFlag] -> t
k [ (Int -> Int -> MatchFlag) -> (Int, Int) -> MatchFlag
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int -> Int -> MatchFlag
IndexRange (String -> (Int, Int)
argparse String
s) | F.IndexRange String
s <- [Flag]
fs ]
  ocheck :: p -> [a]
ocheck p
_ = []
  odesc :: [Compose OptDescr ((->) AbsolutePath) Flag]
odesc = [ SingleArgOptDescr String Flag
forall f. SingleArgOptDescr String f
strArg [Char
'n'] [String
"index"] String -> Flag
F.IndexRange String
"N-M" String
"select a range of patches" ]
  argparse :: String -> (Int, Int)
argparse = String -> (Int, Int)
parseIndexRangeArg