Data.Fold.L
data L a b Source #
A Moore Machine
Constructors
Defined in Data.Fold.L
Methods
dimap :: (a -> b) -> (c -> d) -> L b c -> L a d #
lmap :: (a -> b) -> L b c -> L a c #
rmap :: (b -> c) -> L a b -> L a c #
(#.) :: forall a b c q. Coercible c b => q b c -> L a b -> L a c #
(.#) :: forall a b c q. Coercible b a => L b c -> q a b -> L a c #
unfirst :: L (a, d) (b, d) -> L a b #
unsecond :: L (d, a) (d, b) -> L a b #
Associated Types
type Corep L :: Type -> Type #
cotabulate :: (Corep L d -> c) -> L d c #
left' :: L a b -> L (Either a c) (Either b c) #
right' :: L a b -> L (Either c a) (Either c b) #
closed :: L a b -> L (x -> a) (x -> b) #
efficient prefix, leaky postfix
prefix
postfix
prefix :: Foldable t => t a -> L a b -> L a b Source #
prefixOf :: Fold s a -> s -> L a b -> L a b Source #
postfix :: Foldable t => L a b -> t a -> L a b Source #
postfixOf :: Fold s a -> L a b -> s -> L a b Source #
run :: Foldable t => t a -> L a b -> b Source #
runOf :: Fold s a -> s -> L a b -> b Source #
filtering :: (a -> Bool) -> L a b -> L a b Source #
prefix1 :: a -> L a b -> L a b Source #
postfix1 :: L a b -> a -> L a b Source #
run1 :: a -> L a b -> b Source #
interspersing :: a -> L a b -> L a b Source #
We can convert from a lazy left folding to a strict left folding.
Defined in Data.Fold
asL' :: L a b -> L' a b Source #
asL1' :: L a b -> L1' a b Source #
We can convert from a lazy left folding to a right or monoidal fold
asM :: L a b -> M a b Source #
asR :: L a b -> R a b Source #
asM1 :: L a b -> M1 a b Source #
asR1 :: L a b -> R1 a b Source #
>>> cosieve (L id (+) 0) [1,2,3] 6
>>>
cosieve (L id (+) 0) [1,2,3]
cosieve :: L a b -> [a] -> b #
(>>=) :: L a a0 -> (a0 -> L a b) -> L a b #
(>>) :: L a a0 -> L a b -> L a b #
return :: a0 -> L a a0 #
fmap :: (a0 -> b) -> L a a0 -> L a b #
(<$) :: a0 -> L a b -> L a a0 #
mfix :: (a0 -> L a a0) -> L a a0 #
pure :: a0 -> L a a0 #
(<*>) :: L a (a0 -> b) -> L a a0 -> L a b #
liftA2 :: (a0 -> b -> c) -> L a a0 -> L a b -> L a c #
(*>) :: L a a0 -> L a b -> L a b #
(<*) :: L a a0 -> L a b -> L a a0 #
distribute :: Functor f => f (L a a0) -> L a (f a0) #
collect :: Functor f => (a0 -> L a b) -> f a0 -> L a (f b) #
distributeM :: Monad m => m (L a a0) -> L a (m a0) #
collectM :: Monad m => (a0 -> L a b) -> m a0 -> L a (m b) #
type Rep (L a) #
tabulate :: (Rep (L a) -> a0) -> L a a0 #
index :: L a a0 -> Rep (L a) -> a0 #
mzip :: L a a0 -> L a b -> L a (a0, b) #
mzipWith :: (a0 -> b -> c) -> L a a0 -> L a b -> L a c #
munzip :: L a (a0, b) -> (L a a0, L a b) #
extract :: L a a0 -> a0 #
duplicate :: L a a0 -> L a (L a a0) #
extend :: (L a a0 -> b) -> L a a0 -> L a b #
(<@>) :: L a (a0 -> b) -> L a a0 -> L a b #
(@>) :: L a a0 -> L a b -> L a b #
(<@) :: L a a0 -> L a b -> L a a0 #
(<.>) :: L a (a0 -> b) -> L a a0 -> L a b #
(.>) :: L a a0 -> L a b -> L a b #
(<.) :: L a a0 -> L a b -> L a a0 #
liftF2 :: (a0 -> b -> c) -> L a a0 -> L a b -> L a c #
(>>-) :: L a a0 -> (a0 -> L a b) -> L a b #
join :: L a (L a a0) -> L a a0 #
duplicated :: L a a0 -> L a (L a a0) #
extended :: (L a a0 -> b) -> L a a0 -> L a b #
ask :: L a [a] #
local :: ([a] -> [a]) -> L a a0 -> L a a0 #
reader :: ([a] -> a0) -> L a a0 #
unfoldL :: (s -> (b, a -> s)) -> s -> L a b Source #
Construct a Moore machine from a state valuation and transition function