Zerem

Purpose

.

data Zerem f m r

The stream datatype. It consists of a state machine, and an action that yields the initial state.

Constructors

forall s. Zerem (s -> m (Step s f r)) (m s)

Instances

MFunctor (Zerem f :: (Type -> Type) -> Type -> Type)

Defined in Zerem

Methods

hoist :: forall m n (b :: k). Monad m => (forall a. m a -> n a) -> Zerem f m b -> Zerem f n b

MonadTrans (Zerem a)

Defined in Zerem

Methods

lift :: Monad m => m a0 -> Zerem a m a0

(Functor f, Monad m) => Applicative (Zerem f m)

Not lazy on its arguments. If you use something like:

as = yield a *> as

the program will go into an infinite loop.

For that kind of construction, consider using functions from the Generating section, or simply writing a stream by hand:

as = Zerem next (pure a) where
  next a = pure $ Z.Yield (a, a)

Defined in Zerem

Methods

pure :: a -> Zerem f m a

(<*>) :: Zerem f m (a -> b) -> Zerem f m a -> Zerem f m b

liftA2 :: (a -> b -> c) -> Zerem f m a -> Zerem f m b -> Zerem f m c

(*>) :: Zerem f m a -> Zerem f m b -> Zerem f m b

(<*) :: Zerem f m a -> Zerem f m b -> Zerem f m a

Functor m => Functor (Zerem f m)

Defined in Zerem

Methods

fmap :: (a -> b) -> Zerem f m a -> Zerem f m b

(<$) :: a -> Zerem f m b -> Zerem f m a

(Functor f, Monad m) => Monad (Zerem f m)

Defined in Zerem

Methods

(>>=) :: Zerem f m a -> (a -> Zerem f m b) -> Zerem f m b

(>>) :: Zerem f m a -> Zerem f m b -> Zerem f m b

return :: a -> Zerem f m a

(Functor f, Monad m) => Monoid (Zerem f m ())

Defined in Zerem

Methods

mempty :: Zerem f m ()

mappend :: Zerem f m () -> Zerem f m () -> Zerem f m ()

mconcat :: [Zerem f m ()] -> Zerem f m ()

(Functor f, Monad m) => Semigroup (Zerem f m r)

Defined in Zerem

Methods

(<>) :: Zerem f m r -> Zerem f m r -> Zerem f m r

sconcat :: NonEmpty (Zerem f m r) -> Zerem f m r

stimes :: Integral b => b -> Zerem f m r -> Zerem f m r

data Step s f r

Constructors

Done r

Stream is over and r is the result.

Skip s

Stream is transitioning state without yielding.

Yield !(f s)

Stream yields a functor. Usually (a, s).

Instances

Foldable (Step s f)

Defined in Zerem

Methods

fold :: Monoid m => Step s f m -> m

foldMap :: Monoid m => (a -> m) -> Step s f a -> m

foldMap' :: Monoid m => (a -> m) -> Step s f a -> m

foldr :: (a -> b -> b) -> b -> Step s f a -> b

foldr' :: (a -> b -> b) -> b -> Step s f a -> b

foldl :: (b -> a -> b) -> b -> Step s f a -> b

foldl' :: (b -> a -> b) -> b -> Step s f a -> b

foldr1 :: (a -> a -> a) -> Step s f a -> a

foldl1 :: (a -> a -> a) -> Step s f a -> a

toList :: Step s f a -> [a]

null :: Step s f a -> Bool

length :: Step s f a -> Int

elem :: Eq a => a -> Step s f a -> Bool

maximum :: Ord a => Step s f a -> a

minimum :: Ord a => Step s f a -> a

sum :: Num a => Step s f a -> a

product :: Num a => Step s f a -> a

Traversable (Step s f)

Defined in Zerem

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Step s f a -> f0 (Step s f b)

sequenceA :: Applicative f0 => Step s f (f0 a) -> f0 (Step s f a)

mapM :: Monad m => (a -> m b) -> Step s f a -> m (Step s f b)

sequence :: Monad m => Step s f (m a) -> m (Step s f a)

Functor (Step s f)

Defined in Zerem

Methods

fmap :: (a -> b) -> Step s f a -> Step s f b

(<$) :: a -> Step s f b -> Step s f a

next :: (Functor f, Monad m) => Zerem f m r -> m (Either r (f (Zerem f m r)))

next_ :: (Functor f, Monad m) => Zerem f m r -> m (Maybe (f (Zerem f m r)))

data InitZerem f m r

Constructors

forall s. InitZerem (s -> m (Step s f r)) s

initZerem :: Monad m => Zerem f m r -> m (InitZerem f m r)

newtype ZipZerem r m a

Constructors

ZipZerem

Fields

• runZipZerem :: Zerem ((,) a) m r

Instances

MFunctor (ZipZerem r :: (Type -> Type) -> Type -> Type)

Defined in Zerem

Methods

hoist :: forall m n (b :: k). Monad m => (forall a. m a -> n a) -> ZipZerem r m b -> ZipZerem r n b

MonadTrans (ZipZerem Void)

Defined in Zerem

Methods

lift :: Monad m => m a -> ZipZerem Void m a

Foldable (ZipZerem r Identity)

Defined in Zerem

Methods

fold :: Monoid m => ZipZerem r Identity m -> m

foldMap :: Monoid m => (a -> m) -> ZipZerem r Identity a -> m

foldMap' :: Monoid m => (a -> m) -> ZipZerem r Identity a -> m

foldr :: (a -> b -> b) -> b -> ZipZerem r Identity a -> b

foldr' :: (a -> b -> b) -> b -> ZipZerem r Identity a -> b

foldl :: (b -> a -> b) -> b -> ZipZerem r Identity a -> b

foldl' :: (b -> a -> b) -> b -> ZipZerem r Identity a -> b

foldr1 :: (a -> a -> a) -> ZipZerem r Identity a -> a

foldl1 :: (a -> a -> a) -> ZipZerem r Identity a -> a

toList :: ZipZerem r Identity a -> [a]

null :: ZipZerem r Identity a -> Bool

length :: ZipZerem r Identity a -> Int

elem :: Eq a => a -> ZipZerem r Identity a -> Bool

maximum :: Ord a => ZipZerem r Identity a -> a

minimum :: Ord a => ZipZerem r Identity a -> a

sum :: Num a => ZipZerem r Identity a -> a

product :: Num a => ZipZerem r Identity a -> a

Traversable (ZipZerem () Identity)

Defined in Zerem

Methods

traverse :: Applicative f => (a -> f b) -> ZipZerem () Identity a -> f (ZipZerem () Identity b)

sequenceA :: Applicative f => ZipZerem () Identity (f a) -> f (ZipZerem () Identity a)

mapM :: Monad m => (a -> m b) -> ZipZerem () Identity a -> m (ZipZerem () Identity b)

sequence :: Monad m => ZipZerem () Identity (m a) -> m (ZipZerem () Identity a)

Monad m => Alternative (ZipZerem () m)

Defined in Zerem

Methods

empty :: ZipZerem () m a

(<|>) :: ZipZerem () m a -> ZipZerem () m a -> ZipZerem () m a

some :: ZipZerem () m a -> ZipZerem () m [a]

many :: ZipZerem () m a -> ZipZerem () m [a]

Applicative (ZipZerem Void Identity)

Defined in Zerem

Methods

pure :: a -> ZipZerem Void Identity a

(<*>) :: ZipZerem Void Identity (a -> b) -> ZipZerem Void Identity a -> ZipZerem Void Identity b

liftA2 :: (a -> b -> c) -> ZipZerem Void Identity a -> ZipZerem Void Identity b -> ZipZerem Void Identity c

(*>) :: ZipZerem Void Identity a -> ZipZerem Void Identity b -> ZipZerem Void Identity b

(<*) :: ZipZerem Void Identity a -> ZipZerem Void Identity b -> ZipZerem Void Identity a

Monad m => Applicative (ZipZerem r m)

Defined in Zerem

Methods

pure :: a -> ZipZerem r m a

(<*>) :: ZipZerem r m (a -> b) -> ZipZerem r m a -> ZipZerem r m b

liftA2 :: (a -> b -> c) -> ZipZerem r m a -> ZipZerem r m b -> ZipZerem r m c

(*>) :: ZipZerem r m a -> ZipZerem r m b -> ZipZerem r m b

(<*) :: ZipZerem r m a -> ZipZerem r m b -> ZipZerem r m a

Functor m => Functor (ZipZerem r m)

Defined in Zerem

Methods

fmap :: (a -> b) -> ZipZerem r m a -> ZipZerem r m b

(<$) :: a -> ZipZerem r m b -> ZipZerem r m a

Monad (ZipZerem Void Identity)

Defined in Zerem

Methods

(>>=) :: ZipZerem Void Identity a -> (a -> ZipZerem Void Identity b) -> ZipZerem Void Identity b

(>>) :: ZipZerem Void Identity a -> ZipZerem Void Identity b -> ZipZerem Void Identity b

return :: a -> ZipZerem Void Identity a

Comonad (ZipZerem Void Identity)

Defined in Zerem

Methods

extract :: ZipZerem Void Identity a -> a

duplicate :: ZipZerem Void Identity a -> ZipZerem Void Identity (ZipZerem Void Identity a)

extend :: (ZipZerem Void Identity a -> b) -> ZipZerem Void Identity a -> ZipZerem Void Identity b

ComonadApply (ZipZerem Void Identity)

Defined in Zerem

Methods

(<@>) :: ZipZerem Void Identity (a -> b) -> ZipZerem Void Identity a -> ZipZerem Void Identity b

(@>) :: ZipZerem Void Identity a -> ZipZerem Void Identity b -> ZipZerem Void Identity b

(<@) :: ZipZerem Void Identity a -> ZipZerem Void Identity b -> ZipZerem Void Identity a

newtype ListZerem r m a

Constructors

ListZerem

Fields

• runListZerem :: Zerem ((,) a) m r

Instances

MFunctor (ListZerem r :: (Type -> Type) -> Type -> Type)

Defined in Zerem

Methods

hoist :: forall m n (b :: k). Monad m => (forall a. m a -> n a) -> ListZerem r m b -> ListZerem r n b

MonadTrans (ListZerem ())

Defined in Zerem

Methods

lift :: Monad m => m a -> ListZerem () m a

Foldable (ListZerem r Identity)

Defined in Zerem

Methods

fold :: Monoid m => ListZerem r Identity m -> m

foldMap :: Monoid m => (a -> m) -> ListZerem r Identity a -> m

foldMap' :: Monoid m => (a -> m) -> ListZerem r Identity a -> m

foldr :: (a -> b -> b) -> b -> ListZerem r Identity a -> b

foldr' :: (a -> b -> b) -> b -> ListZerem r Identity a -> b

foldl :: (b -> a -> b) -> b -> ListZerem r Identity a -> b

foldl' :: (b -> a -> b) -> b -> ListZerem r Identity a -> b

foldr1 :: (a -> a -> a) -> ListZerem r Identity a -> a

foldl1 :: (a -> a -> a) -> ListZerem r Identity a -> a

toList :: ListZerem r Identity a -> [a]

null :: ListZerem r Identity a -> Bool

length :: ListZerem r Identity a -> Int

elem :: Eq a => a -> ListZerem r Identity a -> Bool

maximum :: Ord a => ListZerem r Identity a -> a

minimum :: Ord a => ListZerem r Identity a -> a

sum :: Num a => ListZerem r Identity a -> a

product :: Num a => ListZerem r Identity a -> a

Traversable (ListZerem () Identity)

Defined in Zerem

Methods

traverse :: Applicative f => (a -> f b) -> ListZerem () Identity a -> f (ListZerem () Identity b)

sequenceA :: Applicative f => ListZerem () Identity (f a) -> f (ListZerem () Identity a)

mapM :: Monad m => (a -> m b) -> ListZerem () Identity a -> m (ListZerem () Identity b)

sequence :: Monad m => ListZerem () Identity (m a) -> m (ListZerem () Identity a)

Monad m => Alternative (ListZerem () m)

Defined in Zerem

Methods

empty :: ListZerem () m a

(<|>) :: ListZerem () m a -> ListZerem () m a -> ListZerem () m a

some :: ListZerem () m a -> ListZerem () m [a]

many :: ListZerem () m a -> ListZerem () m [a]

Monad m => Applicative (ListZerem () m)

Defined in Zerem

Methods

pure :: a -> ListZerem () m a

(<*>) :: ListZerem () m (a -> b) -> ListZerem () m a -> ListZerem () m b

liftA2 :: (a -> b -> c) -> ListZerem () m a -> ListZerem () m b -> ListZerem () m c

(*>) :: ListZerem () m a -> ListZerem () m b -> ListZerem () m b

(<*) :: ListZerem () m a -> ListZerem () m b -> ListZerem () m a

Functor m => Functor (ListZerem r m)

Defined in Zerem

Methods

fmap :: (a -> b) -> ListZerem r m a -> ListZerem r m b

(<$) :: a -> ListZerem r m b -> ListZerem r m a

Monad m => Monad (ListZerem () m)

Defined in Zerem

Methods

(>>=) :: ListZerem () m a -> (a -> ListZerem () m b) -> ListZerem () m b

(>>) :: ListZerem () m a -> ListZerem () m b -> ListZerem () m b

return :: a -> ListZerem () m a

Monad m => MonadPlus (ListZerem () m)

Defined in Zerem

Methods

mzero :: ListZerem () m a

mplus :: ListZerem () m a -> ListZerem () m a -> ListZerem () m a

Comonad (ListZerem Void Identity)

Defined in Zerem

Methods

extract :: ListZerem Void Identity a -> a

duplicate :: ListZerem Void Identity a -> ListZerem Void Identity (ListZerem Void Identity a)

extend :: (ListZerem Void Identity a -> b) -> ListZerem Void Identity a -> ListZerem Void Identity b

Monad m => MonadLogic (ListZerem () m)

Defined in Zerem

Methods

msplit :: ListZerem () m a -> ListZerem () m (Maybe (a, ListZerem () m a))

interleave :: ListZerem () m a -> ListZerem () m a -> ListZerem () m a

(>>-) :: ListZerem () m a -> (a -> ListZerem () m b) -> ListZerem () m b

once :: ListZerem () m a -> ListZerem () m a

lnot :: ListZerem () m a -> ListZerem () m ()

ifte :: ListZerem () m a -> (a -> ListZerem () m b) -> ListZerem () m b -> ListZerem () m b

newtype Pipe u v f g m p a b

Constructors

Pipe

Fields

• runPipe :: p (Zerem (f a) m u) (Zerem (g b) m v)

Instances

ProfunctorFunctor (Pipe u v f g m :: (Type -> Type -> Type) -> Type -> Type -> Type)

Defined in Zerem

Methods

promap :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type). Profunctor p => (p :-> q) -> Pipe u v f g m p :-> Pipe u v f g m q

Category p => Category (Pipe u u f f m p :: Type -> Type -> Type)

Defined in Zerem

Methods

id :: forall (a :: k). Pipe u u f f m p a a

(.) :: forall (b :: k) (c :: k) (a :: k). Pipe u u f f m p b c -> Pipe u u f f m p a b -> Pipe u u f f m p a c

ProfunctorMonad (Pipe Void Void (,) (,) Identity)

Defined in Zerem

Methods

proreturn :: forall (p :: Type -> Type -> Type). Profunctor p => p :-> Pipe Void Void (,) (,) Identity p

projoin :: forall (p :: Type -> Type -> Type). Profunctor p => Pipe Void Void (,) (,) Identity (Pipe Void Void (,) (,) Identity p) :-> Pipe Void Void (,) (,) Identity p

(Profunctor p, Bifunctor g, Functor m) => Choice (Pipe u v (,) g m p)

Defined in Zerem

Methods

left' :: Pipe u v (,) g m p a b -> Pipe u v (,) g m p (Either a c) (Either b c)

right' :: Pipe u v (,) g m p a b -> Pipe u v (,) g m p (Either c a) (Either c b)

(Profunctor p, Bifunctor f, Bifunctor g, Functor m) => Profunctor (Pipe u v f g m p)

Defined in Zerem

Methods

dimap :: (a -> b) -> (c -> d) -> Pipe u v f g m p b c -> Pipe u v f g m p a d

lmap :: (a -> b) -> Pipe u v f g m p b c -> Pipe u v f g m p a c

rmap :: (b -> c) -> Pipe u v f g m p a b -> Pipe u v f g m p a c

(#.) :: forall a b c q. Coercible c b => q b c -> Pipe u v f g m p a b -> Pipe u v f g m p a c

(.#) :: forall a b c q. Coercible b a => Pipe u v f g m p b c -> q a b -> Pipe u v f g m p a c

(Profunctor p, Bifunctor g, Functor m) => Functor (Pipe u v f g m p a)

Defined in Zerem

Methods

fmap :: (a0 -> b) -> Pipe u v f g m p a a0 -> Pipe u v f g m p a b

(<$) :: a0 -> Pipe u v f g m p a b -> Pipe u v f g m p a a0

Mapping

map :: (Bifunctor f, Functor m) => (a -> b) -> Zerem (f a) m r -> Zerem (f b) m r

maps :: Functor m => (forall x. f x -> g x) -> Zerem f m r -> Zerem g m r

mapM :: (Bitraversable f, Monad m) => (a -> m b) -> Zerem (f a) m r -> Zerem (f b) m r

mapsM :: Monad m => (forall x. f x -> m (g x)) -> Zerem f m r -> Zerem g m r

flatLift :: Monad m => Zerem f m (m r) -> Zerem f m r

flatMapLift :: Monad m => (r -> m r') -> Zerem f m r -> Zerem f m r'

(>>^) :: Monad m => Zerem f m r -> (r -> m r') -> Zerem f m r'

hoistAny :: (forall x. m x -> n x) -> Zerem f m r -> Zerem f n r

Folding

runZerem :: Monad m => Zerem m m r -> m r

runZerem_ :: Monad m => Zerem m m r -> m ()

map_ :: (Comonad f, Monad m) => Zerem f m r -> m r

maps_ :: Monad m => (forall x. f x -> x) -> Zerem f m r -> m r

mapM_ :: (Bitraversable f, Comonad (f b), Monad m) => (a -> m b) -> Zerem (f a) m r -> m r

mapsM_ :: Monad m => (forall x. f x -> m x) -> Zerem f m r -> m r

foldr :: Monad m => (a -> b -> b) -> (r -> b) -> Zerem ((,) a) m r -> m b

foldr_ :: Monad m => (a -> b -> b) -> b -> Zerem ((,) a) m r -> m b

foldrM :: Monad m => (a -> b -> m b) -> (r -> m b) -> Zerem ((,) a) m r -> m b

foldrM_ :: Monad m => (a -> b -> m b) -> m b -> Zerem ((,) a) m r -> m b

foldl :: Monad m => (b -> a -> b) -> b -> (b -> r -> b') -> Zerem ((,) a) m r -> m b'

foldl_ :: Monad m => (b -> a -> b) -> b -> Zerem ((,) a) m r -> m b

foldlM :: Monad m => (b -> a -> m b) -> m b -> (b -> r -> m b') -> Zerem ((,) a) m r -> m b'

foldlM_ :: Monad m => (b -> a -> m b) -> m b -> Zerem ((,) a) m r -> m b

Scanning

scanl :: (Functor m, Functor g) => (a -> x -> g x) -> x -> (r -> x -> x') -> Zerem ((,) a) m r -> Zerem g m x'

scanl_ :: (Functor m, Functor g) => (a -> x -> g x) -> x -> Zerem ((,) a) m r -> Zerem g m x

scansl :: (Functor f, Functor m) => (forall s. f (s, x) -> g (s, x)) -> x -> (r -> x -> x') -> Zerem f m r -> Zerem g m x'

scansl_ :: (Functor f, Functor m) => (forall s. f (s, x) -> g (s, x)) -> x -> Zerem f m r -> Zerem g m x

Filtering

scanMaybel :: Functor m => (a -> x -> (Maybe b, x)) -> x -> (r -> x -> x') -> Zerem ((,) a) m r -> Zerem ((,) b) m x'

scanMaybel_ :: Functor m => (a -> x -> (Maybe b, x)) -> x -> Zerem ((,) a) m r -> Zerem ((,) b) m x

catMaybes :: Functor m => Zerem ((,) (Maybe a)) m r -> Zerem ((,) a) m r

mapMaybe :: Functor m => (a -> Maybe b) -> Zerem ((,) a) m r -> Zerem ((,) b) m r

concat :: Applicative m => Zerem ((,) [a]) m r -> Zerem ((,) a) m r

concatMap :: Applicative m => (a -> [b]) -> Zerem ((,) a) m r -> Zerem ((,) b) m r

filter :: Functor m => (a -> Bool) -> Zerem ((,) a) m r -> Zerem ((,) a) m r

take :: (Functor f, Applicative m) => Int -> Zerem f m r -> Zerem f m ()

drop :: (Comonad f, Functor m) => Int -> Zerem f m r -> Zerem f m r

Generating

yield :: Applicative m => a -> Zerem ((,) a) m ()

yieldMany :: (Foldable f, Applicative m) => f a -> Zerem ((,) a) m ()

yieldM :: Applicative m => m a -> Zerem ((,) a) m ()

yieldManyM :: (Foldable f, Applicative m) => f (m a) -> Zerem ((,) a) m ()

concatStream :: (Functor m, Functor g) => (s -> m (Step s g u)) -> Zerem ((,) s) m r -> Zerem g m r

mtimes :: (Monad m, Functor f) => Int -> Zerem f m r -> Zerem f m ()