polysemy-resume 0.2.0.0 → 0.3.0.0
raw patch · 10 files changed
+37/−74 lines, 10 filesdep +incipit-coredep +stmdep −reludedep ~polysemysetup-changedPVP ok
version bump matches the API change (PVP)
Dependencies added: incipit-core, stm
Dependencies removed: relude
Dependency ranges changed: polysemy
API changes (from Hackage documentation)
- Polysemy.Resume.Data.Stop: stop :: forall e_a9pC r_aaFs a_a9pE. MemberWithError (Stop e_a9pC) r_aaFs => e_a9pC -> Sem r_aaFs a_a9pE
- Polysemy.Resume.Prelude: (!!?) :: [a] -> Int -> Maybe a
- Polysemy.Resume.Prelude: ($!!) :: NFData a => (a -> b) -> a -> b
- Polysemy.Resume.Prelude: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- Polysemy.Resume.Prelude: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- Polysemy.Resume.Prelude: ($<) :: Contravariant f => f b -> b -> f a
- Polysemy.Resume.Prelude: ($>) :: Functor f => f a -> b -> f b
- Polysemy.Resume.Prelude: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
- Polysemy.Resume.Prelude: (&&) :: Bool -> Bool -> Bool
- Polysemy.Resume.Prelude: (&&^) :: Monad m => m Bool -> m Bool -> m Bool
- Polysemy.Resume.Prelude: (&) :: a -> (a -> b) -> b
- Polysemy.Resume.Prelude: (*) :: Num a => a -> a -> a
- Polysemy.Resume.Prelude: (**) :: Floating a => a -> a -> a
- Polysemy.Resume.Prelude: (*>) :: Applicative f => f a -> f b -> f b
- Polysemy.Resume.Prelude: (+) :: Num a => a -> a -> a
- Polysemy.Resume.Prelude: (++) :: [a] -> [a] -> [a]
- Polysemy.Resume.Prelude: (-) :: Num a => a -> a -> a
- Polysemy.Resume.Prelude: (.) :: (b -> c) -> (a -> b) -> a -> c
- Polysemy.Resume.Prelude: (/) :: Fractional a => a -> a -> a
- Polysemy.Resume.Prelude: (/=) :: Eq a => a -> a -> Bool
- Polysemy.Resume.Prelude: (:|) :: a -> [a] -> NonEmpty a
- Polysemy.Resume.Prelude: (<$!>) :: Monad m => (a -> b) -> m a -> m b
- Polysemy.Resume.Prelude: (<$) :: Functor f => a -> f b -> f a
- Polysemy.Resume.Prelude: (<$>) :: Functor f => (a -> b) -> f a -> f b
- Polysemy.Resume.Prelude: (<&>) :: Functor f => f a -> (a -> b) -> f b
- Polysemy.Resume.Prelude: (<) :: Ord a => a -> a -> Bool
- Polysemy.Resume.Prelude: (<*) :: Applicative f => f a -> f b -> f a
- Polysemy.Resume.Prelude: (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- Polysemy.Resume.Prelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
- Polysemy.Resume.Prelude: (<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
- Polysemy.Resume.Prelude: (<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- Polysemy.Resume.Prelude: (<=) :: Ord a => a -> a -> Bool
- Polysemy.Resume.Prelude: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- Polysemy.Resume.Prelude: (<>) :: Semigroup a => a -> a -> a
- Polysemy.Resume.Prelude: (<|>) :: Alternative f => f a -> f a -> f a
- Polysemy.Resume.Prelude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
- Polysemy.Resume.Prelude: (==) :: Eq a => a -> a -> Bool
- Polysemy.Resume.Prelude: (>$$<) :: Contravariant f => f b -> (a -> b) -> f a
- Polysemy.Resume.Prelude: (>$) :: Contravariant f => b -> f b -> f a
- Polysemy.Resume.Prelude: (>$<) :: Contravariant f => (a -> b) -> f b -> f a
- Polysemy.Resume.Prelude: (>) :: Ord a => a -> a -> Bool
- Polysemy.Resume.Prelude: (>=) :: Ord a => a -> a -> Bool
- Polysemy.Resume.Prelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- Polysemy.Resume.Prelude: (>>) :: Monad m => m a -> m b -> m b
- Polysemy.Resume.Prelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
- Polysemy.Resume.Prelude: (>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
- Polysemy.Resume.Prelude: (?:) :: Maybe a -> a -> a
- Polysemy.Resume.Prelude: (??) :: Functor f => f (a -> b) -> a -> f b
- Polysemy.Resume.Prelude: (^) :: (Num a, Integral b) => a -> b -> a
- Polysemy.Resume.Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
- Polysemy.Resume.Prelude: (||) :: Bool -> Bool -> Bool
- Polysemy.Resume.Prelude: (||^) :: Monad m => m Bool -> m Bool -> m Bool
- Polysemy.Resume.Prelude: -- | Type of a single element of the structure.
- Polysemy.Resume.Prelude: All :: Bool -> All
- Polysemy.Resume.Prelude: Alt :: f a -> Alt (f :: k -> Type) (a :: k)
- Polysemy.Resume.Prelude: Any :: Bool -> Any
- Polysemy.Resume.Prelude: Ap :: f a -> Ap (f :: k -> Type) (a :: k)
- Polysemy.Resume.Prelude: AppendMode :: IOMode
- Polysemy.Resume.Prelude: BlockBuffering :: Maybe Int -> BufferMode
- Polysemy.Resume.Prelude: Bug :: SomeException -> CallStack -> Bug
- Polysemy.Resume.Prelude: Comparison :: (a -> a -> Ordering) -> Comparison a
- Polysemy.Resume.Prelude: Compose :: f (g a) -> Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
- Polysemy.Resume.Prelude: Const :: a -> Const a (b :: k)
- Polysemy.Resume.Prelude: D# :: Double# -> Double
- Polysemy.Resume.Prelude: Down :: a -> Down a
- Polysemy.Resume.Prelude: Dual :: a -> Dual a
- Polysemy.Resume.Prelude: EQ :: Ordering
- Polysemy.Resume.Prelude: Endo :: (a -> a) -> Endo a
- Polysemy.Resume.Prelude: Equivalence :: (a -> a -> Bool) -> Equivalence a
- Polysemy.Resume.Prelude: ExceptT :: m (Either e a) -> ExceptT e (m :: Type -> Type) a
- Polysemy.Resume.Prelude: F# :: Float# -> Float
- Polysemy.Resume.Prelude: False :: Bool
- Polysemy.Resume.Prelude: First :: Maybe a -> First a
- Polysemy.Resume.Prelude: GT :: Ordering
- Polysemy.Resume.Prelude: Identity :: a -> Identity a
- Polysemy.Resume.Prelude: Just :: a -> Maybe a
- Polysemy.Resume.Prelude: LT :: Ordering
- Polysemy.Resume.Prelude: Last :: Maybe a -> Last a
- Polysemy.Resume.Prelude: Left :: a -> Either a b
- Polysemy.Resume.Prelude: LineBuffering :: BufferMode
- Polysemy.Resume.Prelude: MaybeT :: m (Maybe a) -> MaybeT (m :: Type -> Type) a
- Polysemy.Resume.Prelude: NoBuffering :: BufferMode
- Polysemy.Resume.Prelude: Nothing :: Maybe a
- Polysemy.Resume.Prelude: Op :: (b -> a) -> Op a b
- Polysemy.Resume.Prelude: Option :: Maybe a -> Option a
- Polysemy.Resume.Prelude: Predicate :: (a -> Bool) -> Predicate a
- Polysemy.Resume.Prelude: Product :: a -> Product a
- Polysemy.Resume.Prelude: Proxy :: Proxy (t :: k)
- Polysemy.Resume.Prelude: ReadMode :: IOMode
- Polysemy.Resume.Prelude: ReadWriteMode :: IOMode
- Polysemy.Resume.Prelude: ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a
- Polysemy.Resume.Prelude: Right :: b -> Either a b
- Polysemy.Resume.Prelude: SomeException :: e -> SomeException
- Polysemy.Resume.Prelude: SomeNat :: Proxy n -> SomeNat
- Polysemy.Resume.Prelude: StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a
- Polysemy.Resume.Prelude: Sum :: a -> Sum a
- Polysemy.Resume.Prelude: True :: Bool
- Polysemy.Resume.Prelude: Undefined :: Undefined
- Polysemy.Resume.Prelude: WriteMode :: IOMode
- Polysemy.Resume.Prelude: ZipList :: [a] -> ZipList a
- Polysemy.Resume.Prelude: [appEndo] :: Endo a -> a -> a
- Polysemy.Resume.Prelude: [getAll] :: All -> Bool
- Polysemy.Resume.Prelude: [getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
- Polysemy.Resume.Prelude: [getAny] :: Any -> Bool
- Polysemy.Resume.Prelude: [getAp] :: Ap (f :: k -> Type) (a :: k) -> f a
- Polysemy.Resume.Prelude: [getComparison] :: Comparison a -> a -> a -> Ordering
- Polysemy.Resume.Prelude: [getCompose] :: Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) -> f (g a)
- Polysemy.Resume.Prelude: [getConst] :: Const a (b :: k) -> a
- Polysemy.Resume.Prelude: [getDown] :: Down a -> a
- Polysemy.Resume.Prelude: [getDual] :: Dual a -> a
- Polysemy.Resume.Prelude: [getEquivalence] :: Equivalence a -> a -> a -> Bool
- Polysemy.Resume.Prelude: [getFirst] :: First a -> Maybe a
- Polysemy.Resume.Prelude: [getLast] :: Last a -> Maybe a
- Polysemy.Resume.Prelude: [getOp] :: Op a b -> b -> a
- Polysemy.Resume.Prelude: [getOption] :: Option a -> Maybe a
- Polysemy.Resume.Prelude: [getPredicate] :: Predicate a -> a -> Bool
- Polysemy.Resume.Prelude: [getProduct] :: Product a -> a
- Polysemy.Resume.Prelude: [getSum] :: Sum a -> a
- Polysemy.Resume.Prelude: [getZipList] :: ZipList a -> [a]
- Polysemy.Resume.Prelude: [runIdentity] :: Identity a -> a
- Polysemy.Resume.Prelude: [runMaybeT] :: MaybeT (m :: Type -> Type) a -> m (Maybe a)
- Polysemy.Resume.Prelude: [runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a
- Polysemy.Resume.Prelude: [runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)
- Polysemy.Resume.Prelude: abs :: Num a => a -> a
- Polysemy.Resume.Prelude: absurd :: Void -> a
- Polysemy.Resume.Prelude: acos :: Floating a => a -> a
- Polysemy.Resume.Prelude: acosh :: Floating a => a -> a
- Polysemy.Resume.Prelude: all :: Foldable t => (a -> Bool) -> t a -> Bool
- Polysemy.Resume.Prelude: allM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
- Polysemy.Resume.Prelude: and :: Foldable t => t Bool -> Bool
- Polysemy.Resume.Prelude: andM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
- Polysemy.Resume.Prelude: any :: Foldable t => (a -> Bool) -> t a -> Bool
- Polysemy.Resume.Prelude: anyM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
- Polysemy.Resume.Prelude: appendFile :: MonadIO m => FilePath -> String -> m ()
- Polysemy.Resume.Prelude: appendFileBS :: MonadIO m => FilePath -> ByteString -> m ()
- Polysemy.Resume.Prelude: appendFileLBS :: MonadIO m => FilePath -> LByteString -> m ()
- Polysemy.Resume.Prelude: appendFileLText :: MonadIO m => FilePath -> LText -> m ()
- Polysemy.Resume.Prelude: appendFileText :: MonadIO m => FilePath -> Text -> m ()
- Polysemy.Resume.Prelude: appliedTo :: Applicative f => f a -> f (a -> b) -> f b
- Polysemy.Resume.Prelude: asTypeOf :: a -> a -> a
- Polysemy.Resume.Prelude: asin :: Floating a => a -> a
- Polysemy.Resume.Prelude: asinh :: Floating a => a -> a
- Polysemy.Resume.Prelude: ask :: MonadReader r m => m r
- Polysemy.Resume.Prelude: asks :: MonadReader r m => (r -> a) -> m a
- Polysemy.Resume.Prelude: asum :: (Foldable t, Alternative f) => t (f a) -> f a
- Polysemy.Resume.Prelude: asumMap :: forall b m f a. (Foldable f, Alternative m) => (a -> m b) -> f a -> m b
- Polysemy.Resume.Prelude: atan :: Floating a => a -> a
- Polysemy.Resume.Prelude: atan2 :: RealFloat a => a -> a -> a
- Polysemy.Resume.Prelude: atanh :: Floating a => a -> a
- Polysemy.Resume.Prelude: atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
- Polysemy.Resume.Prelude: atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
- Polysemy.Resume.Prelude: atomicModifyIORef'_ :: MonadIO m => IORef a -> (a -> a) -> m ()
- Polysemy.Resume.Prelude: atomicModifyIORef_ :: MonadIO m => IORef a -> (a -> a) -> m ()
- Polysemy.Resume.Prelude: atomicWriteIORef :: MonadIO m => IORef a -> a -> m ()
- Polysemy.Resume.Prelude: atomically :: MonadIO m => STM a -> m a
- Polysemy.Resume.Prelude: biList :: Bifoldable t => t a a -> [a]
- Polysemy.Resume.Prelude: biall :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
- Polysemy.Resume.Prelude: biand :: Bifoldable t => t Bool Bool -> Bool
- Polysemy.Resume.Prelude: biany :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
- Polysemy.Resume.Prelude: biasum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a
- Polysemy.Resume.Prelude: bielem :: (Bifoldable t, Eq a) => a -> t a a -> Bool
- Polysemy.Resume.Prelude: bifind :: Bifoldable t => (a -> Bool) -> t a a -> Maybe a
- Polysemy.Resume.Prelude: bifold :: (Bifoldable p, Monoid m) => p m m -> m
- Polysemy.Resume.Prelude: bifoldMap :: (Bifoldable p, Monoid m) => (a -> m) -> (b -> m) -> p a b -> m
- Polysemy.Resume.Prelude: bifoldMapDefault :: (Bitraversable t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m
- Polysemy.Resume.Prelude: bifoldl :: Bifoldable p => (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c
- Polysemy.Resume.Prelude: bifoldl' :: Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a
- Polysemy.Resume.Prelude: bifoldlM :: (Bifoldable t, Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a
- Polysemy.Resume.Prelude: bifoldr :: Bifoldable p => (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
- Polysemy.Resume.Prelude: bifoldr' :: Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c
- Polysemy.Resume.Prelude: bifoldrM :: (Bifoldable t, Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c
- Polysemy.Resume.Prelude: bifor :: (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
- Polysemy.Resume.Prelude: bifor_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
- Polysemy.Resume.Prelude: bilength :: Bifoldable t => t a b -> Int
- Polysemy.Resume.Prelude: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
- Polysemy.Resume.Prelude: bimapDefault :: Bitraversable t => (a -> b) -> (c -> d) -> t a c -> t b d
- Polysemy.Resume.Prelude: binull :: Bifoldable t => t a b -> Bool
- Polysemy.Resume.Prelude: bior :: Bifoldable t => t Bool Bool -> Bool
- Polysemy.Resume.Prelude: bisequence :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)
- Polysemy.Resume.Prelude: bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()
- Polysemy.Resume.Prelude: bitraverse :: (Bitraversable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
- Polysemy.Resume.Prelude: bitraverse_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
- Polysemy.Resume.Prelude: bool :: a -> a -> Bool -> a
- Polysemy.Resume.Prelude: boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
- Polysemy.Resume.Prelude: boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
- Polysemy.Resume.Prelude: break :: (a -> Bool) -> [a] -> ([a], [a])
- Polysemy.Resume.Prelude: bug :: (HasCallStack, Exception e) => e -> a
- Polysemy.Resume.Prelude: byteSwap16 :: Word16 -> Word16
- Polysemy.Resume.Prelude: byteSwap32 :: Word32 -> Word32
- Polysemy.Resume.Prelude: byteSwap64 :: Word64 -> Word64
- Polysemy.Resume.Prelude: callStack :: HasCallStack => CallStack
- Polysemy.Resume.Prelude: catMaybes :: [Maybe a] -> [a]
- Polysemy.Resume.Prelude: catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a
- Polysemy.Resume.Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
- Polysemy.Resume.Prelude: chainedTo :: Monad m => (a -> m b) -> m a -> m b
- Polysemy.Resume.Prelude: chr :: Int -> Char
- Polysemy.Resume.Prelude: class Applicative f => Alternative (f :: Type -> Type)
- Polysemy.Resume.Prelude: class Functor f => Applicative (f :: Type -> Type)
- Polysemy.Resume.Prelude: class Bifoldable (p :: Type -> Type -> Type)
- Polysemy.Resume.Prelude: class Bifunctor (p :: Type -> Type -> Type)
- Polysemy.Resume.Prelude: class (Bifunctor t, Bifoldable t) => Bitraversable (t :: Type -> Type -> Type)
- Polysemy.Resume.Prelude: class Bounded a
- Polysemy.Resume.Prelude: class a ~R# b => Coercible (a :: k) (b :: k)
- Polysemy.Resume.Prelude: class Contravariant (f :: Type -> Type)
- Polysemy.Resume.Prelude: class ConvertUtf8 a b
- Polysemy.Resume.Prelude: class Enum a
- Polysemy.Resume.Prelude: class Eq a
- Polysemy.Resume.Prelude: class (Typeable e, Show e) => Exception e
- Polysemy.Resume.Prelude: class Fractional a => Floating a
- Polysemy.Resume.Prelude: class Foldable (t :: Type -> Type)
- Polysemy.Resume.Prelude: class Num a => Fractional a
- Polysemy.Resume.Prelude: class Functor (f :: Type -> Type)
- Polysemy.Resume.Prelude: class Generic a
- Polysemy.Resume.Prelude: class Hashable a
- Polysemy.Resume.Prelude: class (Real a, Enum a) => Integral a
- Polysemy.Resume.Prelude: class IsLabel (x :: Symbol) a
- Polysemy.Resume.Prelude: class IsList l
- Polysemy.Resume.Prelude: class IsString a
- Polysemy.Resume.Prelude: class KnownNat (n :: Nat)
- Polysemy.Resume.Prelude: class LazyStrict l s | l -> s, s -> l
- Polysemy.Resume.Prelude: class Applicative m => Monad (m :: Type -> Type)
- Polysemy.Resume.Prelude: class Monad m => MonadFail (m :: Type -> Type)
- Polysemy.Resume.Prelude: class Monad m => MonadIO (m :: Type -> Type)
- Polysemy.Resume.Prelude: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
- Polysemy.Resume.Prelude: class Monad m => MonadReader r (m :: Type -> Type) | m -> r
- Polysemy.Resume.Prelude: class Monad m => MonadState s (m :: Type -> Type) | m -> s
- Polysemy.Resume.Prelude: class MonadTrans (t :: Type -> Type -> Type -> Type)
- Polysemy.Resume.Prelude: class Semigroup a => Monoid a
- Polysemy.Resume.Prelude: class NFData a
- Polysemy.Resume.Prelude: class Num a
- Polysemy.Resume.Prelude: class One x where {
- Polysemy.Resume.Prelude: class Eq a => Ord a
- Polysemy.Resume.Prelude: class Read a
- Polysemy.Resume.Prelude: class (Num a, Ord a) => Real a
- Polysemy.Resume.Prelude: class (RealFrac a, Floating a) => RealFloat a
- Polysemy.Resume.Prelude: class (Real a, Fractional a) => RealFrac a
- Polysemy.Resume.Prelude: class Semigroup a
- Polysemy.Resume.Prelude: class Show a
- Polysemy.Resume.Prelude: class ToLText a
- Polysemy.Resume.Prelude: class ToString a
- Polysemy.Resume.Prelude: class ToText a
- Polysemy.Resume.Prelude: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
- Polysemy.Resume.Prelude: class Typeable (a :: k)
- Polysemy.Resume.Prelude: coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
- Polysemy.Resume.Prelude: compare :: Ord a => a -> a -> Ordering
- Polysemy.Resume.Prelude: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
- Polysemy.Resume.Prelude: comparisonEquivalence :: Comparison a -> Equivalence a
- Polysemy.Resume.Prelude: concat :: Foldable t => t [a] -> [a]
- Polysemy.Resume.Prelude: concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- Polysemy.Resume.Prelude: const :: a -> b -> a
- Polysemy.Resume.Prelude: contramap :: Contravariant f => (a -> b) -> f b -> f a
- Polysemy.Resume.Prelude: cos :: Floating a => a -> a
- Polysemy.Resume.Prelude: cosh :: Floating a => a -> a
- Polysemy.Resume.Prelude: currentCallStack :: IO [String]
- Polysemy.Resume.Prelude: curry :: ((a, b) -> c) -> a -> b -> c
- Polysemy.Resume.Prelude: cycle :: [a] -> [a]
- Polysemy.Resume.Prelude: cycle1 :: Semigroup m => m -> m
- Polysemy.Resume.Prelude: data Bool
- Polysemy.Resume.Prelude: data BufferMode
- Polysemy.Resume.Prelude: data Bug
- Polysemy.Resume.Prelude: data ByteString
- Polysemy.Resume.Prelude: data CallStack
- Polysemy.Resume.Prelude: data Char
- Polysemy.Resume.Prelude: data Constraint
- Polysemy.Resume.Prelude: data Double
- Polysemy.Resume.Prelude: data Either a b
- Polysemy.Resume.Prelude: data Error e (m :: k -> Type) (a :: k)
- Polysemy.Resume.Prelude: data Float
- Polysemy.Resume.Prelude: data Handle
- Polysemy.Resume.Prelude: data HashMap k v
- Polysemy.Resume.Prelude: data HashSet a
- Polysemy.Resume.Prelude: data IO a
- Polysemy.Resume.Prelude: data IOMode
- Polysemy.Resume.Prelude: data IORef a
- Polysemy.Resume.Prelude: data IdentityT (f :: k -> Type) (a :: k)
- Polysemy.Resume.Prelude: data Int
- Polysemy.Resume.Prelude: data Int16
- Polysemy.Resume.Prelude: data Int32
- Polysemy.Resume.Prelude: data Int64
- Polysemy.Resume.Prelude: data Int8
- Polysemy.Resume.Prelude: data IntMap a
- Polysemy.Resume.Prelude: data IntSet
- Polysemy.Resume.Prelude: data Integer
- Polysemy.Resume.Prelude: data MVar a
- Polysemy.Resume.Prelude: data Map k a
- Polysemy.Resume.Prelude: data Maybe a
- Polysemy.Resume.Prelude: data Nat
- Polysemy.Resume.Prelude: data Natural
- Polysemy.Resume.Prelude: data NonEmpty a
- Polysemy.Resume.Prelude: data Ordering
- Polysemy.Resume.Prelude: data Proxy (t :: k)
- Polysemy.Resume.Prelude: data Ratio a
- Polysemy.Resume.Prelude: data STM a
- Polysemy.Resume.Prelude: data Sem (r :: EffectRow) a
- Polysemy.Resume.Prelude: data Seq a
- Polysemy.Resume.Prelude: data Set a
- Polysemy.Resume.Prelude: data ShortByteString
- Polysemy.Resume.Prelude: data SomeException
- Polysemy.Resume.Prelude: data SomeNat
- Polysemy.Resume.Prelude: data TMVar a
- Polysemy.Resume.Prelude: data TVar a
- Polysemy.Resume.Prelude: data Text
- Polysemy.Resume.Prelude: data Undefined
- Polysemy.Resume.Prelude: data UnicodeException
- Polysemy.Resume.Prelude: data Void
- Polysemy.Resume.Prelude: data Word
- Polysemy.Resume.Prelude: data Word16
- Polysemy.Resume.Prelude: data Word32
- Polysemy.Resume.Prelude: data Word64
- Polysemy.Resume.Prelude: data Word8
- Polysemy.Resume.Prelude: data WrappedMonoid m
- Polysemy.Resume.Prelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
- Polysemy.Resume.Prelude: decodeUtf8 :: ConvertUtf8 a b => b -> a
- Polysemy.Resume.Prelude: decodeUtf8' :: ByteString -> Either UnicodeException Text
- Polysemy.Resume.Prelude: decodeUtf8Strict :: ConvertUtf8 a b => b -> Either UnicodeException a
- Polysemy.Resume.Prelude: decodeUtf8With :: OnDecodeError -> ByteString -> Text
- Polysemy.Resume.Prelude: deepseq :: NFData a => a -> b -> b
- Polysemy.Resume.Prelude: defaultComparison :: Ord a => Comparison a
- Polysemy.Resume.Prelude: defaultEquivalence :: Eq a => Equivalence a
- Polysemy.Resume.Prelude: denominator :: Ratio a -> a
- Polysemy.Resume.Prelude: die :: MonadIO m => String -> m a
- Polysemy.Resume.Prelude: displayException :: Exception e => e -> String
- Polysemy.Resume.Prelude: div :: Integral a => a -> a -> a
- Polysemy.Resume.Prelude: divMod :: Integral a => a -> a -> (a, a)
- Polysemy.Resume.Prelude: drop :: Int -> [a] -> [a]
- Polysemy.Resume.Prelude: dropWhile :: (a -> Bool) -> [a] -> [a]
- Polysemy.Resume.Prelude: either :: (a -> c) -> (b -> c) -> Either a b -> c
- Polysemy.Resume.Prelude: elem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
- Polysemy.Resume.Prelude: empty :: Alternative f => f a
- Polysemy.Resume.Prelude: encodeFloat :: RealFloat a => Integer -> Int -> a
- Polysemy.Resume.Prelude: encodeUtf8 :: ConvertUtf8 a b => a -> b
- Polysemy.Resume.Prelude: enumFrom :: Enum a => a -> [a]
- Polysemy.Resume.Prelude: enumFromThen :: Enum a => a -> a -> [a]
- Polysemy.Resume.Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
- Polysemy.Resume.Prelude: enumFromTo :: Enum a => a -> a -> [a]
- Polysemy.Resume.Prelude: error :: forall (r :: RuntimeRep) (a :: TYPE r) t. (HasCallStack, IsText t) => t -> a
- Polysemy.Resume.Prelude: etaReaderT :: forall r (m :: Type -> Type) a. ReaderT r m a -> ReaderT r m a
- Polysemy.Resume.Prelude: evalState :: State s a -> s -> a
- Polysemy.Resume.Prelude: evalStateT :: Monad m => StateT s m a -> s -> m a
- Polysemy.Resume.Prelude: evaluateNF :: (NFData a, MonadIO m) => a -> m a
- Polysemy.Resume.Prelude: evaluateNF_ :: (NFData a, MonadIO m) => a -> m ()
- Polysemy.Resume.Prelude: evaluateWHNF :: MonadIO m => a -> m a
- Polysemy.Resume.Prelude: evaluateWHNF_ :: MonadIO m => a -> m ()
- Polysemy.Resume.Prelude: evaluatingState :: s -> State s a -> a
- Polysemy.Resume.Prelude: evaluatingStateT :: Functor f => s -> StateT s f a -> f a
- Polysemy.Resume.Prelude: even :: Integral a => a -> Bool
- Polysemy.Resume.Prelude: exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a
- Polysemy.Resume.Prelude: execState :: State s a -> s -> s
- Polysemy.Resume.Prelude: execStateT :: Monad m => StateT s m a -> s -> m s
- Polysemy.Resume.Prelude: executingState :: s -> State s a -> s
- Polysemy.Resume.Prelude: executingStateT :: Functor f => s -> StateT s f a -> f s
- Polysemy.Resume.Prelude: exitFailure :: MonadIO m => m a
- Polysemy.Resume.Prelude: exitSuccess :: MonadIO m => m a
- Polysemy.Resume.Prelude: exitWith :: MonadIO m => ExitCode -> m a
- Polysemy.Resume.Prelude: exp :: Floating a => a -> a
- Polysemy.Resume.Prelude: fail :: MonadFail m => String -> m a
- Polysemy.Resume.Prelude: filter :: (a -> Bool) -> [a] -> [a]
- Polysemy.Resume.Prelude: filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- Polysemy.Resume.Prelude: find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- Polysemy.Resume.Prelude: first :: Bifunctor p => (a -> b) -> p a c -> p b c
- Polysemy.Resume.Prelude: fix :: (a -> a) -> a
- Polysemy.Resume.Prelude: flap :: Functor f => f (a -> b) -> a -> f b
- Polysemy.Resume.Prelude: flip :: (a -> b -> c) -> b -> a -> c
- Polysemy.Resume.Prelude: flipfoldl' :: Foldable f => (a -> b -> b) -> b -> f a -> b
- Polysemy.Resume.Prelude: floatDigits :: RealFloat a => a -> Int
- Polysemy.Resume.Prelude: floatRadix :: RealFloat a => a -> Integer
- Polysemy.Resume.Prelude: floatRange :: RealFloat a => a -> (Int, Int)
- Polysemy.Resume.Prelude: floor :: (RealFrac a, Integral b) => a -> b
- Polysemy.Resume.Prelude: fmap :: Functor f => (a -> b) -> f a -> f b
- Polysemy.Resume.Prelude: fold :: (Foldable t, Monoid m) => t m -> m
- Polysemy.Resume.Prelude: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
- Polysemy.Resume.Prelude: foldMap' :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
- Polysemy.Resume.Prelude: foldMapA :: (Semigroup b, Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b
- Polysemy.Resume.Prelude: foldMapM :: (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b
- Polysemy.Resume.Prelude: foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
- Polysemy.Resume.Prelude: foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- Polysemy.Resume.Prelude: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
- Polysemy.Resume.Prelude: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- Polysemy.Resume.Prelude: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- Polysemy.Resume.Prelude: for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
- Polysemy.Resume.Prelude: force :: NFData a => a -> a
- Polysemy.Resume.Prelude: forever :: Applicative f => f a -> f b
- Polysemy.Resume.Prelude: fromEnum :: Enum a => a -> Int
- Polysemy.Resume.Prelude: fromException :: Exception e => SomeException -> Maybe e
- Polysemy.Resume.Prelude: fromInteger :: Num a => Integer -> a
- Polysemy.Resume.Prelude: fromIntegral :: (Integral a, Num b) => a -> b
- Polysemy.Resume.Prelude: fromLabel :: IsLabel x a => a
- Polysemy.Resume.Prelude: fromLazy :: LazyStrict l s => l -> s
- Polysemy.Resume.Prelude: fromLeft :: a -> Either a b -> a
- Polysemy.Resume.Prelude: fromList :: IsList l => [Item l] -> l
- Polysemy.Resume.Prelude: fromListN :: IsList l => Int -> [Item l] -> l
- Polysemy.Resume.Prelude: fromMaybe :: a -> Maybe a -> a
- Polysemy.Resume.Prelude: fromRational :: Fractional a => Rational -> a
- Polysemy.Resume.Prelude: fromRight :: b -> Either a b -> b
- Polysemy.Resume.Prelude: fromShort :: ShortByteString -> ByteString
- Polysemy.Resume.Prelude: fromStrict :: LazyStrict l s => s -> l
- Polysemy.Resume.Prelude: fromString :: IsString a => String -> a
- Polysemy.Resume.Prelude: fst :: (a, b) -> a
- Polysemy.Resume.Prelude: gcd :: Integral a => a -> a -> a
- Polysemy.Resume.Prelude: genericDrop :: Integral i => i -> [a] -> [a]
- Polysemy.Resume.Prelude: genericLength :: Num i => [a] -> i
- Polysemy.Resume.Prelude: genericReplicate :: Integral i => i -> a -> [a]
- Polysemy.Resume.Prelude: genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
- Polysemy.Resume.Prelude: genericTake :: Integral i => i -> [a] -> [a]
- Polysemy.Resume.Prelude: get :: MonadState s m => m s
- Polysemy.Resume.Prelude: getArgs :: MonadIO m => m [String]
- Polysemy.Resume.Prelude: getCallStack :: CallStack -> [([Char], SrcLoc)]
- Polysemy.Resume.Prelude: getLine :: MonadIO m => m Text
- Polysemy.Resume.Prelude: getStackTrace :: IO (Maybe [Location])
- Polysemy.Resume.Prelude: gets :: MonadState s m => (s -> a) -> m a
- Polysemy.Resume.Prelude: group :: Eq a => [a] -> [[a]]
- Polysemy.Resume.Prelude: guard :: Alternative f => Bool -> f ()
- Polysemy.Resume.Prelude: guardM :: MonadPlus m => m Bool -> m ()
- Polysemy.Resume.Prelude: guarded :: Alternative f => (a -> Bool) -> a -> f a
- Polysemy.Resume.Prelude: hFlush :: MonadIO m => Handle -> m ()
- Polysemy.Resume.Prelude: hGetBuffering :: MonadIO m => Handle -> m BufferMode
- Polysemy.Resume.Prelude: hIsEOF :: MonadIO m => Handle -> m Bool
- Polysemy.Resume.Prelude: hSetBuffering :: MonadIO m => Handle -> BufferMode -> m ()
- Polysemy.Resume.Prelude: hashNub :: (Eq a, Hashable a) => [a] -> [a]
- Polysemy.Resume.Prelude: hashWithSalt :: Hashable a => Int -> a -> Int
- Polysemy.Resume.Prelude: head :: IsNonEmpty f a a "head" => f a -> a
- Polysemy.Resume.Prelude: hoistEither :: forall (m :: Type -> Type) e a. Applicative m => Either e a -> ExceptT e m a
- Polysemy.Resume.Prelude: hoistMaybe :: forall (m :: Type -> Type) a. Applicative m => Maybe a -> MaybeT m a
- Polysemy.Resume.Prelude: id :: a -> a
- Polysemy.Resume.Prelude: identity :: a -> a
- Polysemy.Resume.Prelude: ifM :: Monad m => m Bool -> m a -> m a -> m a
- Polysemy.Resume.Prelude: infinitely :: Applicative f => f a -> f Void
- Polysemy.Resume.Prelude: infix 4 >=
- Polysemy.Resume.Prelude: infix 9 !!?
- Polysemy.Resume.Prelude: infixl 0 `hashWithSalt`
- Polysemy.Resume.Prelude: infixl 1 <&>
- Polysemy.Resume.Prelude: infixl 3 <|>
- Polysemy.Resume.Prelude: infixl 4 <<$>>
- Polysemy.Resume.Prelude: infixl 6 `xor`
- Polysemy.Resume.Prelude: infixl 7 *
- Polysemy.Resume.Prelude: infixr 0 ?:
- Polysemy.Resume.Prelude: infixr 1 =<<
- Polysemy.Resume.Prelude: infixr 2 ||
- Polysemy.Resume.Prelude: infixr 3 &&
- Polysemy.Resume.Prelude: infixr 5 :|
- Polysemy.Resume.Prelude: infixr 6 <>
- Polysemy.Resume.Prelude: infixr 8 ^
- Polysemy.Resume.Prelude: infixr 9 .
- Polysemy.Resume.Prelude: init :: IsNonEmpty f a [a] "init" => f a -> [a]
- Polysemy.Resume.Prelude: inits :: [a] -> [[a]]
- Polysemy.Resume.Prelude: intNub :: [Int] -> [Int]
- Polysemy.Resume.Prelude: intNubOn :: (a -> Int) -> [a] -> [a]
- Polysemy.Resume.Prelude: integerToBounded :: (Integral a, Bounded a) => Integer -> Maybe a
- Polysemy.Resume.Prelude: integerToNatural :: Integer -> Maybe Natural
- Polysemy.Resume.Prelude: intercalate :: [a] -> [[a]] -> [a]
- Polysemy.Resume.Prelude: intersperse :: a -> [a] -> [a]
- Polysemy.Resume.Prelude: inverseMap :: (Bounded a, Enum a, Ord k) => (a -> k) -> k -> Maybe a
- Polysemy.Resume.Prelude: isDenormalized :: RealFloat a => a -> Bool
- Polysemy.Resume.Prelude: isEmptyTMVar :: TMVar a -> STM Bool
- Polysemy.Resume.Prelude: isIEEE :: RealFloat a => a -> Bool
- Polysemy.Resume.Prelude: isInfinite :: RealFloat a => a -> Bool
- Polysemy.Resume.Prelude: isJust :: Maybe a -> Bool
- Polysemy.Resume.Prelude: isLeft :: Either a b -> Bool
- Polysemy.Resume.Prelude: isNaN :: RealFloat a => a -> Bool
- Polysemy.Resume.Prelude: isNegativeZero :: RealFloat a => a -> Bool
- Polysemy.Resume.Prelude: isNothing :: Maybe a -> Bool
- Polysemy.Resume.Prelude: isPrefixOf :: Eq a => [a] -> [a] -> Bool
- Polysemy.Resume.Prelude: isRight :: Either a b -> Bool
- Polysemy.Resume.Prelude: iterate :: (a -> a) -> a -> [a]
- Polysemy.Resume.Prelude: join :: Monad m => m (m a) -> m a
- Polysemy.Resume.Prelude: last :: IsNonEmpty f a a "last" => f a -> a
- Polysemy.Resume.Prelude: lcm :: Integral a => a -> a -> a
- Polysemy.Resume.Prelude: leftToMaybe :: Either l r -> Maybe l
- Polysemy.Resume.Prelude: lefts :: [Either a b] -> [a]
- Polysemy.Resume.Prelude: length :: Foldable t => t a -> Int
- Polysemy.Resume.Prelude: lenientDecode :: OnDecodeError
- Polysemy.Resume.Prelude: lift :: (MonadTrans t, Monad m) => m a -> t m a
- Polysemy.Resume.Prelude: liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
- Polysemy.Resume.Prelude: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- Polysemy.Resume.Prelude: liftIO :: MonadIO m => IO a -> m a
- Polysemy.Resume.Prelude: lines :: IsText t "lines" => t -> [t]
- Polysemy.Resume.Prelude: listToMaybe :: [a] -> Maybe a
- Polysemy.Resume.Prelude: local :: MonadReader r m => (r -> r) -> m a -> m a
- Polysemy.Resume.Prelude: logBase :: Floating a => a -> a -> a
- Polysemy.Resume.Prelude: lookupEnv :: MonadIO m => String -> m (Maybe String)
- Polysemy.Resume.Prelude: many :: Alternative f => f a -> f [a]
- Polysemy.Resume.Prelude: map :: (a -> b) -> [a] -> [b]
- Polysemy.Resume.Prelude: mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- Polysemy.Resume.Prelude: mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- Polysemy.Resume.Prelude: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- Polysemy.Resume.Prelude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- Polysemy.Resume.Prelude: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- Polysemy.Resume.Prelude: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- Polysemy.Resume.Prelude: mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b]
- Polysemy.Resume.Prelude: mappend :: Monoid a => a -> a -> a
- Polysemy.Resume.Prelude: max :: Ord a => a -> a -> a
- Polysemy.Resume.Prelude: maxBound :: Bounded a => a
- Polysemy.Resume.Prelude: maxInt :: Int
- Polysemy.Resume.Prelude: maybe :: b -> (a -> b) -> Maybe a -> b
- Polysemy.Resume.Prelude: maybeAt :: Int -> [a] -> Maybe a
- Polysemy.Resume.Prelude: maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a
- Polysemy.Resume.Prelude: maybeToLeft :: r -> Maybe l -> Either l r
- Polysemy.Resume.Prelude: maybeToList :: Maybe a -> [a]
- Polysemy.Resume.Prelude: maybeToMonoid :: Monoid m => Maybe m -> m
- Polysemy.Resume.Prelude: maybeToRight :: l -> Maybe r -> Either l r
- Polysemy.Resume.Prelude: mconcat :: Monoid a => [a] -> a
- Polysemy.Resume.Prelude: mempty :: Monoid a => a
- Polysemy.Resume.Prelude: memptyIfFalse :: Monoid m => Bool -> m -> m
- Polysemy.Resume.Prelude: memptyIfTrue :: Monoid m => Bool -> m -> m
- Polysemy.Resume.Prelude: mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- Polysemy.Resume.Prelude: min :: Ord a => a -> a -> a
- Polysemy.Resume.Prelude: minBound :: Bounded a => a
- Polysemy.Resume.Prelude: minInt :: Int
- Polysemy.Resume.Prelude: mkWeakTMVar :: TMVar a -> IO () -> IO (Weak (TMVar a))
- Polysemy.Resume.Prelude: mod :: Integral a => a -> a -> a
- Polysemy.Resume.Prelude: modify :: MonadState s m => (s -> s) -> m ()
- Polysemy.Resume.Prelude: modify' :: MonadState s m => (s -> s) -> m ()
- Polysemy.Resume.Prelude: modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m ()
- Polysemy.Resume.Prelude: modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m ()
- Polysemy.Resume.Prelude: modifyTVar' :: TVar a -> (a -> a) -> STM ()
- Polysemy.Resume.Prelude: mplus :: MonadPlus m => m a -> m a -> m a
- Polysemy.Resume.Prelude: mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
- Polysemy.Resume.Prelude: mzero :: MonadPlus m => m a
- Polysemy.Resume.Prelude: natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Natural
- Polysemy.Resume.Prelude: negate :: Num a => a -> a
- Polysemy.Resume.Prelude: newEmptyMVar :: MonadIO m => m (MVar a)
- Polysemy.Resume.Prelude: newEmptyTMVar :: STM (TMVar a)
- Polysemy.Resume.Prelude: newEmptyTMVarIO :: MonadIO m => m (TMVar a)
- Polysemy.Resume.Prelude: newIORef :: MonadIO m => a -> m (IORef a)
- Polysemy.Resume.Prelude: newMVar :: MonadIO m => a -> m (MVar a)
- Polysemy.Resume.Prelude: newTMVar :: a -> STM (TMVar a)
- Polysemy.Resume.Prelude: newTMVarIO :: MonadIO m => a -> m (TMVar a)
- Polysemy.Resume.Prelude: newTVar :: a -> STM (TVar a)
- Polysemy.Resume.Prelude: newTVarIO :: MonadIO m => a -> m (TVar a)
- Polysemy.Resume.Prelude: newtype All
- Polysemy.Resume.Prelude: newtype Alt (f :: k -> Type) (a :: k)
- Polysemy.Resume.Prelude: newtype Any
- Polysemy.Resume.Prelude: newtype Ap (f :: k -> Type) (a :: k)
- Polysemy.Resume.Prelude: newtype Comparison a
- Polysemy.Resume.Prelude: newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
- Polysemy.Resume.Prelude: newtype Const a (b :: k)
- Polysemy.Resume.Prelude: newtype Down a
- Polysemy.Resume.Prelude: newtype Dual a
- Polysemy.Resume.Prelude: newtype Endo a
- Polysemy.Resume.Prelude: newtype Equivalence a
- Polysemy.Resume.Prelude: newtype ExceptT e (m :: Type -> Type) a
- Polysemy.Resume.Prelude: newtype First a
- Polysemy.Resume.Prelude: newtype Identity a
- Polysemy.Resume.Prelude: newtype Last a
- Polysemy.Resume.Prelude: newtype MaybeT (m :: Type -> Type) a
- Polysemy.Resume.Prelude: newtype Op a b
- Polysemy.Resume.Prelude: newtype Option a
- Polysemy.Resume.Prelude: newtype Predicate a
- Polysemy.Resume.Prelude: newtype Product a
- Polysemy.Resume.Prelude: newtype ReaderT r (m :: Type -> Type) a
- Polysemy.Resume.Prelude: newtype StateT s (m :: Type -> Type) a
- Polysemy.Resume.Prelude: newtype Sum a
- Polysemy.Resume.Prelude: newtype ZipList a
- Polysemy.Resume.Prelude: nonEmpty :: [a] -> Maybe (NonEmpty a)
- Polysemy.Resume.Prelude: not :: Bool -> Bool
- Polysemy.Resume.Prelude: notElem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
- Polysemy.Resume.Prelude: null :: Foldable t => t a -> Bool
- Polysemy.Resume.Prelude: numerator :: Ratio a -> a
- Polysemy.Resume.Prelude: odd :: Integral a => a -> Bool
- Polysemy.Resume.Prelude: on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- Polysemy.Resume.Prelude: one :: One x => OneItem x -> x
- Polysemy.Resume.Prelude: optional :: Alternative f => f a -> f (Maybe a)
- Polysemy.Resume.Prelude: or :: Foldable t => t Bool -> Bool
- Polysemy.Resume.Prelude: orM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
- Polysemy.Resume.Prelude: ord :: Char -> Int
- Polysemy.Resume.Prelude: ordNub :: Ord a => [a] -> [a]
- Polysemy.Resume.Prelude: ordNubOn :: Ord b => (a -> b) -> [a] -> [a]
- Polysemy.Resume.Prelude: otherwise :: Bool
- Polysemy.Resume.Prelude: partitionEithers :: [Either a b] -> ([a], [b])
- Polysemy.Resume.Prelude: partitionWith :: (a -> Either b c) -> [a] -> ([b], [c])
- Polysemy.Resume.Prelude: pass :: Applicative f => f ()
- Polysemy.Resume.Prelude: pattern Exc :: Exception e => e -> SomeException
- Polysemy.Resume.Prelude: permutations :: [a] -> [[a]]
- Polysemy.Resume.Prelude: phantom :: (Functor f, Contravariant f) => f a -> f b
- Polysemy.Resume.Prelude: pi :: Floating a => a
- Polysemy.Resume.Prelude: pred :: Enum a => a -> a
- Polysemy.Resume.Prelude: prettyCallStack :: CallStack -> String
- Polysemy.Resume.Prelude: prettySrcLoc :: SrcLoc -> String
- Polysemy.Resume.Prelude: print :: forall a m. (MonadIO m, Show a) => a -> m ()
- Polysemy.Resume.Prelude: product :: forall a f. (Foldable f, Num a) => f a -> a
- Polysemy.Resume.Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
- Polysemy.Resume.Prelude: pure :: Applicative f => a -> f a
- Polysemy.Resume.Prelude: put :: MonadState s m => s -> m ()
- Polysemy.Resume.Prelude: putBS :: MonadIO m => ByteString -> m ()
- Polysemy.Resume.Prelude: putBSLn :: MonadIO m => ByteString -> m ()
- Polysemy.Resume.Prelude: putLBS :: MonadIO m => LByteString -> m ()
- Polysemy.Resume.Prelude: putLBSLn :: MonadIO m => LByteString -> m ()
- Polysemy.Resume.Prelude: putLText :: MonadIO m => LText -> m ()
- Polysemy.Resume.Prelude: putLTextLn :: MonadIO m => LText -> m ()
- Polysemy.Resume.Prelude: putMVar :: MonadIO m => MVar a -> a -> m ()
- Polysemy.Resume.Prelude: putStr :: MonadIO m => String -> m ()
- Polysemy.Resume.Prelude: putStrLn :: MonadIO m => String -> m ()
- Polysemy.Resume.Prelude: putTMVar :: TMVar a -> a -> STM ()
- Polysemy.Resume.Prelude: putText :: MonadIO m => Text -> m ()
- Polysemy.Resume.Prelude: putTextLn :: MonadIO m => Text -> m ()
- Polysemy.Resume.Prelude: quot :: Integral a => a -> a -> a
- Polysemy.Resume.Prelude: quotRem :: Integral a => a -> a -> (a, a)
- Polysemy.Resume.Prelude: readEither :: Read a => String -> Either Text a
- Polysemy.Resume.Prelude: readFile :: MonadIO m => FilePath -> m String
- Polysemy.Resume.Prelude: readFileBS :: MonadIO m => FilePath -> m ByteString
- Polysemy.Resume.Prelude: readFileLBS :: MonadIO m => FilePath -> m LByteString
- Polysemy.Resume.Prelude: readFileLText :: MonadIO m => FilePath -> m LText
- Polysemy.Resume.Prelude: readFileText :: MonadIO m => FilePath -> m Text
- Polysemy.Resume.Prelude: readIORef :: MonadIO m => IORef a -> m a
- Polysemy.Resume.Prelude: readMVar :: MonadIO m => MVar a -> m a
- Polysemy.Resume.Prelude: readMaybe :: Read a => String -> Maybe a
- Polysemy.Resume.Prelude: readTMVar :: TMVar a -> STM a
- Polysemy.Resume.Prelude: readTVar :: TVar a -> STM a
- Polysemy.Resume.Prelude: readTVarIO :: MonadIO m => TVar a -> m a
- Polysemy.Resume.Prelude: reader :: MonadReader r m => (r -> a) -> m a
- Polysemy.Resume.Prelude: reads :: Read a => ReadS a
- Polysemy.Resume.Prelude: realToFrac :: (Real a, Fractional b) => a -> b
- Polysemy.Resume.Prelude: recip :: Fractional a => a -> a
- Polysemy.Resume.Prelude: rem :: Integral a => a -> a -> a
- Polysemy.Resume.Prelude: repeat :: a -> [a]
- Polysemy.Resume.Prelude: replicate :: Int -> a -> [a]
- Polysemy.Resume.Prelude: replicateM :: Applicative m => Int -> m a -> m [a]
- Polysemy.Resume.Prelude: replicateM_ :: Applicative m => Int -> m a -> m ()
- Polysemy.Resume.Prelude: return :: Monad m => a -> m a
- Polysemy.Resume.Prelude: reverse :: [a] -> [a]
- Polysemy.Resume.Prelude: rightToMaybe :: Either l r -> Maybe r
- Polysemy.Resume.Prelude: rights :: [Either a b] -> [b]
- Polysemy.Resume.Prelude: rnf :: NFData a => a -> ()
- Polysemy.Resume.Prelude: round :: (RealFrac a, Integral b) => a -> b
- Polysemy.Resume.Prelude: runExceptT :: ExceptT e m a -> m (Either e a)
- Polysemy.Resume.Prelude: runReader :: Reader r a -> r -> a
- Polysemy.Resume.Prelude: runState :: State s a -> s -> (a, s)
- Polysemy.Resume.Prelude: scanl :: (b -> a -> b) -> b -> [a] -> [b]
- Polysemy.Resume.Prelude: scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- Polysemy.Resume.Prelude: scanl1 :: (a -> a -> a) -> [a] -> [a]
- Polysemy.Resume.Prelude: scanr :: (a -> b -> b) -> b -> [a] -> [b]
- Polysemy.Resume.Prelude: scanr1 :: (a -> a -> a) -> [a] -> [a]
- Polysemy.Resume.Prelude: sconcat :: Semigroup a => NonEmpty a -> a
- Polysemy.Resume.Prelude: second :: Bifunctor p => (b -> c) -> p a b -> p a c
- Polysemy.Resume.Prelude: seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
- Polysemy.Resume.Prelude: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- Polysemy.Resume.Prelude: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
- Polysemy.Resume.Prelude: sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
- Polysemy.Resume.Prelude: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- Polysemy.Resume.Prelude: show :: forall b a. (Show a, IsString b) => a -> b
- Polysemy.Resume.Prelude: showStackTrace :: IO (Maybe String)
- Polysemy.Resume.Prelude: signum :: Num a => a -> a
- Polysemy.Resume.Prelude: sin :: Floating a => a -> a
- Polysemy.Resume.Prelude: sinh :: Floating a => a -> a
- Polysemy.Resume.Prelude: snd :: (a, b) -> b
- Polysemy.Resume.Prelude: some :: Alternative f => f a -> f [a]
- Polysemy.Resume.Prelude: someNatVal :: Natural -> SomeNat
- Polysemy.Resume.Prelude: sort :: Ord a => [a] -> [a]
- Polysemy.Resume.Prelude: sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- Polysemy.Resume.Prelude: sortNub :: Ord a => [a] -> [a]
- Polysemy.Resume.Prelude: sortOn :: Ord b => (a -> b) -> [a] -> [a]
- Polysemy.Resume.Prelude: sortWith :: Ord b => (a -> b) -> [a] -> [a]
- Polysemy.Resume.Prelude: span :: (a -> Bool) -> [a] -> ([a], [a])
- Polysemy.Resume.Prelude: splitAt :: Int -> [a] -> ([a], [a])
- Polysemy.Resume.Prelude: sqrt :: Floating a => a -> a
- Polysemy.Resume.Prelude: state :: MonadState s m => (s -> (a, s)) -> m a
- Polysemy.Resume.Prelude: stderr :: Handle
- Polysemy.Resume.Prelude: stdin :: Handle
- Polysemy.Resume.Prelude: stdout :: Handle
- Polysemy.Resume.Prelude: stimes :: (Semigroup a, Integral b) => b -> a -> a
- Polysemy.Resume.Prelude: stimesIdempotent :: Integral b => b -> a -> a
- Polysemy.Resume.Prelude: stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
- Polysemy.Resume.Prelude: stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
- Polysemy.Resume.Prelude: strictDecode :: OnDecodeError
- Polysemy.Resume.Prelude: subsequences :: [a] -> [[a]]
- Polysemy.Resume.Prelude: subtract :: Num a => a -> a -> a
- Polysemy.Resume.Prelude: succ :: Enum a => a -> a
- Polysemy.Resume.Prelude: sum :: forall a f. (Foldable f, Num a) => f a -> a
- Polysemy.Resume.Prelude: swap :: (a, b) -> (b, a)
- Polysemy.Resume.Prelude: swapMVar :: MonadIO m => MVar a -> a -> m a
- Polysemy.Resume.Prelude: swapTMVar :: TMVar a -> a -> STM a
- Polysemy.Resume.Prelude: tail :: IsNonEmpty f a [a] "tail" => f a -> [a]
- Polysemy.Resume.Prelude: tails :: [a] -> [[a]]
- Polysemy.Resume.Prelude: take :: Int -> [a] -> [a]
- Polysemy.Resume.Prelude: takeMVar :: MonadIO m => MVar a -> m a
- Polysemy.Resume.Prelude: takeTMVar :: TMVar a -> STM a
- Polysemy.Resume.Prelude: takeWhile :: (a -> Bool) -> [a] -> [a]
- Polysemy.Resume.Prelude: tan :: Floating a => a -> a
- Polysemy.Resume.Prelude: tanh :: Floating a => a -> a
- Polysemy.Resume.Prelude: throwSTM :: Exception e => e -> STM a
- Polysemy.Resume.Prelude: toEnum :: Enum a => Int -> a
- Polysemy.Resume.Prelude: toException :: Exception e => e -> SomeException
- Polysemy.Resume.Prelude: toInteger :: Integral a => a -> Integer
- Polysemy.Resume.Prelude: toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
- Polysemy.Resume.Prelude: toLText :: ToLText a => a -> LText
- Polysemy.Resume.Prelude: toLazy :: LazyStrict l s => s -> l
- Polysemy.Resume.Prelude: toList :: Foldable t => t a -> [a]
- Polysemy.Resume.Prelude: toRational :: Real a => a -> Rational
- Polysemy.Resume.Prelude: toShort :: ByteString -> ShortByteString
- Polysemy.Resume.Prelude: toStrict :: LazyStrict l s => l -> s
- Polysemy.Resume.Prelude: toString :: ToString a => a -> String
- Polysemy.Resume.Prelude: toText :: ToText a => a -> Text
- Polysemy.Resume.Prelude: trace :: String -> a -> a
- Polysemy.Resume.Prelude: traceId :: String -> String
- Polysemy.Resume.Prelude: traceM :: Applicative f => String -> f ()
- Polysemy.Resume.Prelude: traceShow :: Show a => a -> b -> b
- Polysemy.Resume.Prelude: traceShowId :: Show a => a -> a
- Polysemy.Resume.Prelude: traceShowM :: (Show a, Applicative f) => a -> f ()
- Polysemy.Resume.Prelude: traceShowWith :: Show b => (a -> b) -> a -> a
- Polysemy.Resume.Prelude: transpose :: [[a]] -> [[a]]
- Polysemy.Resume.Prelude: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
- Polysemy.Resume.Prelude: traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
- Polysemy.Resume.Prelude: truncate :: (RealFrac a, Integral b) => a -> b
- Polysemy.Resume.Prelude: tryPutMVar :: MonadIO m => MVar a -> a -> m Bool
- Polysemy.Resume.Prelude: tryPutTMVar :: TMVar a -> a -> STM Bool
- Polysemy.Resume.Prelude: tryReadMVar :: MonadIO m => MVar a -> m (Maybe a)
- Polysemy.Resume.Prelude: tryReadTMVar :: TMVar a -> STM (Maybe a)
- Polysemy.Resume.Prelude: tryTakeMVar :: MonadIO m => MVar a -> m (Maybe a)
- Polysemy.Resume.Prelude: tryTakeTMVar :: TMVar a -> STM (Maybe a)
- Polysemy.Resume.Prelude: type Effect = Type -> Type -> Type -> Type
- Polysemy.Resume.Prelude: type EffectRow = [Effect]
- Polysemy.Resume.Prelude: type FilePath = String
- Polysemy.Resume.Prelude: type HasCallStack = ?callStack :: CallStack
- Polysemy.Resume.Prelude: type LByteString = ByteString
- Polysemy.Resume.Prelude: type LText = Text
- Polysemy.Resume.Prelude: type Member (e :: k) (r :: [k]) = MemberNoError e r
- Polysemy.Resume.Prelude: type OnDecodeError = OnError Word8 Char
- Polysemy.Resume.Prelude: type OnError a b = String -> Maybe a -> Maybe b
- Polysemy.Resume.Prelude: type Rational = Ratio Integer
- Polysemy.Resume.Prelude: type Reader r = ReaderT r Identity
- Polysemy.Resume.Prelude: type InterpreterFor (e :: Effect) (r :: [Effect]) = forall a. () => Sem e : r a -> Sem r a
- Polysemy.Resume.Prelude: type State s = StateT s Identity
- Polysemy.Resume.Prelude: type String = [Char]
- Polysemy.Resume.Prelude: type Type = Type
- Polysemy.Resume.Prelude: type family OneItem x;
- Polysemy.Resume.Prelude: uncons :: [a] -> Maybe (a, [a])
- Polysemy.Resume.Prelude: uncurry :: (a -> b -> c) -> (a, b) -> c
- Polysemy.Resume.Prelude: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- Polysemy.Resume.Prelude: unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- Polysemy.Resume.Prelude: universe :: (Bounded a, Enum a) => [a]
- Polysemy.Resume.Prelude: universeNonEmpty :: (Bounded a, Enum a) => NonEmpty a
- Polysemy.Resume.Prelude: unless :: Applicative f => Bool -> f () -> f ()
- Polysemy.Resume.Prelude: unlessM :: Monad m => m Bool -> m () -> m ()
- Polysemy.Resume.Prelude: unlines :: IsText t "unlines" => [t] -> t
- Polysemy.Resume.Prelude: unstableNub :: (Eq a, Hashable a) => [a] -> [a]
- Polysemy.Resume.Prelude: unwords :: IsText t "unwords" => [t] -> t
- Polysemy.Resume.Prelude: unzip :: [(a, b)] -> ([a], [b])
- Polysemy.Resume.Prelude: unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- Polysemy.Resume.Prelude: usingReader :: r -> Reader r a -> a
- Polysemy.Resume.Prelude: usingReaderT :: r -> ReaderT r m a -> m a
- Polysemy.Resume.Prelude: usingState :: s -> State s a -> (a, s)
- Polysemy.Resume.Prelude: usingStateT :: s -> StateT s m a -> m (a, s)
- Polysemy.Resume.Prelude: vacuous :: Functor f => f Void -> f a
- Polysemy.Resume.Prelude: viaNonEmpty :: (NonEmpty a -> b) -> [a] -> Maybe b
- Polysemy.Resume.Prelude: void :: Functor f => f a -> f ()
- Polysemy.Resume.Prelude: when :: Applicative f => Bool -> f () -> f ()
- Polysemy.Resume.Prelude: whenJust :: Applicative f => Maybe a -> (a -> f ()) -> f ()
- Polysemy.Resume.Prelude: whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
- Polysemy.Resume.Prelude: whenLeft :: Applicative f => a -> Either l r -> (l -> f a) -> f a
- Polysemy.Resume.Prelude: whenLeftM :: Monad m => a -> m (Either l r) -> (l -> m a) -> m a
- Polysemy.Resume.Prelude: whenLeftM_ :: Monad m => m (Either l r) -> (l -> m ()) -> m ()
- Polysemy.Resume.Prelude: whenLeft_ :: Applicative f => Either l r -> (l -> f ()) -> f ()
- Polysemy.Resume.Prelude: whenM :: Monad m => m Bool -> m () -> m ()
- Polysemy.Resume.Prelude: whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f ()
- Polysemy.Resume.Prelude: whenNotNullM :: Monad m => m [a] -> (NonEmpty a -> m ()) -> m ()
- Polysemy.Resume.Prelude: whenNothing :: Applicative f => Maybe a -> f a -> f a
- Polysemy.Resume.Prelude: whenNothingM :: Monad m => m (Maybe a) -> m a -> m a
- Polysemy.Resume.Prelude: whenNothingM_ :: Monad m => m (Maybe a) -> m () -> m ()
- Polysemy.Resume.Prelude: whenNothing_ :: Applicative f => Maybe a -> f () -> f ()
- Polysemy.Resume.Prelude: whenRight :: Applicative f => a -> Either l r -> (r -> f a) -> f a
- Polysemy.Resume.Prelude: whenRightM :: Monad m => a -> m (Either l r) -> (r -> m a) -> m a
- Polysemy.Resume.Prelude: whenRightM_ :: Monad m => m (Either l r) -> (r -> m ()) -> m ()
- Polysemy.Resume.Prelude: whenRight_ :: Applicative f => Either l r -> (r -> f ()) -> f ()
- Polysemy.Resume.Prelude: withFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
- Polysemy.Resume.Prelude: withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
- Polysemy.Resume.Prelude: withReader :: (r' -> r) -> Reader r a -> Reader r' a
- Polysemy.Resume.Prelude: withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a
- Polysemy.Resume.Prelude: withState :: (s -> s) -> State s a -> State s a
- Polysemy.Resume.Prelude: words :: IsText t "words" => t -> [t]
- Polysemy.Resume.Prelude: writeFile :: MonadIO m => FilePath -> String -> m ()
- Polysemy.Resume.Prelude: writeFileBS :: MonadIO m => FilePath -> ByteString -> m ()
- Polysemy.Resume.Prelude: writeFileLBS :: MonadIO m => FilePath -> LByteString -> m ()
- Polysemy.Resume.Prelude: writeFileLText :: MonadIO m => FilePath -> LText -> m ()
- Polysemy.Resume.Prelude: writeFileText :: MonadIO m => FilePath -> Text -> m ()
- Polysemy.Resume.Prelude: writeIORef :: MonadIO m => IORef a -> a -> m ()
- Polysemy.Resume.Prelude: writeTVar :: TVar a -> a -> STM ()
- Polysemy.Resume.Prelude: xor :: Bits a => a -> a -> a
- Polysemy.Resume.Prelude: zip :: [a] -> [b] -> [(a, b)]
- Polysemy.Resume.Prelude: zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- Polysemy.Resume.Prelude: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- Polysemy.Resume.Prelude: zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- Polysemy.Resume.Prelude: zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- Polysemy.Resume.Prelude: }
- Polysemy.Resume: stop :: forall e_a9pC r_aaFs a_a9pE. MemberWithError (Stop e_a9pC) r_aaFs => e_a9pC -> Sem r_aaFs a_a9pE
+ Polysemy.Resume: stop :: forall e_a4zT r_a5O5 a_a4zV. MemberWithError (Stop e_a4zT) r_a5O5 => e_a4zT -> Sem r_a5O5 a_a4zV
Files
- Setup.hs +2/−0
- lib/Polysemy/Resume/Data/Stop.hs +3/−2
- lib/Polysemy/Resume/Prelude.hs +0/−13
- lib/Polysemy/Resume/Resumable.hs +7/−11
- lib/Polysemy/Resume/Resume.hs +1/−3
- lib/Polysemy/Resume/Stop.hs +7/−8
- lib/Prelude.hs +0/−5
- polysemy-resume.cabal +7/−14
- test/Polysemy/Resume/ExampleTest.hs +2/−2
- test/Polysemy/Resume/HigherOrderTest.hs +8/−16
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
lib/Polysemy/Resume/Data/Stop.hs view
@@ -1,8 +1,8 @@+{-# options_haddock prune #-}+ -- |Description: Internal module Polysemy.Resume.Data.Stop where -import Polysemy (makeSem)- -- |An effect similar to 'Polysemy.Error.Error' without the ability to be caught. -- Used to signal that an error is supposed to be expected by dependent programs. --@@ -16,6 +16,7 @@ -- StopBoom -> stop (Boom "ouch") -- @ data Stop e :: Effect where+ -- |Abort a computation with an error value. Stop :: e -> Stop e m a makeSem ''Stop
− lib/Polysemy/Resume/Prelude.hs
@@ -1,13 +0,0 @@-{-# LANGUAGE NoImplicitPrelude #-}--module Polysemy.Resume.Prelude (- module GHC.Err,- module Polysemy,- module Polysemy.Error,- module Relude,-) where--import GHC.Err (undefined)-import Polysemy (Effect, EffectRow, InterpreterFor, Member, Members, Sem)-import Polysemy.Error (Error)-import Relude hiding (undefined)
lib/Polysemy/Resume/Resumable.hs view
@@ -1,8 +1,8 @@+{-# options_ghc -Wno-redundant-constraints #-}+ module Polysemy.Resume.Resumable where -import Polysemy (Final, Tactical)-import Polysemy.Error (Error (Throw), catchJust)-import Polysemy.Internal (Sem (Sem, runSem), liftSem, raise, raiseUnder, send, usingSem)+import Polysemy.Internal (Sem (Sem, runSem), liftSem, usingSem) import Polysemy.Internal.CustomErrors (FirstOrder) import Polysemy.Internal.Tactics (liftT, runTactics) import Polysemy.Internal.Union (Weaving (Weaving), decomp, hoist, inj, injWeaving, weave)@@ -38,7 +38,7 @@ -- * the interpreter is wrapped with actions of another effect, as in: -- -- @--- interpretEffResumable :: InterpreterFor Eff r+-- interpretEff :: InterpreterFor Eff r -- ... -- -- interpretEffResumable :: InterpreterFor (Resumable Text Eff) r@@ -69,9 +69,6 @@ runStop $ interpreter $ liftSem $ weave s (raise . raise . wv) ins (injWeaving e) Left g -> k g- -- where- -- int =- -- runSem . interpreter {-# inline resumable #-} -- |Convenience combinator for turning an interpreter that doesn't use 'Stop' into a 'Resumable'.@@ -123,17 +120,16 @@ Left there -> k (hoist (interpretResumableH handler) there) Right (Weaving (Resumable (Weaving e s dist ex ins)) sOuter distOuter exOuter insOuter) ->- usingSem k (exFinal <$> runStop tac)+ usingSem k (exFinal <$> runStop (tac (handler e))) where tac = runTactics (Compose (s <$ sOuter)) (raiseUnder . fmap Compose . distOuter . fmap dist . getCompose)- (join . fmap ins . insOuter . getCompose)+ (ins <=< insOuter . getCompose) (raise . interpretResumableH handler . fmap Compose . distOuter . fmap dist . getCompose)- (handler e) exFinal = exOuter . \case- Right (getCompose -> a) -> Right . ex <$> a+ Right (Compose a) -> Right . ex <$> a Left err -> Left err <$ sOuter {-# inline interpretResumableH #-}
lib/Polysemy/Resume/Resume.hs view
@@ -1,7 +1,5 @@+-- |Resumption combinators, transforming an effect into 'Resumable' and 'Stop'. module Polysemy.Resume.Resume where--import Polysemy (raiseUnder, raiseUnder2)-import Polysemy.Error (throw) import Polysemy.Resume.Data.Resumable (Resumable) import Polysemy.Resume.Data.Stop (Stop, stop)
lib/Polysemy/Resume/Stop.hs view
@@ -1,16 +1,15 @@ module Polysemy.Resume.Stop where -import Control.Exception (throwIO, try)-import Control.Monad.Trans.Except (throwE)+import qualified Control.Exception as Base+import Control.Exception (throwIO)+import Control.Monad.Trans.Except (ExceptT (ExceptT), runExceptT, throwE) import Data.Typeable (typeRep)-import Polysemy (Final)-import Polysemy.Error (runError, throw) import Polysemy.Final (getInitialStateS, interpretFinal, runS, withStrategicToFinal)-import Polysemy.Internal (Sem(Sem), send, usingSem)-import Polysemy.Internal.Union (Weaving(Weaving), decomp, hoist, weave)+import Polysemy.Internal (Sem (Sem), usingSem)+import Polysemy.Internal.Union (Weaving (Weaving), decomp, hoist, weave) import qualified Text.Show -import Polysemy.Resume.Data.Stop (Stop(Stop), stop)+import Polysemy.Resume.Data.Stop (Stop (Stop), stop) hush :: Either e a -> Maybe a hush (Right a) = Just a@@ -67,7 +66,7 @@ withStrategicToFinal @IO do m' <- runS (runStopAsExcFinal sem) s <- getInitialStateS- pure $ either ((<$ s) . Left . unStopExc) (fmap Right) <$> try m'+ pure $ either ((<$ s) . Left . unStopExc) (fmap Right) <$> Base.try m' {-# inline stopToIOFinal #-} -- |Stop if the argument is 'Left', transforming the error with @f@.
− lib/Prelude.hs
@@ -1,5 +0,0 @@-module Prelude (- module Polysemy.Resume.Prelude,-) where--import Polysemy.Resume.Prelude
polysemy-resume.cabal view
@@ -1,11 +1,11 @@ cabal-version: 2.2 --- This file has been generated from package.yaml by hpack version 0.34.4.+-- This file has been generated from package.yaml by hpack version 0.34.6. -- -- see: https://github.com/sol/hpack name: polysemy-resume-version: 0.2.0.0+version: 0.3.0.0 synopsis: Polysemy error tracking description: Please see the readme on Github at <https://github.com/tek/polysemy-resume> category: Experimental@@ -24,15 +24,9 @@ Polysemy.Resume Polysemy.Resume.Data.Resumable Polysemy.Resume.Data.Stop- Polysemy.Resume.Prelude Polysemy.Resume.Resumable Polysemy.Resume.Resume Polysemy.Resume.Stop- other-modules:- Prelude- Paths_polysemy_resume- autogen-modules:- Paths_polysemy_resume hs-source-dirs: lib default-extensions:@@ -96,8 +90,8 @@ ghc-options: -flate-specialise -fspecialise-aggressively -Wall build-depends: base ==4.*- , polysemy >=1.5- , relude >=0.7+ , incipit-core >=0.1+ , polysemy >=1.6 , transformers mixins: base hiding (Prelude)@@ -109,7 +103,6 @@ other-modules: Polysemy.Resume.ExampleTest Polysemy.Resume.HigherOrderTest- Paths_polysemy_resume hs-source-dirs: test default-extensions:@@ -170,19 +163,19 @@ UndecidableInstances UnicodeSyntax ViewPatterns- ghc-options: -flate-specialise -fspecialise-aggressively -Wall -threaded -rtsopts -with-rtsopts=-N -fplugin=Polysemy.Plugin+ ghc-options: -flate-specialise -fspecialise-aggressively -Wall -threaded -rtsopts -with-rtsopts=-N build-depends: base ==4.* , hedgehog+ , incipit-core , polysemy , polysemy-plugin , polysemy-resume , polysemy-test+ , stm , tasty , tasty-hedgehog , text mixins: base hiding (Prelude)- , polysemy-resume hiding (Prelude)- , polysemy-resume (Polysemy.Resume.Prelude as Prelude) default-language: Haskell2010
test/Polysemy/Resume/ExampleTest.hs view
@@ -1,9 +1,9 @@+{-# options_ghc -fplugin=Polysemy.Plugin #-}+ module Polysemy.Resume.ExampleTest where -import Polysemy (interpret, makeSem) import Polysemy.Test (UnitTest, assertRight, runTestAuto, (===)) -import Polysemy.Error (runError) import Polysemy.Resume (Stop, resumable, resumableFor, resume, stop, type (!!)) data Stopper :: Effect where
test/Polysemy/Resume/HigherOrderTest.hs view
@@ -1,22 +1,14 @@-{-# options_ghc -Wno-all #-}+{-# options_ghc -fplugin=Polysemy.Plugin #-} module Polysemy.Resume.HigherOrderTest where -import Polysemy (makeSem, pureT, raise, raiseUnder, runT)-import Polysemy.AtomicState (- AtomicState,- atomicModify,- runAtomicStateTVar,- )-import Polysemy.Resource (Resource, finally)-import Polysemy.Resume (type (!!))-import Polysemy.Resume.Data.Stop (stop)-import Polysemy.Resume.Resumable (interpretResumable, interpretResumableH)-import Polysemy.Resume.Resume (restop, resume)+import Control.Concurrent.STM (newTVarIO, readTVarIO) import Polysemy.Test (UnitTest, runTestAuto, (===)) -import Polysemy.Resume.Data.Stop (Stop)-import Polysemy.Resume.Stop (stopNote)+import Polysemy.Resume (type (!!))+import Polysemy.Resume.Data.Stop (stop)+import Polysemy.Resume.Resumable (interpretResumableH)+import Polysemy.Resume.Resume (resume) data Eff :: Effect where Nest :: m a -> Eff m a@@ -66,9 +58,9 @@ test_switchInterpreter :: UnitTest test_switchInterpreter = runTestAuto do- tv <- newTVarIO 0+ tv <- embed (newTVarIO 0) (2 ===) =<< runAtomicStateTVar tv (interpretEffFinally (resume (nest (result >> result)) \ _ -> pure 3))- (1 ===) =<< readTVarIO tv+ (1 ===) =<< embed (readTVarIO tv) (3 ===) =<< interpretEff (resume (nest (nest result)) \ _ -> pure 3) (1 ===) =<< interpretEff (resume result \ _ -> pure 3) -- (2 ===) =<< interpretEff (interpretOff (resume off \ _ -> pure 3))