IHP Api Reference| Copyright | (c) digitally induced GmbH 2020 |
|---|---|
| Safe Haskell | Safe-Inferred |
IHP.RouterPrelude
Description
Synopsis
- module IHP.RouterSupport
- seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- otherwise :: Bool
- assert :: Bool -> a -> a
- ($) :: 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
- 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 where
- 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) 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 Generic a
- class Semigroup a where
- 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 RealWorld
- data IO a
- data Word
- data Word8
- data Word32
- data Word64
- data Either a b
- pollSTM :: Async a -> STM (Maybe (Either SomeException a))
- waitAnyCatchSTM :: [Async a] -> STM (Async a, Either SomeException a)
- waitAnySTM :: [Async a] -> STM (Async a, a)
- waitBothSTM :: Async a -> Async b -> STM (a, b)
- waitCatchSTM :: Async a -> STM (Either SomeException a)
- waitEitherCatchSTM :: Async a -> Async b -> STM (Either (Either SomeException a) (Either SomeException b))
- waitEitherSTM :: Async a -> Async b -> STM (Either a b)
- waitEitherSTM_ :: Async a -> Async b -> STM ()
- waitSTM :: Async a -> STM a
- optional :: Alternative f => f a -> f (Maybe a)
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- forever :: Applicative f => f a -> f b
- replicateM_ :: Applicative m => Int -> m a -> m ()
- unless :: Applicative f => Bool -> f () -> f ()
- 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 => f a -> b -> f b
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- (<&>) :: Functor f => f a -> (a -> b) -> f b
- void :: Functor f => f a -> f ()
- 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
- for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
- forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- 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
- (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- ap :: Monad m => m (a -> b) -> m a -> m b
- asTypeOf :: a -> a -> a
- const :: a -> b -> a
- flip :: (a -> b -> c) -> b -> a -> c
- liftA :: Applicative f => (a -> b) -> f a -> f b
- liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- liftM :: Monad m => (a1 -> r) -> m a1 -> m r
- liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
- liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
- liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
- liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
- until :: (a -> Bool) -> (a -> a) -> a -> a
- when :: Applicative f => Bool -> f () -> f ()
- newTVar :: a -> STM (TVar a)
- orElse :: STM a -> STM a -> STM a
- readTVar :: TVar a -> STM a
- writeTVar :: TVar a -> a -> STM ()
- error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
- asyncExceptionFromException :: Exception e => SomeException -> Maybe e
- asyncExceptionToException :: Exception e => e -> SomeException
- ioError :: IOError -> IO a
- userError :: String -> IOError
- stderr :: Handle
- stdin :: Handle
- stdout :: Handle
- repeat :: a -> [a]
- 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
- textToBuilder :: ToBuilder Text builder => Text -> builder
- (++) :: Monoid m => m -> m -> m
- (<&&>) :: Applicative a => a Bool -> a Bool -> a Bool
- (<||>) :: Applicative a => a Bool -> a Bool -> a Bool
- (\\) :: SetContainer a => a -> a -> a
- applyDList :: DList a -> [a] -> [a]
- asByteString :: ByteString -> ByteString
- asDList :: DList a -> DList a
- asHashMap :: HashMap k v -> HashMap k v
- asHashSet :: HashSet a -> HashSet a
- asIntMap :: IntMap v -> IntMap v
- asIntSet :: IntSet -> IntSet
- asLByteString :: LByteString -> LByteString
- asLText :: LText -> LText
- asList :: [a] -> [a]
- asMap :: Map k v -> Map k v
- asMaybe :: Maybe a -> Maybe a
- asSVector :: SVector a -> SVector a
- asSet :: Set a -> Set a
- asString :: [Char] -> [Char]
- asText :: Text -> Text
- asUVector :: UVector a -> UVector a
- asVector :: Vector a -> Vector a
- charToLower :: Char -> Char
- charToUpper :: Char -> Char
- fromByteVector :: SVector Word8 -> ByteString
- getChar :: MonadIO m => m Char
- getContents :: MonadIO m => m LText
- getLine :: MonadIO m => m Text
- hGetChunk :: MonadIO m => Handle -> m ByteString
- hGetContents :: MonadIO m => Handle -> m ByteString
- hPut :: MonadIO m => Handle -> ByteString -> m ()
- hashNub :: (Hashable a, Eq a) => [a] -> [a]
- interact :: MonadIO m => (LText -> LText) -> m ()
- intersect :: SetContainer a => a -> a -> a
- link2Async :: MonadIO m => Async a -> Async b -> m ()
- linkAsync :: MonadIO m => Async a -> m ()
- map :: Functor f => (a -> b) -> f a -> f b
- orElseSTM :: STM a -> STM a -> STM a
- ordNub :: Ord a => [a] -> [a]
- ordNubBy :: Ord b => (a -> b) -> (a -> a -> Bool) -> [a] -> [a]
- parseTime :: ParseTime t => TimeLocale -> String -> String -> Maybe t
- pollAsync :: MonadIO m => Async a -> m (Maybe (Either SomeException a))
- print :: (Show a, MonadIO m) => a -> m ()
- putChar :: MonadIO m => Char -> m ()
- putStr :: MonadIO m => Text -> m ()
- putStrLn :: MonadIO m => Text -> m ()
- readFile :: MonadIO m => FilePath -> m ByteString
- readFileUtf8 :: MonadIO m => FilePath -> m Text
- readMay :: (Element c ~ Char, MonoFoldable c, Read a) => c -> Maybe a
- sortWith :: (Ord a, IsSequence c) => (Element c -> a) -> c -> c
- tlshow :: Show a => a -> LText
- toByteVector :: ByteString -> SVector Word8
- trace :: String -> a -> a
- traceId :: String -> String
- traceM :: Monad m => String -> m ()
- traceShow :: Show a => a -> b -> b
- traceShowId :: Show a => a -> a
- traceShowM :: (Show a, Monad m) => a -> m ()
- tshow :: Show a => a -> Text
- undefined :: HasCallStack => a
- unlessM :: Monad m => m Bool -> m () -> m ()
- waitAsync :: MonadIO m => Async a -> m a
- waitCatchAsync :: MonadIO m => Async a -> m (Either SomeException a)
- whenM :: Monad m => m Bool -> m () -> m ()
- writeFile :: MonadIO m => FilePath -> ByteString -> m ()
- writeFileUtf8 :: MonadIO m => FilePath -> Text -> m ()
- yieldThread :: MonadIO m => m ()
- ($!!) :: NFData a => (a -> b) -> a -> b
- deepseq :: NFData a => a -> b -> b
- force :: NFData a => a -> a
- (<.>) :: FilePath -> String -> FilePath
- (</>) :: FilePath -> FilePath -> FilePath
- (&&) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- headMay :: MonoFoldable mono => mono -> Maybe (Element mono)
- lastMay :: MonoFoldable mono => mono -> Maybe (Element mono)
- maximumByMay :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> mono -> Maybe (Element mono)
- maximumEx :: (MonoFoldable mono, Ord (Element mono)) => mono -> Element mono
- maximumMay :: (MonoFoldable mono, Ord (Element mono)) => mono -> Maybe (Element mono)
- minimumByMay :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> mono -> Maybe (Element mono)
- minimumEx :: (MonoFoldable mono, Ord (Element mono)) => mono -> Element mono
- minimumMay :: (MonoFoldable mono, Ord (Element mono)) => mono -> Maybe (Element mono)
- oand :: (Element mono ~ Bool, MonoFoldable mono) => mono -> Bool
- oconcat :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono
- oconcatMap :: (MonoFoldable mono, Monoid m) => (Element mono -> m) -> mono -> m
- ofold :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono
- ofoldM :: (MonoFoldable mono, Monad m) => (a -> Element mono -> m a) -> a -> mono -> m a
- ofoldMUnwrap :: (Monad m, MonoFoldable mono) => (x -> Element mono -> m x) -> m x -> (x -> m b) -> mono -> m b
- ofoldlUnwrap :: MonoFoldable mono => (x -> Element mono -> x) -> x -> (x -> b) -> mono -> b
- ofor :: (MonoTraversable mono, Applicative f) => mono -> (Element mono -> f (Element mono)) -> f mono
- oforM :: (MonoTraversable mono, Applicative f) => mono -> (Element mono -> f (Element mono)) -> f mono
- ointercalate :: (MonoFoldable mono, Monoid (Element mono)) => Element mono -> mono -> Element mono
- oor :: (Element mono ~ Bool, MonoFoldable mono) => mono -> Bool
- oproduct :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono
- osequence_ :: (Applicative m, MonoFoldable mono, Element mono ~ m ()) => mono -> m ()
- osum :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono
- replaceElem :: (MonoFunctor mono, Eq (Element mono)) => Element mono -> Element mono -> mono -> mono
- replaceElemLazyText :: Char -> Char -> Text -> Text
- replaceElemStrictText :: Char -> Char -> Text -> Text
- unwrapMono :: WrappedMono mono a -> mono
- all :: MonoFoldable mono => (Element mono -> Bool) -> mono -> Bool
- and :: (MonoFoldable mono, Element mono ~ Bool) => mono -> Bool
- any :: MonoFoldable mono => (Element mono -> Bool) -> mono -> Bool
- compareLength :: (MonoFoldable mono, Integral i) => mono -> i -> Ordering
- concat :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono
- concatMap :: (MonoFoldable mono, Monoid m) => (Element mono -> m) -> mono -> m
- elem :: (MonoFoldable mono, Eq (Element mono)) => Element mono -> mono -> Bool
- fold :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono
- foldM :: (MonoFoldable mono, Monad m) => (a -> Element mono -> m a) -> a -> mono -> m a
- foldMap :: (MonoFoldable mono, Monoid m) => (Element mono -> m) -> mono -> m
- foldMap1Ex :: (MonoFoldable mono, Semigroup m) => (Element mono -> m) -> mono -> m
- foldl' :: MonoFoldable mono => (a -> Element mono -> a) -> a -> mono -> a
- foldl1Ex' :: MonoFoldable mono => (Element mono -> Element mono -> Element mono) -> mono -> Element mono
- foldlM :: (MonoFoldable mono, Monad m) => (a -> Element mono -> m a) -> a -> mono -> m a
- foldr :: MonoFoldable mono => (Element mono -> b -> b) -> b -> mono -> b
- foldr1Ex :: MonoFoldable mono => (Element mono -> Element mono -> Element mono) -> mono -> Element mono
- forM_ :: (MonoFoldable mono, Applicative m) => mono -> (Element mono -> m ()) -> m ()
- for_ :: (MonoFoldable mono, Applicative f) => mono -> (Element mono -> f b) -> f ()
- intercalate :: (MonoFoldable mono, Monoid (Element mono)) => Element mono -> mono -> Element mono
- length :: MonoFoldable mono => mono -> Int
- length64 :: MonoFoldable mono => mono -> Int64
- mapM_ :: (MonoFoldable mono, Applicative m) => (Element mono -> m ()) -> mono -> m ()
- notElem :: (MonoFoldable mono, Eq (Element mono)) => Element mono -> mono -> Bool
- null :: MonoFoldable mono => mono -> Bool
- or :: (MonoFoldable mono, Element mono ~ Bool) => mono -> Bool
- point :: MonoPointed mono => Element mono -> mono
- product :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono
- sequence_ :: (Applicative m, MonoFoldable mono, Element mono ~ m ()) => mono -> m ()
- sum :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono
- toList :: MonoFoldable mono => mono -> [Element mono]
- traverse_ :: (MonoFoldable mono, Applicative f) => (Element mono -> f b) -> mono -> f ()
- (<|) :: SemiSequence seq => Element seq -> NonNull seq -> NonNull seq
- fromNonEmpty :: IsSequence seq => NonEmpty (Element seq) -> NonNull seq
- fromNullable :: MonoFoldable mono => mono -> Maybe (NonNull mono)
- head :: MonoFoldable mono => NonNull mono -> Element mono
- impureNonNull :: MonoFoldable mono => mono -> NonNull mono
- init :: IsSequence seq => NonNull seq -> seq
- last :: MonoFoldable mono => NonNull mono -> Element mono
- mapNonNull :: (Functor f, MonoFoldable (f b)) => (a -> b) -> NonNull (f a) -> NonNull (f b)
- maximum :: (MonoFoldable mono, Ord (Element mono)) => NonNull mono -> Element mono
- maximumBy :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> NonNull mono -> Element mono
- minimum :: (MonoFoldable mono, Ord (Element mono)) => NonNull mono -> Element mono
- minimumBy :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> NonNull mono -> Element mono
- nReplicate :: IsSequence seq => Index seq -> Element seq -> NonNull seq
- ncons :: SemiSequence seq => Element seq -> seq -> NonNull seq
- nfilter :: IsSequence seq => (Element seq -> Bool) -> NonNull seq -> seq
- nfilterM :: (Monad m, IsSequence seq) => (Element seq -> m Bool) -> NonNull seq -> m seq
- nonNull :: MonoFoldable mono => mono -> NonNull mono
- nuncons :: IsSequence seq => NonNull seq -> (Element seq, Maybe (NonNull seq))
- ofold1 :: (MonoFoldable mono, Semigroup (Element mono)) => NonNull mono -> Element mono
- ofoldMap1 :: (MonoFoldable mono, Semigroup m) => (Element mono -> m) -> NonNull mono -> m
- ofoldl1' :: MonoFoldable mono => (Element mono -> Element mono -> Element mono) -> NonNull mono -> Element mono
- ofoldr1 :: MonoFoldable mono => (Element mono -> Element mono -> Element mono) -> NonNull mono -> Element mono
- splitFirst :: IsSequence seq => NonNull seq -> (Element seq, seq)
- tail :: IsSequence seq => NonNull seq -> seq
- toMinList :: NonEmpty a -> NonNull [a]
- toNonEmpty :: MonoFoldable mono => NonNull mono -> NonEmpty (Element mono)
- catMaybes :: (IsSequence (f (Maybe t)), Functor f, Element (f (Maybe t)) ~ Maybe t) => f (Maybe t) -> f t
- defaultCons :: IsSequence seq => Element seq -> seq -> seq
- defaultFind :: MonoFoldable seq => (Element seq -> Bool) -> seq -> Maybe (Element seq)
- defaultIntersperse :: IsSequence seq => Element seq -> seq -> seq
- defaultReverse :: IsSequence seq => seq -> seq
- defaultSnoc :: IsSequence seq => seq -> Element seq -> seq
- defaultSortBy :: IsSequence seq => (Element seq -> Element seq -> Ordering) -> seq -> seq
- defaultSplitWhen :: IsSequence seq => (Element seq -> Bool) -> seq -> [seq]
- deleteBy :: (IsSequence seq, Eq (Element seq)) => (Element seq -> Element seq -> Bool) -> Element seq -> seq -> seq
- dropPrefix :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> seq
- dropSuffix :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> seq
- ensurePrefix :: (Eq (Element seq), IsSequence seq) => seq -> seq -> seq
- ensureSuffix :: (Eq (Element seq), IsSequence seq) => seq -> seq -> seq
- group :: (IsSequence seq, Eq (Element seq)) => seq -> [seq]
- groupAll :: (IsSequence seq, Eq (Element seq)) => seq -> [seq]
- initDef :: IsSequence seq => seq -> seq
- isInfixOf :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Bool
- isPrefixOf :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Bool
- isSuffixOf :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Bool
- pack :: IsSequence seq => [Element seq] -> seq
- repack :: (MonoFoldable a, IsSequence b, Element a ~ Element b) => a -> b
- replaceSeq :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> seq -> seq
- replaceSeqLazyText :: Text -> Text -> Text -> Text
- replaceSeqStrictText :: Text -> Text -> Text -> Text
- singleton :: MonoPointed seq => Element seq -> seq
- sort :: (SemiSequence seq, Ord (Element seq)) => seq -> seq
- sortOn :: (Ord o, SemiSequence seq) => (Element seq -> o) -> seq -> seq
- splitElem :: (IsSequence seq, Eq (Element seq)) => Element seq -> seq -> [seq]
- splitElemStrictBS :: Word8 -> ByteString -> [ByteString]
- splitSeq :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> [seq]
- splitSeqLazyBS :: Word8 -> ByteString -> [ByteString]
- splitSeqLazyText :: Text -> Text -> [Text]
- splitSeqStrictText :: Text -> Text -> [Text]
- stripPrefix :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Maybe seq
- stripPrefixLazyBS :: ByteString -> ByteString -> Maybe ByteString
- stripPrefixStrictBS :: ByteString -> ByteString -> Maybe ByteString
- stripSuffix :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Maybe seq
- stripSuffixLazyBS :: ByteString -> ByteString -> Maybe ByteString
- stripSuffixStrictBS :: ByteString -> ByteString -> Maybe ByteString
- tailDef :: IsSequence seq => seq -> seq
- unpack :: MonoFoldable mono => mono -> [Element mono]
- vectorSort :: (Vector v e, Ord e) => v e -> v e
- vectorSortBy :: Vector v e => (e -> e -> Ordering) -> v e -> v e
- asks :: MonadReader r m => (r -> a) -> m a
- asBRef :: BRef s a -> BRef s a
- asIORef :: IORef a -> IORef a
- asMutVar :: MutVar s a -> MutVar s a
- asSTRef :: STRef s a -> STRef s a
- asDLList :: DLList s a -> DLList s a
- asBDeque :: BDeque s a -> BDeque s a
- asSDeque :: SDeque s a -> SDeque s a
- asUDeque :: UDeque s a -> UDeque s a
- asPRef :: PRef s a -> PRef s a
- asSRef :: SRef s a -> SRef s a
- asURef :: URef s a -> URef s a
- primToIO :: (PrimBase m, PrimState m ~ RealWorld) => m a -> IO a
- primToPrim :: (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) => m1 a -> m2 a
- primToST :: PrimBase m => m a -> ST (PrimState m) a
- atomicModifyMutVar :: PrimMonad m => MutVar (PrimState m) a -> (a -> (a, b)) -> m b
- atomicModifyMutVar' :: PrimMonad m => MutVar (PrimState m) a -> (a -> (a, b)) -> m b
- modifyMutVar :: PrimMonad m => MutVar (PrimState m) a -> (a -> a) -> m ()
- modifyMutVar' :: PrimMonad m => MutVar (PrimState m) a -> (a -> a) -> m ()
- newMutVar :: PrimMonad m => a -> m (MutVar (PrimState m) a)
- readMutVar :: PrimMonad m => MutVar (PrimState m) a -> m a
- writeMutVar :: PrimMonad m => MutVar (PrimState m) a -> a -> m ()
- hSay :: MonadIO m => Handle -> Text -> m ()
- hSayShow :: (MonadIO m, Show a) => Handle -> a -> m ()
- hSayString :: MonadIO m => Handle -> String -> m ()
- say :: MonadIO m => Text -> m ()
- sayErr :: MonadIO m => Text -> m ()
- sayErrShow :: (MonadIO m, Show a) => a -> m ()
- sayErrString :: MonadIO m => String -> m ()
- sayShow :: (MonadIO m, Show a) => a -> m ()
- sayString :: MonadIO m => String -> m ()
- flushTBQueue :: TBQueue a -> STM [a]
- isEmptyTBQueue :: TBQueue a -> STM Bool
- isFullTBQueue :: TBQueue a -> STM Bool
- lengthTBQueue :: TBQueue a -> STM Natural
- newTBQueue :: Natural -> STM (TBQueue a)
- peekTBQueue :: TBQueue a -> STM a
- readTBQueue :: TBQueue a -> STM a
- tryPeekTBQueue :: TBQueue a -> STM (Maybe a)
- tryReadTBQueue :: TBQueue a -> STM (Maybe a)
- unGetTBQueue :: TBQueue a -> a -> STM ()
- writeTBQueue :: TBQueue a -> a -> STM ()
- cloneTChan :: TChan a -> STM (TChan a)
- dupTChan :: TChan a -> STM (TChan a)
- isEmptyTChan :: TChan a -> STM Bool
- newBroadcastTChan :: STM (TChan a)
- newTChan :: STM (TChan a)
- peekTChan :: TChan a -> STM a
- readTChan :: TChan a -> STM a
- tryPeekTChan :: TChan a -> STM (Maybe a)
- tryReadTChan :: TChan a -> STM (Maybe a)
- unGetTChan :: TChan a -> a -> STM ()
- writeTChan :: TChan a -> a -> STM ()
- isEmptyTMVar :: TMVar a -> STM Bool
- newEmptyTMVar :: STM (TMVar a)
- newTMVar :: a -> STM (TMVar a)
- putTMVar :: TMVar a -> a -> STM ()
- readTMVar :: TMVar a -> STM a
- swapTMVar :: TMVar a -> a -> STM a
- takeTMVar :: TMVar a -> STM a
- tryPutTMVar :: TMVar a -> a -> STM Bool
- tryReadTMVar :: TMVar a -> STM (Maybe a)
- tryTakeTMVar :: TMVar a -> STM (Maybe a)
- isEmptyTQueue :: TQueue a -> STM Bool
- newTQueue :: STM (TQueue a)
- peekTQueue :: TQueue a -> STM a
- readTQueue :: TQueue a -> STM a
- tryPeekTQueue :: TQueue a -> STM (Maybe a)
- tryReadTQueue :: TQueue a -> STM (Maybe a)
- unGetTQueue :: TQueue a -> a -> STM ()
- writeTQueue :: TQueue a -> a -> STM ()
- modifyTVar :: TVar a -> (a -> a) -> STM ()
- modifyTVar' :: TVar a -> (a -> a) -> STM ()
- swapTVar :: TVar a -> a -> STM a
- estimateFreeSlotsTBChan :: TBChan a -> STM Int
- freeSlotsTBChan :: TBChan a -> STM Int
- isEmptyTBChan :: TBChan a -> STM Bool
- isFullTBChan :: TBChan a -> STM Bool
- newTBChan :: Int -> STM (TBChan a)
- newTBChanIO :: Int -> IO (TBChan a)
- peekTBChan :: TBChan a -> STM a
- readTBChan :: TBChan a -> STM a
- tryPeekTBChan :: TBChan a -> STM (Maybe a)
- tryReadTBChan :: TBChan a -> STM (Maybe a)
- tryWriteTBChan :: TBChan a -> a -> STM Bool
- unGetTBChan :: TBChan a -> a -> STM ()
- writeTBChan :: TBChan a -> a -> STM ()
- closeTBMChan :: TBMChan a -> STM ()
- estimateFreeSlotsTBMChan :: TBMChan a -> STM Int
- freeSlotsTBMChan :: TBMChan a -> STM Int
- isClosedTBMChan :: TBMChan a -> STM Bool
- isEmptyTBMChan :: TBMChan a -> STM Bool
- isFullTBMChan :: TBMChan a -> STM Bool
- newTBMChan :: Int -> STM (TBMChan a)
- newTBMChanIO :: Int -> IO (TBMChan a)
- peekTBMChan :: TBMChan a -> STM (Maybe a)
- readTBMChan :: TBMChan a -> STM (Maybe a)
- tryPeekTBMChan :: TBMChan a -> STM (Maybe (Maybe a))
- tryReadTBMChan :: TBMChan a -> STM (Maybe (Maybe a))
- tryWriteTBMChan :: TBMChan a -> a -> STM (Maybe Bool)
- unGetTBMChan :: TBMChan a -> a -> STM ()
- writeTBMChan :: TBMChan a -> a -> STM ()
- closeTBMQueue :: TBMQueue a -> STM ()
- estimateFreeSlotsTBMQueue :: TBMQueue a -> STM Int
- freeSlotsTBMQueue :: TBMQueue a -> STM Int
- isClosedTBMQueue :: TBMQueue a -> STM Bool
- isEmptyTBMQueue :: TBMQueue a -> STM Bool
- isFullTBMQueue :: TBMQueue a -> STM Bool
- newTBMQueue :: Int -> STM (TBMQueue a)
- newTBMQueueIO :: Int -> IO (TBMQueue a)
- peekTBMQueue :: TBMQueue a -> STM (Maybe a)
- readTBMQueue :: TBMQueue a -> STM (Maybe a)
- tryPeekTBMQueue :: TBMQueue a -> STM (Maybe (Maybe a))
- tryReadTBMQueue :: TBMQueue a -> STM (Maybe (Maybe a))
- tryWriteTBMQueue :: TBMQueue a -> a -> STM (Maybe Bool)
- unGetTBMQueue :: TBMQueue a -> a -> STM ()
- writeTBMQueue :: TBMQueue a -> a -> STM ()
- closeTMChan :: TMChan a -> STM ()
- dupTMChan :: TMChan a -> STM (TMChan a)
- isClosedTMChan :: TMChan a -> STM Bool
- isEmptyTMChan :: TMChan a -> STM Bool
- newBroadcastTMChan :: STM (TMChan a)
- newBroadcastTMChanIO :: IO (TMChan a)
- newTMChan :: STM (TMChan a)
- newTMChanIO :: IO (TMChan a)
- peekTMChan :: TMChan a -> STM (Maybe a)
- readTMChan :: TMChan a -> STM (Maybe a)
- tryPeekTMChan :: TMChan a -> STM (Maybe (Maybe a))
- tryReadTMChan :: TMChan a -> STM (Maybe (Maybe a))
- unGetTMChan :: TMChan a -> a -> STM ()
- writeTMChan :: TMChan a -> a -> STM ()
- closeTMQueue :: TMQueue a -> STM ()
- isClosedTMQueue :: TMQueue a -> STM Bool
- isEmptyTMQueue :: TMQueue a -> STM Bool
- newTMQueue :: STM (TMQueue a)
- newTMQueueIO :: IO (TMQueue a)
- peekTMQueue :: TMQueue a -> STM (Maybe a)
- readTMQueue :: TMQueue a -> STM (Maybe a)
- tryPeekTMQueue :: TMQueue a -> STM (Maybe (Maybe a))
- tryReadTMQueue :: TMQueue a -> STM (Maybe (Maybe a))
- unGetTMQueue :: TMQueue a -> a -> STM ()
- writeTMQueue :: TMQueue a -> a -> STM ()
- fromGregorian :: Year -> MonthOfYear -> DayOfMonth -> Day
- toGregorian :: Day -> (Year, MonthOfYear, DayOfMonth)
- getCurrentTime :: IO UTCTime
- formatTime :: FormatTime t => TimeLocale -> String -> t -> String
- defaultTimeLocale :: TimeLocale
- parseTimeM :: (MonadFail m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
- dupChan :: MonadIO m => Chan a -> m (Chan a)
- getChanContents :: MonadIO m => Chan a -> m [a]
- newChan :: MonadIO m => m (Chan a)
- readChan :: MonadIO m => Chan a -> m a
- writeChan :: MonadIO m => Chan a -> a -> m ()
- writeList2Chan :: MonadIO m => Chan a -> [a] -> m ()
- bracket :: MonadUnliftIO m => m a -> (a -> m b) -> (a -> m c) -> m c
- bracketOnError :: MonadUnliftIO m => m a -> (a -> m b) -> (a -> m c) -> m c
- bracketOnError_ :: MonadUnliftIO m => m a -> m b -> m c -> m c
- bracket_ :: MonadUnliftIO m => m a -> m b -> m c -> m c
- catch :: (MonadUnliftIO m, Exception e) => m a -> (e -> m a) -> m a
- catchAny :: MonadUnliftIO m => m a -> (SomeException -> m a) -> m a
- catchAnyDeep :: (NFData a, MonadUnliftIO m) => m a -> (SomeException -> m a) -> m a
- catchDeep :: (MonadUnliftIO m, Exception e, NFData a) => m a -> (e -> m a) -> m a
- catchIO :: MonadUnliftIO m => m a -> (IOException -> m a) -> m a
- catchJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> m a -> (b -> m a) -> m a
- catchSyncOrAsync :: (MonadUnliftIO m, Exception e) => m a -> (e -> m a) -> m a
- catches :: MonadUnliftIO m => m a -> [Handler m a] -> m a
- catchesDeep :: (MonadUnliftIO m, NFData a) => m a -> [Handler m a] -> m a
- evaluate :: MonadIO m => a -> m a
- evaluateDeep :: (MonadIO m, NFData a) => a -> m a
- finally :: MonadUnliftIO m => m a -> m b -> m a
- fromEither :: (Exception e, MonadIO m) => Either e a -> m a
- fromEitherIO :: (Exception e, MonadIO m) => IO (Either e a) -> m a
- fromEitherM :: (Exception e, MonadIO m) => m (Either e a) -> m a
- fromExceptionUnwrap :: Exception e => SomeException -> Maybe e
- handle :: (MonadUnliftIO m, Exception e) => (e -> m a) -> m a -> m a
- handleAny :: MonadUnliftIO m => (SomeException -> m a) -> m a -> m a
- handleAnyDeep :: (MonadUnliftIO m, NFData a) => (SomeException -> m a) -> m a -> m a
- handleDeep :: (MonadUnliftIO m, Exception e, NFData a) => (e -> m a) -> m a -> m a
- handleIO :: MonadUnliftIO m => (IOException -> m a) -> m a -> m a
- handleJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> (b -> m a) -> m a -> m a
- handleSyncOrAsync :: (MonadUnliftIO m, Exception e) => (e -> m a) -> m a -> m a
- impureThrow :: Exception e => e -> a
- isAsyncException :: Exception e => e -> Bool
- isSyncException :: Exception e => e -> Bool
- mapExceptionM :: (Exception e1, Exception e2, MonadUnliftIO m) => (e1 -> e2) -> m a -> m a
- mask :: MonadUnliftIO m => ((forall a. m a -> m a) -> m b) -> m b
- mask_ :: MonadUnliftIO m => m a -> m a
- onException :: MonadUnliftIO m => m a -> m b -> m a
- pureTry :: a -> Either SomeException a
- pureTryDeep :: NFData a => a -> Either SomeException a
- stringException :: HasCallStack => String -> StringException
- throwIO :: (MonadIO m, Exception e) => e -> m a
- throwString :: (MonadIO m, HasCallStack) => String -> m a
- throwTo :: (Exception e, MonadIO m) => ThreadId -> e -> m ()
- toAsyncException :: Exception e => e -> SomeException
- toSyncException :: Exception e => e -> SomeException
- tryAny :: MonadUnliftIO m => m a -> m (Either SomeException a)
- tryAnyDeep :: (MonadUnliftIO m, NFData a) => m a -> m (Either SomeException a)
- tryDeep :: (MonadUnliftIO m, Exception e, NFData a) => m a -> m (Either e a)
- tryIO :: MonadUnliftIO m => m a -> m (Either IOException a)
- tryJust :: (MonadUnliftIO m, Exception e) => (e -> Maybe b) -> m a -> m (Either b a)
- trySyncOrAsync :: (MonadUnliftIO m, Exception e) => m a -> m (Either e a)
- uninterruptibleMask :: MonadUnliftIO m => ((forall a. m a -> m a) -> m b) -> m b
- uninterruptibleMask_ :: MonadUnliftIO m => m a -> m a
- withException :: (MonadUnliftIO m, Exception e) => m a -> (e -> m b) -> m a
- getMonotonicTime :: MonadIO m => m Double
- hClose :: MonadIO m => Handle -> m ()
- hFileSize :: MonadIO m => Handle -> m Integer
- hFlush :: MonadIO m => Handle -> m ()
- hGetBuffering :: MonadIO m => Handle -> m BufferMode
- hGetEcho :: MonadIO m => Handle -> m Bool
- hIsClosed :: MonadIO m => Handle -> m Bool
- hIsEOF :: MonadIO m => Handle -> m Bool
- hIsOpen :: MonadIO m => Handle -> m Bool
- hIsReadable :: MonadIO m => Handle -> m Bool
- hIsSeekable :: MonadIO m => Handle -> m Bool
- hIsTerminalDevice :: MonadIO m => Handle -> m Bool
- hIsWritable :: MonadIO m => Handle -> m Bool
- hReady :: MonadIO m => Handle -> m Bool
- hSeek :: MonadIO m => Handle -> SeekMode -> Integer -> m ()
- hSetBuffering :: MonadIO m => Handle -> BufferMode -> m ()
- hSetEcho :: MonadIO m => Handle -> Bool -> m ()
- hSetFileSize :: MonadIO m => Handle -> Integer -> m ()
- hTell :: MonadIO m => Handle -> m Integer
- hWaitForInput :: MonadIO m => Handle -> Int -> m Bool
- openFile :: MonadIO m => FilePath -> IOMode -> m Handle
- withBinaryFile :: MonadUnliftIO m => FilePath -> IOMode -> (Handle -> m a) -> m a
- withFile :: MonadUnliftIO m => FilePath -> IOMode -> (Handle -> m a) -> m a
- atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
- atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
- atomicWriteIORef :: MonadIO m => IORef a -> a -> m ()
- mkWeakIORef :: MonadUnliftIO m => IORef a -> m () -> m (Weak (IORef a))
- modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m ()
- modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m ()
- newIORef :: MonadIO m => a -> m (IORef a)
- readIORef :: MonadIO m => IORef a -> m a
- writeIORef :: MonadIO m => IORef a -> a -> m ()
- async :: MonadUnliftIO m => m a -> m (Async a)
- asyncBound :: MonadUnliftIO m => m a -> m (Async a)
- asyncOn :: MonadUnliftIO m => Int -> m a -> m (Async a)
- asyncOnWithUnmask :: MonadUnliftIO m => Int -> ((forall b. m b -> m b) -> m a) -> m (Async a)
- asyncWithUnmask :: MonadUnliftIO m => ((forall b. m b -> m b) -> m a) -> m (Async a)
- cancel :: MonadIO m => Async a -> m ()
- cancelWith :: (Exception e, MonadIO m) => Async a -> e -> m ()
- conc :: m a -> Conc m a
- concurrently :: MonadUnliftIO m => m a -> m b -> m (a, b)
- concurrently_ :: MonadUnliftIO m => m a -> m b -> m ()
- forConcurrently :: (MonadUnliftIO m, Traversable t) => t a -> (a -> m b) -> m (t b)
- forConcurrently_ :: (MonadUnliftIO m, Foldable f) => f a -> (a -> m b) -> m ()
- link :: MonadIO m => Async a -> m ()
- link2 :: MonadIO m => Async a -> Async b -> m ()
- mapConcurrently :: (MonadUnliftIO m, Traversable t) => (a -> m b) -> t a -> m (t b)
- mapConcurrently_ :: (MonadUnliftIO m, Foldable f) => (a -> m b) -> f a -> m ()
- poll :: MonadIO m => Async a -> m (Maybe (Either SomeException a))
- pooledForConcurrently :: (MonadUnliftIO m, Traversable t) => t a -> (a -> m b) -> m (t b)
- pooledForConcurrentlyN :: (MonadUnliftIO m, Traversable t) => Int -> t a -> (a -> m b) -> m (t b)
- pooledForConcurrentlyN_ :: (MonadUnliftIO m, Foldable t) => Int -> t a -> (a -> m b) -> m ()
- pooledForConcurrently_ :: (MonadUnliftIO m, Foldable f) => f a -> (a -> m b) -> m ()
- pooledMapConcurrently :: (MonadUnliftIO m, Traversable t) => (a -> m b) -> t a -> m (t b)
- pooledMapConcurrentlyN :: (MonadUnliftIO m, Traversable t) => Int -> (a -> m b) -> t a -> m (t b)
- pooledMapConcurrentlyN_ :: (MonadUnliftIO m, Foldable f) => Int -> (a -> m b) -> f a -> m ()
- pooledMapConcurrently_ :: (MonadUnliftIO m, Foldable f) => (a -> m b) -> f a -> m ()
- pooledReplicateConcurrently :: MonadUnliftIO m => Int -> m a -> m [a]
- pooledReplicateConcurrentlyN :: MonadUnliftIO m => Int -> Int -> m a -> m [a]
- pooledReplicateConcurrentlyN_ :: MonadUnliftIO m => Int -> Int -> m a -> m ()
- pooledReplicateConcurrently_ :: MonadUnliftIO m => Int -> m a -> m ()
- race :: MonadUnliftIO m => m a -> m b -> m (Either a b)
- race_ :: MonadUnliftIO m => m a -> m b -> m ()
- replicateConcurrently :: MonadUnliftIO f => Int -> f a -> f [a]
- replicateConcurrently_ :: (Applicative m, MonadUnliftIO m) => Int -> m a -> m ()
- runConc :: MonadUnliftIO m => Conc m a -> m a
- uninterruptibleCancel :: MonadIO m => Async a -> m ()
- wait :: MonadIO m => Async a -> m a
- waitAny :: MonadIO m => [Async a] -> m (Async a, a)
- waitAnyCancel :: MonadIO m => [Async a] -> m (Async a, a)
- waitAnyCatch :: MonadIO m => [Async a] -> m (Async a, Either SomeException a)
- waitAnyCatchCancel :: MonadIO m => [Async a] -> m (Async a, Either SomeException a)
- waitBoth :: MonadIO m => Async a -> Async b -> m (a, b)
- waitCatch :: MonadIO m => Async a -> m (Either SomeException a)
- waitEither :: MonadIO m => Async a -> Async b -> m (Either a b)
- waitEitherCancel :: MonadIO m => Async a -> Async b -> m (Either a b)
- waitEitherCatch :: MonadIO m => Async a -> Async b -> m (Either (Either SomeException a) (Either SomeException b))
- waitEitherCatchCancel :: MonadIO m => Async a -> Async b -> m (Either (Either SomeException a) (Either SomeException b))
- waitEither_ :: MonadIO m => Async a -> Async b -> m ()
- withAsync :: MonadUnliftIO m => m a -> (Async a -> m b) -> m b
- withAsyncBound :: MonadUnliftIO m => m a -> (Async a -> m b) -> m b
- withAsyncOn :: MonadUnliftIO m => Int -> m a -> (Async a -> m b) -> m b
- withAsyncOnWithUnmask :: MonadUnliftIO m => Int -> ((forall c. m c -> m c) -> m a) -> (Async a -> m b) -> m b
- withAsyncWithUnmask :: MonadUnliftIO m => ((forall c. m c -> m c) -> m a) -> (Async a -> m b) -> m b
- isEmptyMVar :: MonadIO m => MVar a -> m Bool
- mkWeakMVar :: MonadUnliftIO m => MVar a -> m () -> m (Weak (MVar a))
- modifyMVar :: MonadUnliftIO m => MVar a -> (a -> m (a, b)) -> m b
- modifyMVarMasked :: MonadUnliftIO m => MVar a -> (a -> m (a, b)) -> m b
- modifyMVarMasked_ :: MonadUnliftIO m => MVar a -> (a -> m a) -> m ()
- modifyMVar_ :: MonadUnliftIO m => MVar a -> (a -> m a) -> m ()
- newEmptyMVar :: MonadIO m => m (MVar a)
- newMVar :: MonadIO m => a -> m (MVar a)
- putMVar :: MonadIO m => MVar a -> a -> m ()
- readMVar :: MonadIO m => MVar a -> m a
- swapMVar :: MonadIO m => MVar a -> a -> m a
- takeMVar :: MonadIO m => MVar a -> m a
- tryPutMVar :: MonadIO m => MVar a -> a -> m Bool
- tryReadMVar :: MonadIO m => MVar a -> m (Maybe a)
- tryTakeMVar :: MonadIO m => MVar a -> m (Maybe a)
- withMVar :: MonadUnliftIO m => MVar a -> (a -> m b) -> m b
- withMVarMasked :: MonadUnliftIO m => MVar a -> (a -> m b) -> m b
- memoizeMVar :: MonadUnliftIO m => m a -> m (Memoized a)
- memoizeRef :: MonadUnliftIO m => m a -> m (Memoized a)
- runMemoized :: MonadIO m => Memoized a -> m a
- newQSem :: MonadIO m => Int -> m QSem
- signalQSem :: MonadIO m => QSem -> m ()
- waitQSem :: MonadIO m => QSem -> m ()
- withQSem :: MonadUnliftIO m => QSem -> m a -> m a
- newQSemN :: MonadIO m => Int -> m QSemN
- signalQSemN :: MonadIO m => QSemN -> Int -> m ()
- waitQSemN :: MonadIO m => QSemN -> Int -> m ()
- withQSemN :: MonadUnliftIO m => QSemN -> Int -> m a -> m a
- atomically :: MonadIO m => STM a -> m a
- checkSTM :: Bool -> STM ()
- mkWeakTMVar :: MonadUnliftIO m => TMVar a -> m () -> m (Weak (TMVar a))
- mkWeakTVar :: MonadUnliftIO m => TVar a -> m () -> m (Weak (TVar a))
- newBroadcastTChanIO :: MonadIO m => m (TChan a)
- newEmptyTMVarIO :: MonadIO m => m (TMVar a)
- newTBQueueIO :: MonadIO m => Natural -> m (TBQueue a)
- newTChanIO :: MonadIO m => m (TChan a)
- newTMVarIO :: MonadIO m => a -> m (TMVar a)
- newTQueueIO :: MonadIO m => m (TQueue a)
- newTVarIO :: MonadIO m => a -> m (TVar a)
- readTVarIO :: MonadIO m => TVar a -> m a
- registerDelay :: MonadIO m => Int -> m (TVar Bool)
- retrySTM :: STM a
- withSystemTempDirectory :: MonadUnliftIO m => String -> (FilePath -> m a) -> m a
- withSystemTempFile :: MonadUnliftIO m => String -> (FilePath -> Handle -> m a) -> m a
- withTempDirectory :: MonadUnliftIO m => FilePath -> String -> (FilePath -> m a) -> m a
- withTempFile :: MonadUnliftIO m => FilePath -> String -> (FilePath -> Handle -> m a) -> m a
- timeout :: MonadUnliftIO m => Int -> m a -> m (Maybe a)
- askRunInIO :: MonadUnliftIO m => m (m a -> IO a)
- askUnliftIO :: MonadUnliftIO m => m (UnliftIO m)
- toIO :: MonadUnliftIO m => m a -> m (IO a)
- withUnliftIO :: MonadUnliftIO m => (UnliftIO m -> IO a) -> m a
- wrappedWithRunInIO :: MonadUnliftIO n => (n b -> m b) -> (forall a. m a -> n a) -> ((forall a. m a -> IO a) -> IO b) -> m b
- data Async a
- data AsyncCancelled = AsyncCancelled
- (&&&) :: 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
- data Chan a
- data QSem
- data QSemN
- class Monad m => MonadIO (m :: Type -> Type) where
- class Bifunctor (p :: Type -> Type -> Type) where
- newtype Identity a = Identity {
- runIdentity :: a
- newtype Down a = Down {
- getDown :: a
- data WrappedMonoid m
- class Storable a
- class Applicative f => Alternative (f :: Type -> Type) where
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- data STM a
- data TVar a
- class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- data SomeException = Exception e => SomeException e
- type FilePath = String
- data SeekMode
- type IOError = IOException
- data IOErrorType
- data IOException
- data SomeAsyncException = Exception e => SomeAsyncException e
- data BufferMode
- data Handle
- data IOMode
- data IORef a
- data MVar a
- data STRef s a
- type LByteString = ByteString
- type LText = Text
- type SVector = Vector
- type UVector = Vector
- data ByteString
- type BlazeBuilder = Builder
- class Monoid builder => Builder builder lazy | builder -> lazy, lazy -> builder where
- builderToLazy :: builder -> lazy
- flushBuilder :: builder
- type ByteStringBuilder = Builder
- type TextBuilder = Builder
- class ToBuilder value builder where
- toBuilder :: value -> builder
- zipWith :: Zip f => (a -> b -> c) -> f a -> f b -> f c
- unzip :: Zip f => f (a, b) -> (f a, f b)
- zip :: Zip f => f a -> f b -> f (a, b)
- zipWith3 :: Zip3 f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- unzip3 :: Zip3 f => f (a, b, c) -> (f a, f b, f c)
- zip3 :: Zip3 f => f a -> f b -> f c -> f (a, b, c)
- zipWith4 :: Zip4 f => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e
- unzip4 :: Zip4 f => f (a, b, c, d) -> (f a, f b, f c, f d)
- zip4 :: Zip4 f => f a -> f b -> f c -> f d -> f (a, b, c, d)
- zipWith5 :: Zip5 f => (a -> b -> c -> d -> e -> g) -> f a -> f b -> f c -> f d -> f e -> f g
- unzip5 :: Zip5 f => f (a, b, c, d, e) -> (f a, f b, f c, f d, f e)
- zip5 :: Zip5 f => f a -> f b -> f c -> f d -> f e -> f (a, b, c, d, e)
- zipWith6 :: Zip6 f => (a -> b -> c -> d -> e -> g -> h) -> f a -> f b -> f c -> f d -> f e -> f g -> f h
- unzip6 :: Zip6 f => f (a, b, c, d, e, g) -> (f a, f b, f c, f d, f e, f g)
- zip6 :: Zip6 f => f a -> f b -> f c -> f d -> f e -> f g -> f (a, b, c, d, e, g)
- zipWith7 :: Zip7 f => (a -> b -> c -> d -> e -> g -> h -> i) -> f a -> f b -> f c -> f d -> f e -> f g -> f h -> f i
- unzip7 :: Zip7 f => f (a, b, c, d, e, g, h) -> (f a, f b, f c, f d, f e, f g, f h)
- zip7 :: Zip7 f => f a -> f b -> f c -> f d -> f e -> f g -> f h -> f (a, b, c, d, e, g, h)
- data IntMap a
- data IntSet
- data Map k a
- data Seq a
- data Set a
- class NFData a where
- rnf :: a -> ()
- data DList a
- class Eq a => Hashable a where
- hashWithSalt :: Int -> a -> Int
- hash :: a -> Int
- type family BPMKeyConstraint (map :: Type -> Type -> Type) key
- class BiPolyMap (map :: Type -> Type -> Type) where
- type BPMKeyConstraint (map :: Type -> Type -> Type) key
- mapKeysWith :: (BPMKeyConstraint map k1, BPMKeyConstraint map k2) => (v -> v -> v) -> (k1 -> k2) -> map k1 v -> map k2 v
- type family ContainerKey set
- class SetContainer set => HasKeysSet set where
- type family KeySet set
- class (MonoTraversable map, SetContainer map) => IsMap map where
- type MapValue map
- lookup :: ContainerKey map -> map -> Maybe (MapValue map)
- insertMap :: ContainerKey map -> MapValue map -> map -> map
- deleteMap :: ContainerKey map -> map -> map
- singletonMap :: ContainerKey map -> MapValue map -> map
- mapFromList :: [(ContainerKey map, MapValue map)] -> map
- mapToList :: map -> [(ContainerKey map, MapValue map)]
- findWithDefault :: MapValue map -> ContainerKey map -> map -> MapValue map
- insertWith :: (MapValue map -> MapValue map -> MapValue map) -> ContainerKey map -> MapValue map -> map -> map
- insertWithKey :: (ContainerKey map -> MapValue map -> MapValue map -> MapValue map) -> ContainerKey map -> MapValue map -> map -> map
- insertLookupWithKey :: (ContainerKey map -> MapValue map -> MapValue map -> MapValue map) -> ContainerKey map -> MapValue map -> map -> (Maybe (MapValue map), map)
- adjustMap :: (MapValue map -> MapValue map) -> ContainerKey map -> map -> map
- adjustWithKey :: (ContainerKey map -> MapValue map -> MapValue map) -> ContainerKey map -> map -> map
- updateMap :: (MapValue map -> Maybe (MapValue map)) -> ContainerKey map -> map -> map
- updateWithKey :: (ContainerKey map -> MapValue map -> Maybe (MapValue map)) -> ContainerKey map -> map -> map
- updateLookupWithKey :: (ContainerKey map -> MapValue map -> Maybe (MapValue map)) -> ContainerKey map -> map -> (Maybe (MapValue map), map)
- alterMap :: (Maybe (MapValue map) -> Maybe (MapValue map)) -> ContainerKey map -> map -> map
- unionWith :: (MapValue map -> MapValue map -> MapValue map) -> map -> map -> map
- unionWithKey :: (ContainerKey map -> MapValue map -> MapValue map -> MapValue map) -> map -> map -> map
- unionsWith :: (MapValue map -> MapValue map -> MapValue map) -> [map] -> map
- mapWithKey :: (ContainerKey map -> MapValue map -> MapValue map) -> map -> map
- omapKeysWith :: (MapValue map -> MapValue map -> MapValue map) -> (ContainerKey map -> ContainerKey map) -> map -> map
- filterMap :: (MapValue map -> Bool) -> map -> map
- type family MapValue map
- class (SetContainer set, Element set ~ ContainerKey set) => IsSet set where
- class MonoFunctor mono => MonoZip mono where
- class PolyMap (map :: Type -> Type) where
- differenceMap :: map value1 -> map value2 -> map value1
- intersectionMap :: map value1 -> map value2 -> map value1
- intersectionWithMap :: (value1 -> value2 -> value3) -> map value1 -> map value2 -> map value3
- class (Monoid set, Semigroup set, MonoFoldable set, Eq (ContainerKey set), GrowingAppend set) => SetContainer set where
- type ContainerKey set
- member :: ContainerKey set -> set -> Bool
- notMember :: ContainerKey set -> set -> Bool
- union :: set -> set -> set
- unions :: (MonoFoldable mono, Element mono ~ set) => mono -> set
- difference :: set -> set -> set
- intersection :: set -> set -> set
- keys :: set -> [ContainerKey set]
- type family Element mono
- class MonoFoldable mono => GrowingAppend mono
- class MonoFunctor mono => MonoComonad mono where
- class MonoFoldable mono where
- ofoldMap :: Monoid m => (Element mono -> m) -> mono -> m
- ofoldr :: (Element mono -> b -> b) -> b -> mono -> b
- ofoldl' :: (a -> Element mono -> a) -> a -> mono -> a
- otoList :: mono -> [Element mono]
- oall :: (Element mono -> Bool) -> mono -> Bool
- oany :: (Element mono -> Bool) -> mono -> Bool
- onull :: mono -> Bool
- olength :: mono -> Int
- olength64 :: mono -> Int64
- ocompareLength :: Integral i => mono -> i -> Ordering
- otraverse_ :: Applicative f => (Element mono -> f b) -> mono -> f ()
- ofor_ :: Applicative f => mono -> (Element mono -> f b) -> f ()
- omapM_ :: Applicative m => (Element mono -> m ()) -> mono -> m ()
- oforM_ :: Applicative m => mono -> (Element mono -> m ()) -> m ()
- ofoldlM :: Monad m => (a -> Element mono -> m a) -> a -> mono -> m a
- ofoldMap1Ex :: Semigroup m => (Element mono -> m) -> mono -> m
- ofoldr1Ex :: (Element mono -> Element mono -> Element mono) -> mono -> Element mono
- ofoldl1Ex' :: (Element mono -> Element mono -> Element mono) -> mono -> Element mono
- headEx :: mono -> Element mono
- lastEx :: mono -> Element mono
- unsafeHead :: mono -> Element mono
- unsafeLast :: mono -> Element mono
- maximumByEx :: (Element mono -> Element mono -> Ordering) -> mono -> Element mono
- minimumByEx :: (Element mono -> Element mono -> Ordering) -> mono -> Element mono
- oelem :: Element mono -> mono -> Bool
- onotElem :: Element mono -> mono -> Bool
- class MonoFunctor mono where
- class MonoPointed mono where
- class (MonoFunctor mono, MonoFoldable mono) => MonoTraversable mono where
- otraverse :: Applicative f => (Element mono -> f (Element mono)) -> mono -> f mono
- omapM :: Applicative m => (Element mono -> m (Element mono)) -> mono -> m mono
- data WrappedMono mono a where
- WrappedMono :: forall mono a. Element mono ~ a => mono -> WrappedMono mono a
- newtype WrappedPoly (f :: Type -> Type) a = WrappedPoly {
- unwrapPoly :: f a
- data NonNull mono
- type family Index seq
- class (Monoid seq, MonoTraversable seq, SemiSequence seq, MonoPointed seq) => IsSequence seq where
- fromList :: [Element seq] -> seq
- lengthIndex :: seq -> Index seq
- break :: (Element seq -> Bool) -> seq -> (seq, seq)
- span :: (Element seq -> Bool) -> seq -> (seq, seq)
- dropWhile :: (Element seq -> Bool) -> seq -> seq
- splitAt :: Index seq -> seq -> (seq, seq)
- unsafeSplitAt :: Index seq -> seq -> (seq, seq)
- unsafeTake :: Index seq -> seq -> seq
- drop :: Index seq -> seq -> seq
- unsafeDrop :: Index seq -> seq -> seq
- dropEnd :: Index seq -> seq -> seq
- partition :: (Element seq -> Bool) -> seq -> (seq, seq)
- uncons :: seq -> Maybe (Element seq, seq)
- unsnoc :: seq -> Maybe (seq, Element seq)
- filter :: (Element seq -> Bool) -> seq -> seq
- filterM :: Monad m => (Element seq -> m Bool) -> seq -> m seq
- replicate :: Index seq -> Element seq -> seq
- replicateM :: Monad m => Index seq -> m (Element seq) -> m seq
- groupBy :: (Element seq -> Element seq -> Bool) -> seq -> [seq]
- groupAllOn :: Eq b => (Element seq -> b) -> seq -> [seq]
- subsequences :: seq -> [seq]
- permutations :: seq -> [seq]
- tailEx :: seq -> seq
- tailMay :: seq -> Maybe seq
- initEx :: seq -> seq
- initMay :: seq -> Maybe seq
- unsafeTail :: seq -> seq
- unsafeInit :: seq -> seq
- indexEx :: seq -> Index seq -> Element seq
- unsafeIndex :: seq -> Index seq -> Element seq
- splitWhen :: (Element seq -> Bool) -> seq -> [seq]
- class (IsSequence lazy, IsSequence strict) => LazySequence lazy strict | lazy -> strict, strict -> lazy where
- toChunks :: lazy -> [strict]
- fromChunks :: [strict] -> lazy
- toStrict :: lazy -> strict
- fromStrict :: strict -> lazy
- class (Integral (Index seq), GrowingAppend seq) => SemiSequence seq where
- class (IsSequence t, IsString t, Element t ~ Char) => Textual t where
- words :: t -> [t]
- unwords :: (Element seq ~ t, MonoFoldable seq) => seq -> t
- lines :: t -> [t]
- unlines :: (Element seq ~ t, MonoFoldable seq) => seq -> t
- toLower :: t -> t
- toUpper :: t -> t
- toCaseFold :: t -> t
- breakWord :: t -> (t, t)
- breakLine :: t -> (t, t)
- class (Textual textual, IsSequence binary) => Utf8 textual binary | textual -> binary, binary -> textual where
- encodeUtf8 :: textual -> binary
- decodeUtf8 :: binary -> textual
- class Monad m => MonadReader r (m :: Type -> Type) | m -> r where
- ask :: m r
- data BRef s a
- type IOBRef = BRef (PrimState IO)
- type family CollElement c
- type family MCState c
- class MutableRef c => MutableAtomicRef c where
- atomicModifyRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> (RefElement c, a)) -> m a
- atomicModifyRef' :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> (RefElement c, a)) -> m a
- class MutableContainer c => MutableCollection c where
- type CollElement c
- newColl :: (PrimMonad m, PrimState m ~ MCState c) => m c
- class MutableContainer c where
- type MCState c
- type MutableDeque c = (MutableQueue c, MutablePushFront c, MutablePopBack c)
- class MutableCollection c => MutablePopBack c where
- class MutableCollection c => MutablePopFront c where
- class MutableCollection c => MutablePushBack c where
- pushBack :: (PrimMonad m, PrimState m ~ MCState c) => c -> CollElement c -> m ()
- class MutableCollection c => MutablePushFront c where
- pushFront :: (PrimMonad m, PrimState m ~ MCState c) => c -> CollElement c -> m ()
- type MutableQueue c = (MutablePopFront c, MutablePushBack c)
- class MutableContainer c => MutableRef c where
- type RefElement c
- newRef :: (PrimMonad m, PrimState m ~ MCState c) => RefElement c -> m c
- readRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> m (RefElement c)
- writeRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> RefElement c -> m ()
- modifyRef :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> RefElement c) -> m ()
- modifyRef' :: (PrimMonad m, PrimState m ~ MCState c) => c -> (RefElement c -> RefElement c) -> m ()
- type family RefElement c
- type MutableStack c = (MutablePopFront c, MutablePushFront c)
- data DLList s a
- type BDeque = Deque MVector
- data Deque (v :: Type -> Type -> Type) s a
- type SDeque = Deque MVector
- type UDeque = Deque MVector
- type IOPRef = PRef (PrimState IO)
- data PRef s a
- type IOSRef = SRef (PrimState IO)
- data SRef s a
- type IOURef = URef (PrimState IO)
- data URef s a
- class Monad m => PrimMonad (m :: Type -> Type) where
- type PrimState (m :: Type -> Type)
- type family PrimState (m :: Type -> Type)
- data MutVar s a = MutVar (MutVar# s a)
- class Prim a
- data TBQueue a
- data TChan a
- data TMVar a
- data TQueue a
- data TBChan a
- data TBMChan a
- data TBMQueue a
- data TMChan a
- data TMQueue a
- data Text
- newtype Day = ModifiedJulianDay {}
- data UTCTime = UTCTime {
- utctDay :: Day
- utctDayTime :: DiffTime
- lift :: (MonadTrans t, Monad m) => m a -> t m a
- type Reader r = ReaderT r Identity
- newtype ReaderT r (m :: Type -> Type) a = ReaderT {
- runReaderT :: r -> m a
- data AsyncExceptionWrapper = Exception e => AsyncExceptionWrapper e
- data Handler (m :: Type -> Type) a = Exception e => Handler (e -> m a)
- data StringException = StringException String CallStack
- data SyncExceptionWrapper = Exception e => SyncExceptionWrapper e
- data Conc (m :: TYPE LiftedRep -> Type) a
- data ConcException = EmptyWithNoAlternative
- newtype Concurrently (m :: Type -> Type) a = Concurrently {
- runConcurrently :: m a
- data Memoized a
- class MonadIO m => MonadUnliftIO (m :: Type -> Type) where
- withRunInIO :: ((forall a. m a -> IO a) -> IO b) -> m b
- newtype UnliftIO (m :: Type -> Type) = UnliftIO {}
- data HashMap k v
- data HashSet a
- data Vector a
- class (Vector Vector a, MVector MVector a) => Unbox a
- cs :: ConvertibleStrings a b => a -> b
- type Id model = Id' (GetTableName model)
- newtype Id' table = Id (PrimaryKey table)
- data StdMethod
Documentation
module IHP.RouterSupport
fromIntegral :: (Integral a, Num b) => a -> b #
realToFrac :: (Real a, Fractional b) => a -> b #
guard :: Alternative f => Bool -> f () #
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 (And a) | |
| Enum a => Enum (Iff a) | |
| Enum a => Enum (Ior a) | |
| Enum a => Enum (Xor a) | |
| 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] # | |