{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE CPP #-}

-- |
-- Module      : Pinboard.ApiTypes
-- Copyright   : (c) Jon Schoning, 2015
-- Maintainer  : jonschoning@gmail.com
-- Stability   : experimental
-- Portability : POSIX
module Pinboard.ApiTypes where

import Data.Aeson
import Data.Aeson.Types (Parser)
import Data.HashMap.Strict (HashMap, member, toList)
import Data.Data (Data, Typeable)
import Data.Text (Text, words, unwords, unpack, pack)
import Data.Time (UTCTime, parseTimeM)
import Data.Time.Calendar (Day)
import GHC.Generics (Generic)

import qualified Data.HashMap.Strict as HM
#if !MIN_VERSION_aeson(1,0,0)
import qualified Data.Vector as V
#endif
import Data.Time.Format (formatTime, defaultTimeLocale)
import Control.Applicative
import Prelude hiding (words, unwords)

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

instance FromJSON Posts where
  parseJSON :: Value -> Parser Posts
parseJSON (Object Object
o) = UTCTime -> Text -> [Post] -> Posts
Posts (UTCTime -> Text -> [Post] -> Posts)
-> Parser UTCTime -> Parser (Text -> [Post] -> Posts)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser UTCTime
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"date" Parser (Text -> [Post] -> Posts)
-> Parser Text -> Parser ([Post] -> Posts)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"user" Parser ([Post] -> Posts) -> Parser [Post] -> Parser Posts
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser [Post]
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"posts"
  parseJSON Value
_ = String -> Parser Posts
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"

instance ToJSON Posts where
  toJSON :: Posts -> Value
toJSON Posts {[Post]
Text
UTCTime
postsPosts :: [Post]
postsUser :: Text
postsDate :: UTCTime
postsPosts :: Posts -> [Post]
postsUser :: Posts -> Text
postsDate :: Posts -> UTCTime
..} =
    [Pair] -> Value
object
      [ Text
"date" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= UTCTime -> Value
forall a. ToJSON a => a -> Value
toJSON UTCTime
postsDate
      , Text
"user" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postsUser
      , Text
"posts" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [Post] -> Value
forall a. ToJSON a => a -> Value
toJSON [Post]
postsPosts
      ]

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

instance FromJSON Post where
  parseJSON :: Value -> Parser Post
parseJSON (Object Object
o) =
    Text
-> Text
-> Text
-> Text
-> Text
-> UTCTime
-> Bool
-> Bool
-> [Text]
-> Post
Post (Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> UTCTime
 -> Bool
 -> Bool
 -> [Text]
 -> Post)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> UTCTime
      -> Bool
      -> Bool
      -> [Text]
      -> Post)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"href" Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> UTCTime
   -> Bool
   -> Bool
   -> [Text]
   -> Post)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> UTCTime -> Bool -> Bool -> [Text] -> Post)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"description" Parser
  (Text -> Text -> Text -> UTCTime -> Bool -> Bool -> [Text] -> Post)
-> Parser Text
-> Parser
     (Text -> Text -> UTCTime -> Bool -> Bool -> [Text] -> Post)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"extended" Parser (Text -> Text -> UTCTime -> Bool -> Bool -> [Text] -> Post)
-> Parser Text
-> Parser (Text -> UTCTime -> Bool -> Bool -> [Text] -> Post)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"meta" Parser (Text -> UTCTime -> Bool -> Bool -> [Text] -> Post)
-> Parser Text
-> Parser (UTCTime -> Bool -> Bool -> [Text] -> Post)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"hash" Parser (UTCTime -> Bool -> Bool -> [Text] -> Post)
-> Parser UTCTime -> Parser (Bool -> Bool -> [Text] -> Post)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Object
o Object -> Text -> Parser UTCTime
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"time" Parser (Bool -> Bool -> [Text] -> Post)
-> Parser Bool -> Parser (Bool -> [Text] -> Post)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    (Text -> Bool
boolFromYesNo (Text -> Bool) -> Parser Text -> Parser Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"shared") Parser (Bool -> [Text] -> Post)
-> Parser Bool -> Parser ([Text] -> Post)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    (Text -> Bool
boolFromYesNo (Text -> Bool) -> Parser Text -> Parser Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"toread") Parser ([Text] -> Post) -> Parser [Text] -> Parser Post
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    (Text -> [Text]
words (Text -> [Text]) -> Parser Text -> Parser [Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"tags")
  parseJSON Value
_ = String -> Parser Post
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"

instance ToJSON Post where
  toJSON :: Post -> Value
toJSON Post {Bool
[Text]
Text
UTCTime
postTags :: [Text]
postToRead :: Bool
postShared :: Bool
postTime :: UTCTime
postHash :: Text
postMeta :: Text
postExtended :: Text
postDescription :: Text
postHref :: Text
postTags :: Post -> [Text]
postToRead :: Post -> Bool
postShared :: Post -> Bool
postTime :: Post -> UTCTime
postHash :: Post -> Text
postMeta :: Post -> Text
postExtended :: Post -> Text
postDescription :: Post -> Text
postHref :: Post -> Text
..} =
    [Pair] -> Value
object
      [ Text
"href" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postHref
      , Text
"description" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postDescription
      , Text
"extended" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postExtended
      , Text
"meta" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postMeta
      , Text
"hash" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postHash
      , Text
"time" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= UTCTime -> Value
forall a. ToJSON a => a -> Value
toJSON UTCTime
postTime
      , Text
"shared" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Bool -> Text
boolToYesNo Bool
postShared
      , Text
"toread" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Bool -> Text
boolToYesNo Bool
postToRead
      , Text
"tags" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [Text] -> Text
unwords [Text]
postTags
      ]

boolFromYesNo :: Text -> Bool
boolFromYesNo :: Text -> Bool
boolFromYesNo Text
"yes" = Bool
True
boolFromYesNo Text
_ = Bool
False

boolToYesNo :: Bool -> Text
boolToYesNo :: Bool -> Text
boolToYesNo Bool
True = Text
"yes"
boolToYesNo Bool
_ = Text
"no"

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

instance FromJSON PostDates where
  parseJSON :: Value -> Parser PostDates
parseJSON (Object Object
o) =
    Text -> Text -> [(Day, Int)] -> PostDates
PostDates (Text -> Text -> [(Day, Int)] -> PostDates)
-> Parser Text -> Parser (Text -> [(Day, Int)] -> PostDates)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"user" Parser (Text -> [(Day, Int)] -> PostDates)
-> Parser Text -> Parser ([(Day, Int)] -> PostDates)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"tag" Parser ([(Day, Int)] -> PostDates)
-> Parser [(Day, Int)] -> Parser PostDates
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Value -> [(Day, Int)]
parseDates (Value -> [(Day, Int)]) -> Parser Value -> Parser [(Day, Int)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Value
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"dates")
    where
      parseDates :: Value -> [DateCount]
      parseDates :: Value -> [(Day, Int)]
parseDates (Object Object
o') = do
        (Text
dateStr, String Text
countStr) <- Object -> [Pair]
forall k v. HashMap k v -> [(k, v)]
toList Object
o'
        (Day, Int) -> [(Day, Int)]
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> Day
forall a. Read a => String -> a
read (Text -> String
unpack Text
dateStr), String -> Int
forall a. Read a => String -> a
read (Text -> String
unpack Text
countStr))
      parseDates Value
_ = []
  parseJSON Value
_ = String -> Parser PostDates
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"

instance ToJSON PostDates where
  toJSON :: PostDates -> Value
toJSON PostDates {[(Day, Int)]
Text
postDatesCount :: [(Day, Int)]
postDatesTag :: Text
postDatesUser :: Text
postDatesCount :: PostDates -> [(Day, Int)]
postDatesTag :: PostDates -> Text
postDatesUser :: PostDates -> Text
..} =
    [Pair] -> Value
object
      [ Text
"user" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postDatesUser
      , Text
"tag" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postDatesTag
      , Text
"dates" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [Pair] -> Value
object ((Day, Int) -> Pair
forall a a. (Show a, Show a) => (a, a) -> Pair
dateCountToPair ((Day, Int) -> Pair) -> [(Day, Int)] -> [Pair]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Day, Int)]
postDatesCount)
      ]
    where
      dateCountToPair :: (a, a) -> Pair
dateCountToPair (a
day, a
count) =
        ((String -> Text
pack (String -> Text) -> (a -> String) -> a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show) a
day, Text -> Value
String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ (String -> Text
pack (String -> Text) -> (a -> String) -> a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show) a
count)

type DateCount = (Day, Int)

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

instance FromJSON NoteList where
  parseJSON :: Value -> Parser NoteList
parseJSON (Object Object
o) = Int -> [NoteListItem] -> NoteList
NoteList (Int -> [NoteListItem] -> NoteList)
-> Parser Int -> Parser ([NoteListItem] -> NoteList)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Int
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"count" Parser ([NoteListItem] -> NoteList)
-> Parser [NoteListItem] -> Parser NoteList
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser [NoteListItem]
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"notes"
  parseJSON Value
_ = String -> Parser NoteList
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"

instance ToJSON NoteList where
  toJSON :: NoteList -> Value
toJSON NoteList {Int
[NoteListItem]
noteListItems :: [NoteListItem]
noteListCount :: Int
noteListItems :: NoteList -> [NoteListItem]
noteListCount :: NoteList -> Int
..} =
    [Pair] -> Value
object [Text
"count" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int -> Value
forall a. ToJSON a => a -> Value
toJSON Int
noteListCount, Text
"notes" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [NoteListItem] -> Value
forall a. ToJSON a => a -> Value
toJSON [NoteListItem]
noteListItems]

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

instance FromJSON NoteListItem where
  parseJSON :: Value -> Parser NoteListItem
parseJSON (Object Object
o) =
    Text -> Text -> Text -> Int -> UTCTime -> UTCTime -> NoteListItem
NoteListItem (Text -> Text -> Text -> Int -> UTCTime -> UTCTime -> NoteListItem)
-> Parser Text
-> Parser
     (Text -> Text -> Int -> UTCTime -> UTCTime -> NoteListItem)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"id" Parser (Text -> Text -> Int -> UTCTime -> UTCTime -> NoteListItem)
-> Parser Text
-> Parser (Text -> Int -> UTCTime -> UTCTime -> NoteListItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"hash" Parser (Text -> Int -> UTCTime -> UTCTime -> NoteListItem)
-> Parser Text
-> Parser (Int -> UTCTime -> UTCTime -> NoteListItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"title" Parser (Int -> UTCTime -> UTCTime -> NoteListItem)
-> Parser Int -> Parser (UTCTime -> UTCTime -> NoteListItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    (String -> Int
forall a. Read a => String -> a
read (String -> Int) -> Parser String -> Parser Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
o Object -> Text -> Parser String
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"length")) Parser (UTCTime -> UTCTime -> NoteListItem)
-> Parser UTCTime -> Parser (UTCTime -> NoteListItem)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    (String -> Parser UTCTime
forall (m :: * -> *). MonadFail m => String -> m UTCTime
readNoteTime (String -> Parser UTCTime) -> Parser String -> Parser UTCTime
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o Object -> Text -> Parser String
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"created_at") Parser (UTCTime -> NoteListItem)
-> Parser UTCTime -> Parser NoteListItem
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    (String -> Parser UTCTime
forall (m :: * -> *). MonadFail m => String -> m UTCTime
readNoteTime (String -> Parser UTCTime) -> Parser String -> Parser UTCTime
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o Object -> Text -> Parser String
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"updated_at")
  parseJSON Value
_ = String -> Parser NoteListItem
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"

instance ToJSON NoteListItem where
  toJSON :: NoteListItem -> Value
toJSON NoteListItem {Int
Text
UTCTime
noteListItemUpdatedAt :: UTCTime
noteListItemCreatedAt :: UTCTime
noteListItemLength :: Int
noteListItemTitle :: Text
noteListItemHash :: Text
noteListItemId :: Text
noteListItemUpdatedAt :: NoteListItem -> UTCTime
noteListItemCreatedAt :: NoteListItem -> UTCTime
noteListItemLength :: NoteListItem -> Int
noteListItemTitle :: NoteListItem -> Text
noteListItemHash :: NoteListItem -> Text
noteListItemId :: NoteListItem -> Text
..} =
    [Pair] -> Value
object
      [ Text
"id" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteListItemId
      , Text
"hash" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteListItemHash
      , Text
"title" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteListItemTitle
      , Text
"length" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String -> Value
forall a. ToJSON a => a -> Value
toJSON (Int -> String
forall a. Show a => a -> String
show Int
noteListItemLength)
      , Text
"created_at" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String -> Value
forall a. ToJSON a => a -> Value
toJSON (UTCTime -> String
showNoteTime UTCTime
noteListItemCreatedAt)
      , Text
"updated_at" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String -> Value
forall a. ToJSON a => a -> Value
toJSON (UTCTime -> String
showNoteTime UTCTime
noteListItemUpdatedAt)
      ]

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

instance FromJSON Note where
  parseJSON :: Value -> Parser Note
parseJSON (Object Object
o) =
    Text -> Text -> Text -> Text -> Int -> UTCTime -> UTCTime -> Note
Note (Text -> Text -> Text -> Text -> Int -> UTCTime -> UTCTime -> Note)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Int -> UTCTime -> UTCTime -> Note)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"id" Parser (Text -> Text -> Text -> Int -> UTCTime -> UTCTime -> Note)
-> Parser Text
-> Parser (Text -> Text -> Int -> UTCTime -> UTCTime -> Note)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"hash" Parser (Text -> Text -> Int -> UTCTime -> UTCTime -> Note)
-> Parser Text
-> Parser (Text -> Int -> UTCTime -> UTCTime -> Note)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"title" Parser (Text -> Int -> UTCTime -> UTCTime -> Note)
-> Parser Text -> Parser (Int -> UTCTime -> UTCTime -> Note)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"text" Parser (Int -> UTCTime -> UTCTime -> Note)
-> Parser Int -> Parser (UTCTime -> UTCTime -> Note)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    Object
o Object -> Text -> Parser Int
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"length" Parser (UTCTime -> UTCTime -> Note)
-> Parser UTCTime -> Parser (UTCTime -> Note)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    (String -> Parser UTCTime
forall (m :: * -> *). MonadFail m => String -> m UTCTime
readNoteTime (String -> Parser UTCTime) -> Parser String -> Parser UTCTime
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o Object -> Text -> Parser String
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"created_at") Parser (UTCTime -> Note) -> Parser UTCTime -> Parser Note
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
    (String -> Parser UTCTime
forall (m :: * -> *). MonadFail m => String -> m UTCTime
readNoteTime (String -> Parser UTCTime) -> Parser String -> Parser UTCTime
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Object
o Object -> Text -> Parser String
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"updated_at")
  parseJSON Value
_ = String -> Parser Note
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"

instance ToJSON Note where
  toJSON :: Note -> Value
toJSON Note {Int
Text
UTCTime
noteUpdatedAt :: UTCTime
noteCreatedAt :: UTCTime
noteLength :: Int
noteText :: Text
noteTitle :: Text
noteHash :: Text
noteId :: Text
noteUpdatedAt :: Note -> UTCTime
noteCreatedAt :: Note -> UTCTime
noteLength :: Note -> Int
noteText :: Note -> Text
noteTitle :: Note -> Text
noteHash :: Note -> Text
noteId :: Note -> Text
..} =
    [Pair] -> Value
object
      [ Text
"id" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteId
      , Text
"hash" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteHash
      , Text
"title" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteTitle
      , Text
"text" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteText
      , Text
"length" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int -> Value
forall a. ToJSON a => a -> Value
toJSON Int
noteLength
      , Text
"created_at" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String -> Value
forall a. ToJSON a => a -> Value
toJSON (UTCTime -> String
showNoteTime UTCTime
noteCreatedAt)
      , Text
"updated_at" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String -> Value
forall a. ToJSON a => a -> Value
toJSON (UTCTime -> String
showNoteTime UTCTime
noteUpdatedAt)
      ]

readNoteTime
  :: MonadFail m
  => String -> m UTCTime
readNoteTime :: String -> m UTCTime
readNoteTime = Bool -> TimeLocale -> String -> String -> m UTCTime
forall (m :: * -> *) t.
(MonadFail m, ParseTime t) =>
Bool -> TimeLocale -> String -> String -> m t
parseTimeM Bool
True TimeLocale
defaultTimeLocale String
"%F %T"

showNoteTime :: UTCTime -> String
showNoteTime :: UTCTime -> String
showNoteTime = TimeLocale -> String -> UTCTime -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
defaultTimeLocale String
"%F %T"

-- * Tags
type TagMap = HashMap Tag Int

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

instance FromJSON JsonTagMap where
  parseJSON :: Value -> Parser JsonTagMap
parseJSON = Value -> Parser JsonTagMap
forall (m :: * -> *). MonadFail m => Value -> m JsonTagMap
toTags
    where
      toTags :: Value -> m JsonTagMap
toTags (Object Object
o) =
        JsonTagMap -> m JsonTagMap
forall (m :: * -> *) a. Monad m => a -> m a
return (JsonTagMap -> m JsonTagMap)
-> (TagMap -> JsonTagMap) -> TagMap -> m JsonTagMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TagMap -> JsonTagMap
ToJsonTagMap (TagMap -> m JsonTagMap) -> TagMap -> m JsonTagMap
forall a b. (a -> b) -> a -> b
$ (Value -> Int) -> Object -> TagMap
forall v1 v2 k. (v1 -> v2) -> HashMap k v1 -> HashMap k v2
HM.map (\(String Text
s) -> String -> Int
forall a. Read a => String -> a
read (Text -> String
unpack Text
s)) Object
o
      toTags Value
_ = String -> m JsonTagMap
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"

instance ToJSON JsonTagMap where
  toJSON :: JsonTagMap -> Value
toJSON (ToJsonTagMap TagMap
o) = HashMap Text String -> Value
forall a. ToJSON a => a -> Value
toJSON (HashMap Text String -> Value) -> HashMap Text String -> Value
forall a b. (a -> b) -> a -> b
$ Int -> String
forall a. Show a => a -> String
show (Int -> String) -> TagMap -> HashMap Text String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TagMap
o

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

instance FromJSON Suggested where
  parseJSON :: Value -> Parser Suggested
parseJSON (Object Object
o)
    | Text -> Object -> Bool
forall k a. (Eq k, Hashable k) => k -> HashMap k a -> Bool
member Text
"popular" Object
o = [Text] -> Suggested
Popular ([Text] -> Suggested) -> Parser [Text] -> Parser Suggested
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
o Object -> Text -> Parser [Text]
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"popular")
    | Text -> Object -> Bool
forall k a. (Eq k, Hashable k) => k -> HashMap k a -> Bool
member Text
"recommended" Object
o = [Text] -> Suggested
Recommended ([Text] -> Suggested) -> Parser [Text] -> Parser Suggested
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
o Object -> Text -> Parser [Text]
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"recommended")
    | Bool
otherwise = String -> Parser Suggested
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"
  parseJSON Value
_ = String -> Parser Suggested
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"

#if !MIN_VERSION_aeson(1,0,0)
instance ToJSON [Suggested] where
  toJSON xs = Array $ toJSON <$> V.fromList xs
#endif

instance ToJSON Suggested where
  toJSON :: Suggested -> Value
toJSON (Popular [Text]
tags) = [Pair] -> Value
object [Text
"popular" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [Text] -> Value
forall a. ToJSON a => a -> Value
toJSON [Text]
tags]
  toJSON (Recommended [Text]
tags) = [Pair] -> Value
object [Text
"recommended" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [Text] -> Value
forall a. ToJSON a => a -> Value
toJSON [Text]
tags]

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

instance FromJSON DoneResult where
  parseJSON :: Value -> Parser DoneResult
parseJSON (Object Object
o) = Text -> Parser DoneResult
parseDone (Text -> Parser DoneResult) -> Parser Text -> Parser DoneResult
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"result" Parser Text -> Parser Text -> Parser Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"result_code")
    where
      parseDone :: Text -> Parser DoneResult
      parseDone :: Text -> Parser DoneResult
parseDone Text
"done" = DoneResult -> Parser DoneResult
forall (m :: * -> *) a. Monad m => a -> m a
return (DoneResult -> Parser DoneResult)
-> DoneResult -> Parser DoneResult
forall a b. (a -> b) -> a -> b
$ () -> DoneResult
ToDoneResult ()
      parseDone Text
msg = (String -> Parser DoneResult
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser DoneResult)
-> (Text -> String) -> Text -> Parser DoneResult
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
unpack) Text
msg
  parseJSON Value
_ = String -> Parser DoneResult
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"

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

instance FromJSON TextResult where
  parseJSON :: Value -> Parser TextResult
parseJSON (Object Object
o) = Text -> TextResult
ToTextResult (Text -> TextResult) -> Parser Text -> Parser TextResult
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
o Object -> Text -> Parser Text
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"result")
  parseJSON Value
_ = String -> Parser TextResult
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"bad parse"

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

instance FromJSON UpdateTime where
  parseJSON :: Value -> Parser UpdateTime
parseJSON (Object Object
o) = UTCTime -> UpdateTime
ToUpdateTime (UTCTime -> UpdateTime) -> Parser UTCTime -> Parser UpdateTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
o Object -> Text -> Parser UTCTime
forall a. FromJSON a => Object -> Text -> Parser a
.: Text
"update_time")
  parseJSON Value
_ = String -> Parser UpdateTime
forall a. HasCallStack => String -> a
error String
"bad parse"

-- prettyString :: String -> String
-- prettyString s = case parseExp s of
--     ParseOk x -> prettyPrint x
--     ParseFailed{} -> s
-- pretty :: Show a => a -> String
-- pretty = prettyString . show
-- * Aliases
-- | as defined by RFC 3986. Allowed schemes are http, https, javascript, mailto, ftp and file. The Safari-specific feed scheme is allowed but will be treated as a synonym for http.
type Url = Text

-- | up to 255 characters long
type Description = Text

-- | up to 65536 characters long. Any URLs will be auto-linkified when displayed.
type Extended = Text

-- | up to 255 characters. May not contain commas or whitespace.
type Tag = Text

type Old = Tag

type New = Tag

type Count = Int

type NumResults = Int

type StartOffset = Int

type Shared = Bool

type Replace = Bool

type ToRead = Bool

-- | UTC date in this format: 2010-12-11. Same range as datetime above
type Date = Day

-- | UTC timestamp in this format: 2010-12-11T19:48:02Z. Valid date range is Jan 1, 1 AD to January 1, 2100 (but see note below about future timestamps).
type DateTime = UTCTime

type FromDateTime = DateTime

type ToDateTime = DateTime

type Meta = Int

type NoteId = Text