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

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

data Comment = Comment
    { Comment -> Maybe Int
commentPosition  :: !(Maybe Int)
    , Comment -> Maybe Int
commentLine      :: !(Maybe Int)
    , Comment -> Text
commentBody      :: !Text
    , Comment -> Maybe Text
commentCommitId  :: !(Maybe Text)
    , Comment -> UTCTime
commentUpdatedAt :: !UTCTime
    , Comment -> Maybe URL
commentHtmlUrl   :: !(Maybe URL)
    , Comment -> URL
commentUrl       :: !URL
    , Comment -> Maybe UTCTime
commentCreatedAt :: !(Maybe UTCTime)
    , Comment -> Maybe Text
commentPath      :: !(Maybe Text)
    , Comment -> SimpleUser
commentUser      :: !SimpleUser
    , Comment -> Id Comment
commentId        :: !(Id Comment)
    }
  deriving (Int -> Comment -> ShowS
[Comment] -> ShowS
Comment -> String
(Int -> Comment -> ShowS)
-> (Comment -> String) -> ([Comment] -> ShowS) -> Show Comment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Comment] -> ShowS
$cshowList :: [Comment] -> ShowS
show :: Comment -> String
$cshow :: Comment -> String
showsPrec :: Int -> Comment -> ShowS
$cshowsPrec :: Int -> Comment -> ShowS
Show, Typeable Comment
DataType
Constr
Typeable Comment
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Comment -> c Comment)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Comment)
-> (Comment -> Constr)
-> (Comment -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Comment))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment))
-> ((forall b. Data b => b -> b) -> Comment -> Comment)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Comment -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Comment -> r)
-> (forall u. (forall d. Data d => d -> u) -> Comment -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Comment -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Comment -> m Comment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Comment -> m Comment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Comment -> m Comment)
-> Data Comment
Comment -> DataType
Comment -> Constr
(forall b. Data b => b -> b) -> Comment -> Comment
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Comment -> c Comment
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Comment
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) -> Comment -> u
forall u. (forall d. Data d => d -> u) -> Comment -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Comment
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Comment -> c Comment
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Comment)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment)
$cComment :: Constr
$tComment :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Comment -> m Comment
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
gmapMp :: (forall d. Data d => d -> m d) -> Comment -> m Comment
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
gmapM :: (forall d. Data d => d -> m d) -> Comment -> m Comment
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Comment -> m Comment
gmapQi :: Int -> (forall d. Data d => d -> u) -> Comment -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Comment -> u
gmapQ :: (forall d. Data d => d -> u) -> Comment -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Comment -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Comment -> r
gmapT :: (forall b. Data b => b -> b) -> Comment -> Comment
$cgmapT :: (forall b. Data b => b -> b) -> Comment -> Comment
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Comment)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Comment)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Comment)
dataTypeOf :: Comment -> DataType
$cdataTypeOf :: Comment -> DataType
toConstr :: Comment -> Constr
$ctoConstr :: Comment -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Comment
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Comment
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Comment -> c Comment
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Comment -> c Comment
$cp1Data :: Typeable Comment
Data, Typeable, Comment -> Comment -> Bool
(Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool) -> Eq Comment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Comment -> Comment -> Bool
$c/= :: Comment -> Comment -> Bool
== :: Comment -> Comment -> Bool
$c== :: Comment -> Comment -> Bool
Eq, Eq Comment
Eq Comment
-> (Comment -> Comment -> Ordering)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Bool)
-> (Comment -> Comment -> Comment)
-> (Comment -> Comment -> Comment)
-> Ord Comment
Comment -> Comment -> Bool
Comment -> Comment -> Ordering
Comment -> Comment -> Comment
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 :: Comment -> Comment -> Comment
$cmin :: Comment -> Comment -> Comment
max :: Comment -> Comment -> Comment
$cmax :: Comment -> Comment -> Comment
>= :: Comment -> Comment -> Bool
$c>= :: Comment -> Comment -> Bool
> :: Comment -> Comment -> Bool
$c> :: Comment -> Comment -> Bool
<= :: Comment -> Comment -> Bool
$c<= :: Comment -> Comment -> Bool
< :: Comment -> Comment -> Bool
$c< :: Comment -> Comment -> Bool
compare :: Comment -> Comment -> Ordering
$ccompare :: Comment -> Comment -> Ordering
$cp1Ord :: Eq Comment
Ord, (forall x. Comment -> Rep Comment x)
-> (forall x. Rep Comment x -> Comment) -> Generic Comment
forall x. Rep Comment x -> Comment
forall x. Comment -> Rep Comment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Comment x -> Comment
$cfrom :: forall x. Comment -> Rep Comment x
Generic)

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

instance FromJSON Comment where
    parseJSON :: Value -> Parser Comment
parseJSON = String -> (Object -> Parser Comment) -> Value -> Parser Comment
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Comment" ((Object -> Parser Comment) -> Value -> Parser Comment)
-> (Object -> Parser Comment) -> Value -> Parser Comment
forall a b. (a -> b) -> a -> b
$ \Object
o -> Maybe Int
-> Maybe Int
-> Text
-> Maybe Text
-> UTCTime
-> Maybe URL
-> URL
-> Maybe UTCTime
-> Maybe Text
-> SimpleUser
-> Id Comment
-> Comment
Comment
        (Maybe Int
 -> Maybe Int
 -> Text
 -> Maybe Text
 -> UTCTime
 -> Maybe URL
 -> URL
 -> Maybe UTCTime
 -> Maybe Text
 -> SimpleUser
 -> Id Comment
 -> Comment)
-> Parser (Maybe Int)
-> Parser
     (Maybe Int
      -> Text
      -> Maybe Text
      -> UTCTime
      -> Maybe URL
      -> URL
      -> Maybe UTCTime
      -> Maybe Text
      -> SimpleUser
      -> Id Comment
      -> Comment)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"position"
        Parser
  (Maybe Int
   -> Text
   -> Maybe Text
   -> UTCTime
   -> Maybe URL
   -> URL
   -> Maybe UTCTime
   -> Maybe Text
   -> SimpleUser
   -> Id Comment
   -> Comment)
-> Parser (Maybe Int)
-> Parser
     (Text
      -> Maybe Text
      -> UTCTime
      -> Maybe URL
      -> URL
      -> Maybe UTCTime
      -> Maybe Text
      -> SimpleUser
      -> Id Comment
      -> Comment)
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
"line"
        Parser
  (Text
   -> Maybe Text
   -> UTCTime
   -> Maybe URL
   -> URL
   -> Maybe UTCTime
   -> Maybe Text
   -> SimpleUser
   -> Id Comment
   -> Comment)
-> Parser Text
-> Parser
     (Maybe Text
      -> UTCTime
      -> Maybe URL
      -> URL
      -> Maybe UTCTime
      -> Maybe Text
      -> SimpleUser
      -> Id Comment
      -> Comment)
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
"body"
        Parser
  (Maybe Text
   -> UTCTime
   -> Maybe URL
   -> URL
   -> Maybe UTCTime
   -> Maybe Text
   -> SimpleUser
   -> Id Comment
   -> Comment)
-> Parser (Maybe Text)
-> Parser
     (UTCTime
      -> Maybe URL
      -> URL
      -> Maybe UTCTime
      -> Maybe Text
      -> SimpleUser
      -> Id Comment
      -> Comment)
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
"commit_id"
        Parser
  (UTCTime
   -> Maybe URL
   -> URL
   -> Maybe UTCTime
   -> Maybe Text
   -> SimpleUser
   -> Id Comment
   -> Comment)
-> Parser UTCTime
-> Parser
     (Maybe URL
      -> URL
      -> Maybe UTCTime
      -> Maybe Text
      -> SimpleUser
      -> Id Comment
      -> Comment)
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
"updated_at"
        Parser
  (Maybe URL
   -> URL
   -> Maybe UTCTime
   -> Maybe Text
   -> SimpleUser
   -> Id Comment
   -> Comment)
-> Parser (Maybe URL)
-> Parser
     (URL
      -> Maybe UTCTime
      -> Maybe Text
      -> SimpleUser
      -> Id Comment
      -> Comment)
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
"html_url"
        Parser
  (URL
   -> Maybe UTCTime
   -> Maybe Text
   -> SimpleUser
   -> Id Comment
   -> Comment)
-> Parser URL
-> Parser
     (Maybe UTCTime
      -> Maybe Text -> SimpleUser -> Id Comment -> Comment)
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
  (Maybe UTCTime
   -> Maybe Text -> SimpleUser -> Id Comment -> Comment)
-> Parser (Maybe UTCTime)
-> Parser (Maybe Text -> SimpleUser -> Id Comment -> Comment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe UTCTime)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
        Parser (Maybe Text -> SimpleUser -> Id Comment -> Comment)
-> Parser (Maybe Text)
-> Parser (SimpleUser -> Id Comment -> Comment)
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
"path"
        Parser (SimpleUser -> Id Comment -> Comment)
-> Parser SimpleUser -> Parser (Id Comment -> Comment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser SimpleUser
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user"
        Parser (Id Comment -> Comment)
-> Parser (Id Comment) -> Parser Comment
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Id Comment)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"

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

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

instance ToJSON NewComment where
    toJSON :: NewComment -> Value
toJSON (NewComment Text
b) = [Pair] -> Value
object [ Key
"body" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
b ]

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

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

instance ToJSON EditComment where
    toJSON :: EditComment -> Value
toJSON (EditComment Text
b) = [Pair] -> Value
object [ Key
"body" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
b ]

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

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

instance ToJSON NewPullComment where
    toJSON :: NewPullComment -> Value
toJSON (NewPullComment Text
c Text
path Int
pos Text
b) =
        [Pair] -> Value
object [ Key
"body" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
b
               , Key
"commit_id" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
c
               , Key
"path" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
path
               , Key
"position" Key -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Int
pos
               ]

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

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

instance ToJSON PullCommentReply where
    toJSON :: PullCommentReply -> Value
toJSON (PullCommentReply Text
b) =
        [Pair] -> Value
object [ Key
"body" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text
b
               ]