Data.Fold.L

Documentation

data L a b

A Moore Machine

Constructors

forall r . L (r -> b) (r -> a -> r) r

Instances

Corepresentable L

Associated Types

type Corep (L :: * -> * -> *) :: * -> *

Methods

cotabulate :: (Corep L d -> c) -> L d c

Profunctor 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

(#.) :: Coercible * c b => (b -> c) -> L a b -> L a c

(.#) :: Coercible * b a => L b c -> (a -> b) -> L a c

Choice L

Methods

left' :: L a b -> L (Either a c) (Either b c)

right' :: L a b -> L (Either c a) (Either c b)

Closed L

Methods

closed :: L a b -> L (x -> a) (x -> b)

Costrong L

Methods

unfirst :: L (a, d) (b, d) -> L a b

unsecond :: L (d, a) (d, b) -> L a b

Folding L

efficient prefix, leaky postfix

Methods

prefix :: Foldable t => t a -> L a b -> L a b

prefixOf :: Fold s a -> s -> L a b -> L a b

postfix :: Foldable t => L a b -> t a -> L a b

postfixOf :: Fold s a -> L a b -> s -> L a b

run :: Foldable t => t a -> L a b -> b

runOf :: Fold s a -> s -> L a b -> b

filtering :: (a -> Bool) -> L a b -> L a b

Scan L

Methods

prefix1 :: a -> L a b -> L a b

postfix1 :: L a b -> a -> L a b

run1 :: a -> L a b -> b

interspersing :: a -> L a b -> L a b

AsL' L

We can convert from a lazy left folding to a strict left folding.

Methods

asL' :: L a b -> L' a b

AsL1' L

Methods

asL1' :: L a b -> L1' a b

AsRM L

We can convert from a lazy left folding to a right or monoidal fold

Methods

asM :: L a b -> M a b

asR :: L a b -> R a b

AsRM1 L

Methods

asM1 :: L a b -> M1 a b

asR1 :: L a b -> R1 a b

Cosieve L []

>>> cosieve (L id (+) 0) [1,2,3]
6

Methods

cosieve :: L a b -> [a] -> b

Monad (L a)

Methods

(>>=) :: L a b -> (b -> L a c) -> L a c

(>>) :: L a b -> L a c -> L a c

return :: b -> L a b

fail :: String -> L a b

Functor (L a)

Methods

fmap :: (b -> c) -> L a b -> L a c

(<$) :: b -> L a c -> L a b

MonadFix (L a)

Methods

mfix :: (b -> L a b) -> L a b

Applicative (L a)

Methods

pure :: b -> L a b

(<*>) :: L a (b -> c) -> L a b -> L a c

(*>) :: L a b -> L a c -> L a c

(<*) :: L a b -> L a c -> L a b

Distributive (L a)

Methods

distribute :: Functor f => f (L a b) -> L a (f b)

collect :: Functor f => (b -> L a c) -> f b -> L a (f c)

distributeM :: Monad m => m (L a b) -> L a (m b)

collectM :: Monad m => (b -> L a c) -> m b -> L a (m c)

Representable (L a)

Associated Types

type Rep (L a :: * -> *) :: *

Methods

tabulate :: (Rep (L a) -> b) -> L a b

index :: L a b -> Rep (L a) -> b

MonadZip (L a)

Methods

mzip :: L a b -> L a c -> L a (b, c)

mzipWith :: (b -> c -> d) -> L a b -> L a c -> L a d

munzip :: L a (b, c) -> (L a b, L a c)

Comonad (L a)

Methods

extract :: L a b -> b

duplicate :: L a b -> L a (L a b)

extend :: (L a b -> c) -> L a b -> L a c

ComonadApply (L a)

Methods

(<@>) :: L a (b -> c) -> L a b -> L a c

(@>) :: L a b -> L a c -> L a c

(<@) :: L a b -> L a c -> L a b

Apply (L a)

Methods

(<.>) :: L a (b -> c) -> L a b -> L a c

(.>) :: L a b -> L a c -> L a c

(<.) :: L a b -> L a c -> L a b

Bind (L a)

Methods

(>>-) :: L a b -> (b -> L a c) -> L a c

join :: L a (L a b) -> L a b

Extend (L a)

Methods

duplicated :: L a b -> L a (L a b)

extended :: (L a b -> c) -> L a b -> L a c

MonadReader [a] (L a)

Methods

ask :: L a [a]

local :: ([a] -> [a]) -> L a b -> L a b

reader :: ([a] -> b) -> L a b

type Corep L = []

type Rep (L a) = [a]

unfoldL :: (s -> (b, a -> s)) -> s -> L a b

Construct a Moore machine from a state valuation and transition function