Safe Haskell	Safe-Inferred
Language	Haskell2010

Hledger.Web.Import

Synopsis

(++) :: [a] -> [a] -> [a]
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
filter :: (a -> Bool) -> [a] -> [a]
zip :: [a] -> [b] -> [(a, b)]
print :: Show a => a -> IO ()
fst :: (a, b) -> a
snd :: (a, b) -> b
otherwise :: Bool
map :: (a -> b) -> [a] -> [b]
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
fromIntegral :: (Integral a, Num b) => a -> b
realToFrac :: (Real a, Fractional b) => a -> b
guard :: Alternative f => Bool -> f ()
join :: Monad m => m (m a) -> m a
class Bounded a where
- minBound :: a
- maxBound :: a
class Enum a where
- succ :: a -> a
- pred :: a -> a
- toEnum :: Int -> a
- fromEnum :: a -> Int
- enumFrom :: a -> [a]
- enumFromThen :: a -> a -> [a]
- enumFromTo :: a -> a -> [a]
- enumFromThenTo :: a -> a -> a -> [a]
class Eq a where
- (==) :: a -> a -> Bool
- (/=) :: a -> a -> Bool
class Fractional a => Floating a where
- pi :: a
- exp :: a -> a
- log :: a -> a
- sqrt :: a -> a
- (**) :: a -> a -> a
- logBase :: a -> a -> a
- sin :: a -> a
- cos :: a -> a
- tan :: a -> a
- asin :: a -> a
- acos :: a -> a
- atan :: a -> a
- sinh :: a -> a
- cosh :: a -> a
- tanh :: a -> a
- asinh :: a -> a
- acosh :: a -> a
- atanh :: a -> a
class Num a => Fractional a where
- (/) :: a -> a -> a
- recip :: a -> a
- fromRational :: Rational -> a
class (Real a, Enum a) => Integral a where
- quot :: a -> a -> a
- rem :: a -> a -> a
- div :: a -> a -> a
- mod :: a -> a -> a
- quotRem :: a -> a -> (a, a)
- divMod :: a -> a -> (a, a)
- toInteger :: a -> Integer
class Applicative m => Monad (m :: Type -> Type) where
- (>>=) :: m a -> (a -> m b) -> m b
- (>>) :: m a -> m b -> m b
- return :: a -> m a
class Functor (f :: Type -> Type) where
- fmap :: (a -> b) -> f a -> f b
- (<$) :: a -> f b -> f a
class Num a where
- (+) :: a -> a -> a
- (-) :: a -> a -> a
- (*) :: a -> a -> a
- negate :: a -> a
- abs :: a -> a
- signum :: a -> a
- fromInteger :: Integer -> a
class Eq a => Ord a where
- compare :: a -> a -> Ordering
- (<) :: a -> a -> Bool
- (<=) :: a -> a -> Bool
- (>) :: a -> a -> Bool
- (>=) :: a -> a -> Bool
- max :: a -> a -> a
- min :: a -> a -> a
class Read a where
- readsPrec :: Int -> ReadS a
- readList :: ReadS [a]
class (Num a, Ord a) => Real a where
- toRational :: a -> Rational
class (RealFrac a, Floating a) => RealFloat a where
- floatRadix :: a -> Integer
- floatDigits :: a -> Int
- floatRange :: a -> (Int, Int)
- decodeFloat :: a -> (Integer, Int)
- encodeFloat :: Integer -> Int -> a
- exponent :: a -> Int
- significand :: a -> a
- scaleFloat :: Int -> a -> a
- isNaN :: a -> Bool
- isInfinite :: a -> Bool
- isDenormalized :: a -> Bool
- isNegativeZero :: a -> Bool
- isIEEE :: a -> Bool
- atan2 :: a -> a -> a
class (Real a, Fractional a) => RealFrac a where
- properFraction :: Integral b => a -> (b, a)
- truncate :: Integral b => a -> b
- round :: Integral b => a -> b
- ceiling :: Integral b => a -> b
- floor :: Integral b => a -> b
class Show a where
- showsPrec :: Int -> a -> ShowS
- show :: a -> String
- showList :: [a] -> ShowS
class Monad m => MonadFail (m :: Type -> Type) where
- fail :: String -> m a
class Functor f => Applicative (f :: Type -> Type) where
- pure :: a -> f a
- (<*>) :: f (a -> b) -> f a -> f b
- (*>) :: f a -> f b -> f b
- (<*) :: f a -> f b -> f a
class Foldable (t :: TYPE LiftedRep -> Type) where
- fold :: Monoid m => t m -> m
- foldMap :: Monoid m => (a -> m) -> t a -> m
- foldMap' :: Monoid m => (a -> m) -> t a -> m
- foldr :: (a -> b -> b) -> b -> t a -> b
- foldr' :: (a -> b -> b) -> b -> t a -> b
- foldl :: (b -> a -> b) -> b -> t a -> b
- foldl' :: (b -> a -> b) -> b -> t a -> b
- foldr1 :: (a -> a -> a) -> t a -> a
- foldl1 :: (a -> a -> a) -> t a -> a
- toList :: t a -> [a]
- null :: t a -> Bool
- length :: t a -> Int
- elem :: Eq a => a -> t a -> Bool
- maximum :: Ord a => t a -> a
- minimum :: Ord a => t a -> a
- sum :: Num a => t a -> a
- product :: Num a => t a -> a
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
- sequenceA :: Applicative f => t (f a) -> f (t a)
- mapM :: Monad m => (a -> m b) -> t a -> m (t b)
- sequence :: Monad m => t (m a) -> m (t a)
class Semigroup a where
- (<>) :: a -> a -> a
class Semigroup a => Monoid a where
- mempty :: a
- mappend :: a -> a -> a
- mconcat :: [a] -> a
data Bool
- = False
- | True
type String = [Char]
data Char
data Double
data Float
data Int
data Integer
data Maybe a
- = Nothing
- | Just a
data Ordering
- = LT
- | EQ
- | GT
type Rational = Ratio Integer
data IO a
data Word
data Either a b
- = Left a
- | Right b
type FilePath = String
span :: (a -> Bool) -> [a] -> ([a], [a])
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
type ShowS = String -> String
(<$>) :: Functor f => (a -> b) -> f a -> f b
type Year = Integer
const :: a -> b -> a
(.) :: (b -> c) -> (a -> b) -> a -> c
id :: a -> a
data UTCTime = UTCTime {
- utctDay :: Day
- utctDayTime :: DiffTime
}
data ByteString
data Text
class ToJSON a where
- toJSON :: a -> Value
- toEncoding :: a -> Encoding
- toJSONList :: [a] -> Value
- toEncodingList :: [a] -> Encoding
(.=) :: (KeyValue kv, ToJSON v) => Key -> v -> kv
(.:) :: FromJSON a => Object -> Key -> Parser a
class FromJSON a where
- parseJSON :: Value -> Parser a
- parseJSONList :: Value -> Parser [a]
object :: [Pair] -> Value
data Value
- = Object !Object
- | Array !Array
- | String !Text
- | Number !Scientific
- | Bool !Bool
- | Null
class Bifunctor (p :: Type -> Type -> Type) where
- bimap :: (a -> b) -> (c -> d) -> p a c -> p b d
- first :: (a -> b) -> p a c -> p b c
- second :: (b -> c) -> p a b -> p a c
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
read :: Read a => String -> a
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- mzero :: m a
- mplus :: m a -> m a -> m a
data Void
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
unless :: Applicative f => Bool -> f () -> f ()
replicateM_ :: Applicative m => Int -> m a -> m ()
replicateM :: Applicative m => Int -> m a -> m [a]
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
forever :: Applicative f => f a -> f b
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(<$!>) :: Monad m => (a -> b) -> m a -> m b
mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
fmapDefault :: Traversable t => (a -> b) -> t a -> t b
readLn :: Read a => IO a
readIO :: Read a => String -> IO a
putStrLn :: String -> IO ()
putStr :: String -> IO ()
putChar :: Char -> IO ()
interact :: (String -> String) -> IO ()
getLine :: IO String
getContents :: IO String
getChar :: IO Char
appendFile :: FilePath -> String -> IO ()
ioError :: IOError -> IO a
type IOError = IOException
userError :: String -> IOError
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
or :: Foldable t => t Bool -> Bool
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
find :: Foldable t => (a -> Bool) -> t a -> Maybe a
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
concat :: Foldable t => t [a] -> [a]
asum :: (Foldable t, Alternative f) => t (f a) -> f a
any :: Foldable t => (a -> Bool) -> t a -> Bool
and :: Foldable t => t Bool -> Bool
all :: Foldable t => (a -> Bool) -> t a -> Bool
words :: String -> [String]
unwords :: [String] -> String
unlines :: [String] -> String
unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
lines :: String -> [String]
reads :: Read a => ReadS a
rights :: [Either a b] -> [b]
partitionEithers :: [Either a b] -> ([a], [b])
lefts :: [Either a b] -> [a]
isRight :: Either a b -> Bool
isLeft :: Either a b -> Bool
fromRight :: b -> Either a b -> b
fromLeft :: a -> Either a b -> a
either :: (a -> c) -> (b -> c) -> Either a b -> c
readParen :: Bool -> ReadS a -> ReadS a
lex :: ReadS String
type ReadS a = String -> [(a, String)]
odd :: Integral a => a -> Bool
lcm :: Integral a => a -> a -> a
gcd :: Integral a => a -> a -> a
even :: Integral a => a -> Bool
(^^) :: (Fractional a, Integral b) => a -> b -> a
(^) :: (Num a, Integral b) => a -> b -> a
shows :: Show a => a -> ShowS
showString :: String -> ShowS
showParen :: Bool -> ShowS -> ShowS
showChar :: Char -> ShowS
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
unzip :: [(a, b)] -> ([a], [b])
takeWhile :: (a -> Bool) -> [a] -> [a]
take :: Int -> [a] -> [a]
splitAt :: Int -> [a] -> ([a], [a])
scanr1 :: (a -> a -> a) -> [a] -> [a]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanl1 :: (a -> a -> a) -> [a] -> [a]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
reverse :: [a] -> [a]
replicate :: Int -> a -> [a]
repeat :: a -> [a]
lookup :: Eq a => a -> [(a, b)] -> Maybe b
iterate :: (a -> a) -> a -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
drop :: Int -> [a] -> [a]
cycle :: [a] -> [a]
break :: (a -> Bool) -> [a] -> ([a], [a])
(!!) :: [a] -> Int -> a
maybeToList :: Maybe a -> [a]
maybe :: b -> (a -> b) -> Maybe a -> b
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
listToMaybe :: [a] -> Maybe a
isNothing :: Maybe a -> Bool
isJust :: Maybe a -> Bool
fromMaybe :: a -> Maybe a -> a
fromJust :: HasCallStack => Maybe a -> a
catMaybes :: [Maybe a] -> [a]
void :: Functor f => f a -> f ()
uncurry :: (a -> b -> c) -> (a, b) -> c
curry :: ((a, b) -> c) -> a -> b -> c
subtract :: Num a => a -> a -> a
when :: Applicative f => Bool -> f () -> f ()
until :: (a -> Bool) -> (a -> a) -> a -> a
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
flip :: (a -> b -> c) -> b -> a -> c
asTypeOf :: a -> a -> a
ap :: Monad m => m (a -> b) -> m a -> m b
(=<<) :: Monad m => (a -> m b) -> m a -> m b
($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a
(&&) :: Bool -> Bool -> Bool
not :: Bool -> Bool
(||) :: Bool -> Bool -> Bool
type Markup = MarkupM ()
preEscapedToMarkup :: ToMarkup a => a -> Markup
toHtml :: ToMarkup a => a -> Html
type Html = Markup
class MonadIO m => MonadUnliftIO (m :: Type -> Type) where
- withRunInIO :: ((forall a. m a -> IO a) -> IO b) -> m b
class MonadIO m => MonadResource (m :: Type -> Type) where
- liftResourceT :: ResourceT IO a -> m a
class MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- lift :: Monad m => m a -> t m a
data DiffTime
class Default a where
- def :: a
calendarDay :: CalendarDiffDays
calendarMonth :: CalendarDiffDays
calendarWeek :: CalendarDiffDays
calendarYear :: CalendarDiffDays
scaleCalendarDiffDays :: Integer -> CalendarDiffDays -> CalendarDiffDays
data CalendarDiffDays = CalendarDiffDays {
- cdMonths :: Integer
- cdDays :: Integer
}
addDays :: Integer -> Day -> Day
diffDays :: Day -> Day -> Integer
newtype Day = ModifiedJulianDay {
- toModifiedJulianDay :: Integer
}
type DayOfMonth = Int
type MonthOfYear = Int
isLeapYear :: Year -> Bool
pattern YearMonthDay :: Year -> MonthOfYear -> DayOfMonth -> Day
addGregorianDurationClip :: CalendarDiffDays -> Day -> Day
addGregorianDurationRollOver :: CalendarDiffDays -> Day -> Day
addGregorianMonthsClip :: Integer -> Day -> Day
addGregorianMonthsRollOver :: Integer -> Day -> Day
addGregorianYearsClip :: Integer -> Day -> Day
addGregorianYearsRollOver :: Integer -> Day -> Day
diffGregorianDurationClip :: Day -> Day -> CalendarDiffDays
diffGregorianDurationRollOver :: Day -> Day -> CalendarDiffDays
fromGregorian :: Year -> MonthOfYear -> DayOfMonth -> Day
fromGregorianValid :: Year -> MonthOfYear -> DayOfMonth -> Maybe Day
gregorianMonthLength :: Year -> MonthOfYear -> DayOfMonth
showGregorian :: Day -> String
toGregorian :: Day -> (Year, MonthOfYear, DayOfMonth)
dayOfWeek :: Day -> DayOfWeek
dayOfWeekDiff :: DayOfWeek -> DayOfWeek -> Int
firstDayOfWeekOnAfter :: DayOfWeek -> Day -> Day
data DayOfWeek
- = Monday
- | Tuesday
- | Wednesday
- | Thursday
- | Friday
- | Saturday
- | Sunday
diffTimeToPicoseconds :: DiffTime -> Integer
picosecondsToDiffTime :: Integer -> DiffTime
secondsToDiffTime :: Integer -> DiffTime
nominalDay :: NominalDiffTime
nominalDiffTimeToSeconds :: NominalDiffTime -> Pico
secondsToNominalDiffTime :: Pico -> NominalDiffTime
data NominalDiffTime
getTime_resolution :: DiffTime
newtype UniversalTime = ModJulianDate {
- getModJulianDate :: Rational
}
getCurrentTime :: IO UTCTime
addUTCTime :: NominalDiffTime -> UTCTime -> UTCTime
diffUTCTime :: UTCTime -> UTCTime -> NominalDiffTime
calendarTimeDays :: CalendarDiffDays -> CalendarDiffTime
calendarTimeTime :: NominalDiffTime -> CalendarDiffTime
scaleCalendarDiffTime :: Integer -> CalendarDiffTime -> CalendarDiffTime
data CalendarDiffTime = CalendarDiffTime {
- ctMonths :: Integer
- ctTime :: NominalDiffTime
}
getCurrentTimeZone :: IO TimeZone
getTimeZone :: UTCTime -> IO TimeZone
hoursToTimeZone :: Int -> TimeZone
minutesToTimeZone :: Int -> TimeZone
timeZoneOffsetString :: TimeZone -> String
timeZoneOffsetString' :: Maybe Char -> TimeZone -> String
utc :: TimeZone
data TimeZone = TimeZone {
- timeZoneMinutes :: Int
- timeZoneSummerOnly :: Bool
- timeZoneName :: String
}
dayFractionToTimeOfDay :: Rational -> TimeOfDay
daysAndTimeOfDayToTime :: Integer -> TimeOfDay -> NominalDiffTime
localToUTCTimeOfDay :: TimeZone -> TimeOfDay -> (Integer, TimeOfDay)
makeTimeOfDayValid :: Int -> Int -> Pico -> Maybe TimeOfDay
midday :: TimeOfDay
midnight :: TimeOfDay
pastMidnight :: DiffTime -> TimeOfDay
sinceMidnight :: TimeOfDay -> DiffTime
timeOfDayToDayFraction :: TimeOfDay -> Rational
timeOfDayToTime :: TimeOfDay -> DiffTime
timeToDaysAndTimeOfDay :: NominalDiffTime -> (Integer, TimeOfDay)
timeToTimeOfDay :: DiffTime -> TimeOfDay
utcToLocalTimeOfDay :: TimeZone -> TimeOfDay -> (Integer, TimeOfDay)
data TimeOfDay = TimeOfDay {
- todHour :: Int
- todMin :: Int
- todSec :: Pico
}
addLocalTime :: NominalDiffTime -> LocalTime -> LocalTime
diffLocalTime :: LocalTime -> LocalTime -> NominalDiffTime
localTimeToUT1 :: Rational -> LocalTime -> UniversalTime
localTimeToUTC :: TimeZone -> LocalTime -> UTCTime
ut1ToLocalTime :: Rational -> UniversalTime -> LocalTime
utcToLocalTime :: TimeZone -> UTCTime -> LocalTime
data LocalTime = LocalTime {
- localDay :: Day
- localTimeOfDay :: TimeOfDay
}
defaultTimeLocale :: TimeLocale
iso8601DateFormat :: Maybe String -> String
rfc822DateFormat :: String
data TimeLocale = TimeLocale {
- wDays :: [(String, String)]
- months :: [(String, String)]
- amPm :: (String, String)
- dateTimeFmt :: String
- dateFmt :: String
- timeFmt :: String
- time12Fmt :: String
- knownTimeZones :: [TimeZone]
}
class ParseTime t
formatTime :: FormatTime t => TimeLocale -> String -> t -> String
class FormatTime t
getZonedTime :: IO ZonedTime
utcToLocalZonedTime :: UTCTime -> IO ZonedTime
utcToZonedTime :: TimeZone -> UTCTime -> ZonedTime
zonedTimeToUTC :: ZonedTime -> UTCTime
data ZonedTime = ZonedTime {
- zonedTimeToLocalTime :: LocalTime
- zonedTimeZone :: TimeZone
}
parseTimeM :: (MonadFail m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
parseTimeMultipleM :: (MonadFail m, ParseTime t) => Bool -> TimeLocale -> [(String, String)] -> m t
parseTimeOrError :: ParseTime t => Bool -> TimeLocale -> String -> String -> t
readPTime :: ParseTime t => Bool -> TimeLocale -> String -> ReadP t
readSTime :: ParseTime t => Bool -> TimeLocale -> String -> ReadS t
logOtherS :: Q Exp
logErrorS :: Q Exp
logWarnS :: Q Exp
logInfoS :: Q Exp
logDebugS :: Q Exp
logOther :: Text -> Q Exp
logError :: Q Exp
logWarn :: Q Exp
logInfo :: Q Exp
logDebug :: Q Exp
data LogLevel
- = LevelDebug
- | LevelInfo
- | LevelWarn
- | LevelError
- | LevelOther Text
class Monad m => MonadLogger (m :: Type -> Type)
class PathPiece s where
- fromPathPiece :: Text -> Maybe s
- toPathPiece :: s -> Text
class PathMultiPiece s where
- fromPathMultiPiece :: [Text] -> Maybe s
- toPathMultiPiece :: s -> [Text]
discoverEntities :: Q Exp
mkMigrate :: String -> [UnboundEntityDef] -> Q [Dec]
migrateModels :: [EntityDef] -> Migration
derivePersistFieldJSON :: String -> Q [Dec]
derivePersistField :: String -> Q [Dec]
mkEntityDefList :: String -> [UnboundEntityDef] -> Q [Dec]
share :: [[a] -> Q [Dec]] -> [a] -> Q [Dec]
persistFieldFromEntity :: MkPersistSettings -> UnboundEntityDef -> Q [Dec]
fieldError :: Text -> Text -> Text -> Text
pkNewtype :: MkPersistSettings -> UnboundEntityDef -> Bool
lensPTH :: (s -> a) -> (s -> b -> t) -> Lens s t a b
sqlSettings :: MkPersistSettings
mkPersistSettings :: Type -> MkPersistSettings
setImplicitIdDef :: ImplicitIdDef -> MkPersistSettings -> MkPersistSettings
mkPersistWith :: MkPersistSettings -> [EntityDef] -> [UnboundEntityDef] -> Q [Dec]
mkPersist :: MkPersistSettings -> [UnboundEntityDef] -> Q [Dec]
parseReferences :: PersistSettings -> Text -> Q Exp
embedEntityDefs :: [EntityDef] -> [UnboundEntityDef] -> [UnboundEntityDef]
persistManyFileWith :: PersistSettings -> [FilePath] -> Q Exp
persistFileWith :: PersistSettings -> FilePath -> Q Exp
persistLowerCase :: QuasiQuoter
persistUpperCase :: QuasiQuoter
persistWith :: PersistSettings -> QuasiQuoter
data MkPersistSettings
data EntityJSON = EntityJSON {
- entityToJSON :: Name
- entityFromJSON :: Name
}
data ImplicitIdDef
limitOffsetOrder :: PersistEntity val => [SelectOpt val] -> (Int, Int, [SelectOpt val])
toJsonText :: ToJSON j => j -> Text
mapToJSON :: [(Text, PersistValue)] -> Text
listToJSON :: [PersistValue] -> Text
(||.) :: [Filter v] -> [Filter v] -> [Filter v]
(/<-.) :: forall v typ. PersistField typ => EntityField v typ -> [typ] -> Filter v
(<-.) :: forall v typ. PersistField typ => EntityField v typ -> [typ] -> Filter v
(>=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(>.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(<=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(<.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(!=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(==.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
(/=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
(*=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
(-=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
(+=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
(=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
type PersistUnique a = PersistUniqueWrite a
type PersistQuery a = PersistQueryWrite a
type PersistStore a = PersistStoreWrite a
selectKeysList :: forall record backend (m :: Type -> Type). (MonadIO m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m [Key record]
selectList :: forall record backend (m :: Type -> Type). (MonadIO m, PersistQueryRead backend, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m [Entity record]
selectKeys :: forall record backend (m :: Type -> Type). (PersistQueryRead backend, MonadResource m, PersistRecordBackend record backend, MonadReader backend m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Key record) m ()
selectSource :: forall record backend (m :: Type -> Type). (PersistQueryRead backend, MonadResource m, PersistRecordBackend record backend, MonadReader backend m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Entity record) m ()
class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend where
- selectSourceRes :: forall record (m1 :: Type -> Type) (m2 :: Type -> Type). (PersistRecordBackend record backend, MonadIO m1, MonadIO m2) => [Filter record] -> [SelectOpt record] -> ReaderT backend m1 (Acquire (ConduitM () (Entity record) m2 ()))
- selectFirst :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
- selectKeysRes :: forall (m1 :: Type -> Type) (m2 :: Type -> Type) record. (MonadIO m1, MonadIO m2, PersistRecordBackend record backend) => [Filter record] -> [SelectOpt record] -> ReaderT backend m1 (Acquire (ConduitM () (Key record) m2 ()))
- count :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> ReaderT backend m Int
- exists :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> ReaderT backend m Bool
class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend where
- updateWhere :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> [Update record] -> ReaderT backend m ()
- deleteWhere :: forall (m :: Type -> Type) record. (MonadIO m, PersistRecordBackend record backend) => [Filter record] -> ReaderT backend m ()
checkUniqueUpdateable :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueRead backend) => Entity record -> ReaderT backend m (Maybe (Unique record))
checkUnique :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueRead backend) => record -> ReaderT backend m (Maybe (Unique record))
replaceUnique :: forall record backend (m :: Type -> Type). (MonadIO m, Eq (Unique record), PersistRecordBackend record backend, PersistUniqueWrite backend) => Key record -> record -> ReaderT backend m (Maybe (Unique record))
getByValue :: forall record (m :: Type -> Type) backend. (MonadIO m, PersistUniqueRead backend, PersistRecordBackend record backend, AtLeastOneUniqueKey record) => record -> ReaderT backend m (Maybe (Entity record))
onlyUnique :: forall record backend (m :: Type -> Type). (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend, OnlyOneUniqueKey record) => record -> ReaderT backend m (Unique record)
insertUniqueEntity :: forall record backend (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, PersistUniqueWrite backend, SafeToInsert record) => record -> ReaderT backend m (Maybe (Entity record))
insertBy :: forall record backend (m :: Type -> Type). (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend record backend, AtLeastOneUniqueKey record, SafeToInsert record) => record -> ReaderT backend m (Either (Entity record) (Key record))
onlyOneUniqueDef :: (OnlyOneUniqueKey record, Monad proxy) => proxy record -> UniqueDef
class PersistStoreRead backend => PersistUniqueRead backend where
- getBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m (Maybe (Entity record))
- existsBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m Bool
class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend where
- deleteBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m ()
- insertUnique :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe (Key record))
- insertUnique_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe ())
- upsert :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, OnlyOneUniqueKey record, SafeToInsert record) => record -> [Update record] -> ReaderT backend m (Entity record)
- upsertBy :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => Unique record -> record -> [Update record] -> ReaderT backend m (Entity record)
- putMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m ()
class PersistEntity record => OnlyOneUniqueKey record where
- onlyUniqueP :: record -> Unique record
type NoUniqueKeysError ty = (('Text "The entity " :<>: 'ShowType ty) :<>: 'Text " does not have any unique keys.") :$$: ('Text "The function you are trying to call requires a unique key " :<>: 'Text "to be defined on the entity.")
type MultipleUniqueKeysError ty = ((('Text "The entity " :<>: 'ShowType ty) :<>: 'Text " has multiple unique keys.") :$$: ('Text "The function you are trying to call requires only a single " :<>: 'Text "unique key.")) :$$: (('Text "There is probably a variant of the function with 'By' " :<>: 'Text "appended that will allow you to select a unique key ") :<>: 'Text "for the operation.")
class PersistEntity record => AtLeastOneUniqueKey record where
- requireUniquesP :: record -> NonEmpty (Unique record)
insertRecord :: forall record backend (m :: Type -> Type). (PersistEntityBackend record ~ BaseBackend backend, PersistEntity record, MonadIO m, PersistStoreWrite backend, SafeToInsert record, HasCallStack) => record -> ReaderT backend m record
getEntity :: forall e backend (m :: Type -> Type). (PersistStoreRead backend, PersistRecordBackend e backend, MonadIO m) => Key e -> ReaderT backend m (Maybe (Entity e))
insertEntity :: forall e backend (m :: Type -> Type). (PersistStoreWrite backend, PersistRecordBackend e backend, SafeToInsert e, MonadIO m, HasCallStack) => e -> ReaderT backend m (Entity e)
belongsToJust :: forall ent1 ent2 backend (m :: Type -> Type). (PersistStoreRead backend, PersistEntity ent1, PersistRecordBackend ent2 backend, MonadIO m) => (ent1 -> Key ent2) -> ent1 -> ReaderT backend m ent2
belongsTo :: forall ent1 ent2 backend (m :: Type -> Type). (PersistStoreRead backend, PersistEntity ent1, PersistRecordBackend ent2 backend, MonadIO m) => (ent1 -> Maybe (Key ent2)) -> ent1 -> ReaderT backend m (Maybe ent2)
getJustEntity :: forall record backend (m :: Type -> Type). (PersistEntityBackend record ~ BaseBackend backend, MonadIO m, PersistEntity record, PersistStoreRead backend) => Key record -> ReaderT backend m (Entity record)
getJust :: forall record backend (m :: Type -> Type). (PersistStoreRead backend, PersistRecordBackend record backend, MonadIO m) => Key record -> ReaderT backend m record
liftPersist :: (MonadIO m, MonadReader backend m) => ReaderT backend IO b -> m b
withCompatibleBackend :: forall sup sub (m :: Type -> Type) a. BackendCompatible sup sub => ReaderT sup m a -> ReaderT sub m a
withBaseBackend :: forall backend (m :: Type -> Type) a. HasPersistBackend backend => ReaderT (BaseBackend backend) m a -> ReaderT backend m a
type family BaseBackend backend
class HasPersistBackend backend where
- type BaseBackend backend
- persistBackend :: backend -> BaseBackend backend
class HasPersistBackend backend => IsPersistBackend backend
class BackendCompatible sup sub where
- projectBackend :: sub -> sup
type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend)
class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record where
- toBackendKey :: Key record -> BackendKey backend
- fromBackendKey :: BackendKey backend -> Key record
data family BackendKey backend
class PersistCore backend where
- data BackendKey backend
class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistCore backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreRead backend where
- get :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> ReaderT backend m (Maybe record)
- getMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => [Key record] -> ReaderT backend m (Map (Key record) record)
class (Show (BackendKey backend), Read (BackendKey backend), Eq (BackendKey backend), Ord (BackendKey backend), PersistStoreRead backend, PersistField (BackendKey backend), ToJSON (BackendKey backend), FromJSON (BackendKey backend)) => PersistStoreWrite backend where
- insert :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Key record)
- insert_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m ()
- insertMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m [Key record]
- insertMany_ :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => [record] -> ReaderT backend m ()
- insertEntityMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => [Entity record] -> ReaderT backend m ()
- insertKey :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m ()
- repsert :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m ()
- repsertMany :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => [(Key record, record)] -> ReaderT backend m ()
- replace :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> record -> ReaderT backend m ()
- delete :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> ReaderT backend m ()
- update :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT backend m ()
- updateGet :: forall record (m :: Type -> Type). (MonadIO m, PersistRecordBackend record backend) => Key record -> [Update record] -> ReaderT backend m record
fromPersistValueJSON :: FromJSON a => PersistValue -> Either Text a
toPersistValueJSON :: ToJSON a => a -> PersistValue
entityIdFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)
entityIdToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value
keyValueEntityFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)
keyValueEntityToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value
entityValues :: PersistEntity record => Entity record -> [PersistValue]
tabulateEntity :: PersistEntity record => (forall a. EntityField record a -> a) -> Entity record
data family Unique record
data family EntityField record :: Type -> Type
data family Key record
type family PersistEntityBackend record
class (PersistField (Key record), ToJSON (Key record), FromJSON (Key record), Show (Key record), Read (Key record), Eq (Key record), Ord (Key record)) => PersistEntity record where
- type PersistEntityBackend record
- data Key record
- data EntityField record :: Type -> Type
- data Unique record
- keyToValues :: Key record -> [PersistValue]
- keyFromValues :: [PersistValue] -> Either Text (Key record)
- persistIdField :: EntityField record (Key record)
- entityDef :: proxy record -> EntityDef
- persistFieldDef :: EntityField record typ -> FieldDef
- toPersistFields :: record -> [PersistValue]
- fromPersistValues :: [PersistValue] -> Either Text record
- tabulateEntityA :: Applicative f => (forall a. EntityField record a -> f a) -> f (Entity record)
- persistUniqueKeys :: record -> [Unique record]
- persistUniqueToFieldNames :: Unique record -> NonEmpty (FieldNameHS, FieldNameDB)
- persistUniqueToValues :: Unique record -> [PersistValue]
- fieldLens :: EntityField record field -> forall (f :: Type -> Type). Functor f => (field -> f field) -> Entity record -> f (Entity record)
- keyFromRecordM :: Maybe (record -> Key record)
type family BackendSpecificUpdate backend record
data Update record
- = PersistField typ => Update {
  - updateField :: EntityField record typ
  - updateValue :: typ
  - updateUpdate :: PersistUpdate
  }
- | BackendUpdate (BackendSpecificUpdate (PersistEntityBackend record) record)
data SelectOpt record
- = Asc (EntityField record typ)
- | Desc (EntityField record typ)
- | OffsetBy Int
- | LimitTo Int
type family BackendSpecificFilter backend record
data Filter record
- = PersistField typ => Filter {
  - filterField :: EntityField record typ
  - filterValue :: FilterValue typ
  - filterFilter :: PersistFilter
  }
- | FilterAnd [Filter record]
- | FilterOr [Filter record]
- | BackendFilter (BackendSpecificFilter (PersistEntityBackend record) record)
data FilterValue typ where
- FilterValue :: forall typ. typ -> FilterValue typ
- FilterValues :: forall typ. [typ] -> FilterValue typ
- UnsafeValue :: forall a typ. PersistField a => a -> FilterValue typ
data Entity record = Entity {
- entityKey :: Key record
- entityVal :: record
}
class SymbolToField (sym :: Symbol) rec typ | sym rec -> typ where
- symbolToField :: EntityField rec typ
class SafeToInsert a
getPersistMap :: PersistValue -> Either Text [(Text, PersistValue)]
class PersistField a where
- toPersistValue :: a -> PersistValue
- fromPersistValue :: PersistValue -> Either Text a
newtype OverflowNatural = OverflowNatural {
- unOverflowNatural :: Natural
}
overEntityFields :: ([FieldDef] -> [FieldDef]) -> EntityDef -> EntityDef
getEntityKeyFields :: EntityDef -> NonEmpty FieldDef
setEntityIdDef :: EntityIdDef -> EntityDef -> EntityDef
setEntityId :: FieldDef -> EntityDef -> EntityDef
getEntityIdField :: EntityDef -> Maybe FieldDef
getEntityId :: EntityDef -> EntityIdDef
isEntitySum :: EntityDef -> Bool
getEntityFieldsDatabase :: EntityDef -> [FieldDef]
getEntityFields :: EntityDef -> [FieldDef]
getEntityForeignDefs :: EntityDef -> [ForeignDef]
getEntityComments :: EntityDef -> Maybe Text
setEntityDBName :: EntityNameDB -> EntityDef -> EntityDef
getEntityExtra :: EntityDef -> Map Text [[Text]]
getEntityDBName :: EntityDef -> EntityNameDB
getEntityHaskellName :: EntityDef -> EntityNameHS
getEntityUniques :: EntityDef -> [UniqueDef]
getEntityUniquesNoPrimaryKey :: EntityDef -> [UniqueDef]
isFieldMaybe :: FieldDef -> Bool
isFieldNullable :: FieldDef -> IsNullable
addFieldAttr :: FieldAttr -> FieldDef -> FieldDef
overFieldAttrs :: ([FieldAttr] -> [FieldAttr]) -> FieldDef -> FieldDef
setFieldAttrs :: [FieldAttr] -> FieldDef -> FieldDef
renderCascadeAction :: CascadeAction -> Text
renderFieldCascade :: FieldCascade -> Text
noCascade :: FieldCascade
isHaskellField :: FieldDef -> Bool
isFieldNotGenerated :: FieldDef -> Bool
parseFieldAttrs :: [Text] -> [FieldAttr]
keyAndEntityFields :: EntityDef -> NonEmpty FieldDef
entityPrimary :: EntityDef -> Maybe CompositeDef
entitiesPrimary :: EntityDef -> NonEmpty FieldDef
fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable
data Checkmark
- = Active
- | Inactive
data IsNullable
- = Nullable !WhyNullable
- | NotNullable
data WhyNullable
- = ByMaybeAttr
- | ByNullableAttr
data EntityDef
data EntityIdDef
- = EntityIdField !FieldDef
- | EntityIdNaturalKey !CompositeDef
type ExtraLine = [Text]
type Attr = Text
data FieldAttr
- = FieldAttrMaybe
- | FieldAttrNullable
- | FieldAttrMigrationOnly
- | FieldAttrSafeToRemove
- | FieldAttrNoreference
- | FieldAttrReference Text
- | FieldAttrConstraint Text
- | FieldAttrDefault Text
- | FieldAttrSqltype Text
- | FieldAttrMaxlen Integer
- | FieldAttrSql Text
- | FieldAttrOther Text
data FieldType
- = FTTypeCon (Maybe Text) Text
- | FTLit FieldTypeLit
- | FTTypePromoted Text
- | FTApp FieldType FieldType
- | FTList FieldType
data ReferenceDef
- = NoReference
- | ForeignRef !EntityNameHS
- | EmbedRef EntityNameHS
- | SelfReference
data EmbedEntityDef = EmbedEntityDef {
- embeddedHaskell :: EntityNameHS
- embeddedFields :: [EmbedFieldDef]
}
data EmbedFieldDef = EmbedFieldDef {
- emFieldDB :: FieldNameDB
- emFieldEmbed :: Maybe (Either SelfEmbed EntityNameHS)
}
data UniqueDef = UniqueDef {
- uniqueHaskell :: !ConstraintNameHS
- uniqueDBName :: !ConstraintNameDB
- uniqueFields :: !(NonEmpty (FieldNameHS, FieldNameDB))
- uniqueAttrs :: ![Attr]
}
data CompositeDef = CompositeDef {
- compositeFields :: !(NonEmpty FieldDef)
- compositeAttrs :: ![Attr]
}
type ForeignFieldDef = (FieldNameHS, FieldNameDB)
data ForeignDef = ForeignDef {
- foreignRefTableHaskell :: !EntityNameHS
- foreignRefTableDBName :: !EntityNameDB
- foreignConstraintNameHaskell :: !ConstraintNameHS
- foreignConstraintNameDBName :: !ConstraintNameDB
- foreignFieldCascade :: !FieldCascade
- foreignFields :: ![(ForeignFieldDef, ForeignFieldDef)]
- foreignAttrs :: ![Attr]
- foreignNullable :: Bool
- foreignToPrimary :: Bool
}
data FieldCascade = FieldCascade {
- fcOnUpdate :: !(Maybe CascadeAction)
- fcOnDelete :: !(Maybe CascadeAction)
}
data CascadeAction
- = Cascade
- | Restrict
- | SetNull
- | SetDefault
data PersistException
- = PersistError Text
- | PersistMarshalError Text
- | PersistInvalidField Text
- | PersistForeignConstraintUnmet Text
- | PersistMongoDBError Text
- | PersistMongoDBUnsupported Text
data SqlType
- = SqlString
- | SqlInt32
- | SqlInt64
- | SqlReal
- | SqlNumeric Word32 Word32
- | SqlBool
- | SqlDay
- | SqlTime
- | SqlDayTime
- | SqlBlob
- | SqlOther Text
data PersistFilter
- = Eq
- | Ne
- | Gt
- | Lt
- | Ge
- | Le
- | In
- | NotIn
- | BackendSpecificFilter Text
data UpdateException
- = KeyNotFound String
- | UpsertError String
data PersistUpdate
- = Assign
- | Add
- | Subtract
- | Multiply
- | Divide
- | BackendSpecificUpdate Text
data FieldDef = FieldDef {
- fieldHaskell :: !FieldNameHS
- fieldDB :: !FieldNameDB
- fieldType :: !FieldType
- fieldSqlType :: !SqlType
- fieldAttrs :: ![FieldAttr]
- fieldStrict :: !Bool
- fieldReference :: !ReferenceDef
- fieldCascade :: !FieldCascade
- fieldComments :: !(Maybe Text)
- fieldGenerated :: !(Maybe Text)
- fieldIsImplicitIdColumn :: !Bool
}
fromPersistValueText :: PersistValue -> Either Text Text
data PersistValue where
- PersistText Text
- PersistByteString ByteString
- PersistInt64 Int64
- PersistDouble Double
- PersistRational Rational
- PersistBool Bool
- PersistDay Day
- PersistTimeOfDay TimeOfDay
- PersistUTCTime UTCTime
- PersistNull
- PersistList [PersistValue]
- PersistMap [(Text, PersistValue)]
- PersistObjectId ByteString
- PersistArray [PersistValue]
- PersistLiteral_ LiteralType ByteString
- pattern PersistDbSpecific :: ByteString -> PersistValue
- pattern PersistLiteralEscaped :: ByteString -> PersistValue
- pattern PersistLiteral :: ByteString -> PersistValue
data LiteralType
- = Escaped
- | Unescaped
- | DbSpecific
class DatabaseName a where
- escapeWith :: (Text -> str) -> a -> str
newtype FieldNameDB = FieldNameDB {
- unFieldNameDB :: Text
}
newtype FieldNameHS = FieldNameHS {
- unFieldNameHS :: Text
}
newtype EntityNameHS = EntityNameHS {
- unEntityNameHS :: Text
}
newtype EntityNameDB = EntityNameDB {
- unEntityNameDB :: Text
}
newtype ConstraintNameDB = ConstraintNameDB {
- unConstraintNameDB :: Text
}
newtype ConstraintNameHS = ConstraintNameHS {
- unConstraintNameHS :: Text
}
type family PersistConfigPool c
type family PersistConfigBackend c :: (Type -> Type) -> Type -> Type
class PersistConfig c where
- type PersistConfigBackend c :: (Type -> Type) -> Type -> Type
- type PersistConfigPool c
- loadConfig :: Value -> Parser c
- applyEnv :: c -> IO c
- createPoolConfig :: c -> IO (PersistConfigPool c)
- runPool :: MonadUnliftIO m => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a
mkMessageVariant :: String -> String -> FilePath -> Lang -> Q [Dec]
mkMessageFor :: String -> String -> FilePath -> Lang -> Q [Dec]
mkMessage :: String -> FilePath -> Lang -> Q [Dec]
class ToMessage a where
- toMessage :: a -> Text
class RenderMessage master message where
- renderMessage :: master -> [Lang] -> message -> Text
type Lang = Text
data SomeMessage master = RenderMessage master msg => SomeMessage msg
cassius :: QuasiQuoter
xhamlet :: QuasiQuoter
hamlet :: QuasiQuoter
shamlet :: QuasiQuoter
type HtmlUrl url = Render url -> Html
lucius :: QuasiQuoter
renderCssUrl :: (url -> [(Text, Text)] -> Text) -> CssUrl url -> Text
type CssUrl url = (url -> [(Text, Text)] -> Text) -> Css
julius :: QuasiQuoter
renderJavascriptUrl :: (url -> [(Text, Text)] -> Text) -> JavascriptUrl url -> Text
type JavascriptUrl url = (url -> [(Text, Text)] -> Text) -> Javascript
type Application = Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived
newtype DBRunner site = DBRunner {
- runDBRunner :: forall a. YesodDB site a -> HandlerFor site a
}
class YesodPersist site => YesodPersistRunner site where
- getDBRunner :: HandlerFor site (DBRunner site, HandlerFor site ())
class Monad (YesodDB site) => YesodPersist site where
- type YesodPersistBackend site
- runDB :: YesodDB site a -> HandlerFor site a
type family YesodPersistBackend site
type YesodDB site = ReaderT (YesodPersistBackend site) (HandlerFor site)
defaultRunDB :: PersistConfig c => (site -> c) -> (site -> PersistConfigPool c) -> PersistConfigBackend c (HandlerFor site) a -> HandlerFor site a
defaultGetDBRunner :: (IsSqlBackend backend, YesodPersistBackend site ~ backend) => (site -> Pool backend) -> HandlerFor site (DBRunner site, HandlerFor site ())
runDBSource :: YesodPersistRunner site => ConduitT () a (YesodDB site) () -> ConduitT () a (HandlerFor site) ()
respondSourceDB :: YesodPersistRunner site => ContentType -> ConduitT () (Flush Builder) (YesodDB site) () -> HandlerFor site TypedContent
get404 :: forall (m :: Type -> Type) backend val. (MonadIO m, PersistStoreRead backend, PersistRecordBackend val backend) => Key val -> ReaderT backend m val
getBy404 :: forall backend val (m :: Type -> Type). (PersistUniqueRead backend, PersistRecordBackend val backend, MonadIO m) => Unique val -> ReaderT backend m (Entity val)
insert400 :: forall (m :: Type -> Type) backend val. (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend val backend, SafeToInsert val) => val -> ReaderT backend m (Key val)
insert400_ :: forall (m :: Type -> Type) backend val. (MonadIO m, PersistUniqueWrite backend, PersistRecordBackend val backend, SafeToInsert val) => val -> ReaderT backend m ()
data FormMessage
- = MsgInvalidInteger Text
- | MsgInvalidNumber Text
- | MsgInvalidEntry Text
- | MsgInvalidUrl Text
- | MsgInvalidEmail Text
- | MsgInvalidTimeFormat
- | MsgInvalidHour Text
- | MsgInvalidMinute Text
- | MsgInvalidSecond Text
- | MsgInvalidDay
- | MsgCsrfWarning
- | MsgValueRequired
- | MsgInputNotFound Text
- | MsgSelectNone
- | MsgInvalidBool Text
- | MsgBoolYes
- | MsgBoolNo
- | MsgDelete
- | MsgInvalidHexColorFormat Text
data Field (m :: Type -> Type) a = Field {
- fieldParse :: [Text] -> [FileInfo] -> m (Either (SomeMessage (HandlerSite m)) (Maybe a))
- fieldView :: FieldViewFunc m a
- fieldEnctype :: Enctype
}
type FieldViewFunc (m :: Type -> Type) a = Text -> Text -> [(Text, Text)] -> Either Text a -> Bool -> WidgetFor (HandlerSite m) ()
data FieldView site = FieldView {
- fvLabel :: Markup
- fvTooltip :: Maybe Markup
- fvId :: Text
- fvInput :: WidgetFor site ()
- fvErrors :: Maybe Markup
- fvRequired :: Bool
}
data FieldSettings master = FieldSettings {
- fsLabel :: SomeMessage master
- fsTooltip :: Maybe (SomeMessage master)
- fsId :: Maybe Text
- fsName :: Maybe Text
- fsAttrs :: [(Text, Text)]
}
newtype AForm (m :: Type -> Type) a = AForm {
- unAForm :: (HandlerSite m, [Text]) -> Maybe (Env, FileEnv) -> Ints -> m (FormResult a, [FieldView (HandlerSite m)] -> [FieldView (HandlerSite m)], Ints, Enctype)
}
type MForm (m :: Type -> Type) a = RWST (Maybe (Env, FileEnv), HandlerSite m, [Lang]) Enctype Ints m a
type WForm (m :: Type -> Type) a = MForm (WriterT [FieldView (HandlerSite m)] m) a
type FileEnv = Map Text [FileInfo]
type Env = Map Text [Text]
data Ints
- = IntCons Int Ints
- | IntSingle Int
data Enctype
- = UrlEncoded
- | Multipart
data FormResult a
- = FormMissing
- | FormFailure [Text]
- | FormSuccess a
newtype FormInput (m :: Type -> Type) a = FormInput {
- unFormInput :: HandlerSite m -> [Text] -> Env -> FileEnv -> m (Either DText a)
}
ireq :: forall (m :: Type -> Type) a. (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m a -> Text -> FormInput m a
iopt :: forall (m :: Type -> Type) a. Monad m => Field m a -> Text -> FormInput m (Maybe a)
runInputGet :: MonadHandler m => FormInput m a -> m a
runInputGetResult :: MonadHandler m => FormInput m a -> m (FormResult a)
runInputPost :: MonadHandler m => FormInput m a -> m a
runInputPostResult :: MonadHandler m => FormInput m a -> m (FormResult a)
type FormRender (m :: Type -> Type) a = AForm m a -> Markup -> MForm m (FormResult a, WidgetFor (HandlerSite m) ())
newFormIdent :: forall (m :: Type -> Type). Monad m => MForm m Text
formToAForm :: forall (m :: Type -> Type) site a. (HandlerSite m ~ site, Monad m) => MForm m (FormResult a, [FieldView site]) -> AForm m a
aFormToForm :: forall (m :: Type -> Type) site a. (Monad m, HandlerSite m ~ site) => AForm m a -> MForm m (FormResult a, [FieldView site] -> [FieldView site])
askParams :: forall (m :: Type -> Type). Monad m => MForm m (Maybe Env)
askFiles :: forall (m :: Type -> Type). Monad m => MForm m (Maybe FileEnv)
wreq :: forall site (m :: Type -> Type) a. (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m) => Field m a -> FieldSettings site -> Maybe a -> WForm m (FormResult a)
wreqMsg :: forall site msg (m :: Type -> Type) a. (RenderMessage site msg, HandlerSite m ~ site, MonadHandler m) => Field m a -> FieldSettings site -> msg -> Maybe a -> WForm m (FormResult a)
wopt :: forall (m :: Type -> Type) site a. (MonadHandler m, HandlerSite m ~ site) => Field m a -> FieldSettings site -> Maybe (Maybe a) -> WForm m (FormResult (Maybe a))
wFormToAForm :: forall (m :: Type -> Type) a. MonadHandler m => WForm m (FormResult a) -> AForm m a
wFormToMForm :: forall (m :: Type -> Type) site a. (MonadHandler m, HandlerSite m ~ site) => WForm m a -> MForm m (a, [FieldView site])
mFormToWForm :: forall (m :: Type -> Type) site a. (MonadHandler m, HandlerSite m ~ site) => MForm m (a, FieldView site) -> WForm m a
mreq :: forall site (m :: Type -> Type) a. (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m) => Field m a -> FieldSettings site -> Maybe a -> MForm m (FormResult a, FieldView site)
mreqMsg :: forall site msg (m :: Type -> Type) a. (RenderMessage site msg, HandlerSite m ~ site, MonadHandler m) => Field m a -> FieldSettings site -> msg -> Maybe a -> MForm m (FormResult a, FieldView site)
mopt :: forall site (m :: Type -> Type) a. (site ~ HandlerSite m, MonadHandler m) => Field m a -> FieldSettings site -> Maybe (Maybe a) -> MForm m (FormResult (Maybe a), FieldView site)
areq :: forall site (m :: Type -> Type) a. (RenderMessage site FormMessage, HandlerSite m ~ site, MonadHandler m) => Field m a -> FieldSettings site -> Maybe a -> AForm m a
areqMsg :: forall site msg (m :: Type -> Type) a. (RenderMessage site msg, HandlerSite m ~ site, MonadHandler m) => Field m a -> FieldSettings site -> msg -> Maybe a -> AForm m a
aopt :: forall (m :: Type -> Type) a. MonadHandler m => Field m a -> FieldSettings (HandlerSite m) -> Maybe (Maybe a) -> AForm m (Maybe a)
runFormPost :: (RenderMessage (HandlerSite m) FormMessage, MonadResource m, MonadHandler m) => (Markup -> MForm m (FormResult a, xml)) -> m ((FormResult a, xml), Enctype)
generateFormPost :: (RenderMessage (HandlerSite m) FormMessage, MonadHandler m) => (Markup -> MForm m (FormResult a, xml)) -> m (xml, Enctype)
runFormPostNoToken :: MonadHandler m => (Markup -> MForm m a) -> m (a, Enctype)
runFormGet :: MonadHandler m => (Markup -> MForm m a) -> m (a, Enctype)
generateFormGet' :: MonadHandler m => (Markup -> MForm m (FormResult a, xml)) -> m (xml, Enctype)
generateFormGet :: MonadHandler m => (Markup -> MForm m a) -> m (a, Enctype)
identifyForm :: forall (m :: Type -> Type) a. Monad m => Text -> (Markup -> MForm m (FormResult a, WidgetFor (HandlerSite m) ())) -> Markup -> MForm m (FormResult a, WidgetFor (HandlerSite m) ())
renderTable :: forall (m :: Type -> Type) a. Monad m => FormRender m a
renderDivs :: forall (m :: Type -> Type) a. Monad m => FormRender m a
renderDivsNoLabels :: forall (m :: Type -> Type) a. Monad m => FormRender m a
renderBootstrap2 :: forall (m :: Type -> Type) a. Monad m => FormRender m a
renderBootstrap :: forall (m :: Type -> Type) a. Monad m => FormRender m a
check :: forall (m :: Type -> Type) msg a. (Monad m, RenderMessage (HandlerSite m) msg) => (a -> Either msg a) -> Field m a -> Field m a
checkBool :: forall (m :: Type -> Type) msg a. (Monad m, RenderMessage (HandlerSite m) msg) => (a -> Bool) -> msg -> Field m a -> Field m a
checkM :: (Monad m, RenderMessage (HandlerSite m) msg) => (a -> m (Either msg a)) -> Field m a -> Field m a
checkMMap :: (Monad m, RenderMessage (HandlerSite m) msg) => (a -> m (Either msg b)) -> (b -> a) -> Field m a -> Field m b
customErrorMessage :: forall (m :: Type -> Type) a. Monad m => SomeMessage (HandlerSite m) -> Field m a -> Field m a
fieldSettingsLabel :: RenderMessage site msg => msg -> FieldSettings site
parseHelper :: (Monad m, RenderMessage site FormMessage) => (Text -> Either FormMessage a) -> [Text] -> [FileInfo] -> m (Either (SomeMessage site) (Maybe a))
parseHelperGen :: (Monad m, RenderMessage site msg) => (Text -> Either msg a) -> [Text] -> [FileInfo] -> m (Either (SomeMessage site) (Maybe a))
convertField :: forall (m :: Type -> Type) a b. Functor m => (a -> b) -> (b -> a) -> Field m a -> Field m b
removeClass :: Text -> [(Text, Text)] -> [(Text, Text)]
addClass :: Text -> [(Text, Text)] -> [(Text, Text)]
data Option a = Option {
- optionDisplay :: Text
- optionInternalValue :: a
- optionExternalValue :: Text
}
data OptionList a
- = OptionList {
  - olOptions :: [Option a]
  - olReadExternal :: Text -> Maybe a
  }
- | OptionListGrouped {
  - olOptionsGrouped :: [(Text, [Option a])]
  - olReadExternalGrouped :: Text -> Maybe a
  }
type AutoFocus = Bool
newtype Textarea = Textarea {
- unTextarea :: Text
}
defaultFormMessage :: FormMessage -> Text
intField :: forall (m :: Type -> Type) i. (Monad m, Integral i, RenderMessage (HandlerSite m) FormMessage) => Field m i
doubleField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Double
dayField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Day
timeField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m TimeOfDay
timeFieldTypeTime :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m TimeOfDay
timeFieldTypeText :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m TimeOfDay
htmlField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Html
textareaField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Textarea
hiddenField :: forall (m :: Type -> Type) p. (Monad m, PathPiece p, RenderMessage (HandlerSite m) FormMessage) => Field m p
textField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text
passwordField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text
parseDate :: String -> Either FormMessage Day
emailField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text
multiEmailField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m [Text]
searchField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => AutoFocus -> Field m Text
urlField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text
selectFieldList :: (Eq a, RenderMessage site FormMessage, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) a
selectFieldListGrouped :: (Eq a, RenderMessage site FormMessage, RenderMessage site msg) => [(msg, [(msg, a)])] -> Field (HandlerFor site) a
selectField :: (Eq a, RenderMessage site FormMessage) => HandlerFor site (OptionList a) -> Field (HandlerFor site) a
multiSelectFieldList :: (Eq a, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) [a]
multiSelectField :: Eq a => HandlerFor site (OptionList a) -> Field (HandlerFor site) [a]
radioFieldList :: (Eq a, RenderMessage site FormMessage, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) a
checkboxesFieldList :: (Eq a, RenderMessage site msg) => [(msg, a)] -> Field (HandlerFor site) [a]
checkboxesField :: Eq a => HandlerFor site (OptionList a) -> Field (HandlerFor site) [a]
radioField :: (Eq a, RenderMessage site FormMessage) => HandlerFor site (OptionList a) -> Field (HandlerFor site) a
withRadioField :: (Eq a, RenderMessage site FormMessage) => (Text -> WidgetFor site () -> WidgetFor site ()) -> (Text -> Text -> Bool -> Text -> WidgetFor site () -> WidgetFor site ()) -> HandlerFor site (OptionList a) -> Field (HandlerFor site) a
boolField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Bool
checkBoxField :: forall (m :: Type -> Type). Monad m => Field m Bool
mkOptionList :: [Option a] -> OptionList a
mkOptionListGrouped :: [(Text, [Option a])] -> OptionList a
optionsPairs :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => [(msg, a)] -> m (OptionList a)
optionsPairsGrouped :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => [(msg, [(msg, a)])] -> m (OptionList a)
optionsEnum :: (MonadHandler m, Show a, Enum a, Bounded a) => m (OptionList a)
optionsPersist :: (YesodPersist site, PersistQueryRead backend, PathPiece (Key a), RenderMessage site msg, YesodPersistBackend site ~ backend, PersistRecordBackend a backend) => [Filter a] -> [SelectOpt a] -> (a -> msg) -> HandlerFor site (OptionList (Entity a))
optionsPersistKey :: (YesodPersist site, PersistQueryRead backend, PathPiece (Key a), RenderMessage site msg, backend ~ YesodPersistBackend site, PersistRecordBackend a backend) => [Filter a] -> [SelectOpt a] -> (a -> msg) -> HandlerFor site (OptionList (Key a))
selectFieldHelper :: (Eq a, RenderMessage site FormMessage) => (Text -> Text -> [(Text, Text)] -> WidgetFor site () -> WidgetFor site ()) -> (Text -> Text -> Bool -> WidgetFor site ()) -> (Text -> Text -> [(Text, Text)] -> Text -> Bool -> Text -> WidgetFor site ()) -> Maybe (Text -> WidgetFor site ()) -> HandlerFor site (OptionList a) -> Field (HandlerFor site) a
fileField :: forall (m :: Type -> Type). Monad m => Field m FileInfo
fileAFormReq :: forall (m :: Type -> Type). (MonadHandler m, RenderMessage (HandlerSite m) FormMessage) => FieldSettings (HandlerSite m) -> AForm m FileInfo
fileAFormOpt :: forall (m :: Type -> Type). MonadHandler m => FieldSettings (HandlerSite m) -> AForm m (Maybe FileInfo)
colorField :: forall (m :: Type -> Type). (Monad m, RenderMessage (HandlerSite m) FormMessage) => Field m Text
formatW3 :: UTCTime -> Text
formatRFC1123 :: UTCTime -> Text
formatRFC822 :: UTCTime -> Text
class RenderRoute a => RouteAttrs a where
- routeAttrs :: Route a -> Set Text
class RenderRoute a => ParseRoute a where
- parseRoute :: ([Text], [(Text, Text)]) -> Maybe (Route a)
class Eq (Route a) => RenderRoute a where
- renderRoute :: Route a -> ([Text], [(Text, Text)])
data family Route a
data SubHandlerFor sub master a
data Header
- = AddCookie !SetCookie
- | DeleteCookie !ByteString !ByteString
- | Header !(CI ByteString) !ByteString
data ErrorResponse
- = NotFound
- | InternalError !Text
- | InvalidArgs ![Text]
- | NotAuthenticated
- | PermissionDenied !Text
- | BadMethod !Method
newtype DontFullyEvaluate a = DontFullyEvaluate {
- unDontFullyEvaluate :: a
}
type ContentType = ByteString
newtype RepXml = RepXml Content
newtype RepPlain = RepPlain Content
newtype RepJson = RepJson Content
type RepHtml = Html
data TypedContent = TypedContent !ContentType !Content
data Content
- = ContentBuilder !Builder !(Maybe Int)
- | ContentSource !(ConduitT () (Flush Builder) (ResourceT IO) ())
- | ContentFile !FilePath !(Maybe FilePart)
- | ContentDontEvaluate !Content
data PageContent url = PageContent {
- pageTitle :: !Html
- pageDescription :: !(Maybe Text)
- pageHead :: !(HtmlUrl url)
- pageBody :: !(HtmlUrl url)
}
newtype CssBuilder = CssBuilder {
- unCssBuilder :: Builder
}
data WidgetFor site a
data HandlerFor site a
newtype WaiSubsiteWithAuth = WaiSubsiteWithAuth {
- runWaiSubsiteWithAuth :: Application
}
newtype WaiSubsite = WaiSubsite {
- runWaiSubsite :: Application
}
type Texts = [Text]
type BottomOfHeadAsync master = [Text] -> Maybe (HtmlUrl (Route master)) -> HtmlUrl (Route master)
data ScriptLoadPosition master
- = BottomOfBody
- | BottomOfHeadBlocking
- | BottomOfHeadAsync !(BottomOfHeadAsync master)
data AuthResult
- = Authorized
- | AuthenticationRequired
- | Unauthorized !Text
data Approot master
- = ApprootRelative
- | ApprootStatic !Text
- | ApprootMaster !(master -> Text)
- | ApprootRequest !(master -> Request -> Text)
data FileUpload
- = FileUploadMemory !(BackEnd ByteString)
- | FileUploadDisk !(InternalState -> BackEnd FilePath)
- | FileUploadSource !(BackEnd (ConduitT () ByteString (ResourceT IO) ()))
data FileInfo
type RequestBodyContents = ([(Text, Text)], [(Text, FileInfo)])
data YesodRequest = YesodRequest {
- reqGetParams :: ![(Text, Text)]
- reqCookies :: ![(Text, Text)]
- reqWaiRequest :: !Request
- reqLangs :: ![Text]
- reqToken :: !(Maybe Text)
- reqSession :: !SessionMap
- reqAccept :: ![ContentType]
}
newtype SessionBackend = SessionBackend {
- sbLoadSession :: Request -> IO (SessionMap, SaveSession)
}
type SessionMap = Map Text ByteString
clientSessionDateCacher :: NominalDiffTime -> IO (IO ClientSessionDateCache, IO ())
class ToContent a => ToTypedContent a where
- toTypedContent :: a -> TypedContent
class ToTypedContent a => HasContentType a where
- getContentType :: Monad m => m a -> ContentType
class ToFlushBuilder a where
- toFlushBuilder :: a -> Flush Builder
class ToContent a where
- toContent :: a -> Content
emptyContent :: Content
repJson :: ToContent a => a -> RepJson
repPlain :: ToContent a => a -> RepPlain
repXml :: ToContent a => a -> RepXml
typeHtml :: ContentType
typePlain :: ContentType
typeJson :: ContentType
typeXml :: ContentType
typeAtom :: ContentType
typeRss :: ContentType
typeJpeg :: ContentType
typePng :: ContentType
typeGif :: ContentType
typeSvg :: ContentType
typeJavascript :: ContentType
typeCss :: ContentType
typeFlv :: ContentType
typeOgv :: ContentType
typeOctet :: ContentType
simpleContentType :: ContentType -> ContentType
contentTypeTypes :: ContentType -> (ByteString, ByteString)
class MonadHandler m => MonadWidget (m :: Type -> Type) where
- liftWidget :: WidgetFor (HandlerSite m) a -> m a
class (MonadResource m, MonadLogger m) => MonadHandler (m :: Type -> Type) where
- type HandlerSite (m :: Type -> Type)
- type SubHandlerSite (m :: Type -> Type)
- liftHandler :: HandlerFor (HandlerSite m) a -> m a
- liftSubHandler :: SubHandlerFor (SubHandlerSite m) (HandlerSite m) a -> m a
type family HandlerSite (m :: Type -> Type)
type family SubHandlerSite (m :: Type -> Type)
data ProvidedRep (m :: Type -> Type)
data Fragment a b = a :#: b
class RedirectUrl master a where
- toTextUrl :: (MonadHandler m, HandlerSite m ~ master) => a -> m Text
type HandlerT site (m :: Type -> Type) = HandlerFor site
getRequest :: MonadHandler m => m YesodRequest
runRequestBody :: MonadHandler m => m RequestBodyContents
getYesod :: MonadHandler m => m (HandlerSite m)
getsYesod :: MonadHandler m => (HandlerSite m -> a) -> m a
getUrlRender :: MonadHandler m => m (Route (HandlerSite m) -> Text)
getUrlRenderParams :: MonadHandler m => m (Route (HandlerSite m) -> [(Text, Text)] -> Text)
getPostParams :: MonadHandler m => m [(Text, Text)]
getCurrentRoute :: MonadHandler m => m (Maybe (Route (HandlerSite m)))
handlerToIO :: MonadIO m => HandlerFor site (HandlerFor site a -> m a)
forkHandler :: (SomeException -> HandlerFor site ()) -> HandlerFor site () -> HandlerFor site ()
redirect :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => url -> m a
redirectWith :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => Status -> url -> m a
setUltDest :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => url -> m ()
setUltDestCurrent :: MonadHandler m => m ()
setUltDestReferer :: MonadHandler m => m ()
redirectUltDest :: (RedirectUrl (HandlerSite m) url, MonadHandler m) => url -> m a
clearUltDest :: MonadHandler m => m ()
addMessage :: MonadHandler m => Text -> Html -> m ()
addMessageI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => Text -> msg -> m ()
getMessages :: MonadHandler m => m [(Text, Html)]
setMessage :: MonadHandler m => Html -> m ()
setMessageI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => msg -> m ()
getMessage :: MonadHandler m => m (Maybe Html)
sendFile :: MonadHandler m => ContentType -> FilePath -> m a
sendFilePart :: MonadHandler m => ContentType -> FilePath -> Integer -> Integer -> m a
sendResponse :: (MonadHandler m, ToTypedContent c) => c -> m a
sendResponseStatus :: (MonadHandler m, ToTypedContent c) => Status -> c -> m a
sendStatusJSON :: (MonadHandler m, ToJSON c) => Status -> c -> m a
sendResponseCreated :: MonadHandler m => Route (HandlerSite m) -> m a
sendResponseNoContent :: MonadHandler m => m a
sendWaiResponse :: MonadHandler m => Response -> m b
sendWaiApplication :: MonadHandler m => Application -> m b
sendRawResponseNoConduit :: (MonadHandler m, MonadUnliftIO m) => (IO ByteString -> (ByteString -> IO ()) -> m ()) -> m a
sendRawResponse :: (MonadHandler m, MonadUnliftIO m) => (ConduitT () ByteString IO () -> ConduitT ByteString Void IO () -> m ()) -> m a
notModified :: MonadHandler m => m a
notFound :: MonadHandler m => m a
badMethod :: MonadHandler m => m a
notAuthenticated :: MonadHandler m => m a
permissionDenied :: MonadHandler m => Text -> m a
permissionDeniedI :: (RenderMessage (HandlerSite m) msg, MonadHandler m) => msg -> m a
invalidArgs :: MonadHandler m => [Text] -> m a
invalidArgsI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => [msg] -> m a
setCookie :: MonadHandler m => SetCookie -> m ()
getExpires :: MonadIO m => Int -> m UTCTime
deleteCookie :: MonadHandler m => Text -> Text -> m ()
setLanguage :: MonadHandler m => Text -> m ()
addContentDispositionFileName :: MonadHandler m => Text -> m ()
addHeader :: MonadHandler m => Text -> Text -> m ()
setHeader :: MonadHandler m => Text -> Text -> m ()
replaceOrAddHeader :: MonadHandler m => Text -> Text -> m ()
cacheSeconds :: MonadHandler m => Int -> m ()
neverExpires :: MonadHandler m => m ()
alreadyExpired :: MonadHandler m => m ()
expiresAt :: MonadHandler m => UTCTime -> m ()
setEtag :: MonadHandler m => Text -> m ()
setWeakEtag :: MonadHandler m => Text -> m ()
setSession :: MonadHandler m => Text -> Text -> m ()
setSessionBS :: MonadHandler m => Text -> ByteString -> m ()
deleteSession :: MonadHandler m => Text -> m ()
clearSession :: MonadHandler m => m ()
lookupSession :: MonadHandler m => Text -> m (Maybe Text)
lookupSessionBS :: MonadHandler m => Text -> m (Maybe ByteString)
getSession :: MonadHandler m => m SessionMap
newIdent :: MonadHandler m => m Text
redirectToPost :: (MonadHandler m, RedirectUrl (HandlerSite m) url) => url -> m a
hamletToRepHtml :: MonadHandler m => HtmlUrl (Route (HandlerSite m)) -> m Html
giveUrlRenderer :: MonadHandler m => ((Route (HandlerSite m) -> [(Text, Text)] -> Text) -> output) -> m output
withUrlRenderer :: MonadHandler m => ((Route (HandlerSite m) -> [(Text, Text)] -> Text) -> output) -> m output
waiRequest :: MonadHandler m => m Request
getMessageRender :: (MonadHandler m, RenderMessage (HandlerSite m) message) => m (message -> Text)
cached :: (MonadHandler m, Typeable a) => m a -> m a
cacheGet :: (MonadHandler m, Typeable a) => m (Maybe a)
cacheSet :: (MonadHandler m, Typeable a) => a -> m ()
cachedBy :: (MonadHandler m, Typeable a) => ByteString -> m a -> m a
cacheByGet :: (MonadHandler m, Typeable a) => ByteString -> m (Maybe a)
cacheBySet :: (MonadHandler m, Typeable a) => ByteString -> a -> m ()
languages :: MonadHandler m => m [Text]
lookupHeader :: MonadHandler m => CI ByteString -> m (Maybe ByteString)
lookupHeaders :: MonadHandler m => CI ByteString -> m [ByteString]
lookupBasicAuth :: MonadHandler m => m (Maybe (Text, Text))
lookupBearerAuth :: MonadHandler m => m (Maybe Text)
lookupGetParams :: MonadHandler m => Text -> m [Text]
lookupGetParam :: MonadHandler m => Text -> m (Maybe Text)
lookupPostParams :: (MonadResource m, MonadHandler m) => Text -> m [Text]
lookupPostParam :: (MonadResource m, MonadHandler m) => Text -> m (Maybe Text)
lookupFile :: MonadHandler m => Text -> m (Maybe FileInfo)
lookupFiles :: MonadHandler m => Text -> m [FileInfo]
lookupCookie :: MonadHandler m => Text -> m (Maybe Text)
lookupCookies :: MonadHandler m => Text -> m [Text]
selectRep :: MonadHandler m => Writer (Endo [ProvidedRep m]) () -> m TypedContent
provideRep :: (Monad m, HasContentType a) => m a -> Writer (Endo [ProvidedRep m]) ()
provideRepType :: (Monad m, ToContent a) => ContentType -> m a -> Writer (Endo [ProvidedRep m]) ()
rawRequestBody :: forall (m :: Type -> Type) i. MonadHandler m => ConduitT i ByteString m ()
fileSource :: forall (m :: Type -> Type). MonadResource m => FileInfo -> ConduitT () ByteString m ()
fileSourceByteString :: MonadResource m => FileInfo -> m ByteString
respond :: (Monad m, ToContent a) => ContentType -> a -> m TypedContent
respondSource :: ContentType -> ConduitT () (Flush Builder) (HandlerFor site) () -> HandlerFor site TypedContent
sendChunk :: forall (m :: Type -> Type) a i. (Monad m, ToFlushBuilder a) => a -> ConduitT i (Flush Builder) m ()
sendFlush :: forall (m :: Type -> Type) i. Monad m => ConduitT i (Flush Builder) m ()
sendChunkBS :: forall (m :: Type -> Type) i. Monad m => ByteString -> ConduitT i (Flush Builder) m ()
sendChunkLBS :: forall (m :: Type -> Type) i. Monad m => ByteString -> ConduitT i (Flush Builder) m ()
sendChunkText :: forall (m :: Type -> Type) i. Monad m => Text -> ConduitT i (Flush Builder) m ()
sendChunkLazyText :: forall (m :: Type -> Type) i. Monad m => Text -> ConduitT i (Flush Builder) m ()
sendChunkHtml :: forall (m :: Type -> Type) i. Monad m => Html -> ConduitT i (Flush Builder) m ()
defaultCsrfCookieName :: ByteString
setCsrfCookie :: MonadHandler m => m ()
setCsrfCookieWithCookie :: MonadHandler m => SetCookie -> m ()
defaultCsrfHeaderName :: CI ByteString
checkCsrfHeaderNamed :: MonadHandler m => CI ByteString -> m ()
hasValidCsrfHeaderNamed :: MonadHandler m => CI ByteString -> m Bool
defaultCsrfParamName :: Text
checkCsrfParamNamed :: MonadHandler m => Text -> m ()
hasValidCsrfParamNamed :: MonadHandler m => Text -> m Bool
checkCsrfHeaderOrParam :: (MonadHandler m, MonadLogger m) => CI ByteString -> Text -> m ()
getSubYesod :: MonadHandler m => m (SubHandlerSite m)
getRouteToParent :: MonadHandler m => m (Route (SubHandlerSite m) -> Route (HandlerSite m))
getSubCurrentRoute :: MonadHandler m => m (Maybe (Route (SubHandlerSite m)))
class ToWidgetHead site a where
- toWidgetHead :: (MonadWidget m, HandlerSite m ~ site) => a -> m ()
class ToWidgetBody site a where
- toWidgetBody :: (MonadWidget m, HandlerSite m ~ site) => a -> m ()
class ToWidgetMedia site a where
- toWidgetMedia :: (MonadWidget m, HandlerSite m ~ site) => Text -> a -> m ()
class ToWidget site a where
- toWidget :: (MonadWidget m, HandlerSite m ~ site) => a -> m ()
type WidgetT site (m :: Type -> Type) = WidgetFor site
setTitle :: MonadWidget m => Html -> m ()
setTitleI :: (MonadWidget m, RenderMessage (HandlerSite m) msg) => msg -> m ()
setDescription :: MonadWidget m => Text -> m ()
setDescriptionI :: (MonadWidget m, RenderMessage (HandlerSite m) msg) => msg -> m ()
setDescriptionIdemp :: MonadWidget m => Text -> m ()
setDescriptionIdempI :: (MonadWidget m, RenderMessage (HandlerSite m) msg) => msg -> m ()
setOGType :: MonadWidget m => Text -> m ()
setOGImage :: MonadWidget m => Text -> m ()
addStylesheet :: MonadWidget m => Route (HandlerSite m) -> m ()
addStylesheetAttrs :: MonadWidget m => Route (HandlerSite m) -> [(Text, Text)] -> m ()
addStylesheetRemote :: MonadWidget m => Text -> m ()
addStylesheetRemoteAttrs :: MonadWidget m => Text -> [(Text, Text)] -> m ()
addStylesheetEither :: MonadWidget m => Either (Route (HandlerSite m)) Text -> m ()
addScriptEither :: MonadWidget m => Either (Route (HandlerSite m)) Text -> m ()
addScript :: MonadWidget m => Route (HandlerSite m) -> m ()
addScriptAttrs :: MonadWidget m => Route (HandlerSite m) -> [(Text, Text)] -> m ()
addScriptRemote :: MonadWidget m => Text -> m ()
addScriptRemoteAttrs :: MonadWidget m => Text -> [(Text, Text)] -> m ()
whamlet :: QuasiQuoter
whamletFile :: FilePath -> Q Exp
whamletFileWithSettings :: HamletSettings -> FilePath -> Q Exp
asWidgetT :: forall site (m :: Type -> Type). WidgetT site m () -> WidgetT site m ()
ihamletToRepHtml :: (MonadHandler m, RenderMessage (HandlerSite m) message) => HtmlUrlI18n message (Route (HandlerSite m)) -> m Html
ihamletToHtml :: (MonadHandler m, RenderMessage (HandlerSite m) message) => HtmlUrlI18n message (Route (HandlerSite m)) -> m Html
handlerToWidget :: HandlerFor site a -> WidgetFor site a
class RenderRoute site => Yesod site where
- approot :: Approot site
- catchHandlerExceptions :: MonadUnliftIO m => site -> m a -> (SomeException -> m a) -> m a
- errorHandler :: ErrorResponse -> HandlerFor site TypedContent
- defaultLayout :: WidgetFor site () -> HandlerFor site Html
- urlParamRenderOverride :: site -> Route site -> [(Text, Text)] -> Maybe Builder
- isAuthorized :: Route site -> Bool -> HandlerFor site AuthResult
- isWriteRequest :: Route site -> HandlerFor site Bool
- authRoute :: site -> Maybe (Route site)
- cleanPath :: site -> [Text] -> Either [Text] [Text]
- joinPath :: site -> Text -> [Text] -> [(Text, Text)] -> Builder
- addStaticContent :: Text -> Text -> ByteString -> HandlerFor site (Maybe (Either Text (Route site, [(Text, Text)])))
- maximumContentLength :: site -> Maybe (Route site) -> Maybe Word64
- maximumContentLengthIO :: site -> Maybe (Route site) -> IO (Maybe Word64)
- makeLogger :: site -> IO Logger
- messageLoggerSource :: site -> Logger -> Loc -> LogSource -> LogLevel -> LogStr -> IO ()
- jsLoader :: site -> ScriptLoadPosition site
- jsAttributes :: site -> [(Text, Text)]
- jsAttributesHandler :: HandlerFor site [(Text, Text)]
- makeSessionBackend :: site -> IO (Maybe SessionBackend)
- fileUpload :: site -> RequestBodyLength -> FileUpload
- shouldLogIO :: site -> LogSource -> LogLevel -> IO Bool
- yesodMiddleware :: ToTypedContent res => HandlerFor site res -> HandlerFor site res
- yesodWithInternalState :: site -> Maybe (Route site) -> (InternalState -> IO a) -> IO a
- defaultMessageWidget :: Html -> HtmlUrl (Route site) -> WidgetFor site ()
defaultMakeLogger :: IO Logger
defaultMessageLoggerSource :: (LogSource -> LogLevel -> IO Bool) -> Logger -> Loc -> LogSource -> LogLevel -> LogStr -> IO ()
defaultShouldLogIO :: LogSource -> LogLevel -> IO Bool
defaultYesodMiddleware :: Yesod site => HandlerFor site res -> HandlerFor site res
sslOnlySessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend)
laxSameSiteSessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend)
strictSameSiteSessions :: IO (Maybe SessionBackend) -> IO (Maybe SessionBackend)
sslOnlyMiddleware :: Int -> HandlerFor site res -> HandlerFor site res
authorizationCheck :: Yesod site => HandlerFor site ()
defaultCsrfCheckMiddleware :: Yesod site => HandlerFor site res -> HandlerFor site res
csrfCheckMiddleware :: HandlerFor site res -> HandlerFor site Bool -> CI ByteString -> Text -> HandlerFor site res
defaultCsrfSetCookieMiddleware :: HandlerFor site res -> HandlerFor site res
csrfSetCookieMiddleware :: HandlerFor site res -> SetCookie -> HandlerFor site res
defaultCsrfMiddleware :: Yesod site => HandlerFor site res -> HandlerFor site res
widgetToPageContent :: Yesod site => WidgetFor site () -> HandlerFor site (PageContent (Route site))
defaultErrorHandler :: Yesod site => ErrorResponse -> HandlerFor site TypedContent
formatLogMessage :: IO ZonedDate -> Loc -> LogSource -> LogLevel -> LogStr -> IO LogStr
customizeSessionCookies :: (SetCookie -> SetCookie) -> SessionBackend -> SessionBackend
defaultClientSessionBackend :: Int -> FilePath -> IO SessionBackend
envClientSessionBackend :: Int -> String -> IO SessionBackend
clientSessionBackend :: Key -> IO ClientSessionDateCache -> SessionBackend
loadClientSession :: Key -> IO ClientSessionDateCache -> ByteString -> Request -> IO (SessionMap, SaveSession)
guessApproot :: Approot site
guessApprootOr :: Approot site -> Approot site
getApprootText :: Approot site -> site -> Request -> Text
defaultLayoutJson :: (Yesod site, ToJSON a) => WidgetFor site () -> HandlerFor site a -> HandlerFor site TypedContent
jsonToRepJson :: (Monad m, ToJSON a) => a -> m Value
returnJson :: (Monad m, ToJSON a) => a -> m Value
returnJsonEncoding :: (Monad m, ToJSON a) => a -> m Encoding
provideJson :: forall (m :: Type -> Type) a. (Monad m, ToJSON a) => a -> Writer (Endo [ProvidedRep m]) ()
parseJsonBody :: (MonadHandler m, FromJSON a) => m (Result a)
parseInsecureJsonBody :: (MonadHandler m, FromJSON a) => m (Result a)
parseCheckJsonBody :: (MonadHandler m, FromJSON a) => m (Result a)
parseJsonBody_ :: (MonadHandler m, FromJSON a) => m a
requireJsonBody :: (MonadHandler m, FromJSON a) => m a
requireInsecureJsonBody :: (MonadHandler m, FromJSON a) => m a
requireCheckJsonBody :: (MonadHandler m, FromJSON a) => m a
array :: ToJSON a => [a] -> Value
jsonOrRedirect :: (MonadHandler m, ToJSON a) => Route (HandlerSite m) -> a -> m Value
jsonEncodingOrRedirect :: (MonadHandler m, ToJSON a) => Route (HandlerSite m) -> a -> m Encoding
acceptsJson :: MonadHandler m => m Bool
contentTypeHeaderIsJson :: ByteString -> Bool
yesodRunner :: (ToTypedContent res, Yesod site) => HandlerFor site res -> YesodRunnerEnv site -> Maybe (Route site) -> Application
yesodRender :: Yesod y => y -> ResolvedApproot -> Route y -> [(Text, Text)] -> Text
class YesodSubDispatch sub master where
- yesodSubDispatch :: YesodSubRunnerEnv sub master -> Application
class Yesod site => YesodDispatch site where
- yesodDispatch :: YesodRunnerEnv site -> Application
type LiteWidget = WidgetFor LiteApp
type LiteHandler = HandlerFor LiteApp
newtype LiteApp = LiteApp {
- unLiteApp :: Method -> [Text] -> Maybe (LiteHandler TypedContent)
}
liteApp :: Writer LiteApp () -> LiteApp
dispatchTo :: ToTypedContent a => LiteHandler a -> Writer LiteApp ()
onMethod :: Method -> Writer LiteApp () -> Writer LiteApp ()
onStatic :: Text -> Writer LiteApp () -> Writer LiteApp ()
withDynamic :: PathPiece p => (p -> Writer LiteApp ()) -> Writer LiteApp ()
withDynamicMulti :: PathMultiPiece ps => (ps -> Writer LiteApp ()) -> Writer LiteApp ()
class YesodBreadcrumbs site where
- breadcrumb :: Route site -> HandlerFor site (Text, Maybe (Route site))
breadcrumbs :: (YesodBreadcrumbs site, Show (Route site), Eq (Route site)) => HandlerFor site (Text, [(Route site, Text)])
parseRoutes :: QuasiQuoter
parseRoutesFile :: FilePath -> Q Exp
parseRoutesFileNoCheck :: FilePath -> Q Exp
parseRoutesNoCheck :: QuasiQuoter
mkYesod :: String -> [ResourceTree String] -> Q [Dec]
mkYesodWith :: [[String]] -> String -> [String] -> [ResourceTree String] -> Q [Dec]
mkYesodData :: String -> [ResourceTree String] -> Q [Dec]
mkYesodSubData :: String -> [ResourceTree String] -> Q [Dec]
mkYesodDispatch :: String -> [ResourceTree String] -> Q [Dec]
mkYesodSubDispatch :: [ResourceTree a] -> Q Exp
toWaiAppPlain :: YesodDispatch site => site -> IO Application
defaultGen :: IO Int
toWaiAppYre :: YesodDispatch site => YesodRunnerEnv site -> Application
toWaiApp :: YesodDispatch site => site -> IO Application
warp :: YesodDispatch site => Int -> site -> IO ()
mkDefaultMiddlewares :: Logger -> IO Middleware
defaultMiddlewaresNoLogging :: Middleware
warpDebug :: YesodDispatch site => Int -> site -> IO ()
warpEnv :: YesodDispatch site => site -> IO ()
getGetMaxExpires :: IO (IO Text)
runFakeHandler :: (Yesod site, MonadIO m) => SessionMap -> (site -> Logger) -> site -> HandlerT site IO a -> m (Either ErrorResponse a)
unauthorizedI :: (MonadHandler m, RenderMessage (HandlerSite m) msg) => msg -> m AuthResult
yesodVersion :: String
maybeAuthorized :: Yesod site => Route site -> Bool -> HandlerT site IO (Maybe (Route site))
showIntegral :: Integral a => a -> String
readIntegral :: Num a => String -> Maybe a
data Extra = Extra {
- extraCopyright :: Text
- extraAnalytics :: Maybe Text
- extraStaticRoot :: Maybe Text
}
development :: Bool
production :: Bool
hledgerorgurl :: Text
manualurl :: Text
defhost :: String
defport :: Int
defbaseurl :: String -> Int -> String
staticDir :: FilePath
staticRoot :: AppConfig DefaultEnv Extra -> Text
widgetFileSettings :: WidgetFileSettings
widgetFile :: String -> Q Exp
parseExtra :: DefaultEnv -> Object -> Parser Extra
staticSite :: IO Static
hledger_css :: StaticRoute
hledger_js :: StaticRoute
css_bootstrap_datepicker_standalone_min_css :: StaticRoute
css_bootstrap_theme_css :: StaticRoute
css_bootstrap_theme_css_map :: StaticRoute
css_bootstrap_theme_min_css :: StaticRoute
css_bootstrap_css :: StaticRoute
css_bootstrap_css_map :: StaticRoute
css_bootstrap_min_css :: StaticRoute
fonts_glyphicons_halflings_regular_eot :: StaticRoute
fonts_glyphicons_halflings_regular_svg :: StaticRoute
fonts_glyphicons_halflings_regular_ttf :: StaticRoute
fonts_glyphicons_halflings_regular_woff :: StaticRoute
js_bootstrap_datepicker_min_js :: StaticRoute
js_bootstrap_js :: StaticRoute
js_bootstrap_min_js :: StaticRoute
js_excanvas_js :: StaticRoute
js_excanvas_min_js :: StaticRoute
js_jquery_cookie_js :: StaticRoute
js_jquery_flot_canvas_js :: StaticRoute
js_jquery_flot_canvas_min_js :: StaticRoute
js_jquery_flot_categories_js :: StaticRoute
js_jquery_flot_categories_min_js :: StaticRoute
js_jquery_flot_crosshair_js :: StaticRoute
js_jquery_flot_crosshair_min_js :: StaticRoute
js_jquery_flot_errorbars_js :: StaticRoute
js_jquery_flot_errorbars_min_js :: StaticRoute
js_jquery_flot_fillbetween_js :: StaticRoute
js_jquery_flot_fillbetween_min_js :: StaticRoute
js_jquery_flot_image_js :: StaticRoute
js_jquery_flot_image_min_js :: StaticRoute
js_jquery_flot_js :: StaticRoute
js_jquery_flot_min_js :: StaticRoute
js_jquery_flot_navigate_js :: StaticRoute
js_jquery_flot_navigate_min_js :: StaticRoute
js_jquery_flot_pie_js :: StaticRoute
js_jquery_flot_pie_min_js :: StaticRoute
js_jquery_flot_resize_js :: StaticRoute
js_jquery_flot_resize_min_js :: StaticRoute
js_jquery_flot_selection_js :: StaticRoute
js_jquery_flot_selection_min_js :: StaticRoute
js_jquery_flot_stack_js :: StaticRoute
js_jquery_flot_stack_min_js :: StaticRoute
js_jquery_flot_symbol_js :: StaticRoute
js_jquery_flot_symbol_min_js :: StaticRoute
js_jquery_flot_threshold_js :: StaticRoute
js_jquery_flot_threshold_min_js :: StaticRoute
js_jquery_flot_time_js :: StaticRoute
js_jquery_flot_time_min_js :: StaticRoute
js_jquery_flot_tooltip_js :: StaticRoute
js_jquery_flot_tooltip_min_js :: StaticRoute
js_jquery_hotkeys_js :: StaticRoute
js_jquery_js :: StaticRoute
js_jquery_min_js :: StaticRoute
js_jquery_url_js :: StaticRoute
js_typeahead_bundle_js :: StaticRoute
js_typeahead_bundle_min_js :: StaticRoute
data Capability
- = CapView
- | CapAdd
- | CapManage
data App = App {
- settings :: AppConfig DefaultEnv Extra
- getStatic :: Static
- httpManager :: Manager
- appOpts :: WebOpts
- appJournal :: IORef Journal
}
data ViewData = VD {
- opts :: WebOpts
- today :: Day
- j :: Journal
- qparam :: Text
- q :: Query
- qopts :: [QueryOpt]
- caps :: [Capability]
}
type Form a = Html -> MForm Handler (FormResult a, Widget)
type AppRoute = Route App
type Widget = WidgetFor App ()
type Handler = HandlerFor App
resourcesApp :: [ResourceTree String]
getViewData :: Handler ViewData
checkServerSideUiEnabled :: Handler ()
shouldShowSidebar :: Handler Bool
getCurrentJournal :: IORef Journal -> CliOpts -> Day -> Handler (Journal, Maybe String)

Documentation

(++) :: [a] -> [a] -> [a] infixr 5 #

Append two lists, i.e.,

[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
[x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]

If the first list is not finite, the result is the first list.

seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b infixr 0 #

The value of seq a b is bottom if a is bottom, and otherwise equal to b. In other words, it evaluates the first argument a to weak head normal form (WHNF). seq is usually introduced to improve performance by avoiding unneeded laziness.

A note on evaluation order: the expression seq a b does not guarantee that a will be evaluated before b. The only guarantee given by seq is that the both a and b will be evaluated before seq returns a value. In particular, this means that b may be evaluated before a. If you need to guarantee a specific order of evaluation, you must use the function pseq from the "parallel" package.

filter :: (a -> Bool) -> [a] -> [a] #

$\mathcal{O}(n)$. filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,

filter p xs = [ x | x <- xs, p x]

>>> filter odd [1, 2, 3]
[1,3]

zip :: [a] -> [b] -> [(a, b)] #

$\mathcal{O}(\min(m,n))$. zip takes two lists and returns a list of corresponding pairs.

>>> zip [1, 2] ['a', 'b']
[(1,'a'),(2,'b')]

If one input list is shorter than the other, excess elements of the longer list are discarded, even if one of the lists is infinite:

>>> zip [1] ['a', 'b']
[(1,'a')]
>>> zip [1, 2] ['a']
[(1,'a')]
>>> zip [] [1..]
[]
>>> zip [1..] []
[]

zip is right-lazy:

>>> zip [] undefined
[]
>>> zip undefined []
*** Exception: Prelude.undefined
...

zip is capable of list fusion, but it is restricted to its first list argument and its resulting list.

print :: Show a => a -> IO () #

The print function outputs a value of any printable type to the standard output device. Printable types are those that are instances of class Show; print converts values to strings for output using the show operation and adds a newline.

For example, a program to print the first 20 integers and their powers of 2 could be written as:

main = print ([(n, 2^n) | n <- [0..19]])

fst :: (a, b) -> a #

Extract the first component of a pair.

snd :: (a, b) -> b #

Extract the second component of a pair.

otherwise :: Bool #

otherwise is defined as the value True. It helps to make guards more readable. eg.

 f x | x < 0     = ...
     | otherwise = ...

map :: (a -> b) -> [a] -> [b] #

$\mathcal{O}(n)$. map f xs is the list obtained by applying f to each element of xs, i.e.,

map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
map f [x1, x2, ...] == [f x1, f x2, ...]

>>> map (+1) [1, 2, 3]
[2,3,4]

($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 #

Application operator. This operator is redundant, since ordinary application (f x) means the same as (f $ x). However, $ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

f $ g $ h x  =  f (g (h x))

It is also useful in higher-order situations, such as map ($ 0) xs, or zipWith ($) fs xs.

Note that ($) is levity-polymorphic in its result type, so that foo $ True where foo :: Bool -> Int# is well-typed.

fromIntegral :: (Integral a, Num b) => a -> b #

general coercion from integral types

realToFrac :: (Real a, Fractional b) => a -> b #

general coercion to fractional types

guard :: Alternative f => Bool -> f () #

Conditional failure of Alternative computations. Defined by

guard True  = pure ()
guard False = empty

Examples

Expand

Common uses of guard include conditionally signaling an error in an error monad and conditionally rejecting the current choice in an Alternative-based parser.

As an example of signaling an error in the error monad Maybe, consider a safe division function safeDiv x y that returns Nothing when the denominator y is zero and Just (x `div` y) otherwise. For example:

>>> safeDiv 4 0
Nothing

>>> safeDiv 4 2
Just 2

A definition of safeDiv using guards, but not guard:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y | y /= 0    = Just (x `div` y)
            | otherwise = Nothing

A definition of safeDiv using guard and Monad do-notation:

safeDiv :: Int -> Int -> Maybe Int
safeDiv x y = do
  guard (y /= 0)
  return (x `div` y)

join :: Monad m => m (m a) -> m a #

The join function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

'join bss' can be understood as the do expression

do bs <- bss
   bs

Examples

Expand

A common use of join is to run an IO computation returned from an STM transaction, since STM transactions can't perform IO directly. Recall that

atomically :: STM a -> IO a

is used to run STM transactions atomically. So, by specializing the types of atomically and join to

atomically :: STM (IO b) -> IO (IO b)
join       :: IO (IO b)  -> IO b

we can compose them as

join . atomically :: STM (IO b) -> IO b

to run an STM transaction and the IO action it returns.

class Bounded a where #

The Bounded class is used to name the upper and lower limits of a type. Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds.

The Bounded class may be derived for any enumeration type; minBound is the first constructor listed in the data declaration and maxBound is the last. Bounded may also be derived for single-constructor datatypes whose constituent types are in Bounded.

Methods

minBound :: a #

maxBound :: a #

Instances

Instances details

Bounded All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: All # maxBound :: All #
Bounded Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Any # maxBound :: Any #
Bounded CBool
Instance details Defined in Foreign.C.Types Methods minBound :: CBool # maxBound :: CBool #
Bounded CChar
Instance details Defined in Foreign.C.Types Methods minBound :: CChar # maxBound :: CChar #
Bounded CInt
Instance details Defined in Foreign.C.Types Methods minBound :: CInt # maxBound :: CInt #
Bounded CIntMax
Instance details Defined in Foreign.C.Types Methods minBound :: CIntMax # maxBound :: CIntMax #
Bounded CIntPtr
Instance details Defined in Foreign.C.Types Methods minBound :: CIntPtr # maxBound :: CIntPtr #
Bounded CLLong
Instance details Defined in Foreign.C.Types Methods minBound :: CLLong # maxBound :: CLLong #
Bounded CLong
Instance details Defined in Foreign.C.Types Methods minBound :: CLong # maxBound :: CLong #
Bounded CPtrdiff
Instance details Defined in Foreign.C.Types Methods minBound :: CPtrdiff # maxBound :: CPtrdiff #
Bounded CSChar
Instance details Defined in Foreign.C.Types Methods minBound :: CSChar # maxBound :: CSChar #
Bounded CShort
Instance details Defined in Foreign.C.Types Methods minBound :: CShort # maxBound :: CShort #
Bounded CSigAtomic
Instance details Defined in Foreign.C.Types Methods minBound :: CSigAtomic # maxBound :: CSigAtomic #
Bounded CSize
Instance details Defined in Foreign.C.Types Methods minBound :: CSize # maxBound :: CSize #
Bounded CUChar
Instance details Defined in Foreign.C.Types Methods minBound :: CUChar # maxBound :: CUChar #
Bounded CUInt
Instance details Defined in Foreign.C.Types Methods minBound :: CUInt # maxBound :: CUInt #
Bounded CUIntMax
Instance details Defined in Foreign.C.Types Methods minBound :: CUIntMax # maxBound :: CUIntMax #
Bounded CUIntPtr
Instance details Defined in Foreign.C.Types Methods minBound :: CUIntPtr # maxBound :: CUIntPtr #
Bounded CULLong
Instance details Defined in Foreign.C.Types Methods minBound :: CULLong # maxBound :: CULLong #
Bounded CULong
Instance details Defined in Foreign.C.Types Methods minBound :: CULong # maxBound :: CULong #
Bounded CUShort
Instance details Defined in Foreign.C.Types Methods minBound :: CUShort # maxBound :: CUShort #
Bounded CWchar
Instance details Defined in Foreign.C.Types Methods minBound :: CWchar # maxBound :: CWchar #
Bounded ByteOrder	Since: base-4.11.0.0
Instance details Defined in GHC.ByteOrder Methods minBound :: ByteOrder # maxBound :: ByteOrder #
Bounded Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: Associativity # maxBound :: Associativity #
Bounded DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: DecidedStrictness # maxBound :: DecidedStrictness #
Bounded SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceStrictness # maxBound :: SourceStrictness #
Bounded SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceUnpackedness # maxBound :: SourceUnpackedness #
Bounded Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int16 # maxBound :: Int16 #
Bounded Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int32 # maxBound :: Int32 #
Bounded Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int64 # maxBound :: Int64 #
Bounded Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods minBound :: Int8 # maxBound :: Int8 #
Bounded Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word16 # maxBound :: Word16 #
Bounded Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word32 # maxBound :: Word32 #
Bounded Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word64 # maxBound :: Word64 #
Bounded Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word8 # maxBound :: Word8 #
Bounded Encoding
Instance details Defined in Basement.String Methods minBound :: Encoding # maxBound :: Encoding #
Bounded UTF32_Invalid
Instance details Defined in Basement.String.Encoding.UTF32 Methods minBound :: UTF32_Invalid # maxBound :: UTF32_Invalid #
Bounded HelpFormat
Instance details Defined in System.Console.CmdArgs.Explicit.Help Methods minBound :: HelpFormat # maxBound :: HelpFormat #
Bounded FileType
Instance details Defined in System.Directory.Internal.Common Methods minBound :: FileType # maxBound :: FileType #
Bounded XdgDirectory
Instance details Defined in System.Directory.Internal.Common Methods minBound :: XdgDirectory # maxBound :: XdgDirectory #
Bounded XdgDirectoryList
Instance details Defined in System.Directory.Internal.Common Methods minBound :: XdgDirectoryList # maxBound :: XdgDirectoryList #
Bounded Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods minBound :: Extension # maxBound :: Extension #
Bounded Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering # maxBound :: Ordering #
Bounded Status
Instance details Defined in Hledger.Data.Types Methods minBound :: Status # maxBound :: Status #
Bounded Capability Source #
Instance details Defined in Hledger.Web.WebOptions Methods minBound :: Capability # maxBound :: Capability #
Bounded StdMethod
Instance details Defined in Network.HTTP.Types.Method Methods minBound :: StdMethod # maxBound :: StdMethod #
Bounded Status
Instance details Defined in Network.HTTP.Types.Status Methods minBound :: Status # maxBound :: Status #
Bounded IPv4
Instance details Defined in Data.IP.Addr Methods minBound :: IPv4 # maxBound :: IPv4 #
Bounded IPv6
Instance details Defined in Data.IP.Addr Methods minBound :: IPv6 # maxBound :: IPv6 #
Bounded MappingStyle
Instance details Defined in Text.Libyaml Methods minBound :: MappingStyle # maxBound :: MappingStyle #
Bounded SequenceStyle
Instance details Defined in Text.Libyaml Methods minBound :: SequenceStyle # maxBound :: SequenceStyle #
Bounded Style
Instance details Defined in Text.Libyaml Methods minBound :: Style # maxBound :: Style #
Bounded PortNumber
Instance details Defined in Network.Socket.Types Methods minBound :: PortNumber # maxBound :: PortNumber #
Bounded Checkmark
Instance details Defined in Database.Persist.Types.Base Methods minBound :: Checkmark # maxBound :: Checkmark #
Bounded VarType
Instance details Defined in Text.Shakespeare Methods minBound :: VarType # maxBound :: VarType #
Bounded DefaultEnv
Instance details Defined in Yesod.Default.Config Methods minBound :: DefaultEnv # maxBound :: DefaultEnv #
Bounded Enctype
Instance details Defined in Yesod.Form.Types Methods minBound :: Enctype # maxBound :: Enctype #
Bounded CompressionStrategy
Instance details Defined in Codec.Compression.Zlib.Stream Methods minBound :: CompressionStrategy # maxBound :: CompressionStrategy #
Bounded Format
Instance details Defined in Codec.Compression.Zlib.Stream Methods minBound :: Format # maxBound :: Format #
Bounded Method
Instance details Defined in Codec.Compression.Zlib.Stream Methods minBound :: Method # maxBound :: Method #
Bounded ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: () # maxBound :: () #
Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool # maxBound :: Bool #
Bounded Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char # maxBound :: Char #
Bounded Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int # maxBound :: Int #
Bounded Levity	Since: base-4.16.0.0
Instance details Defined in GHC.Enum Methods minBound :: Levity # maxBound :: Levity #
Bounded VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecCount # maxBound :: VecCount #
Bounded VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecElem # maxBound :: VecElem #
Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word # maxBound :: Word #
Bounded a => Bounded (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods minBound :: Identity a # maxBound :: Identity a #
Bounded a => Bounded (Down a)	Swaps `minBound` and `maxBound` of the underlying type. Since: base-4.14.0.0
Instance details Defined in Data.Ord Methods minBound :: Down a # maxBound :: Down a #
Bounded a => Bounded (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: First a # maxBound :: First a #
Bounded a => Bounded (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Last a # maxBound :: Last a #
Bounded a => Bounded (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Max a # maxBound :: Max a #
Bounded a => Bounded (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: Min a # maxBound :: Min a #
Bounded m => Bounded (WrappedMonoid m)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods minBound :: WrappedMonoid m # maxBound :: WrappedMonoid m #
Bounded a => Bounded (Dual a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Dual a # maxBound :: Dual a #
Bounded a => Bounded (Product a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Product a # maxBound :: Product a #
Bounded a => Bounded (Sum a)	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods minBound :: Sum a # maxBound :: Sum a #
SizeValid n => Bounded (Bits n)
Instance details Defined in Basement.Bits Methods minBound :: Bits n # maxBound :: Bits n #
Bounded a => Bounded (a)
Instance details Defined in GHC.Enum Methods minBound :: (a) # maxBound :: (a) #
Bounded (Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods minBound :: Proxy t # maxBound :: Proxy t #
(Bounded a, Bounded b) => Bounded (Pair a b)
Instance details Defined in Data.Strict.Tuple Methods minBound :: Pair a b # maxBound :: Pair a b #
(Bounded a, Bounded b) => Bounded (a, b)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b) # maxBound :: (a, b) #
Bounded a => Bounded (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b # maxBound :: Const a b #
(Applicative f, Bounded a) => Bounded (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods minBound :: Ap f a # maxBound :: Ap f a #
Bounded b => Bounded (Tagged s b)
Instance details Defined in Data.Tagged Methods minBound :: Tagged s b # maxBound :: Tagged s b #
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c) # maxBound :: (a, b, c) #
(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d) # maxBound :: (a, b, c, d) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e) # maxBound :: (a, b, c, d, e) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f) # maxBound :: (a, b, c, d, e, f) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g) # maxBound :: (a, b, c, d, e, f, g) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h) # maxBound :: (a, b, c, d, e, f, g, h) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i) # maxBound :: (a, b, c, d, e, f, g, h, i) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j) # maxBound :: (a, b, c, d, e, f, g, h, i, j) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #

class Enum a where #

Class Enum defines operations on sequentially ordered types.

The enumFrom... methods are used in Haskell's translation of arithmetic sequences.

Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details.

For any type that is an instance of class Bounded as well as Enum, the following should hold:

The calls succ maxBound and pred minBound should result in a runtime error.
fromEnum and toEnum should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool is an error.
enumFrom and enumFromThen should be defined with an implicit bound, thus:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
     where
       bound | fromEnum y >= fromEnum x = maxBound
             | otherwise                = minBound

Minimal complete definition

toEnum, fromEnum

Methods

succ :: a -> a #

the successor of a value. For numeric types, succ adds 1.

pred :: a -> a #

the predecessor of a value. For numeric types, pred subtracts 1.

toEnum :: Int -> a #

Convert from an Int.

fromEnum :: a -> Int #

Convert to an Int. It is implementation-dependent what fromEnum returns when applied to a value that is too large to fit in an Int.

enumFrom :: a -> [a] #

Used in Haskell's translation of [n..] with [n..] = enumFrom n, a possible implementation being enumFrom n = n : enumFrom (succ n). For example:

```
enumFrom 4 :: [Integer] = [4,5,6,7,...]
```

enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound :: Int]

enumFromThen :: a -> a -> [a] #

Used in Haskell's translation of [n,n'..] with [n,n'..] = enumFromThen n n', a possible implementation being enumFromThen n n' = n : n' : worker (f x) (f x n'), worker s v = v : worker s (s v), x = fromEnum n' - fromEnum n and f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n + 1) (pred y) | otherwise = y For example:

enumFromThen 4 6 :: [Integer] = [4,6,8,10...]

enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound :: Int]

enumFromTo :: a -> a -> [a] #

Used in Haskell's translation of [n..m] with [n..m] = enumFromTo n m, a possible implementation being enumFromTo n m | n <= m = n : enumFromTo (succ n) m | otherwise = []. For example:

```
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
```
```
enumFromTo 42 1 :: [Integer] = []
```

enumFromThenTo :: a -> a -> a -> [a] #

Used in Haskell's translation of [n,n'..m] with [n,n'..m] = enumFromThenTo n n' m, a possible implementation being enumFromThenTo n n' m = worker (f x) (c x) n m, x = fromEnum n' - fromEnum n, c x = bool (>=) ((x 0) f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n + 1) (pred y) | otherwise = y and worker s c v m | c v m = v : worker s c (s v) m | otherwise = [] For example:

enumFromThenTo 4 2 -6 :: [Integer] = [4,2,0,-2,-4,-6]

```
enumFromThenTo 6 8 2 :: [Int] = []
```

Instances

Instances details

Enum CBool
Instance details Defined in Foreign.C.Types Methods succ :: CBool -> CBool # pred :: CBool -> CBool # toEnum :: Int -> CBool # fromEnum :: CBool -> Int # enumFrom :: CBool -> [CBool] # enumFromThen :: CBool -> CBool -> [CBool] # enumFromTo :: CBool -> CBool -> [CBool] # enumFromThenTo :: CBool -> CBool -> CBool -> [CBool] #
Enum CChar
Instance details Defined in Foreign.C.Types Methods succ :: CChar -> CChar # pred :: CChar -> CChar # toEnum :: Int -> CChar # fromEnum :: CChar -> Int # enumFrom :: CChar -> [CChar] # enumFromThen :: CChar -> CChar -> [CChar] # enumFromTo :: CChar -> CChar -> [CChar] # enumFromThenTo :: CChar -> CChar -> CChar -> [CChar] #
Enum CClock
Instance details Defined in Foreign.C.Types Methods succ :: CClock -> CClock # pred :: CClock -> CClock # toEnum :: Int -> CClock # fromEnum :: CClock -> Int # enumFrom :: CClock -> [CClock] # enumFromThen :: CClock -> CClock -> [CClock] # enumFromTo :: CClock -> CClock -> [CClock] # enumFromThenTo :: CClock -> CClock -> CClock -> [CClock] #
Enum CDouble
Instance details Defined in Foreign.C.Types Methods succ :: CDouble -> CDouble # pred :: CDouble -> CDouble # toEnum :: Int -> CDouble # fromEnum :: CDouble -> Int # enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] #
Enum CFloat
Instance details Defined in Foreign.C.Types Methods succ :: CFloat -> CFloat # pred :: CFloat -> CFloat # toEnum :: Int -> CFloat # fromEnum :: CFloat -> Int # enumFrom :: CFloat -> [CFloat] # enumFromThen :: CFloat -> CFloat -> [CFloat] # enumFromTo :: CFloat -> CFloat -> [CFloat] # enumFromThenTo :: CFloat -> CFloat -> CFloat -> [CFloat] #
Enum CInt
Instance details Defined in Foreign.C.Types Methods succ :: CInt -> CInt # pred :: CInt -> CInt # toEnum :: Int -> CInt # fromEnum :: CInt -> Int # enumFrom :: CInt -> [CInt] # enumFromThen :: CInt -> CInt -> [CInt] # enumFromTo :: CInt -> CInt -> [CInt] # enumFromThenTo :: CInt -> CInt -> CInt -> [CInt] #
Enum CIntMax
Instance details Defined in Foreign.C.Types Methods succ :: CIntMax -> CIntMax # pred :: CIntMax -> CIntMax # toEnum :: Int -> CIntMax # fromEnum :: CIntMax -> Int # enumFrom :: CIntMax -> [CIntMax] # enumFromThen :: CIntMax -> CIntMax -> [CIntMax] # enumFromTo :: CIntMax -> CIntMax -> [CIntMax] # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] #
Enum CIntPtr
Instance details Defined in Foreign.C.Types Methods succ :: CIntPtr -> CIntPtr # pred :: CIntPtr -> CIntPtr # toEnum :: Int -> CIntPtr # fromEnum :: CIntPtr -> Int # enumFrom :: CIntPtr -> [CIntPtr] # enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] #
Enum CLLong
Instance details Defined in Foreign.C.Types Methods succ :: CLLong -> CLLong # pred :: CLLong -> CLLong # toEnum :: Int -> CLLong # fromEnum :: CLLong -> Int # enumFrom :: CLLong -> [CLLong] # enumFromThen :: CLLong -> CLLong -> [CLLong] # enumFromTo :: CLLong -> CLLong -> [CLLong] # enumFromThenTo :: CLLong -> CLLong -> CLLong -> [CLLong] #
Enum CLong
Instance details Defined in Foreign.C.Types Methods succ :: CLong -> CLong # pred :: CLong -> CLong # toEnum :: Int -> CLong # fromEnum :: CLong -> Int # enumFrom :: CLong -> [CLong] # enumFromThen :: CLong -> CLong -> [CLong] # enumFromTo :: CLong -> CLong -> [CLong] # enumFromThenTo :: CLong -> CLong -> CLong -> [CLong] #
Enum CPtrdiff
Instance details Defined in Foreign.C.Types Methods succ :: CPtrdiff -> CPtrdiff # pred :: CPtrdiff -> CPtrdiff # toEnum :: Int -> CPtrdiff # fromEnum :: CPtrdiff -> Int # enumFrom :: CPtrdiff -> [CPtrdiff] # enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff] #
Enum CSChar
Instance details Defined in Foreign.C.Types Methods succ :: CSChar -> CSChar # pred :: CSChar -> CSChar # toEnum :: Int -> CSChar # fromEnum :: CSChar -> Int # enumFrom :: CSChar -> [CSChar] # enumFromThen :: CSChar -> CSChar -> [CSChar] # enumFromTo :: CSChar -> CSChar -> [CSChar] # enumFromThenTo :: CSChar -> CSChar -> CSChar -> [CSChar] #
Enum CSUSeconds
Instance details Defined in Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # toEnum :: Int -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] #
Enum CShort
Instance details Defined in Foreign.C.Types Methods succ :: CShort -> CShort # pred :: CShort -> CShort # toEnum :: Int -> CShort # fromEnum :: CShort -> Int # enumFrom :: CShort -> [CShort] # enumFromThen :: CShort -> CShort -> [CShort] # enumFromTo :: CShort -> CShort -> [CShort] # enumFromThenTo :: CShort -> CShort -> CShort -> [CShort] #
Enum CSigAtomic
Instance details Defined in Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # toEnum :: Int -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] #
Enum CSize
Instance details Defined in Foreign.C.Types Methods succ :: CSize -> CSize # pred :: CSize -> CSize # toEnum :: Int -> CSize # fromEnum :: CSize -> Int # enumFrom :: CSize -> [CSize] # enumFromThen :: CSize -> CSize -> [CSize] # enumFromTo :: CSize -> CSize -> [CSize] # enumFromThenTo :: CSize -> CSize -> CSize -> [CSize] #
Enum CTime
Instance details Defined in Foreign.C.Types Methods succ :: CTime -> CTime # pred :: CTime -> CTime # toEnum :: Int -> CTime # fromEnum :: CTime -> Int # enumFrom :: CTime -> [CTime] # enumFromThen :: CTime -> CTime -> [CTime] # enumFromTo :: CTime -> CTime -> [CTime] # enumFromThenTo :: CTime -> CTime -> CTime -> [CTime] #
Enum CUChar
Instance details Defined in Foreign.C.Types Methods succ :: CUChar -> CUChar # pred :: CUChar -> CUChar # toEnum :: Int -> CUChar # fromEnum :: CUChar -> Int # enumFrom :: CUChar -> [CUChar] # enumFromThen :: CUChar -> CUChar -> [CUChar] # enumFromTo :: CUChar -> CUChar -> [CUChar] # enumFromThenTo :: CUChar -> CUChar -> CUChar -> [CUChar] #
Enum CUInt
Instance details Defined in Foreign.C.Types Methods succ :: CUInt -> CUInt # pred :: CUInt -> CUInt # toEnum :: Int -> CUInt # fromEnum :: CUInt -> Int # enumFrom :: CUInt -> [CUInt] # enumFromThen :: CUInt -> CUInt -> [CUInt] # enumFromTo :: CUInt -> CUInt -> [CUInt] # enumFromThenTo :: CUInt -> CUInt -> CUInt -> [CUInt] #
Enum CUIntMax
Instance details Defined in Foreign.C.Types Methods succ :: CUIntMax -> CUIntMax # pred :: CUIntMax -> CUIntMax # toEnum :: Int -> CUIntMax # fromEnum :: CUIntMax -> Int # enumFrom :: CUIntMax -> [CUIntMax] # enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax] #
Enum CUIntPtr
Instance details Defined in Foreign.C.Types Methods succ :: CUIntPtr -> CUIntPtr # pred :: CUIntPtr -> CUIntPtr # toEnum :: Int -> CUIntPtr # fromEnum :: CUIntPtr -> Int # enumFrom :: CUIntPtr -> [CUIntPtr] # enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr] #
Enum CULLong
Instance details Defined in Foreign.C.Types Methods succ :: CULLong -> CULLong # pred :: CULLong -> CULLong # toEnum :: Int -> CULLong # fromEnum :: CULLong -> Int # enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] #
Enum CULong
Instance details Defined in Foreign.C.Types Methods succ :: CULong -> CULong # pred :: CULong -> CULong # toEnum :: Int -> CULong # fromEnum :: CULong -> Int # enumFrom :: CULong -> [CULong] # enumFromThen :: CULong -> CULong -> [CULong] # enumFromTo :: CULong -> CULong -> [CULong] # enumFromThenTo :: CULong -> CULong -> CULong -> [CULong] #
Enum CUSeconds
Instance details Defined in Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # toEnum :: Int -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] #
Enum CUShort
Instance details Defined in Foreign.C.Types Methods succ :: CUShort -> CUShort # pred :: CUShort -> CUShort # toEnum :: Int -> CUShort # fromEnum :: CUShort -> Int # enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] #
Enum CWchar
Instance details Defined in Foreign.C.Types Methods succ :: CWchar -> CWchar # pred :: CWchar -> CWchar # toEnum :: Int -> CWchar # fromEnum :: CWchar -> Int # enumFrom :: CWchar -> [CWchar] # enumFromThen :: CWchar -> CWchar -> [CWchar] # enumFromTo :: CWchar -> CWchar -> [CWchar] # enumFromThenTo :: CWchar -> CWchar -> CWchar -> [CWchar] #
Enum ByteOrder	Since: base-4.11.0.0
Instance details Defined in GHC.ByteOrder Methods succ :: ByteOrder -> ByteOrder # pred :: ByteOrder -> ByteOrder # toEnum :: Int -> ByteOrder # fromEnum :: ByteOrder -> Int # enumFrom :: ByteOrder -> [ByteOrder] # enumFromThen :: ByteOrder -> ByteOrder -> [ByteOrder] # enumFromTo :: ByteOrder -> ByteOrder -> [ByteOrder] # enumFromThenTo :: ByteOrder -> ByteOrder -> ByteOrder -> [ByteOrder] #
Enum Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] #
Enum DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] #
Enum SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] #
Enum SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] #
Enum Int16	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int16 -> Int16 # pred :: Int16 -> Int16 # toEnum :: Int -> Int16 # fromEnum :: Int16 -> Int # enumFrom :: Int16 -> [Int16] # enumFromThen :: Int16 -> Int16 -> [Int16] # enumFromTo :: Int16 -> Int16 -> [Int16] # enumFromThenTo :: Int16 -> Int16 -> Int16 -> [Int16] #
Enum Int32	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int32 -> Int32 # pred :: Int32 -> Int32 # toEnum :: Int -> Int32 # fromEnum :: Int32 -> Int # enumFrom :: Int32 -> [Int32] # enumFromThen :: Int32 -> Int32 -> [Int32] # enumFromTo :: Int32 -> Int32 -> [Int32] # enumFromThenTo :: Int32 -> Int32 -> Int32 -> [Int32] #
Enum Int64	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int64 -> Int64 # pred :: Int64 -> Int64 # toEnum :: Int -> Int64 # fromEnum :: Int64 -> Int # enumFrom :: Int64 -> [Int64] # enumFromThen :: Int64 -> Int64 -> [Int64] # enumFromTo :: Int64 -> Int64 -> [Int64] # enumFromThenTo :: Int64 -> Int64 -> Int64 -> [Int64] #
Enum Int8	Since: base-2.1
Instance details Defined in GHC.Int Methods succ :: Int8 -> Int8 # pred :: Int8 -> Int8 # toEnum :: Int -> Int8 # fromEnum :: Int8 -> Int # enumFrom :: Int8 -> [Int8] # enumFromThen :: Int8 -> Int8 -> [Int8] # enumFromTo :: Int8 -> Int8 -> [Int8] # enumFromThenTo :: Int8 -> Int8 -> Int8 -> [Int8] #
Enum DoCostCentres	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods succ :: DoCostCentres -> DoCostCentres # pred :: DoCostCentres -> DoCostCentres # toEnum :: Int -> DoCostCentres # fromEnum :: DoCostCentres -> Int # enumFrom :: DoCostCentres -> [DoCostCentres] # enumFromThen :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromTo :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromThenTo :: DoCostCentres -> DoCostCentres -> DoCostCentres -> [DoCostCentres] #
Enum DoHeapProfile	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods succ :: DoHeapProfile -> DoHeapProfile # pred :: DoHeapProfile -> DoHeapProfile # toEnum :: Int -> DoHeapProfile # fromEnum :: DoHeapProfile -> Int # enumFrom :: DoHeapProfile -> [DoHeapProfile] # enumFromThen :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromTo :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromThenTo :: DoHeapProfile -> DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] #
Enum DoTrace	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods succ :: DoTrace -> DoTrace # pred :: DoTrace -> DoTrace # toEnum :: Int -> DoTrace # fromEnum :: DoTrace -> Int # enumFrom :: DoTrace -> [DoTrace] # enumFromThen :: DoTrace -> DoTrace -> [DoTrace] # enumFromTo :: DoTrace -> DoTrace -> [DoTrace] # enumFromThenTo :: DoTrace -> DoTrace -> DoTrace -> [DoTrace] #
Enum GiveGCStats	Since: base-4.8.0.0
Instance details Defined in GHC.RTS.Flags Methods succ :: GiveGCStats -> GiveGCStats # pred :: GiveGCStats -> GiveGCStats # toEnum :: Int -> GiveGCStats # fromEnum :: GiveGCStats -> Int # enumFrom :: GiveGCStats -> [GiveGCStats] # enumFromThen :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromTo :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromThenTo :: GiveGCStats -> GiveGCStats -> GiveGCStats -> [GiveGCStats] #
Enum IoSubSystem	Since: base-4.9.0.0
Instance details Defined in GHC.RTS.Flags Methods succ :: IoSubSystem -> IoSubSystem # pred :: IoSubSystem -> IoSubSystem # toEnum :: Int -> IoSubSystem # fromEnum :: IoSubSystem -> Int # enumFrom :: IoSubSystem -> [IoSubSystem] # enumFromThen :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromTo :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromThenTo :: IoSubSystem -> IoSubSystem -> IoSubSystem -> [IoSubSystem] #
Enum Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Enum Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Enum Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Enum Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Enum Encoding
Instance details Defined in Basement.String Methods succ :: Encoding -> Encoding # pred :: Encoding -> Encoding # toEnum :: Int -> Encoding # fromEnum :: Encoding -> Int # enumFrom :: Encoding -> [Encoding] # enumFromThen :: Encoding -> Encoding -> [Encoding] # enumFromTo :: Encoding -> Encoding -> [Encoding] # enumFromThenTo :: Encoding -> Encoding -> Encoding -> [Encoding] #
Enum UTF32_Invalid
Instance details Defined in Basement.String.Encoding.UTF32 Methods succ :: UTF32_Invalid -> UTF32_Invalid # pred :: UTF32_Invalid -> UTF32_Invalid # toEnum :: Int -> UTF32_Invalid # fromEnum :: UTF32_Invalid -> Int # enumFrom :: UTF32_Invalid -> [UTF32_Invalid] # enumFromThen :: UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # enumFromTo :: UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] # enumFromThenTo :: UTF32_Invalid -> UTF32_Invalid -> UTF32_Invalid -> [UTF32_Invalid] #
Enum HelpFormat
Instance details Defined in System.Console.CmdArgs.Explicit.Help Methods succ :: HelpFormat -> HelpFormat # pred :: HelpFormat -> HelpFormat # toEnum :: Int -> HelpFormat # fromEnum :: HelpFormat -> Int # enumFrom :: HelpFormat -> [HelpFormat] # enumFromThen :: HelpFormat -> HelpFormat -> [HelpFormat] # enumFromTo :: HelpFormat -> HelpFormat -> [HelpFormat] # enumFromThenTo :: HelpFormat -> HelpFormat -> HelpFormat -> [HelpFormat] #
Enum CryptoError
Instance details Defined in Crypto.Error.Types Methods succ :: CryptoError -> CryptoError # pred :: CryptoError -> CryptoError # toEnum :: Int -> CryptoError # fromEnum :: CryptoError -> Int # enumFrom :: CryptoError -> [CryptoError] # enumFromThen :: CryptoError -> CryptoError -> [CryptoError] # enumFromTo :: CryptoError -> CryptoError -> [CryptoError] # enumFromThenTo :: CryptoError -> CryptoError -> CryptoError -> [CryptoError] #
Enum CryptoError
Instance details Defined in Crypto.Error.Types Methods succ :: CryptoError -> CryptoError # pred :: CryptoError -> CryptoError # toEnum :: Int -> CryptoError # fromEnum :: CryptoError -> Int # enumFrom :: CryptoError -> [CryptoError] # enumFromThen :: CryptoError -> CryptoError -> [CryptoError] # enumFromTo :: CryptoError -> CryptoError -> [CryptoError] # enumFromThenTo :: CryptoError -> CryptoError -> CryptoError -> [CryptoError] #
Enum FileType
Instance details Defined in System.Directory.Internal.Common Methods succ :: FileType -> FileType # pred :: FileType -> FileType # toEnum :: Int -> FileType # fromEnum :: FileType -> Int # enumFrom :: FileType -> [FileType] # enumFromThen :: FileType -> FileType -> [FileType] # enumFromTo :: FileType -> FileType -> [FileType] # enumFromThenTo :: FileType -> FileType -> FileType -> [FileType] #
Enum XdgDirectory
Instance details Defined in System.Directory.Internal.Common Methods succ :: XdgDirectory -> XdgDirectory # pred :: XdgDirectory -> XdgDirectory # toEnum :: Int -> XdgDirectory # fromEnum :: XdgDirectory -> Int # enumFrom :: XdgDirectory -> [XdgDirectory] # enumFromThen :: XdgDirectory -> XdgDirectory -> [XdgDirectory] # enumFromTo :: XdgDirectory -> XdgDirectory -> [XdgDirectory] # enumFromThenTo :: XdgDirectory -> XdgDirectory -> XdgDirectory -> [XdgDirectory] #
Enum XdgDirectoryList
Instance details Defined in System.Directory.Internal.Common Methods succ :: XdgDirectoryList -> XdgDirectoryList # pred :: XdgDirectoryList -> XdgDirectoryList # toEnum :: Int -> XdgDirectoryList # fromEnum :: XdgDirectoryList -> Int # enumFrom :: XdgDirectoryList -> [XdgDirectoryList] # enumFromThen :: XdgDirectoryList -> XdgDirectoryList -> [XdgDirectoryList] # enumFromTo :: XdgDirectoryList -> XdgDirectoryList -> [XdgDirectoryList] # enumFromThenTo :: XdgDirectoryList -> XdgDirectoryList -> XdgDirectoryList -> [XdgDirectoryList] #
Enum Extension
Instance details Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # toEnum :: Int -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Enum Status
Instance details Defined in Hledger.Data.Types Methods succ :: Status -> Status # pred :: Status -> Status # toEnum :: Int -> Status # fromEnum :: Status -> Int # enumFrom :: Status -> [Status] # enumFromThen :: Status -> Status -> [Status] # enumFromTo :: Status -> Status -> [Status] # enumFromThenTo :: Status -> Status -> Status -> [Status] #
Enum Capability Source #
Instance details Defined in Hledger.Web.WebOptions Methods succ :: Capability -> Capability # pred :: Capability -> Capability # toEnum :: Int -> Capability # fromEnum :: Capability -> Int # enumFrom :: Capability -> [Capability] # enumFromThen :: Capability -> Capability -> [Capability] # enumFromTo :: Capability -> Capability -> [Capability] # enumFromThenTo :: Capability -> Capability -> Capability -> [Capability] #
Enum StdMethod
Instance details Defined in Network.HTTP.Types.Method Methods succ :: StdMethod -> StdMethod # pred :: StdMethod -> StdMethod # toEnum :: Int -> StdMethod # fromEnum :: StdMethod -> Int # enumFrom :: StdMethod -> [StdMethod] # enumFromThen :: StdMethod -> StdMethod -> [StdMethod] # enumFromTo :: StdMethod -> StdMethod -> [StdMethod] # enumFromThenTo :: StdMethod -> StdMethod -> StdMethod -> [StdMethod] #
Enum Status
Instance details Defined in Network.HTTP.Types.Status Methods succ :: Status -> Status # pred :: Status -> Status # toEnum :: Int -> Status # fromEnum :: Status -> Int # enumFrom :: Status -> [Status] # enumFromThen :: Status -> Status -> [Status] # enumFromTo :: Status -> Status -> [Status] # enumFromThenTo :: Status -> Status -> Status -> [Status] #
Enum IP
Instance details Defined in Data.IP.Addr Methods succ :: IP -> IP # pred :: IP -> IP # toEnum :: Int -> IP # fromEnum :: IP -> Int # enumFrom :: IP -> [IP] # enumFromThen :: IP -> IP -> [IP] # enumFromTo :: IP -> IP -> [IP] # enumFromThenTo :: IP -> IP -> IP -> [IP] #
Enum IPv4
Instance details Defined in Data.IP.Addr Methods succ :: IPv4 -> IPv4 # pred :: IPv4 -> IPv4 # toEnum :: Int -> IPv4 # fromEnum :: IPv4 -> Int # enumFrom :: IPv4 -> [IPv4] # enumFromThen :: IPv4 -> IPv4 -> [IPv4] # enumFromTo :: IPv4 -> IPv4 -> [IPv4] # enumFromThenTo :: IPv4 -> IPv4 -> IPv4 -> [IPv4] #
Enum IPv6
Instance details Defined in Data.IP.Addr Methods succ :: IPv6 -> IPv6 # pred :: IPv6 -> IPv6 # toEnum :: Int -> IPv6 # fromEnum :: IPv6 -> Int # enumFrom :: IPv6 -> [IPv6] # enumFromThen :: IPv6 -> IPv6 -> [IPv6] # enumFromTo :: IPv6 -> IPv6 -> [IPv6] # enumFromThenTo :: IPv6 -> IPv6 -> IPv6 -> [IPv6] #
Enum EventType
Instance details Defined in Text.Libyaml Methods succ :: EventType -> EventType # pred :: EventType -> EventType # toEnum :: Int -> EventType # fromEnum :: EventType -> Int # enumFrom :: EventType -> [EventType] # enumFromThen :: EventType -> EventType -> [EventType] # enumFromTo :: EventType -> EventType -> [EventType] # enumFromThenTo :: EventType -> EventType -> EventType -> [EventType] #
Enum MappingStyle
Instance details Defined in Text.Libyaml Methods succ :: MappingStyle -> MappingStyle # pred :: MappingStyle -> MappingStyle # toEnum :: Int -> MappingStyle # fromEnum :: MappingStyle -> Int # enumFrom :: MappingStyle -> [MappingStyle] # enumFromThen :: MappingStyle -> MappingStyle -> [MappingStyle] # enumFromTo :: MappingStyle -> MappingStyle -> [MappingStyle] # enumFromThenTo :: MappingStyle -> MappingStyle -> MappingStyle -> [MappingStyle] #
Enum SequenceStyle
Instance details Defined in Text.Libyaml Methods succ :: SequenceStyle -> SequenceStyle # pred :: SequenceStyle -> SequenceStyle # toEnum :: Int -> SequenceStyle # fromEnum :: SequenceStyle -> Int # enumFrom :: SequenceStyle -> [SequenceStyle] # enumFromThen :: SequenceStyle -> SequenceStyle -> [SequenceStyle] # enumFromTo :: SequenceStyle -> SequenceStyle -> [SequenceStyle] # enumFromThenTo :: SequenceStyle -> SequenceStyle -> SequenceStyle -> [SequenceStyle] #
Enum Style
Instance details Defined in Text.Libyaml Methods succ :: Style -> Style # pred :: Style -> Style # toEnum :: Int -> Style # fromEnum :: Style -> Int # enumFrom :: Style -> [Style] # enumFromThen :: Style -> Style -> [Style] # enumFromTo :: Style -> Style -> [Style] # enumFromThenTo :: Style -> Style -> Style -> [Style] #
Enum TagRender
Instance details Defined in Text.Libyaml Methods succ :: TagRender -> TagRender # pred :: TagRender -> TagRender # toEnum :: Int -> TagRender # fromEnum :: TagRender -> Int # enumFrom :: TagRender -> [TagRender] # enumFromThen :: TagRender -> TagRender -> [TagRender] # enumFromTo :: TagRender -> TagRender -> [TagRender] # enumFromThenTo :: TagRender -> TagRender -> TagRender -> [TagRender] #
Enum PortNumber
Instance details Defined in Network.Socket.Types Methods succ :: PortNumber -> PortNumber # pred :: PortNumber -> PortNumber # toEnum :: Int -> PortNumber # fromEnum :: PortNumber -> Int # enumFrom :: PortNumber -> [PortNumber] # enumFromThen :: PortNumber -> PortNumber -> [PortNumber] # enumFromTo :: PortNumber -> PortNumber -> [PortNumber] # enumFromThenTo :: PortNumber -> PortNumber -> PortNumber -> [PortNumber] #
Enum Checkmark
Instance details Defined in Database.Persist.Types.Base Methods succ :: Checkmark -> Checkmark # pred :: Checkmark -> Checkmark # toEnum :: Int -> Checkmark # fromEnum :: Checkmark -> Int # enumFrom :: Checkmark -> [Checkmark] # enumFromThen :: Checkmark -> Checkmark -> [Checkmark] # enumFromTo :: Checkmark -> Checkmark -> [Checkmark] # enumFromThenTo :: Checkmark -> Checkmark -> Checkmark -> [Checkmark] #
Enum VarType
Instance details Defined in Text.Shakespeare Methods succ :: VarType -> VarType # pred :: VarType -> VarType # toEnum :: Int -> VarType # fromEnum :: VarType -> Int # enumFrom :: VarType -> [VarType] # enumFromThen :: VarType -> VarType -> [VarType] # enumFromTo :: VarType -> VarType -> [VarType] # enumFromThenTo :: VarType -> VarType -> VarType -> [VarType] #
Enum Day
Instance details Defined in Data.Time.Calendar.Days Methods succ :: Day -> Day # pred :: Day -> Day # toEnum :: Int -> Day # fromEnum :: Day -> Int # enumFrom :: Day -> [Day] # enumFromThen :: Day -> Day -> [Day] # enumFromTo :: Day -> Day -> [Day] # enumFromThenTo :: Day -> Day -> Day -> [Day] #
Enum DayOfWeek	"Circular", so for example `[Tuesday ..]` gives an endless sequence. Also: `fromEnum` gives [1 .. 7] for [Monday .. Sunday], and `toEnum` performs mod 7 to give a cycle of days.
Instance details Defined in Data.Time.Calendar.Week Methods succ :: DayOfWeek -> DayOfWeek # pred :: DayOfWeek -> DayOfWeek # toEnum :: Int -> DayOfWeek # fromEnum :: DayOfWeek -> Int # enumFrom :: DayOfWeek -> [DayOfWeek] # enumFromThen :: DayOfWeek -> DayOfWeek -> [DayOfWeek] # enumFromTo :: DayOfWeek -> DayOfWeek -> [DayOfWeek] # enumFromThenTo :: DayOfWeek -> DayOfWeek -> DayOfWeek -> [DayOfWeek] #
Enum DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods succ :: DiffTime -> DiffTime # pred :: DiffTime -> DiffTime # toEnum :: Int -> DiffTime # fromEnum :: DiffTime -> Int # enumFrom :: DiffTime -> [DiffTime] # enumFromThen :: DiffTime -> DiffTime -> [DiffTime] # enumFromTo :: DiffTime -> DiffTime -> [DiffTime] # enumFromThenTo :: DiffTime -> DiffTime -> DiffTime -> [DiffTime] #
Enum NominalDiffTime
Instance details Defined in Data.Time.Clock.Internal.NominalDiffTime Methods succ :: NominalDiffTime -> NominalDiffTime # pred :: NominalDiffTime -> NominalDiffTime # toEnum :: Int -> NominalDiffTime # fromEnum :: NominalDiffTime -> Int # enumFrom :: NominalDiffTime -> [NominalDiffTime] # enumFromThen :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromTo :: NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] # enumFromThenTo :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime -> [NominalDiffTime] #
Enum DefaultEnv
Instance details Defined in Yesod.Default.Config Methods succ :: DefaultEnv -> DefaultEnv # pred :: DefaultEnv -> DefaultEnv # toEnum :: Int -> DefaultEnv # fromEnum :: DefaultEnv -> Int # enumFrom :: DefaultEnv -> [DefaultEnv] # enumFromThen :: DefaultEnv -> DefaultEnv -> [DefaultEnv] # enumFromTo :: DefaultEnv -> DefaultEnv -> [DefaultEnv] # enumFromThenTo :: DefaultEnv -> DefaultEnv -> DefaultEnv -> [DefaultEnv] #
Enum Enctype
Instance details Defined in Yesod.Form.Types Methods succ :: Enctype -> Enctype # pred :: Enctype -> Enctype # toEnum :: Int -> Enctype # fromEnum :: Enctype -> Int # enumFrom :: Enctype -> [Enctype] # enumFromThen :: Enctype -> Enctype -> [Enctype] # enumFromTo :: Enctype -> Enctype -> [Enctype] # enumFromThenTo :: Enctype -> Enctype -> Enctype -> [Enctype] #
Enum CompressionStrategy
Instance details Defined in Codec.Compression.Zlib.Stream Methods succ :: CompressionStrategy -> CompressionStrategy # pred :: CompressionStrategy -> CompressionStrategy # toEnum :: Int -> CompressionStrategy # fromEnum :: CompressionStrategy -> Int # enumFrom :: CompressionStrategy -> [CompressionStrategy] # enumFromThen :: CompressionStrategy -> CompressionStrategy -> [CompressionStrategy] # enumFromTo :: CompressionStrategy -> CompressionStrategy -> [CompressionStrategy] # enumFromThenTo :: CompressionStrategy -> CompressionStrategy -> CompressionStrategy -> [CompressionStrategy] #
Enum Format
Instance details Defined in Codec.Compression.Zlib.Stream Methods succ :: Format -> Format # pred :: Format -> Format # toEnum :: Int -> Format # fromEnum :: Format -> Int # enumFrom :: Format -> [Format] # enumFromThen :: Format -> Format -> [Format] # enumFromTo :: Format -> Format -> [Format] # enumFromThenTo :: Format -> Format -> Format -> [Format] #
Enum Method
Instance details Defined in Codec.Compression.Zlib.Stream Methods succ :: Method -> Method # pred :: Method -> Method # toEnum :: Int -> Method # fromEnum :: Method -> Int # enumFrom :: Method -> [Method] # enumFromThen :: Method -> Method -> [Method] # enumFromTo :: Method -> Method -> [Method] # enumFromThenTo :: Method -> Method -> Method -> [Method] #
Enum Integer	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Enum Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Enum Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Enum ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: () -> () # pred :: () -> () # toEnum :: Int -> () # fromEnum :: () -> Int # enumFrom :: () -> [()] # enumFromThen :: () -> () -> [()] # enumFromTo :: () -> () -> [()] # enumFromThenTo :: () -> () -> () -> [()] #
Enum Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Bool -> Bool # pred :: Bool -> Bool # toEnum :: Int -> Bool # fromEnum :: Bool -> Int # enumFrom :: Bool -> [Bool] # enumFromThen :: Bool -> Bool -> [Bool] # enumFromTo :: Bool -> Bool -> [Bool] # enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #
Enum Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Char -> Char # pred :: Char -> Char # toEnum :: Int -> Char # fromEnum :: Char -> Int # enumFrom :: Char -> [Char] # enumFromThen :: Char -> Char -> [Char] # enumFromTo :: Char -> Char -> [Char] # enumFromThenTo :: Char -> Char -> Char -> [Char] #
Enum Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Int -> Int # pred :: Int -> Int # toEnum :: Int -> Int # fromEnum :: Int -> Int # enumFrom :: Int -> [Int] # enumFromThen :: Int -> Int -> [Int] # enumFromTo :: Int -> Int -> [Int] # enumFromThenTo :: Int -> Int -> Int -> [Int] #
Enum Levity	Since: base-4.16.0.0
Instance details Defined in GHC.Enum Methods succ :: Levity -> Levity # pred :: Levity -> Levity # toEnum :: Int -> Levity # fromEnum :: Levity -> Int # enumFrom :: Levity -> [Levity] # enumFromThen :: Levity -> Levity -> [Levity] # enumFromTo :: Levity -> Levity -> [Levity] # enumFromThenTo :: Levity -> Levity -> Levity -> [Levity] #
Enum VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # toEnum :: Int -> VecCount # fromEnum :: VecCount -> Int # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] #
Enum VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecElem -> VecElem # pred :: VecElem -> VecElem # toEnum :: Int -> VecElem # fromEnum :: VecElem -> Int # enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Word -> Word # pred :: Word -> Word # toEnum :: Int -> Word # fromEnum :: Word -> Int # enumFrom :: Word -> [Word] # enumFromThen :: Word -> Word -> [Word] # enumFromTo :: Word -> Word -> [Word] # enumFromThenTo :: Word -> Word -> Word -> [Word] #
Integral i => Enum (DecimalRaw i)
Instance details Defined in Data.Decimal Methods succ :: DecimalRaw i -> DecimalRaw i # pred :: DecimalRaw i -> DecimalRaw i # toEnum :: Int -> DecimalRaw i # fromEnum :: DecimalRaw i -> Int # enumFrom :: DecimalRaw i -> [DecimalRaw i] # enumFromThen :: DecimalRaw i -> DecimalRaw i -> [DecimalRaw i] # enumFromTo :: DecimalRaw i -> DecimalRaw i -> [DecimalRaw i] # enumFromThenTo :: DecimalRaw i -> DecimalRaw i -> DecimalRaw i -> [DecimalRaw i] #
Enum a => Enum (Identity a)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] #
Enum a => Enum (First a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: First a -> First a # pred :: First a -> First a # toEnum :: Int -> First a # fromEnum :: First a -> Int # enumFrom :: First a -> [First a] # enumFromThen :: First a -> First a -> [First a] # enumFromTo :: First a -> First a -> [First a] # enumFromThenTo :: First a -> First a -> First a -> [First a] #
Enum a => Enum (Last a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Last a -> Last a # pred :: Last a -> Last a # toEnum :: Int -> Last a # fromEnum :: Last a -> Int # enumFrom :: Last a -> [Last a] # enumFromThen :: Last a -> Last a -> [Last a] # enumFromTo :: Last a -> Last a -> [Last a] # enumFromThenTo :: Last a -> Last a -> Last a -> [Last a] #
Enum a => Enum (Max a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Max a -> Max a # pred :: Max a -> Max a # toEnum :: Int -> Max a # fromEnum :: Max a -> Int # enumFrom :: Max a -> [Max a] # enumFromThen :: Max a -> Max a -> [Max a] # enumFromTo :: Max a -> Max a -> [Max a] # enumFromThenTo :: Max a -> Max a -> Max a -> [Max a] #
Enum a => Enum (Min a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: Min a -> Min a # pred :: Min a -> Min a # toEnum :: Int -> Min a # fromEnum :: Min a -> Int # enumFrom :: Min a -> [Min a] # enumFromThen :: Min a -> Min a -> [Min a] # enumFromTo :: Min a -> Min a -> [Min a] # enumFromThenTo :: Min a -> Min a -> Min a -> [Min a] #
Enum a => Enum (WrappedMonoid a)	Since: base-4.9.0.0
Instance details Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] #
Integral a => Enum (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods succ :: Ratio a -> Ratio a # pred :: Ratio a -> Ratio a # toEnum :: Int -> Ratio a # fromEnum :: Ratio a -> Int # enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] #
SizeValid n => Enum (Bits n)
Instance details Defined in Basement.Bits Methods succ :: Bits n -> Bits n # pred :: Bits n -> Bits n # toEnum :: Int -> Bits n # fromEnum :: Bits n -> Int # enumFrom :: Bits n -> [Bits n] # enumFromThen :: Bits n -> Bits n -> [Bits n] # enumFromTo :: Bits n -> Bits n -> [Bits n] # enumFromThenTo :: Bits n -> Bits n -> Bits n -> [Bits n] #
Enum (CountOf ty)
Instance details Defined in Basement.Types.OffsetSize Methods succ :: CountOf ty -> CountOf ty # pred :: CountOf ty -> CountOf ty # toEnum :: Int -> CountOf ty # fromEnum :: CountOf ty -> Int # enumFrom :: CountOf ty -> [CountOf ty] # enumFromThen :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromTo :: CountOf ty -> CountOf ty -> [CountOf ty] # enumFromThenTo :: CountOf ty -> CountOf ty -> CountOf ty -> [CountOf ty] #
Enum (Offset ty)
Instance details Defined in Basement.Types.OffsetSize Methods succ :: Offset ty -> Offset ty # pred :: Offset ty -> Offset ty # toEnum :: Int -> Offset ty # fromEnum :: Offset ty -> Int # enumFrom :: Offset ty -> [Offset ty] # enumFromThen :: Offset ty -> Offset ty -> [Offset ty] # enumFromTo :: Offset ty -> Offset ty -> [Offset ty] # enumFromThenTo :: Offset ty -> Offset ty -> Offset ty -> [Offset ty] #
Enum a => Enum (a)
Instance details Defined in GHC.Enum Methods succ :: (a) -> (a) # pred :: (a) -> (a) # toEnum :: Int -> (a) # fromEnum :: (a) -> Int # enumFrom :: (a) -> [(a)] # enumFromThen :: (a) -> (a) -> [(a)] # enumFromTo :: (a) -> (a) -> [(a)] # enumFromThenTo :: (a) -> (a) -> (a) -> [(a)] #
Enum (Fixed a)	Recall that, for numeric types, `succ` and `pred` typically add and subtract `1`, respectively. This is not true in the case of `Fixed`, whose successor and predecessor functions intuitively return the "next" and "previous" values in the enumeration. The results of these functions thus depend on the resolution of the `Fixed` value. For example, when enumerating values of resolution `10^-3` of `type Milli = Fixed E3`, succ (0.000 :: Milli) == 1.001 and likewise pred (0.000 :: Milli) == -0.001 In other words, `succ` and `pred` increment and decrement a fixed-precision value by the least amount such that the value's resolution is unchanged. For example, `10^-12` is the smallest (positive) amount that can be added to a value of `type Pico = Fixed E12` without changing its resolution, and so succ (0.000000000000 :: Pico) == 0.000000000001 and similarly pred (0.000000000000 :: Pico) == -0.000000000001 This is worth bearing in mind when defining `Fixed` arithmetic sequences. In particular, you may be forgiven for thinking the sequence [1..10] :: [Pico] evaluates to `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] :: [Pico]`. However, this is not true. On the contrary, similarly to the above implementations of `succ` and `pred`, `enumFromTo :: Pico -> Pico -> [Pico]` has a "step size" of `10^-12`. Hence, the list `[1..10] :: [Pico]` has the form [1.000000000000, 1.00000000001, 1.00000000002, ..., 10.000000000000] and contains `9 * 10^12 + 1` values. Since: base-2.1
Instance details Defined in Data.Fixed Methods succ :: Fixed a -> Fixed a # pred :: Fixed a -> Fixed a # toEnum :: Int -> Fixed a # fromEnum :: Fixed a -> Int # enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] #
Enum (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods succ :: Proxy s -> Proxy s # pred :: Proxy s -> Proxy s # toEnum :: Int -> Proxy s # fromEnum :: Proxy s -> Int # enumFrom :: Proxy s -> [Proxy s] # enumFromThen :: Proxy s -> Proxy s -> [Proxy s] # enumFromTo :: Proxy s -> Proxy s -> [Proxy s] # enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s] #
Enum a => Enum (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # toEnum :: Int -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] #
Enum (f a) => Enum (Ap f a)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods succ :: Ap f a -> Ap f a # pred :: Ap f a -> Ap f a # toEnum :: Int -> Ap f a # fromEnum :: Ap f a -> Int # enumFrom :: Ap f a -> [Ap f a] # enumFromThen :: Ap f a -> Ap f a -> [Ap f a] # enumFromTo :: Ap f a -> Ap f a -> [Ap f a] # enumFromThenTo :: Ap f a -> Ap f a -> Ap f a -> [Ap f a] #
Enum (f a) => Enum (Alt f a)	Since: base-4.8.0.0
Instance details Defined in Data.Semigroup.Internal Methods succ :: Alt f a -> Alt f a # pred :: Alt f a -> Alt f a # toEnum :: Int -> Alt f a # fromEnum :: Alt f a -> Int # enumFrom :: Alt f a -> [Alt f a] # enumFromThen :: Alt f a -> Alt f a -> [Alt f a] # enumFromTo :: Alt f a -> Alt f a -> [Alt f a] # enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] #
Enum a => Enum (Tagged s a)
Instance details Defined in Data.Tagged Methods succ :: Tagged s a -> Tagged s a # pred :: Tagged s a -> Tagged s a # toEnum :: Int -> Tagged s a # fromEnum :: Tagged s a -> Int # enumFrom :: Tagged s a -> [Tagged s a] # enumFromThen :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromTo :: Tagged s a -> Tagged s a -> [Tagged s a] # enumFromThenTo :: Tagged s a -> Tagged s a -> Tagged s a -> [Tagged s a] #

class Eq a where #

The Eq class defines equality (==) and inequality (/=). All the basic datatypes exported by the Prelude are instances of Eq, and Eq may be derived for any datatype whose constituents are also instances of Eq.

The Haskell Report defines no laws for Eq. However, instances are encouraged to follow these properties:

Reflexivity: x == x = True
Symmetry: x == y = y == x
Transitivity: if x == y && y == z = True, then x == z = True
Extensionality: if x == y = True and f is a function whose return type is an instance of Eq, then f x == f y = True
Negation: x /= y = not (x == y)

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Methods

(==) :: a -> a -> Bool infix 4 #

(/=) :: a -> a -> Bool infix 4 #

Instances

Instances details

Eq Key
Instance details Defined in Data.Aeson.Key Methods (==) :: Key -> Key -> Bool # (/=) :: Key -> Key -> Bool #
Eq DotNetTime
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: DotNetTime -> DotNetTime -> Bool # (/=) :: DotNetTime -> DotNetTime -> Bool #
Eq JSONPathElement
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: JSONPathElement -> JSONPathElement -> Bool # (/=) :: JSONPathElement -> JSONPathElement -> Bool #
Eq SumEncoding
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: SumEncoding -> SumEncoding -> Bool # (/=) :: SumEncoding -> SumEncoding -> Bool #
Eq Value
Instance details Defined in Data.Aeson.Types.Internal Methods (==) :: Value -> Value -> Bool # (/=) :: Value -> Value -> Bool #
Eq More
Instance details Defined in Data.Attoparsec.Internal.Types Methods (==) :: More -> More -> Bool # (/=) :: More -> More -> Bool #
Eq Pos
Instance details Defined in Data.Attoparsec.Internal.Types Methods (==) :: Pos -> Pos -> Bool # (/=) :: Pos -> Pos -> Bool #
Eq All	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Eq Any	Since: base-2.1
Instance details Defined in Data.Semigroup.Internal Methods (==) :: Any -> Any -> Bool # (/=) :: Any -> Any -> Bool #
Eq SomeTypeRep
Instance details Defined in Data.Typeable.Internal Methods (==) :: SomeTypeRep -> SomeTypeRep -> Bool # (/=) :: SomeTypeRep -> SomeTypeRep -> Bool #
Eq Version	Since: base-2.1
Instance details Defined in Data.Version Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Eq Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Eq CBool
Instance details Defined in Foreign.C.Types Methods (==) :: CBool -> CBool -> Bool # (/=) :: CBool -> CBool -> Bool #
Eq CChar
Instance details Defined in Foreign.C.Types Methods (==) :: CChar -> CChar -> Bool # (/=) :: CChar -> CChar -> Bool #
Eq CClock
Instance details Defined in Foreign.C.Types Methods (==) :: CClock -> CClock -> Bool # (/=) :: CClock -> CClock -> Bool #
Eq CDouble
Instance details Defined in Foreign.C.Types Methods (==) :: CDouble -> CDouble -> Bool # (/=) :: CDouble -> CDouble -> Bool #
Eq CFloat
Instance details Defined in Foreign.C.Types Methods (==) :: CFloat -> CFloat -> Bool # (/=) :: CFloat -> CFloat -> Bool #
Eq CInt
Instance details Defined in Foreign.C.Types Methods (==) :: CInt -> CInt -> Bool # (/=) :: CInt -> CInt -> Bool #
Eq CIntMax
Instance details Defined in Foreign.C.Types Methods (==) :: CIntMax -> CIntMax -> Bool # (/=) :: CIntMax -> CIntMax -> Bool #
Eq CIntPtr
Instance details Defined in Foreign.C.Types Methods (==) :: CIntPtr -> CIntPtr -> Bool # (/=) :: CIntPtr -> CIntPtr -> Bool #
Eq CLLong
Instance details Defined in Foreign.C.Types Methods (==) :: CLLong -> CLLong -> Bool # (/=) :: CLLong -> CLLong -> Bool #
Eq CLong
Instance details Defined in Foreign.C.Types Methods (==) :: CLong -> CLong -> Bool # (/=) :: CLong -> CLong -> Bool #
Eq CPtrdiff
Instance details Defined in Foreign.C.Types Methods (==) :: CPtrdiff -> CPtrdiff -> Bool # (/=) :: CPtrdiff -> CPtrdiff -> Bool #
Eq CSChar
Instance details Defined in Foreign.C.Types Methods (==) :: CSChar -> CSChar -> Bool # (/=) :: CSChar -> CSChar -> Bool #
Eq CSUSeconds
Instance details Defined in Foreign.C.Types Methods (==) :: CSUSeconds -> CSUSeconds -> Bool # (/=) :: CSUSeconds -> CSUSeconds -> Bool #
Eq CShort
Instance details Defined in Foreign.C.Types Methods (==) :: CShort -> CShort -> Bool # (/=) :: CShort -> CShort -> Bool #
Eq CSigAtomic
Instance details Defined in Foreign.C.Types Methods (==) :: CSigAtomic -> CSigAtomic -> Bool # (/=) :: CSigAtomic -> CSigAtomic -> Bool #
Eq CSize
Instance details Defined in Foreign.C.Types Methods (==) :: CSize -> CSize -> Bool # (/=) :: CSize -> CSize -> Bool #
Eq CTime
Instance details Defined in Foreign.C.Types Methods (==) :: CTime -> CTime -> Bool # (/=) :: CTime -> CTime -> Bool #
Eq CUChar
Instance details Defined in Foreign.C.Types Methods (==) :: CUChar -> CUChar -> Bool # (/=) :: CUChar -> CUChar -> Bool #
Eq CUInt
Instance details Defined in Foreign.C.Types Methods (==) :: CUInt -> CUInt -> Bool # (/=) :: CUInt -> CUInt -> Bool #
Eq