Safe Haskell | None |
---|---|
Language | Haskell2010 |
Rebase.Prelude
Description
This module reexports the non-conflicting definitions from the modules exported by this package, providing a much more featureful alternative to the standard Prelude.
For details check out the source.
Synopsis
- (++) :: [a] -> [a] -> [a]
- seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
- filter :: (a -> Bool) -> [a] -> [a]
- zip :: [a] -> [b] -> [(a, b)]
- newStablePtr :: a -> IO (StablePtr a)
- print :: Show a => a -> IO ()
- fst :: (a, b) -> a
- snd :: (a, b) -> b
- otherwise :: Bool
- assert :: Bool -> a -> a
- lazy :: a -> a
- assertError :: (?callStack :: CallStack) => Bool -> a -> a
- trace :: String -> a -> a
- inline :: a -> a
- map :: (a -> b) -> [a] -> [b]
- groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
- ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
- fromIntegral :: (Integral a, Num b) => a -> b
- realToFrac :: (Real a, Fractional b) => a -> b
- guard :: Alternative f => Bool -> f ()
- class IsList l where
- toDyn :: Typeable a => a -> Dynamic
- 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
- pi :: a
- exp :: a -> a
- log :: a -> a
- sqrt :: a -> a
- (**) :: a -> a -> a
- logBase :: a -> a -> a
- sin :: a -> a
- cos :: a -> a
- tan :: a -> a
- asin :: a -> a
- acos :: a -> a
- atan :: a -> a
- sinh :: a -> a
- cosh :: a -> a
- tanh :: a -> a
- asinh :: a -> a
- acosh :: a -> a
- atanh :: a -> a
- log1p :: a -> a
- expm1 :: a -> a
- log1pexp :: a -> a
- log1mexp :: a -> a
- class Num a => Fractional a where
- (/) :: a -> a -> a
- recip :: a -> a
- fromRational :: Rational -> a
- class (Real a, Enum a) => Integral a where
- class Applicative m => Monad (m :: Type -> Type) where
- class Typeable a => Data a where
- gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> a -> c a
- gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a
- toConstr :: a -> Constr
- dataTypeOf :: a -> DataType
- dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c a)
- dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a)
- gmapT :: (forall b. Data b => b -> b) -> a -> a
- gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
- gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
- gmapQ :: (forall d. Data d => d -> u) -> a -> [u]
- gmapQi :: Int -> (forall d. Data d => d -> u) -> a -> u
- gmapM :: Monad m => (forall d. Data d => d -> m d) -> a -> m a
- gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
- gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
- class Functor (f :: Type -> Type) where
- class Num a where
- class Eq a => Ord a where
- class Read a where
- 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 Ord a => Ix a where
- class Typeable (a :: k)
- class Monad m => MonadFix (m :: Type -> Type) where
- mfix :: (a -> m a) -> m a
- class Monad m => MonadFail (m :: Type -> Type) where
- class IsString a where
- fromString :: String -> a
- class Functor f => Applicative (f :: Type -> Type) where
- class Foldable (t :: Type -> Type) where
- fold :: Monoid m => t m -> m
- foldMap :: Monoid m => (a -> m) -> t a -> m
- foldMap' :: Monoid m => (a -> m) -> t a -> m
- foldr :: (a -> b -> b) -> b -> t a -> b
- foldr' :: (a -> b -> b) -> b -> t a -> b
- foldl :: (b -> a -> b) -> b -> t a -> b
- foldl' :: (b -> a -> b) -> b -> t a -> b
- foldr1 :: (a -> a -> a) -> t a -> a
- foldl1 :: (a -> a -> a) -> t a -> a
- null :: t a -> Bool
- length :: t a -> Int
- elem :: Eq a => a -> t a -> Bool
- maximum :: Ord a => t a -> a
- minimum :: Ord a => t a -> a
- sum :: Num a => t a -> a
- product :: Num a => t a -> a
- class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
- sequenceA :: Applicative f => t (f a) -> f (t a)
- mapM :: Monad m => (a -> m b) -> t a -> m (t b)
- sequence :: Monad m => t (m a) -> m (t a)
- class Generic a
- class IsLabel (x :: Symbol) a where
- fromLabel :: a
- class Semigroup a where
- class Semigroup a => Monoid a where
- class HasField (x :: k) r a | x r -> a where
- getField :: r -> a
- data Bool
- data Char
- data Double
- data Float
- data Int
- data Int8
- data Int16
- data Int32
- data Int64
- data Integer
- data Natural
- data Maybe a
- data Ordering
- data Ratio a
- type Rational = Ratio Integer
- data RealWorld
- data StablePtr a
- data IO a
- data Word
- data Word8
- data Word16
- data Word32
- data Word64
- data Ptr a
- data FunPtr a
- data Either a b
- class a ~R# b => Coercible (a :: k) (b :: k)
- data TyCon
- liftM :: Monad m => (a1 -> r) -> m a1 -> m r
- newtype Op a b = Op {
- getOp :: b -> a
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- class Contravariant (f :: Type -> Type) where
- class Monad m => MonadReader r (m :: Type -> Type) | m -> r where
- class Monad m => MonadState s (m :: Type -> Type) | m -> s where
- data ForeignPtr a
- data Handle
- data ST s a
- phase :: RealFloat a => Complex a -> a
- magnitude :: RealFloat a => Complex a -> a
- polar :: RealFloat a => Complex a -> (a, a)
- cis :: Floating a => a -> Complex a
- mkPolar :: Floating a => a -> a -> Complex a
- conjugate :: Num a => Complex a -> Complex a
- imagPart :: Complex a -> a
- realPart :: Complex a -> a
- data Complex a = !a :+ !a
- showFixed :: forall k (a :: k). HasResolution a => Bool -> Fixed a -> String
- mod' :: Real a => a -> a -> a
- divMod' :: (Real a, Integral b) => a -> a -> (b, a)
- div' :: (Real a, Integral b) => a -> a -> b
- newtype Fixed (a :: k) = MkFixed Integer
- class HasResolution (a :: k) where
- resolution :: p a -> Integer
- data E0
- type Uni = Fixed E0
- data E1
- type Deci = Fixed E1
- data E2
- type Centi = Fixed E2
- data E3
- type Milli = Fixed E3
- data E6
- type Micro = Fixed E6
- data E9
- type Nano = Fixed E9
- data E12
- type Pico = Fixed E12
- comparisonEquivalence :: Comparison a -> Equivalence a
- defaultEquivalence :: Eq a => Equivalence a
- defaultComparison :: Ord a => Comparison a
- (>$$<) :: Contravariant f => f b -> (a -> b) -> f a
- (>$<) :: Contravariant f => (a -> b) -> f b -> f a
- ($<) :: Contravariant f => f b -> b -> f a
- phantom :: (Functor f, Contravariant f) => f a -> f b
- newtype Predicate a = Predicate {
- getPredicate :: a -> Bool
- newtype Comparison a = Comparison {
- getComparison :: a -> a -> Ordering
- newtype Equivalence a = Equivalence {
- getEquivalence :: a -> a -> Bool
- newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) = Compose {
- getCompose :: f (g a)
- vacuous :: Functor f => f Void -> f a
- absurd :: Void -> a
- data Void
- option :: b -> (a -> b) -> Option a -> b
- mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
- diff :: Semigroup m => m -> Endo m
- cycle1 :: Semigroup m => m -> m
- newtype Min a = Min {
- getMin :: a
- newtype Max a = Max {
- getMax :: a
- data Arg a b = Arg a b
- type ArgMin a b = Min (Arg a b)
- type ArgMax a b = Max (Arg a b)
- newtype First a = First {
- getFirst :: a
- newtype Last a = Last {
- getLast :: a
- newtype WrappedMonoid m = WrapMonoid {
- unwrapMonoid :: m
- newtype Option a = Option {}
- sortWith :: Ord b => (a -> b) -> [a] -> [a]
- type family Item l
- tyconModule :: String -> String
- tyconUQname :: String -> String
- isNorepType :: DataType -> Bool
- mkNoRepType :: String -> DataType
- mkCharConstr :: DataType -> Char -> Constr
- mkRealConstr :: (Real a, Show a) => DataType -> a -> Constr
- mkIntegralConstr :: (Integral a, Show a) => DataType -> a -> Constr
- mkCharType :: String -> DataType
- mkFloatType :: String -> DataType
- mkIntType :: String -> DataType
- maxConstrIndex :: DataType -> ConIndex
- constrIndex :: Constr -> ConIndex
- indexConstr :: DataType -> ConIndex -> Constr
- isAlgType :: DataType -> Bool
- readConstr :: DataType -> String -> Maybe Constr
- showConstr :: Constr -> String
- constrFixity :: Constr -> Fixity
- constrFields :: Constr -> [String]
- dataTypeConstrs :: DataType -> [Constr]
- mkConstr :: DataType -> String -> [String] -> Fixity -> Constr
- mkDataType :: String -> [Constr] -> DataType
- repConstr :: DataType -> ConstrRep -> Constr
- constrRep :: Constr -> ConstrRep
- constrType :: Constr -> DataType
- dataTypeRep :: DataType -> DataRep
- dataTypeName :: DataType -> String
- fromConstrM :: (Monad m, Data a) => (forall d. Data d => m d) -> Constr -> m a
- fromConstrB :: Data a => (forall d. Data d => d) -> Constr -> a
- fromConstr :: Data a => Constr -> a
- data DataType
- data Constr
- data DataRep
- data ConstrRep
- type ConIndex = Int
- data Fixity
- timeout :: Int -> IO a -> IO (Maybe a)
- data Timeout
- threadWaitWriteSTM :: Fd -> IO (STM (), IO ())
- threadWaitReadSTM :: Fd -> IO (STM (), IO ())
- threadWaitWrite :: Fd -> IO ()
- threadWaitRead :: Fd -> IO ()
- runInUnboundThread :: IO a -> IO a
- runInBoundThread :: IO a -> IO a
- isCurrentThreadBound :: IO Bool
- forkOSWithUnmask :: ((forall a. IO a -> IO a) -> IO ()) -> IO ThreadId
- forkOS :: IO () -> IO ThreadId
- forkFinally :: IO a -> (Either SomeException a -> IO ()) -> IO ThreadId
- rtsSupportsBoundThreads :: Bool
- writeList2Chan :: Chan a -> [a] -> IO ()
- getChanContents :: Chan a -> IO [a]
- dupChan :: Chan a -> IO (Chan a)
- readChan :: Chan a -> IO a
- writeChan :: Chan a -> a -> IO ()
- newChan :: IO (Chan a)
- data Chan a
- signalQSem :: QSem -> IO ()
- waitQSem :: QSem -> IO ()
- newQSem :: Int -> IO QSem
- data QSem
- signalQSemN :: QSemN -> Int -> IO ()
- waitQSemN :: QSemN -> Int -> IO ()
- newQSemN :: Int -> IO QSemN
- data QSemN
- class Bifunctor (p :: Type -> Type -> Type) where
- showsBinary1 :: (Show1 f, Show1 g, Show a) => String -> Int -> f a -> g a -> ShowS
- showsUnary1 :: (Show1 f, Show a) => String -> Int -> f a -> ShowS
- showsUnary :: Show a => String -> Int -> a -> ShowS
- readsBinary1 :: (Read1 f, Read1 g, Read a) => String -> (f a -> g a -> t) -> String -> ReadS t
- readsUnary1 :: (Read1 f, Read a) => String -> (f a -> t) -> String -> ReadS t
- readsUnary :: Read a => String -> (a -> t) -> String -> ReadS t
- showsBinaryWith :: (Int -> a -> ShowS) -> (Int -> b -> ShowS) -> String -> Int -> a -> b -> ShowS
- showsUnaryWith :: (Int -> a -> ShowS) -> String -> Int -> a -> ShowS
- readBinaryWith :: ReadPrec a -> ReadPrec b -> String -> (a -> b -> t) -> ReadPrec t
- readsBinaryWith :: (Int -> ReadS a) -> (Int -> ReadS b) -> String -> (a -> b -> t) -> String -> ReadS t
- readUnaryWith :: ReadPrec a -> String -> (a -> t) -> ReadPrec t
- readsUnaryWith :: (Int -> ReadS a) -> String -> (a -> t) -> String -> ReadS t
- readData :: ReadPrec a -> ReadPrec a
- readsData :: (String -> ReadS a) -> Int -> ReadS a
- showsPrec2 :: (Show2 f, Show a, Show b) => Int -> f a b -> ShowS
- liftReadListPrec2Default :: Read2 f => ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [f a b]
- liftReadList2Default :: Read2 f => (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [f a b]
- readPrec2 :: (Read2 f, Read a, Read b) => ReadPrec (f a b)
- readsPrec2 :: (Read2 f, Read a, Read b) => Int -> ReadS (f a b)
- compare2 :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> Ordering
- eq2 :: (Eq2 f, Eq a, Eq b) => f a b -> f a b -> Bool
- showsPrec1 :: (Show1 f, Show a) => Int -> f a -> ShowS
- liftReadListPrecDefault :: Read1 f => ReadPrec a -> ReadPrec [a] -> ReadPrec [f a]
- liftReadListDefault :: Read1 f => (Int -> ReadS a) -> ReadS [a] -> ReadS [f a]
- readPrec1 :: (Read1 f, Read a) => ReadPrec (f a)
- readsPrec1 :: (Read1 f, Read a) => Int -> ReadS (f a)
- compare1 :: (Ord1 f, Ord a) => f a -> f a -> Ordering
- eq1 :: (Eq1 f, Eq a) => f a -> f a -> Bool
- class Eq1 (f :: Type -> Type) where
- class Eq1 f => Ord1 (f :: Type -> Type) where
- liftCompare :: (a -> b -> Ordering) -> f a -> f b -> Ordering
- class Read1 (f :: Type -> Type) where
- liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a)
- liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [f a]
- liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (f a)
- liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [f a]
- class Show1 (f :: Type -> Type) where
- class Eq2 (f :: Type -> Type -> Type) where
- class Eq2 f => Ord2 (f :: Type -> Type -> Type) where
- liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> f a c -> f b d -> Ordering
- class Read2 (f :: Type -> Type -> Type) where
- liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (f a b)
- liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [f a b]
- liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (f a b)
- liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [f a b]
- class Show2 (f :: Type -> Type -> Type) where
- class Monad m => MonadIO (m :: Type -> Type) where
- approxRational :: RealFrac a => a -> a -> Rational
- modifySTRef' :: STRef s a -> (a -> a) -> ST s ()
- modifySTRef :: STRef s a -> (a -> a) -> ST s ()
- hashUnique :: Unique -> Int
- newUnique :: IO Unique
- data Unique
- eqStableName :: StableName a -> StableName b -> Bool
- hashStableName :: StableName a -> Int
- makeStableName :: a -> IO (StableName a)
- data StableName a
- getEnvironment :: IO [(String, String)]
- withProgName :: String -> IO a -> IO a
- withArgs :: [String] -> IO a -> IO a
- unsetEnv :: String -> IO ()
- setEnv :: String -> String -> IO ()
- lookupEnv :: String -> IO (Maybe String)
- getEnv :: String -> IO String
- getProgName :: IO String
- getArgs :: IO [String]
- getExecutablePath :: IO FilePath
- die :: String -> IO a
- exitSuccess :: IO a
- exitFailure :: IO a
- exitWith :: ExitCode -> IO a
- performGC :: IO ()
- performMajorGC :: IO ()
- performMinorGC :: IO ()
- hPrintf :: HPrintfType r => Handle -> String -> r
- printf :: PrintfType r => String -> r
- mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- (<$!>) :: Monad m => (a -> b) -> m a -> m b
- unless :: Applicative f => Bool -> f () -> f ()
- replicateM_ :: Applicative m => Int -> m a -> m ()
- replicateM :: Applicative m => Int -> m a -> m [a]
- foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
- foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- forever :: Applicative f => f a -> f b
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- makeVersion :: [Int] -> Version
- parseVersion :: ReadP Version
- showVersion :: Version -> String
- data Version = Version {
- versionBranch :: [Int]
- versionTags :: [String]
- traceMarkerIO :: String -> IO ()
- traceMarker :: String -> a -> a
- traceEventIO :: String -> IO ()
- traceEvent :: String -> a -> a
- traceStack :: String -> a -> a
- traceShowM :: (Show a, Applicative f) => a -> f ()
- traceM :: Applicative f => String -> f ()
- traceShowId :: Show a => a -> a
- traceShow :: Show a => a -> b -> b
- traceId :: String -> String
- putTraceMsg :: String -> IO ()
- traceIO :: String -> IO ()
- isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
- foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
- fmapDefault :: Traversable t => (a -> b) -> t a -> t b
- mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
- optional :: Alternative f => f a -> f (Maybe a)
- newtype WrappedMonad (m :: Type -> Type) a = WrapMonad {
- unwrapMonad :: m a
- newtype WrappedArrow (a :: Type -> Type -> Type) b c = WrapArrow {
- unwrapArrow :: a b c
- newtype ZipList a = ZipList {
- getZipList :: [a]
- leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d)
- (^<<) :: Arrow a => (c -> d) -> a b c -> a b d
- (<<^) :: Arrow a => a c d -> (b -> c) -> a b d
- (>>^) :: Arrow a => a b c -> (c -> d) -> a b d
- (^>>) :: Arrow a => (b -> c) -> a c d -> a b d
- returnA :: Arrow a => a b b
- class Category a => Arrow (a :: Type -> Type -> Type) where
- newtype Kleisli (m :: Type -> Type) a b = Kleisli {
- runKleisli :: a -> m b
- class Arrow a => ArrowZero (a :: Type -> Type -> Type) where
- zeroArrow :: a b c
- class ArrowZero a => ArrowPlus (a :: Type -> Type -> Type) where
- (<+>) :: a b c -> a b c -> a b c
- class Arrow a => ArrowChoice (a :: Type -> Type -> Type) where
- class Arrow a => ArrowApply (a :: Type -> Type -> Type) where
- app :: a (a b c, b) c
- newtype ArrowMonad (a :: Type -> Type -> Type) b = ArrowMonad (a () b)
- class Arrow a => ArrowLoop (a :: Type -> Type -> Type) where
- loop :: a (b, d) (c, d) -> a b c
- newtype Identity a = Identity {
- runIdentity :: a
- readIO :: Read a => String -> IO a
- readLn :: Read a => IO a
- appendFile :: FilePath -> String -> IO ()
- writeFile :: FilePath -> String -> IO ()
- readFile :: FilePath -> IO String
- interact :: (String -> String) -> IO ()
- getContents :: IO String
- getLine :: IO String
- getChar :: IO Char
- putStrLn :: String -> IO ()
- putStr :: String -> IO ()
- putChar :: Char -> IO ()
- hClose :: Handle -> IO ()
- registerDelay :: Int -> IO (TVar Bool)
- threadDelay :: Int -> IO ()
- closeFdWith :: (Fd -> IO ()) -> Fd -> IO ()
- ioManagerCapabilitiesChanged :: IO ()
- ensureIOManagerIsRunning :: IO ()
- runHandlers :: ForeignPtr Word8 -> Signal -> IO ()
- setHandler :: Signal -> Maybe (HandlerFun, Dynamic) -> IO (Maybe (HandlerFun, Dynamic))
- type Signal = CInt
- type HandlerFun = ForeignPtr Word8 -> IO ()
- mkWeakMVar :: MVar a -> IO () -> IO (Weak (MVar a))
- addMVarFinalizer :: MVar a -> IO () -> IO ()
- modifyMVarMasked :: MVar a -> (a -> IO (a, b)) -> IO b
- modifyMVarMasked_ :: MVar a -> (a -> IO a) -> IO ()
- modifyMVar :: MVar a -> (a -> IO (a, b)) -> IO b
- modifyMVar_ :: MVar a -> (a -> IO a) -> IO ()
- withMVarMasked :: MVar a -> (a -> IO b) -> IO b
- withMVar :: MVar a -> (a -> IO b) -> IO b
- swapMVar :: MVar a -> a -> IO a
- unsafeFixIO :: (a -> IO a) -> IO a
- allowInterrupt :: IO ()
- catches :: IO a -> [Handler a] -> IO a
- data Handler a = Exception e => Handler (e -> IO a)
- fixST :: (a -> ST s a) -> ST s a
- catchIOError :: IO a -> (IOError -> IO a) -> IO a
- annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
- modifyIOError :: (IOError -> IOError) -> IO a -> IO a
- ioeSetFileName :: IOError -> FilePath -> IOError
- ioeSetHandle :: IOError -> Handle -> IOError
- ioeSetLocation :: IOError -> String -> IOError
- ioeSetErrorString :: IOError -> String -> IOError
- ioeSetErrorType :: IOError -> IOErrorType -> IOError
- ioeGetFileName :: IOError -> Maybe FilePath
- ioeGetHandle :: IOError -> Maybe Handle
- ioeGetLocation :: IOError -> String
- ioeGetErrorString :: IOError -> String
- ioeGetErrorType :: IOError -> IOErrorType
- isResourceVanishedErrorType :: IOErrorType -> Bool
- isUserErrorType :: IOErrorType -> Bool
- isPermissionErrorType :: IOErrorType -> Bool
- isIllegalOperationErrorType :: IOErrorType -> Bool
- isEOFErrorType :: IOErrorType -> Bool
- isFullErrorType :: IOErrorType -> Bool
- isAlreadyInUseErrorType :: IOErrorType -> Bool
- isDoesNotExistErrorType :: IOErrorType -> Bool
- isAlreadyExistsErrorType :: IOErrorType -> Bool
- resourceVanishedErrorType :: IOErrorType
- userErrorType :: IOErrorType
- permissionErrorType :: IOErrorType
- illegalOperationErrorType :: IOErrorType
- eofErrorType :: IOErrorType
- fullErrorType :: IOErrorType
- alreadyInUseErrorType :: IOErrorType
- doesNotExistErrorType :: IOErrorType
- alreadyExistsErrorType :: IOErrorType
- isResourceVanishedError :: IOError -> Bool
- isUserError :: IOError -> Bool
- isPermissionError :: IOError -> Bool
- isIllegalOperation :: IOError -> Bool
- isEOFError :: IOError -> Bool
- isFullError :: IOError -> Bool
- isAlreadyInUseError :: IOError -> Bool
- isDoesNotExistError :: IOError -> Bool
- isAlreadyExistsError :: IOError -> Bool
- mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError
- tryIOError :: IO a -> IO (Either IOError a)
- bracketOnError :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
- bracket_ :: IO a -> IO b -> IO c -> IO c
- finally :: IO a -> IO b -> IO a
- bracket :: IO a -> (a -> IO b) -> (a -> IO c) -> IO c
- onException :: IO a -> IO b -> IO a
- tryJust :: Exception e => (e -> Maybe b) -> IO a -> IO (Either b a)
- try :: Exception e => IO a -> IO (Either e a)
- mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
- handleJust :: Exception e => (e -> Maybe b) -> (b -> IO a) -> IO a -> IO a
- handle :: Exception e => (e -> IO a) -> IO a -> IO a
- catchJust :: Exception e => (e -> Maybe b) -> IO a -> (b -> IO a) -> IO a
- newtype PatternMatchFail = PatternMatchFail String
- newtype RecSelError = RecSelError String
- newtype RecConError = RecConError String
- newtype RecUpdError = RecUpdError String
- newtype NoMethodError = NoMethodError String
- newtype TypeError = TypeError String
- data NonTermination = NonTermination
- data NestedAtomically = NestedAtomically
- getUncaughtExceptionHandler :: IO (SomeException -> IO ())
- setUncaughtExceptionHandler :: (SomeException -> IO ()) -> IO ()
- reportError :: SomeException -> IO ()
- reportStackOverflow :: IO ()
- writeTVar :: TVar a -> a -> STM ()
- readTVar :: TVar a -> STM a
- readTVarIO :: TVar a -> IO a
- newTVarIO :: a -> IO (TVar a)
- newTVar :: a -> STM (TVar a)
- catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a
- throwSTM :: Exception e => e -> STM a
- retry :: STM a
- atomically :: STM a -> IO a
- unsafeIOToSTM :: IO a -> STM a
- newStablePtrPrimMVar :: MVar () -> IO (StablePtr PrimMVar)
- mkWeakThreadId :: ThreadId -> IO (Weak ThreadId)
- threadCapability :: ThreadId -> IO (Int, Bool)
- threadStatus :: ThreadId -> IO ThreadStatus
- runSparks :: IO ()
- par :: a -> b -> b
- pseq :: a -> b -> b
- labelThread :: ThreadId -> String -> IO ()
- yield :: IO ()
- myThreadId :: IO ThreadId
- throwTo :: Exception e => ThreadId -> e -> IO ()
- killThread :: ThreadId -> IO ()
- childHandler :: SomeException -> IO ()
- numSparks :: IO Int
- getNumProcessors :: IO Int
- setNumCapabilities :: Int -> IO ()
- getNumCapabilities :: IO Int
- numCapabilities :: Int
- forkOnWithUnmask :: Int -> ((forall a. IO a -> IO a) -> IO ()) -> IO ThreadId
- forkOn :: Int -> IO () -> IO ThreadId
- forkIOWithUnmask :: ((forall a. IO a -> IO a) -> IO ()) -> IO ThreadId
- forkIO :: IO () -> IO ThreadId
- disableAllocationLimit :: IO ()
- enableAllocationLimit :: IO ()
- getAllocationCounter :: IO Int64
- setAllocationCounter :: Int64 -> IO ()
- reportHeapOverflow :: IO ()
- data ThreadId = ThreadId ThreadId#
- data BlockReason
- data ThreadStatus
- data PrimMVar
- newtype STM a = STM (State# RealWorld -> (# State# RealWorld, a #))
- data TVar a = TVar (TVar# RealWorld a)
- dynTypeRep :: Dynamic -> SomeTypeRep
- dynApp :: Dynamic -> Dynamic -> Dynamic
- dynApply :: Dynamic -> Dynamic -> Maybe Dynamic
- fromDynamic :: Typeable a => Dynamic -> Maybe a
- fromDyn :: Typeable a => Dynamic -> a -> a
- data Dynamic where
- untangle :: Addr# -> String -> String
- ioError :: IOError -> IO a
- ioException :: IOException -> IO a
- heapOverflow :: SomeException
- stackOverflow :: SomeException
- asyncExceptionFromException :: Exception e => SomeException -> Maybe e
- asyncExceptionToException :: Exception e => e -> SomeException
- cannotCompactMutable :: SomeException
- cannotCompactPinned :: SomeException
- cannotCompactFunction :: SomeException
- allocationLimitExceeded :: SomeException
- blockedIndefinitelyOnSTM :: SomeException
- blockedIndefinitelyOnMVar :: SomeException
- data BlockedIndefinitelyOnMVar = BlockedIndefinitelyOnMVar
- data BlockedIndefinitelyOnSTM = BlockedIndefinitelyOnSTM
- data Deadlock = Deadlock
- data AllocationLimitExceeded = AllocationLimitExceeded
- newtype CompactionFailed = CompactionFailed String
- newtype AssertionFailed = AssertionFailed String
- data SomeAsyncException = Exception e => SomeAsyncException e
- data AsyncException
- data ArrayException
- data FixIOException = FixIOException
- data ExitCode
- data IOErrorType
- atomicWriteIORef :: IORef a -> a -> IO ()
- atomicModifyIORef :: IORef a -> (a -> (a, b)) -> IO b
- modifyIORef' :: IORef a -> (a -> a) -> IO ()
- modifyIORef :: IORef a -> (a -> a) -> IO ()
- mkWeakIORef :: IORef a -> IO () -> IO (Weak (IORef a))
- mallocForeignPtrArray0 :: Storable a => Int -> IO (ForeignPtr a)
- mallocForeignPtrArray :: Storable a => Int -> IO (ForeignPtr a)
- newForeignPtrEnv :: FinalizerEnvPtr env a -> Ptr env -> Ptr a -> IO (ForeignPtr a)
- withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
- newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
- finalizeForeignPtr :: ForeignPtr a -> IO ()
- plusForeignPtr :: ForeignPtr a -> Int -> ForeignPtr b
- castForeignPtr :: ForeignPtr a -> ForeignPtr b
- touchForeignPtr :: ForeignPtr a -> IO ()
- newForeignPtr_ :: Ptr a -> IO (ForeignPtr a)
- addForeignPtrFinalizerEnv :: FinalizerEnvPtr env a -> Ptr env -> ForeignPtr a -> IO ()
- addForeignPtrFinalizer :: FinalizerPtr a -> ForeignPtr a -> IO ()
- mallocForeignPtrBytes :: Int -> IO (ForeignPtr a)
- mallocForeignPtr :: Storable a => IO (ForeignPtr a)
- type FinalizerPtr a = FunPtr (Ptr a -> IO ())
- type FinalizerEnvPtr env a = FunPtr (Ptr env -> Ptr a -> IO ())
- atomicModifyIORef' :: IORef a -> (a -> (a, b)) -> IO b
- writeIORef :: IORef a -> a -> IO ()
- readIORef :: IORef a -> IO a
- newIORef :: a -> IO (IORef a)
- data IORef a
- evaluate :: a -> IO a
- uninterruptibleMask :: ((forall a. IO a -> IO a) -> IO b) -> IO b
- uninterruptibleMask_ :: IO a -> IO a
- mask :: ((forall a. IO a -> IO a) -> IO b) -> IO b
- mask_ :: IO a -> IO a
- getMaskingState :: IO MaskingState
- interruptible :: IO a -> IO a
- throwIO :: Exception e => e -> IO a
- catch :: Exception e => IO a -> (e -> IO a) -> IO a
- stToIO :: ST RealWorld a -> IO a
- type FilePath = String
- data MaskingState
- userError :: String -> IOError
- unsupportedOperation :: IOError
- data IOException = IOError {}
- type IOError = IOException
- throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
- data ErrorCall where
- class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- data ArithException
- typeOf7 :: Typeable t => t a b c d e f g -> TypeRep
- typeOf6 :: Typeable t => t a b c d e f -> TypeRep
- typeOf5 :: Typeable t => t a b c d e -> TypeRep
- typeOf4 :: Typeable t => t a b c d -> TypeRep
- typeOf3 :: Typeable t => t a b c -> TypeRep
- typeOf2 :: Typeable t => t a b -> TypeRep
- typeOf1 :: Typeable t => t a -> TypeRep
- rnfTypeRep :: TypeRep -> ()
- typeRepFingerprint :: TypeRep -> Fingerprint
- typeRepTyCon :: TypeRep -> TyCon
- typeRepArgs :: TypeRep -> [TypeRep]
- splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
- mkFunTy :: TypeRep -> TypeRep -> TypeRep
- funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep
- gcast2 :: forall k1 k2 k3 c (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))
- gcast1 :: forall k1 k2 c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))
- gcast :: forall k (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b)
- eqT :: forall k (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b)
- cast :: (Typeable a, Typeable b) => a -> Maybe b
- showsTypeRep :: TypeRep -> ShowS
- typeRep :: forall k proxy (a :: k). Typeable a => proxy a -> TypeRep
- typeOf :: Typeable a => a -> TypeRep
- type TypeRep = SomeTypeRep
- rnfTyCon :: TyCon -> ()
- tyConFingerprint :: TyCon -> Fingerprint
- tyConName :: TyCon -> String
- tyConModule :: TyCon -> String
- tyConPackage :: TyCon -> String
- newtype Const a (b :: k) = Const {
- getConst :: a
- find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- notElem :: (Foldable t, Eq a) => a -> t a -> Bool
- minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
- maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
- all :: Foldable t => (a -> Bool) -> t a -> Bool
- any :: Foldable t => (a -> Bool) -> t a -> Bool
- or :: Foldable t => t Bool -> Bool
- and :: Foldable t => t Bool -> Bool
- concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- concat :: Foldable t => t [a] -> [a]
- msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
- asum :: (Foldable t, Alternative f) => t (f a) -> f a
- sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
- forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
- traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
- foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
- newtype Ap (f :: k -> Type) (a :: k) = Ap {
- getAp :: f a
- stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
- stimesIdempotent :: Integral b => b -> a -> a
- newtype Dual a = Dual {
- getDual :: a
- newtype Endo a = Endo {
- appEndo :: a -> a
- newtype All = All {}
- newtype Any = Any {}
- newtype Sum a = Sum {
- getSum :: a
- newtype Product a = Product {
- getProduct :: a
- getAlt :: Alt f a -> f a
- unsafeCoerce :: a -> b
- unwords :: [String] -> String
- words :: String -> [String]
- unlines :: [String] -> String
- lines :: String -> [String]
- unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- sortOn :: Ord b => (a -> b) -> [a] -> [a]
- sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- sort :: Ord a => [a] -> [a]
- permutations :: [a] -> [[a]]
- subsequences :: [a] -> [[a]]
- tails :: [a] -> [[a]]
- inits :: [a] -> [[a]]
- groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
- group :: Eq a => [a] -> [[a]]
- deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
- unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
- unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
- unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
- zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
- zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
- zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
- zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
- zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
- zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
- zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
- zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
- genericReplicate :: Integral i => i -> a -> [a]
- genericIndex :: Integral i => [a] -> i -> a
- genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
- genericDrop :: Integral i => i -> [a] -> [a]
- genericTake :: Integral i => i -> [a] -> [a]
- genericLength :: Num i => [a] -> i
- insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
- insert :: Ord a => a -> [a] -> [a]
- partition :: (a -> Bool) -> [a] -> ([a], [a])
- transpose :: [[a]] -> [[a]]
- intercalate :: [a] -> [[a]] -> [a]
- intersperse :: a -> [a] -> [a]
- intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- intersect :: Eq a => [a] -> [a] -> [a]
- unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- union :: Eq a => [a] -> [a] -> [a]
- (\\) :: Eq a => [a] -> [a] -> [a]
- deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
- delete :: Eq a => a -> [a] -> [a]
- nubBy :: (a -> a -> Bool) -> [a] -> [a]
- nub :: Eq a => [a] -> [a]
- isInfixOf :: Eq a => [a] -> [a] -> Bool
- isSuffixOf :: Eq a => [a] -> [a] -> Bool
- isPrefixOf :: Eq a => [a] -> [a] -> Bool
- findIndices :: (a -> Bool) -> [a] -> [Int]
- findIndex :: (a -> Bool) -> [a] -> Maybe Int
- elemIndices :: Eq a => a -> [a] -> [Int]
- elemIndex :: Eq a => a -> [a] -> Maybe Int
- stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
- dropWhileEnd :: (a -> Bool) -> [a] -> [a]
- isSeparator :: Char -> Bool
- isNumber :: Char -> Bool
- isMark :: Char -> Bool
- isLetter :: Char -> Bool
- digitToInt :: Char -> Int
- read :: Read a => String -> a
- readMaybe :: Read a => String -> Maybe a
- readEither :: Read a => String -> Either String a
- reads :: Read a => ReadS a
- fromRight :: b -> Either a b -> b
- fromLeft :: a -> Either a b -> a
- isRight :: Either a b -> Bool
- isLeft :: Either a b -> Bool
- partitionEithers :: [Either a b] -> ([a], [b])
- rights :: [Either a b] -> [b]
- lefts :: [Either a b] -> [a]
- comparing :: Ord a => (b -> a) -> b -> b -> Ordering
- newtype Down a = Down {
- getDown :: a
- asProxyTypeOf :: a -> proxy a -> a
- data Proxy (t :: k) = Proxy
- data KProxy t = KProxy
- (>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
- (<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- class Category (cat :: k -> k -> Type) where
- data (a :: k) :~: (b :: k) where
- data (a :: k1) :~~: (b :: k2) where
- intPtrToPtr :: IntPtr -> Ptr a
- ptrToIntPtr :: Ptr a -> IntPtr
- wordPtrToPtr :: WordPtr -> Ptr a
- ptrToWordPtr :: Ptr a -> WordPtr
- freeHaskellFunPtr :: FunPtr a -> IO ()
- newtype WordPtr = WordPtr Word
- newtype IntPtr = IntPtr Int
- class Storable a where
- castPtrToStablePtr :: Ptr () -> StablePtr a
- castStablePtrToPtr :: StablePtr a -> Ptr ()
- deRefStablePtr :: StablePtr a -> IO a
- freeStablePtr :: StablePtr a -> IO ()
- castPtrToFunPtr :: Ptr a -> FunPtr b
- castFunPtrToPtr :: FunPtr a -> Ptr b
- castFunPtr :: FunPtr a -> FunPtr b
- nullFunPtr :: FunPtr a
- minusPtr :: Ptr a -> Ptr b -> Int
- alignPtr :: Ptr a -> Int -> Ptr a
- plusPtr :: Ptr a -> Int -> Ptr b
- castPtr :: Ptr a -> Ptr b
- nullPtr :: Ptr a
- showOct :: (Integral a, Show a) => a -> ShowS
- showHex :: (Integral a, Show a) => a -> ShowS
- showIntAtBase :: (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
- showHFloat :: RealFloat a => a -> ShowS
- showGFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
- showFFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS
- showGFloat :: RealFloat a => Maybe Int -> a -> ShowS
- showFFloat :: RealFloat a => Maybe Int -> a -> ShowS
- showEFloat :: RealFloat a => Maybe Int -> a -> ShowS
- showInt :: Integral a => a -> ShowS
- readSigned :: Real a => ReadS a -> ReadS a
- readFloat :: RealFrac a => ReadS a
- readHex :: (Eq a, Num a) => ReadS a
- readDec :: (Eq a, Num a) => ReadS a
- readOct :: (Eq a, Num a) => ReadS a
- readInt :: Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
- lexDigits :: ReadS String
- readLitChar :: ReadS Char
- lexLitChar :: ReadS String
- lex :: ReadS String
- readParen :: Bool -> ReadS a -> ReadS a
- readS_to_Prec :: (Int -> ReadS a) -> ReadPrec a
- readPrec_to_S :: ReadPrec a -> Int -> ReadS a
- readP_to_Prec :: (Int -> ReadP a) -> ReadPrec a
- readPrec_to_P :: ReadPrec a -> Int -> ReadP a
- data ReadPrec a
- readS_to_P :: ReadS a -> ReadP a
- readP_to_S :: ReadP a -> ReadS a
- type ReadS a = String -> [(a, String)]
- data ReadP a
- fromRat :: RealFloat a => Rational -> a
- floatToDigits :: RealFloat a => Integer -> a -> ([Int], Int)
- showFloat :: RealFloat a => a -> ShowS
- bitReverse64 :: Word64 -> Word64
- bitReverse32 :: Word32 -> Word32
- bitReverse16 :: Word16 -> Word16
- bitReverse8 :: Word8 -> Word8
- byteSwap64 :: Word64 -> Word64
- byteSwap32 :: Word32 -> Word32
- byteSwap16 :: Word16 -> Word16
- toTitle :: Char -> Char
- toUpper :: Char -> Char
- toLower :: Char -> Char
- isLower :: Char -> Bool
- isUpper :: Char -> Bool
- isPrint :: Char -> Bool
- isControl :: Char -> Bool
- isAlphaNum :: Char -> Bool
- isAlpha :: Char -> Bool
- isSymbol :: Char -> Bool
- isPunctuation :: Char -> Bool
- isHexDigit :: Char -> Bool
- isOctDigit :: Char -> Bool
- isDigit :: Char -> Bool
- isSpace :: Char -> Bool
- isAsciiUpper :: Char -> Bool
- isAsciiLower :: Char -> Bool
- isLatin1 :: Char -> Bool
- isAscii :: Char -> Bool
- generalCategory :: Char -> GeneralCategory
- data GeneralCategory
- = UppercaseLetter
- | LowercaseLetter
- | TitlecaseLetter
- | ModifierLetter
- | OtherLetter
- | NonSpacingMark
- | SpacingCombiningMark
- | EnclosingMark
- | DecimalNumber
- | LetterNumber
- | OtherNumber
- | ConnectorPunctuation
- | DashPunctuation
- | OpenPunctuation
- | ClosePunctuation
- | InitialQuote
- | FinalQuote
- | OtherPunctuation
- | MathSymbol
- | CurrencySymbol
- | ModifierSymbol
- | OtherSymbol
- | Space
- | LineSeparator
- | ParagraphSeparator
- | Control
- | Format
- | Surrogate
- | PrivateUse
- | NotAssigned
- toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
- popCountDefault :: (Bits a, Num a) => a -> Int
- testBitDefault :: (Bits a, Num a) => a -> Int -> Bool
- bitDefault :: (Bits a, Num a) => Int -> a
- class Eq a => Bits a where
- (.&.) :: a -> a -> a
- (.|.) :: a -> a -> a
- xor :: a -> a -> a
- complement :: a -> a
- shift :: a -> Int -> a
- rotate :: a -> Int -> a
- zeroBits :: a
- bit :: Int -> a
- setBit :: a -> Int -> a
- clearBit :: a -> Int -> a
- complementBit :: a -> Int -> a
- testBit :: a -> Int -> Bool
- bitSizeMaybe :: a -> Maybe Int
- bitSize :: a -> Int
- isSigned :: a -> Bool
- shiftL :: a -> Int -> a
- unsafeShiftL :: a -> Int -> a
- shiftR :: a -> Int -> a
- unsafeShiftR :: a -> Int -> a
- rotateL :: a -> Int -> a
- rotateR :: a -> Int -> a
- popCount :: a -> Int
- class Bits b => FiniteBits b where
- finiteBitSize :: b -> Int
- countLeadingZeros :: b -> Int
- countTrailingZeros :: b -> Int
- lcm :: Integral a => a -> a -> a
- gcd :: Integral a => a -> a -> a
- (^^) :: (Fractional a, Integral b) => a -> b -> a
- (^) :: (Num a, Integral b) => a -> b -> a
- odd :: Integral a => a -> Bool
- even :: Integral a => a -> Bool
- showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
- denominator :: Ratio a -> a
- numerator :: Ratio a -> a
- (%) :: Integral a => a -> a -> Ratio a
- chr :: Int -> Char
- writeSTRef :: STRef s a -> a -> ST s ()
- readSTRef :: STRef s a -> ST s a
- newSTRef :: a -> ST s (STRef s a)
- data STRef s a
- runST :: (forall s. ST s a) -> a
- intToDigit :: Int -> Char
- showLitChar :: Char -> ShowS
- showParen :: Bool -> ShowS -> ShowS
- showString :: String -> ShowS
- showChar :: Char -> ShowS
- shows :: Show a => a -> ShowS
- type ShowS = String -> String
- unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- unzip :: [(a, b)] -> ([a], [b])
- zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- (!!) :: [a] -> Int -> a
- lookup :: Eq a => a -> [(a, b)] -> Maybe b
- reverse :: [a] -> [a]
- break :: (a -> Bool) -> [a] -> ([a], [a])
- span :: (a -> Bool) -> [a] -> ([a], [a])
- splitAt :: Int -> [a] -> ([a], [a])
- drop :: Int -> [a] -> [a]
- take :: Int -> [a] -> [a]
- dropWhile :: (a -> Bool) -> [a] -> [a]
- takeWhile :: (a -> Bool) -> [a] -> [a]
- cycle :: [a] -> [a]
- replicate :: Int -> a -> [a]
- repeat :: a -> [a]
- iterate' :: (a -> a) -> a -> [a]
- iterate :: (a -> a) -> a -> [a]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- scanr :: (a -> b -> b) -> b -> [a] -> [b]
- scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- scanl :: (b -> a -> b) -> b -> [a] -> [b]
- foldl1' :: (a -> a -> a) -> [a] -> a
- init :: [a] -> [a]
- last :: [a] -> a
- tail :: [a] -> [a]
- uncons :: [a] -> Maybe (a, [a])
- head :: [a] -> a
- mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- catMaybes :: [Maybe a] -> [a]
- listToMaybe :: [a] -> Maybe a
- maybeToList :: Maybe a -> [a]
- fromMaybe :: a -> Maybe a -> a
- fromJust :: HasCallStack => Maybe a -> a
- isNothing :: Maybe a -> Bool
- isJust :: Maybe a -> Bool
- maybe :: b -> (a -> b) -> Maybe a -> b
- bool :: a -> a -> Bool -> a
- (&) :: a -> (a -> b) -> b
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- fix :: (a -> a) -> a
- void :: Functor f => f a -> f ()
- ($>) :: Functor f => f a -> b -> f b
- (<&>) :: Functor f => f a -> (a -> b) -> f b
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- swap :: (a, b) -> (b, a)
- uncurry :: (a -> b -> c) -> (a, b) -> c
- curry :: ((a, b) -> c) -> a -> b -> c
- unsafeInterleaveIO :: IO a -> IO a
- unsafeDupablePerformIO :: IO a -> a
- unsafePerformIO :: IO a -> a
- isEmptyMVar :: MVar a -> IO Bool
- tryReadMVar :: MVar a -> IO (Maybe a)
- tryPutMVar :: MVar a -> a -> IO Bool
- tryTakeMVar :: MVar a -> IO (Maybe a)
- putMVar :: MVar a -> a -> IO ()
- readMVar :: MVar a -> IO a
- takeMVar :: MVar a -> IO a
- newMVar :: a -> IO (MVar a)
- newEmptyMVar :: IO (MVar a)
- data MVar a
- subtract :: Num a => a -> a -> a
- asTypeOf :: a -> a -> a
- until :: (a -> Bool) -> (a -> a) -> a -> a
- ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- flip :: (a -> b -> c) -> b -> a -> c
- const :: a -> b -> a
- ord :: Char -> Int
- ap :: Monad m => m (a -> b) -> m a -> m b
- liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
- liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
- liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
- liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
- when :: Applicative f => Bool -> f () -> f ()
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- liftA :: Applicative f => (a -> b) -> f a -> f b
- (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- class Applicative f => Alternative (f :: Type -> Type) where
- class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- data NonEmpty a = a :| [a]
- type String = [Char]
- undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a
- error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
- stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
- data SomeException = Exception e => SomeException e
- (&&) :: Bool -> Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- newtype WrappedBifunctor (p :: k -> k1 -> Type) (a :: k) (b :: k1) = WrapBifunctor {
- unwrapBifunctor :: p a b
- (<<$>>) :: (a -> b) -> a -> b
- data ShortByteString
- data ByteString
- liftW3 :: ComonadApply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d
- liftW2 :: ComonadApply w => (a -> b -> c) -> w a -> w b -> w c
- (<@@>) :: ComonadApply w => w a -> w (a -> b) -> w b
- (=>=) :: Comonad w => (w a -> b) -> (w b -> c) -> w a -> c
- (=<=) :: Comonad w => (w b -> c) -> (w a -> b) -> w a -> c
- (<<=) :: Comonad w => (w a -> b) -> w a -> w b
- (=>>) :: Comonad w => w a -> (w a -> b) -> w b
- kfix :: ComonadApply w => w (w a -> a) -> w a
- cfix :: Comonad w => (w a -> a) -> w a
- wfix :: Comonad w => w (w a -> a) -> a
- liftW :: Comonad w => (a -> b) -> w a -> w b
- class Functor w => Comonad (w :: Type -> Type) where
- class Comonad w => ComonadApply (w :: Type -> Type) where
- newtype Cokleisli (w :: k -> Type) (a :: k) b = Cokleisli {
- runCokleisli :: w a -> b
- data IntMap a
- data IntSet
- data Map k a
- data Seq a
- data Set a
- chosen :: Decidable f => f b -> f c -> f (Either b c)
- lost :: Decidable f => f Void
- liftD :: Divisible f => (a -> b) -> f b -> f a
- conquered :: Divisible f => f ()
- divided :: Divisible f => f a -> f b -> f (a, b)
- class Contravariant f => Divisible (f :: Type -> Type) where
- class Divisible f => Decidable (f :: Type -> Type) where
- rnf2 :: (NFData2 p, NFData a, NFData b) => p a b -> ()
- rnf1 :: (NFData1 f, NFData a) => f a -> ()
- rwhnf :: a -> ()
- (<$!!>) :: (Monad m, NFData b) => (a -> b) -> m a -> m b
- force :: NFData a => a -> a
- ($!!) :: NFData a => (a -> b) -> a -> b
- deepseq :: NFData a => a -> b -> b
- class NFData a where
- rnf :: a -> ()
- class NFData1 (f :: Type -> Type) where
- liftRnf :: (a -> ()) -> f a -> ()
- class NFData2 (p :: Type -> Type -> Type) where
- liftRnf2 :: (a -> ()) -> (b -> ()) -> p a b -> ()
- data DList a
- swapEither :: Either e a -> Either a e
- eitherToError :: MonadError e m => Either e a -> m a
- maybeToRight :: b -> Maybe a -> Either b a
- maybeToLeft :: b -> Maybe a -> Either a b
- rightToMaybe :: Either a b -> Maybe b
- leftToMaybe :: Either a b -> Maybe a
- unlessRight :: Applicative m => Either a b -> (a -> m ()) -> m ()
- unlessLeft :: Applicative m => Either a b -> (b -> m ()) -> m ()
- whenRight :: Applicative m => Either a b -> (b -> m ()) -> m ()
- whenLeft :: Applicative m => Either a b -> (a -> m ()) -> m ()
- mapBoth :: (a -> c) -> (b -> d) -> Either a b -> Either c d
- fromRight' :: Either a b -> b
- fromLeft' :: Either a b -> a
- newtype MaybeT (m :: Type -> Type) a = MaybeT {}
- newtype ExceptT e (m :: Type -> Type) a = ExceptT (m (Either e a))
- generated' :: (Eq a, Cyclic a) => [a]
- generated :: Cyclic a => [a]
- class Monoid m => Group m where
- class Group g => Abelian g
- class Group a => Cyclic a where
- generator :: a
- traverseHashed :: (Hashable b, Functor f) => (a -> f b) -> Hashed a -> f (Hashed b)
- mapHashed :: Hashable b => (a -> b) -> Hashed a -> Hashed b
- hashedHash :: Hashed a -> Int
- unhashed :: Hashed a -> a
- hashed :: Hashable a => a -> Hashed a
- hashByteArray :: ByteArray# -> Int -> Int -> Int
- hashPtr :: Ptr a -> Int -> IO Int
- hashUsing :: Hashable b => (a -> b) -> Int -> a -> Int
- class Eq a => Hashable a where
- hashWithSalt :: Int -> a -> Int
- hash :: a -> Int
- data Hashed a
- hashByteArrayWithSalt :: ByteArray# -> Int -> Int -> Salt -> Salt
- hashPtrWithSalt :: Ptr a -> Int -> Salt -> IO Salt
- class Profunctor (p :: Type -> Type -> Type) where
- genericInvmap :: (Generic1 f, Invariant (Rep1 f)) => (a -> b) -> (b -> a) -> f a -> f b
- invmap2Profunctor :: Profunctor f => (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> f a b -> f c d
- invmap2Bifunctor :: Bifunctor f => (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> f a b -> f c d
- invmapContravariant :: Contravariant f => (a -> b) -> (b -> a) -> f a -> f b
- invmapFunctor :: Functor f => (a -> b) -> (b -> a) -> f a -> f b
- class Invariant (f :: Type -> Type) where
- invmap :: (a -> b) -> (b -> a) -> f a -> f b
- newtype WrappedFunctor (f :: k -> Type) (a :: k) = WrapFunctor {
- unwrapFunctor :: f a
- newtype WrappedContravariant (f :: k -> Type) (a :: k) = WrapContravariant {
- unwrapContravariant :: f a
- class Invariant2 (f :: Type -> Type -> Type) where
- invmap2 :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> f a b -> f c d
- newtype WrappedProfunctor (p :: k -> k1 -> Type) (a :: k) (b :: k1) = WrapProfunctor {
- unwrapProfunctor :: p a b
- class MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- censor :: MonadWriter w m => (w -> w) -> m a -> m a
- listens :: MonadWriter w m => (w -> b) -> m a -> m (a, b)
- class (Monoid w, Monad m) => MonadWriter w (m :: Type -> Type) | m -> w where
- gets :: MonadState s m => (s -> a) -> m a
- modify' :: MonadState s m => (s -> s) -> m ()
- modify :: MonadState s m => (s -> s) -> m ()
- asks :: MonadReader r m => (r -> a) -> m a
- liftEither :: MonadError e m => Either e a -> m a
- class Monad m => MonadError e (m :: Type -> Type) | m -> e where
- throwError :: e -> m a
- catchError :: m a -> (e -> m a) -> m a
- class Monad m => MonadCont (m :: Type -> Type) where
- callCC :: ((a -> m b) -> m a) -> m a
- newtype ContT (r :: k) (m :: k -> Type) a = ContT {
- runContT :: (a -> m r) -> m r
- type Cont r = ContT r Identity
- cont :: ((a -> r) -> r) -> Cont r a
- runCont :: Cont r a -> (a -> r) -> r
- mapCont :: (r -> r) -> Cont r a -> Cont r a
- withCont :: ((b -> r) -> a -> r) -> Cont r a -> Cont r b
- mapContT :: forall k m (r :: k) a. (m r -> m r) -> ContT r m a -> ContT r m a
- withContT :: forall k b m (r :: k) a. ((b -> m r) -> a -> m r) -> ContT r m a -> ContT r m b
- type Except e = ExceptT e Identity
- runExcept :: Except e a -> Either e a
- mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b
- withExcept :: (e -> e') -> Except e a -> Except e' a
- runExceptT :: ExceptT e m a -> m (Either e a)
- mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b
- withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a
- newtype ReaderT r (m :: Type -> Type) a = ReaderT {
- runReaderT :: r -> m a
- type Reader r = ReaderT r Identity
- runReader :: Reader r a -> r -> a
- mapReader :: (a -> b) -> Reader r a -> Reader r b
- withReader :: (r' -> r) -> Reader r a -> Reader r' a
- mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b
- withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a
- newtype StateT s (m :: Type -> Type) a = StateT {
- runStateT :: s -> m (a, s)
- type State s = StateT s Identity
- runState :: State s a -> s -> (a, s)
- evalState :: State s a -> s -> a
- execState :: State s a -> s -> s
- mapState :: ((a, s) -> (b, s)) -> State s a -> State s b
- withState :: (s -> s) -> State s a -> State s a
- evalStateT :: Monad m => StateT s m a -> s -> m a
- execStateT :: Monad m => StateT s m a -> s -> m s
- mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
- withStateT :: forall s (m :: Type -> Type) a. (s -> s) -> StateT s m a -> StateT s m a
- newtype WriterT w (m :: Type -> Type) a = WriterT {
- runWriterT :: m (a, w)
- type Writer w = WriterT w Identity
- runWriter :: Writer w a -> (a, w)
- execWriter :: Writer w a -> w
- mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
- execWriterT :: Monad m => WriterT w m a -> m w
- mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
- joinCoyoneda :: forall (p :: Type -> Type -> Type) a b. Coyoneda (Coyoneda p) a b -> Coyoneda p a b
- returnCoyoneda :: p a b -> Coyoneda p a b
- duplicateYoneda :: forall (p :: Type -> Type -> Type) a b. Yoneda p a b -> Yoneda (Yoneda p) a b
- extractYoneda :: Yoneda p a b -> p a b
- newtype Yoneda (p :: Type -> Type -> Type) a b = Yoneda {
- runYoneda :: forall x y. (x -> a) -> (b -> y) -> p x y
- data Coyoneda (p :: Type -> Type -> Type) a b where
- mapCayley :: forall k1 k2 k3 f g (p :: k2 -> k3 -> k1) (x :: k2) (y :: k3). (forall (a :: k1). f a -> g a) -> Cayley f p x y -> Cayley g p x y
- newtype Cayley (f :: k -> Type) (p :: k1 -> k2 -> k) (a :: k1) (b :: k2) = Cayley {
- runCayley :: f (p a b)
- decomposeCodensity :: forall k1 k2 p (a :: k1) (b :: k2). Procompose (Codensity p) p a b -> p a b
- uncurryRan :: forall k1 k2 k3 (p :: k1 -> k2 -> Type) (q :: k3 -> k1 -> Type) (r :: k3 -> k2 -> Type). (p :-> Ran q r) -> Procompose p q :-> r
- curryRan :: forall k1 k2 k3 (p :: k1 -> k2 -> Type) (q :: k3 -> k1 -> Type) (r :: k3 -> k2 -> Type). (Procompose p q :-> r) -> p :-> Ran q r
- precomposeRan :: forall k (q :: Type -> Type -> Type) (p :: Type -> k -> Type). Profunctor q => Procompose q (Ran p ((->) :: Type -> Type -> Type)) :-> Ran p q
- decomposeRan :: forall k1 k2 k3 (q :: k1 -> k2 -> Type) (p :: k1 -> k3 -> Type). Procompose (Ran q p) q :-> p
- newtype Ran (p :: k -> k1 -> Type) (q :: k -> k2 -> Type) (a :: k1) (b :: k2) = Ran {
- runRan :: forall (x :: k). p x a -> q x b
- newtype Codensity (p :: k -> k1 -> Type) (a :: k1) (b :: k1) = Codensity {
- runCodensity :: forall (x :: k). p x a -> p x b
- mu :: forall k (p :: k -> k -> Type). Category p => Procompose p p :-> p
- eta :: forall (p :: Type -> Type -> Type). (Profunctor p, Category p) => ((->) :: Type -> Type -> Type) :-> p
- decomposeRift :: forall k1 k2 k3 (p :: k1 -> k2 -> Type) (q :: k3 -> k2 -> Type). Procompose p (Rift p q) :-> q
- cokleislis :: forall k1 k2 (f :: Type -> Type) (g :: k1 -> Type) (d :: k1) c (f' :: Type -> Type) (g' :: k2 -> Type) (d' :: k2) c'. Functor f => Iso (Procompose (Cokleisli f) (Cokleisli g) d c) (Procompose (Cokleisli f') (Cokleisli g') d' c') (Cokleisli (Compose f g) d c) (Cokleisli (Compose f' g') d' c')
- kleislis :: forall (g :: Type -> Type) (f :: Type -> Type) d c (f' :: Type -> Type) (g' :: Type -> Type) d' c'. Monad g => Iso (Procompose (Kleisli f) (Kleisli g) d c) (Procompose (Kleisli f') (Kleisli g') d' c') (Kleisli (Compose g f) d c) (Kleisli (Compose g' f') d' c')
- costars :: forall k1 k2 (f :: Type -> Type) (g :: k1 -> Type) (d :: k1) c (f' :: Type -> Type) (g' :: k2 -> Type) (d' :: k2) c'. Functor f => Iso (Procompose (Costar f) (Costar g) d c) (Procompose (Costar f') (Costar g') d' c') (Costar (Compose f g) d c) (Costar (Compose f' g') d' c')
- stars :: forall k1 k2 (g :: Type -> Type) (f :: k1 -> Type) d (c :: k1) (f' :: k2 -> Type) (g' :: Type -> Type) d' (c' :: k2). Functor g => Iso (Procompose (Star f) (Star g) d c) (Procompose (Star f') (Star g') d' c') (Star (Compose g f) d c) (Star (Compose g' f') d' c')
- assoc :: forall k1 k2 k3 k4 k5 k6 (p :: k1 -> k2 -> Type) (q :: k3 -> k1 -> Type) (r :: k4 -> k3 -> Type) (a :: k4) (b :: k2) (x :: k5 -> k2 -> Type) (y :: k6 -> k5 -> Type) (z :: k4 -> k6 -> Type). Iso (Procompose p (Procompose q r) a b) (Procompose x (Procompose y z) a b) (Procompose (Procompose p q) r a b) (Procompose (Procompose x y) z a b)
- idr :: forall k (q :: Type -> Type -> Type) d c (r :: Type -> k -> Type) d' (c' :: k). Profunctor q => Iso (Procompose q ((->) :: Type -> Type -> Type) d c) (Procompose r ((->) :: Type -> Type -> Type) d' c') (q d c) (r d' c')
- idl :: forall k (q :: Type -> Type -> Type) d c (r :: k -> Type -> Type) (d' :: k) c'. Profunctor q => Iso (Procompose ((->) :: Type -> Type -> Type) q d c) (Procompose ((->) :: Type -> Type -> Type) r d' c') (q d c) (r d' c')
- procomposed :: forall k p (a :: k) (b :: k). Category p => Procompose p p a b -> p a b
- data Procompose (p :: k -> k1 -> Type) (q :: k2 -> k -> Type) (d :: k2) (c :: k1) where
- Procompose :: forall k k1 k2 (p :: k -> k1 -> Type) (x :: k) (c :: k1) (q :: k2 -> k -> Type) (d :: k2). p x c -> q d x -> Procompose p q d c
- newtype Rift (p :: k -> k1 -> Type) (q :: k2 -> k1 -> Type) (a :: k2) (b :: k) = Rift {
- runRift :: forall (x :: k1). p b x -> q a x
- coprepCounit :: forall k f (a :: k). f a -> Coprep (Costar f) a
- coprepUnit :: forall k (p :: k -> Type -> Type). p :-> Costar (Coprep p)
- uncoprepAdj :: forall k (p :: k -> Type -> Type) f (a :: k). (p :-> Costar f) -> f a -> Coprep p a
- coprepAdj :: forall k f (p :: k -> Type -> Type). (forall (a :: k). f a -> Coprep p a) -> p :-> Costar f
- prepCounit :: forall k f (a :: k). Prep (Star f) a -> f a
- prepUnit :: forall k (p :: Type -> k -> Type). p :-> Star (Prep p)
- unprepAdj :: forall k (p :: Type -> k -> Type) g (a :: k). (p :-> Star g) -> Prep p a -> g a
- prepAdj :: forall k (p :: Type -> k -> Type) g. (forall (a :: k). Prep p a -> g a) -> p :-> Star g
- cotabulated :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type) d c d' c'. (Corepresentable p, Corepresentable q) => Iso (Corep p d -> c) (Corep q d' -> c') (p d c) (q d' c')
- closedCorep :: Corepresentable p => p a b -> p (x -> a) (x -> b)
- unsecondCorep :: Corepresentable p => p (d, a) (d, b) -> p a b
- unfirstCorep :: Corepresentable p => p (a, d) (b, d) -> p a b
- tabulated :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type) d c d' c'. (Representable p, Representable q) => Iso (d -> Rep p c) (d' -> Rep q c') (p d c) (q d' c')
- secondRep :: Representable p => p a b -> p (c, a) (c, b)
- firstRep :: Representable p => p a b -> p (a, c) (b, c)
- type family Rep (p :: Type -> Type -> Type) :: Type -> Type
- class (Sieve p (Rep p), Strong p) => Representable (p :: Type -> Type -> Type) where
- type family Corep (p :: Type -> Type -> Type) :: Type -> Type
- class (Cosieve p (Corep p), Costrong p) => Corepresentable (p :: Type -> Type -> Type) where
- data Prep (p :: Type -> k -> Type) (a :: k) where
- newtype Coprep (p :: k -> Type -> Type) (a :: k) = Coprep {
- runCoprep :: forall r. p a r -> r
- class (Profunctor p, Functor f) => Sieve (p :: Type -> Type -> Type) (f :: Type -> Type) | p -> f where
- sieve :: p a b -> a -> f b
- class (Profunctor p, Functor f) => Cosieve (p :: Type -> Type -> Type) (f :: Type -> Type) | p -> f where
- cosieve :: p a b -> f a -> b
- closedMapping :: Mapping p => p a b -> p (x -> a) (x -> b)
- traverseMapping :: (Mapping p, Functor f) => p a b -> p (f a) (f b)
- wanderMapping :: Mapping p => (forall (f :: Type -> Type). Applicative f => (a -> f b) -> s -> f t) -> p a b -> p s t
- class (Traversing p, Closed p) => Mapping (p :: Type -> Type -> Type) where
- newtype CofreeMapping (p :: Type -> Type -> Type) a b = CofreeMapping {
- runCofreeMapping :: forall (f :: Type -> Type). Functor f => p (f a) (f b)
- data FreeMapping (p :: Type -> Type -> Type) a b where
- FreeMapping :: forall (f :: Type -> Type) y b (p :: Type -> Type -> Type) x a. Functor f => (f y -> b) -> p x y -> (a -> f x) -> FreeMapping p a b
- rightTraversing :: Traversing p => p a b -> p (Either c a) (Either c b)
- leftTraversing :: Traversing p => p a b -> p (Either a c) (Either b c)
- rmapWandering :: Traversing p => (b -> c) -> p a b -> p a c
- lmapWandering :: Traversing p => (a -> b) -> p b c -> p a c
- dimapWandering :: Traversing p => (a' -> a) -> (b -> b') -> p a b -> p a' b'
- secondTraversing :: Traversing p => p a b -> p (c, a) (c, b)
- firstTraversing :: Traversing p => p a b -> p (a, c) (b, c)
- class (Choice p, Strong p) => Traversing (p :: Type -> Type -> Type) where
- traverse' :: Traversable f => p a b -> p (f a) (f b)
- wander :: (forall (f :: Type -> Type). Applicative f => (a -> f b) -> s -> f t) -> p a b -> p s t
- newtype CofreeTraversing (p :: Type -> Type -> Type) a b = CofreeTraversing {
- runCofreeTraversing :: forall (f :: Type -> Type). Traversable f => p (f a) (f b)
- data FreeTraversing (p :: Type -> Type -> Type) a b where
- FreeTraversing :: forall (f :: Type -> Type) y b (p :: Type -> Type -> Type) x a. Traversable f => (f y -> b) -> p x y -> (a -> f x) -> FreeTraversing p a b
- uncotambaraSum :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Profunctor q => (p :-> CotambaraSum q) -> p :-> q
- cotambaraSum :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Cochoice p => (p :-> q) -> p :-> CotambaraSum q
- untambaraSum :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Profunctor q => (p :-> TambaraSum q) -> p :-> q
- tambaraSum :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Choice p => (p :-> q) -> p :-> TambaraSum q
- class Profunctor p => Choice (p :: Type -> Type -> Type) where
- newtype TambaraSum (p :: Type -> Type -> Type) a b = TambaraSum {
- runTambaraSum :: forall c. p (Either a c) (Either b c)
- data PastroSum (p :: Type -> Type -> Type) a b where
- class Profunctor p => Cochoice (p :: Type -> Type -> Type) where
- data CotambaraSum (q :: Type -> Type -> Type) a b where
- CotambaraSum :: forall (r :: Type -> Type -> Type) (q :: Type -> Type -> Type) a b. Cochoice r => (r :-> q) -> r a b -> CotambaraSum q a b
- newtype CopastroSum (p :: Type -> Type -> Type) a b = CopastroSum {
- runCopastroSum :: forall (r :: Type -> Type -> Type). Cochoice r => (forall x y. p x y -> r x y) -> r a b
- unclose :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Profunctor q => (p :-> Closure q) -> p :-> q
- close :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Closed p => (p :-> q) -> p :-> Closure q
- curry' :: Closed p => p (a, b) c -> p a (b -> c)
- class Profunctor p => Closed (p :: Type -> Type -> Type) where
- closed :: p a b -> p (x -> a) (x -> b)
- newtype Closure (p :: Type -> Type -> Type) a b = Closure {
- runClosure :: forall x. p (x -> a) (x -> b)
- data Environment (p :: Type -> Type -> Type) a b where
- Environment :: forall z y b (p :: Type -> Type -> Type) x a. ((z -> y) -> b) -> p x y -> (a -> z -> x) -> Environment p a b
- uncotambara :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Profunctor q => (p :-> Cotambara q) -> p :-> q
- cotambara :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Costrong p => (p :-> q) -> p :-> Cotambara q
- unpastro :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). (Pastro p :-> q) -> p :-> q
- pastro :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Strong q => (p :-> q) -> Pastro p :-> q
- untambara :: forall (q :: Type -> Type -> Type) (p :: Type -> Type -> Type). Profunctor q => (p :-> Tambara q) -> p :-> q
- tambara :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Strong p => (p :-> q) -> p :-> Tambara q
- strong :: Strong p => (a -> b -> c) -> p a b -> p a c
- uncurry' :: Strong p => p a (b -> c) -> p (a, b) c
- class Profunctor p => Strong (p :: Type -> Type -> Type) where
- newtype Tambara (p :: Type -> Type -> Type) a b = Tambara {
- runTambara :: forall c. p (a, c) (b, c)
- data Pastro (p :: Type -> Type -> Type) a b where
- class Profunctor p => Costrong (p :: Type -> Type -> Type) where
- data Cotambara (q :: Type -> Type -> Type) a b where
- newtype Copastro (p :: Type -> Type -> Type) a b = Copastro {
- runCopastro :: forall (r :: Type -> Type -> Type). Costrong r => (forall x y. p x y -> r x y) -> r a b
- class (ProfunctorFunctor f, ProfunctorFunctor u) => ProfunctorAdjunction (f :: (Type -> Type -> Type) -> Type -> Type -> Type) (u :: (Type -> Type -> Type) -> Type -> Type -> Type) | f -> u, u -> f where
- class ProfunctorFunctor (t :: (Type -> Type -> Type) -> k -> k1 -> Type) where
- class ProfunctorFunctor t => ProfunctorMonad (t :: (Type -> Type -> Type) -> Type -> Type -> Type) where
- class ProfunctorFunctor t => ProfunctorComonad (t :: (Type -> Type -> Type) -> Type -> Type -> Type) where
- proextract :: forall (p :: Type -> Type -> Type). Profunctor p => t p :-> p
- produplicate :: forall (p :: Type -> Type -> Type). Profunctor p => t p :-> t (t p)
- type (:->) (p :: k -> k1 -> Type) (q :: k -> k1 -> Type) = forall (a :: k) (b :: k1). p a b -> q a b
- newtype Star (f :: k -> Type) d (c :: k) = Star {
- runStar :: d -> f c
- newtype Costar (f :: k -> Type) (d :: k) c = Costar {
- runCostar :: f d -> c
- newtype Forget r a (b :: k) = Forget {
- runForget :: a -> r
- data Scientific
- foldS :: (Selective f, Foldable t, Monoid a) => t (f (Either e a)) -> f (Either e a)
- allS :: Selective f => (a -> f Bool) -> [a] -> f Bool
- anyS :: Selective f => (a -> f Bool) -> [a] -> f Bool
- (<&&>) :: Selective f => f Bool -> f Bool -> f Bool
- (<||>) :: Selective f => f Bool -> f Bool -> f Bool
- untilRight :: (Monoid a, Selective f) => f (Either a b) -> f (a, b)
- whileS :: Selective f => f Bool -> f ()
- andAlso :: (Selective f, Semigroup a) => f (Either e a) -> f (Either e a) -> f (Either e a)
- orElse :: (Selective f, Semigroup e) => f (Either e a) -> f (Either e a) -> f (Either e a)
- fromMaybeS :: Selective f => f a -> f (Maybe a) -> f a
- whenS :: Selective f => f Bool -> f () -> f ()
- bindS :: (Bounded a, Enum a, Eq a, Selective f) => f a -> (a -> f b) -> f b
- matchM :: Monad m => Cases a -> m a -> (a -> m b) -> m (Either a b)
- matchS :: (Eq a, Selective f) => Cases a -> f a -> (a -> f b) -> f (Either a b)
- cases :: Eq a => [a] -> Cases a
- casesEnum :: (Bounded a, Enum a) => Cases a
- ifS :: Selective f => f Bool -> f a -> f a -> f a
- selectM :: Monad f => f (Either a b) -> f (a -> b) -> f b
- apS :: Selective f => f (a -> b) -> f a -> f b
- selectT :: (Applicative f, Traversable f) => f (Either a b) -> f (a -> b) -> f b
- selectA :: Applicative f => f (Either a b) -> f (a -> b) -> f b
- branch :: Selective f => f (Either a b) -> f (a -> c) -> f (b -> c) -> f c
- (<*?) :: Selective f => f (Either a b) -> f (a -> b) -> f b
- class Applicative f => Selective (f :: Type -> Type) where
- data Cases a
- newtype SelectA (f :: Type -> Type) a = SelectA {
- getSelectA :: f a
- newtype SelectM (f :: Type -> Type) a = SelectM {
- getSelectM :: f a
- newtype Over m a = Over {
- getOver :: m
- newtype Under m a = Under {
- getUnder :: m
- data Validation e a
- newtype ComposeEither (f :: Type -> Type) e a = ComposeEither (f (Either e a))
- psum :: (Foldable t, Plus f) => t (f a) -> f a
- class Alt f => Plus (f :: Type -> Type) where
- zero :: f a
- bifoldMap1Default :: (Bitraversable1 t, Semigroup m) => (a -> m) -> (b -> m) -> t a b -> m
- foldMap1Default :: (Traversable1 f, Semigroup m) => (a -> m) -> f a -> m
- class (Bifoldable1 t, Bitraversable t) => Bitraversable1 (t :: Type -> Type -> Type) where
- bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> t a c -> f (t b d)
- bisequence1 :: Apply f => t (f a) (f b) -> f (t a b)
- class (Foldable1 t, Traversable t) => Traversable1 (t :: Type -> Type) where
- foldlM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a
- foldrM1 :: (Foldable1 t, Monad m) => (a -> a -> m a) -> t a -> m a
- asum1 :: (Foldable1 t, Alt m) => t (m a) -> m a
- foldMapDefault1 :: (Foldable1 t, Monoid m) => (a -> m) -> t a -> m
- sequenceA1_ :: (Foldable1 t, Apply f) => t (f a) -> f ()
- for1_ :: (Foldable1 t, Apply f) => t a -> (a -> f b) -> f ()
- traverse1_ :: (Foldable1 t, Apply f) => (a -> f b) -> t a -> f ()
- intercalateMap1 :: (Foldable1 t, Semigroup m) => m -> (a -> m) -> t a -> m
- intercalate1 :: (Foldable1 t, Semigroup m) => m -> t m -> m
- class Functor f => Alt (f :: Type -> Type) where
- (<!>) :: f a -> f a -> f a
- bilift3 :: Biapply w => (a -> b -> c -> d) -> (e -> f -> g -> h) -> w a e -> w b f -> w c g -> w d h
- bilift2 :: Biapply w => (a -> b -> c) -> (d -> e -> f) -> w a d -> w b e -> w c f
- (<<..>>) :: Biapply p => p a c -> p (a -> b) (c -> d) -> p b d
- class Semigroupoid k1 => Groupoid (k1 :: k -> k -> Type) where
- inv :: forall (a :: k) (b :: k). k1 a b -> k1 b a
- class Semigroupoid (c :: k -> k -> Type) where
- o :: forall (j :: k) (k1 :: k) (i :: k). c j k1 -> c i j -> c i k1
- newtype WrappedCategory (k2 :: k -> k1 -> Type) (a :: k) (b :: k1) = WrapCategory {
- unwrapCategory :: k2 a b
- newtype Semi m (a :: k) (b :: k1) = Semi {
- getSemi :: m
- (-<-) :: Bind m => (b -> m c) -> (a -> m b) -> a -> m c
- (->-) :: Bind m => (a -> m b) -> (b -> m c) -> a -> m c
- (-<<) :: Bind m => (a -> m b) -> m a -> m b
- bifoldMapDefault1 :: (Bifoldable1 t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m
- bisequenceA1_ :: (Bifoldable1 t, Apply f) => t (f a) (f b) -> f ()
- bifor1_ :: (Bifoldable1 t, Apply f) => t a c -> (a -> f b) -> (c -> f d) -> f ()
- bitraverse1_ :: (Bifoldable1 t, Apply f) => (a -> f b) -> (c -> f d) -> t a c -> f ()
- liftF3 :: Apply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d
- (<..>) :: Apply w => w a -> w (a -> b) -> w b
- apDefault :: Bind f => f (a -> b) -> f a -> f b
- returning :: Functor f => f a -> (a -> b) -> f b
- traverse1Maybe :: (Traversable t, Apply f) => (a -> f b) -> t a -> MaybeApply f (t b)
- (<*.>) :: Apply f => MaybeApply f (a -> b) -> f a -> f b
- (<.*>) :: Apply f => f (a -> b) -> MaybeApply f a -> f b
- class Functor f => Apply (f :: Type -> Type) where
- newtype WrappedApplicative (f :: Type -> Type) a = WrapApplicative {
- unwrapApplicative :: f a
- newtype MaybeApply (f :: Type -> Type) a = MaybeApply {
- runMaybeApply :: Either (f a) a
- class Apply m => Bind (m :: Type -> Type) where
- (>>-) :: m a -> (a -> m b) -> m b
- class Bifunctor p => Biapply (p :: Type -> Type -> Type) where
- class Foldable t => Foldable1 (t :: Type -> Type) where
- class Bifoldable t => Bifoldable1 (t :: Type -> Type -> Type) where
- bifold1 :: Semigroup m => t m m -> m
- bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> t a b -> m
- class Functor w => Extend (w :: Type -> Type) where
- duplicated :: w a -> w (w a)
- extended :: (w a -> b) -> w a -> w b
- check :: Bool -> STM ()
- data TArray i e
- mkWeakTVar :: TVar a -> IO () -> IO (Weak (TVar a))
- swapTVar :: TVar a -> a -> STM a
- stateTVar :: TVar s -> (s -> (a, s)) -> STM a
- modifyTVar' :: TVar a -> (a -> a) -> STM ()
- modifyTVar :: TVar a -> (a -> a) -> STM ()
- isEmptyTQueue :: TQueue a -> STM Bool
- unGetTQueue :: TQueue a -> a -> STM ()
- tryPeekTQueue :: TQueue a -> STM (Maybe a)
- peekTQueue :: TQueue a -> STM a
- flushTQueue :: TQueue a -> STM [a]
- tryReadTQueue :: TQueue a -> STM (Maybe a)
- readTQueue :: TQueue a -> STM a
- writeTQueue :: TQueue a -> a -> STM ()
- newTQueueIO :: IO (TQueue a)
- newTQueue :: STM (TQueue a)
- data TQueue a
- mkWeakTMVar :: TMVar a -> IO () -> IO (Weak (TMVar a))
- isEmptyTMVar :: TMVar a -> STM Bool
- swapTMVar :: TMVar a -> a -> STM a
- tryReadTMVar :: TMVar a -> STM (Maybe a)
- readTMVar :: TMVar a -> STM a
- tryPutTMVar :: TMVar a -> a -> STM Bool
- putTMVar :: TMVar a -> a -> STM ()
- tryTakeTMVar :: TMVar a -> STM (Maybe a)
- takeTMVar :: TMVar a -> STM a
- newEmptyTMVarIO :: IO (TMVar a)
- newEmptyTMVar :: STM (TMVar a)
- newTMVarIO :: a -> IO (TMVar a)
- newTMVar :: a -> STM (TMVar a)
- data TMVar a
- cloneTChan :: TChan a -> STM (TChan a)
- isEmptyTChan :: TChan a -> STM Bool
- unGetTChan :: TChan a -> a -> STM ()
- dupTChan :: TChan a -> STM (TChan a)
- tryPeekTChan :: TChan a -> STM (Maybe a)
- peekTChan :: TChan a -> STM a
- tryReadTChan :: TChan a -> STM (Maybe a)
- readTChan :: TChan a -> STM a
- writeTChan :: TChan a -> a -> STM ()
- newBroadcastTChanIO :: IO (TChan a)
- newBroadcastTChan :: STM (TChan a)
- newTChanIO :: IO (TChan a)
- newTChan :: STM (TChan a)
- data TChan a
- isFullTBQueue :: TBQueue a -> STM Bool
- isEmptyTBQueue :: TBQueue a -> STM Bool
- lengthTBQueue :: TBQueue a -> STM Natural
- unGetTBQueue :: TBQueue a -> a -> STM ()
- tryPeekTBQueue :: TBQueue a -> STM (Maybe a)
- peekTBQueue :: TBQueue a -> STM a
- flushTBQueue :: TBQueue a -> STM [a]
- tryReadTBQueue :: TBQueue a -> STM (Maybe a)
- readTBQueue :: TBQueue a -> STM a
- writeTBQueue :: TBQueue a -> a -> STM ()
- newTBQueueIO :: Natural -> IO (TBQueue a)
- newTBQueue :: Natural -> STM (TBQueue a)
- data TBQueue a
- data Text
- readsTime :: ParseTime t => TimeLocale -> String -> ReadS t
- readTime :: ParseTime t => TimeLocale -> String -> String -> t
- parseTime :: ParseTime t => TimeLocale -> String -> String -> Maybe t
- readPTime :: ParseTime t => Bool -> TimeLocale -> String -> ReadP t
- readSTime :: ParseTime t => Bool -> TimeLocale -> String -> ReadS t
- parseTimeOrError :: ParseTime t => Bool -> TimeLocale -> String -> String -> t
- parseTimeM :: (MonadFail m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
- utcToLocalZonedTime :: UTCTime -> IO ZonedTime
- getZonedTime :: IO ZonedTime
- zonedTimeToUTC :: ZonedTime -> UTCTime
- utcToZonedTime :: TimeZone -> UTCTime -> ZonedTime
- data ZonedTime = ZonedTime {}
- formatTime :: FormatTime t => TimeLocale -> String -> t -> String
- class FormatTime t
- class ParseTime t
- rfc822DateFormat :: String
- iso8601DateFormat :: Maybe String -> String
- defaultTimeLocale :: TimeLocale
- data TimeLocale = TimeLocale {}
- localTimeToUT1 :: Rational -> LocalTime -> UniversalTime
- ut1ToLocalTime :: Rational -> UniversalTime -> LocalTime
- localTimeToUTC :: TimeZone -> LocalTime -> UTCTime
- utcToLocalTime :: TimeZone -> UTCTime -> LocalTime
- diffLocalTime :: LocalTime -> LocalTime -> NominalDiffTime
- addLocalTime :: NominalDiffTime -> LocalTime -> LocalTime
- data LocalTime = LocalTime {}
- timeOfDayToDayFraction :: TimeOfDay -> Rational
- dayFractionToTimeOfDay :: Rational -> TimeOfDay
- timeOfDayToTime :: TimeOfDay -> DiffTime
- timeToTimeOfDay :: DiffTime -> TimeOfDay
- localToUTCTimeOfDay :: TimeZone -> TimeOfDay -> (Integer, TimeOfDay)
- utcToLocalTimeOfDay :: TimeZone -> TimeOfDay -> (Integer, TimeOfDay)
- daysAndTimeOfDayToTime :: Integer -> TimeOfDay -> NominalDiffTime
- timeToDaysAndTimeOfDay :: NominalDiffTime -> (Integer, TimeOfDay)
- makeTimeOfDayValid :: Int -> Int -> Pico -> Maybe TimeOfDay
- midday :: TimeOfDay
- midnight :: TimeOfDay
- data TimeOfDay = TimeOfDay {}
- getCurrentTimeZone :: IO TimeZone
- getTimeZone :: UTCTime -> IO TimeZone
- utc :: TimeZone
- timeZoneOffsetString :: TimeZone -> String
- timeZoneOffsetString' :: Maybe Char -> TimeZone -> String
- hoursToTimeZone :: Int -> TimeZone
- minutesToTimeZone :: Int -> TimeZone
- data TimeZone = TimeZone {}
- scaleCalendarDiffTime :: Integer -> CalendarDiffTime -> CalendarDiffTime
- calendarTimeTime :: NominalDiffTime -> CalendarDiffTime
- calendarTimeDays :: CalendarDiffDays -> CalendarDiffTime
- data CalendarDiffTime = CalendarDiffTime {}
- diffUTCTime :: UTCTime -> UTCTime -> NominalDiffTime
- addUTCTime :: NominalDiffTime -> UTCTime -> UTCTime
- getCurrentTime :: IO UTCTime
- getPOSIXTime :: IO POSIXTime
- systemToPOSIXTime :: SystemTime -> POSIXTime
- utcTimeToPOSIXSeconds :: UTCTime -> POSIXTime
- posixSecondsToUTCTime :: POSIXTime -> UTCTime
- systemEpochDay :: Day
- systemToTAITime :: SystemTime -> AbsoluteTime
- utcToSystemTime :: UTCTime -> SystemTime
- systemToUTCTime :: SystemTime -> UTCTime
- truncateSystemTimeLeapSecond :: SystemTime -> SystemTime
- newtype UniversalTime = ModJulianDate {}
- data UTCTime = UTCTime {
- utctDay :: Day
- utctDayTime :: DiffTime
- getTime_resolution :: DiffTime
- getSystemTime :: IO SystemTime
- data SystemTime = MkSystemTime {}
- posixDayLength :: NominalDiffTime
- type POSIXTime = NominalDiffTime
- nominalDay :: NominalDiffTime
- nominalDiffTimeToSeconds :: NominalDiffTime -> Pico
- secondsToNominalDiffTime :: Pico -> NominalDiffTime
- data NominalDiffTime
- diffTimeToPicoseconds :: DiffTime -> Integer
- picosecondsToDiffTime :: Integer -> DiffTime
- secondsToDiffTime :: Integer -> DiffTime
- data DiffTime
- dayOfWeek :: Day -> DayOfWeek
- data DayOfWeek
- diffGregorianDurationRollOver :: Day -> Day -> CalendarDiffDays
- diffGregorianDurationClip :: Day -> Day -> CalendarDiffDays
- addGregorianDurationRollOver :: CalendarDiffDays -> Day -> Day
- addGregorianDurationClip :: CalendarDiffDays -> Day -> Day
- addGregorianYearsRollOver :: Integer -> Day -> Day
- addGregorianYearsClip :: Integer -> Day -> Day
- addGregorianMonthsRollOver :: Integer -> Day -> Day
- addGregorianMonthsClip :: Integer -> Day -> Day
- gregorianMonthLength :: Integer -> Int -> Int
- showGregorian :: Day -> String
- fromGregorianValid :: Integer -> Int -> Int -> Maybe Day
- fromGregorian :: Integer -> Int -> Int -> Day
- toGregorian :: Day -> (Integer, Int, Int)
- isLeapYear :: Integer -> Bool
- diffDays :: Day -> Day -> Integer
- addDays :: Integer -> Day -> Day
- newtype Day = ModifiedJulianDay {}
- scaleCalendarDiffDays :: Integer -> CalendarDiffDays -> CalendarDiffDays
- calendarYear :: CalendarDiffDays
- calendarMonth :: CalendarDiffDays
- calendarWeek :: CalendarDiffDays
- calendarDay :: CalendarDiffDays
- data CalendarDiffDays = CalendarDiffDays {}
- liftPass :: Monad m => Pass w m (Maybe a) -> Pass w (MaybeT m) a
- liftListen :: Monad m => Listen w m (Maybe a) -> Listen w (MaybeT m) a
- liftCatch :: Catch e m (Maybe a) -> Catch e (MaybeT m) a
- liftCallCC :: CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b
- exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a
- maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a
- mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
- except :: forall (m :: Type -> Type) e a. Monad m => Either e a -> ExceptT e m a
- liftLocal :: Monad m => m r' -> ((r' -> r') -> m r -> m r) -> (r' -> r') -> ContT r m a -> ContT r m a
- shiftT :: Monad m => ((a -> m r) -> ContT r m r) -> ContT r m a
- resetT :: forall (m :: Type -> Type) r r'. Monad m => ContT r m r -> ContT r' m r
- evalContT :: Monad m => ContT r m r -> m r
- reset :: Cont r r -> Cont r' r
- evalCont :: Cont r r -> r
- data HashSet a
- data HashMap k v
- data UUID
- data Vector a
- unsafeVacuousM :: Monad m => m Void -> m a
- unsafeVacuous :: Functor f => f Void -> f a
- mapLeft :: Bifunctor p => (a -> b) -> p a c -> p b c
- mapRight :: Bifunctor p => (b -> c) -> p a b -> p a c
- type List = []
- type List1 = NonEmpty
- sappend :: Semigroup a => a -> a -> a
Documentation
(++) :: [a] -> [a] -> [a] infixr 5 #
Append two lists, i.e.,
[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn] [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
If the first list is not finite, the result is the first list.
seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b infixr 0 #
The value of seq a b
is bottom if a
is bottom, and
otherwise equal to b
. In other words, it evaluates the first
argument a
to weak head normal form (WHNF). seq
is usually
introduced to improve performance by avoiding unneeded laziness.
A note on evaluation order: the expression seq a b
does
not guarantee that a
will be evaluated before b
.
The only guarantee given by seq
is that the both a
and b
will be evaluated before seq
returns a value.
In particular, this means that b
may be evaluated before
a
. If you need to guarantee a specific order of evaluation,
you must use the function pseq
from the "parallel" package.
filter :: (a -> Bool) -> [a] -> [a] #
\(\mathcal{O}(n)\). filter
, applied to a predicate and a list, returns
the list of those elements that satisfy the predicate; i.e.,
filter p xs = [ x | x <- xs, p x]
>>>
filter odd [1, 2, 3]
[1,3]
zip :: [a] -> [b] -> [(a, b)] #
\(\mathcal{O}(\min(m,n))\). zip
takes two lists and returns a list of
corresponding pairs.
zip [1, 2] ['a', 'b'] = [(1, 'a'), (2, 'b')]
If one input list is short, excess elements of the longer list are discarded:
zip [1] ['a', 'b'] = [(1, 'a')] zip [1, 2] ['a'] = [(1, 'a')]
zip
is right-lazy:
zip [] _|_ = [] zip _|_ [] = _|_
zip
is capable of list fusion, but it is restricted to its
first list argument and its resulting list.
newStablePtr :: a -> IO (StablePtr a) #
Create a stable pointer referring to the given Haskell value.
print :: Show a => a -> IO () #
The print
function outputs a value of any printable type to the
standard output device.
Printable types are those that are instances of class Show
; print
converts values to strings for output using the show
operation and
adds a newline.
For example, a program to print the first 20 integers and their powers of 2 could be written as:
main = print ([(n, 2^n) | n <- [0..19]])
If the first argument evaluates to True
, then the result is the
second argument. Otherwise an AssertionFailed
exception
is raised, containing a String
with the source file and line number of the
call to assert
.
Assertions can normally be turned on or off with a compiler flag
(for GHC, assertions are normally on unless optimisation is turned on
with -O
or the -fignore-asserts
option is given). When assertions are turned off, the first
argument to assert
is ignored, and the second argument is
returned as the result.
The lazy
function restrains strictness analysis a little. The
call lazy e
means the same as e
, but lazy
has a magical
property so far as strictness analysis is concerned: it is lazy in
its first argument, even though its semantics is strict. After
strictness analysis has run, calls to lazy
are inlined to be the
identity function.
This behaviour is occasionally useful when controlling evaluation
order. Notably, lazy
is used in the library definition of
par
:
par :: a -> b -> b par x y = case (par# x) of _ -> lazy y
If lazy
were not lazy, par
would look strict in
y
which would defeat the whole purpose of par
.
Like seq
, the argument of lazy
can have an unboxed type.
assertError :: (?callStack :: CallStack) => Bool -> a -> a #
The trace
function outputs the trace message given as its first argument,
before returning the second argument as its result.
For example, this returns the value of f x
but first outputs the message.
>>>
let x = 123; f = show
>>>
trace ("calling f with x = " ++ show x) (f x)
"calling f with x = 123 123"
The trace
function should only be used for debugging, or for monitoring
execution. The function is not referentially transparent: its type indicates
that it is a pure function but it has the side effect of outputting the
trace message.
The call inline f
arranges that f
is inlined, regardless of
its size. More precisely, the call inline f
rewrites to the
right-hand side of f
's definition. This allows the programmer to
control inlining from a particular call site rather than the
definition site of the function (c.f. INLINE
pragmas).
This inlining occurs regardless of the argument to the call or the
size of f
's definition; it is unconditional. The main caveat is
that f
's definition must be visible to the compiler; it is
therefore recommended to mark the function with an INLINABLE
pragma at its definition so that GHC guarantees to record its
unfolding regardless of size.
If no inlining takes place, the inline
function expands to the
identity function in Phase zero, so its use imposes no overhead.
map :: (a -> b) -> [a] -> [b] #
\(\mathcal{O}(n)\). map
f xs
is the list obtained by applying f
to
each element of xs
, i.e.,
map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] map f [x1, x2, ...] == [f x1, f x2, ...]
>>>
map (+1) [1, 2, 3]
groupWith :: Ord b => (a -> b) -> [a] -> [[a]] #
The groupWith
function uses the user supplied function which
projects an element out of every list element in order to first sort the
input list and then to form groups by equality on these projected elements
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b infixr 0 #
Application operator. This operator is redundant, since ordinary
application (f x)
means the same as (f
. However, $
x)$
has
low, right-associative binding precedence, so it sometimes allows
parentheses to be omitted; for example:
f $ g $ h x = f (g (h x))
It is also useful in higher-order situations, such as
,
or map
($
0) xs
.zipWith
($
) fs xs
Note that (
is levity-polymorphic in its result type, so that
$
)foo
where $
Truefoo :: Bool -> Int#
is well-typed.
coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b #
The function coerce
allows you to safely convert between values of
types that have the same representation with no run-time overhead. In the
simplest case you can use it instead of a newtype constructor, to go from
the newtype's concrete type to the abstract type. But it also works in
more complicated settings, e.g. converting a list of newtypes to a list of
concrete types.
This function is runtime-representation polymorphic, but the
RuntimeRep
type argument is marked as Inferred
, meaning
that it is not available for visible type application. This means
the typechecker will accept coerce @Int @Age 42
.
fromIntegral :: (Integral a, Num b) => a -> b #
general coercion from integral types
realToFrac :: (Real a, Fractional b) => a -> b #
general coercion to fractional types
guard :: Alternative f => Bool -> f () #
Conditional failure of Alternative
computations. Defined by
guard True =pure
() guard False =empty
Examples
Common uses of guard
include conditionally signaling an error in
an error monad and conditionally rejecting the current choice in an
Alternative
-based parser.
As an example of signaling an error in the error monad Maybe
,
consider a safe division function safeDiv x y
that returns
Nothing
when the denominator y
is zero and
otherwise. For example:Just
(x `div`
y)
>>> safeDiv 4 0 Nothing >>> safeDiv 4 2 Just 2
A definition of safeDiv
using guards, but not guard
:
safeDiv :: Int -> Int -> Maybe Int safeDiv x y | y /= 0 = Just (x `div` y) | otherwise = Nothing
A definition of safeDiv
using guard
and Monad
do
-notation:
safeDiv :: Int -> Int -> Maybe Int safeDiv x y = do guard (y /= 0) return (x `div` y)
The IsList
class and its methods are intended to be used in
conjunction with the OverloadedLists extension.
Since: base-4.7.0.0
Methods
The fromList
function constructs the structure l
from the given
list of Item l
fromListN :: Int -> [Item l] -> l #
The fromListN
function takes the input list's length as a hint. Its
behaviour should be equivalent to fromList
. The hint can be used to
construct the structure l
more efficiently compared to fromList
. If
the given hint does not equal to the input list's length the behaviour of
fromListN
is not specified.
The toList
function extracts a list of Item l
from the structure l
.
It should satisfy fromList . toList = id.
Instances
IsList CallStack | Be aware that 'fromList . toList = id' only for unfrozen Since: base-4.9.0.0 |
IsList Version | Since: base-4.8.0.0 |
IsList IntSet | Since: containers-0.5.6.2 |
IsList ByteArray | Since: primitive-0.6.3.0 |
IsList [a] | Since: base-4.7.0.0 |
IsList (ZipList a) | Since: base-4.15.0.0 |
IsList (NonEmpty a) | Since: base-4.9.0.0 |
IsList (IntMap a) | Since: containers-0.5.6.2 |
IsList (Seq a) | |
Ord a => IsList (Set a) | Since: containers-0.5.6.2 |
IsList (DList a) | |
Prim a => IsList (PrimArray a) | Since: primitive-0.6.4.0 |
IsList (SmallArray a) | |
Defined in Data.Primitive.SmallArray Associated Types type Item (SmallArray a) # Methods fromList :: [Item (SmallArray a)] -> SmallArray a # fromListN :: Int -> [Item (SmallArray a)] -> SmallArray a # toList :: SmallArray a -> [Item (SmallArray a)] # | |
IsList (Array a) | |
(Eq a, Hashable a) => IsList (HashSet a) | |
Storable a => IsList (Vector a) | |
Prim a => IsList (Vector a) | |
IsList (Vector a) | |
Ord k => IsList (Map k v) | Since: containers-0.5.6.2 |
(Eq k, Hashable k) => IsList (HashMap k v) | |
toDyn :: Typeable a => a -> Dynamic #
Converts an arbitrary value into an object of type Dynamic
.
The type of the object must be an instance of Typeable
, which
ensures that only monomorphically-typed objects may be converted to
Dynamic
. To convert a polymorphic object into Dynamic
, give it
a monomorphic type signature. For example:
toDyn (id :: Int -> Int)
join :: Monad m => m (m a) -> m a #
The join
function is the conventional monad join operator. It
is used to remove one level of monadic structure, projecting its
bound argument into the outer level.
'
' can be understood as the join
bssdo
expression
do bs <- bss bs
Examples
A common use of join
is to run an IO
computation returned from
an STM
transaction, since STM
transactions
can't perform IO
directly. Recall that
atomically
:: STM a -> IO a
is used to run STM
transactions atomically. So, by
specializing the types of atomically
and join
to
atomically
:: STM (IO b) -> IO (IO b)join
:: IO (IO b) -> IO b
we can compose them as
join
.atomically
:: STM (IO b) -> IO b
The Bounded
class is used to name the upper and lower limits of a
type. Ord
is not a superclass of Bounded
since types that are not
totally ordered may also have upper and lower bounds.
The Bounded
class may be derived for any enumeration type;
minBound
is the first constructor listed in the data
declaration
and maxBound
is the last.
Bounded
may also be derived for single-constructor datatypes whose
constituent types are in Bounded
.
Instances
Class Enum
defines operations on sequentially ordered types.
The enumFrom
... methods are used in Haskell's translation of
arithmetic sequences.
Instances of Enum
may be derived for any enumeration type (types
whose constructors have no fields). The nullary constructors are
assumed to be numbered left-to-right by fromEnum
from 0
through n-1
.
See Chapter 10 of the Haskell Report for more details.
For any type that is an instance of class Bounded
as well as Enum
,
the following should hold:
- The calls
andsucc
maxBound
should result in a runtime error.pred
minBound
fromEnum
andtoEnum
should give a runtime error if the result value is not representable in the result type. For example,
is an error.toEnum
7 ::Bool
enumFrom
andenumFromThen
should be defined with an implicit bound, thus:
enumFrom x = enumFromTo x maxBound enumFromThen x y = enumFromThenTo x y bound where bound | fromEnum y >= fromEnum x = maxBound | otherwise = minBound
Methods
the successor of a value. For numeric types, succ
adds 1.
the predecessor of a value. For numeric types, pred
subtracts 1.
Convert from an Int
.
Convert to an Int
.
It is implementation-dependent what fromEnum
returns when
applied to a value that is too large to fit in an Int
.
Used in Haskell's translation of [n..]
with [n..] = enumFrom n
,
a possible implementation being enumFrom n = n : enumFrom (succ n)
.
For example:
enumFrom 4 :: [Integer] = [4,5,6,7,...]
enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound :: Int]
enumFromThen :: a -> a -> [a] #
Used in Haskell's translation of [n,n'..]
with [n,n'..] = enumFromThen n n'
, a possible implementation being
enumFromThen n n' = n : n' : worker (f x) (f x n')
,
worker s v = v : worker s (s v)
, x = fromEnum n' - fromEnum n
and
f n y
| n > 0 = f (n - 1) (succ y)
| n < 0 = f (n + 1) (pred y)
| otherwise = y
For example:
enumFromThen 4 6 :: [Integer] = [4,6,8,10...]
enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound :: Int]
enumFromTo :: a -> a -> [a] #
Used in Haskell's translation of [n..m]
with
[n..m] = enumFromTo n m
, a possible implementation being
enumFromTo n m
| n <= m = n : enumFromTo (succ n) m
| otherwise = []
.
For example:
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
enumFromTo 42 1 :: [Integer] = []
enumFromThenTo :: a -> a -> a -> [a] #
Used in Haskell's translation of [n,n'..m]
with
[n,n'..m] = enumFromThenTo n n' m
, a possible implementation
being enumFromThenTo n n' m = worker (f x) (c x) n m
,
x = fromEnum n' - fromEnum n
, c x = bool (>=) ((x 0)
f n y
| n > 0 = f (n - 1) (succ y)
| n < 0 = f (n + 1) (pred y)
| otherwise = y
and
worker s c v m
| c v m = v : worker s c (s v) m
| otherwise = []
For example:
enumFromThenTo 4 2 -6 :: [Integer] = [4,2,0,-2,-4,-6]
enumFromThenTo 6 8 2 :: [Int] = []
Instances
The Eq
class defines equality (==
) and inequality (/=
).
All the basic datatypes exported by the Prelude are instances of Eq
,
and Eq
may be derived for any datatype whose constituents are also
instances of Eq
.
The Haskell Report defines no laws for Eq
. However, ==
is customarily
expected to implement an equivalence relationship where two values comparing
equal are indistinguishable by "public" functions, with a "public" function
being one not allowing to see implementation details. For example, for a
type representing non-normalised natural numbers modulo 100, a "public"
function doesn't make the difference between 1 and 201. It is expected to
have the following properties:
Instances
Eq Bool | |
Eq Char | |
Eq Double | Note that due to the presence of
Also note that
|
Eq Float | Note that due to the presence of
Also note that
|
Eq Int | |
Eq Int8 | Since: base-2.1 |
Eq Int16 | Since: base-2.1 |
Eq Int32 | Since: base-2.1 |
Eq Int64 | Since: base-2.1 |
Eq Integer | |
Eq Natural | Since: base-4.8.0.0 |
Eq Ordering | |
Eq Word | |
Eq Word8 | Since: base-2.1 |
Eq Word16 | Since: base-2.1 |
Eq Word32 | Since: base-2.1 |
Eq Word64 | Since: base-2.1 |
Eq SomeTypeRep | |
Defined in Data.Typeable.Internal | |
Eq Exp | |
Eq Match | |
Eq Clause | |
Eq Pat | |
Eq Type | |
Eq Dec | |
Eq Name | |
Eq FunDep | |
Eq InjectivityAnn | |
Defined in Language.Haskell.TH.Syntax Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool # | |
Eq Overlap | |
Eq () | |
Eq TyCon | |
Eq Module | |
Eq TrName | |
Eq Handle | Since: base-4.1.0.0 |
Eq Void | Since: base-4.8.0.0 |
Eq SpecConstrAnnotation | Since: base-4.3.0.0 |
Defined in GHC.Exts Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # | |
Eq Constr | Equality of constructors Since: base-4.0.0.0 |
Eq DataRep | Since: base-4.0.0.0 |
Eq ConstrRep | Since: base-4.0.0.0 |
Eq Fixity | Since: base-4.0.0.0 |
Eq Timeout | |
Eq Unique | |
Eq Version | Since: base-2.1 |
Defined in Data.Version |