{-# 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 qualified Data.Aeson.KeyMap as A
import qualified Data.Aeson.Key as A
import Data.HashMap.Strict (HashMap)
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 -> Key -> Parser UTCTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user" Parser ([Post] -> Posts) -> Parser [Post] -> Parser Posts
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser [Post]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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]
UTCTime
Text
postsPosts :: [Post]
postsUser :: Text
postsDate :: UTCTime
postsPosts :: Posts -> [Post]
postsUser :: Posts -> Text
postsDate :: Posts -> UTCTime
..} =
    [Pair] -> Value
object
      [ Key
"date" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime -> Value
forall a. ToJSON a => a -> Value
toJSON UTCTime
postsDate
      , Key
"user" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postsUser
      , Key
"posts" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> 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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser UTCTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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]
UTCTime
Text
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
      [ Key
"href" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postHref
      , Key
"description" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postDescription
      , Key
"extended" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postExtended
      , Key
"meta" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postMeta
      , Key
"hash" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postHash
      , Key
"time" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= UTCTime -> Value
forall a. ToJSON a => a -> Value
toJSON UTCTime
postTime
      , Key
"shared" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool -> Text
boolToYesNo Bool
postShared
      , Key
"toread" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool -> Text
boolToYesNo Bool
postToRead
      , Key
"tags" Key -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> 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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"dates")
    where
      parseDates :: Value -> [DateCount]
      parseDates :: Value -> [(Day, Int)]
parseDates (Object Object
o') = do
        (Key
dateStr, String Text
countStr) <- Object -> [Pair]
forall v. KeyMap v -> [(Key, v)]
A.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 (Key -> String
A.toString Key
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
      [ Key
"user" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postDatesUser
      , Key
"tag" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
postDatesTag
      , Key
"dates" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> 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 -> Key
A.fromString (String -> Key) -> (a -> String) -> a -> Key
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 -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"count" Parser ([NoteListItem] -> NoteList)
-> Parser [NoteListItem] -> Parser NoteList
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser [NoteListItem]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 [Key
"count" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Int -> Value
forall a. ToJSON a => a -> Value
toJSON Int
noteListCount, Key
"notes" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> 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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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
UTCTime
Text
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
      [ Key
"id" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteListItemId
      , Key
"hash" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteListItemHash
      , Key
"title" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteListItemTitle
      , Key
"length" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= String -> Value
forall a. ToJSON a => a -> Value
toJSON (Int -> String
forall a. Show a => a -> String
show Int
noteListItemLength)
      , Key
"created_at" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= String -> Value
forall a. ToJSON a => a -> Value
toJSON (UTCTime -> String
showNoteTime UTCTime
noteListItemCreatedAt)
      , Key
"updated_at" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> 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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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
UTCTime
Text
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
      [ Key
"id" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteId
      , Key
"hash" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteHash
      , Key
"title" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteTitle
      , Key
"text" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Text -> Value
forall a. ToJSON a => a -> Value
toJSON Text
noteText
      , Key
"length" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Int -> Value
forall a. ToJSON a => a -> Value
toJSON Int
noteLength
      , Key
"created_at" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= String -> Value
forall a. ToJSON a => a -> Value
toJSON (UTCTime -> String
showNoteTime UTCTime
noteCreatedAt)
      , Key
"updated_at" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> 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) -> HashMap Text Value -> 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)) (HashMap Text Value -> TagMap) -> HashMap Text Value -> TagMap
forall a b. (a -> b) -> a -> b
$ Object -> HashMap Text Value
forall v. KeyMap v -> HashMap Text v
A.toHashMapText 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)
    | Key -> Object -> Bool
forall a. Key -> KeyMap a -> Bool
A.member Key
"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 -> Key -> Parser [Text]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"popular")
    | Key -> Object -> Bool
forall a. Key -> KeyMap a -> Bool
A.member Key
"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 -> Key -> Parser [Text]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 [Key
"popular" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Text] -> Value
forall a. ToJSON a => a -> Value
toJSON [Text]
tags]
  toJSON (Recommended [Text]
tags) = [Pair] -> Value
object [Key
"recommended" Key -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Key -> 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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"result" Parser Text -> Parser Text -> Parser Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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 -> Key -> Parser UTCTime
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"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