-----------------------------------------------------------------------------
-- |
-- License     :  BSD-3-Clause
-- Maintainer  :  Oleg Grenrus <oleg.grenrus@iki.fi>
--
module GitHub.Data.GitData where

import GitHub.Data.Definitions
import GitHub.Data.Name        (Name)
import GitHub.Data.URL         (URL)
import GitHub.Internal.Prelude
import Prelude ()

import qualified Data.Vector as V

-- | The options for querying commits.
data CommitQueryOption
    = CommitQuerySha !Text
    | CommitQueryPath !Text
    | CommitQueryAuthor !Text
    | CommitQuerySince !UTCTime
    | CommitQueryUntil !UTCTime
  deriving (Int -> CommitQueryOption -> ShowS
[CommitQueryOption] -> ShowS
CommitQueryOption -> String
(Int -> CommitQueryOption -> ShowS)
-> (CommitQueryOption -> String)
-> ([CommitQueryOption] -> ShowS)
-> Show CommitQueryOption
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CommitQueryOption] -> ShowS
$cshowList :: [CommitQueryOption] -> ShowS
show :: CommitQueryOption -> String
$cshow :: CommitQueryOption -> String
showsPrec :: Int -> CommitQueryOption -> ShowS
$cshowsPrec :: Int -> CommitQueryOption -> ShowS
Show, CommitQueryOption -> CommitQueryOption -> Bool
(CommitQueryOption -> CommitQueryOption -> Bool)
-> (CommitQueryOption -> CommitQueryOption -> Bool)
-> Eq CommitQueryOption
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CommitQueryOption -> CommitQueryOption -> Bool
$c/= :: CommitQueryOption -> CommitQueryOption -> Bool
== :: CommitQueryOption -> CommitQueryOption -> Bool
$c== :: CommitQueryOption -> CommitQueryOption -> Bool
Eq, Eq CommitQueryOption
Eq CommitQueryOption
-> (CommitQueryOption -> CommitQueryOption -> Ordering)
-> (CommitQueryOption -> CommitQueryOption -> Bool)
-> (CommitQueryOption -> CommitQueryOption -> Bool)
-> (CommitQueryOption -> CommitQueryOption -> Bool)
-> (CommitQueryOption -> CommitQueryOption -> Bool)
-> (CommitQueryOption -> CommitQueryOption -> CommitQueryOption)
-> (CommitQueryOption -> CommitQueryOption -> CommitQueryOption)
-> Ord CommitQueryOption
CommitQueryOption -> CommitQueryOption -> Bool
CommitQueryOption -> CommitQueryOption -> Ordering
CommitQueryOption -> CommitQueryOption -> CommitQueryOption
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CommitQueryOption -> CommitQueryOption -> CommitQueryOption
$cmin :: CommitQueryOption -> CommitQueryOption -> CommitQueryOption
max :: CommitQueryOption -> CommitQueryOption -> CommitQueryOption
$cmax :: CommitQueryOption -> CommitQueryOption -> CommitQueryOption
>= :: CommitQueryOption -> CommitQueryOption -> Bool
$c>= :: CommitQueryOption -> CommitQueryOption -> Bool
> :: CommitQueryOption -> CommitQueryOption -> Bool
$c> :: CommitQueryOption -> CommitQueryOption -> Bool
<= :: CommitQueryOption -> CommitQueryOption -> Bool
$c<= :: CommitQueryOption -> CommitQueryOption -> Bool
< :: CommitQueryOption -> CommitQueryOption -> Bool
$c< :: CommitQueryOption -> CommitQueryOption -> Bool
compare :: CommitQueryOption -> CommitQueryOption -> Ordering
$ccompare :: CommitQueryOption -> CommitQueryOption -> Ordering
Ord, (forall x. CommitQueryOption -> Rep CommitQueryOption x)
-> (forall x. Rep CommitQueryOption x -> CommitQueryOption)
-> Generic CommitQueryOption
forall x. Rep CommitQueryOption x -> CommitQueryOption
forall x. CommitQueryOption -> Rep CommitQueryOption x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CommitQueryOption x -> CommitQueryOption
$cfrom :: forall x. CommitQueryOption -> Rep CommitQueryOption x
Generic, Typeable, Typeable CommitQueryOption
Typeable CommitQueryOption
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> CommitQueryOption
    -> c CommitQueryOption)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CommitQueryOption)
-> (CommitQueryOption -> Constr)
-> (CommitQueryOption -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CommitQueryOption))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CommitQueryOption))
-> ((forall b. Data b => b -> b)
    -> CommitQueryOption -> CommitQueryOption)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CommitQueryOption -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CommitQueryOption -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CommitQueryOption -> m CommitQueryOption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommitQueryOption -> m CommitQueryOption)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommitQueryOption -> m CommitQueryOption)
-> Data CommitQueryOption
CommitQueryOption -> DataType
CommitQueryOption -> Constr
(forall b. Data b => b -> b)
-> CommitQueryOption -> CommitQueryOption
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> CommitQueryOption -> u
forall u. (forall d. Data d => d -> u) -> CommitQueryOption -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CommitQueryOption
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommitQueryOption -> c CommitQueryOption
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CommitQueryOption)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CommitQueryOption)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CommitQueryOption -> m CommitQueryOption
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CommitQueryOption -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CommitQueryOption -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CommitQueryOption -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CommitQueryOption -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CommitQueryOption -> r
gmapT :: (forall b. Data b => b -> b)
-> CommitQueryOption -> CommitQueryOption
$cgmapT :: (forall b. Data b => b -> b)
-> CommitQueryOption -> CommitQueryOption
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CommitQueryOption)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CommitQueryOption)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CommitQueryOption)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CommitQueryOption)
dataTypeOf :: CommitQueryOption -> DataType
$cdataTypeOf :: CommitQueryOption -> DataType
toConstr :: CommitQueryOption -> Constr
$ctoConstr :: CommitQueryOption -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CommitQueryOption
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CommitQueryOption
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommitQueryOption -> c CommitQueryOption
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CommitQueryOption -> c CommitQueryOption
Data)

data Stats = Stats
    { Stats -> Int
statsAdditions :: !Int
    , Stats -> Int
statsTotal     :: !Int
    , Stats -> Int
statsDeletions :: !Int
    }
  deriving (Int -> Stats -> ShowS
[Stats] -> ShowS
Stats -> String
(Int -> Stats -> ShowS)
-> (Stats -> String) -> ([Stats] -> ShowS) -> Show Stats
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Stats] -> ShowS
$cshowList :: [Stats] -> ShowS
show :: Stats -> String
$cshow :: Stats -> String
showsPrec :: Int -> Stats -> ShowS
$cshowsPrec :: Int -> Stats -> ShowS
Show, Typeable Stats
Typeable Stats
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Stats -> c Stats)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Stats)
-> (Stats -> Constr)
-> (Stats -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Stats))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stats))
-> ((forall b. Data b => b -> b) -> Stats -> Stats)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r)
-> (forall u. (forall d. Data d => d -> u) -> Stats -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Stats -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Stats -> m Stats)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stats -> m Stats)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Stats -> m Stats)
-> Data Stats
Stats -> DataType
Stats -> Constr
(forall b. Data b => b -> b) -> Stats -> Stats
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Stats -> u
forall u. (forall d. Data d => d -> u) -> Stats -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stats
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stats -> c Stats
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stats)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stats)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stats -> m Stats
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stats -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stats -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Stats -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Stats -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stats -> r
gmapT :: (forall b. Data b => b -> b) -> Stats -> Stats
$cgmapT :: (forall b. Data b => b -> b) -> Stats -> Stats
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stats)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stats)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stats)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stats)
dataTypeOf :: Stats -> DataType
$cdataTypeOf :: Stats -> DataType
toConstr :: Stats -> Constr
$ctoConstr :: Stats -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stats
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stats
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stats -> c Stats
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stats -> c Stats
Data, Typeable, Stats -> Stats -> Bool
(Stats -> Stats -> Bool) -> (Stats -> Stats -> Bool) -> Eq Stats
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Stats -> Stats -> Bool
$c/= :: Stats -> Stats -> Bool
== :: Stats -> Stats -> Bool
$c== :: Stats -> Stats -> Bool
Eq, Eq Stats
Eq Stats
-> (Stats -> Stats -> Ordering)
-> (Stats -> Stats -> Bool)
-> (Stats -> Stats -> Bool)
-> (Stats -> Stats -> Bool)
-> (Stats -> Stats -> Bool)
-> (Stats -> Stats -> Stats)
-> (Stats -> Stats -> Stats)
-> Ord Stats
Stats -> Stats -> Bool
Stats -> Stats -> Ordering
Stats -> Stats -> Stats
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Stats -> Stats -> Stats
$cmin :: Stats -> Stats -> Stats
max :: Stats -> Stats -> Stats
$cmax :: Stats -> Stats -> Stats
>= :: Stats -> Stats -> Bool
$c>= :: Stats -> Stats -> Bool
> :: Stats -> Stats -> Bool
$c> :: Stats -> Stats -> Bool
<= :: Stats -> Stats -> Bool
$c<= :: Stats -> Stats -> Bool
< :: Stats -> Stats -> Bool
$c< :: Stats -> Stats -> Bool
compare :: Stats -> Stats -> Ordering
$ccompare :: Stats -> Stats -> Ordering
Ord, (forall x. Stats -> Rep Stats x)
-> (forall x. Rep Stats x -> Stats) -> Generic Stats
forall x. Rep Stats x -> Stats
forall x. Stats -> Rep Stats x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Stats x -> Stats
$cfrom :: forall x. Stats -> Rep Stats x
Generic)

instance NFData Stats where rnf :: Stats -> ()
rnf = Stats -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Stats

data Commit = Commit
    { Commit -> Name Commit
commitSha       :: !(Name Commit)
    , Commit -> Vector Tree
commitParents   :: !(Vector Tree)
    , Commit -> URL
commitUrl       :: !URL
    , Commit -> GitCommit
commitGitCommit :: !GitCommit
    , Commit -> Maybe SimpleUser
commitCommitter :: !(Maybe SimpleUser)
    , Commit -> Maybe SimpleUser
commitAuthor    :: !(Maybe SimpleUser)
    , Commit -> Vector File
commitFiles     :: !(Vector File)
    , Commit -> Maybe Stats
commitStats     :: !(Maybe Stats)
    }
  deriving (Int -> Commit -> ShowS
[Commit] -> ShowS
Commit -> String
(Int -> Commit -> ShowS)
-> (Commit -> String) -> ([Commit] -> ShowS) -> Show Commit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Commit] -> ShowS
$cshowList :: [Commit] -> ShowS
show :: Commit -> String
$cshow :: Commit -> String
showsPrec :: Int -> Commit -> ShowS
$cshowsPrec :: Int -> Commit -> ShowS
Show, Typeable Commit
Typeable Commit
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Commit -> c Commit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Commit)
-> (Commit -> Constr)
-> (Commit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Commit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Commit))
-> ((forall b. Data b => b -> b) -> Commit -> Commit)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Commit -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Commit -> r)
-> (forall u. (forall d. Data d => d -> u) -> Commit -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Commit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Commit -> m Commit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Commit -> m Commit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Commit -> m Commit)
-> Data Commit
Commit -> DataType
Commit -> Constr
(forall b. Data b => b -> b) -> Commit -> Commit
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Commit -> u
forall u. (forall d. Data d => d -> u) -> Commit -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Commit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Commit -> c Commit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Commit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Commit)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Commit -> m Commit
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Commit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Commit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Commit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Commit -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Commit -> r
gmapT :: (forall b. Data b => b -> b) -> Commit -> Commit
$cgmapT :: (forall b. Data b => b -> b) -> Commit -> Commit
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Commit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Commit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Commit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Commit)
dataTypeOf :: Commit -> DataType
$cdataTypeOf :: Commit -> DataType
toConstr :: Commit -> Constr
$ctoConstr :: Commit -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Commit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Commit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Commit -> c Commit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Commit -> c Commit
Data, Typeable, Commit -> Commit -> Bool
(Commit -> Commit -> Bool)
-> (Commit -> Commit -> Bool) -> Eq Commit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Commit -> Commit -> Bool
$c/= :: Commit -> Commit -> Bool
== :: Commit -> Commit -> Bool
$c== :: Commit -> Commit -> Bool
Eq, Eq Commit
Eq Commit
-> (Commit -> Commit -> Ordering)
-> (Commit -> Commit -> Bool)
-> (Commit -> Commit -> Bool)
-> (Commit -> Commit -> Bool)
-> (Commit -> Commit -> Bool)
-> (Commit -> Commit -> Commit)
-> (Commit -> Commit -> Commit)
-> Ord Commit
Commit -> Commit -> Bool
Commit -> Commit -> Ordering
Commit -> Commit -> Commit
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Commit -> Commit -> Commit
$cmin :: Commit -> Commit -> Commit
max :: Commit -> Commit -> Commit
$cmax :: Commit -> Commit -> Commit
>= :: Commit -> Commit -> Bool
$c>= :: Commit -> Commit -> Bool
> :: Commit -> Commit -> Bool
$c> :: Commit -> Commit -> Bool
<= :: Commit -> Commit -> Bool
$c<= :: Commit -> Commit -> Bool
< :: Commit -> Commit -> Bool
$c< :: Commit -> Commit -> Bool
compare :: Commit -> Commit -> Ordering
$ccompare :: Commit -> Commit -> Ordering
Ord, (forall x. Commit -> Rep Commit x)
-> (forall x. Rep Commit x -> Commit) -> Generic Commit
forall x. Rep Commit x -> Commit
forall x. Commit -> Rep Commit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Commit x -> Commit
$cfrom :: forall x. Commit -> Rep Commit x
Generic)

instance NFData Commit where rnf :: Commit -> ()
rnf = Commit -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Commit

data Tree = Tree
    { Tree -> Name Tree
treeSha      :: !(Name Tree)
    , Tree -> URL
treeUrl      :: !URL
    , Tree -> Vector GitTree
treeGitTrees :: !(Vector GitTree)
    }
  deriving (Int -> Tree -> ShowS
[Tree] -> ShowS
Tree -> String
(Int -> Tree -> ShowS)
-> (Tree -> String) -> ([Tree] -> ShowS) -> Show Tree
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Tree] -> ShowS
$cshowList :: [Tree] -> ShowS
show :: Tree -> String
$cshow :: Tree -> String
showsPrec :: Int -> Tree -> ShowS
$cshowsPrec :: Int -> Tree -> ShowS
Show, Typeable Tree
Typeable Tree
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Tree -> c Tree)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Tree)
-> (Tree -> Constr)
-> (Tree -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Tree))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tree))
-> ((forall b. Data b => b -> b) -> Tree -> Tree)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r)
-> (forall u. (forall d. Data d => d -> u) -> Tree -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Tree -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tree -> m Tree)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tree -> m Tree)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tree -> m Tree)
-> Data Tree
Tree -> DataType
Tree -> Constr
(forall b. Data b => b -> b) -> Tree -> Tree
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Tree -> u
forall u. (forall d. Data d => d -> u) -> Tree -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tree
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree -> c Tree
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tree)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tree)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tree -> m Tree
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tree -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tree -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Tree -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Tree -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tree -> r
gmapT :: (forall b. Data b => b -> b) -> Tree -> Tree
$cgmapT :: (forall b. Data b => b -> b) -> Tree -> Tree
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tree)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tree)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tree)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tree)
dataTypeOf :: Tree -> DataType
$cdataTypeOf :: Tree -> DataType
toConstr :: Tree -> Constr
$ctoConstr :: Tree -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tree
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tree
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree -> c Tree
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tree -> c Tree
Data, Typeable, Tree -> Tree -> Bool
(Tree -> Tree -> Bool) -> (Tree -> Tree -> Bool) -> Eq Tree
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tree -> Tree -> Bool
$c/= :: Tree -> Tree -> Bool
== :: Tree -> Tree -> Bool
$c== :: Tree -> Tree -> Bool
Eq, Eq Tree
Eq Tree
-> (Tree -> Tree -> Ordering)
-> (Tree -> Tree -> Bool)
-> (Tree -> Tree -> Bool)
-> (Tree -> Tree -> Bool)
-> (Tree -> Tree -> Bool)
-> (Tree -> Tree -> Tree)
-> (Tree -> Tree -> Tree)
-> Ord Tree
Tree -> Tree -> Bool
Tree -> Tree -> Ordering
Tree -> Tree -> Tree
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tree -> Tree -> Tree
$cmin :: Tree -> Tree -> Tree
max :: Tree -> Tree -> Tree
$cmax :: Tree -> Tree -> Tree
>= :: Tree -> Tree -> Bool
$c>= :: Tree -> Tree -> Bool
> :: Tree -> Tree -> Bool
$c> :: Tree -> Tree -> Bool
<= :: Tree -> Tree -> Bool
$c<= :: Tree -> Tree -> Bool
< :: Tree -> Tree -> Bool
$c< :: Tree -> Tree -> Bool
compare :: Tree -> Tree -> Ordering
$ccompare :: Tree -> Tree -> Ordering
Ord, (forall x. Tree -> Rep Tree x)
-> (forall x. Rep Tree x -> Tree) -> Generic Tree
forall x. Rep Tree x -> Tree
forall x. Tree -> Rep Tree x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Tree x -> Tree
$cfrom :: forall x. Tree -> Rep Tree x
Generic)

instance NFData Tree where rnf :: Tree -> ()
rnf = Tree -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Tree

data GitTree = GitTree
    { GitTree -> Text
gitTreeType :: !Text
    , GitTree -> Name GitTree
gitTreeSha  :: !(Name GitTree)
    -- Can be empty for submodule
    , GitTree -> Maybe URL
gitTreeUrl  :: !(Maybe URL)
    , GitTree -> Maybe Int
gitTreeSize :: !(Maybe Int)
    , GitTree -> Text
gitTreePath :: !Text
    , GitTree -> Text
gitTreeMode :: !Text
    }
  deriving (Int -> GitTree -> ShowS
[GitTree] -> ShowS
GitTree -> String
(Int -> GitTree -> ShowS)
-> (GitTree -> String) -> ([GitTree] -> ShowS) -> Show GitTree
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitTree] -> ShowS
$cshowList :: [GitTree] -> ShowS
show :: GitTree -> String
$cshow :: GitTree -> String
showsPrec :: Int -> GitTree -> ShowS
$cshowsPrec :: Int -> GitTree -> ShowS
Show, Typeable GitTree
Typeable GitTree
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GitTree -> c GitTree)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GitTree)
-> (GitTree -> Constr)
-> (GitTree -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GitTree))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitTree))
-> ((forall b. Data b => b -> b) -> GitTree -> GitTree)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GitTree -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GitTree -> r)
-> (forall u. (forall d. Data d => d -> u) -> GitTree -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> GitTree -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GitTree -> m GitTree)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GitTree -> m GitTree)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GitTree -> m GitTree)
-> Data GitTree
GitTree -> DataType
GitTree -> Constr
(forall b. Data b => b -> b) -> GitTree -> GitTree
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GitTree -> u
forall u. (forall d. Data d => d -> u) -> GitTree -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitTree
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitTree -> c GitTree
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitTree)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitTree)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitTree -> m GitTree
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitTree -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitTree -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> GitTree -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GitTree -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitTree -> r
gmapT :: (forall b. Data b => b -> b) -> GitTree -> GitTree
$cgmapT :: (forall b. Data b => b -> b) -> GitTree -> GitTree
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitTree)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitTree)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitTree)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitTree)
dataTypeOf :: GitTree -> DataType
$cdataTypeOf :: GitTree -> DataType
toConstr :: GitTree -> Constr
$ctoConstr :: GitTree -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitTree
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitTree
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitTree -> c GitTree
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitTree -> c GitTree
Data, Typeable, GitTree -> GitTree -> Bool
(GitTree -> GitTree -> Bool)
-> (GitTree -> GitTree -> Bool) -> Eq GitTree
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitTree -> GitTree -> Bool
$c/= :: GitTree -> GitTree -> Bool
== :: GitTree -> GitTree -> Bool
$c== :: GitTree -> GitTree -> Bool
Eq, Eq GitTree
Eq GitTree
-> (GitTree -> GitTree -> Ordering)
-> (GitTree -> GitTree -> Bool)
-> (GitTree -> GitTree -> Bool)
-> (GitTree -> GitTree -> Bool)
-> (GitTree -> GitTree -> Bool)
-> (GitTree -> GitTree -> GitTree)
-> (GitTree -> GitTree -> GitTree)
-> Ord GitTree
GitTree -> GitTree -> Bool
GitTree -> GitTree -> Ordering
GitTree -> GitTree -> GitTree
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GitTree -> GitTree -> GitTree
$cmin :: GitTree -> GitTree -> GitTree
max :: GitTree -> GitTree -> GitTree
$cmax :: GitTree -> GitTree -> GitTree
>= :: GitTree -> GitTree -> Bool
$c>= :: GitTree -> GitTree -> Bool
> :: GitTree -> GitTree -> Bool
$c> :: GitTree -> GitTree -> Bool
<= :: GitTree -> GitTree -> Bool
$c<= :: GitTree -> GitTree -> Bool
< :: GitTree -> GitTree -> Bool
$c< :: GitTree -> GitTree -> Bool
compare :: GitTree -> GitTree -> Ordering
$ccompare :: GitTree -> GitTree -> Ordering
Ord, (forall x. GitTree -> Rep GitTree x)
-> (forall x. Rep GitTree x -> GitTree) -> Generic GitTree
forall x. Rep GitTree x -> GitTree
forall x. GitTree -> Rep GitTree x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitTree x -> GitTree
$cfrom :: forall x. GitTree -> Rep GitTree x
Generic)

instance NFData GitTree where rnf :: GitTree -> ()
rnf = GitTree -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary GitTree

data GitCommit = GitCommit
    { GitCommit -> Text
gitCommitMessage   :: !Text
    , GitCommit -> URL
gitCommitUrl       :: !URL
    , GitCommit -> GitUser
gitCommitCommitter :: !GitUser
    , GitCommit -> GitUser
gitCommitAuthor    :: !GitUser
    , GitCommit -> Tree
gitCommitTree      :: !Tree
    , GitCommit -> Maybe (Name GitCommit)
gitCommitSha       :: !(Maybe (Name GitCommit))
    , GitCommit -> Vector Tree
gitCommitParents   :: !(Vector Tree)
    }
  deriving (Int -> GitCommit -> ShowS
[GitCommit] -> ShowS
GitCommit -> String
(Int -> GitCommit -> ShowS)
-> (GitCommit -> String)
-> ([GitCommit] -> ShowS)
-> Show GitCommit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitCommit] -> ShowS
$cshowList :: [GitCommit] -> ShowS
show :: GitCommit -> String
$cshow :: GitCommit -> String
showsPrec :: Int -> GitCommit -> ShowS
$cshowsPrec :: Int -> GitCommit -> ShowS
Show, Typeable GitCommit
Typeable GitCommit
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GitCommit -> c GitCommit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GitCommit)
-> (GitCommit -> Constr)
-> (GitCommit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GitCommit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitCommit))
-> ((forall b. Data b => b -> b) -> GitCommit -> GitCommit)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GitCommit -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GitCommit -> r)
-> (forall u. (forall d. Data d => d -> u) -> GitCommit -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GitCommit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GitCommit -> m GitCommit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GitCommit -> m GitCommit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GitCommit -> m GitCommit)
-> Data GitCommit
GitCommit -> DataType
GitCommit -> Constr
(forall b. Data b => b -> b) -> GitCommit -> GitCommit
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GitCommit -> u
forall u. (forall d. Data d => d -> u) -> GitCommit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitCommit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitCommit -> c GitCommit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitCommit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitCommit)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitCommit -> m GitCommit
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitCommit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitCommit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> GitCommit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GitCommit -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitCommit -> r
gmapT :: (forall b. Data b => b -> b) -> GitCommit -> GitCommit
$cgmapT :: (forall b. Data b => b -> b) -> GitCommit -> GitCommit
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitCommit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitCommit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitCommit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitCommit)
dataTypeOf :: GitCommit -> DataType
$cdataTypeOf :: GitCommit -> DataType
toConstr :: GitCommit -> Constr
$ctoConstr :: GitCommit -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitCommit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitCommit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitCommit -> c GitCommit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitCommit -> c GitCommit
Data, Typeable, GitCommit -> GitCommit -> Bool
(GitCommit -> GitCommit -> Bool)
-> (GitCommit -> GitCommit -> Bool) -> Eq GitCommit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitCommit -> GitCommit -> Bool
$c/= :: GitCommit -> GitCommit -> Bool
== :: GitCommit -> GitCommit -> Bool
$c== :: GitCommit -> GitCommit -> Bool
Eq, Eq GitCommit
Eq GitCommit
-> (GitCommit -> GitCommit -> Ordering)
-> (GitCommit -> GitCommit -> Bool)
-> (GitCommit -> GitCommit -> Bool)
-> (GitCommit -> GitCommit -> Bool)
-> (GitCommit -> GitCommit -> Bool)
-> (GitCommit -> GitCommit -> GitCommit)
-> (GitCommit -> GitCommit -> GitCommit)
-> Ord GitCommit
GitCommit -> GitCommit -> Bool
GitCommit -> GitCommit -> Ordering
GitCommit -> GitCommit -> GitCommit
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GitCommit -> GitCommit -> GitCommit
$cmin :: GitCommit -> GitCommit -> GitCommit
max :: GitCommit -> GitCommit -> GitCommit
$cmax :: GitCommit -> GitCommit -> GitCommit
>= :: GitCommit -> GitCommit -> Bool
$c>= :: GitCommit -> GitCommit -> Bool
> :: GitCommit -> GitCommit -> Bool
$c> :: GitCommit -> GitCommit -> Bool
<= :: GitCommit -> GitCommit -> Bool
$c<= :: GitCommit -> GitCommit -> Bool
< :: GitCommit -> GitCommit -> Bool
$c< :: GitCommit -> GitCommit -> Bool
compare :: GitCommit -> GitCommit -> Ordering
$ccompare :: GitCommit -> GitCommit -> Ordering
Ord, (forall x. GitCommit -> Rep GitCommit x)
-> (forall x. Rep GitCommit x -> GitCommit) -> Generic GitCommit
forall x. Rep GitCommit x -> GitCommit
forall x. GitCommit -> Rep GitCommit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitCommit x -> GitCommit
$cfrom :: forall x. GitCommit -> Rep GitCommit x
Generic)

instance NFData GitCommit where rnf :: GitCommit -> ()
rnf = GitCommit -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary GitCommit

data Blob = Blob
    { Blob -> URL
blobUrl      :: !URL
    , Blob -> Text
blobEncoding :: !Text
    , Blob -> Text
blobContent  :: !Text
    , Blob -> Name Blob
blobSha      :: !(Name Blob)
    , Blob -> Int
blobSize     :: !Int
    }
  deriving (Int -> Blob -> ShowS
[Blob] -> ShowS
Blob -> String
(Int -> Blob -> ShowS)
-> (Blob -> String) -> ([Blob] -> ShowS) -> Show Blob
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Blob] -> ShowS
$cshowList :: [Blob] -> ShowS
show :: Blob -> String
$cshow :: Blob -> String
showsPrec :: Int -> Blob -> ShowS
$cshowsPrec :: Int -> Blob -> ShowS
Show, Typeable Blob
Typeable Blob
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Blob -> c Blob)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Blob)
-> (Blob -> Constr)
-> (Blob -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Blob))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blob))
-> ((forall b. Data b => b -> b) -> Blob -> Blob)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r)
-> (forall u. (forall d. Data d => d -> u) -> Blob -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Blob -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Blob -> m Blob)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Blob -> m Blob)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Blob -> m Blob)
-> Data Blob
Blob -> DataType
Blob -> Constr
(forall b. Data b => b -> b) -> Blob -> Blob
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Blob -> u
forall u. (forall d. Data d => d -> u) -> Blob -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Blob
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Blob -> c Blob
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Blob)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blob)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Blob -> m Blob
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Blob -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Blob -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Blob -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Blob -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blob -> r
gmapT :: (forall b. Data b => b -> b) -> Blob -> Blob
$cgmapT :: (forall b. Data b => b -> b) -> Blob -> Blob
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blob)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blob)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Blob)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Blob)
dataTypeOf :: Blob -> DataType
$cdataTypeOf :: Blob -> DataType
toConstr :: Blob -> Constr
$ctoConstr :: Blob -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Blob
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Blob
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Blob -> c Blob
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Blob -> c Blob
Data, Typeable, Blob -> Blob -> Bool
(Blob -> Blob -> Bool) -> (Blob -> Blob -> Bool) -> Eq Blob
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Blob -> Blob -> Bool
$c/= :: Blob -> Blob -> Bool
== :: Blob -> Blob -> Bool
$c== :: Blob -> Blob -> Bool
Eq, Eq Blob
Eq Blob
-> (Blob -> Blob -> Ordering)
-> (Blob -> Blob -> Bool)
-> (Blob -> Blob -> Bool)
-> (Blob -> Blob -> Bool)
-> (Blob -> Blob -> Bool)
-> (Blob -> Blob -> Blob)
-> (Blob -> Blob -> Blob)
-> Ord Blob
Blob -> Blob -> Bool
Blob -> Blob -> Ordering
Blob -> Blob -> Blob
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Blob -> Blob -> Blob
$cmin :: Blob -> Blob -> Blob
max :: Blob -> Blob -> Blob
$cmax :: Blob -> Blob -> Blob
>= :: Blob -> Blob -> Bool
$c>= :: Blob -> Blob -> Bool
> :: Blob -> Blob -> Bool
$c> :: Blob -> Blob -> Bool
<= :: Blob -> Blob -> Bool
$c<= :: Blob -> Blob -> Bool
< :: Blob -> Blob -> Bool
$c< :: Blob -> Blob -> Bool
compare :: Blob -> Blob -> Ordering
$ccompare :: Blob -> Blob -> Ordering
Ord, (forall x. Blob -> Rep Blob x)
-> (forall x. Rep Blob x -> Blob) -> Generic Blob
forall x. Rep Blob x -> Blob
forall x. Blob -> Rep Blob x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Blob x -> Blob
$cfrom :: forall x. Blob -> Rep Blob x
Generic)

instance NFData Blob where rnf :: Blob -> ()
rnf = Blob -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Blob

data Tag = Tag
    { Tag -> Text
tagName       :: !Text
    , Tag -> URL
tagZipballUrl :: !URL
    , Tag -> URL
tagTarballUrl :: !URL
    , Tag -> BranchCommit
tagCommit     :: !BranchCommit
    }
  deriving (Int -> Tag -> ShowS
[Tag] -> ShowS
Tag -> String
(Int -> Tag -> ShowS)
-> (Tag -> String) -> ([Tag] -> ShowS) -> Show Tag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Tag] -> ShowS
$cshowList :: [Tag] -> ShowS
show :: Tag -> String
$cshow :: Tag -> String
showsPrec :: Int -> Tag -> ShowS
$cshowsPrec :: Int -> Tag -> ShowS
Show, Typeable Tag
Typeable Tag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Tag -> c Tag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Tag)
-> (Tag -> Constr)
-> (Tag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Tag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tag))
-> ((forall b. Data b => b -> b) -> Tag -> Tag)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r)
-> (forall u. (forall d. Data d => d -> u) -> Tag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Tag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tag -> m Tag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tag -> m Tag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tag -> m Tag)
-> Data Tag
Tag -> DataType
Tag -> Constr
(forall b. Data b => b -> b) -> Tag -> Tag
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Tag -> u
forall u. (forall d. Data d => d -> u) -> Tag -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tag -> c Tag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tag)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tag -> m Tag
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tag -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Tag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Tag -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tag -> r
gmapT :: (forall b. Data b => b -> b) -> Tag -> Tag
$cgmapT :: (forall b. Data b => b -> b) -> Tag -> Tag
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tag)
dataTypeOf :: Tag -> DataType
$cdataTypeOf :: Tag -> DataType
toConstr :: Tag -> Constr
$ctoConstr :: Tag -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tag -> c Tag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tag -> c Tag
Data, Typeable, Tag -> Tag -> Bool
(Tag -> Tag -> Bool) -> (Tag -> Tag -> Bool) -> Eq Tag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Tag -> Tag -> Bool
$c/= :: Tag -> Tag -> Bool
== :: Tag -> Tag -> Bool
$c== :: Tag -> Tag -> Bool
Eq, Eq Tag
Eq Tag
-> (Tag -> Tag -> Ordering)
-> (Tag -> Tag -> Bool)
-> (Tag -> Tag -> Bool)
-> (Tag -> Tag -> Bool)
-> (Tag -> Tag -> Bool)
-> (Tag -> Tag -> Tag)
-> (Tag -> Tag -> Tag)
-> Ord Tag
Tag -> Tag -> Bool
Tag -> Tag -> Ordering
Tag -> Tag -> Tag
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Tag -> Tag -> Tag
$cmin :: Tag -> Tag -> Tag
max :: Tag -> Tag -> Tag
$cmax :: Tag -> Tag -> Tag
>= :: Tag -> Tag -> Bool
$c>= :: Tag -> Tag -> Bool
> :: Tag -> Tag -> Bool
$c> :: Tag -> Tag -> Bool
<= :: Tag -> Tag -> Bool
$c<= :: Tag -> Tag -> Bool
< :: Tag -> Tag -> Bool
$c< :: Tag -> Tag -> Bool
compare :: Tag -> Tag -> Ordering
$ccompare :: Tag -> Tag -> Ordering
Ord, (forall x. Tag -> Rep Tag x)
-> (forall x. Rep Tag x -> Tag) -> Generic Tag
forall x. Rep Tag x -> Tag
forall x. Tag -> Rep Tag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Tag x -> Tag
$cfrom :: forall x. Tag -> Rep Tag x
Generic)

instance NFData Tag where rnf :: Tag -> ()
rnf = Tag -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Tag

data Branch = Branch
    { Branch -> Text
branchName   :: !Text
    , Branch -> BranchCommit
branchCommit :: !BranchCommit
    }
  deriving (Int -> Branch -> ShowS
[Branch] -> ShowS
Branch -> String
(Int -> Branch -> ShowS)
-> (Branch -> String) -> ([Branch] -> ShowS) -> Show Branch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Branch] -> ShowS
$cshowList :: [Branch] -> ShowS
show :: Branch -> String
$cshow :: Branch -> String
showsPrec :: Int -> Branch -> ShowS
$cshowsPrec :: Int -> Branch -> ShowS
Show, Typeable Branch
Typeable Branch
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Branch -> c Branch)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Branch)
-> (Branch -> Constr)
-> (Branch -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Branch))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Branch))
-> ((forall b. Data b => b -> b) -> Branch -> Branch)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Branch -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Branch -> r)
-> (forall u. (forall d. Data d => d -> u) -> Branch -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Branch -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Branch -> m Branch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Branch -> m Branch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Branch -> m Branch)
-> Data Branch
Branch -> DataType
Branch -> Constr
(forall b. Data b => b -> b) -> Branch -> Branch
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Branch -> u
forall u. (forall d. Data d => d -> u) -> Branch -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Branch
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch -> c Branch
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Branch)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Branch)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Branch -> m Branch
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Branch -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Branch -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Branch -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Branch -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Branch -> r
gmapT :: (forall b. Data b => b -> b) -> Branch -> Branch
$cgmapT :: (forall b. Data b => b -> b) -> Branch -> Branch
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Branch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Branch)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Branch)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Branch)
dataTypeOf :: Branch -> DataType
$cdataTypeOf :: Branch -> DataType
toConstr :: Branch -> Constr
$ctoConstr :: Branch -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Branch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Branch
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch -> c Branch
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch -> c Branch
Data, Typeable, Branch -> Branch -> Bool
(Branch -> Branch -> Bool)
-> (Branch -> Branch -> Bool) -> Eq Branch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Branch -> Branch -> Bool
$c/= :: Branch -> Branch -> Bool
== :: Branch -> Branch -> Bool
$c== :: Branch -> Branch -> Bool
Eq, Eq Branch
Eq Branch
-> (Branch -> Branch -> Ordering)
-> (Branch -> Branch -> Bool)
-> (Branch -> Branch -> Bool)
-> (Branch -> Branch -> Bool)
-> (Branch -> Branch -> Bool)
-> (Branch -> Branch -> Branch)
-> (Branch -> Branch -> Branch)
-> Ord Branch
Branch -> Branch -> Bool
Branch -> Branch -> Ordering
Branch -> Branch -> Branch
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Branch -> Branch -> Branch
$cmin :: Branch -> Branch -> Branch
max :: Branch -> Branch -> Branch
$cmax :: Branch -> Branch -> Branch
>= :: Branch -> Branch -> Bool
$c>= :: Branch -> Branch -> Bool
> :: Branch -> Branch -> Bool
$c> :: Branch -> Branch -> Bool
<= :: Branch -> Branch -> Bool
$c<= :: Branch -> Branch -> Bool
< :: Branch -> Branch -> Bool
$c< :: Branch -> Branch -> Bool
compare :: Branch -> Branch -> Ordering
$ccompare :: Branch -> Branch -> Ordering
Ord, (forall x. Branch -> Rep Branch x)
-> (forall x. Rep Branch x -> Branch) -> Generic Branch
forall x. Rep Branch x -> Branch
forall x. Branch -> Rep Branch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Branch x -> Branch
$cfrom :: forall x. Branch -> Rep Branch x
Generic)

instance NFData Branch where rnf :: Branch -> ()
rnf = Branch -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf

data BranchCommit = BranchCommit
    { BranchCommit -> Text
branchCommitSha :: !Text
    , BranchCommit -> URL
branchCommitUrl :: !URL
    }
  deriving (Int -> BranchCommit -> ShowS
[BranchCommit] -> ShowS
BranchCommit -> String
(Int -> BranchCommit -> ShowS)
-> (BranchCommit -> String)
-> ([BranchCommit] -> ShowS)
-> Show BranchCommit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BranchCommit] -> ShowS
$cshowList :: [BranchCommit] -> ShowS
show :: BranchCommit -> String
$cshow :: BranchCommit -> String
showsPrec :: Int -> BranchCommit -> ShowS
$cshowsPrec :: Int -> BranchCommit -> ShowS
Show, Typeable BranchCommit
Typeable BranchCommit
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BranchCommit -> c BranchCommit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BranchCommit)
-> (BranchCommit -> Constr)
-> (BranchCommit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BranchCommit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BranchCommit))
-> ((forall b. Data b => b -> b) -> BranchCommit -> BranchCommit)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BranchCommit -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BranchCommit -> r)
-> (forall u. (forall d. Data d => d -> u) -> BranchCommit -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BranchCommit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit)
-> Data BranchCommit
BranchCommit -> DataType
BranchCommit -> Constr
(forall b. Data b => b -> b) -> BranchCommit -> BranchCommit
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BranchCommit -> u
forall u. (forall d. Data d => d -> u) -> BranchCommit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BranchCommit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BranchCommit -> c BranchCommit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BranchCommit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BranchCommit)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BranchCommit -> m BranchCommit
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BranchCommit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BranchCommit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> BranchCommit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BranchCommit -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BranchCommit -> r
gmapT :: (forall b. Data b => b -> b) -> BranchCommit -> BranchCommit
$cgmapT :: (forall b. Data b => b -> b) -> BranchCommit -> BranchCommit
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BranchCommit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BranchCommit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BranchCommit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BranchCommit)
dataTypeOf :: BranchCommit -> DataType
$cdataTypeOf :: BranchCommit -> DataType
toConstr :: BranchCommit -> Constr
$ctoConstr :: BranchCommit -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BranchCommit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BranchCommit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BranchCommit -> c BranchCommit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BranchCommit -> c BranchCommit
Data, Typeable, BranchCommit -> BranchCommit -> Bool
(BranchCommit -> BranchCommit -> Bool)
-> (BranchCommit -> BranchCommit -> Bool) -> Eq BranchCommit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BranchCommit -> BranchCommit -> Bool
$c/= :: BranchCommit -> BranchCommit -> Bool
== :: BranchCommit -> BranchCommit -> Bool
$c== :: BranchCommit -> BranchCommit -> Bool
Eq, Eq BranchCommit
Eq BranchCommit
-> (BranchCommit -> BranchCommit -> Ordering)
-> (BranchCommit -> BranchCommit -> Bool)
-> (BranchCommit -> BranchCommit -> Bool)
-> (BranchCommit -> BranchCommit -> Bool)
-> (BranchCommit -> BranchCommit -> Bool)
-> (BranchCommit -> BranchCommit -> BranchCommit)
-> (BranchCommit -> BranchCommit -> BranchCommit)
-> Ord BranchCommit
BranchCommit -> BranchCommit -> Bool
BranchCommit -> BranchCommit -> Ordering
BranchCommit -> BranchCommit -> BranchCommit
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BranchCommit -> BranchCommit -> BranchCommit
$cmin :: BranchCommit -> BranchCommit -> BranchCommit
max :: BranchCommit -> BranchCommit -> BranchCommit
$cmax :: BranchCommit -> BranchCommit -> BranchCommit
>= :: BranchCommit -> BranchCommit -> Bool
$c>= :: BranchCommit -> BranchCommit -> Bool
> :: BranchCommit -> BranchCommit -> Bool
$c> :: BranchCommit -> BranchCommit -> Bool
<= :: BranchCommit -> BranchCommit -> Bool
$c<= :: BranchCommit -> BranchCommit -> Bool
< :: BranchCommit -> BranchCommit -> Bool
$c< :: BranchCommit -> BranchCommit -> Bool
compare :: BranchCommit -> BranchCommit -> Ordering
$ccompare :: BranchCommit -> BranchCommit -> Ordering
Ord, (forall x. BranchCommit -> Rep BranchCommit x)
-> (forall x. Rep BranchCommit x -> BranchCommit)
-> Generic BranchCommit
forall x. Rep BranchCommit x -> BranchCommit
forall x. BranchCommit -> Rep BranchCommit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BranchCommit x -> BranchCommit
$cfrom :: forall x. BranchCommit -> Rep BranchCommit x
Generic)

instance NFData BranchCommit where rnf :: BranchCommit -> ()
rnf = BranchCommit -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary BranchCommit

data Diff = Diff
    { Diff -> Text
diffStatus       :: !Text
    , Diff -> Int
diffBehindBy     :: !Int
    , Diff -> URL
diffPatchUrl     :: !URL
    , Diff -> URL
diffUrl          :: !URL
    , Diff -> Commit
diffBaseCommit   :: !Commit
    , Diff -> Vector Commit
diffCommits      :: !(Vector Commit)
    , Diff -> Int
diffTotalCommits :: !Int
    , Diff -> URL
diffHtmlUrl      :: !URL
    , Diff -> Vector File
diffFiles        :: !(Vector File)
    , Diff -> Int
diffAheadBy      :: !Int
    , Diff -> URL
diffDiffUrl      :: !URL
    , Diff -> URL
diffPermalinkUrl :: !URL
    }
  deriving (Int -> Diff -> ShowS
[Diff] -> ShowS
Diff -> String
(Int -> Diff -> ShowS)
-> (Diff -> String) -> ([Diff] -> ShowS) -> Show Diff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Diff] -> ShowS
$cshowList :: [Diff] -> ShowS
show :: Diff -> String
$cshow :: Diff -> String
showsPrec :: Int -> Diff -> ShowS
$cshowsPrec :: Int -> Diff -> ShowS
Show, Typeable Diff
Typeable Diff
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Diff -> c Diff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Diff)
-> (Diff -> Constr)
-> (Diff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Diff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diff))
-> ((forall b. Data b => b -> b) -> Diff -> Diff)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r)
-> (forall u. (forall d. Data d => d -> u) -> Diff -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Diff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Diff -> m Diff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Diff -> m Diff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Diff -> m Diff)
-> Data Diff
Diff -> DataType
Diff -> Constr
(forall b. Data b => b -> b) -> Diff -> Diff
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Diff -> u
forall u. (forall d. Data d => d -> u) -> Diff -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Diff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Diff -> c Diff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Diff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diff)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Diff -> m Diff
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Diff -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Diff -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Diff -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Diff -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Diff -> r
gmapT :: (forall b. Data b => b -> b) -> Diff -> Diff
$cgmapT :: (forall b. Data b => b -> b) -> Diff -> Diff
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Diff)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Diff)
dataTypeOf :: Diff -> DataType
$cdataTypeOf :: Diff -> DataType
toConstr :: Diff -> Constr
$ctoConstr :: Diff -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Diff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Diff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Diff -> c Diff
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Diff -> c Diff
Data, Typeable, Diff -> Diff -> Bool
(Diff -> Diff -> Bool) -> (Diff -> Diff -> Bool) -> Eq Diff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Diff -> Diff -> Bool
$c/= :: Diff -> Diff -> Bool
== :: Diff -> Diff -> Bool
$c== :: Diff -> Diff -> Bool
Eq, Eq Diff
Eq Diff
-> (Diff -> Diff -> Ordering)
-> (Diff -> Diff -> Bool)
-> (Diff -> Diff -> Bool)
-> (Diff -> Diff -> Bool)
-> (Diff -> Diff -> Bool)
-> (Diff -> Diff -> Diff)
-> (Diff -> Diff -> Diff)
-> Ord Diff
Diff -> Diff -> Bool
Diff -> Diff -> Ordering
Diff -> Diff -> Diff
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Diff -> Diff -> Diff
$cmin :: Diff -> Diff -> Diff
max :: Diff -> Diff -> Diff
$cmax :: Diff -> Diff -> Diff
>= :: Diff -> Diff -> Bool
$c>= :: Diff -> Diff -> Bool
> :: Diff -> Diff -> Bool
$c> :: Diff -> Diff -> Bool
<= :: Diff -> Diff -> Bool
$c<= :: Diff -> Diff -> Bool
< :: Diff -> Diff -> Bool
$c< :: Diff -> Diff -> Bool
compare :: Diff -> Diff -> Ordering
$ccompare :: Diff -> Diff -> Ordering
Ord, (forall x. Diff -> Rep Diff x)
-> (forall x. Rep Diff x -> Diff) -> Generic Diff
forall x. Rep Diff x -> Diff
forall x. Diff -> Rep Diff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Diff x -> Diff
$cfrom :: forall x. Diff -> Rep Diff x
Generic)

instance NFData Diff where rnf :: Diff -> ()
rnf = Diff -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary Diff

data NewGitReference = NewGitReference
    { NewGitReference -> Text
newGitReferenceRef :: !Text
    , NewGitReference -> Text
newGitReferenceSha :: !Text
    }
  deriving (Int -> NewGitReference -> ShowS
[NewGitReference] -> ShowS
NewGitReference -> String
(Int -> NewGitReference -> ShowS)
-> (NewGitReference -> String)
-> ([NewGitReference] -> ShowS)
-> Show NewGitReference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NewGitReference] -> ShowS
$cshowList :: [NewGitReference] -> ShowS
show :: NewGitReference -> String
$cshow :: NewGitReference -> String
showsPrec :: Int -> NewGitReference -> ShowS
$cshowsPrec :: Int -> NewGitReference -> ShowS
Show, Typeable NewGitReference
Typeable NewGitReference
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NewGitReference -> c NewGitReference)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NewGitReference)
-> (NewGitReference -> Constr)
-> (NewGitReference -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NewGitReference))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NewGitReference))
-> ((forall b. Data b => b -> b)
    -> NewGitReference -> NewGitReference)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NewGitReference -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NewGitReference -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> NewGitReference -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NewGitReference -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NewGitReference -> m NewGitReference)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NewGitReference -> m NewGitReference)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NewGitReference -> m NewGitReference)
-> Data NewGitReference
NewGitReference -> DataType
NewGitReference -> Constr
(forall b. Data b => b -> b) -> NewGitReference -> NewGitReference
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> NewGitReference -> u
forall u. (forall d. Data d => d -> u) -> NewGitReference -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewGitReference
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewGitReference -> c NewGitReference
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewGitReference)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NewGitReference)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NewGitReference -> m NewGitReference
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> NewGitReference -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> NewGitReference -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> NewGitReference -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NewGitReference -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NewGitReference -> r
gmapT :: (forall b. Data b => b -> b) -> NewGitReference -> NewGitReference
$cgmapT :: (forall b. Data b => b -> b) -> NewGitReference -> NewGitReference
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NewGitReference)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NewGitReference)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewGitReference)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NewGitReference)
dataTypeOf :: NewGitReference -> DataType
$cdataTypeOf :: NewGitReference -> DataType
toConstr :: NewGitReference -> Constr
$ctoConstr :: NewGitReference -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewGitReference
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NewGitReference
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewGitReference -> c NewGitReference
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NewGitReference -> c NewGitReference
Data, Typeable, NewGitReference -> NewGitReference -> Bool
(NewGitReference -> NewGitReference -> Bool)
-> (NewGitReference -> NewGitReference -> Bool)
-> Eq NewGitReference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NewGitReference -> NewGitReference -> Bool
$c/= :: NewGitReference -> NewGitReference -> Bool
== :: NewGitReference -> NewGitReference -> Bool
$c== :: NewGitReference -> NewGitReference -> Bool
Eq, Eq NewGitReference
Eq NewGitReference
-> (NewGitReference -> NewGitReference -> Ordering)
-> (NewGitReference -> NewGitReference -> Bool)
-> (NewGitReference -> NewGitReference -> Bool)
-> (NewGitReference -> NewGitReference -> Bool)
-> (NewGitReference -> NewGitReference -> Bool)
-> (NewGitReference -> NewGitReference -> NewGitReference)
-> (NewGitReference -> NewGitReference -> NewGitReference)
-> Ord NewGitReference
NewGitReference -> NewGitReference -> Bool
NewGitReference -> NewGitReference -> Ordering
NewGitReference -> NewGitReference -> NewGitReference
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NewGitReference -> NewGitReference -> NewGitReference
$cmin :: NewGitReference -> NewGitReference -> NewGitReference
max :: NewGitReference -> NewGitReference -> NewGitReference
$cmax :: NewGitReference -> NewGitReference -> NewGitReference
>= :: NewGitReference -> NewGitReference -> Bool
$c>= :: NewGitReference -> NewGitReference -> Bool
> :: NewGitReference -> NewGitReference -> Bool
$c> :: NewGitReference -> NewGitReference -> Bool
<= :: NewGitReference -> NewGitReference -> Bool
$c<= :: NewGitReference -> NewGitReference -> Bool
< :: NewGitReference -> NewGitReference -> Bool
$c< :: NewGitReference -> NewGitReference -> Bool
compare :: NewGitReference -> NewGitReference -> Ordering
$ccompare :: NewGitReference -> NewGitReference -> Ordering
Ord, (forall x. NewGitReference -> Rep NewGitReference x)
-> (forall x. Rep NewGitReference x -> NewGitReference)
-> Generic NewGitReference
forall x. Rep NewGitReference x -> NewGitReference
forall x. NewGitReference -> Rep NewGitReference x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NewGitReference x -> NewGitReference
$cfrom :: forall x. NewGitReference -> Rep NewGitReference x
Generic)

instance NFData NewGitReference where rnf :: NewGitReference -> ()
rnf = NewGitReference -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary NewGitReference

data GitReference = GitReference
    { GitReference -> GitObject
gitReferenceObject :: !GitObject
    , GitReference -> URL
gitReferenceUrl    :: !URL
    , GitReference -> Name GitReference
gitReferenceRef    :: !(Name GitReference)
    }
  deriving (Int -> GitReference -> ShowS
[GitReference] -> ShowS
GitReference -> String
(Int -> GitReference -> ShowS)
-> (GitReference -> String)
-> ([GitReference] -> ShowS)
-> Show GitReference
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitReference] -> ShowS
$cshowList :: [GitReference] -> ShowS
show :: GitReference -> String
$cshow :: GitReference -> String
showsPrec :: Int -> GitReference -> ShowS
$cshowsPrec :: Int -> GitReference -> ShowS
Show, Typeable GitReference
Typeable GitReference
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GitReference -> c GitReference)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GitReference)
-> (GitReference -> Constr)
-> (GitReference -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GitReference))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c GitReference))
-> ((forall b. Data b => b -> b) -> GitReference -> GitReference)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GitReference -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GitReference -> r)
-> (forall u. (forall d. Data d => d -> u) -> GitReference -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GitReference -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GitReference -> m GitReference)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GitReference -> m GitReference)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GitReference -> m GitReference)
-> Data GitReference
GitReference -> DataType
GitReference -> Constr
(forall b. Data b => b -> b) -> GitReference -> GitReference
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GitReference -> u
forall u. (forall d. Data d => d -> u) -> GitReference -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitReference
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitReference -> c GitReference
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitReference)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GitReference)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitReference -> m GitReference
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitReference -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitReference -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> GitReference -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GitReference -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitReference -> r
gmapT :: (forall b. Data b => b -> b) -> GitReference -> GitReference
$cgmapT :: (forall b. Data b => b -> b) -> GitReference -> GitReference
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GitReference)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c GitReference)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitReference)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitReference)
dataTypeOf :: GitReference -> DataType
$cdataTypeOf :: GitReference -> DataType
toConstr :: GitReference -> Constr
$ctoConstr :: GitReference -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitReference
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitReference
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitReference -> c GitReference
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitReference -> c GitReference
Data, Typeable, GitReference -> GitReference -> Bool
(GitReference -> GitReference -> Bool)
-> (GitReference -> GitReference -> Bool) -> Eq GitReference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitReference -> GitReference -> Bool
$c/= :: GitReference -> GitReference -> Bool
== :: GitReference -> GitReference -> Bool
$c== :: GitReference -> GitReference -> Bool
Eq, Eq GitReference
Eq GitReference
-> (GitReference -> GitReference -> Ordering)
-> (GitReference -> GitReference -> Bool)
-> (GitReference -> GitReference -> Bool)
-> (GitReference -> GitReference -> Bool)
-> (GitReference -> GitReference -> Bool)
-> (GitReference -> GitReference -> GitReference)
-> (GitReference -> GitReference -> GitReference)
-> Ord GitReference
GitReference -> GitReference -> Bool
GitReference -> GitReference -> Ordering
GitReference -> GitReference -> GitReference
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GitReference -> GitReference -> GitReference
$cmin :: GitReference -> GitReference -> GitReference
max :: GitReference -> GitReference -> GitReference
$cmax :: GitReference -> GitReference -> GitReference
>= :: GitReference -> GitReference -> Bool
$c>= :: GitReference -> GitReference -> Bool
> :: GitReference -> GitReference -> Bool
$c> :: GitReference -> GitReference -> Bool
<= :: GitReference -> GitReference -> Bool
$c<= :: GitReference -> GitReference -> Bool
< :: GitReference -> GitReference -> Bool
$c< :: GitReference -> GitReference -> Bool
compare :: GitReference -> GitReference -> Ordering
$ccompare :: GitReference -> GitReference -> Ordering
Ord, (forall x. GitReference -> Rep GitReference x)
-> (forall x. Rep GitReference x -> GitReference)
-> Generic GitReference
forall x. Rep GitReference x -> GitReference
forall x. GitReference -> Rep GitReference x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitReference x -> GitReference
$cfrom :: forall x. GitReference -> Rep GitReference x
Generic)

instance NFData GitReference where rnf :: GitReference -> ()
rnf = GitReference -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary GitReference

data GitObject = GitObject
    { GitObject -> Text
gitObjectType :: !Text
    , GitObject -> Text
gitObjectSha  :: !Text
    , GitObject -> URL
gitObjectUrl  :: !URL
    }
  deriving (Int -> GitObject -> ShowS
[GitObject] -> ShowS
GitObject -> String
(Int -> GitObject -> ShowS)
-> (GitObject -> String)
-> ([GitObject] -> ShowS)
-> Show GitObject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitObject] -> ShowS
$cshowList :: [GitObject] -> ShowS
show :: GitObject -> String
$cshow :: GitObject -> String
showsPrec :: Int -> GitObject -> ShowS
$cshowsPrec :: Int -> GitObject -> ShowS
Show, Typeable GitObject
Typeable GitObject
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GitObject -> c GitObject)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GitObject)
-> (GitObject -> Constr)
-> (GitObject -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GitObject))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitObject))
-> ((forall b. Data b => b -> b) -> GitObject -> GitObject)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GitObject -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GitObject -> r)
-> (forall u. (forall d. Data d => d -> u) -> GitObject -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> GitObject -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GitObject -> m GitObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GitObject -> m GitObject)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GitObject -> m GitObject)
-> Data GitObject
GitObject -> DataType
GitObject -> Constr
(forall b. Data b => b -> b) -> GitObject -> GitObject
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GitObject -> u
forall u. (forall d. Data d => d -> u) -> GitObject -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitObject
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitObject -> c GitObject
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitObject)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitObject)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitObject -> m GitObject
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitObject -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitObject -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> GitObject -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GitObject -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitObject -> r
gmapT :: (forall b. Data b => b -> b) -> GitObject -> GitObject
$cgmapT :: (forall b. Data b => b -> b) -> GitObject -> GitObject
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitObject)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitObject)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitObject)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitObject)
dataTypeOf :: GitObject -> DataType
$cdataTypeOf :: GitObject -> DataType
toConstr :: GitObject -> Constr
$ctoConstr :: GitObject -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitObject
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitObject
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitObject -> c GitObject
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitObject -> c GitObject
Data, Typeable, GitObject -> GitObject -> Bool
(GitObject -> GitObject -> Bool)
-> (GitObject -> GitObject -> Bool) -> Eq GitObject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitObject -> GitObject -> Bool
$c/= :: GitObject -> GitObject -> Bool
== :: GitObject -> GitObject -> Bool
$c== :: GitObject -> GitObject -> Bool
Eq, Eq GitObject
Eq GitObject
-> (GitObject -> GitObject -> Ordering)
-> (GitObject -> GitObject -> Bool)
-> (GitObject -> GitObject -> Bool)
-> (GitObject -> GitObject -> Bool)
-> (GitObject -> GitObject -> Bool)
-> (GitObject -> GitObject -> GitObject)
-> (GitObject -> GitObject -> GitObject)
-> Ord GitObject
GitObject -> GitObject -> Bool
GitObject -> GitObject -> Ordering
GitObject -> GitObject -> GitObject
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GitObject -> GitObject -> GitObject
$cmin :: GitObject -> GitObject -> GitObject
max :: GitObject -> GitObject -> GitObject
$cmax :: GitObject -> GitObject -> GitObject
>= :: GitObject -> GitObject -> Bool
$c>= :: GitObject -> GitObject -> Bool
> :: GitObject -> GitObject -> Bool
$c> :: GitObject -> GitObject -> Bool
<= :: GitObject -> GitObject -> Bool
$c<= :: GitObject -> GitObject -> Bool
< :: GitObject -> GitObject -> Bool
$c< :: GitObject -> GitObject -> Bool
compare :: GitObject -> GitObject -> Ordering
$ccompare :: GitObject -> GitObject -> Ordering
Ord, (forall x. GitObject -> Rep GitObject x)
-> (forall x. Rep GitObject x -> GitObject) -> Generic GitObject
forall x. Rep GitObject x -> GitObject
forall x. GitObject -> Rep GitObject x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitObject x -> GitObject
$cfrom :: forall x. GitObject -> Rep GitObject x
Generic)

instance NFData GitObject where rnf :: GitObject -> ()
rnf = GitObject -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary GitObject

data GitUser = GitUser
    { GitUser -> Text
gitUserName  :: !Text
    , GitUser -> Text
gitUserEmail :: !Text
    , GitUser -> UTCTime
gitUserDate  :: !UTCTime
    }
  deriving (Int -> GitUser -> ShowS
[GitUser] -> ShowS
GitUser -> String
(Int -> GitUser -> ShowS)
-> (GitUser -> String) -> ([GitUser] -> ShowS) -> Show GitUser
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GitUser] -> ShowS
$cshowList :: [GitUser] -> ShowS
show :: GitUser -> String
$cshow :: GitUser -> String
showsPrec :: Int -> GitUser -> ShowS
$cshowsPrec :: Int -> GitUser -> ShowS
Show, Typeable GitUser
Typeable GitUser
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GitUser -> c GitUser)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c GitUser)
-> (GitUser -> Constr)
-> (GitUser -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c GitUser))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitUser))
-> ((forall b. Data b => b -> b) -> GitUser -> GitUser)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GitUser -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GitUser -> r)
-> (forall u. (forall d. Data d => d -> u) -> GitUser -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> GitUser -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> GitUser -> m GitUser)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GitUser -> m GitUser)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> GitUser -> m GitUser)
-> Data GitUser
GitUser -> DataType
GitUser -> Constr
(forall b. Data b => b -> b) -> GitUser -> GitUser
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> GitUser -> u
forall u. (forall d. Data d => d -> u) -> GitUser -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitUser
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitUser -> c GitUser
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitUser)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitUser)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> GitUser -> m GitUser
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitUser -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> GitUser -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> GitUser -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> GitUser -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> GitUser -> r
gmapT :: (forall b. Data b => b -> b) -> GitUser -> GitUser
$cgmapT :: (forall b. Data b => b -> b) -> GitUser -> GitUser
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitUser)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GitUser)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitUser)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c GitUser)
dataTypeOf :: GitUser -> DataType
$cdataTypeOf :: GitUser -> DataType
toConstr :: GitUser -> Constr
$ctoConstr :: GitUser -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitUser
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c GitUser
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitUser -> c GitUser
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> GitUser -> c GitUser
Data, Typeable, GitUser -> GitUser -> Bool
(GitUser -> GitUser -> Bool)
-> (GitUser -> GitUser -> Bool) -> Eq GitUser
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GitUser -> GitUser -> Bool
$c/= :: GitUser -> GitUser -> Bool
== :: GitUser -> GitUser -> Bool
$c== :: GitUser -> GitUser -> Bool
Eq, Eq GitUser
Eq GitUser
-> (GitUser -> GitUser -> Ordering)
-> (GitUser -> GitUser -> Bool)
-> (GitUser -> GitUser -> Bool)
-> (GitUser -> GitUser -> Bool)
-> (GitUser -> GitUser -> Bool)
-> (GitUser -> GitUser -> GitUser)
-> (GitUser -> GitUser -> GitUser)
-> Ord GitUser
GitUser -> GitUser -> Bool
GitUser -> GitUser -> Ordering
GitUser -> GitUser -> GitUser
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: GitUser -> GitUser -> GitUser
$cmin :: GitUser -> GitUser -> GitUser
max :: GitUser -> GitUser -> GitUser
$cmax :: GitUser -> GitUser -> GitUser
>= :: GitUser -> GitUser -> Bool
$c>= :: GitUser -> GitUser -> Bool
> :: GitUser -> GitUser -> Bool
$c> :: GitUser -> GitUser -> Bool
<= :: GitUser -> GitUser -> Bool
$c<= :: GitUser -> GitUser -> Bool
< :: GitUser -> GitUser -> Bool
$c< :: GitUser -> GitUser -> Bool
compare :: GitUser -> GitUser -> Ordering
$ccompare :: GitUser -> GitUser -> Ordering
Ord, (forall x. GitUser -> Rep GitUser x)
-> (forall x. Rep GitUser x -> GitUser) -> Generic GitUser
forall x. Rep GitUser x -> GitUser
forall x. GitUser -> Rep GitUser x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GitUser x -> GitUser
$cfrom :: forall x. GitUser -> Rep GitUser x
Generic)

instance NFData GitUser where rnf :: GitUser -> ()
rnf = GitUser -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary GitUser

data File = File
    { File -> Maybe URL
fileBlobUrl   :: !(Maybe URL)
    , File -> Text
fileStatus    :: !Text
    , File -> Maybe URL
fileRawUrl    :: !(Maybe URL)
    , File -> Int
fileAdditions :: !Int
    , File -> Maybe Text
fileSha       :: !(Maybe Text)
    , File -> Int
fileChanges   :: !Int
    , File -> Maybe Text
filePatch     :: !(Maybe Text)
    , File -> Text
fileFilename  :: !Text
    , File -> Int
fileDeletions :: !Int
    }
  deriving (Int -> File -> ShowS
[File] -> ShowS
File -> String
(Int -> File -> ShowS)
-> (File -> String) -> ([File] -> ShowS) -> Show File
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [File] -> ShowS
$cshowList :: [File] -> ShowS
show :: File -> String
$cshow :: File -> String
showsPrec :: Int -> File -> ShowS
$cshowsPrec :: Int -> File -> ShowS
Show, Typeable File
Typeable File
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> File -> c File)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c File)
-> (File -> Constr)
-> (File -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c File))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File))
-> ((forall b. Data b => b -> b) -> File -> File)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r)
-> (forall u. (forall d. Data d => d -> u) -> File -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> File -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> File -> m File)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> File -> m File)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> File -> m File)
-> Data File
File -> DataType
File -> Constr
(forall b. Data b => b -> b) -> File -> File
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> File -> u
forall u. (forall d. Data d => d -> u) -> File -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> File -> m File
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File -> m File
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c File
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> File -> c File
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c File)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File -> m File
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File -> m File
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File -> m File
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> File -> m File
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> File -> m File
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> File -> m File
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> File -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> File -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> File -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> File -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r
gmapT :: (forall b. Data b => b -> b) -> File -> File
$cgmapT :: (forall b. Data b => b -> b) -> File -> File
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c File)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c File)
dataTypeOf :: File -> DataType
$cdataTypeOf :: File -> DataType
toConstr :: File -> Constr
$ctoConstr :: File -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c File
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c File
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> File -> c File
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> File -> c File
Data, Typeable, File -> File -> Bool
(File -> File -> Bool) -> (File -> File -> Bool) -> Eq File
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: File -> File -> Bool
$c/= :: File -> File -> Bool
== :: File -> File -> Bool
$c== :: File -> File -> Bool
Eq, Eq File
Eq File
-> (File -> File -> Ordering)
-> (File -> File -> Bool)
-> (File -> File -> Bool)
-> (File -> File -> Bool)
-> (File -> File -> Bool)
-> (File -> File -> File)
-> (File -> File -> File)
-> Ord File
File -> File -> Bool
File -> File -> Ordering
File -> File -> File
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: File -> File -> File
$cmin :: File -> File -> File
max :: File -> File -> File
$cmax :: File -> File -> File
>= :: File -> File -> Bool
$c>= :: File -> File -> Bool
> :: File -> File -> Bool
$c> :: File -> File -> Bool
<= :: File -> File -> Bool
$c<= :: File -> File -> Bool
< :: File -> File -> Bool
$c< :: File -> File -> Bool
compare :: File -> File -> Ordering
$ccompare :: File -> File -> Ordering
Ord, (forall x. File -> Rep File x)
-> (forall x. Rep File x -> File) -> Generic File
forall x. Rep File x -> File
forall x. File -> Rep File x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep File x -> File
$cfrom :: forall x. File -> Rep File x
Generic)

instance NFData File where rnf :: File -> ()
rnf = File -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf
instance Binary File

-- JSON instances

instance FromJSON Stats where
    parseJSON :: Value -> Parser Stats
parseJSON = String -> (Object -> Parser Stats) -> Value -> Parser Stats
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Stats" ((Object -> Parser Stats) -> Value -> Parser Stats)
-> (Object -> Parser Stats) -> Value -> Parser Stats
forall a b. (a -> b) -> a -> b
$ \Object
o -> Int -> Int -> Int -> Stats
Stats
        (Int -> Int -> Int -> Stats)
-> Parser Int -> Parser (Int -> Int -> Stats)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"additions"
        Parser (Int -> Int -> Stats) -> Parser Int -> Parser (Int -> Stats)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total"
        Parser (Int -> Stats) -> Parser Int -> Parser Stats
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"deletions"

instance FromJSON Commit where
    parseJSON :: Value -> Parser Commit
parseJSON = String -> (Object -> Parser Commit) -> Value -> Parser Commit
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Commit" ((Object -> Parser Commit) -> Value -> Parser Commit)
-> (Object -> Parser Commit) -> Value -> Parser Commit
forall a b. (a -> b) -> a -> b
$ \Object
o -> Name Commit
-> Vector Tree
-> URL
-> GitCommit
-> Maybe SimpleUser
-> Maybe SimpleUser
-> Vector File
-> Maybe Stats
-> Commit
Commit
        (Name Commit
 -> Vector Tree
 -> URL
 -> GitCommit
 -> Maybe SimpleUser
 -> Maybe SimpleUser
 -> Vector File
 -> Maybe Stats
 -> Commit)
-> Parser (Name Commit)
-> Parser
     (Vector Tree
      -> URL
      -> GitCommit
      -> Maybe SimpleUser
      -> Maybe SimpleUser
      -> Vector File
      -> Maybe Stats
      -> Commit)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Name Commit)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        Parser
  (Vector Tree
   -> URL
   -> GitCommit
   -> Maybe SimpleUser
   -> Maybe SimpleUser
   -> Vector File
   -> Maybe Stats
   -> Commit)
-> Parser (Vector Tree)
-> Parser
     (URL
      -> GitCommit
      -> Maybe SimpleUser
      -> Maybe SimpleUser
      -> Vector File
      -> Maybe Stats
      -> Commit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Vector Tree)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"parents"
        Parser
  (URL
   -> GitCommit
   -> Maybe SimpleUser
   -> Maybe SimpleUser
   -> Vector File
   -> Maybe Stats
   -> Commit)
-> Parser URL
-> Parser
     (GitCommit
      -> Maybe SimpleUser
      -> Maybe SimpleUser
      -> Vector File
      -> Maybe Stats
      -> Commit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        Parser
  (GitCommit
   -> Maybe SimpleUser
   -> Maybe SimpleUser
   -> Vector File
   -> Maybe Stats
   -> Commit)
-> Parser GitCommit
-> Parser
     (Maybe SimpleUser
      -> Maybe SimpleUser -> Vector File -> Maybe Stats -> Commit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser GitCommit
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commit"
        Parser
  (Maybe SimpleUser
   -> Maybe SimpleUser -> Vector File -> Maybe Stats -> Commit)
-> Parser (Maybe SimpleUser)
-> Parser
     (Maybe SimpleUser -> Vector File -> Maybe Stats -> Commit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe SimpleUser)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"committer"
        Parser (Maybe SimpleUser -> Vector File -> Maybe Stats -> Commit)
-> Parser (Maybe SimpleUser)
-> Parser (Vector File -> Maybe Stats -> Commit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe SimpleUser)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"author"
        Parser (Vector File -> Maybe Stats -> Commit)
-> Parser (Vector File) -> Parser (Maybe Stats -> Commit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe (Vector File))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"files" Parser (Maybe (Vector File)) -> Vector File -> Parser (Vector File)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Vector File
forall a. Vector a
V.empty
        Parser (Maybe Stats -> Commit)
-> Parser (Maybe Stats) -> Parser Commit
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Stats)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"stats"

instance FromJSON Tree where
    parseJSON :: Value -> Parser Tree
parseJSON = String -> (Object -> Parser Tree) -> Value -> Parser Tree
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Tree" ((Object -> Parser Tree) -> Value -> Parser Tree)
-> (Object -> Parser Tree) -> Value -> Parser Tree
forall a b. (a -> b) -> a -> b
$ \Object
o -> Name Tree -> URL -> Vector GitTree -> Tree
Tree
        (Name Tree -> URL -> Vector GitTree -> Tree)
-> Parser (Name Tree) -> Parser (URL -> Vector GitTree -> Tree)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Name Tree)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        Parser (URL -> Vector GitTree -> Tree)
-> Parser URL -> Parser (Vector GitTree -> Tree)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        Parser (Vector GitTree -> Tree)
-> Parser (Vector GitTree) -> Parser Tree
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe (Vector GitTree))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"tree" Parser (Maybe (Vector GitTree))
-> Vector GitTree -> Parser (Vector GitTree)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Vector GitTree
forall a. Vector a
V.empty

instance FromJSON GitTree where
    parseJSON :: Value -> Parser GitTree
parseJSON = String -> (Object -> Parser GitTree) -> Value -> Parser GitTree
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GitTree" ((Object -> Parser GitTree) -> Value -> Parser GitTree)
-> (Object -> Parser GitTree) -> Value -> Parser GitTree
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text
-> Name GitTree
-> Maybe URL
-> Maybe Int
-> Text
-> Text
-> GitTree
GitTree
        (Text
 -> Name GitTree
 -> Maybe URL
 -> Maybe Int
 -> Text
 -> Text
 -> GitTree)
-> Parser Text
-> Parser
     (Name GitTree -> Maybe URL -> Maybe Int -> Text -> Text -> GitTree)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
        Parser
  (Name GitTree -> Maybe URL -> Maybe Int -> Text -> Text -> GitTree)
-> Parser (Name GitTree)
-> Parser (Maybe URL -> Maybe Int -> Text -> Text -> GitTree)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Name GitTree)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        Parser (Maybe URL -> Maybe Int -> Text -> Text -> GitTree)
-> Parser (Maybe URL)
-> Parser (Maybe Int -> Text -> Text -> GitTree)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"url"
        Parser (Maybe Int -> Text -> Text -> GitTree)
-> Parser (Maybe Int) -> Parser (Text -> Text -> GitTree)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"size"
        Parser (Text -> Text -> GitTree)
-> Parser Text -> Parser (Text -> GitTree)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
        Parser (Text -> GitTree) -> Parser Text -> Parser GitTree
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"mode"

instance FromJSON GitCommit where
    parseJSON :: Value -> Parser GitCommit
parseJSON = String -> (Object -> Parser GitCommit) -> Value -> Parser GitCommit
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GitCommit" ((Object -> Parser GitCommit) -> Value -> Parser GitCommit)
-> (Object -> Parser GitCommit) -> Value -> Parser GitCommit
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text
-> URL
-> GitUser
-> GitUser
-> Tree
-> Maybe (Name GitCommit)
-> Vector Tree
-> GitCommit
GitCommit
        (Text
 -> URL
 -> GitUser
 -> GitUser
 -> Tree
 -> Maybe (Name GitCommit)
 -> Vector Tree
 -> GitCommit)
-> Parser Text
-> Parser
     (URL
      -> GitUser
      -> GitUser
      -> Tree
      -> Maybe (Name GitCommit)
      -> Vector Tree
      -> GitCommit)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"message"
        Parser
  (URL
   -> GitUser
   -> GitUser
   -> Tree
   -> Maybe (Name GitCommit)
   -> Vector Tree
   -> GitCommit)
-> Parser URL
-> Parser
     (GitUser
      -> GitUser
      -> Tree
      -> Maybe (Name GitCommit)
      -> Vector Tree
      -> GitCommit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        Parser
  (GitUser
   -> GitUser
   -> Tree
   -> Maybe (Name GitCommit)
   -> Vector Tree
   -> GitCommit)
-> Parser GitUser
-> Parser
     (GitUser
      -> Tree -> Maybe (Name GitCommit) -> Vector Tree -> GitCommit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser GitUser
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"committer"
        Parser
  (GitUser
   -> Tree -> Maybe (Name GitCommit) -> Vector Tree -> GitCommit)
-> Parser GitUser
-> Parser
     (Tree -> Maybe (Name GitCommit) -> Vector Tree -> GitCommit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser GitUser
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"author"
        Parser (Tree -> Maybe (Name GitCommit) -> Vector Tree -> GitCommit)
-> Parser Tree
-> Parser (Maybe (Name GitCommit) -> Vector Tree -> GitCommit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Tree
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"tree"
        Parser (Maybe (Name GitCommit) -> Vector Tree -> GitCommit)
-> Parser (Maybe (Name GitCommit))
-> Parser (Vector Tree -> GitCommit)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe (Name GitCommit))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"sha"
        Parser (Vector Tree -> GitCommit)
-> Parser (Vector Tree) -> Parser GitCommit
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe (Vector Tree))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parents" Parser (Maybe (Vector Tree)) -> Vector Tree -> Parser (Vector Tree)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Vector Tree
forall a. Vector a
V.empty

instance FromJSON GitUser where
    parseJSON :: Value -> Parser GitUser
parseJSON = String -> (Object -> Parser GitUser) -> Value -> Parser GitUser
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GitUser" ((Object -> Parser GitUser) -> Value -> Parser GitUser)
-> (Object -> Parser GitUser) -> Value -> Parser GitUser
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> Text -> UTCTime -> GitUser
GitUser
        (Text -> Text -> UTCTime -> GitUser)
-> Parser Text -> Parser (Text -> UTCTime -> GitUser)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        Parser (Text -> UTCTime -> GitUser)
-> Parser Text -> Parser (UTCTime -> GitUser)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"email"
        Parser (UTCTime -> GitUser) -> Parser UTCTime -> Parser GitUser
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser UTCTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"date"

instance FromJSON File where
    parseJSON :: Value -> Parser File
parseJSON = String -> (Object -> Parser File) -> Value -> Parser File
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"File" ((Object -> Parser File) -> Value -> Parser File)
-> (Object -> Parser File) -> Value -> Parser File
forall a b. (a -> b) -> a -> b
$ \Object
o -> Maybe URL
-> Text
-> Maybe URL
-> Int
-> Maybe Text
-> Int
-> Maybe Text
-> Text
-> Int
-> File
File
        (Maybe URL
 -> Text
 -> Maybe URL
 -> Int
 -> Maybe Text
 -> Int
 -> Maybe Text
 -> Text
 -> Int
 -> File)
-> Parser (Maybe URL)
-> Parser
     (Text
      -> Maybe URL
      -> Int
      -> Maybe Text
      -> Int
      -> Maybe Text
      -> Text
      -> Int
      -> File)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"blob_url"
        Parser
  (Text
   -> Maybe URL
   -> Int
   -> Maybe Text
   -> Int
   -> Maybe Text
   -> Text
   -> Int
   -> File)
-> Parser Text
-> Parser
     (Maybe URL
      -> Int -> Maybe Text -> Int -> Maybe Text -> Text -> Int -> File)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"status"
        Parser
  (Maybe URL
   -> Int -> Maybe Text -> Int -> Maybe Text -> Text -> Int -> File)
-> Parser (Maybe URL)
-> Parser
     (Int -> Maybe Text -> Int -> Maybe Text -> Text -> Int -> File)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe URL)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"raw_url"
        Parser
  (Int -> Maybe Text -> Int -> Maybe Text -> Text -> Int -> File)
-> Parser Int
-> Parser (Maybe Text -> Int -> Maybe Text -> Text -> Int -> File)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"additions"
        Parser (Maybe Text -> Int -> Maybe Text -> Text -> Int -> File)
-> Parser (Maybe Text)
-> Parser (Int -> Maybe Text -> Text -> Int -> File)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"sha"
        Parser (Int -> Maybe Text -> Text -> Int -> File)
-> Parser Int -> Parser (Maybe Text -> Text -> Int -> File)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"changes"
        Parser (Maybe Text -> Text -> Int -> File)
-> Parser (Maybe Text) -> Parser (Text -> Int -> File)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"patch"
        Parser (Text -> Int -> File) -> Parser Text -> Parser (Int -> File)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"filename"
        Parser (Int -> File) -> Parser Int -> Parser File
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"deletions"

instance ToJSON NewGitReference where
    toJSON :: NewGitReference -> Value
toJSON (NewGitReference Text
r Text
s) = [Pair] -> Value
object [ Key
"ref" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
r, Key
"sha" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
s  ]

instance FromJSON GitReference where
    parseJSON :: Value -> Parser GitReference
parseJSON = String
-> (Object -> Parser GitReference) -> Value -> Parser GitReference
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GitReference" ((Object -> Parser GitReference) -> Value -> Parser GitReference)
-> (Object -> Parser GitReference) -> Value -> Parser GitReference
forall a b. (a -> b) -> a -> b
$ \Object
o -> GitObject -> URL -> Name GitReference -> GitReference
GitReference
        (GitObject -> URL -> Name GitReference -> GitReference)
-> Parser GitObject
-> Parser (URL -> Name GitReference -> GitReference)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser GitObject
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object"
        Parser (URL -> Name GitReference -> GitReference)
-> Parser URL -> Parser (Name GitReference -> GitReference)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        Parser (Name GitReference -> GitReference)
-> Parser (Name GitReference) -> Parser GitReference
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Name GitReference)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ref"

instance FromJSON GitObject where
    parseJSON :: Value -> Parser GitObject
parseJSON = String -> (Object -> Parser GitObject) -> Value -> Parser GitObject
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GitObject" ((Object -> Parser GitObject) -> Value -> Parser GitObject)
-> (Object -> Parser GitObject) -> Value -> Parser GitObject
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> Text -> URL -> GitObject
GitObject
        (Text -> Text -> URL -> GitObject)
-> Parser Text -> Parser (Text -> URL -> GitObject)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
        Parser (Text -> URL -> GitObject)
-> Parser Text -> Parser (URL -> GitObject)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        Parser (URL -> GitObject) -> Parser URL -> Parser GitObject
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"

instance FromJSON Diff where
    parseJSON :: Value -> Parser Diff
parseJSON = String -> (Object -> Parser Diff) -> Value -> Parser Diff
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Diff" ((Object -> Parser Diff) -> Value -> Parser Diff)
-> (Object -> Parser Diff) -> Value -> Parser Diff
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text
-> Int
-> URL
-> URL
-> Commit
-> Vector Commit
-> Int
-> URL
-> Vector File
-> Int
-> URL
-> URL
-> Diff
Diff
        (Text
 -> Int
 -> URL
 -> URL
 -> Commit
 -> Vector Commit
 -> Int
 -> URL
 -> Vector File
 -> Int
 -> URL
 -> URL
 -> Diff)
-> Parser Text
-> Parser
     (Int
      -> URL
      -> URL
      -> Commit
      -> Vector Commit
      -> Int
      -> URL
      -> Vector File
      -> Int
      -> URL
      -> URL
      -> Diff)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"status"
        Parser
  (Int
   -> URL
   -> URL
   -> Commit
   -> Vector Commit
   -> Int
   -> URL
   -> Vector File
   -> Int
   -> URL
   -> URL
   -> Diff)
-> Parser Int
-> Parser
     (URL
      -> URL
      -> Commit
      -> Vector Commit
      -> Int
      -> URL
      -> Vector File
      -> Int
      -> URL
      -> URL
      -> Diff)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"behind_by"
        Parser
  (URL
   -> URL
   -> Commit
   -> Vector Commit
   -> Int
   -> URL
   -> Vector File
   -> Int
   -> URL
   -> URL
   -> Diff)
-> Parser URL
-> Parser
     (URL
      -> Commit
      -> Vector Commit
      -> Int
      -> URL
      -> Vector File
      -> Int
      -> URL
      -> URL
      -> Diff)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"patch_url"
        Parser
  (URL
   -> Commit
   -> Vector Commit
   -> Int
   -> URL
   -> Vector File
   -> Int
   -> URL
   -> URL
   -> Diff)
-> Parser URL
-> Parser
     (Commit
      -> Vector Commit
      -> Int
      -> URL
      -> Vector File
      -> Int
      -> URL
      -> URL
      -> Diff)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        Parser
  (Commit
   -> Vector Commit
   -> Int
   -> URL
   -> Vector File
   -> Int
   -> URL
   -> URL
   -> Diff)
-> Parser Commit
-> Parser
     (Vector Commit
      -> Int -> URL -> Vector File -> Int -> URL -> URL -> Diff)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Commit
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"base_commit"
        Parser
  (Vector Commit
   -> Int -> URL -> Vector File -> Int -> URL -> URL -> Diff)
-> Parser (Vector Commit)
-> Parser (Int -> URL -> Vector File -> Int -> URL -> URL -> Diff)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe (Vector Commit))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"commits" Parser (Maybe (Vector Commit))
-> Vector Commit -> Parser (Vector Commit)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Vector Commit
forall a. Vector a
V.empty
        Parser (Int -> URL -> Vector File -> Int -> URL -> URL -> Diff)
-> Parser Int
-> Parser (URL -> Vector File -> Int -> URL -> URL -> Diff)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total_commits"
        Parser (URL -> Vector File -> Int -> URL -> URL -> Diff)
-> Parser URL -> Parser (Vector File -> Int -> URL -> URL -> Diff)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"html_url"
        Parser (Vector File -> Int -> URL -> URL -> Diff)
-> Parser (Vector File) -> Parser (Int -> URL -> URL -> Diff)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe (Vector File))
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"files" Parser (Maybe (Vector File)) -> Vector File -> Parser (Vector File)
forall a. Parser (Maybe a) -> a -> Parser a
.!= Vector File
forall a. Vector a
V.empty
        Parser (Int -> URL -> URL -> Diff)
-> Parser Int -> Parser (URL -> URL -> Diff)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ahead_by"
        Parser (URL -> URL -> Diff) -> Parser URL -> Parser (URL -> Diff)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"diff_url"
        Parser (URL -> Diff) -> Parser URL -> Parser Diff
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"permalink_url"

instance FromJSON Blob where
    parseJSON :: Value -> Parser Blob
parseJSON = String -> (Object -> Parser Blob) -> Value -> Parser Blob
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Blob" ((Object -> Parser Blob) -> Value -> Parser Blob)
-> (Object -> Parser Blob) -> Value -> Parser Blob
forall a b. (a -> b) -> a -> b
$ \Object
o -> URL -> Text -> Text -> Name Blob -> Int -> Blob
Blob
        (URL -> Text -> Text -> Name Blob -> Int -> Blob)
-> Parser URL -> Parser (Text -> Text -> Name Blob -> Int -> Blob)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"
        Parser (Text -> Text -> Name Blob -> Int -> Blob)
-> Parser Text -> Parser (Text -> Name Blob -> Int -> Blob)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"encoding"
        Parser (Text -> Name Blob -> Int -> Blob)
-> Parser Text -> Parser (Name Blob -> Int -> Blob)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"content"
        Parser (Name Blob -> Int -> Blob)
-> Parser (Name Blob) -> Parser (Int -> Blob)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Name Blob)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        Parser (Int -> Blob) -> Parser Int -> Parser Blob
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"size"

instance FromJSON Tag where
    parseJSON :: Value -> Parser Tag
parseJSON = String -> (Object -> Parser Tag) -> Value -> Parser Tag
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Tag" ((Object -> Parser Tag) -> Value -> Parser Tag)
-> (Object -> Parser Tag) -> Value -> Parser Tag
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> URL -> URL -> BranchCommit -> Tag
Tag
        (Text -> URL -> URL -> BranchCommit -> Tag)
-> Parser Text -> Parser (URL -> URL -> BranchCommit -> Tag)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        Parser (URL -> URL -> BranchCommit -> Tag)
-> Parser URL -> Parser (URL -> BranchCommit -> Tag)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"zipball_url"
        Parser (URL -> BranchCommit -> Tag)
-> Parser URL -> Parser (BranchCommit -> Tag)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"tarball_url"
        Parser (BranchCommit -> Tag) -> Parser BranchCommit -> Parser Tag
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser BranchCommit
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commit"

instance FromJSON Branch where
    parseJSON :: Value -> Parser Branch
parseJSON = String -> (Object -> Parser Branch) -> Value -> Parser Branch
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Branch" ((Object -> Parser Branch) -> Value -> Parser Branch)
-> (Object -> Parser Branch) -> Value -> Parser Branch
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> BranchCommit -> Branch
Branch
        (Text -> BranchCommit -> Branch)
-> Parser Text -> Parser (BranchCommit -> Branch)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
        Parser (BranchCommit -> Branch)
-> Parser BranchCommit -> Parser Branch
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser BranchCommit
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commit"

instance FromJSON BranchCommit where
    parseJSON :: Value -> Parser BranchCommit
parseJSON = String
-> (Object -> Parser BranchCommit) -> Value -> Parser BranchCommit
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"BranchCommit" ((Object -> Parser BranchCommit) -> Value -> Parser BranchCommit)
-> (Object -> Parser BranchCommit) -> Value -> Parser BranchCommit
forall a b. (a -> b) -> a -> b
$ \Object
o -> Text -> URL -> BranchCommit
BranchCommit
        (Text -> URL -> BranchCommit)
-> Parser Text -> Parser (URL -> BranchCommit)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
        Parser (URL -> BranchCommit) -> Parser URL -> Parser BranchCommit
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser URL
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"url"