yesod-paginator 1.1.0.0 → 1.1.0.1
raw patch · 2 files changed
+12/−13 lines, 2 filesdep −yesod-persistentPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependencies removed: yesod-persistent
API changes (from Hackage documentation)
+ Yesod.Paginator.Paginate: getCurrentPage :: MonadHandler m => m PageNumber
+ Yesod.Paginator.Prelude: (!!) :: () => [a] -> Int -> a
+ Yesod.Paginator.Prelude: ($!) :: () => a -> b -> a -> b
+ Yesod.Paginator.Prelude: ($) :: () => a -> b -> a -> b
+ Yesod.Paginator.Prelude: (&&) :: Bool -> Bool -> Bool
+ Yesod.Paginator.Prelude: (*) :: Num a => a -> a -> a
+ Yesod.Paginator.Prelude: (**) :: Floating a => a -> a -> a
+ Yesod.Paginator.Prelude: (*>) :: Applicative f => f a -> f b -> f b
+ Yesod.Paginator.Prelude: (+) :: Num a => a -> a -> a
+ Yesod.Paginator.Prelude: (++) :: () => [a] -> [a] -> [a]
+ Yesod.Paginator.Prelude: (-) :: Num a => a -> a -> a
+ Yesod.Paginator.Prelude: (.) :: () => b -> c -> a -> b -> a -> c
+ Yesod.Paginator.Prelude: (/) :: Fractional a => a -> a -> a
+ Yesod.Paginator.Prelude: (/=) :: Eq a => a -> a -> Bool
+ Yesod.Paginator.Prelude: (<$!>) :: Monad m => a -> b -> m a -> m b
+ Yesod.Paginator.Prelude: (<$) :: Functor f => a -> f b -> f a
+ Yesod.Paginator.Prelude: (<$>) :: Functor f => a -> b -> f a -> f b
+ Yesod.Paginator.Prelude: (<) :: Ord a => a -> a -> Bool
+ Yesod.Paginator.Prelude: (<*) :: Applicative f => f a -> f b -> f a
+ Yesod.Paginator.Prelude: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ Yesod.Paginator.Prelude: (<=) :: Ord a => a -> a -> Bool
+ Yesod.Paginator.Prelude: (<=<) :: Monad m => b -> m c -> a -> m b -> a -> m c
+ Yesod.Paginator.Prelude: (<>) :: Semigroup a => a -> a -> a
+ Yesod.Paginator.Prelude: (=<<) :: Monad m => a -> m b -> m a -> m b
+ Yesod.Paginator.Prelude: (==) :: Eq a => a -> a -> Bool
+ Yesod.Paginator.Prelude: (>) :: Ord a => a -> a -> Bool
+ Yesod.Paginator.Prelude: (>=) :: Ord a => a -> a -> Bool
+ Yesod.Paginator.Prelude: (>=>) :: Monad m => a -> m b -> b -> m c -> a -> m c
+ Yesod.Paginator.Prelude: (>>) :: Monad m => m a -> m b -> m b
+ Yesod.Paginator.Prelude: (>>=) :: Monad m => m a -> a -> m b -> m b
+ Yesod.Paginator.Prelude: (\\) :: Eq a => [a] -> [a] -> [a]
+ Yesod.Paginator.Prelude: (^) :: (Num a, Integral b) => a -> b -> a
+ Yesod.Paginator.Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Yesod.Paginator.Prelude: (||) :: Bool -> Bool -> Bool
+ Yesod.Paginator.Prelude: EQ :: Ordering
+ Yesod.Paginator.Prelude: False :: Bool
+ Yesod.Paginator.Prelude: GT :: Ordering
+ Yesod.Paginator.Prelude: Just :: a -> Maybe a
+ Yesod.Paginator.Prelude: LT :: Ordering
+ Yesod.Paginator.Prelude: Left :: a -> Either a b
+ Yesod.Paginator.Prelude: Nothing :: Maybe a
+ Yesod.Paginator.Prelude: Right :: b -> Either a b
+ Yesod.Paginator.Prelude: True :: Bool
+ Yesod.Paginator.Prelude: abort :: Partial => String -> a
+ Yesod.Paginator.Prelude: abs :: Num a => a -> a
+ Yesod.Paginator.Prelude: acos :: Floating a => a -> a
+ Yesod.Paginator.Prelude: acosh :: Floating a => a -> a
+ Yesod.Paginator.Prelude: all :: Foldable t => a -> Bool -> t a -> Bool
+ Yesod.Paginator.Prelude: and :: Foldable t => t Bool -> Bool
+ Yesod.Paginator.Prelude: any :: Foldable t => a -> Bool -> t a -> Bool
+ Yesod.Paginator.Prelude: ap :: Monad m => m a -> b -> m a -> m b
+ Yesod.Paginator.Prelude: appendFile :: FilePath -> String -> IO ()
+ Yesod.Paginator.Prelude: asTypeOf :: () => a -> a -> a
+ Yesod.Paginator.Prelude: asin :: Floating a => a -> a
+ Yesod.Paginator.Prelude: asinh :: Floating a => a -> a
+ Yesod.Paginator.Prelude: assertNote :: Partial => String -> Bool -> a -> a
+ Yesod.Paginator.Prelude: at :: Partial => [a] -> Int -> a
+ Yesod.Paginator.Prelude: atDef :: () => a -> [a] -> Int -> a
+ Yesod.Paginator.Prelude: atMay :: () => [a] -> Int -> Maybe a
+ Yesod.Paginator.Prelude: atNote :: Partial => String -> [a] -> Int -> a
+ Yesod.Paginator.Prelude: atan :: Floating a => a -> a
+ Yesod.Paginator.Prelude: atan2 :: RealFloat a => a -> a -> a
+ Yesod.Paginator.Prelude: atanh :: Floating a => a -> a
+ Yesod.Paginator.Prelude: break :: () => a -> Bool -> [a] -> ([a], [a])
+ Yesod.Paginator.Prelude: catMaybes :: () => [Maybe a] -> [a]
+ Yesod.Paginator.Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ Yesod.Paginator.Prelude: class Functor f => Applicative (f :: * -> *)
+ Yesod.Paginator.Prelude: class Bounded a
+ Yesod.Paginator.Prelude: class Enum a
+ Yesod.Paginator.Prelude: class Eq a
+ Yesod.Paginator.Prelude: class Fractional a => Floating a
+ Yesod.Paginator.Prelude: class Foldable (t :: * -> *)
+ Yesod.Paginator.Prelude: class Num a => Fractional a
+ Yesod.Paginator.Prelude: class Functor (f :: * -> *)
+ Yesod.Paginator.Prelude: class (Real a, Enum a) => Integral a
+ Yesod.Paginator.Prelude: class Applicative m => Monad (m :: * -> *)
+ Yesod.Paginator.Prelude: class (Alternative m, Monad m) => MonadPlus (m :: * -> *)
+ Yesod.Paginator.Prelude: class Semigroup a => Monoid a
+ Yesod.Paginator.Prelude: class Num a
+ Yesod.Paginator.Prelude: class Eq a => Ord a
+ Yesod.Paginator.Prelude: class Read a
+ Yesod.Paginator.Prelude: class (Num a, Ord a) => Real a
+ Yesod.Paginator.Prelude: class (RealFrac a, Floating a) => RealFloat a
+ Yesod.Paginator.Prelude: class (Real a, Fractional a) => RealFrac a
+ Yesod.Paginator.Prelude: class Semigroup a
+ Yesod.Paginator.Prelude: class Show a
+ Yesod.Paginator.Prelude: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Yesod.Paginator.Prelude: compare :: Ord a => a -> a -> Ordering
+ Yesod.Paginator.Prelude: concat :: Foldable t => t [a] -> [a]
+ Yesod.Paginator.Prelude: concatMap :: Foldable t => a -> [b] -> t a -> [b]
+ Yesod.Paginator.Prelude: const :: () => a -> b -> a
+ Yesod.Paginator.Prelude: cos :: Floating a => a -> a
+ Yesod.Paginator.Prelude: cosh :: Floating a => a -> a
+ Yesod.Paginator.Prelude: curry :: () => (a, b) -> c -> a -> b -> c
+ Yesod.Paginator.Prelude: cycle :: () => [a] -> [a]
+ Yesod.Paginator.Prelude: cycleDef :: () => [a] -> [a] -> [a]
+ Yesod.Paginator.Prelude: cycleMay :: () => [a] -> Maybe [a]
+ Yesod.Paginator.Prelude: cycleNote :: Partial => String -> [a] -> [a]
+ Yesod.Paginator.Prelude: data Bool
+ Yesod.Paginator.Prelude: data Char
+ Yesod.Paginator.Prelude: data Double
+ Yesod.Paginator.Prelude: data Either a b
+ Yesod.Paginator.Prelude: data Float
+ Yesod.Paginator.Prelude: data IO a
+ Yesod.Paginator.Prelude: data Int
+ Yesod.Paginator.Prelude: data Integer
+ Yesod.Paginator.Prelude: data Maybe a
+ Yesod.Paginator.Prelude: data Natural
+ Yesod.Paginator.Prelude: data Ordering
+ Yesod.Paginator.Prelude: data Text
+ Yesod.Paginator.Prelude: data Word
+ Yesod.Paginator.Prelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Yesod.Paginator.Prelude: delete :: Eq a => a -> [a] -> [a]
+ Yesod.Paginator.Prelude: deleteBy :: () => a -> a -> Bool -> a -> [a] -> [a]
+ Yesod.Paginator.Prelude: deleteFirstsBy :: () => a -> a -> Bool -> [a] -> [a] -> [a]
+ Yesod.Paginator.Prelude: div :: Integral a => a -> a -> a
+ Yesod.Paginator.Prelude: divMod :: Integral a => a -> a -> (a, a)
+ Yesod.Paginator.Prelude: drop :: () => Int -> [a] -> [a]
+ Yesod.Paginator.Prelude: dropWhile :: () => a -> Bool -> [a] -> [a]
+ Yesod.Paginator.Prelude: dropWhileEnd :: () => a -> Bool -> [a] -> [a]
+ Yesod.Paginator.Prelude: either :: () => a -> c -> b -> c -> Either a b -> c
+ Yesod.Paginator.Prelude: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Yesod.Paginator.Prelude: elemIndex :: Eq a => a -> [a] -> Maybe Int
+ Yesod.Paginator.Prelude: elemIndexJust :: (Partial, Eq a) => a -> [a] -> Int
+ Yesod.Paginator.Prelude: elemIndexJustDef :: Eq a => Int -> a -> [a] -> Int
+ Yesod.Paginator.Prelude: elemIndexJustNote :: (Partial, Eq a) => String -> a -> [a] -> Int
+ Yesod.Paginator.Prelude: elemIndices :: Eq a => a -> [a] -> [Int]
+ Yesod.Paginator.Prelude: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Yesod.Paginator.Prelude: enumFrom :: Enum a => a -> [a]
+ Yesod.Paginator.Prelude: enumFromThen :: Enum a => a -> a -> [a]
+ Yesod.Paginator.Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Yesod.Paginator.Prelude: enumFromTo :: Enum a => a -> a -> [a]
+ Yesod.Paginator.Prelude: error :: HasCallStack => [Char] -> a
+ Yesod.Paginator.Prelude: errorWithoutStackTrace :: () => [Char] -> a
+ Yesod.Paginator.Prelude: even :: Integral a => a -> Bool
+ Yesod.Paginator.Prelude: exp :: Floating a => a -> a
+ Yesod.Paginator.Prelude: exponent :: RealFloat a => a -> Int
+ Yesod.Paginator.Prelude: fail :: Monad m => String -> m a
+ Yesod.Paginator.Prelude: filter :: () => a -> Bool -> [a] -> [a]
+ Yesod.Paginator.Prelude: filterM :: Applicative m => a -> m Bool -> [a] -> m [a]
+ Yesod.Paginator.Prelude: find :: Foldable t => a -> Bool -> t a -> Maybe a
+ Yesod.Paginator.Prelude: findIndex :: () => a -> Bool -> [a] -> Maybe Int
+ Yesod.Paginator.Prelude: findIndexJust :: () => a -> Bool -> [a] -> Int
+ Yesod.Paginator.Prelude: findIndexJustDef :: () => Int -> a -> Bool -> [a] -> Int
+ Yesod.Paginator.Prelude: findIndexJustNote :: Partial => String -> a -> Bool -> [a] -> Int
+ Yesod.Paginator.Prelude: findIndices :: () => a -> Bool -> [a] -> [Int]
+ Yesod.Paginator.Prelude: findJust :: () => a -> Bool -> [a] -> a
+ Yesod.Paginator.Prelude: findJustDef :: () => a -> a -> Bool -> [a] -> a
+ Yesod.Paginator.Prelude: findJustNote :: Partial => String -> a -> Bool -> [a] -> a
+ Yesod.Paginator.Prelude: flip :: () => a -> b -> c -> b -> a -> c
+ Yesod.Paginator.Prelude: floatDigits :: RealFloat a => a -> Int
+ Yesod.Paginator.Prelude: floatRadix :: RealFloat a => a -> Integer
+ Yesod.Paginator.Prelude: floatRange :: RealFloat a => a -> (Int, Int)
+ Yesod.Paginator.Prelude: floor :: (RealFrac a, Integral b) => a -> b
+ Yesod.Paginator.Prelude: fmap :: Functor f => a -> b -> f a -> f b
+ Yesod.Paginator.Prelude: foldM :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m b
+ Yesod.Paginator.Prelude: foldM_ :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m ()
+ Yesod.Paginator.Prelude: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m
+ Yesod.Paginator.Prelude: foldl :: Foldable t => b -> a -> b -> b -> t a -> b
+ Yesod.Paginator.Prelude: foldl' :: Foldable t => b -> a -> b -> b -> t a -> b
+ Yesod.Paginator.Prelude: foldl1 :: Foldable t => a -> a -> a -> t a -> a
+ Yesod.Paginator.Prelude: foldl1' :: () => a -> a -> a -> [a] -> a
+ Yesod.Paginator.Prelude: foldl1Def :: () => a -> a -> a -> a -> [a] -> a
+ Yesod.Paginator.Prelude: foldl1Def' :: () => a -> a -> a -> a -> [a] -> a
+ Yesod.Paginator.Prelude: foldl1May :: () => a -> a -> a -> [a] -> Maybe a
+ Yesod.Paginator.Prelude: foldl1May' :: () => a -> a -> a -> [a] -> Maybe a
+ Yesod.Paginator.Prelude: foldl1Note :: Partial => String -> a -> a -> a -> [a] -> a
+ Yesod.Paginator.Prelude: foldl1Note' :: Partial => String -> a -> a -> a -> [a] -> a
+ Yesod.Paginator.Prelude: foldr :: Foldable t => a -> b -> b -> b -> t a -> b
+ Yesod.Paginator.Prelude: foldr1 :: Foldable t => a -> a -> a -> t a -> a
+ Yesod.Paginator.Prelude: foldr1Def :: () => a -> a -> a -> a -> [a] -> a
+ Yesod.Paginator.Prelude: foldr1May :: () => a -> a -> a -> [a] -> Maybe a
+ Yesod.Paginator.Prelude: foldr1Note :: Partial => String -> a -> a -> a -> [a] -> a
+ Yesod.Paginator.Prelude: forM :: (Traversable t, Monad m) => t a -> a -> m b -> m t b
+ Yesod.Paginator.Prelude: forM_ :: (Foldable t, Monad m) => t a -> a -> m b -> m ()
+ Yesod.Paginator.Prelude: forever :: Applicative f => f a -> f b
+ Yesod.Paginator.Prelude: fromEnum :: Enum a => a -> Int
+ Yesod.Paginator.Prelude: fromInteger :: Num a => Integer -> a
+ Yesod.Paginator.Prelude: fromIntegral :: (Integral a, Num b) => a -> b
+ Yesod.Paginator.Prelude: fromJust :: () => Maybe a -> a
+ Yesod.Paginator.Prelude: fromJustDef :: () => a -> Maybe a -> a
+ Yesod.Paginator.Prelude: fromJustNote :: Partial => String -> Maybe a -> a
+ Yesod.Paginator.Prelude: fromMaybe :: () => a -> Maybe a -> a
+ Yesod.Paginator.Prelude: fromRational :: Fractional a => Rational -> a
+ Yesod.Paginator.Prelude: fst :: () => (a, b) -> a
+ Yesod.Paginator.Prelude: gcd :: Integral a => a -> a -> a
+ Yesod.Paginator.Prelude: genericDrop :: Integral i => i -> [a] -> [a]
+ Yesod.Paginator.Prelude: genericIndex :: Integral i => [a] -> i -> a
+ Yesod.Paginator.Prelude: genericLength :: Num i => [a] -> i
+ Yesod.Paginator.Prelude: genericReplicate :: Integral i => i -> a -> [a]
+ Yesod.Paginator.Prelude: genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
+ Yesod.Paginator.Prelude: genericTake :: Integral i => i -> [a] -> [a]
+ Yesod.Paginator.Prelude: getChar :: IO Char
+ Yesod.Paginator.Prelude: getContents :: IO String
+ Yesod.Paginator.Prelude: getLine :: IO String
+ Yesod.Paginator.Prelude: group :: Eq a => [a] -> [[a]]
+ Yesod.Paginator.Prelude: groupBy :: () => a -> a -> Bool -> [a] -> [[a]]
+ Yesod.Paginator.Prelude: guard :: Alternative f => Bool -> f ()
+ Yesod.Paginator.Prelude: head :: () => [a] -> a
+ Yesod.Paginator.Prelude: headDef :: () => a -> [a] -> a
+ Yesod.Paginator.Prelude: headMay :: () => [a] -> Maybe a
+ Yesod.Paginator.Prelude: headNote :: Partial => String -> [a] -> a
+ Yesod.Paginator.Prelude: id :: () => a -> a
+ Yesod.Paginator.Prelude: indexDef :: Ix a => Int -> (a, a) -> a -> Int
+ Yesod.Paginator.Prelude: indexMay :: Ix a => (a, a) -> a -> Maybe Int
+ Yesod.Paginator.Prelude: indexNote :: (Partial, Ix a) => String -> (a, a) -> a -> Int
+ Yesod.Paginator.Prelude: infix 4 `notElem`
+ Yesod.Paginator.Prelude: infix 5 \\
+ Yesod.Paginator.Prelude: infixl 4 <$!>
+ Yesod.Paginator.Prelude: infixl 9 !!
+ Yesod.Paginator.Prelude: infixr 0 $!
+ Yesod.Paginator.Prelude: infixr 1 =<<
+ Yesod.Paginator.Prelude: infixr 2 ||
+ Yesod.Paginator.Prelude: infixr 3 &&
+ Yesod.Paginator.Prelude: infixr 5 ++
+ Yesod.Paginator.Prelude: infixr 8 ^
+ Yesod.Paginator.Prelude: infixr 9 .
+ Yesod.Paginator.Prelude: init :: () => [a] -> [a]
+ Yesod.Paginator.Prelude: initDef :: () => [a] -> [a] -> [a]
+ Yesod.Paginator.Prelude: initMay :: () => [a] -> Maybe [a]
+ Yesod.Paginator.Prelude: initNote :: Partial => String -> [a] -> [a]
+ Yesod.Paginator.Prelude: initSafe :: () => [a] -> [a]
+ Yesod.Paginator.Prelude: inits :: () => [a] -> [[a]]
+ Yesod.Paginator.Prelude: insert :: Ord a => a -> [a] -> [a]
+ Yesod.Paginator.Prelude: insertBy :: () => a -> a -> Ordering -> a -> [a] -> [a]
+ Yesod.Paginator.Prelude: interact :: String -> String -> IO ()
+ Yesod.Paginator.Prelude: intercalate :: () => [a] -> [[a]] -> [a]
+ Yesod.Paginator.Prelude: intersect :: Eq a => [a] -> [a] -> [a]
+ Yesod.Paginator.Prelude: intersectBy :: () => a -> a -> Bool -> [a] -> [a] -> [a]
+ Yesod.Paginator.Prelude: intersperse :: () => a -> [a] -> [a]
+ Yesod.Paginator.Prelude: ioError :: () => IOError -> IO a
+ Yesod.Paginator.Prelude: isDenormalized :: RealFloat a => a -> Bool
+ Yesod.Paginator.Prelude: isIEEE :: RealFloat a => a -> Bool
+ Yesod.Paginator.Prelude: isInfinite :: RealFloat a => a -> Bool
+ Yesod.Paginator.Prelude: isInfixOf :: Eq a => [a] -> [a] -> Bool
+ Yesod.Paginator.Prelude: isJust :: () => Maybe a -> Bool
+ Yesod.Paginator.Prelude: isNaN :: RealFloat a => a -> Bool
+ Yesod.Paginator.Prelude: isNegativeZero :: RealFloat a => a -> Bool
+ Yesod.Paginator.Prelude: isNothing :: () => Maybe a -> Bool
+ Yesod.Paginator.Prelude: isPrefixOf :: Eq a => [a] -> [a] -> Bool
+ Yesod.Paginator.Prelude: isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
+ Yesod.Paginator.Prelude: isSuffixOf :: Eq a => [a] -> [a] -> Bool
+ Yesod.Paginator.Prelude: iterate :: () => a -> a -> a -> [a]
+ Yesod.Paginator.Prelude: iterate' :: () => a -> a -> a -> [a]
+ Yesod.Paginator.Prelude: join :: Monad m => m m a -> m a
+ Yesod.Paginator.Prelude: last :: () => [a] -> a
+ Yesod.Paginator.Prelude: lastDef :: () => a -> [a] -> a
+ Yesod.Paginator.Prelude: lastMay :: () => [a] -> Maybe a
+ Yesod.Paginator.Prelude: lastNote :: Partial => String -> [a] -> a
+ Yesod.Paginator.Prelude: lcm :: Integral a => a -> a -> a
+ Yesod.Paginator.Prelude: length :: Foldable t => t a -> Int
+ Yesod.Paginator.Prelude: lex :: ReadS String
+ Yesod.Paginator.Prelude: liftM :: Monad m => a1 -> r -> m a1 -> m r
+ Yesod.Paginator.Prelude: liftM2 :: Monad m => a1 -> a2 -> r -> m a1 -> m a2 -> m r
+ Yesod.Paginator.Prelude: liftM3 :: Monad m => a1 -> a2 -> a3 -> r -> m a1 -> m a2 -> m a3 -> m r
+ Yesod.Paginator.Prelude: liftM4 :: Monad m => a1 -> a2 -> a3 -> a4 -> r -> m a1 -> m a2 -> m a3 -> m a4 -> m r
+ Yesod.Paginator.Prelude: liftM5 :: Monad m => a1 -> a2 -> a3 -> a4 -> a5 -> r -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
+ Yesod.Paginator.Prelude: lines :: String -> [String]
+ Yesod.Paginator.Prelude: listToMaybe :: () => [a] -> Maybe a
+ Yesod.Paginator.Prelude: log :: Floating a => a -> a
+ Yesod.Paginator.Prelude: logBase :: Floating a => a -> a -> a
+ Yesod.Paginator.Prelude: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Yesod.Paginator.Prelude: lookupJust :: (Eq a, Partial) => a -> [(a, b)] -> b
+ Yesod.Paginator.Prelude: lookupJustDef :: Eq a => b -> a -> [(a, b)] -> b
+ Yesod.Paginator.Prelude: lookupJustNote :: (Partial, Eq a) => String -> a -> [(a, b)] -> b
+ Yesod.Paginator.Prelude: map :: () => a -> b -> [a] -> [b]
+ Yesod.Paginator.Prelude: mapAccumL :: Traversable t => a -> b -> (a, c) -> a -> t b -> (a, t c)
+ Yesod.Paginator.Prelude: mapAccumR :: Traversable t => a -> b -> (a, c) -> a -> t b -> (a, t c)
+ Yesod.Paginator.Prelude: mapAndUnzipM :: Applicative m => a -> m (b, c) -> [a] -> m ([b], [c])
+ Yesod.Paginator.Prelude: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ Yesod.Paginator.Prelude: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()
+ Yesod.Paginator.Prelude: mapMaybe :: () => a -> Maybe b -> [a] -> [b]
+ Yesod.Paginator.Prelude: mappend :: Monoid a => a -> a -> a
+ Yesod.Paginator.Prelude: max :: Ord a => a -> a -> a
+ Yesod.Paginator.Prelude: maxBound :: Bounded a => a
+ Yesod.Paginator.Prelude: maximum :: (Foldable t, Ord a) => t a -> a
+ Yesod.Paginator.Prelude: maximumBy :: Foldable t => a -> a -> Ordering -> t a -> a
+ Yesod.Paginator.Prelude: maximumByDef :: () => a -> a -> a -> Ordering -> [a] -> a
+ Yesod.Paginator.Prelude: maximumByMay :: () => a -> a -> Ordering -> [a] -> Maybe a
+ Yesod.Paginator.Prelude: maximumByNote :: Partial => String -> a -> a -> Ordering -> [a] -> a
+ Yesod.Paginator.Prelude: maximumDef :: Ord a => a -> [a] -> a
+ Yesod.Paginator.Prelude: maximumMay :: Ord a => [a] -> Maybe a
+ Yesod.Paginator.Prelude: maximumNote :: (Partial, Ord a) => String -> [a] -> a
+ Yesod.Paginator.Prelude: maybe :: () => b -> a -> b -> Maybe a -> b
+ Yesod.Paginator.Prelude: maybeToList :: () => Maybe a -> [a]
+ Yesod.Paginator.Prelude: mconcat :: Monoid a => [a] -> a
+ Yesod.Paginator.Prelude: mempty :: Monoid a => a
+ Yesod.Paginator.Prelude: mfilter :: MonadPlus m => a -> Bool -> m a -> m a
+ Yesod.Paginator.Prelude: min :: Ord a => a -> a -> a
+ Yesod.Paginator.Prelude: minBound :: Bounded a => a
+ Yesod.Paginator.Prelude: minimum :: (Foldable t, Ord a) => t a -> a
+ Yesod.Paginator.Prelude: minimumBy :: Foldable t => a -> a -> Ordering -> t a -> a
+ Yesod.Paginator.Prelude: minimumByDef :: () => a -> a -> a -> Ordering -> [a] -> a
+ Yesod.Paginator.Prelude: minimumByMay :: () => a -> a -> Ordering -> [a] -> Maybe a
+ Yesod.Paginator.Prelude: minimumByNote :: Partial => String -> a -> a -> Ordering -> [a] -> a
+ Yesod.Paginator.Prelude: minimumDef :: Ord a => a -> [a] -> a
+ Yesod.Paginator.Prelude: minimumMay :: Ord a => [a] -> Maybe a
+ Yesod.Paginator.Prelude: minimumNote :: (Partial, Ord a) => String -> [a] -> a
+ Yesod.Paginator.Prelude: mod :: Integral a => a -> a -> a
+ Yesod.Paginator.Prelude: mplus :: MonadPlus m => m a -> m a -> m a
+ Yesod.Paginator.Prelude: msum :: (Foldable t, MonadPlus m) => t m a -> m a
+ Yesod.Paginator.Prelude: mzero :: MonadPlus m => m a
+ Yesod.Paginator.Prelude: negate :: Num a => a -> a
+ Yesod.Paginator.Prelude: not :: Bool -> Bool
+ Yesod.Paginator.Prelude: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Yesod.Paginator.Prelude: nub :: Eq a => [a] -> [a]
+ Yesod.Paginator.Prelude: nubBy :: () => a -> a -> Bool -> [a] -> [a]
+ Yesod.Paginator.Prelude: null :: Foldable t => t a -> Bool
+ Yesod.Paginator.Prelude: odd :: Integral a => a -> Bool
+ Yesod.Paginator.Prelude: or :: Foldable t => t Bool -> Bool
+ Yesod.Paginator.Prelude: otherwise :: Bool
+ Yesod.Paginator.Prelude: pack :: String -> Text
+ Yesod.Paginator.Prelude: partition :: () => a -> Bool -> [a] -> ([a], [a])
+ Yesod.Paginator.Prelude: permutations :: () => [a] -> [[a]]
+ Yesod.Paginator.Prelude: pi :: Floating a => a
+ Yesod.Paginator.Prelude: pred :: Enum a => a -> a
+ Yesod.Paginator.Prelude: predDef :: (Enum a, Eq a, Bounded a) => a -> a -> a
+ Yesod.Paginator.Prelude: predMay :: (Enum a, Eq a, Bounded a) => a -> Maybe a
+ Yesod.Paginator.Prelude: predNote :: (Partial, Enum a, Eq a, Bounded a) => String -> a -> a
+ Yesod.Paginator.Prelude: predSafe :: (Enum a, Eq a, Bounded a) => a -> a
+ Yesod.Paginator.Prelude: print :: Show a => a -> IO ()
+ Yesod.Paginator.Prelude: product :: (Foldable t, Num a) => t a -> a
+ Yesod.Paginator.Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Yesod.Paginator.Prelude: pure :: Applicative f => a -> f a
+ Yesod.Paginator.Prelude: putChar :: Char -> IO ()
+ Yesod.Paginator.Prelude: putStr :: String -> IO ()
+ Yesod.Paginator.Prelude: putStrLn :: String -> IO ()
+ Yesod.Paginator.Prelude: quot :: Integral a => a -> a -> a
+ Yesod.Paginator.Prelude: quotRem :: Integral a => a -> a -> (a, a)
+ Yesod.Paginator.Prelude: read :: Read a => String -> a
+ Yesod.Paginator.Prelude: readDef :: Read a => a -> String -> a
+ Yesod.Paginator.Prelude: readEitherSafe :: Read a => String -> Either String a
+ Yesod.Paginator.Prelude: readFile :: FilePath -> IO String
+ Yesod.Paginator.Prelude: readIO :: Read a => String -> IO a
+ Yesod.Paginator.Prelude: readList :: Read a => ReadS [a]
+ Yesod.Paginator.Prelude: readLn :: Read a => IO a
+ Yesod.Paginator.Prelude: readMay :: Read a => String -> Maybe a
+ Yesod.Paginator.Prelude: readNote :: (Partial, Read a) => String -> String -> a
+ Yesod.Paginator.Prelude: readParen :: () => Bool -> ReadS a -> ReadS a
+ Yesod.Paginator.Prelude: reads :: Read a => ReadS a
+ Yesod.Paginator.Prelude: readsPrec :: Read a => Int -> ReadS a
+ Yesod.Paginator.Prelude: realToFrac :: (Real a, Fractional b) => a -> b
+ Yesod.Paginator.Prelude: recip :: Fractional a => a -> a
+ Yesod.Paginator.Prelude: rem :: Integral a => a -> a -> a
+ Yesod.Paginator.Prelude: repeat :: () => a -> [a]
+ Yesod.Paginator.Prelude: replicate :: () => Int -> a -> [a]
+ Yesod.Paginator.Prelude: replicateM :: Applicative m => Int -> m a -> m [a]
+ Yesod.Paginator.Prelude: replicateM_ :: Applicative m => Int -> m a -> m ()
+ Yesod.Paginator.Prelude: return :: Monad m => a -> m a
+ Yesod.Paginator.Prelude: reverse :: () => [a] -> [a]
+ Yesod.Paginator.Prelude: round :: (RealFrac a, Integral b) => a -> b
+ Yesod.Paginator.Prelude: scaleFloat :: RealFloat a => Int -> a -> a
+ Yesod.Paginator.Prelude: scanl :: () => b -> a -> b -> b -> [a] -> [b]
+ Yesod.Paginator.Prelude: scanl' :: () => b -> a -> b -> b -> [a] -> [b]
+ Yesod.Paginator.Prelude: scanl1 :: () => a -> a -> a -> [a] -> [a]
+ Yesod.Paginator.Prelude: scanl1Def :: () => [a] -> a -> a -> a -> [a] -> [a]
+ Yesod.Paginator.Prelude: scanl1May :: () => a -> a -> a -> [a] -> Maybe [a]
+ Yesod.Paginator.Prelude: scanl1Note :: Partial => String -> a -> a -> a -> [a] -> [a]
+ Yesod.Paginator.Prelude: scanr :: () => a -> b -> b -> b -> [a] -> [b]
+ Yesod.Paginator.Prelude: scanr1 :: () => a -> a -> a -> [a] -> [a]
+ Yesod.Paginator.Prelude: scanr1Def :: () => [a] -> a -> a -> a -> [a] -> [a]
+ Yesod.Paginator.Prelude: scanr1May :: () => a -> a -> a -> [a] -> Maybe [a]
+ Yesod.Paginator.Prelude: scanr1Note :: Partial => String -> a -> a -> a -> [a] -> [a]
+ Yesod.Paginator.Prelude: seq :: () => a -> b -> b
+ Yesod.Paginator.Prelude: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ Yesod.Paginator.Prelude: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ Yesod.Paginator.Prelude: sequence_ :: (Foldable t, Monad m) => t m a -> m ()
+ Yesod.Paginator.Prelude: show :: Show a => a -> String
+ Yesod.Paginator.Prelude: showChar :: Char -> ShowS
+ Yesod.Paginator.Prelude: showList :: Show a => [a] -> ShowS
+ Yesod.Paginator.Prelude: showParen :: Bool -> ShowS -> ShowS
+ Yesod.Paginator.Prelude: showString :: String -> ShowS
+ Yesod.Paginator.Prelude: shows :: Show a => a -> ShowS
+ Yesod.Paginator.Prelude: showsPrec :: Show a => Int -> a -> ShowS
+ Yesod.Paginator.Prelude: significand :: RealFloat a => a -> a
+ Yesod.Paginator.Prelude: signum :: Num a => a -> a
+ Yesod.Paginator.Prelude: sin :: Floating a => a -> a
+ Yesod.Paginator.Prelude: sinh :: Floating a => a -> a
+ Yesod.Paginator.Prelude: snd :: () => (a, b) -> b
+ Yesod.Paginator.Prelude: sort :: Ord a => [a] -> [a]
+ Yesod.Paginator.Prelude: sortBy :: () => a -> a -> Ordering -> [a] -> [a]
+ Yesod.Paginator.Prelude: sortOn :: Ord b => a -> b -> [a] -> [a]
+ Yesod.Paginator.Prelude: span :: () => a -> Bool -> [a] -> ([a], [a])
+ Yesod.Paginator.Prelude: splitAt :: () => Int -> [a] -> ([a], [a])
+ Yesod.Paginator.Prelude: sqrt :: Floating a => a -> a
+ Yesod.Paginator.Prelude: stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
+ Yesod.Paginator.Prelude: subsequences :: () => [a] -> [[a]]
+ Yesod.Paginator.Prelude: subtract :: Num a => a -> a -> a
+ Yesod.Paginator.Prelude: succ :: Enum a => a -> a
+ Yesod.Paginator.Prelude: succDef :: (Enum a, Eq a, Bounded a) => a -> a -> a
+ Yesod.Paginator.Prelude: succMay :: (Enum a, Eq a, Bounded a) => a -> Maybe a
+ Yesod.Paginator.Prelude: succNote :: (Partial, Enum a, Eq a, Bounded a) => String -> a -> a
+ Yesod.Paginator.Prelude: succSafe :: (Enum a, Eq a, Bounded a) => a -> a
+ Yesod.Paginator.Prelude: sum :: (Foldable t, Num a) => t a -> a
+ Yesod.Paginator.Prelude: tail :: () => [a] -> [a]
+ Yesod.Paginator.Prelude: tailDef :: () => [a] -> [a] -> [a]
+ Yesod.Paginator.Prelude: tailMay :: () => [a] -> Maybe [a]
+ Yesod.Paginator.Prelude: tailNote :: Partial => String -> [a] -> [a]
+ Yesod.Paginator.Prelude: tailSafe :: () => [a] -> [a]
+ Yesod.Paginator.Prelude: tails :: () => [a] -> [[a]]
+ Yesod.Paginator.Prelude: take :: () => Int -> [a] -> [a]
+ Yesod.Paginator.Prelude: takeWhile :: () => a -> Bool -> [a] -> [a]
+ Yesod.Paginator.Prelude: tan :: Floating a => a -> a
+ Yesod.Paginator.Prelude: tanh :: Floating a => a -> a
+ Yesod.Paginator.Prelude: toEnum :: Enum a => Int -> a
+ Yesod.Paginator.Prelude: toEnumDef :: (Enum a, Bounded a) => a -> Int -> a
+ Yesod.Paginator.Prelude: toEnumMay :: (Enum a, Bounded a) => Int -> Maybe a
+ Yesod.Paginator.Prelude: toEnumNote :: (Partial, Enum a, Bounded a) => String -> Int -> a
+ Yesod.Paginator.Prelude: toEnumSafe :: (Enum a, Bounded a) => Int -> a
+ Yesod.Paginator.Prelude: toInteger :: Integral a => a -> Integer
+ Yesod.Paginator.Prelude: toRational :: Real a => a -> Rational
+ Yesod.Paginator.Prelude: transpose :: () => [[a]] -> [[a]]
+ Yesod.Paginator.Prelude: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ Yesod.Paginator.Prelude: truncate :: (RealFrac a, Integral b) => a -> b
+ Yesod.Paginator.Prelude: type FilePath = String
+ Yesod.Paginator.Prelude: type IOError = IOException
+ Yesod.Paginator.Prelude: type Rational = Ratio Integer
+ Yesod.Paginator.Prelude: type ReadS a = String -> [(a, String)]
+ Yesod.Paginator.Prelude: type ShowS = String -> String
+ Yesod.Paginator.Prelude: type String = [Char]
+ Yesod.Paginator.Prelude: uncons :: () => [a] -> Maybe (a, [a])
+ Yesod.Paginator.Prelude: uncurry :: () => a -> b -> c -> (a, b) -> c
+ Yesod.Paginator.Prelude: undefined :: HasCallStack => a
+ Yesod.Paginator.Prelude: unfoldr :: () => b -> Maybe (a, b) -> b -> [a]
+ Yesod.Paginator.Prelude: union :: Eq a => [a] -> [a] -> [a]
+ Yesod.Paginator.Prelude: unionBy :: () => a -> a -> Bool -> [a] -> [a] -> [a]
+ Yesod.Paginator.Prelude: unless :: Applicative f => Bool -> f () -> f ()
+ Yesod.Paginator.Prelude: unlines :: [String] -> String
+ Yesod.Paginator.Prelude: unpack :: Text -> String
+ Yesod.Paginator.Prelude: until :: () => a -> Bool -> a -> a -> a -> a
+ Yesod.Paginator.Prelude: unwords :: [String] -> String
+ Yesod.Paginator.Prelude: unzip :: () => [(a, b)] -> ([a], [b])
+ Yesod.Paginator.Prelude: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
+ Yesod.Paginator.Prelude: unzip4 :: () => [(a, b, c, d)] -> ([a], [b], [c], [d])
+ Yesod.Paginator.Prelude: unzip5 :: () => [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
+ Yesod.Paginator.Prelude: unzip6 :: () => [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
+ Yesod.Paginator.Prelude: unzip7 :: () => [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
+ Yesod.Paginator.Prelude: userError :: String -> IOError
+ Yesod.Paginator.Prelude: void :: Functor f => f a -> f ()
+ Yesod.Paginator.Prelude: when :: Applicative f => Bool -> f () -> f ()
+ Yesod.Paginator.Prelude: words :: String -> [String]
+ Yesod.Paginator.Prelude: writeFile :: FilePath -> String -> IO ()
+ Yesod.Paginator.Prelude: zip :: () => [a] -> [b] -> [(a, b)]
+ Yesod.Paginator.Prelude: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]
+ Yesod.Paginator.Prelude: zip4 :: () => [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
+ Yesod.Paginator.Prelude: zip5 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
+ Yesod.Paginator.Prelude: zip6 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
+ Yesod.Paginator.Prelude: zip7 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
+ Yesod.Paginator.Prelude: zipWith :: () => a -> b -> c -> [a] -> [b] -> [c]
+ Yesod.Paginator.Prelude: zipWith3 :: () => a -> b -> c -> d -> [a] -> [b] -> [c] -> [d]
+ Yesod.Paginator.Prelude: zipWith4 :: () => a -> b -> c -> d -> e -> [a] -> [b] -> [c] -> [d] -> [e]
+ Yesod.Paginator.Prelude: zipWith5 :: () => a -> b -> c -> d -> e -> f -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
+ Yesod.Paginator.Prelude: zipWith6 :: () => a -> b -> c -> d -> e -> f -> g -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
+ Yesod.Paginator.Prelude: zipWith7 :: () => a -> b -> c -> d -> e -> f -> g -> h -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
+ Yesod.Paginator.Prelude: zipWithM :: Applicative m => a -> b -> m c -> [a] -> [b] -> m [c]
+ Yesod.Paginator.Prelude: zipWithM_ :: Applicative m => a -> b -> m c -> [a] -> [b] -> m ()
- Yesod.Paginator: paginate :: Yesod site => PerPage -> [a] -> HandlerFor site (Pages a)
+ Yesod.Paginator: paginate :: MonadHandler m => PerPage -> [a] -> m (Pages a)
- Yesod.Paginator: selectPaginated :: (PersistEntity val, PersistEntityBackend val ~ BaseBackend (YesodPersistBackend site), PersistQuery (YesodPersistBackend site), Yesod site) => PerPage -> [Filter val] -> [SelectOpt val] -> YesodDB site (Pages (Entity val))
+ Yesod.Paginator: selectPaginated :: (MonadHandler m, PersistEntity record, PersistEntityBackend record ~ BaseBackend backend, PersistQueryRead backend) => PerPage -> [Filter record] -> [SelectOpt record] -> ReaderT backend m (Pages (Entity record))
- Yesod.Paginator.Paginate: paginate :: Yesod site => PerPage -> [a] -> HandlerFor site (Pages a)
+ Yesod.Paginator.Paginate: paginate :: MonadHandler m => PerPage -> [a] -> m (Pages a)
- Yesod.Paginator.Paginate: selectPaginated :: (PersistEntity val, PersistEntityBackend val ~ BaseBackend (YesodPersistBackend site), PersistQuery (YesodPersistBackend site), Yesod site) => PerPage -> [Filter val] -> [SelectOpt val] -> YesodDB site (Pages (Entity val))
+ Yesod.Paginator.Paginate: selectPaginated :: (MonadHandler m, PersistEntity record, PersistEntityBackend record ~ BaseBackend backend, PersistQueryRead backend) => PerPage -> [Filter record] -> [SelectOpt record] -> ReaderT backend m (Pages (Entity record))
Files
- src/Yesod/Paginator/Paginate.hs +10/−10
- yesod-paginator.cabal +2/−3
src/Yesod/Paginator/Paginate.hs view
@@ -7,6 +7,7 @@ , paginate' , selectPaginated , selectPaginated'+ , getCurrentPage ) where @@ -16,10 +17,9 @@ import Database.Persist import Yesod.Core import Yesod.Paginator.Pages-import Yesod.Persist.Core -- | Paginate a list of items-paginate :: Yesod site => PerPage -> [a] -> HandlerFor site (Pages a)+paginate :: MonadHandler m => PerPage -> [a] -> m (Pages a) paginate per items = paginate' per items <$> getCurrentPage -- | A version where the current page is given@@ -49,21 +49,21 @@ -- | Paginate out of a persistent database selectPaginated- :: ( PersistEntity val- , PersistEntityBackend val ~ BaseBackend (YesodPersistBackend site)- , PersistQuery (YesodPersistBackend site)- , Yesod site+ :: ( MonadHandler m+ , PersistEntity record+ , PersistEntityBackend record ~ BaseBackend backend+ , PersistQueryRead backend ) => PerPage- -> [Filter val]- -> [SelectOpt val]- -> YesodDB site (Pages (Entity val))+ -> [Filter record]+ -> [SelectOpt record]+ -> ReaderT backend m (Pages (Entity record)) selectPaginated per filters options = selectPaginated' per filters options =<< lift getCurrentPage -- | A version where the current page is given ----- This can be used to avoid the Yesod context+-- This can be used to avoid the @'MonadHandler'@ context. -- selectPaginated' :: ( MonadIO m
yesod-paginator.cabal view
@@ -2,10 +2,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: 4dbcdeb4bab34224d2c65b70f8a52d4759b83a23c55b5e77e4e616bce3152296+-- hash: d114fc955427bbe8caa75c10f5898d5fbb49e54e90b280a34b9720af0a92c592 name: yesod-paginator-version: 1.1.0.0+version: 1.1.0.1 synopsis: A pagination approach for yesod description: Paginate a list showing a per-item widget and links to other pages category: Web, Yesod@@ -49,7 +49,6 @@ , transformers , uri-encode , yesod-core >=1.4- , yesod-persistent >=1.4 default-language: Haskell2010 executable yesod-paginator-example