Data.Aeson.Decoding.Tokens

Methods

bifold :: Monoid m => Tokens m m -> m#

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Tokens a b -> m#

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Tokens a b -> c#

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Tokens a b -> c#

Methods

bimap :: (a -> b) -> (c -> d) -> Tokens a c -> Tokens b d#

first :: (a -> b) -> Tokens a c -> Tokens b c#

second :: (b -> c) -> Tokens a b -> Tokens a c#

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Tokens a b -> f (Tokens c d)#

Methods

fmap :: (a -> b) -> Tokens k a -> Tokens k b#

(<$) :: a -> Tokens k b -> Tokens k a#

Methods

fold :: Monoid m => Tokens k m -> m#

foldMap :: Monoid m => (a -> m) -> Tokens k a -> m#

foldMap' :: Monoid m => (a -> m) -> Tokens k a -> m#

foldr :: (a -> b -> b) -> b -> Tokens k a -> b#

foldr' :: (a -> b -> b) -> b -> Tokens k a -> b#

foldl :: (b -> a -> b) -> b -> Tokens k a -> b#

foldl' :: (b -> a -> b) -> b -> Tokens k a -> b#

foldr1 :: (a -> a -> a) -> Tokens k a -> a#

foldl1 :: (a -> a -> a) -> Tokens k a -> a#

toList :: Tokens k a -> [a]#

null :: Tokens k a -> Bool#

length :: Tokens k a -> Int#

elem :: Eq a => a -> Tokens k a -> Bool#

maximum :: Ord a => Tokens k a -> a#

minimum :: Ord a => Tokens k a -> a#

sum :: Num a => Tokens k a -> a#

product :: Num a => Tokens k a -> a#

Methods

traverse :: Applicative f => (a -> f b) -> Tokens k a -> f (Tokens k b)#

sequenceA :: Applicative f => Tokens k (f a) -> f (Tokens k a)#

mapM :: Monad m => (a -> m b) -> Tokens k a -> m (Tokens k b)#

sequence :: Monad m => Tokens k (m a) -> m (Tokens k a)#

Methods

(==) :: Tokens k e -> Tokens k e -> Bool#

(/=) :: Tokens k e -> Tokens k e -> Bool#

Methods

showsPrec :: Int -> Tokens k e -> ShowS#

show :: Tokens k e -> String#

showList :: [Tokens k e] -> ShowS#

Methods

(==) :: Lit -> Lit -> Bool#

(/=) :: Lit -> Lit -> Bool#

Methods

showsPrec :: Int -> Lit -> ShowS#

show :: Lit -> String#

showList :: [Lit] -> ShowS#

Methods

(==) :: Number -> Number -> Bool#

(/=) :: Number -> Number -> Bool#

Methods

showsPrec :: Int -> Number -> ShowS#

show :: Number -> String#

showList :: [Number] -> ShowS#

Methods

bifold :: Monoid m => TkArray m m -> m#

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> TkArray a b -> m#

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> TkArray a b -> c#

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> TkArray a b -> c#

Methods

bimap :: (a -> b) -> (c -> d) -> TkArray a c -> TkArray b d#

first :: (a -> b) -> TkArray a c -> TkArray b c#

second :: (b -> c) -> TkArray a b -> TkArray a c#

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> TkArray a b -> f (TkArray c d)#

Methods

fmap :: (a -> b) -> TkArray k a -> TkArray k b#

(<$) :: a -> TkArray k b -> TkArray k a#

Methods

fold :: Monoid m => TkArray k m -> m#

foldMap :: Monoid m => (a -> m) -> TkArray k a -> m#

foldMap' :: Monoid m => (a -> m) -> TkArray k a -> m#

foldr :: (a -> b -> b) -> b -> TkArray k a -> b#

foldr' :: (a -> b -> b) -> b -> TkArray k a -> b#

foldl :: (b -> a -> b) -> b -> TkArray k a -> b#

foldl' :: (b -> a -> b) -> b -> TkArray k a -> b#

foldr1 :: (a -> a -> a) -> TkArray k a -> a#

foldl1 :: (a -> a -> a) -> TkArray k a -> a#

toList :: TkArray k a -> [a]#

null :: TkArray k a -> Bool#

length :: TkArray k a -> Int#

elem :: Eq a => a -> TkArray k a -> Bool#

maximum :: Ord a => TkArray k a -> a#

minimum :: Ord a => TkArray k a -> a#

sum :: Num a => TkArray k a -> a#

product :: Num a => TkArray k a -> a#

Methods

traverse :: Applicative f => (a -> f b) -> TkArray k a -> f (TkArray k b)#

sequenceA :: Applicative f => TkArray k (f a) -> f (TkArray k a)#

mapM :: Monad m => (a -> m b) -> TkArray k a -> m (TkArray k b)#

sequence :: Monad m => TkArray k (m a) -> m (TkArray k a)#

Methods

(==) :: TkArray k e -> TkArray k e -> Bool#

(/=) :: TkArray k e -> TkArray k e -> Bool#

Methods

showsPrec :: Int -> TkArray k e -> ShowS#

show :: TkArray k e -> String#

showList :: [TkArray k e] -> ShowS#

Methods

bifold :: Monoid m => TkRecord m m -> m#

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> TkRecord a b -> m#

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> TkRecord a b -> c#

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> TkRecord a b -> c#

Methods

bimap :: (a -> b) -> (c -> d) -> TkRecord a c -> TkRecord b d#

first :: (a -> b) -> TkRecord a c -> TkRecord b c#

second :: (b -> c) -> TkRecord a b -> TkRecord a c#

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> TkRecord a b -> f (TkRecord c d)#

Methods

fmap :: (a -> b) -> TkRecord k a -> TkRecord k b#

(<$) :: a -> TkRecord k b -> TkRecord k a#

Methods

fold :: Monoid m => TkRecord k m -> m#

foldMap :: Monoid m => (a -> m) -> TkRecord k a -> m#

foldMap' :: Monoid m => (a -> m) -> TkRecord k a -> m#

foldr :: (a -> b -> b) -> b -> TkRecord k a -> b#

foldr' :: (a -> b -> b) -> b -> TkRecord k a -> b#

foldl :: (b -> a -> b) -> b -> TkRecord k a -> b#

foldl' :: (b -> a -> b) -> b -> TkRecord k a -> b#

foldr1 :: (a -> a -> a) -> TkRecord k a -> a#

foldl1 :: (a -> a -> a) -> TkRecord k a -> a#

toList :: TkRecord k a -> [a]#

null :: TkRecord k a -> Bool#

length :: TkRecord k a -> Int#

elem :: Eq a => a -> TkRecord k a -> Bool#

maximum :: Ord a => TkRecord k a -> a#

minimum :: Ord a => TkRecord k a -> a#

sum :: Num a => TkRecord k a -> a#

product :: Num a => TkRecord k a -> a#

Methods

traverse :: Applicative f => (a -> f b) -> TkRecord k a -> f (TkRecord k b)#

sequenceA :: Applicative f => TkRecord k (f a) -> f (TkRecord k a)#

mapM :: Monad m => (a -> m b) -> TkRecord k a -> m (TkRecord k b)#

sequence :: Monad m => TkRecord k (m a) -> m (TkRecord k a)#

Methods

(==) :: TkRecord k e -> TkRecord k e -> Bool#

(/=) :: TkRecord k e -> TkRecord k e -> Bool#

Methods

showsPrec :: Int -> TkRecord k e -> ShowS#

show :: TkRecord k e -> String#

showList :: [TkRecord k e] -> ShowS#