Documentation

Methods

readsPrec :: Int -> ReadS Symbol #

readList :: ReadS [Symbol] #

readPrec :: ReadPrec Symbol #

readListPrec :: ReadPrec [Symbol] #

Methods

showsPrec :: Int -> Symbol -> ShowS #

show :: Symbol -> String #

showList :: [Symbol] -> ShowS #

Methods

readsPrec :: Int -> ReadS PrimExpr #

readList :: ReadS [PrimExpr] #

readPrec :: ReadPrec PrimExpr #

readListPrec :: ReadPrec [PrimExpr] #

Methods

showsPrec :: Int -> PrimExpr -> ShowS #

show :: PrimExpr -> String #

showList :: [PrimExpr] -> ShowS #

Methods

readsPrec :: Int -> ReadS Literal #

readList :: ReadS [Literal] #

readPrec :: ReadPrec Literal #

readListPrec :: ReadPrec [Literal] #

Methods

showsPrec :: Int -> Literal -> ShowS #

show :: Literal -> String #

showList :: [Literal] -> ShowS #

Methods

readsPrec :: Int -> ReadS BinOp #

readList :: ReadS [BinOp] #

readPrec :: ReadPrec BinOp #

readListPrec :: ReadPrec [BinOp] #

Methods

showsPrec :: Int -> BinOp -> ShowS #

show :: BinOp -> String #

showList :: [BinOp] -> ShowS #

Methods

readsPrec :: Int -> ReadS UnOp #

readList :: ReadS [UnOp] #

readPrec :: ReadPrec UnOp #

readListPrec :: ReadPrec [UnOp] #

Methods

showsPrec :: Int -> UnOp -> ShowS #

show :: UnOp -> String #

showList :: [UnOp] -> ShowS #

Methods

readsPrec :: Int -> ReadS AggrOp #

readList :: ReadS [AggrOp] #

readPrec :: ReadPrec AggrOp #

readListPrec :: ReadPrec [AggrOp] #

Methods

showsPrec :: Int -> AggrOp -> ShowS #

show :: AggrOp -> String #

showList :: [AggrOp] -> ShowS #

Methods

readsPrec :: Int -> ReadS AggrDistinct #

readList :: ReadS [AggrDistinct] #

readPrec :: ReadPrec AggrDistinct #

readListPrec :: ReadPrec [AggrDistinct] #

Methods

showsPrec :: Int -> AggrDistinct -> ShowS #

show :: AggrDistinct -> String #

showList :: [AggrDistinct] -> ShowS #

Methods

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

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

Methods

fold :: Monoid m => Aggregate' m -> m #

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

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

foldr :: (a -> b -> b) -> b -> Aggregate' a -> b #

foldr' :: (a -> b -> b) -> b -> Aggregate' a -> b #

foldl :: (b -> a -> b) -> b -> Aggregate' a -> b #

foldl' :: (b -> a -> b) -> b -> Aggregate' a -> b #

foldr1 :: (a -> a -> a) -> Aggregate' a -> a #

foldl1 :: (a -> a -> a) -> Aggregate' a -> a #

toList :: Aggregate' a -> [a] #

null :: Aggregate' a -> Bool #

length :: Aggregate' a -> Int #

elem :: Eq a => a -> Aggregate' a -> Bool #

maximum :: Ord a => Aggregate' a -> a #

minimum :: Ord a => Aggregate' a -> a #

sum :: Num a => Aggregate' a -> a #

product :: Num a => Aggregate' a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Aggregate' a -> f (Aggregate' b) #

sequenceA :: Applicative f => Aggregate' (f a) -> f (Aggregate' a) #

mapM :: Monad m => (a -> m b) -> Aggregate' a -> m (Aggregate' b) #

sequence :: Monad m => Aggregate' (m a) -> m (Aggregate' a) #

Methods

fmap :: (a -> b) -> Aggregate' a -> Aggregate' b #

(<$) :: a -> Aggregate' b -> Aggregate' a #

Methods

readsPrec :: Int -> ReadS (Aggregate' a) #

readList :: ReadS [Aggregate' a] #

readPrec :: ReadPrec (Aggregate' a) #

readListPrec :: ReadPrec [Aggregate' a] #

Methods

showsPrec :: Int -> Aggregate' a -> ShowS #

show :: Aggregate' a -> String #

showList :: [Aggregate' a] -> ShowS #

Methods

fold :: Monoid m => Aggr' m -> m #

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

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

foldr :: (a -> b -> b) -> b -> Aggr' a -> b #

foldr' :: (a -> b -> b) -> b -> Aggr' a -> b #

foldl :: (b -> a -> b) -> b -> Aggr' a -> b #

foldl' :: (b -> a -> b) -> b -> Aggr' a -> b #

foldr1 :: (a -> a -> a) -> Aggr' a -> a #

foldl1 :: (a -> a -> a) -> Aggr' a -> a #

toList :: Aggr' a -> [a] #

null :: Aggr' a -> Bool #

length :: Aggr' a -> Int #

elem :: Eq a => a -> Aggr' a -> Bool #

maximum :: Ord a => Aggr' a -> a #

minimum :: Ord a => Aggr' a -> a #

sum :: Num a => Aggr' a -> a #

product :: Num a => Aggr' a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> Aggr' a -> f (Aggr' b) #

sequenceA :: Applicative f => Aggr' (f a) -> f (Aggr' a) #

mapM :: Monad m => (a -> m b) -> Aggr' a -> m (Aggr' b) #

sequence :: Monad m => Aggr' (m a) -> m (Aggr' a) #

Methods

fmap :: (a -> b) -> Aggr' a -> Aggr' b #

(<$) :: a -> Aggr' b -> Aggr' a #

Methods

readsPrec :: Int -> ReadS (Aggr' a) #

readList :: ReadS [Aggr' a] #

readPrec :: ReadPrec (Aggr' a) #

readListPrec :: ReadPrec [Aggr' a] #

Methods

showsPrec :: Int -> Aggr' a -> ShowS #

show :: Aggr' a -> String #

showList :: [Aggr' a] -> ShowS #

Methods

fold :: Monoid m => OrderExpr' m -> m #

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

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

foldr :: (a -> b -> b) -> b -> OrderExpr' a -> b #

foldr' :: (a -> b -> b) -> b -> OrderExpr' a -> b #

foldl :: (b -> a -> b) -> b -> OrderExpr' a -> b #

foldl' :: (b -> a -> b) -> b -> OrderExpr' a -> b #

foldr1 :: (a -> a -> a) -> OrderExpr' a -> a #

foldl1 :: (a -> a -> a) -> OrderExpr' a -> a #

toList :: OrderExpr' a -> [a] #

null :: OrderExpr' a -> Bool #

length :: OrderExpr' a -> Int #

elem :: Eq a => a -> OrderExpr' a -> Bool #

maximum :: Ord a => OrderExpr' a -> a #

minimum :: Ord a => OrderExpr' a -> a #

sum :: Num a => OrderExpr' a -> a #

product :: Num a => OrderExpr' a -> a #

Methods

traverse :: Applicative f => (a -> f b) -> OrderExpr' a -> f (OrderExpr' b) #

sequenceA :: Applicative f => OrderExpr' (f a) -> f (OrderExpr' a) #

mapM :: Monad m => (a -> m b) -> OrderExpr' a -> m (OrderExpr' b) #

sequence :: Monad m => OrderExpr' (m a) -> m (OrderExpr' a) #

Methods

fmap :: (a -> b) -> OrderExpr' a -> OrderExpr' b #

(<$) :: a -> OrderExpr' b -> OrderExpr' a #

Methods

readsPrec :: Int -> ReadS (OrderExpr' a) #

readList :: ReadS [OrderExpr' a] #

readPrec :: ReadPrec (OrderExpr' a) #

readListPrec :: ReadPrec [OrderExpr' a] #

Methods

showsPrec :: Int -> OrderExpr' a -> ShowS #

show :: OrderExpr' a -> String #

showList :: [OrderExpr' a] -> ShowS #

Methods

readsPrec :: Int -> ReadS OrderNulls #

readList :: ReadS [OrderNulls] #

readPrec :: ReadPrec OrderNulls #

readListPrec :: ReadPrec [OrderNulls] #

Methods

showsPrec :: Int -> OrderNulls -> ShowS #

show :: OrderNulls -> String #

showList :: [OrderNulls] -> ShowS #

Methods

readsPrec :: Int -> ReadS OrderDirection #

readList :: ReadS [OrderDirection] #

readPrec :: ReadPrec OrderDirection #

readListPrec :: ReadPrec [OrderDirection] #

Methods

showsPrec :: Int -> OrderDirection -> ShowS #

show :: OrderDirection -> String #

showList :: [OrderDirection] -> ShowS #

Methods

readsPrec :: Int -> ReadS OrderOp #

readList :: ReadS [OrderOp] #

readPrec :: ReadPrec OrderOp #

readListPrec :: ReadPrec [OrderOp] #

Methods

showsPrec :: Int -> OrderOp -> ShowS #

show :: OrderOp -> String #

showList :: [OrderOp] -> ShowS #

Methods

readsPrec :: Int -> ReadS BoundExpr #

readList :: ReadS [BoundExpr] #

readPrec :: ReadPrec BoundExpr #

readListPrec :: ReadPrec [BoundExpr] #

Methods

showsPrec :: Int -> BoundExpr -> ShowS #

show :: BoundExpr -> String #

showList :: [BoundExpr] -> ShowS #

Methods

readsPrec :: Int -> ReadS WndwOp #

readList :: ReadS [WndwOp] #

readPrec :: ReadPrec WndwOp #

readListPrec :: ReadPrec [WndwOp] #

Methods

showsPrec :: Int -> WndwOp -> ShowS #

show :: WndwOp -> String #

showList :: [WndwOp] -> ShowS #

Methods

readsPrec :: Int -> ReadS Partition #

readList :: ReadS [Partition] #

readPrec :: ReadPrec Partition #

readListPrec :: ReadPrec [Partition] #

Methods

showsPrec :: Int -> Partition -> ShowS #

show :: Partition -> String #

showList :: [Partition] -> ShowS #