polysemy-time 0.1.4.0 → 0.2.0.0
raw patch · 3 files changed
+12/−241 lines, 3 filesdep −compositiondep −containersdep −data-defaultPVP ok
version bump matches the API change (PVP)
Dependencies removed: composition, containers, data-default, either, hedgehog, tasty-hedgehog
API changes (from Hackage documentation)
- Polysemy.Time.Prelude: (!!?) :: [a] -> Int -> Maybe a
- Polysemy.Time.Prelude: ($!!) :: NFData a => (a -> b) -> a -> b
- Polysemy.Time.Prelude: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- Polysemy.Time.Prelude: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- Polysemy.Time.Prelude: ($<) :: Contravariant f => f b -> b -> f a
- Polysemy.Time.Prelude: ($>) :: Functor f => f a -> b -> f b
- Polysemy.Time.Prelude: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
- Polysemy.Time.Prelude: (&&) :: Bool -> Bool -> Bool
- Polysemy.Time.Prelude: (&&^) :: Monad m => m Bool -> m Bool -> m Bool
- Polysemy.Time.Prelude: (&) :: a -> (a -> b) -> b
- Polysemy.Time.Prelude: (*) :: Num a => a -> a -> a
- Polysemy.Time.Prelude: (**) :: Floating a => a -> a -> a
- Polysemy.Time.Prelude: (*>) :: Applicative f => f a -> f b -> f b
- Polysemy.Time.Prelude: (+) :: Num a => a -> a -> a
- Polysemy.Time.Prelude: (++) :: [a] -> [a] -> [a]
- Polysemy.Time.Prelude: (-) :: Num a => a -> a -> a
- Polysemy.Time.Prelude: (.) :: (b -> c) -> (a -> b) -> a -> c
- Polysemy.Time.Prelude: (.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
- Polysemy.Time.Prelude: (.:.) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
- Polysemy.Time.Prelude: (.::) :: (d -> e) -> (a1 -> a2 -> b -> c -> d) -> a1 -> a2 -> b -> c -> e
- Polysemy.Time.Prelude: (/) :: Fractional a => a -> a -> a
- Polysemy.Time.Prelude: (/=) :: Eq a => a -> a -> Bool
- Polysemy.Time.Prelude: (:|) :: a -> [a] -> NonEmpty a
- Polysemy.Time.Prelude: (<$!>) :: Monad m => (a -> b) -> m a -> m b
- Polysemy.Time.Prelude: (<$) :: Functor f => a -> f b -> f a
- Polysemy.Time.Prelude: (<$>) :: Functor f => (a -> b) -> f a -> f b
- Polysemy.Time.Prelude: (<&>) :: Functor f => f a -> (a -> b) -> f b
- Polysemy.Time.Prelude: (<) :: Ord a => a -> a -> Bool
- Polysemy.Time.Prelude: (<*) :: Applicative f => f a -> f b -> f a
- Polysemy.Time.Prelude: (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- Polysemy.Time.Prelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
- Polysemy.Time.Prelude: (<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
- Polysemy.Time.Prelude: (<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- Polysemy.Time.Prelude: (<=) :: Ord a => a -> a -> Bool
- Polysemy.Time.Prelude: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- Polysemy.Time.Prelude: (<>) :: Semigroup a => a -> a -> a
- Polysemy.Time.Prelude: (<|) :: a -> NonEmpty a -> NonEmpty a
- Polysemy.Time.Prelude: (<|>) :: Alternative f => f a -> f a -> f a
- Polysemy.Time.Prelude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
- Polysemy.Time.Prelude: (==) :: Eq a => a -> a -> Bool
- Polysemy.Time.Prelude: (>$$<) :: Contravariant f => f b -> (a -> b) -> f a
- Polysemy.Time.Prelude: (>$) :: Contravariant f => b -> f b -> f a
- Polysemy.Time.Prelude: (>$<) :: Contravariant f => (a -> b) -> f b -> f a
- Polysemy.Time.Prelude: (>) :: Ord a => a -> a -> Bool
- Polysemy.Time.Prelude: (>=) :: Ord a => a -> a -> Bool
- Polysemy.Time.Prelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- Polysemy.Time.Prelude: (>>) :: Monad m => m a -> m b -> m b
- Polysemy.Time.Prelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
- Polysemy.Time.Prelude: (>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
- Polysemy.Time.Prelude: (?:) :: Maybe a -> a -> a
- Polysemy.Time.Prelude: (??) :: Functor f => f (a -> b) -> a -> f b
- Polysemy.Time.Prelude: (^) :: (Num a, Integral b) => a -> b -> a
- Polysemy.Time.Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
- Polysemy.Time.Prelude: (||) :: Bool -> Bool -> Bool
- Polysemy.Time.Prelude: (||^) :: Monad m => m Bool -> m Bool -> m Bool
- Polysemy.Time.Prelude: All :: Bool -> All
- Polysemy.Time.Prelude: Alt :: f a -> Alt (f :: k -> Type) (a :: k)
- Polysemy.Time.Prelude: Any :: Bool -> Any
- Polysemy.Time.Prelude: Ap :: f a -> Ap (f :: k -> Type) (a :: k)
- Polysemy.Time.Prelude: AppendMode :: IOMode
- Polysemy.Time.Prelude: BlockBuffering :: Maybe Int -> BufferMode
- Polysemy.Time.Prelude: Bug :: SomeException -> CallStack -> Bug
- Polysemy.Time.Prelude: Comparison :: (a -> a -> Ordering) -> Comparison a
- Polysemy.Time.Prelude: Compose :: f (g a) -> Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
- Polysemy.Time.Prelude: Const :: a -> Const a (b :: k)
- Polysemy.Time.Prelude: D# :: Double# -> Double
- Polysemy.Time.Prelude: Down :: a -> Down a
- Polysemy.Time.Prelude: Dual :: a -> Dual a
- Polysemy.Time.Prelude: EQ :: Ordering
- Polysemy.Time.Prelude: Endo :: (a -> a) -> Endo a
- Polysemy.Time.Prelude: Equivalence :: (a -> a -> Bool) -> Equivalence a
- Polysemy.Time.Prelude: ExceptT :: m (Either e a) -> ExceptT e (m :: Type -> Type) a
- Polysemy.Time.Prelude: F# :: Float# -> Float
- Polysemy.Time.Prelude: False :: Bool
- Polysemy.Time.Prelude: First :: Maybe a -> First a
- Polysemy.Time.Prelude: GT :: Ordering
- Polysemy.Time.Prelude: Identity :: a -> Identity a
- Polysemy.Time.Prelude: Just :: a -> Maybe a
- Polysemy.Time.Prelude: LT :: Ordering
- Polysemy.Time.Prelude: Last :: Maybe a -> Last a
- Polysemy.Time.Prelude: Left :: a -> Either a b
- Polysemy.Time.Prelude: LineBuffering :: BufferMode
- Polysemy.Time.Prelude: MaybeT :: m (Maybe a) -> MaybeT (m :: Type -> Type) a
- Polysemy.Time.Prelude: NoBuffering :: BufferMode
- Polysemy.Time.Prelude: Nothing :: Maybe a
- Polysemy.Time.Prelude: Op :: (b -> a) -> Op a b
- Polysemy.Time.Prelude: Option :: Maybe a -> Option a
- Polysemy.Time.Prelude: Predicate :: (a -> Bool) -> Predicate a
- Polysemy.Time.Prelude: Product :: a -> Product a
- Polysemy.Time.Prelude: Proxy :: Proxy (t :: k)
- Polysemy.Time.Prelude: ReadMode :: IOMode
- Polysemy.Time.Prelude: ReadWriteMode :: IOMode
- Polysemy.Time.Prelude: ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a
- Polysemy.Time.Prelude: Right :: b -> Either a b
- Polysemy.Time.Prelude: SomeException :: e -> SomeException
- Polysemy.Time.Prelude: SomeNat :: Proxy n -> SomeNat
- Polysemy.Time.Prelude: StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a
- Polysemy.Time.Prelude: True :: Bool
- Polysemy.Time.Prelude: Undefined :: Undefined
- Polysemy.Time.Prelude: WriteMode :: IOMode
- Polysemy.Time.Prelude: ZipList :: [a] -> ZipList a
- Polysemy.Time.Prelude: [appEndo] :: Endo a -> a -> a
- Polysemy.Time.Prelude: [getAll] :: All -> Bool
- Polysemy.Time.Prelude: [getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
- Polysemy.Time.Prelude: [getAny] :: Any -> Bool
- Polysemy.Time.Prelude: [getAp] :: Ap (f :: k -> Type) (a :: k) -> f a
- Polysemy.Time.Prelude: [getComparison] :: Comparison a -> a -> a -> Ordering
- Polysemy.Time.Prelude: [getCompose] :: Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) -> f (g a)
- Polysemy.Time.Prelude: [getConst] :: Const a (b :: k) -> a
- Polysemy.Time.Prelude: [getDown] :: Down a -> a
- Polysemy.Time.Prelude: [getDual] :: Dual a -> a
- Polysemy.Time.Prelude: [getEquivalence] :: Equivalence a -> a -> a -> Bool
- Polysemy.Time.Prelude: [getFirst] :: First a -> Maybe a
- Polysemy.Time.Prelude: [getLast] :: Last a -> Maybe a
- Polysemy.Time.Prelude: [getOp] :: Op a b -> b -> a
- Polysemy.Time.Prelude: [getOption] :: Option a -> Maybe a
- Polysemy.Time.Prelude: [getPredicate] :: Predicate a -> a -> Bool
- Polysemy.Time.Prelude: [getProduct] :: Product a -> a
- Polysemy.Time.Prelude: [getZipList] :: ZipList a -> [a]
- Polysemy.Time.Prelude: [runIdentity] :: Identity a -> a
- Polysemy.Time.Prelude: [runMaybeT] :: MaybeT (m :: Type -> Type) a -> m (Maybe a)
- Polysemy.Time.Prelude: [runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a
- Polysemy.Time.Prelude: [runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)
- Polysemy.Time.Prelude: abs :: Num a => a -> a
- Polysemy.Time.Prelude: absurd :: Void -> a
- Polysemy.Time.Prelude: acos :: Floating a => a -> a
- Polysemy.Time.Prelude: acosh :: Floating a => a -> a
- Polysemy.Time.Prelude: all :: Foldable t => (a -> Bool) -> t a -> Bool
- Polysemy.Time.Prelude: allM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
- Polysemy.Time.Prelude: and :: Foldable t => t Bool -> Bool
- Polysemy.Time.Prelude: andM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
- Polysemy.Time.Prelude: any :: Foldable t => (a -> Bool) -> t a -> Bool
- Polysemy.Time.Prelude: anyM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
- Polysemy.Time.Prelude: appendFile :: MonadIO m => FilePath -> String -> m ()
- Polysemy.Time.Prelude: appendFileBS :: MonadIO m => FilePath -> ByteString -> m ()
- Polysemy.Time.Prelude: appendFileLBS :: MonadIO m => FilePath -> LByteString -> m ()
- Polysemy.Time.Prelude: appendFileLText :: MonadIO m => FilePath -> LText -> m ()
- Polysemy.Time.Prelude: appendFileText :: MonadIO m => FilePath -> Text -> m ()
- Polysemy.Time.Prelude: appliedTo :: Applicative f => f a -> f (a -> b) -> f b
- Polysemy.Time.Prelude: as :: Functor m => a -> m b -> m a
- Polysemy.Time.Prelude: asTypeOf :: a -> a -> a
- Polysemy.Time.Prelude: asin :: Floating a => a -> a
- Polysemy.Time.Prelude: asinh :: Floating a => a -> a
- Polysemy.Time.Prelude: asum :: (Foldable t, Alternative f) => t (f a) -> f a
- Polysemy.Time.Prelude: asumMap :: forall b m f a. (Foldable f, Alternative m) => (a -> m b) -> f a -> m b
- Polysemy.Time.Prelude: atan :: Floating a => a -> a
- Polysemy.Time.Prelude: atan2 :: RealFloat a => a -> a -> a
- Polysemy.Time.Prelude: atanh :: Floating a => a -> a
- Polysemy.Time.Prelude: atomicGet :: forall s (r :: [(Type -> Type) -> Type -> Type]). Member (AtomicState s :: (Type -> Type) -> Type -> Type) r => Sem r s
- Polysemy.Time.Prelude: atomicGets :: forall s s' (r :: [(Type -> Type) -> Type -> Type]). Member (AtomicState s :: (Type -> Type) -> Type -> Type) r => (s -> s') -> Sem r s'
- Polysemy.Time.Prelude: atomicModify' :: forall s (r :: [(Type -> Type) -> Type -> Type]). Member (AtomicState s :: (Type -> Type) -> Type -> Type) r => (s -> s) -> Sem r ()
- Polysemy.Time.Prelude: atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
- Polysemy.Time.Prelude: atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
- Polysemy.Time.Prelude: atomicModifyIORef'_ :: MonadIO m => IORef a -> (a -> a) -> m ()
- Polysemy.Time.Prelude: atomicModifyIORef_ :: MonadIO m => IORef a -> (a -> a) -> m ()
- Polysemy.Time.Prelude: atomicPut :: forall s (r :: [(Type -> Type) -> Type -> Type]). Member (AtomicState s :: (Type -> Type) -> Type -> Type) r => s -> Sem r ()
- Polysemy.Time.Prelude: atomicWriteIORef :: MonadIO m => IORef a -> a -> m ()
- Polysemy.Time.Prelude: atomically :: MonadIO m => STM a -> m a
- Polysemy.Time.Prelude: basicOptions :: Options
- Polysemy.Time.Prelude: biList :: Bifoldable t => t a a -> [a]
- Polysemy.Time.Prelude: biall :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
- Polysemy.Time.Prelude: biand :: Bifoldable t => t Bool Bool -> Bool
- Polysemy.Time.Prelude: biany :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
- Polysemy.Time.Prelude: biasum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a
- Polysemy.Time.Prelude: bielem :: (Bifoldable t, Eq a) => a -> t a a -> Bool
- Polysemy.Time.Prelude: bifind :: Bifoldable t => (a -> Bool) -> t a a -> Maybe a
- Polysemy.Time.Prelude: bifold :: (Bifoldable p, Monoid m) => p m m -> m
- Polysemy.Time.Prelude: bifoldMap :: (Bifoldable p, Monoid m) => (a -> m) -> (b -> m) -> p a b -> m
- Polysemy.Time.Prelude: bifoldMapDefault :: (Bitraversable t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m
- Polysemy.Time.Prelude: bifoldl :: Bifoldable p => (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c
- Polysemy.Time.Prelude: bifoldl' :: Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a
- Polysemy.Time.Prelude: bifoldlM :: (Bifoldable t, Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a
- Polysemy.Time.Prelude: bifoldr :: Bifoldable p => (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
- Polysemy.Time.Prelude: bifoldr' :: Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c
- Polysemy.Time.Prelude: bifoldrM :: (Bifoldable t, Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c
- Polysemy.Time.Prelude: bifor :: (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
- Polysemy.Time.Prelude: bifor_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
- Polysemy.Time.Prelude: bilength :: Bifoldable t => t a b -> Int
- Polysemy.Time.Prelude: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
- Polysemy.Time.Prelude: bimapDefault :: Bitraversable t => (a -> b) -> (c -> d) -> t a c -> t b d
- Polysemy.Time.Prelude: binull :: Bifoldable t => t a b -> Bool
- Polysemy.Time.Prelude: bior :: Bifoldable t => t Bool Bool -> Bool
- Polysemy.Time.Prelude: bisequence :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)
- Polysemy.Time.Prelude: bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()
- Polysemy.Time.Prelude: bitraverse :: (Bitraversable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
- Polysemy.Time.Prelude: bitraverse_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
- Polysemy.Time.Prelude: bool :: a -> a -> Bool -> a
- Polysemy.Time.Prelude: boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
- Polysemy.Time.Prelude: boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
- Polysemy.Time.Prelude: break :: (a -> Bool) -> [a] -> ([a], [a])
- Polysemy.Time.Prelude: bug :: (HasCallStack, Exception e) => e -> a
- Polysemy.Time.Prelude: byteSwap16 :: Word16 -> Word16
- Polysemy.Time.Prelude: byteSwap32 :: Word32 -> Word32
- Polysemy.Time.Prelude: byteSwap64 :: Word64 -> Word64
- Polysemy.Time.Prelude: callStack :: HasCallStack => CallStack
- Polysemy.Time.Prelude: catMaybes :: [Maybe a] -> [a]
- Polysemy.Time.Prelude: catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a
- Polysemy.Time.Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
- Polysemy.Time.Prelude: chainedTo :: Monad m => (a -> m b) -> m a -> m b
- Polysemy.Time.Prelude: chr :: Int -> Char
- Polysemy.Time.Prelude: class Applicative f => Alternative (f :: Type -> Type)
- Polysemy.Time.Prelude: class Functor f => Applicative (f :: Type -> Type)
- Polysemy.Time.Prelude: class Bifoldable (p :: Type -> Type -> Type)
- Polysemy.Time.Prelude: class Bifunctor (p :: Type -> Type -> Type)
- Polysemy.Time.Prelude: class (Bifunctor t, Bifoldable t) => Bitraversable (t :: Type -> Type -> Type)
- Polysemy.Time.Prelude: class Bounded a
- Polysemy.Time.Prelude: class a ~R# b => Coercible (a :: k) (b :: k)
- Polysemy.Time.Prelude: class Contravariant (f :: Type -> Type)
- Polysemy.Time.Prelude: class ConvertUtf8 a b
- Polysemy.Time.Prelude: class Default a
- Polysemy.Time.Prelude: class Enum a
- Polysemy.Time.Prelude: class Eq a
- Polysemy.Time.Prelude: class (Typeable e, Show e) => Exception e
- Polysemy.Time.Prelude: class Fractional a => Floating a
- Polysemy.Time.Prelude: class Foldable (t :: Type -> Type)
- Polysemy.Time.Prelude: class Num a => Fractional a
- Polysemy.Time.Prelude: class FromJSON a
- Polysemy.Time.Prelude: class Functor (f :: Type -> Type)
- Polysemy.Time.Prelude: class Generic a
- Polysemy.Time.Prelude: class Hashable a
- Polysemy.Time.Prelude: class (Real a, Enum a) => Integral a
- Polysemy.Time.Prelude: class IsLabel (x :: Symbol) a
- Polysemy.Time.Prelude: class IsList l
- Polysemy.Time.Prelude: class IsString a
- Polysemy.Time.Prelude: class KnownNat (n :: Nat)
- Polysemy.Time.Prelude: class LazyStrict l s | l -> s, s -> l
- Polysemy.Time.Prelude: class Applicative m => Monad (m :: Type -> Type)
- Polysemy.Time.Prelude: class Monad m => MonadFail (m :: Type -> Type)
- Polysemy.Time.Prelude: class Monad m => MonadIO (m :: Type -> Type)
- Polysemy.Time.Prelude: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
- Polysemy.Time.Prelude: class Monad m => MonadReader r (m :: Type -> Type) | m -> r
- Polysemy.Time.Prelude: class Monad m => MonadState s (m :: Type -> Type) | m -> s
- Polysemy.Time.Prelude: class MonadTrans (t :: Type -> Type -> Type -> Type)
- Polysemy.Time.Prelude: class Semigroup a => Monoid a
- Polysemy.Time.Prelude: class NFData a
- Polysemy.Time.Prelude: class Num a
- Polysemy.Time.Prelude: class One x where {
- Polysemy.Time.Prelude: class Eq a => Ord a
- Polysemy.Time.Prelude: class Read a
- Polysemy.Time.Prelude: class (Num a, Ord a) => Real a
- Polysemy.Time.Prelude: class (RealFrac a, Floating a) => RealFloat a
- Polysemy.Time.Prelude: class (Real a, Fractional a) => RealFrac a
- Polysemy.Time.Prelude: class Semigroup a
- Polysemy.Time.Prelude: class Show a
- Polysemy.Time.Prelude: class ToJSON a
- Polysemy.Time.Prelude: class ToLText a
- Polysemy.Time.Prelude: class ToString a
- Polysemy.Time.Prelude: class ToText a
- Polysemy.Time.Prelude: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
- Polysemy.Time.Prelude: class Typeable (a :: k)
- Polysemy.Time.Prelude: coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
- Polysemy.Time.Prelude: compare :: Ord a => a -> a -> Ordering
- Polysemy.Time.Prelude: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
- Polysemy.Time.Prelude: comparisonEquivalence :: Comparison a -> Equivalence a
- Polysemy.Time.Prelude: concat :: Foldable t => t [a] -> [a]
- Polysemy.Time.Prelude: concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- Polysemy.Time.Prelude: const :: a -> b -> a
- Polysemy.Time.Prelude: contramap :: Contravariant f => (a -> b) -> f b -> f a
- Polysemy.Time.Prelude: cos :: Floating a => a -> a
- Polysemy.Time.Prelude: cosh :: Floating a => a -> a
- Polysemy.Time.Prelude: currentCallStack :: IO [String]
- Polysemy.Time.Prelude: curry :: ((a, b) -> c) -> a -> b -> c
- Polysemy.Time.Prelude: cycle :: [a] -> [a]
- Polysemy.Time.Prelude: cycle1 :: Semigroup m => m -> m
- Polysemy.Time.Prelude: data AtomicState s (m :: k) a
- Polysemy.Time.Prelude: data Bool
- Polysemy.Time.Prelude: data BufferMode
- Polysemy.Time.Prelude: data Bug
- Polysemy.Time.Prelude: data ByteString
- Polysemy.Time.Prelude: data CallStack
- Polysemy.Time.Prelude: data Char
- Polysemy.Time.Prelude: data Constraint
- Polysemy.Time.Prelude: data Double
- Polysemy.Time.Prelude: data Either a b
- Polysemy.Time.Prelude: data Embed (m :: Type -> Type) (z :: Type -> Type) a
- Polysemy.Time.Prelude: data Error e (m :: k -> Type) (a :: k)
- Polysemy.Time.Prelude: data Final (m :: Type -> Type) (z :: Type -> Type) a
- Polysemy.Time.Prelude: data Float
- Polysemy.Time.Prelude: data Handle
- Polysemy.Time.Prelude: data HashMap k v
- Polysemy.Time.Prelude: data HashSet a
- Polysemy.Time.Prelude: data IO a
- Polysemy.Time.Prelude: data IOMode
- Polysemy.Time.Prelude: data IORef a
- Polysemy.Time.Prelude: data IdentityT (f :: k -> Type) (a :: k)
- Polysemy.Time.Prelude: data Int
- Polysemy.Time.Prelude: data Int16
- Polysemy.Time.Prelude: data Int32
- Polysemy.Time.Prelude: data Int64
- Polysemy.Time.Prelude: data Int8
- Polysemy.Time.Prelude: data IntMap a
- Polysemy.Time.Prelude: data IntSet
- Polysemy.Time.Prelude: data Integer
- Polysemy.Time.Prelude: data MVar a
- Polysemy.Time.Prelude: data Map k a
- Polysemy.Time.Prelude: data Maybe a
- Polysemy.Time.Prelude: data Nat
- Polysemy.Time.Prelude: data Natural
- Polysemy.Time.Prelude: data NonEmpty a
- Polysemy.Time.Prelude: data Ordering
- Polysemy.Time.Prelude: data Proxy (t :: k)
- Polysemy.Time.Prelude: data Ratio a
- Polysemy.Time.Prelude: data Reader i (m :: Type -> Type) a
- Polysemy.Time.Prelude: data STM a
- Polysemy.Time.Prelude: data Sem (r :: EffectRow) a
- Polysemy.Time.Prelude: data Seq a
- Polysemy.Time.Prelude: data Set a
- Polysemy.Time.Prelude: data ShortByteString
- Polysemy.Time.Prelude: data SomeException
- Polysemy.Time.Prelude: data SomeNat
- Polysemy.Time.Prelude: data State s (m :: k) a
- Polysemy.Time.Prelude: data Symbol
- Polysemy.Time.Prelude: data TMVar a
- Polysemy.Time.Prelude: data TVar a
- Polysemy.Time.Prelude: data Text
- Polysemy.Time.Prelude: data Undefined
- Polysemy.Time.Prelude: data UnicodeException
- Polysemy.Time.Prelude: data Void
- Polysemy.Time.Prelude: data Word
- Polysemy.Time.Prelude: data Word16
- Polysemy.Time.Prelude: data Word32
- Polysemy.Time.Prelude: data Word64
- Polysemy.Time.Prelude: data Word8
- Polysemy.Time.Prelude: data WrappedMonoid m
- Polysemy.Time.Prelude: dbg :: HasCallStack => Monad m => Text -> m ()
- Polysemy.Time.Prelude: dbgs :: HasCallStack => Monad m => Show a => a -> m ()
- Polysemy.Time.Prelude: dbgs_ :: HasCallStack => Monad m => Show a => a -> m a
- Polysemy.Time.Prelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
- Polysemy.Time.Prelude: decodeUtf8 :: ConvertUtf8 a b => b -> a
- Polysemy.Time.Prelude: decodeUtf8' :: ByteString -> Either UnicodeException Text
- Polysemy.Time.Prelude: decodeUtf8Strict :: ConvertUtf8 a b => b -> Either UnicodeException a
- Polysemy.Time.Prelude: decodeUtf8With :: OnDecodeError -> ByteString -> Text
- Polysemy.Time.Prelude: deepseq :: NFData a => a -> b -> b
- Polysemy.Time.Prelude: def :: Default a => a
- Polysemy.Time.Prelude: defaultComparison :: Ord a => Comparison a
- Polysemy.Time.Prelude: defaultEquivalence :: Eq a => Equivalence a
- Polysemy.Time.Prelude: defaultJson :: Name -> Q [Dec]
- Polysemy.Time.Prelude: denominator :: Ratio a -> a
- Polysemy.Time.Prelude: deriveFromJSON :: Options -> Name -> Q [Dec]
- Polysemy.Time.Prelude: deriveJSON :: Options -> Name -> Q [Dec]
- Polysemy.Time.Prelude: die :: MonadIO m => String -> m a
- Polysemy.Time.Prelude: displayException :: Exception e => e -> String
- Polysemy.Time.Prelude: div :: Integral a => a -> a -> a
- Polysemy.Time.Prelude: divMod :: Integral a => a -> a -> (a, a)
- Polysemy.Time.Prelude: divOr0 :: Real a => Integral a => a -> a -> a
- Polysemy.Time.Prelude: drop :: Int -> [a] -> [a]
- Polysemy.Time.Prelude: dropWhile :: (a -> Bool) -> [a] -> [a]
- Polysemy.Time.Prelude: either :: (a -> c) -> (b -> c) -> Either a b -> c
- Polysemy.Time.Prelude: elem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
- Polysemy.Time.Prelude: embed :: forall m (r :: [(Type -> Type) -> Type -> Type]) a. Member (Embed m) r => m a -> Sem r a
- Polysemy.Time.Prelude: embedToFinal :: forall (m :: Type -> Type) (r :: [(Type -> Type) -> Type -> Type]) a. (Member (Final m) r, Functor m) => Sem (Embed m : r) a -> Sem r a
- Polysemy.Time.Prelude: empty :: Alternative f => f a
- Polysemy.Time.Prelude: encodeFloat :: RealFloat a => Integer -> Int -> a
- Polysemy.Time.Prelude: encodeUtf8 :: ConvertUtf8 a b => a -> b
- Polysemy.Time.Prelude: enumFrom :: Enum a => a -> [a]
- Polysemy.Time.Prelude: enumFromThen :: Enum a => a -> a -> [a]
- Polysemy.Time.Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
- Polysemy.Time.Prelude: enumFromTo :: Enum a => a -> a -> [a]
- Polysemy.Time.Prelude: error :: forall (r :: RuntimeRep) (a :: TYPE r) t. (HasCallStack, IsText t) => t -> a
- Polysemy.Time.Prelude: etaReaderT :: forall r (m :: Type -> Type) a. ReaderT r m a -> ReaderT r m a
- Polysemy.Time.Prelude: evalState :: forall s (r :: [(Type -> Type) -> Type -> Type]) a. s -> Sem ((State s :: (Type -> Type) -> Type -> Type) : r) a -> Sem r a
- Polysemy.Time.Prelude: evalStateT :: Monad m => StateT s m a -> s -> m a
- Polysemy.Time.Prelude: evaluateNF :: (NFData a, MonadIO m) => a -> m a
- Polysemy.Time.Prelude: evaluateNF_ :: (NFData a, MonadIO m) => a -> m ()
- Polysemy.Time.Prelude: evaluateWHNF :: MonadIO m => a -> m a
- Polysemy.Time.Prelude: evaluateWHNF_ :: MonadIO m => a -> m ()
- Polysemy.Time.Prelude: evaluatingState :: s -> State s a -> a
- Polysemy.Time.Prelude: evaluatingStateT :: Functor f => s -> StateT s f a -> f a
- Polysemy.Time.Prelude: even :: Integral a => a -> Bool
- Polysemy.Time.Prelude: exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a
- Polysemy.Time.Prelude: execState :: State s a -> s -> s
- Polysemy.Time.Prelude: execStateT :: Monad m => StateT s m a -> s -> m s
- Polysemy.Time.Prelude: executingState :: s -> State s a -> s
- Polysemy.Time.Prelude: executingStateT :: Functor f => s -> StateT s f a -> f s
- Polysemy.Time.Prelude: exitFailure :: MonadIO m => m a
- Polysemy.Time.Prelude: exitSuccess :: MonadIO m => m a
- Polysemy.Time.Prelude: exitWith :: MonadIO m => ExitCode -> m a
- Polysemy.Time.Prelude: exp :: Floating a => a -> a
- Polysemy.Time.Prelude: fail :: MonadFail m => String -> m a
- Polysemy.Time.Prelude: filter :: (a -> Bool) -> [a] -> [a]
- Polysemy.Time.Prelude: find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- Polysemy.Time.Prelude: first :: Bifunctor p => (a -> b) -> p a c -> p b c
- Polysemy.Time.Prelude: fix :: (a -> a) -> a
- Polysemy.Time.Prelude: flap :: Functor f => f (a -> b) -> a -> f b
- Polysemy.Time.Prelude: flip :: (a -> b -> c) -> b -> a -> c
- Polysemy.Time.Prelude: flipfoldl' :: Foldable f => (a -> b -> b) -> b -> f a -> b
- Polysemy.Time.Prelude: floatDigits :: RealFloat a => a -> Int
- Polysemy.Time.Prelude: floatRadix :: RealFloat a => a -> Integer
- Polysemy.Time.Prelude: floatRange :: RealFloat a => a -> (Int, Int)
- Polysemy.Time.Prelude: floor :: (RealFrac a, Integral b) => a -> b
- Polysemy.Time.Prelude: fmap :: Functor f => (a -> b) -> f a -> f b
- Polysemy.Time.Prelude: fold :: (Foldable t, Monoid m) => t m -> m
- Polysemy.Time.Prelude: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
- Polysemy.Time.Prelude: foldMap' :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
- Polysemy.Time.Prelude: foldMapA :: (Semigroup b, Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b
- Polysemy.Time.Prelude: foldMapM :: (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b
- Polysemy.Time.Prelude: foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
- Polysemy.Time.Prelude: foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
- Polysemy.Time.Prelude: foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- Polysemy.Time.Prelude: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
- Polysemy.Time.Prelude: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- Polysemy.Time.Prelude: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- Polysemy.Time.Prelude: for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
- Polysemy.Time.Prelude: force :: NFData a => a -> a
- Polysemy.Time.Prelude: forever :: Applicative f => f a -> f b
- Polysemy.Time.Prelude: fromEither :: forall e (r :: [(Type -> Type) -> Type -> Type]) a. Member (Error e :: (Type -> Type) -> Type -> Type) r => Either e a -> Sem r a
- Polysemy.Time.Prelude: fromEnum :: Enum a => a -> Int
- Polysemy.Time.Prelude: fromException :: Exception e => SomeException -> Maybe e
- Polysemy.Time.Prelude: fromInteger :: Num a => Integer -> a
- Polysemy.Time.Prelude: fromIntegral :: (Integral a, Num b) => a -> b
- Polysemy.Time.Prelude: fromLabel :: IsLabel x a => a
- Polysemy.Time.Prelude: fromLazy :: LazyStrict l s => l -> s
- Polysemy.Time.Prelude: fromLeft :: a -> Either a b -> a
- Polysemy.Time.Prelude: fromList :: IsList l => [Item l] -> l
- Polysemy.Time.Prelude: fromListN :: IsList l => Int -> [Item l] -> l
- Polysemy.Time.Prelude: fromMaybe :: a -> Maybe a -> a
- Polysemy.Time.Prelude: fromRational :: Fractional a => Rational -> a
- Polysemy.Time.Prelude: fromRight :: b -> Either a b -> b
- Polysemy.Time.Prelude: fromShort :: ShortByteString -> ByteString
- Polysemy.Time.Prelude: fromStrict :: LazyStrict l s => s -> l
- Polysemy.Time.Prelude: fromString :: IsString a => String -> a
- Polysemy.Time.Prelude: fst :: (a, b) -> a
- Polysemy.Time.Prelude: gcd :: Integral a => a -> a -> a
- Polysemy.Time.Prelude: genericDrop :: Integral i => i -> [a] -> [a]
- Polysemy.Time.Prelude: genericLength :: Num i => [a] -> i
- Polysemy.Time.Prelude: genericReplicate :: Integral i => i -> a -> [a]
- Polysemy.Time.Prelude: genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
- Polysemy.Time.Prelude: genericTake :: Integral i => i -> [a] -> [a]
- Polysemy.Time.Prelude: get :: forall s (r :: [Effect]). MemberWithError (State s :: (Type -> Type) -> Type -> Type) r => Sem r s
- Polysemy.Time.Prelude: getArgs :: MonadIO m => m [String]
- Polysemy.Time.Prelude: getCallStack :: CallStack -> [([Char], SrcLoc)]
- Polysemy.Time.Prelude: getLine :: MonadIO m => m Text
- Polysemy.Time.Prelude: getStackTrace :: IO (Maybe [Location])
- Polysemy.Time.Prelude: getSum :: Sum a -> a
- Polysemy.Time.Prelude: gets :: forall s a (r :: [(Type -> Type) -> Type -> Type]). Member (State s :: (Type -> Type) -> Type -> Type) r => (s -> a) -> Sem r a
- Polysemy.Time.Prelude: group :: Eq a => [a] -> [[a]]
- Polysemy.Time.Prelude: guard :: Alternative f => Bool -> f ()
- Polysemy.Time.Prelude: guardM :: MonadPlus m => m Bool -> m ()
- Polysemy.Time.Prelude: guarded :: Alternative f => (a -> Bool) -> a -> f a
- Polysemy.Time.Prelude: hFlush :: MonadIO m => Handle -> m ()
- Polysemy.Time.Prelude: hGetBuffering :: MonadIO m => Handle -> m BufferMode
- Polysemy.Time.Prelude: hIsEOF :: MonadIO m => Handle -> m Bool
- Polysemy.Time.Prelude: hSetBuffering :: MonadIO m => Handle -> BufferMode -> m ()
- Polysemy.Time.Prelude: hashNub :: (Eq a, Hashable a) => [a] -> [a]
- Polysemy.Time.Prelude: hashWithSalt :: Hashable a => Int -> a -> Int
- Polysemy.Time.Prelude: head :: IsNonEmpty f a a "head" => f a -> a
- Polysemy.Time.Prelude: hoistEither :: Member (Error e2) r => (e1 -> e2) -> Either e1 a -> Sem r a
- Polysemy.Time.Prelude: hoistEitherShow :: Show e1 => Member (Error e2) r => (Text -> e2) -> Either e1 a -> Sem r a
- Polysemy.Time.Prelude: hoistEitherWith :: (e -> Sem r a) -> Either e a -> Sem r a
- Polysemy.Time.Prelude: hoistErrorWith :: (e -> Sem r a) -> Sem (Error e : r) a -> Sem r a
- Polysemy.Time.Prelude: hoistMaybe :: forall (m :: Type -> Type) a. Applicative m => Maybe a -> MaybeT m a
- Polysemy.Time.Prelude: id :: a -> a
- Polysemy.Time.Prelude: identity :: a -> a
- Polysemy.Time.Prelude: ifM :: Monad m => m Bool -> m a -> m a -> m a
- Polysemy.Time.Prelude: infinitely :: Applicative f => f a -> f Void
- Polysemy.Time.Prelude: infix 4 >=
- Polysemy.Time.Prelude: infixl 0 `on`
- Polysemy.Time.Prelude: infixl 1 <&>
- Polysemy.Time.Prelude: infixl 3 <|>
- Polysemy.Time.Prelude: infixl 4 <**>
- Polysemy.Time.Prelude: infixl 6 `xor`
- Polysemy.Time.Prelude: infixl 7 *
- Polysemy.Time.Prelude: infixr 0 $!!
- Polysemy.Time.Prelude: infixr 1 =<<
- Polysemy.Time.Prelude: infixr 2 ||
- Polysemy.Time.Prelude: infixr 3 &&
- Polysemy.Time.Prelude: infixr 5 :|
- Polysemy.Time.Prelude: infixr 6 <>
- Polysemy.Time.Prelude: infixr 8 ^
- Polysemy.Time.Prelude: infixr 9 `Compose`
- Polysemy.Time.Prelude: init :: IsNonEmpty f a [a] "init" => f a -> [a]
- Polysemy.Time.Prelude: inits :: [a] -> [[a]]
- Polysemy.Time.Prelude: intNub :: [Int] -> [Int]
- Polysemy.Time.Prelude: intNubOn :: (a -> Int) -> [a] -> [a]
- Polysemy.Time.Prelude: integerToBounded :: (Integral a, Bounded a) => Integer -> Maybe a
- Polysemy.Time.Prelude: integerToNatural :: Integer -> Maybe Natural
- Polysemy.Time.Prelude: intercalate :: [a] -> [[a]] -> [a]
- Polysemy.Time.Prelude: interpret :: forall e (r :: [Effect]) a. FirstOrder e "interpret" => (forall (rInitial :: EffectRow) x. () => e (Sem rInitial) x -> Sem r x) -> Sem (e : r) a -> Sem r a
- Polysemy.Time.Prelude: intersperse :: a -> [a] -> [a]
- Polysemy.Time.Prelude: inverseMap :: (Bounded a, Enum a, Ord k) => (a -> k) -> k -> Maybe a
- Polysemy.Time.Prelude: isDenormalized :: RealFloat a => a -> Bool
- Polysemy.Time.Prelude: isEmptyTMVar :: TMVar a -> STM Bool
- Polysemy.Time.Prelude: isIEEE :: RealFloat a => a -> Bool
- Polysemy.Time.Prelude: isInfinite :: RealFloat a => a -> Bool
- Polysemy.Time.Prelude: isJust :: Maybe a -> Bool
- Polysemy.Time.Prelude: isLeft :: Either a b -> Bool
- Polysemy.Time.Prelude: isNaN :: RealFloat a => a -> Bool
- Polysemy.Time.Prelude: isNegativeZero :: RealFloat a => a -> Bool
- Polysemy.Time.Prelude: isNothing :: Maybe a -> Bool
- Polysemy.Time.Prelude: isPrefixOf :: Eq a => [a] -> [a] -> Bool
- Polysemy.Time.Prelude: isRight :: Either a b -> Bool
- Polysemy.Time.Prelude: iterate :: (a -> a) -> a -> [a]
- Polysemy.Time.Prelude: join :: Monad m => m (m a) -> m a
- Polysemy.Time.Prelude: jsonDecode :: FromJSON a => ByteString -> Either Text a
- Polysemy.Time.Prelude: jsonDecodeL :: FromJSON a => LByteString -> Either Text a
- Polysemy.Time.Prelude: jsonDecodeText :: FromJSON a => Text -> Either Text a
- Polysemy.Time.Prelude: jsonEncode :: ToJSON a => a -> ByteString
- Polysemy.Time.Prelude: jsonEncodeText :: ToJSON a => a -> Text
- Polysemy.Time.Prelude: jsonOptions :: Options
- Polysemy.Time.Prelude: last :: IsNonEmpty f a a "last" => f a -> a
- Polysemy.Time.Prelude: lcm :: Integral a => a -> a -> a
- Polysemy.Time.Prelude: leftToMaybe :: Either l r -> Maybe l
- Polysemy.Time.Prelude: lefts :: [Either a b] -> [a]
- Polysemy.Time.Prelude: length :: Foldable t => t a -> Int
- Polysemy.Time.Prelude: lenientDecode :: OnDecodeError
- Polysemy.Time.Prelude: lift :: (MonadTrans t, Monad m) => m a -> t m a
- Polysemy.Time.Prelude: liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
- Polysemy.Time.Prelude: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- Polysemy.Time.Prelude: liftIO :: MonadIO m => IO a -> m a
- Polysemy.Time.Prelude: liftT :: forall m f r e a. Functor f => Sem r a -> Sem (WithTactics e f m r) (f a)
- Polysemy.Time.Prelude: lines :: IsText t "lines" => t -> [t]
- Polysemy.Time.Prelude: listToMaybe :: [a] -> Maybe a
- Polysemy.Time.Prelude: local :: MonadReader r m => (r -> r) -> m a -> m a
- Polysemy.Time.Prelude: logBase :: Floating a => a -> a -> a
- Polysemy.Time.Prelude: lookup :: Ord k => k -> Map k a -> Maybe a
- Polysemy.Time.Prelude: lookupEnv :: MonadIO m => String -> m (Maybe String)
- Polysemy.Time.Prelude: makeSem :: Name -> Q [Dec]
- Polysemy.Time.Prelude: many :: Alternative f => f a -> f [a]
- Polysemy.Time.Prelude: map :: (a -> b) -> [a] -> [b]
- Polysemy.Time.Prelude: mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- Polysemy.Time.Prelude: mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- Polysemy.Time.Prelude: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- Polysemy.Time.Prelude: mapBy :: Ord k => (a -> k) -> [a] -> Map k a
- Polysemy.Time.Prelude: mapError :: forall e1 e2 (r :: [(Type -> Type) -> Type -> Type]) a. Member (Error e2 :: (Type -> Type) -> Type -> Type) r => (e1 -> e2) -> Sem ((Error e1 :: (Type -> Type) -> Type -> Type) : r) a -> Sem r a
- Polysemy.Time.Prelude: mapLeft :: (a -> c) -> Either a b -> Either c b
- Polysemy.Time.Prelude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- Polysemy.Time.Prelude: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- Polysemy.Time.Prelude: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- Polysemy.Time.Prelude: mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b]
- Polysemy.Time.Prelude: mappend :: Monoid a => a -> a -> a
- Polysemy.Time.Prelude: max :: Ord a => a -> a -> a
- Polysemy.Time.Prelude: maxBound :: Bounded a => a
- Polysemy.Time.Prelude: maxInt :: Int
- Polysemy.Time.Prelude: maybe :: b -> (a -> b) -> Maybe a -> b
- Polysemy.Time.Prelude: maybeAt :: Int -> [a] -> Maybe a
- Polysemy.Time.Prelude: maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a
- Polysemy.Time.Prelude: maybeToLeft :: r -> Maybe l -> Either l r
- Polysemy.Time.Prelude: maybeToList :: Maybe a -> [a]
- Polysemy.Time.Prelude: maybeToMonoid :: Monoid m => Maybe m -> m
- Polysemy.Time.Prelude: maybeToRight :: l -> Maybe r -> Either l r
- Polysemy.Time.Prelude: mconcat :: Monoid a => [a] -> a
- Polysemy.Time.Prelude: mempty :: Monoid a => a
- Polysemy.Time.Prelude: memptyIfFalse :: Monoid m => Bool -> m -> m
- Polysemy.Time.Prelude: memptyIfTrue :: Monoid m => Bool -> m -> m
- Polysemy.Time.Prelude: mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- Polysemy.Time.Prelude: min :: Ord a => a -> a -> a
- Polysemy.Time.Prelude: minBound :: Bounded a => a
- Polysemy.Time.Prelude: minInt :: Int
- Polysemy.Time.Prelude: mkWeakTMVar :: TMVar a -> IO () -> IO (Weak (TMVar a))
- Polysemy.Time.Prelude: mneToList :: Maybe (NonEmpty a) -> [a]
- Polysemy.Time.Prelude: mod :: Integral a => a -> a -> a
- Polysemy.Time.Prelude: modify :: forall s (r :: [(Type -> Type) -> Type -> Type]). Member (State s :: (Type -> Type) -> Type -> Type) r => (s -> s) -> Sem r ()
- Polysemy.Time.Prelude: modify' :: forall s (r :: [(Type -> Type) -> Type -> Type]). Member (State s :: (Type -> Type) -> Type -> Type) r => (s -> s) -> Sem r ()
- Polysemy.Time.Prelude: modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m ()
- Polysemy.Time.Prelude: modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m ()
- Polysemy.Time.Prelude: modifyTVar' :: TVar a -> (a -> a) -> STM ()
- Polysemy.Time.Prelude: mplus :: MonadPlus m => m a -> m a -> m a
- Polysemy.Time.Prelude: mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
- Polysemy.Time.Prelude: mzero :: MonadPlus m => m a
- Polysemy.Time.Prelude: natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Natural
- Polysemy.Time.Prelude: negate :: Num a => a -> a
- Polysemy.Time.Prelude: newEmptyMVar :: MonadIO m => m (MVar a)
- Polysemy.Time.Prelude: newEmptyTMVar :: STM (TMVar a)
- Polysemy.Time.Prelude: newEmptyTMVarIO :: MonadIO m => m (TMVar a)
- Polysemy.Time.Prelude: newIORef :: MonadIO m => a -> m (IORef a)
- Polysemy.Time.Prelude: newMVar :: MonadIO m => a -> m (MVar a)
- Polysemy.Time.Prelude: newTMVar :: a -> STM (TMVar a)
- Polysemy.Time.Prelude: newTMVarIO :: MonadIO m => a -> m (TMVar a)
- Polysemy.Time.Prelude: newTVar :: a -> STM (TVar a)
- Polysemy.Time.Prelude: newTVarIO :: MonadIO m => a -> m (TVar a)
- Polysemy.Time.Prelude: newtype All
- Polysemy.Time.Prelude: newtype Alt (f :: k -> Type) (a :: k)
- Polysemy.Time.Prelude: newtype Any
- Polysemy.Time.Prelude: newtype Ap (f :: k -> Type) (a :: k)
- Polysemy.Time.Prelude: newtype Comparison a
- Polysemy.Time.Prelude: newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
- Polysemy.Time.Prelude: newtype Const a (b :: k)
- Polysemy.Time.Prelude: newtype Down a
- Polysemy.Time.Prelude: newtype Dual a
- Polysemy.Time.Prelude: newtype Endo a
- Polysemy.Time.Prelude: newtype Equivalence a
- Polysemy.Time.Prelude: newtype ExceptT e (m :: Type -> Type) a
- Polysemy.Time.Prelude: newtype First a
- Polysemy.Time.Prelude: newtype Identity a
- Polysemy.Time.Prelude: newtype Last a
- Polysemy.Time.Prelude: newtype MaybeT (m :: Type -> Type) a
- Polysemy.Time.Prelude: newtype Op a b
- Polysemy.Time.Prelude: newtype Option a
- Polysemy.Time.Prelude: newtype Predicate a
- Polysemy.Time.Prelude: newtype Product a
- Polysemy.Time.Prelude: newtype ReaderT r (m :: Type -> Type) a
- Polysemy.Time.Prelude: newtype StateT s (m :: Type -> Type) a
- Polysemy.Time.Prelude: newtype ZipList a
- Polysemy.Time.Prelude: nonEmpty :: [a] -> Maybe (NonEmpty a)
- Polysemy.Time.Prelude: not :: Bool -> Bool
- Polysemy.Time.Prelude: notElem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
- Polysemy.Time.Prelude: note :: forall e (r :: [(Type -> Type) -> Type -> Type]) a. Member (Error e :: (Type -> Type) -> Type -> Type) r => e -> Maybe a -> Sem r a
- Polysemy.Time.Prelude: null :: Foldable t => t a -> Bool
- Polysemy.Time.Prelude: numerator :: Ratio a -> a
- Polysemy.Time.Prelude: odd :: Integral a => a -> Bool
- Polysemy.Time.Prelude: on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- Polysemy.Time.Prelude: one :: One x => OneItem x -> x
- Polysemy.Time.Prelude: optional :: Alternative f => f a -> f (Maybe a)
- Polysemy.Time.Prelude: or :: Foldable t => t Bool -> Bool
- Polysemy.Time.Prelude: orM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
- Polysemy.Time.Prelude: ord :: Char -> Int
- Polysemy.Time.Prelude: ordNub :: Ord a => [a] -> [a]
- Polysemy.Time.Prelude: ordNubOn :: Ord b => (a -> b) -> [a] -> [a]
- Polysemy.Time.Prelude: otherwise :: Bool
- Polysemy.Time.Prelude: parseJSON :: FromJSON a => Value -> Parser a
- Polysemy.Time.Prelude: partitionEithers :: [Either a b] -> ([a], [b])
- Polysemy.Time.Prelude: partitionWith :: (a -> Either b c) -> [a] -> ([b], [c])
- Polysemy.Time.Prelude: pass :: Applicative f => f ()
- Polysemy.Time.Prelude: pattern Exc :: Exception e => e -> SomeException
- Polysemy.Time.Prelude: permutations :: [a] -> [[a]]
- Polysemy.Time.Prelude: phantom :: (Functor f, Contravariant f) => f a -> f b
- Polysemy.Time.Prelude: pi :: Floating a => a
- Polysemy.Time.Prelude: pred :: Enum a => a -> a
- Polysemy.Time.Prelude: prettyCallStack :: CallStack -> String
- Polysemy.Time.Prelude: prettySrcLoc :: SrcLoc -> String
- Polysemy.Time.Prelude: print :: forall a m. (MonadIO m, Show a) => a -> m ()
- Polysemy.Time.Prelude: product :: forall a f. (Foldable f, Num a) => f a -> a
- Polysemy.Time.Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
- Polysemy.Time.Prelude: pure :: Applicative f => a -> f a
- Polysemy.Time.Prelude: pureT :: forall f a (e :: Effect) (m :: Type -> Type) (r :: [Effect]). Functor f => a -> Sem (WithTactics e f m r) (f a)
- Polysemy.Time.Prelude: put :: forall s (r :: [Effect]). MemberWithError (State s :: (Type -> Type) -> Type -> Type) r => s -> Sem r ()
- Polysemy.Time.Prelude: putBS :: MonadIO m => ByteString -> m ()
- Polysemy.Time.Prelude: putBSLn :: MonadIO m => ByteString -> m ()
- Polysemy.Time.Prelude: putLBS :: MonadIO m => LByteString -> m ()
- Polysemy.Time.Prelude: putLBSLn :: MonadIO m => LByteString -> m ()
- Polysemy.Time.Prelude: putLText :: MonadIO m => LText -> m ()
- Polysemy.Time.Prelude: putLTextLn :: MonadIO m => LText -> m ()
- Polysemy.Time.Prelude: putMVar :: MonadIO m => MVar a -> a -> m ()
- Polysemy.Time.Prelude: putStr :: MonadIO m => String -> m ()
- Polysemy.Time.Prelude: putStrLn :: MonadIO m => String -> m ()
- Polysemy.Time.Prelude: putTMVar :: TMVar a -> a -> STM ()
- Polysemy.Time.Prelude: putText :: MonadIO m => Text -> m ()
- Polysemy.Time.Prelude: putTextLn :: MonadIO m => Text -> m ()
- Polysemy.Time.Prelude: quot :: Integral a => a -> a -> a
- Polysemy.Time.Prelude: quotRem :: Integral a => a -> a -> (a, a)
- Polysemy.Time.Prelude: raise :: forall (e :: Effect) (r :: EffectRow) a. Sem r a -> Sem (e : r) a
- Polysemy.Time.Prelude: raiseUnder :: forall (e2 :: Effect) (e1 :: Effect) (r :: [Effect]) a. Sem (e1 : r) a -> Sem (e1 : (e2 : r)) a
- Polysemy.Time.Prelude: raiseUnder2 :: forall (e2 :: Effect) (e3 :: Effect) (e1 :: Effect) (r :: [Effect]) a. Sem (e1 : r) a -> Sem (e1 : (e2 : (e3 : r))) a
- Polysemy.Time.Prelude: raiseUnder3 :: forall (e2 :: Effect) (e3 :: Effect) (e4 :: Effect) (e1 :: Effect) (r :: [Effect]) a. Sem (e1 : r) a -> Sem (e1 : (e2 : (e3 : (e4 : r)))) a
- Polysemy.Time.Prelude: readEither :: Read a => String -> Either Text a
- Polysemy.Time.Prelude: readFileBS :: MonadIO m => FilePath -> m ByteString
- Polysemy.Time.Prelude: readFileLBS :: MonadIO m => FilePath -> m LByteString
- Polysemy.Time.Prelude: readFileLText :: MonadIO m => FilePath -> m LText
- Polysemy.Time.Prelude: readFileText :: MonadIO m => FilePath -> m Text
- Polysemy.Time.Prelude: readIORef :: MonadIO m => IORef a -> m a
- Polysemy.Time.Prelude: readMVar :: MonadIO m => MVar a -> m a
- Polysemy.Time.Prelude: readMaybe :: Read a => String -> Maybe a
- Polysemy.Time.Prelude: readTMVar :: TMVar a -> STM a
- Polysemy.Time.Prelude: readTVar :: TVar a -> STM a
- Polysemy.Time.Prelude: readTVarIO :: MonadIO m => TVar a -> m a
- Polysemy.Time.Prelude: reader :: MonadReader r m => (r -> a) -> m a
- Polysemy.Time.Prelude: reads :: Read a => ReadS a
- Polysemy.Time.Prelude: realToFrac :: (Real a, Fractional b) => a -> b
- Polysemy.Time.Prelude: recip :: Fractional a => a -> a
- Polysemy.Time.Prelude: reinterpret :: forall e1 (e2 :: Effect) (r :: [Effect]) a. FirstOrder e1 "reinterpret" => (forall (rInitial :: EffectRow) x. () => e1 (Sem rInitial) x -> Sem (e2 : r) x) -> Sem (e1 : r) a -> Sem (e2 : r) a
- Polysemy.Time.Prelude: rem :: Integral a => a -> a -> a
- Polysemy.Time.Prelude: repeat :: a -> [a]
- Polysemy.Time.Prelude: replicate :: Int -> a -> [a]
- Polysemy.Time.Prelude: replicateM :: Applicative m => Int -> m a -> m [a]
- Polysemy.Time.Prelude: replicateM_ :: Applicative m => Int -> m a -> m ()
- Polysemy.Time.Prelude: return :: Monad m => a -> m a
- Polysemy.Time.Prelude: reverse :: [a] -> [a]
- Polysemy.Time.Prelude: rightOr :: (a -> b) -> Either a b -> b
- Polysemy.Time.Prelude: rightToMaybe :: Either l r -> Maybe r
- Polysemy.Time.Prelude: rights :: [Either a b] -> [b]
- Polysemy.Time.Prelude: rnf :: NFData a => a -> ()
- Polysemy.Time.Prelude: round :: (RealFrac a, Integral b) => a -> b
- Polysemy.Time.Prelude: runAtomicStateTVar :: forall (r :: [(Type -> Type) -> Type -> Type]) s a. Member (Embed IO) r => TVar s -> Sem ((AtomicState s :: (Type -> Type) -> Type -> Type) : r) a -> Sem r a
- Polysemy.Time.Prelude: runError :: forall e (r :: [(Type -> Type) -> Type -> Type]) a. Sem ((Error e :: (Type -> Type) -> Type -> Type) : r) a -> Sem r (Either e a)
- Polysemy.Time.Prelude: runExceptT :: ExceptT e m a -> m (Either e a)
- Polysemy.Time.Prelude: runFinal :: Monad m => Sem '[Final m] a -> m a
- Polysemy.Time.Prelude: runState :: forall s (r :: [(Type -> Type) -> Type -> Type]) a. s -> Sem ((State s :: (Type -> Type) -> Type -> Type) : r) a -> Sem r (s, a)
- Polysemy.Time.Prelude: safeDiv :: Real a => Integral a => a -> a -> Maybe a
- Polysemy.Time.Prelude: scanl :: (b -> a -> b) -> b -> [a] -> [b]
- Polysemy.Time.Prelude: scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- Polysemy.Time.Prelude: scanl1 :: (a -> a -> a) -> [a] -> [a]
- Polysemy.Time.Prelude: scanr :: (a -> b -> b) -> b -> [a] -> [b]
- Polysemy.Time.Prelude: scanr1 :: (a -> a -> a) -> [a] -> [a]
- Polysemy.Time.Prelude: sconcat :: Semigroup a => NonEmpty a -> a
- Polysemy.Time.Prelude: second :: Bifunctor p => (b -> c) -> p a b -> p a c
- Polysemy.Time.Prelude: seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
- Polysemy.Time.Prelude: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- Polysemy.Time.Prelude: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
- Polysemy.Time.Prelude: sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
- Polysemy.Time.Prelude: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- Polysemy.Time.Prelude: show :: forall b a. (Show a, IsString b) => a -> b
- Polysemy.Time.Prelude: showStackTrace :: IO (Maybe String)
- Polysemy.Time.Prelude: signum :: Num a => a -> a
- Polysemy.Time.Prelude: sin :: Floating a => a -> a
- Polysemy.Time.Prelude: sinh :: Floating a => a -> a
- Polysemy.Time.Prelude: snd :: (a, b) -> b
- Polysemy.Time.Prelude: some :: Alternative f => f a -> f [a]
- Polysemy.Time.Prelude: someNatVal :: Natural -> SomeNat
- Polysemy.Time.Prelude: sort :: Ord a => [a] -> [a]
- Polysemy.Time.Prelude: sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- Polysemy.Time.Prelude: sortNub :: Ord a => [a] -> [a]
- Polysemy.Time.Prelude: sortOn :: Ord b => (a -> b) -> [a] -> [a]
- Polysemy.Time.Prelude: sortWith :: Ord b => (a -> b) -> [a] -> [a]
- Polysemy.Time.Prelude: span :: (a -> Bool) -> [a] -> ([a], [a])
- Polysemy.Time.Prelude: splitAt :: Int -> [a] -> ([a], [a])
- Polysemy.Time.Prelude: sqrt :: Floating a => a -> a
- Polysemy.Time.Prelude: stderr :: Handle
- Polysemy.Time.Prelude: stdin :: Handle
- Polysemy.Time.Prelude: stdout :: Handle
- Polysemy.Time.Prelude: stimes :: (Semigroup a, Integral b) => b -> a -> a
- Polysemy.Time.Prelude: stimesIdempotent :: Integral b => b -> a -> a
- Polysemy.Time.Prelude: stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
- Polysemy.Time.Prelude: stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
- Polysemy.Time.Prelude: strictDecode :: OnDecodeError
- Polysemy.Time.Prelude: subsequences :: [a] -> [[a]]
- Polysemy.Time.Prelude: subtract :: Num a => a -> a -> a
- Polysemy.Time.Prelude: succ :: Enum a => a -> a
- Polysemy.Time.Prelude: sum :: forall a f. (Foldable f, Num a) => f a -> a
- Polysemy.Time.Prelude: swap :: (a, b) -> (b, a)
- Polysemy.Time.Prelude: swapMVar :: MonadIO m => MVar a -> a -> m a
- Polysemy.Time.Prelude: swapTMVar :: TMVar a -> a -> STM a
- Polysemy.Time.Prelude: tail :: IsNonEmpty f a [a] "tail" => f a -> [a]
- Polysemy.Time.Prelude: tails :: [a] -> [[a]]
- Polysemy.Time.Prelude: take :: Int -> [a] -> [a]
- Polysemy.Time.Prelude: takeMVar :: MonadIO m => MVar a -> m a
- Polysemy.Time.Prelude: takeTMVar :: TMVar a -> STM a
- Polysemy.Time.Prelude: takeWhile :: (a -> Bool) -> [a] -> [a]
- Polysemy.Time.Prelude: tan :: Floating a => a -> a
- Polysemy.Time.Prelude: tanh :: Floating a => a -> a
- Polysemy.Time.Prelude: throw :: forall e (r :: [Effect]) a. MemberWithError (Error e :: (Type -> Type) -> Type -> Type) r => e -> Sem r a
- Polysemy.Time.Prelude: throwEitherIO :: Either Text a -> IO a
- Polysemy.Time.Prelude: throwSTM :: Exception e => e -> STM a
- Polysemy.Time.Prelude: throwTextIO :: Text -> IO a
- Polysemy.Time.Prelude: toEnum :: Enum a => Int -> a
- Polysemy.Time.Prelude: toException :: Exception e => e -> SomeException
- Polysemy.Time.Prelude: toInteger :: Integral a => a -> Integer
- Polysemy.Time.Prelude: toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
- Polysemy.Time.Prelude: toJSON :: ToJSON a => a -> Value
- Polysemy.Time.Prelude: toLText :: ToLText a => a -> LText
- Polysemy.Time.Prelude: toLazy :: LazyStrict l s => s -> l
- Polysemy.Time.Prelude: toList :: Foldable t => t a -> [a]
- Polysemy.Time.Prelude: toRational :: Real a => a -> Rational
- Polysemy.Time.Prelude: toShort :: ByteString -> ShortByteString
- Polysemy.Time.Prelude: toStrict :: LazyStrict l s => l -> s
- Polysemy.Time.Prelude: toString :: ToString a => a -> String
- Polysemy.Time.Prelude: toText :: ToText a => a -> Text
- Polysemy.Time.Prelude: traceId :: String -> String
- Polysemy.Time.Prelude: traceM :: Applicative f => String -> f ()
- Polysemy.Time.Prelude: traceShowId :: Show a => a -> a
- Polysemy.Time.Prelude: traceShowM :: (Show a, Applicative f) => a -> f ()
- Polysemy.Time.Prelude: traceShowWith :: Show b => (a -> b) -> a -> a
- Polysemy.Time.Prelude: transpose :: [[a]] -> [[a]]
- Polysemy.Time.Prelude: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
- Polysemy.Time.Prelude: traverseLeft :: Applicative m => (a -> m b) -> Either a b -> m b
- Polysemy.Time.Prelude: traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
- Polysemy.Time.Prelude: truncate :: (RealFrac a, Integral b) => a -> b
- Polysemy.Time.Prelude: tryAny :: Member (Embed IO) r => IO a -> Sem r (Either Text a)
- Polysemy.Time.Prelude: tryHoist :: Member (Embed IO) r => (Text -> e) -> IO a -> Sem r (Either e a)
- Polysemy.Time.Prelude: tryPutMVar :: MonadIO m => MVar a -> a -> m Bool
- Polysemy.Time.Prelude: tryPutTMVar :: TMVar a -> a -> STM Bool
- Polysemy.Time.Prelude: tryReadMVar :: MonadIO m => MVar a -> m (Maybe a)
- Polysemy.Time.Prelude: tryReadTMVar :: TMVar a -> STM (Maybe a)
- Polysemy.Time.Prelude: tryTakeMVar :: MonadIO m => MVar a -> m (Maybe a)
- Polysemy.Time.Prelude: tryTakeTMVar :: TMVar a -> STM (Maybe a)
- Polysemy.Time.Prelude: tryThrow :: Members [Embed IO, Error e] r => (Text -> e) -> IO a -> Sem r a
- Polysemy.Time.Prelude: tuple :: Applicative f => f a -> f b -> f (a, b)
- Polysemy.Time.Prelude: type Basic a = (Eq a, Show a)
- Polysemy.Time.Prelude: type Effect = Type -> Type -> Type -> Type
- Polysemy.Time.Prelude: type EffectRow = [Effect]
- Polysemy.Time.Prelude: type Eso a = (Basic a, Ord a)
- Polysemy.Time.Prelude: type FilePath = String
- Polysemy.Time.Prelude: type HasCallStack = ?callStack :: CallStack
- Polysemy.Time.Prelude: type Json a = (FromJSON a, ToJSON a, Basic a)
- Polysemy.Time.Prelude: type LByteString = ByteString
- Polysemy.Time.Prelude: type LText = Text
- Polysemy.Time.Prelude: type Member (e :: k) (r :: [k]) = MemberNoError e r
- Polysemy.Time.Prelude: type OnDecodeError = OnError Word8 Char
- Polysemy.Time.Prelude: type OnError a b = String -> Maybe a -> Maybe b
- Polysemy.Time.Prelude: type Rational = Ratio Integer
- Polysemy.Time.Prelude: type InterpreterFor (e :: Effect) (r :: [Effect]) = forall a. () => Sem e : r a -> Sem r a
- Polysemy.Time.Prelude: type String = [Char]
- Polysemy.Time.Prelude: type Type = Type
- Polysemy.Time.Prelude: type WithTactics (e :: Effect) (f :: Type -> Type) (m :: Type -> Type) (r :: [Effect]) = Tactics f m e : r :: Type -> Type -> Type -> Type : r
- Polysemy.Time.Prelude: type family OneItem x
- Polysemy.Time.Prelude: unaryRecordJson :: Name -> Q [Dec]
- Polysemy.Time.Prelude: uncons :: [a] -> Maybe (a, [a])
- Polysemy.Time.Prelude: uncurry :: (a -> b -> c) -> (a, b) -> c
- Polysemy.Time.Prelude: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- Polysemy.Time.Prelude: unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- Polysemy.Time.Prelude: unit :: Applicative f => f ()
- Polysemy.Time.Prelude: universe :: (Bounded a, Enum a) => [a]
- Polysemy.Time.Prelude: universeNonEmpty :: (Bounded a, Enum a) => NonEmpty a
- Polysemy.Time.Prelude: unless :: Applicative f => Bool -> f () -> f ()
- Polysemy.Time.Prelude: unlessM :: Monad m => m Bool -> m () -> m ()
- Polysemy.Time.Prelude: unlines :: IsText t "unlines" => [t] -> t
- Polysemy.Time.Prelude: unstableNub :: (Eq a, Hashable a) => [a] -> [a]
- Polysemy.Time.Prelude: unwords :: IsText t "unwords" => [t] -> t
- Polysemy.Time.Prelude: unzip :: [(a, b)] -> ([a], [b])
- Polysemy.Time.Prelude: unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- Polysemy.Time.Prelude: usingReader :: r -> Reader r a -> a
- Polysemy.Time.Prelude: usingReaderT :: r -> ReaderT r m a -> m a
- Polysemy.Time.Prelude: usingState :: s -> State s a -> (a, s)
- Polysemy.Time.Prelude: usingStateT :: s -> StateT s m a -> m (a, s)
- Polysemy.Time.Prelude: vacuous :: Functor f => f Void -> f a
- Polysemy.Time.Prelude: viaNonEmpty :: (NonEmpty a -> b) -> [a] -> Maybe b
- Polysemy.Time.Prelude: void :: Functor f => f a -> f ()
- Polysemy.Time.Prelude: when :: Applicative f => Bool -> f () -> f ()
- Polysemy.Time.Prelude: whenJust :: Applicative f => Maybe a -> (a -> f ()) -> f ()
- Polysemy.Time.Prelude: whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
- Polysemy.Time.Prelude: whenLeft :: Applicative f => a -> Either l r -> (l -> f a) -> f a
- Polysemy.Time.Prelude: whenLeftM :: Monad m => a -> m (Either l r) -> (l -> m a) -> m a
- Polysemy.Time.Prelude: whenLeftM_ :: Monad m => m (Either l r) -> (l -> m ()) -> m ()
- Polysemy.Time.Prelude: whenLeft_ :: Applicative f => Either l r -> (l -> f ()) -> f ()
- Polysemy.Time.Prelude: whenM :: Monad m => m Bool -> m () -> m ()
- Polysemy.Time.Prelude: whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f ()
- Polysemy.Time.Prelude: whenNotNullM :: Monad m => m [a] -> (NonEmpty a -> m ()) -> m ()
- Polysemy.Time.Prelude: whenNothing :: Applicative f => Maybe a -> f a -> f a
- Polysemy.Time.Prelude: whenNothingM :: Monad m => m (Maybe a) -> m a -> m a
- Polysemy.Time.Prelude: whenNothingM_ :: Monad m => m (Maybe a) -> m () -> m ()
- Polysemy.Time.Prelude: whenNothing_ :: Applicative f => Maybe a -> f () -> f ()
- Polysemy.Time.Prelude: whenRight :: Applicative f => a -> Either l r -> (r -> f a) -> f a
- Polysemy.Time.Prelude: whenRightM :: Monad m => a -> m (Either l r) -> (r -> m a) -> m a
- Polysemy.Time.Prelude: whenRightM_ :: Monad m => m (Either l r) -> (r -> m ()) -> m ()
- Polysemy.Time.Prelude: whenRight_ :: Applicative f => Either l r -> (r -> f ()) -> f ()
- Polysemy.Time.Prelude: withFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
- Polysemy.Time.Prelude: withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
- Polysemy.Time.Prelude: withReader :: (r' -> r) -> Reader r a -> Reader r' a
- Polysemy.Time.Prelude: withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a
- Polysemy.Time.Prelude: withState :: (s -> s) -> State s a -> State s a
- Polysemy.Time.Prelude: words :: IsText t "words" => t -> [t]
- Polysemy.Time.Prelude: writeFile :: MonadIO m => FilePath -> String -> m ()
- Polysemy.Time.Prelude: writeFileBS :: MonadIO m => FilePath -> ByteString -> m ()
- Polysemy.Time.Prelude: writeFileLBS :: MonadIO m => FilePath -> LByteString -> m ()
- Polysemy.Time.Prelude: writeFileLText :: MonadIO m => FilePath -> LText -> m ()
- Polysemy.Time.Prelude: writeFileText :: MonadIO m => FilePath -> Text -> m ()
- Polysemy.Time.Prelude: writeIORef :: MonadIO m => IORef a -> a -> m ()
- Polysemy.Time.Prelude: writeTVar :: TVar a -> a -> STM ()
- Polysemy.Time.Prelude: xor :: Bits a => a -> a -> a
- Polysemy.Time.Prelude: zip :: [a] -> [b] -> [(a, b)]
- Polysemy.Time.Prelude: zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- Polysemy.Time.Prelude: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- Polysemy.Time.Prelude: zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- Polysemy.Time.Prelude: zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- Polysemy.Time.Prelude: }
- Polysemy.Time: adjust :: forall t_axil d_axio r_axnl u1_Xxin u2_Xxip. (MemberWithError (Time t_axil d_axio) r_axnl, AddTimeUnit t_axil u1_Xxin u2_Xxip) => u1_Xxin -> Sem r_axnl ()
+ Polysemy.Time: adjust :: forall t_aw9d d_aw9g r_awed u1_Xw9f u2_Xw9h. (MemberWithError (Time t_aw9d d_aw9g) r_awed, AddTimeUnit t_aw9d u1_Xw9f u2_Xw9h) => u1_Xw9f -> Sem r_awed ()
- Polysemy.Time: now :: forall t_axi8 d_axi9 r_axnf. MemberWithError (Time t_axi8 d_axi9) r_axnf => Sem r_axnf t_axi8
+ Polysemy.Time: now :: forall t_aw90 d_aw91 r_awe7. MemberWithError (Time t_aw90 d_aw91) r_awe7 => Sem r_awe7 t_aw90
- Polysemy.Time: setDate :: forall t_axir d_axiq r_axnn. MemberWithError (Time t_axir d_axiq) r_axnn => d_axiq -> Sem r_axnn ()
+ Polysemy.Time: setDate :: forall t_aw9j d_aw9i r_awef. MemberWithError (Time t_aw9j d_aw9i) r_awef => d_aw9i -> Sem r_awef ()
- Polysemy.Time: setTime :: forall t_axii d_axij r_axnj. MemberWithError (Time t_axii d_axij) r_axnj => t_axii -> Sem r_axnj ()
+ Polysemy.Time: setTime :: forall t_aw9a d_aw9b r_aweb. MemberWithError (Time t_aw9a d_aw9b) r_aweb => t_aw9a -> Sem r_aweb ()
- Polysemy.Time: sleep :: forall t_axif d_axig r_axnh u_Xxif. (MemberWithError (Time t_axif d_axig) r_axnh, TimeUnit u_Xxif) => u_Xxif -> Sem r_axnh ()
+ Polysemy.Time: sleep :: forall t_aw97 d_aw98 r_awe9 u_Xw97. (MemberWithError (Time t_aw97 d_aw98) r_awe9, TimeUnit u_Xw97) => u_Xw97 -> Sem r_awe9 ()
- Polysemy.Time: today :: forall t_axib d_axic r_axng. MemberWithError (Time t_axib d_axic) r_axng => Sem r_axng d_axic
+ Polysemy.Time: today :: forall t_aw93 d_aw94 r_awe8. MemberWithError (Time t_aw93 d_aw94) r_awe8 => Sem r_awe8 d_aw94
- Polysemy.Time.Data.Time: adjust :: forall t_axil d_axio r_axnl u1_Xxin u2_Xxip. (MemberWithError (Time t_axil d_axio) r_axnl, AddTimeUnit t_axil u1_Xxin u2_Xxip) => u1_Xxin -> Sem r_axnl ()
+ Polysemy.Time.Data.Time: adjust :: forall t_aw9d d_aw9g r_awed u1_Xw9f u2_Xw9h. (MemberWithError (Time t_aw9d d_aw9g) r_awed, AddTimeUnit t_aw9d u1_Xw9f u2_Xw9h) => u1_Xw9f -> Sem r_awed ()
- Polysemy.Time.Data.Time: now :: forall t_axi8 d_axi9 r_axnf. MemberWithError (Time t_axi8 d_axi9) r_axnf => Sem r_axnf t_axi8
+ Polysemy.Time.Data.Time: now :: forall t_aw90 d_aw91 r_awe7. MemberWithError (Time t_aw90 d_aw91) r_awe7 => Sem r_awe7 t_aw90
- Polysemy.Time.Data.Time: setDate :: forall t_axir d_axiq r_axnn. MemberWithError (Time t_axir d_axiq) r_axnn => d_axiq -> Sem r_axnn ()
+ Polysemy.Time.Data.Time: setDate :: forall t_aw9j d_aw9i r_awef. MemberWithError (Time t_aw9j d_aw9i) r_awef => d_aw9i -> Sem r_awef ()
- Polysemy.Time.Data.Time: setTime :: forall t_axii d_axij r_axnj. MemberWithError (Time t_axii d_axij) r_axnj => t_axii -> Sem r_axnj ()
+ Polysemy.Time.Data.Time: setTime :: forall t_aw9a d_aw9b r_aweb. MemberWithError (Time t_aw9a d_aw9b) r_aweb => t_aw9a -> Sem r_aweb ()
- Polysemy.Time.Data.Time: sleep :: forall t_axif d_axig r_axnh u_Xxif. (MemberWithError (Time t_axif d_axig) r_axnh, TimeUnit u_Xxif) => u_Xxif -> Sem r_axnh ()
+ Polysemy.Time.Data.Time: sleep :: forall t_aw97 d_aw98 r_awe9 u_Xw97. (MemberWithError (Time t_aw97 d_aw98) r_awe9, TimeUnit u_Xw97) => u_Xw97 -> Sem r_awe9 ()
- Polysemy.Time.Data.Time: today :: forall t_axib d_axic r_axng. MemberWithError (Time t_axib d_axic) r_axng => Sem r_axng d_axic
+ Polysemy.Time.Data.Time: today :: forall t_aw93 d_aw94 r_awe8. MemberWithError (Time t_aw93 d_aw94) r_awe8 => Sem r_awe8 d_aw94
Files
- lib/Polysemy/Time/Prelude.hs +5/−220
- lib/Polysemy/Time/Sleep.hs +2/−0
- polysemy-time.cabal +5/−21
lib/Polysemy/Time/Prelude.hs view
@@ -1,43 +1,23 @@+{-# options_haddock hide #-} {-# LANGUAGE NoImplicitPrelude #-} module Polysemy.Time.Prelude ( module Polysemy.Time.Prelude,- module Data.Aeson,- module Data.Aeson.TH,- module Data.Composition,- module Data.Default,- module Data.Either.Combinators, module Data.Foldable, module Data.Kind,- module Data.List.NonEmpty,- module Data.Map.Strict, module GHC.Err,- module GHC.TypeLits, module Polysemy, module Polysemy.AtomicState, module Polysemy.Time.Debug,- module Polysemy.Error,- module Polysemy.Reader,- module Polysemy.State, module Relude, ) where -import Control.Exception (throwIO, try) import qualified Data.Aeson as Aeson-import Data.Aeson (FromJSON (parseJSON), ToJSON (toJSON))-import Data.Aeson.TH (deriveFromJSON, deriveJSON)-import Data.Composition ((.:), (.:.), (.::))-import Data.Default (Default (def))-import Data.Either.Combinators (mapLeft)+import Data.Aeson.TH (deriveJSON) import Data.Fixed (div')-import Data.Foldable (foldl, traverse_)+import Data.Foldable (traverse_) import Data.Kind (Type)-import Data.List.NonEmpty ((<|))-import qualified Data.Map.Strict as Map-import Data.Map.Strict (Map, lookup)-import qualified Data.Text as Text import GHC.Err (undefined)-import GHC.TypeLits (Symbol) import qualified Language.Haskell.TH.Syntax as TH import Polysemy ( Effect,@@ -62,9 +42,6 @@ runFinal, ) import Polysemy.AtomicState (AtomicState, atomicGet, atomicGets, atomicModify', atomicPut, runAtomicStateTVar)-import Polysemy.Error (Error, fromEither, mapError, note, runError, throw)-import Polysemy.Reader (Reader)-import Polysemy.State (State, evalState, get, gets, modify, modify', put, runState) import Relude hiding ( Reader, State,@@ -88,7 +65,6 @@ traceShow, undefined, )-import System.IO.Error (userError) import Polysemy.Time.Debug (dbg, dbgs, dbgs_) @@ -99,95 +75,6 @@ pure () {-# inline unit #-} -tuple ::- Applicative f =>- f a ->- f b ->- f (a, b)-tuple fa fb =- (,) <$> fa <*> fb-{-# inline tuple #-}--liftT ::- forall m f r e a .- Functor f =>- Sem r a ->- Sem (WithTactics e f m r) (f a)-liftT =- pureT <=< raise-{-# inline liftT #-}--hoistEither ::- Member (Error e2) r =>- (e1 -> e2) ->- Either e1 a ->- Sem r a-hoistEither f =- fromEither . mapLeft f-{-# inline hoistEither #-}--hoistEitherWith ::- (e -> Sem r a) ->- Either e a ->- Sem r a-hoistEitherWith f =- either f pure-{-# inline hoistEitherWith #-}--hoistEitherShow ::- Show e1 =>- Member (Error e2) r =>- (Text -> e2) ->- Either e1 a ->- Sem r a-hoistEitherShow f =- fromEither . mapLeft (f . Text.replace "\\" "" . show)-{-# inline hoistEitherShow #-}--hoistErrorWith ::- (e -> Sem r a) ->- Sem (Error e : r) a ->- Sem r a-hoistErrorWith f =- hoistEitherWith f <=< runError-{-# inline hoistErrorWith #-}--tryAny ::- Member (Embed IO) r =>- IO a ->- Sem r (Either Text a)-tryAny =- embed . fmap (mapLeft show) . try @SomeException-{-# inline tryAny #-}--tryHoist ::- Member (Embed IO) r =>- (Text -> e) ->- IO a ->- Sem r (Either e a)-tryHoist f =- fmap (mapLeft f) . tryAny-{-# inline tryHoist #-}--tryThrow ::- Members [Embed IO, Error e] r =>- (Text -> e) ->- IO a ->- Sem r a-tryThrow f =- fromEither <=< tryHoist f-{-# inline tryThrow #-}--throwTextIO :: Text -> IO a-throwTextIO =- throwIO . userError . toString-{-# inline throwTextIO #-}--throwEitherIO :: Either Text a -> IO a-throwEitherIO =- traverseLeft throwTextIO-{-# inline throwEitherIO #-}- basicOptions :: Aeson.Options basicOptions = Aeson.defaultOptions {@@ -205,100 +92,6 @@ deriveJSON jsonOptions {-# inline defaultJson #-} -unaryRecordJson :: TH.Name -> TH.Q [TH.Dec]-unaryRecordJson =- deriveJSON basicOptions-{-# inline unaryRecordJson #-}--type Basic a =- (Eq a, Show a)--type family Basics (as :: [Type]) :: Constraint where- Basics '[] = ()- Basics (a : as) = (Basic a, Basics as)--type Eso a =- (Basic a, Ord a)--type family Esos (as :: [Type]) :: Constraint where- Esos '[] = ()- Esos (a : as) = (Eso a, Esos as)--type Json a =- (FromJSON a, ToJSON a, Basic a)--type family Jsons (r :: [Type]) :: Constraint where- Jsons '[] = ()- Jsons (a ': r) = (Json a, Jsons r)--rightOr :: (a -> b) -> Either a b -> b-rightOr f =- either f id-{-# inline rightOr #-}--traverseLeft ::- Applicative m =>- (a -> m b) ->- Either a b ->- m b-traverseLeft f =- either f pure-{-# inline traverseLeft #-}--jsonDecode ::- FromJSON a =>- ByteString ->- Either Text a-jsonDecode =- mapLeft toText . Aeson.eitherDecodeStrict'-{-# inline jsonDecode #-}--jsonDecodeL ::- FromJSON a =>- LByteString ->- Either Text a-jsonDecodeL =- mapLeft toText . Aeson.eitherDecode'-{-# inline jsonDecodeL #-}--jsonDecodeText ::- FromJSON a =>- Text ->- Either Text a-jsonDecodeText =- mapLeft toText . Aeson.eitherDecodeStrict' . encodeUtf8-{-# inline jsonDecodeText #-}--jsonEncode ::- ToJSON a =>- a ->- ByteString-jsonEncode =- toStrict . Aeson.encode-{-# inline jsonEncode #-}--jsonEncodeText ::- ToJSON a =>- a ->- Text-jsonEncodeText =- decodeUtf8 . jsonEncode-{-# inline jsonEncodeText #-}--as ::- Functor m =>- a ->- m b ->- m a-as =- (<$)-{-# inline as #-}--mneToList :: Maybe (NonEmpty a) -> [a]-mneToList =- maybe [] toList-{-# inline mneToList #-}- safeDiv :: Real a => Integral a =>@@ -317,14 +110,6 @@ a -> a -> a-divOr0 =- fromMaybe 0 .: safeDiv+divOr0 l r =+ fromMaybe 0 (safeDiv l r) {-# inline divOr0 #-}--mapBy ::- Ord k =>- (a -> k) ->- [a] ->- Map k a-mapBy f =- Map.fromList . fmap \ a -> (f a, a)
lib/Polysemy/Time/Sleep.hs view
@@ -8,6 +8,8 @@ Member (Embed IO) r => MicroSeconds -> Sem r ()+uSleep (MicroSeconds 0) =+ unit uSleep (MicroSeconds us) = embed (threadDelay (fromIntegral us))
polysemy-time.cabal view
@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack name: polysemy-time-version: 0.1.4.0+version: 0.2.0.0 synopsis: Polysemy Effect for Time description: Please see the readme on Github at <https://github.com/tek/polysemy-time> category: Time@@ -100,14 +100,10 @@ UndecidableInstances UnicodeSyntax ViewPatterns- ghc-options: -flate-specialise -fspecialise-aggressively -Wall+ ghc-options: -flate-specialise -fspecialise-aggressively -Wall -Wredundant-constraints -Wunused-packages build-depends: aeson >=1.4 , base ==4.*- , composition >=1.0- , containers- , data-default >=0.7- , either , polysemy >=1.3 , relude >=0.7 , string-interpolate >=0.2@@ -187,28 +183,16 @@ UndecidableInstances UnicodeSyntax ViewPatterns- ghc-options: -flate-specialise -fspecialise-aggressively -Wall -threaded -rtsopts -with-rtsopts=-N+ ghc-options: -flate-specialise -fspecialise-aggressively -Wall -Wredundant-constraints -Wunused-packages -threaded -rtsopts -with-rtsopts=-N build-depends:- aeson >=1.4- , base ==4.*- , composition >=1.0- , containers- , data-default >=0.7- , either- , hedgehog+ base ==4.* , polysemy >=1.3 , polysemy-test , polysemy-time- , relude >=0.7- , string-interpolate >=0.2 , tasty- , tasty-hedgehog- , template-haskell- , text , time- , torsor >=0.1 mixins: base hiding (Prelude)- , polysemy-time hiding (Prelude)+ , polysemy-time hiding (Polysemy.Time.Prelude) , polysemy-time (Polysemy.Time.Prelude as Prelude) default-language: Haskell2010