IHP Api Reference| Safe Haskell | Safe-Inferred |
|---|
IHP.Prelude
Synopsis
- seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- otherwise :: Bool
- ($) :: 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
- class Bounded a where
- 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
- class Fractional a => Floating a where
- class Num a => Fractional a where
- (/) :: a -> a -> a
- recip :: a -> a
- fromRational :: Rational -> a
- class (Real a, Enum a) => Integral a where
- class Applicative m => Monad (m :: Type -> Type) where
- class Functor (f :: Type -> Type) where
- class Num a where
- class Eq a => Ord a where
- class Read 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
- class Show a
- class Typeable (a :: k)
- class IsString a where
- fromString :: String -> a
- class Functor f => Applicative (f :: Type -> Type) where
- class Foldable (t :: TYPE LiftedRep -> Type)
- class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
- (<>) :: Semigroup a => a -> a -> a
- class Semigroup a => Monoid a where
- data Bool
- type String = [Char]
- data Char
- data Double
- data Float
- data Int
- data Int32
- data Int64
- data Integer
- data Maybe a
- data Ordering
- type Rational = Ratio Integer
- data IO a
- data Word
- data Word8
- data Word32
- data Word64
- data Either a b
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- bool :: a -> a -> Bool -> a
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- lefts :: [Either a b] -> [a]
- partitionEithers :: [Either a b] -> ([a], [b])
- rights :: [Either a b] -> [b]
- asum :: (Foldable t, Alternative f) => t (f a) -> f a
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- fromMaybe :: a -> Maybe a -> a
- isJust :: Maybe a -> Bool
- isNothing :: Maybe a -> Bool
- listToMaybe :: [a] -> Maybe a
- mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- maybe :: b -> (a -> b) -> Maybe a -> b
- maybeToList :: Maybe a -> [a]
- comparing :: Ord a => (b -> a) -> b -> b -> Ordering
- curry :: ((a, b) -> c) -> a -> b -> c
- swap :: (a, b) -> (b, a)
- uncurry :: (a -> b -> c) -> (a, b) -> c
- ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- asTypeOf :: a -> a -> a
- const :: a -> b -> a
- flip :: (a -> b -> c) -> b -> a -> c
- until :: (a -> Bool) -> (a -> a) -> a -> a
- ioError :: IOError -> IO a
- userError :: String -> IOError
- subtract :: Num a => a -> a -> a
- (^) :: (Num a, Integral b) => a -> b -> a
- (^^) :: (Fractional a, Integral b) => a -> b -> a
- even :: Integral a => a -> Bool
- odd :: Integral a => a -> Bool
- alreadyExistsErrorType :: IOErrorType
- alreadyInUseErrorType :: IOErrorType
- annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
- doesNotExistErrorType :: IOErrorType
- eofErrorType :: IOErrorType
- fullErrorType :: IOErrorType
- illegalOperationErrorType :: IOErrorType
- ioeGetErrorString :: IOError -> String
- ioeGetErrorType :: IOError -> IOErrorType
- ioeGetFileName :: IOError -> Maybe FilePath
- ioeGetHandle :: IOError -> Maybe Handle
- ioeGetLocation :: IOError -> String
- ioeSetErrorString :: IOError -> String -> IOError
- ioeSetErrorType :: IOError -> IOErrorType -> IOError
- ioeSetFileName :: IOError -> FilePath -> IOError
- ioeSetHandle :: IOError -> Handle -> IOError
- ioeSetLocation :: IOError -> String -> IOError
- isAlreadyExistsError :: IOError -> Bool
- isAlreadyExistsErrorType :: IOErrorType -> Bool
- isAlreadyInUseError :: IOError -> Bool
- isAlreadyInUseErrorType :: IOErrorType -> Bool
- isDoesNotExistError :: IOError -> Bool
- isDoesNotExistErrorType :: IOErrorType -> Bool
- isEOFError :: IOError -> Bool
- isEOFErrorType :: IOErrorType -> Bool
- isFullError :: IOError -> Bool
- isFullErrorType :: IOErrorType -> Bool
- isIllegalOperation :: IOError -> Bool
- isIllegalOperationErrorType :: IOErrorType -> Bool
- isPermissionError :: IOError -> Bool
- isPermissionErrorType :: IOErrorType -> Bool
- isResourceVanishedError :: IOError -> Bool
- isResourceVanishedErrorType :: IOErrorType -> Bool
- isUserError :: IOError -> Bool
- isUserErrorType :: IOErrorType -> Bool
- mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError
- modifyIOError :: (IOError -> IOError) -> IO a -> IO a
- permissionErrorType :: IOErrorType
- resourceVanishedErrorType :: IOErrorType
- tryIOError :: IO a -> IO (Either IOError a)
- userErrorType :: IOErrorType
- equating :: Eq a => (b -> a) -> b -> b -> Bool
- getArgs :: MonadIO m => m [Text]
- terror :: HasCallStack => Text -> a
- (<.>) :: FilePath -> String -> FilePath
- (</>) :: FilePath -> FilePath -> FilePath
- (&&) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- second :: Arrow a => a b c -> a (d, b) (d, c)
- first :: Arrow a => a b c -> a (b, d) (c, d)
- (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
- (***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
- (.) :: forall (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- id :: forall (a :: k). Category cat => cat a a
- class Monad m => MonadIO (m :: Type -> Type) where
- newtype Down a = Down {
- getDown :: a
- class Storable a
- (<|>) :: Alternative f => f a -> f a -> f a
- class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- data SomeException
- type FilePath = String
- type IOError = IOException
- data IOErrorType
- data IOException
- type LByteString = ByteString
- type LText = Text
- type SVector = Vector
- type UVector = Vector
- data ByteString
- data IntMap a
- data IntSet
- data Map k a
- data Seq a
- data Set a
- class Eq a => Hashable a where
- hashWithSalt :: Int -> a -> Int
- hash :: a -> Int
- data Text
- lift :: (MonadTrans t, Monad m) => m a -> t m a
- data HashMap k v
- data HashSet a
- data Vector a
- class (Vector Vector a, MVector MVector a) => Unbox a
- undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- catMaybes :: [Maybe a] -> [a]
- catchIOError :: IO a -> (IOError -> IO a) -> IO a
- putStr :: Text -> IO ()
- putStrLn :: Text -> IO ()
- module IHP.HaskellSupport
- data UUID
- class Default a where
- def :: a
- tshow :: Show a => a -> Text
- data Proxy (t :: k) = Proxy
- join :: Monad m => m (m a) -> m a
- mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- forever :: Applicative f => f a -> f b
- unless :: Applicative f => Bool -> f () -> f ()
- forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- when :: Applicative f => Bool -> f () -> f ()
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- filter :: (a -> Bool) -> [a] -> [a]
- zip :: [a] -> [b] -> [(a, b)]
- map :: (a -> b) -> [a] -> [b]
- foldr1 :: Foldable t => (a -> a -> a) -> t a -> a
- foldl1 :: Foldable t => (a -> a -> a) -> t a -> a
- foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
- minimum :: (Foldable t, Ord a) => t a -> a
- maximum :: (Foldable t, Ord a) => t a -> a
- sum :: (Foldable t, Num a) => t a -> a
- product :: (Foldable t, Num a) => t a -> a
- length :: Foldable t => t a -> Int
- foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
- elem :: (Foldable t, Eq a) => a -> t a -> Bool
- foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
- repeat :: a -> [a]
- transpose :: [[a]] -> [[a]]
- genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
- break :: (a -> Bool) -> [a] -> ([a], [a])
- dropWhile :: (a -> Bool) -> [a] -> [a]
- groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
- span :: (a -> Bool) -> [a] -> ([a], [a])
- takeWhile :: (a -> Bool) -> [a] -> [a]
- and :: Foldable t => t Bool -> Bool
- concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- notElem :: (Foldable t, Eq a) => a -> t a -> Bool
- or :: Foldable t => t Bool -> Bool
- (!!) :: [a] -> Int -> a
- cycle :: [a] -> [a]
- iterate :: (a -> a) -> a -> [a]
- lookup :: Eq a => a -> [(a, b)] -> Maybe b
- scanl :: (b -> a -> b) -> b -> [a] -> [b]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- scanr :: (a -> b -> b) -> b -> [a] -> [b]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- unzip :: [(a, b)] -> ([a], [b])
- unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- genericReplicate :: Integral i => i -> a -> [a]
- take :: Int -> [a] -> [a]
- drop :: Int -> [a] -> [a]
- partition :: (a -> Bool) -> [a] -> ([a], [a])
- replicate :: Int -> a -> [a]
- reverse :: [a] -> [a]
- stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
- deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
- delete :: Eq a => a -> [a] -> [a]
- findIndices :: (a -> Bool) -> [a] -> [Int]
- zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
- zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
- zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
- zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
- all :: Foldable t => (a -> Bool) -> t a -> Bool
- any :: Foldable t => (a -> Bool) -> t a -> Bool
- concat :: Foldable t => t [a] -> [a]
- foldl1' :: (a -> a -> a) -> [a] -> a
- iterate' :: (a -> a) -> a -> [a]
- scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- uncons :: [a] -> Maybe (a, [a])
- find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
- minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
- isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
- (\\) :: Eq a => [a] -> [a] -> [a]
- deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- dropWhileEnd :: (a -> Bool) -> [a] -> [a]
- elemIndex :: Eq a => a -> [a] -> Maybe Int
- elemIndices :: Eq a => a -> [a] -> [Int]
- findIndex :: (a -> Bool) -> [a] -> Maybe Int
- genericDrop :: Integral i => i -> [a] -> [a]
- genericIndex :: Integral i => [a] -> i -> a
- genericLength :: Num i => [a] -> i
- genericTake :: Integral i => i -> [a] -> [a]
- group :: Eq a => [a] -> [[a]]
- inits :: [a] -> [[a]]
- insert :: Ord a => a -> [a] -> [a]
- insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
- intersect :: Eq a => [a] -> [a] -> [a]
- nub :: Eq a => [a] -> [a]
- nubBy :: (a -> a -> Bool) -> [a] -> [a]
- permutations :: [a] -> [[a]]
- singleton :: a -> [a]
- sort :: Ord a => [a] -> [a]
- sortOn :: Ord b => (a -> b) -> [a] -> [a]
- subsequences :: [a] -> [[a]]
- tails :: [a] -> [[a]]
- unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- union :: Eq a => [a] -> [a] -> [a]
- unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
- unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
- unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
- unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
- zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
- zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
- zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
- zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
- mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
- mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
- head :: [a] -> Maybe a
- headMay :: [a] -> Maybe a
- last :: [a] -> Maybe a
- lastMay :: [a] -> Maybe a
- tail :: [a] -> Maybe [a]
- tailMay :: [a] -> Maybe [a]
- init :: [a] -> Maybe [a]
- initMay :: [a] -> Maybe [a]
- show :: Show a => a -> Text
- cs :: ConvertibleStrings a b => a -> b
- class ConvertibleStrings a b where
- convertString :: a -> b
- intercalate :: Text -> [Text] -> Text
- intersperse :: Char -> Text -> Text
- isInfixOf :: Text -> Text -> Bool
- isPrefixOf :: Text -> Text -> Bool
- isSuffixOf :: Text -> Text -> Bool
- lines :: Text -> [Text]
- splitAt :: Int -> Text -> (Text, Text)
- toLower :: Text -> Text
- toUpper :: Text -> Text
- unlines :: [Text] -> Text
- unwords :: [Text] -> Text
- words :: Text -> [Text]
- plain :: QuasiQuoter
- (++) :: Semigroup a => a -> a -> a
- error :: Text -> a
- class Typeable a => Data a
- class KnownSymbol (n :: Symbol)
- data Symbol
- symbolVal :: forall (n :: Symbol) proxy. KnownSymbol n => proxy n -> String
- module IHP.NameSupport
- data MetaBag = MetaBag {
- annotations :: ![(Text, Violation)]
- touchedFields :: ![Text]
- originalDatabaseRecord :: Maybe Dynamic
- type NormalizeModel model = GetModelByTableName (GetTableName model)
- type Id model = Id' (GetTableName model)
- type family GetModelName model :: Symbol
- class CanUpdate a where
- updateRecord :: (?modelContext :: ModelContext) => a -> IO a
- type family GetTableName model :: Symbol
- data ModelContext = ModelContext {
- connectionPool :: Pool Connection
- transactionConnection :: Maybe Connection
- logger :: Logger
- trackTableReadCallback :: Maybe (ByteString -> IO ())
- rowLevelSecurity :: Maybe RowLevelSecurityContext
- createRecord :: (?modelContext :: ModelContext, CanCreate model) => model -> IO model
- deleteRecord :: forall record table. (?modelContext :: ModelContext, Show (PrimaryKey table), Table record, HasField "id" record (Id' table), ToField (PrimaryKey table), GetModelByTableName table ~ record, Show (PrimaryKey table), ToField (PrimaryKey table)) => record -> IO ()
- type TMap = TypeRepMap Identity
- class FromRow a
- null :: MonoFoldable mono => mono -> Bool
- catch :: Exception e => IO a -> (e -> IO a) -> IO a
- throwIO :: Exception e => e -> IO a
- throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
- fail :: MonadFail m => String -> m a
- trimming :: QuasiQuoter
- data CallStack
- type HasCallStack = ?callStack :: CallStack
Documentation
fromIntegral :: (Integral a, Num b) => a -> b #
realToFrac :: (Real a, Fractional b) => a -> b #
Instances
Methods
enumFromThen :: a -> a -> [a] #
enumFromTo :: a -> a -> [a] #
enumFromThenTo :: a -> a -> a -> [a] #
Instances
| Enum Arity | |
Defined in Data.Aeson.TH | |
| Enum CBool | |
Defined in Foreign.C.Types | |
| Enum CChar | |
Defined in Foreign.C.Types | |
| Enum CClock | |
Defined in Foreign.C.Types | |
| Enum CDouble | |
Defined in Foreign.C.Types Methods enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] # | |
| Enum CFloat | |
Defined in Foreign.C.Types | |
| Enum CInt | |
Defined in Foreign.C.Types | |
| Enum CIntMax | |
Defined in Foreign.C.Types Methods enumFrom :: CIntMax -> [CIntMax] # enumFromThen :: CIntMax -> CIntMax -> [CIntMax] # enumFromTo :: CIntMax -> CIntMax -> [CIntMax] # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] # | |
| Enum CIntPtr | |
Defined in Foreign.C.Types Methods enumFrom :: CIntPtr -> [CIntPtr] # enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] # | |
| Enum CLLong | |
Defined in Foreign.C.Types | |
| Enum CLong | |
Defined in Foreign.C.Types | |
| Enum CPtrdiff | |
Defined in Foreign.C.Types Methods succ :: CPtrdiff -> CPtrdiff # pred :: CPtrdiff -> CPtrdiff # enumFrom :: CPtrdiff -> [CPtrdiff] # enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff] # | |
| Enum CSChar | |
Defined in Foreign.C.Types | |
| Enum CSUSeconds | |
Defined in Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] # | |
| Enum CShort | |
Defined in Foreign.C.Types | |
| Enum CSigAtomic | |
Defined in Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] # | |
| Enum CSize | |
Defined in Foreign.C.Types | |
| Enum CTime | |
Defined in Foreign.C.Types | |
| Enum CUChar | |
Defined in Foreign.C.Types | |
| Enum CUInt | |
Defined in Foreign.C.Types | |
| Enum CUIntMax | |
Defined in Foreign.C.Types Methods succ :: CUIntMax -> CUIntMax # pred :: CUIntMax -> CUIntMax # enumFrom :: CUIntMax -> [CUIntMax] # enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax] # | |
| Enum CUIntPtr | |
Defined in Foreign.C.Types Methods succ :: CUIntPtr -> CUIntPtr # pred :: CUIntPtr -> CUIntPtr # enumFrom :: CUIntPtr -> [CUIntPtr] # enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr] # | |
| Enum CULLong | |
Defined in Foreign.C.Types Methods enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] # | |
| Enum CULong | |
Defined in Foreign.C.Types | |
| Enum CUSeconds | |
Defined in Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] # | |
| Enum CUShort | |
Defined in Foreign.C.Types Methods enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] # | |
| Enum CWchar | |
Defined in Foreign.C.Types | |
| Enum ByteOrder | |
Defined in GHC.ByteOrder Methods succ :: ByteOrder -> ByteOrder # pred :: ByteOrder -> ByteOrder # fromEnum :: ByteOrder -> Int # enumFrom :: ByteOrder -> [ByteOrder] # enumFromThen :: ByteOrder -> ByteOrder -> [ByteOrder] # enumFromTo :: ByteOrder -> ByteOrder -> [ByteOrder] # enumFromThenTo :: ByteOrder -> ByteOrder -> ByteOrder -> [ByteOrder] # | |
| Enum Associativity | |
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 | |
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 | |
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 | |
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 SeekMode | |
| Enum IOMode | |
Defined in GHC.IO.IOMode | |
| Enum Int16 | |
| Enum Int32 | |
| Enum Int64 | |
| Enum Int8 | |
| Enum DoCostCentres | |
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 | |
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 | |
Defined in GHC.RTS.Flags Methods enumFrom :: DoTrace -> [DoTrace] # enumFromThen :: DoTrace -> DoTrace -> [DoTrace] # enumFromTo :: DoTrace -> DoTrace -> [DoTrace] # enumFromThenTo :: DoTrace -> DoTrace -> DoTrace -> [DoTrace] # | |
| Enum GiveGCStats | |
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 | |
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 GeneralCategory | |
Defined in GHC.Unicode Methods succ :: GeneralCategory -> GeneralCategory # pred :: GeneralCategory -> GeneralCategory # toEnum :: Int -> GeneralCategory # fromEnum :: GeneralCategory -> Int # enumFrom :: GeneralCategory -> [GeneralCategory] # enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] # | |
| Enum Word16 | |
Defined in GHC.Word | |
| Enum Word32 | |
Defined in GHC.Word | |
| Enum Word64 | |
Defined in GHC.Word | |
| Enum Word8 | |
| Enum CBlkCnt | |
Defined in System.Posix.Types Methods enumFrom :: CBlkCnt -> [CBlkCnt] # enumFromThen :: CBlkCnt -> CBlkCnt -> [CBlkCnt] # enumFromTo :: CBlkCnt -> CBlkCnt -> [CBlkCnt] # enumFromThenTo :: CBlkCnt -> CBlkCnt -> CBlkCnt -> [CBlkCnt] # | |
| Enum CBlkSize | |
Defined in System.Posix.Types Methods succ :: CBlkSize -> CBlkSize # pred :: CBlkSize -> CBlkSize # enumFrom :: CBlkSize -> [CBlkSize] # enumFromThen :: CBlkSize -> CBlkSize -> [CBlkSize] # enumFromTo :: CBlkSize -> CBlkSize -> [CBlkSize] # enumFromThenTo :: CBlkSize -> CBlkSize -> CBlkSize -> [CBlkSize] # | |
| Enum CCc | |
Defined in System.Posix.Types | |
| Enum CClockId | |
Defined in System.Posix.Types Methods succ :: CClockId -> CClockId # pred :: CClockId -> CClockId # enumFrom :: CClockId -> [CClockId] # enumFromThen :: CClockId -> CClockId -> [CClockId] # enumFromTo :: CClockId -> CClockId -> [CClockId] # enumFromThenTo :: CClockId -> CClockId -> CClockId -> [CClockId] # | |
| Enum CDev | |
Defined in System.Posix.Types | |
| Enum CFsBlkCnt | |
Defined in System.Posix.Types Methods succ :: CFsBlkCnt -> CFsBlkCnt # pred :: CFsBlkCnt -> CFsBlkCnt # fromEnum :: CFsBlkCnt -> Int # enumFrom :: CFsBlkCnt -> [CFsBlkCnt] # enumFromThen :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # enumFromTo :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # enumFromThenTo :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # | |
| Enum CFsFilCnt | |
Defined in System.Posix.Types Methods succ :: CFsFilCnt -> CFsFilCnt # pred :: CFsFilCnt -> CFsFilCnt # fromEnum :: CFsFilCnt -> Int # enumFrom :: CFsFilCnt -> [CFsFilCnt] # enumFromThen :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # enumFromTo :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # enumFromThenTo :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # | |
| Enum CGid | |
Defined in System.Posix.Types | |
| Enum CId | |
Defined in System.Posix.Types | |
| Enum CIno | |
Defined in System.Posix.Types | |
| Enum CKey | |
Defined in System.Posix.Types | |
| Enum CMode | |
Defined in System.Posix.Types | |
| Enum CNfds | |
Defined in System.Posix.Types | |
| Enum CNlink | |
Defined in System.Posix.Types | |
| Enum COff | |
Defined in System.Posix.Types | |
| Enum CPid | |
Defined in System.Posix.Types | |
| Enum CRLim | |
Defined in System.Posix.Types | |
| Enum CSocklen | |
Defined in System.Posix.Types Methods succ :: CSocklen -> CSocklen # pred :: CSocklen -> CSocklen # enumFrom :: CSocklen -> [CSocklen] # enumFromThen :: CSocklen -> CSocklen -> [CSocklen] # enumFromTo :: CSocklen -> CSocklen -> [CSocklen] # enumFromThenTo :: CSocklen -> CSocklen -> CSocklen -> [CSocklen] # | |
| Enum CSpeed | |
Defined in System.Posix.Types | |
| Enum CSsize | |
Defined in System.Posix.Types | |
| Enum CTcflag | |
Defined in System.Posix.Types Methods enumFrom :: CTcflag -> [CTcflag] # enumFromThen :: CTcflag -> CTcflag -> [CTcflag] # enumFromTo :: CTcflag -> CTcflag -> [CTcflag] # enumFromThenTo :: CTcflag -> CTcflag -> CTcflag -> [CTcflag] # | |
| Enum CUid | |
Defined in System.Posix.Types | |
| Enum Fd | |
Defined in System.Posix.Types | |
| Enum Encoding | |
Defined in Basement.String Methods succ :: Encoding -> Encoding # pred :: Encoding -> Encoding # enumFrom :: Encoding -> [Encoding] # enumFromThen :: Encoding -> Encoding -> [Encoding] # enumFromTo :: Encoding -> Encoding -> [Encoding] # enumFromThenTo :: Encoding -> Encoding -> Encoding -> [Encoding] # | |
| Enum UTF32_Invalid | |
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 Clock | |
Defined in System.Clock | |
| Enum TimeSpec | |
Defined in System.Clock Methods succ :: TimeSpec -> TimeSpec # pred :: TimeSpec -> TimeSpec # enumFrom :: TimeSpec -> [TimeSpec] # enumFromThen :: TimeSpec -> TimeSpec -> [TimeSpec] # enumFromTo :: TimeSpec -> TimeSpec -> [TimeSpec] # enumFromThenTo :: TimeSpec -> TimeSpec -> TimeSpec -> [TimeSpec] # | |
| Enum CryptoError | |
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 | |
Defined in System.Directory.Internal.Common Methods succ :: FileType -> FileType # pred :: FileType -> FileType # enumFrom :: FileType -> [FileType] # enumFromThen :: FileType -> FileType -> [FileType] # enumFromTo :: FileType -> FileType -> [FileType] # enumFromThenTo :: FileType -> FileType -> FileType -> [FileType] # | |
| Enum XdgDirectory | |
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 | |
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 | |
Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] # | |
| Enum ClosureType | |
Defined in GHC.Exts.Heap.ClosureTypes Methods succ :: ClosureType -> ClosureType # pred :: ClosureType -> ClosureType # toEnum :: Int -> ClosureType # fromEnum :: ClosureType -> Int # enumFrom :: ClosureType -> [ClosureType] # enumFromThen :: ClosureType -> ClosureType -> [ClosureType] # enumFromTo :: ClosureType -> ClosureType -> [ClosureType] # enumFromThenTo :: ClosureType -> ClosureType -> ClosureType -> [ClosureType] # | |
| Enum Ordering | |
| Enum THResultType | |
Defined in GHCi.Message Methods succ :: THResultType -> THResultType # pred :: THResultType -> THResultType # toEnum :: Int -> THResultType # fromEnum :: THResultType -> Int # enumFrom :: THResultType -> [THResultType] # enumFromThen :: THResultType -> THResultType -> [THResultType] # enumFromTo :: THResultType -> THResultType -> [THResultType] # enumFromThenTo :: THResultType -> THResultType -> THResultType -> [THResultType] # | |
| Enum StdMethod | |
Defined in Network.HTTP.Types.Method Methods succ :: StdMethod -> StdMethod # pred :: StdMethod -> StdMethod # fromEnum :: StdMethod -> Int # enumFrom :: StdMethod -> [StdMethod] # enumFromThen :: StdMethod -> StdMethod -> [StdMethod] # enumFromTo :: StdMethod -> StdMethod -> [StdMethod] # enumFromThenTo :: StdMethod -> StdMethod -> StdMethod -> [StdMethod] # | |
| Enum Status | |
Defined in Network.HTTP.Types.Status | |
| Enum IPv4 | |
| Enum IPv6 | |
| Enum IP | |
Defined in Data.IP.Addr | |
| Enum IPv4 | |
Defined in Data.IP.Addr | |
| Enum IPv6 | |
Defined in Data.IP.Addr | |
| Enum PortConfig Source # | |
Defined in IHP.IDE.PortConfig Methods succ :: PortConfig -> PortConfig # pred :: PortConfig -> PortConfig # toEnum :: Int -> PortConfig # fromEnum :: PortConfig -> Int # enumFrom :: PortConfig -> [PortConfig] # enumFromThen :: PortConfig -> PortConfig -> [PortConfig] # enumFromTo :: PortConfig -> PortConfig -> [PortConfig] # enumFromThenTo :: PortConfig -> PortConfig -> PortConfig -> [PortConfig] # | |
| Enum JobStatus Source # | |
Defined in IHP.Job.Types Methods succ :: JobStatus -> JobStatus # pred :: JobStatus -> JobStatus # fromEnum :: JobStatus -> Int # enumFrom :: JobStatus -> [JobStatus] # enumFromThen :: JobStatus -> JobStatus -> [JobStatus] # enumFromTo :: JobStatus -> JobStatus -> [JobStatus] # enumFromThenTo :: JobStatus -> JobStatus -> JobStatus -> [JobStatus] # | |
| Enum LogLevel Source # | |
| Enum PortNumber | |
Defined in Network.Socket.Types Methods succ :: PortNumber -> PortNumber # pred :: PortNumber -> PortNumber # fromEnum :: PortNumber -> Int # enumFrom :: PortNumber -> [PortNumber] # enumFromThen :: PortNumber -> PortNumber -> [PortNumber] # enumFromTo :: PortNumber -> PortNumber -> [PortNumber] # enumFromThenTo :: PortNumber -> PortNumber -> PortNumber -> [PortNumber] # | |
| Enum Column | |
Defined in Database.PostgreSQL.LibPQ | |
| Enum ExecStatus | |
Defined in Database.PostgreSQL.LibPQ Methods succ :: ExecStatus -> ExecStatus # pred :: ExecStatus -> ExecStatus # fromEnum :: ExecStatus -> Int # enumFrom :: ExecStatus -> [ExecStatus] # enumFromThen :: ExecStatus -> ExecStatus -> [ExecStatus] # enumFromTo :: ExecStatus -> ExecStatus -> [ExecStatus] # enumFromThenTo :: ExecStatus -> ExecStatus -> ExecStatus -> [ExecStatus] # | |
| Enum FieldCode | |
Defined in Database.PostgreSQL.LibPQ Methods succ :: FieldCode -> FieldCode # pred :: FieldCode -> FieldCode # fromEnum :: FieldCode -> Int # enumFrom :: FieldCode -> [FieldCode] # enumFromThen :: FieldCode -> FieldCode -> [FieldCode] # enumFromTo :: FieldCode -> FieldCode -> [FieldCode] # enumFromThenTo :: FieldCode -> FieldCode -> FieldCode -> [FieldCode] # | |
| Enum Format | |
Defined in Database.PostgreSQL.LibPQ | |
| Enum Row | |
Defined in Database.PostgreSQL.LibPQ | |
| Enum Verbosity | |
Defined in Database.PostgreSQL.LibPQ Methods succ :: Verbosity -> Verbosity # pred :: Verbosity -> Verbosity # fromEnum :: Verbosity -> Int # enumFrom :: Verbosity -> [Verbosity] # enumFromThen :: Verbosity -> Verbosity -> [Verbosity] # enumFromTo :: Verbosity -> Verbosity -> [Verbosity] # enumFromThenTo :: Verbosity -> Verbosity -> Verbosity -> [Verbosity] # | |
| Enum IsolationLevel | |
Defined in Database.PostgreSQL.Simple.Transaction Methods succ :: IsolationLevel -> IsolationLevel # pred :: IsolationLevel -> IsolationLevel # toEnum :: Int -> IsolationLevel # fromEnum :: IsolationLevel -> Int # enumFrom :: IsolationLevel -> [IsolationLevel] # enumFromThen :: IsolationLevel -> IsolationLevel -> [IsolationLevel] # enumFromTo :: IsolationLevel -> IsolationLevel -> [IsolationLevel] # enumFromThenTo :: IsolationLevel -> IsolationLevel -> IsolationLevel -> [IsolationLevel] # | |
| Enum ReadWriteMode | |
Defined in Database.PostgreSQL.Simple.Transaction Methods succ :: ReadWriteMode -> ReadWriteMode # pred :: ReadWriteMode -> ReadWriteMode # toEnum :: Int -> ReadWriteMode # fromEnum :: ReadWriteMode -> Int # enumFrom :: ReadWriteMode -> [ReadWriteMode] # enumFromThen :: ReadWriteMode -> ReadWriteMode -> [ReadWriteMode] # enumFromTo :: ReadWriteMode -> ReadWriteMode -> [ReadWriteMode] # enumFromThenTo :: ReadWriteMode -> ReadWriteMode -> ReadWriteMode -> [ReadWriteMode] # | |
| Enum DoPa | |
Defined in Text.Regex.TDFA.Common | |
| Enum WhichTest | |
Defined in Text.Regex.TDFA.Common Methods succ :: WhichTest -> WhichTest # pred :: WhichTest -> WhichTest # fromEnum :: WhichTest -> Int # enumFrom :: WhichTest -> [WhichTest] # enumFromThen :: WhichTest -> WhichTest -> [WhichTest] # enumFromTo :: WhichTest -> WhichTest -> [WhichTest] # enumFromThenTo :: WhichTest -> WhichTest -> WhichTest -> [WhichTest] # | |
| Enum Undefined | |
Defined in Relude.Debug Methods succ :: Undefined -> Undefined # pred :: Undefined -> Undefined # fromEnum :: Undefined -> Int # enumFrom :: Undefined -> [Undefined] # enumFromThen :: Undefined -> Undefined -> [Undefined] # enumFromTo :: Undefined -> Undefined -> [Undefined] # enumFromThenTo :: Undefined -> Undefined -> Undefined -> [Undefined] # | |
| Enum FPFormat | |
Defined in Data.Text.Lazy.Builder.RealFloat Methods succ :: FPFormat -> FPFormat # pred :: FPFormat -> FPFormat # enumFrom :: FPFormat -> [FPFormat] # enumFromThen :: FPFormat -> FPFormat -> [FPFormat] # enumFromTo :: FPFormat -> FPFormat -> [FPFormat] # enumFromThenTo :: FPFormat -> FPFormat -> FPFormat -> [FPFormat] # | |
| Enum Day | |
| Enum DayOfWeek | |
Defined in Data.Time.Calendar.Week Methods succ :: DayOfWeek -> DayOfWeek # pred :: DayOfWeek -> DayOfWeek # fromEnum :: DayOfWeek -> Int # enumFrom :: DayOfWeek -> [DayOfWeek] # enumFromThen :: DayOfWeek -> DayOfWeek -> [DayOfWeek] # enumFromTo :: DayOfWeek -> DayOfWeek -> [DayOfWeek] # enumFromThenTo :: DayOfWeek -> DayOfWeek -> DayOfWeek -> [DayOfWeek] # | |
| Enum DiffTime | |
Defined in Data.Time.Clock.Internal.DiffTime | |
| Enum NominalDiffTime | |
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 Int128 | |
Defined in Data.WideWord.Int128 | |
| Enum Word128 | |
Defined in Data.WideWord.Word128 Methods enumFrom :: Word128 -> [Word128] # enumFromThen :: Word128 -> Word128 -> [Word128] # enumFromTo :: Word128 -> Word128 -> [Word128] # enumFromThenTo :: Word128 -> Word128 -> Word128 -> [Word128] # | |
| Enum Word256 | |
Defined in Data.WideWord.Word256 Methods enumFrom :: Word256 -> [Word256] # enumFromThen :: Word256 -> Word256 -> [Word256] # enumFromTo :: Word256 -> Word256 -> [Word256] # enumFromThenTo :: Word256 -> Word256 -> Word256 -> [Word256] # | |
| Enum CompressionStrategy | |
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 | |
Defined in Codec.Compression.Zlib.Stream | |
| Enum Method | |
Defined in Codec.Compression.Zlib.Stream | |
| Enum Integer | |
| Enum Natural | |
Defined in GHC.Enum Methods enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] # | |
| Enum () | |
| Enum Bool | |
| Enum Char | |
| Enum Int | |
| Enum Levity | |
Defined in GHC.Enum | |
| Enum VecCount | |
Defined in GHC.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] # | |
| Enum VecElem | |
Defined in GHC.Enum Methods enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # | |
| Enum Word | |
| Enum a => Enum (Identity a) | |
Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> 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) | |
Defined in Data.Semigroup Methods 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) | |
Defined in Data.Semigroup | |
| Enum a => Enum (Max a) | |
Defined in Data.Semigroup | |
| Enum a => Enum (Min a) | |
Defined in Data.Semigroup | |
| Enum a => Enum (WrappedMonoid a) | |
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) | |
Defined in GHC.Real Methods 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) | |
Defined in Basement.Bits | |
| Enum (CountOf ty) | |
Defined in Basement.Types.OffsetSize Methods succ :: CountOf ty -> CountOf ty # pred :: CountOf ty -> 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) | |
Defined in Basement.Types.OffsetSize Methods succ :: Offset ty -> Offset ty # pred :: Offset ty -> 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) | |
| Enum (Fixed a) | |
Defined in Data.Fixed Methods 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) | |
| Enum a => Enum (Const a b) | |
Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> 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) | |
Defined in Data.Monoid | |
| Enum (f a) => Enum (Alt f a) | |
Defined in Data.Semigroup.Internal Methods 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] # | |
| a ~ b => Enum (a :~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b # pred :: (a :~: b) -> a :~: b # fromEnum :: (a :~: b) -> Int # enumFrom :: (a :~: b) -> [a :~: b] # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] # | |
| Enum a => Enum (Tagged s a) | |
Defined in Data.Tagged Methods succ :: Tagged s a -> Tagged s a # pred :: Tagged s a -> 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] # | |
| a ~~ b => Enum (a :~~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~~: b) -> a :~~: b # pred :: (a :~~: b) -> a :~~: b # fromEnum :: (a :~~: b) -> Int # enumFrom :: (a :~~: b) -> [a :~~: b] # enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b] # | |