Data.Fold

Scaners and Foldings

class Choice p => Scan p where

Minimal complete definition

interspersing

Methods

prefix1 :: a -> p a b -> p a b

default prefix1 :: Folding p => a -> p a b -> p a b

postfix1 :: p a b -> a -> p a b

default postfix1 :: Folding p => p a b -> a -> p a b

run1 :: a -> p a b -> b

Apply a Folding to a single element of input

default run1 :: Folding p => a -> p a b -> b

interspersing :: a -> p a b -> p a b

Instances

Scan L

Defined in Data.Fold.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

Scan L'

Defined in Data.Fold.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

Scan L1

Defined in Data.Fold.L1

Methods

prefix1 :: a -> L1 a b -> L1 a b

postfix1 :: L1 a b -> a -> L1 a b

run1 :: a -> L1 a b -> b

interspersing :: a -> L1 a b -> L1 a b

Scan L1'

Defined in Data.Fold.L1'

Methods

prefix1 :: a -> L1' a b -> L1' a b

postfix1 :: L1' a b -> a -> L1' a b

run1 :: a -> L1' a b -> b

interspersing :: a -> L1' a b -> L1' a b

Scan M

Defined in Data.Fold.M

Methods

prefix1 :: a -> M a b -> M a b

postfix1 :: M a b -> a -> M a b

run1 :: a -> M a b -> b

interspersing :: a -> M a b -> M a b

Scan M1

Defined in Data.Fold.M1

Methods

prefix1 :: a -> M1 a b -> M1 a b

postfix1 :: M1 a b -> a -> M1 a b

run1 :: a -> M1 a b -> b

interspersing :: a -> M1 a b -> M1 a b

Scan R

Defined in Data.Fold.R

Methods

prefix1 :: a -> R a b -> R a b

postfix1 :: R a b -> a -> R a b

run1 :: a -> R a b -> b

interspersing :: a -> R a b -> R a b

Scan R1

Defined in Data.Fold.R1

Methods

prefix1 :: a -> R1 a b -> R1 a b

postfix1 :: R1 a b -> a -> R1 a b

run1 :: a -> R1 a b -> b

interspersing :: a -> R1 a b -> R1 a b

class Scan p => Folding p where

Minimal complete definition

prefixOf, postfixOf, runOf, filtering

Methods

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

Partially apply a Folding to some initial input on the left.

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

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

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

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

Apply a Folding to a container full of input:

>>> run ["hello","world"] $ L id (++) []
"helloworld"

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

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

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

Instances

Folding L

efficient prefix, leaky postfix

Defined in Data.Fold.L

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

Folding L'

efficient prefix, leaky postfix

Defined in Data.Fold.L'

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

Folding M

efficient prefix, efficient postfix

Defined in Data.Fold.M

Methods

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

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

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

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

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

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

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

Folding R

leaky prefix, efficient postfix

Defined in Data.Fold.R

Methods

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

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

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

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

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

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

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

Combinators

beneath :: Profunctor p => Optic p Identity s t a b -> p a b -> p s t

Lift a Folding into a Prism.

This acts like a generalized notion of "costrength", when applied to a Folding, causing it to return the left-most value that fails to match the Prism, or the result of accumulating rewrapped in the Prism if everything matches.

>>> run [Left 1, Left 2, Left 3] $ beneath _Left $ R id (+) 0
Left 6

>>> run [Left 1, Right 2, Right 3] $ beneath _Left $ R id (+) 0
Right 2

beneath :: Prism s t a b -> p a b -> p s t
beneath :: Iso s t a b   -> p a b -> p s t

Scans

Left Scans

data L1 a b

A Mealy Machine

Constructors

forall c. L1 (c -> b) (c -> a -> c) (a -> c)

Instances

Arrow L1

Defined in Data.Fold.L1

Methods

arr :: (b -> c) -> L1 b c

first :: L1 b c -> L1 (b, d) (c, d)

second :: L1 b c -> L1 (d, b) (d, c)

(***) :: L1 b c -> L1 b' c' -> L1 (b, b') (c, c')

(&&&) :: L1 b c -> L1 b c' -> L1 b (c, c')

ArrowChoice L1

Defined in Data.Fold.L1

Methods

left :: L1 b c -> L1 (Either b d) (Either c d)

right :: L1 b c -> L1 (Either d b) (Either d c)

(+++) :: L1 b c -> L1 b' c' -> L1 (Either b b') (Either c c')

(|||) :: L1 b d -> L1 c d -> L1 (Either b c) d

Profunctor L1

Defined in Data.Fold.L1

Methods

dimap :: (a -> b) -> (c -> d) -> L1 b c -> L1 a d

lmap :: (a -> b) -> L1 b c -> L1 a c

rmap :: (b -> c) -> L1 a b -> L1 a c

(#.) :: forall a b c q. Coercible c b => q b c -> L1 a b -> L1 a c

(.#) :: forall a b c q. Coercible b a => L1 b c -> q a b -> L1 a c

Costrong L1

Defined in Data.Fold.L1

Methods

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

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

Strong L1

Defined in Data.Fold.L1

Methods

first' :: L1 a b -> L1 (a, c) (b, c)

second' :: L1 a b -> L1 (c, a) (c, b)

Corepresentable L1

Defined in Data.Fold.L1

Associated Types

type Corep L1 :: Type -> Type

Methods

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

Choice L1

Defined in Data.Fold.L1

Methods

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

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

Closed L1

Defined in Data.Fold.L1

Methods

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

Scan L1

Defined in Data.Fold.L1

Methods

prefix1 :: a -> L1 a b -> L1 a b

postfix1 :: L1 a b -> a -> L1 a b

run1 :: a -> L1 a b -> b

interspersing :: a -> L1 a b -> L1 a b

AsL1' L1

Defined in Data.Fold

Methods

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

AsRM1 L1

Defined in Data.Fold

Methods

asM1 :: L1 a b -> M1 a b

asR1 :: L1 a b -> R1 a b

Cosieve L1 NonEmpty

Defined in Data.Fold.L1

Methods

cosieve :: L1 a b -> NonEmpty a -> b

Monad (L1 a)

Defined in Data.Fold.L1

Methods

(>>=) :: L1 a a0 -> (a0 -> L1 a b) -> L1 a b

(>>) :: L1 a a0 -> L1 a b -> L1 a b

return :: a0 -> L1 a a0

Functor (L1 a)

Defined in Data.Fold.L1

Methods

fmap :: (a0 -> b) -> L1 a a0 -> L1 a b

(<$) :: a0 -> L1 a b -> L1 a a0

MonadFix (L1 a)

Defined in Data.Fold.L1

Methods

mfix :: (a0 -> L1 a a0) -> L1 a a0

Applicative (L1 a)

Defined in Data.Fold.L1

Methods

pure :: a0 -> L1 a a0

(<*>) :: L1 a (a0 -> b) -> L1 a a0 -> L1 a b

liftA2 :: (a0 -> b -> c) -> L1 a a0 -> L1 a b -> L1 a c

(*>) :: L1 a a0 -> L1 a b -> L1 a b

(<*) :: L1 a a0 -> L1 a b -> L1 a a0

Distributive (L1 a)

Defined in Data.Fold.L1

Methods

distribute :: Functor f => f (L1 a a0) -> L1 a (f a0)

collect :: Functor f => (a0 -> L1 a b) -> f a0 -> L1 a (f b)

distributeM :: Monad m => m (L1 a a0) -> L1 a (m a0)

collectM :: Monad m => (a0 -> L1 a b) -> m a0 -> L1 a (m b)

Representable (L1 a)

Defined in Data.Fold.L1

Associated Types

type Rep (L1 a)

Methods

tabulate :: (Rep (L1 a) -> a0) -> L1 a a0

index :: L1 a a0 -> Rep (L1 a) -> a0

MonadZip (L1 a)

Defined in Data.Fold.L1

Methods

mzip :: L1 a a0 -> L1 a b -> L1 a (a0, b)

mzipWith :: (a0 -> b -> c) -> L1 a a0 -> L1 a b -> L1 a c

munzip :: L1 a (a0, b) -> (L1 a a0, L1 a b)

Apply (L1 a)

Defined in Data.Fold.L1

Methods

(<.>) :: L1 a (a0 -> b) -> L1 a a0 -> L1 a b

(.>) :: L1 a a0 -> L1 a b -> L1 a b

(<.) :: L1 a a0 -> L1 a b -> L1 a a0

liftF2 :: (a0 -> b -> c) -> L1 a a0 -> L1 a b -> L1 a c

Pointed (L1 a)

Defined in Data.Fold.L1

Methods

point :: a0 -> L1 a a0

Category L1

Defined in Data.Fold.L1

Methods

id :: forall (a :: k). L1 a a

(.) :: forall (b :: k) (c :: k) (a :: k). L1 b c -> L1 a b -> L1 a c

Semigroupoid L1

Defined in Data.Fold.L1

Methods

o :: forall (j :: k) (k1 :: k) (i :: k). L1 j k1 -> L1 i j -> L1 i k1

MonadReader (NonEmpty a) (L1 a)

Defined in Data.Fold.L1

Methods

ask :: L1 a (NonEmpty a)

local :: (NonEmpty a -> NonEmpty a) -> L1 a a0 -> L1 a a0

reader :: (NonEmpty a -> a0) -> L1 a a0

type Corep L1

Defined in Data.Fold.L1

type Corep L1 = NonEmpty

type Rep (L1 a)

Defined in Data.Fold.L1

type Rep (L1 a) = NonEmpty a

data L1' a b

A strict Mealy Machine

Constructors

forall c. L1' (c -> b) (c -> a -> c) (a -> c)

Instances

Arrow L1'

Defined in Data.Fold.L1'

Methods

arr :: (b -> c) -> L1' b c

first :: L1' b c -> L1' (b, d) (c, d)

second :: L1' b c -> L1' (d, b) (d, c)

(***) :: L1' b c -> L1' b' c' -> L1' (b, b') (c, c')

(&&&) :: L1' b c -> L1' b c' -> L1' b (c, c')

ArrowChoice L1'

Defined in Data.Fold.L1'

Methods

left :: L1' b c -> L1' (Either b d) (Either c d)

right :: L1' b c -> L1' (Either d b) (Either d c)

(+++) :: L1' b c -> L1' b' c' -> L1' (Either b b') (Either c c')

(|||) :: L1' b d -> L1' c d -> L1' (Either b c) d

Profunctor L1'

Defined in Data.Fold.L1'

Methods

dimap :: (a -> b) -> (c -> d) -> L1' b c -> L1' a d

lmap :: (a -> b) -> L1' b c -> L1' a c

rmap :: (b -> c) -> L1' a b -> L1' a c

(#.) :: forall a b c q. Coercible c b => q b c -> L1' a b -> L1' a c

(.#) :: forall a b c q. Coercible b a => L1' b c -> q a b -> L1' a c

Costrong L1'

Defined in Data.Fold.L1'

Methods

unfirst :: L1' (a, d) (b, d) -> L1' a b

unsecond :: L1' (d, a) (d, b) -> L1' a b

Strong L1'

Defined in Data.Fold.L1'

Methods

first' :: L1' a b -> L1' (a, c) (b, c)

second' :: L1' a b -> L1' (c, a) (c, b)

Corepresentable L1'

Defined in Data.Fold.L1'

Associated Types

type Corep L1' :: Type -> Type

Methods

cotabulate :: (Corep L1' d -> c) -> L1' d c

Choice L1'

Defined in Data.Fold.L1'

Methods

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

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

Closed L1'

Defined in Data.Fold.L1'

Methods

closed :: L1' a b -> L1' (x -> a) (x -> b)

Scan L1'

Defined in Data.Fold.L1'

Methods

prefix1 :: a -> L1' a b -> L1' a b

postfix1 :: L1' a b -> a -> L1' a b

run1 :: a -> L1' a b -> b

interspersing :: a -> L1' a b -> L1' a b

AsL1' L1'

Defined in Data.Fold

Methods

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

AsRM1 L1'

Defined in Data.Fold

Methods

asM1 :: L1' a b -> M1 a b

asR1 :: L1' a b -> R1 a b

Cosieve L1' NonEmpty

Defined in Data.Fold.L1'

Methods

cosieve :: L1' a b -> NonEmpty a -> b

Monad (L1' a)

Defined in Data.Fold.L1'

Methods

(>>=) :: L1' a a0 -> (a0 -> L1' a b) -> L1' a b

(>>) :: L1' a a0 -> L1' a b -> L1' a b

return :: a0 -> L1' a a0

Functor (L1' a)

Defined in Data.Fold.L1'

Methods

fmap :: (a0 -> b) -> L1' a a0 -> L1' a b

(<$) :: a0 -> L1' a b -> L1' a a0

MonadFix (L1' a)

Defined in Data.Fold.L1'

Methods

mfix :: (a0 -> L1' a a0) -> L1' a a0

Applicative (L1' a)

Defined in Data.Fold.L1'

Methods

pure :: a0 -> L1' a a0

(<*>) :: L1' a (a0 -> b) -> L1' a a0 -> L1' a b

liftA2 :: (a0 -> b -> c) -> L1' a a0 -> L1' a b -> L1' a c

(*>) :: L1' a a0 -> L1' a b -> L1' a b

(<*) :: L1' a a0 -> L1' a b -> L1' a a0

Distributive (L1' a)

Defined in Data.Fold.L1'

Methods

distribute :: Functor f => f (L1' a a0) -> L1' a (f a0)

collect :: Functor f => (a0 -> L1' a b) -> f a0 -> L1' a (f b)

distributeM :: Monad m => m (L1' a a0) -> L1' a (m a0)

collectM :: Monad m => (a0 -> L1' a b) -> m a0 -> L1' a (m b)

Representable (L1' a)

Defined in Data.Fold.L1'

Associated Types

type Rep (L1' a)

Methods

tabulate :: (Rep (L1' a) -> a0) -> L1' a a0

index :: L1' a a0 -> Rep (L1' a) -> a0

Apply (L1' a)

Defined in Data.Fold.L1'

Methods

(<.>) :: L1' a (a0 -> b) -> L1' a a0 -> L1' a b

(.>) :: L1' a a0 -> L1' a b -> L1' a b

(<.) :: L1' a a0 -> L1' a b -> L1' a a0

liftF2 :: (a0 -> b -> c) -> L1' a a0 -> L1' a b -> L1' a c

Pointed (L1' a)

Defined in Data.Fold.L1'

Methods

point :: a0 -> L1' a a0

Category L1'

Defined in Data.Fold.L1'

Methods

id :: forall (a :: k). L1' a a

(.) :: forall (b :: k) (c :: k) (a :: k). L1' b c -> L1' a b -> L1' a c

Semigroupoid L1'

Defined in Data.Fold.L1'

Methods

o :: forall (j :: k) (k1 :: k) (i :: k). L1' j k1 -> L1' i j -> L1' i k1

MonadReader (NonEmpty a) (L1' a)

Defined in Data.Fold.L1'

Methods

ask :: L1' a (NonEmpty a)

local :: (NonEmpty a -> NonEmpty a) -> L1' a a0 -> L1' a a0

reader :: (NonEmpty a -> a0) -> L1' a a0

type Corep L1'

Defined in Data.Fold.L1'

type Corep L1' = NonEmpty

type Rep (L1' a)

Defined in Data.Fold.L1'

type Rep (L1' a) = NonEmpty a

Semigroup Scans

data M1 a b

A semigroup reducer

Constructors

forall m. M1 (m -> b) (a -> m) (m -> m -> m)

Instances

Arrow M1

Defined in Data.Fold.M1

Methods

arr :: (b -> c) -> M1 b c

first :: M1 b c -> M1 (b, d) (c, d)

second :: M1 b c -> M1 (d, b) (d, c)

(***) :: M1 b c -> M1 b' c' -> M1 (b, b') (c, c')

(&&&) :: M1 b c -> M1 b c' -> M1 b (c, c')

ArrowChoice M1

Defined in Data.Fold.M1

Methods

left :: M1 b c -> M1 (Either b d) (Either c d)

right :: M1 b c -> M1 (Either d b) (Either d c)

(+++) :: M1 b c -> M1 b' c' -> M1 (Either b b') (Either c c')

(|||) :: M1 b d -> M1 c d -> M1 (Either b c) d

Profunctor M1

Defined in Data.Fold.M1

Methods

dimap :: (a -> b) -> (c -> d) -> M1 b c -> M1 a d

lmap :: (a -> b) -> M1 b c -> M1 a c

rmap :: (b -> c) -> M1 a b -> M1 a c

(#.) :: forall a b c q. Coercible c b => q b c -> M1 a b -> M1 a c

(.#) :: forall a b c q. Coercible b a => M1 b c -> q a b -> M1 a c

Costrong M1

Defined in Data.Fold.M1

Methods

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

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

Strong M1

Defined in Data.Fold.M1

Methods

first' :: M1 a b -> M1 (a, c) (b, c)

second' :: M1 a b -> M1 (c, a) (c, b)

Corepresentable M1

Defined in Data.Fold.M1

Associated Types

type Corep M1 :: Type -> Type

Methods

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

Choice M1

Defined in Data.Fold.M1

Methods

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

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

Closed M1

Defined in Data.Fold.M1

Methods

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

Scan M1

Defined in Data.Fold.M1

Methods

prefix1 :: a -> M1 a b -> M1 a b

postfix1 :: M1 a b -> a -> M1 a b

run1 :: a -> M1 a b -> b

interspersing :: a -> M1 a b -> M1 a b

AsRM1 M1

Defined in Data.Fold

Methods

asM1 :: M1 a b -> M1 a b

asR1 :: M1 a b -> R1 a b

Cosieve M1 FreeSemigroup

Defined in Data.Fold.M1

Methods

cosieve :: M1 a b -> FreeSemigroup a -> b

Monad (M1 a)

Defined in Data.Fold.M1

Methods

(>>=) :: M1 a a0 -> (a0 -> M1 a b) -> M1 a b

(>>) :: M1 a a0 -> M1 a b -> M1 a b

return :: a0 -> M1 a a0

Functor (M1 a)

Defined in Data.Fold.M1

Methods

fmap :: (a0 -> b) -> M1 a a0 -> M1 a b

(<$) :: a0 -> M1 a b -> M1 a a0

MonadFix (M1 a)

Defined in Data.Fold.M1

Methods

mfix :: (a0 -> M1 a a0) -> M1 a a0

Applicative (M1 a)

Defined in Data.Fold.M1

Methods

pure :: a0 -> M1 a a0

(<*>) :: M1 a (a0 -> b) -> M1 a a0 -> M1 a b

liftA2 :: (a0 -> b -> c) -> M1 a a0 -> M1 a b -> M1 a c

(*>) :: M1 a a0 -> M1 a b -> M1 a b

(<*) :: M1 a a0 -> M1 a b -> M1 a a0

Distributive (M1 a)

Defined in Data.Fold.M1

Methods

distribute :: Functor f => f (M1 a a0) -> M1 a (f a0)

collect :: Functor f => (a0 -> M1 a b) -> f a0 -> M1 a (f b)

distributeM :: Monad m => m (M1 a a0) -> M1 a (m a0)

collectM :: Monad m => (a0 -> M1 a b) -> m a0 -> M1 a (m b)

Representable (M1 a)

Defined in Data.Fold.M1

Associated Types

type Rep (M1 a)

Methods

tabulate :: (Rep (M1 a) -> a0) -> M1 a a0

index :: M1 a a0 -> Rep (M1 a) -> a0

MonadZip (M1 a)

Defined in Data.Fold.M1

Methods

mzip :: M1 a a0 -> M1 a b -> M1 a (a0, b)

mzipWith :: (a0 -> b -> c) -> M1 a a0 -> M1 a b -> M1 a c

munzip :: M1 a (a0, b) -> (M1 a a0, M1 a b)

Apply (M1 a)

Defined in Data.Fold.M1

Methods

(<.>) :: M1 a (a0 -> b) -> M1 a a0 -> M1 a b

(.>) :: M1 a a0 -> M1 a b -> M1 a b

(<.) :: M1 a a0 -> M1 a b -> M1 a a0

liftF2 :: (a0 -> b -> c) -> M1 a a0 -> M1 a b -> M1 a c

Pointed (M1 a)

Defined in Data.Fold.M1

Methods

point :: a0 -> M1 a a0

Category M1

Defined in Data.Fold.M1

Methods

id :: forall (a :: k). M1 a a

(.) :: forall (b :: k) (c :: k) (a :: k). M1 b c -> M1 a b -> M1 a c

Semigroupoid M1

Defined in Data.Fold.M1

Methods

o :: forall (j :: k) (k1 :: k) (i :: k). M1 j k1 -> M1 i j -> M1 i k1

MonadReader (FreeSemigroup a) (M1 a)

Defined in Data.Fold.M1

Methods

ask :: M1 a (FreeSemigroup a)

local :: (FreeSemigroup a -> FreeSemigroup a) -> M1 a a0 -> M1 a a0

reader :: (FreeSemigroup a -> a0) -> M1 a a0

type Corep M1

Defined in Data.Fold.M1

type Corep M1 = FreeSemigroup

type Rep (M1 a)

Defined in Data.Fold.M1

type Rep (M1 a) = FreeSemigroup a

Right Scans

data R1 a b

A reversed Mealy machine

Constructors

forall c. R1 (c -> b) (a -> c -> c) (a -> c)

Instances

Arrow R1

Defined in Data.Fold.R1

Methods

arr :: (b -> c) -> R1 b c

first :: R1 b c -> R1 (b, d) (c, d)

second :: R1 b c -> R1 (d, b) (d, c)

(***) :: R1 b c -> R1 b' c' -> R1 (b, b') (c, c')

(&&&) :: R1 b c -> R1 b c' -> R1 b (c, c')

ArrowChoice R1

Defined in Data.Fold.R1

Methods

left :: R1 b c -> R1 (Either b d) (Either c d)

right :: R1 b c -> R1 (Either d b) (Either d c)

(+++) :: R1 b c -> R1 b' c' -> R1 (Either b b') (Either c c')

(|||) :: R1 b d -> R1 c d -> R1 (Either b c) d

Profunctor R1

Defined in Data.Fold.R1

Methods

dimap :: (a -> b) -> (c -> d) -> R1 b c -> R1 a d

lmap :: (a -> b) -> R1 b c -> R1 a c

rmap :: (b -> c) -> R1 a b -> R1 a c

(#.) :: forall a b c q. Coercible c b => q b c -> R1 a b -> R1 a c

(.#) :: forall a b c q. Coercible b a => R1 b c -> q a b -> R1 a c

Costrong R1

Defined in Data.Fold.R1

Methods

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

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

Strong R1

Defined in Data.Fold.R1

Methods

first' :: R1 a b -> R1 (a, c) (b, c)

second' :: R1 a b -> R1 (c, a) (c, b)

Corepresentable R1

Defined in Data.Fold.R1

Associated Types

type Corep R1 :: Type -> Type

Methods

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

Choice R1

Defined in Data.Fold.R1

Methods

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

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

Closed R1

Defined in Data.Fold.R1

Methods

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

Scan R1

Defined in Data.Fold.R1

Methods

prefix1 :: a -> R1 a b -> R1 a b

postfix1 :: R1 a b -> a -> R1 a b

run1 :: a -> R1 a b -> b

interspersing :: a -> R1 a b -> R1 a b

AsRM1 R1

Defined in Data.Fold

Methods

asM1 :: R1 a b -> M1 a b

asR1 :: R1 a b -> R1 a b

Cosieve R1 NonEmpty

Defined in Data.Fold.R1

Methods

cosieve :: R1 a b -> NonEmpty a -> b

Monad (R1 a)

Defined in Data.Fold.R1

Methods

(>>=) :: R1 a a0 -> (a0 -> R1 a b) -> R1 a b

(>>) :: R1 a a0 -> R1 a b -> R1 a b

return :: a0 -> R1 a a0

Functor (R1 a)

Defined in Data.Fold.R1

Methods

fmap :: (a0 -> b) -> R1 a a0 -> R1 a b

(<$) :: a0 -> R1 a b -> R1 a a0

MonadFix (R1 a)

Defined in Data.Fold.R1

Methods

mfix :: (a0 -> R1 a a0) -> R1 a a0

Applicative (R1 a)

Defined in Data.Fold.R1

Methods

pure :: a0 -> R1 a a0

(<*>) :: R1 a (a0 -> b) -> R1 a a0 -> R1 a b

liftA2 :: (a0 -> b -> c) -> R1 a a0 -> R1 a b -> R1 a c

(*>) :: R1 a a0 -> R1 a b -> R1 a b

(<*) :: R1 a a0 -> R1 a b -> R1 a a0

Distributive (R1 a)

Defined in Data.Fold.R1

Methods

distribute :: Functor f => f (R1 a a0) -> R1 a (f a0)

collect :: Functor f => (a0 -> R1 a b) -> f a0 -> R1 a (f b)

distributeM :: Monad m => m (R1 a a0) -> R1 a (m a0)

collectM :: Monad m => (a0 -> R1 a b) -> m a0 -> R1 a (m b)

Representable (R1 a)

Defined in Data.Fold.R1

Associated Types

type Rep (R1 a)

Methods

tabulate :: (Rep (R1 a) -> a0) -> R1 a a0

index :: R1 a a0 -> Rep (R1 a) -> a0

MonadZip (R1 a)

Defined in Data.Fold.R1

Methods

mzip :: R1 a a0 -> R1 a b -> R1 a (a0, b)

mzipWith :: (a0 -> b -> c) -> R1 a a0 -> R1 a b -> R1 a c

munzip :: R1 a (a0, b) -> (R1 a a0, R1 a b)

Apply (R1 a)

Defined in Data.Fold.R1

Methods

(<.>) :: R1 a (a0 -> b) -> R1 a a0 -> R1 a b

(.>) :: R1 a a0 -> R1 a b -> R1 a b

(<.) :: R1 a a0 -> R1 a b -> R1 a a0

liftF2 :: (a0 -> b -> c) -> R1 a a0 -> R1 a b -> R1 a c

Pointed (R1 a)

Defined in Data.Fold.R1

Methods

point :: a0 -> R1 a a0

Category R1

Defined in Data.Fold.R1

Methods

id :: forall (a :: k). R1 a a

(.) :: forall (b :: k) (c :: k) (a :: k). R1 b c -> R1 a b -> R1 a c

Semigroupoid R1

Defined in Data.Fold.R1

Methods

o :: forall (j :: k) (k1 :: k) (i :: k). R1 j k1 -> R1 i j -> R1 i k1

MonadReader (NonEmpty a) (R1 a)

Defined in Data.Fold.R1

Methods

ask :: R1 a (NonEmpty a)

local :: (NonEmpty a -> NonEmpty a) -> R1 a a0 -> R1 a a0

reader :: (NonEmpty a -> a0) -> R1 a a0

type Corep R1

Defined in Data.Fold.R1

type Corep R1 = NonEmpty

type Rep (R1 a)

Defined in Data.Fold.R1

type Rep (R1 a) = NonEmpty a

Foldings

Left Foldings

data L a b

A Moore Machine

Constructors

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

Instances

Profunctor L

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

Costrong L

Defined in Data.Fold.L

Methods

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

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

Corepresentable L

Defined in Data.Fold.L

Associated Types

type Corep L :: Type -> Type

Methods

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

Choice L

Defined in Data.Fold.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

Defined in Data.Fold.L

Methods

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

Folding L

efficient prefix, leaky postfix

Defined in Data.Fold.L

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

Defined in Data.Fold.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.

Defined in Data.Fold

Methods

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

AsL1' L

Defined in Data.Fold

Methods

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

AsRM L

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

Defined in Data.Fold

Methods

asM :: L a b -> M a b

asR :: L a b -> R a b

AsRM1 L

Defined in Data.Fold

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

Defined in Data.Fold.L

Methods

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

Monad (L a)

Defined in Data.Fold.L

Methods

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

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

return :: a0 -> L a a0

Functor (L a)

Defined in Data.Fold.L

Methods

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

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

MonadFix (L a)

Defined in Data.Fold.L

Methods

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

Applicative (L a)

Defined in Data.Fold.L

Methods

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

Distributive (L a)

Defined in Data.Fold.L

Methods

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)

Representable (L a)

Defined in Data.Fold.L

Associated Types

type Rep (L a)

Methods

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

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

MonadZip (L a)

Defined in Data.Fold.L

Methods

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)

Comonad (L a)

Defined in Data.Fold.L

Methods

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

ComonadApply (L a)

Defined in Data.Fold.L

Methods

(<@>) :: 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

Apply (L a)

Defined in Data.Fold.L

Methods

(<.>) :: 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

Bind (L a)

Defined in Data.Fold.L

Methods

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

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

Extend (L a)

Defined in Data.Fold.L

Methods

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

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

MonadReader [a] (L a)

Defined in Data.Fold.L

Methods

ask :: L a [a]

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

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

type Corep L

Defined in Data.Fold.L

type Corep L = []

type Rep (L a)

Defined in Data.Fold.L

type Rep (L a) = [a]

data L' a b

A strict left fold / strict Moore machine

Constructors

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

Instances

Profunctor L'

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

Costrong L'

Defined in Data.Fold.L'

Methods

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

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

Corepresentable L'

Defined in Data.Fold.L'

Associated Types

type Corep L' :: Type -> Type

Methods

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

Choice L'

Defined in Data.Fold.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'

Defined in Data.Fold.L'

Methods

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

Folding L'

efficient prefix, leaky postfix

Defined in Data.Fold.L'

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'

Defined in Data.Fold.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 a lazy fold to itself

Defined in Data.Fold

Methods

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

AsL1' L'

Defined in Data.Fold

Methods

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

AsRM L'

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

Defined in Data.Fold

Methods

asM :: L' a b -> M a b

asR :: L' a b -> R a b

AsRM1 L'

Defined in Data.Fold

Methods

asM1 :: L' a b -> M1 a b

asR1 :: L' a b -> R1 a b

Cosieve L' []

Defined in Data.Fold.L'

Methods

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

Monad (L' a)

Defined in Data.Fold.L'

Methods

(>>=) :: L' a a0 -> (a0 -> L' a b) -> L' a b

(>>) :: L' a a0 -> L' a b -> L' a b

return :: a0 -> L' a a0

Functor (L' a)

Defined in Data.Fold.L'

Methods

fmap :: (a0 -> b) -> L' a a0 -> L' a b

(<$) :: a0 -> L' a b -> L' a a0

MonadFix (L' a)

Defined in Data.Fold.L'

Methods

mfix :: (a0 -> L' a a0) -> L' a a0

Applicative (L' a)

Defined in Data.Fold.L'

Methods

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

Distributive (L' a)

Defined in Data.Fold.L'

Methods

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)

Representable (L' a)

Defined in Data.Fold.L'

Associated Types

type Rep (L' a)

Methods

tabulate :: (Rep (L' a) -> a0) -> L' a a0

index :: L' a a0 -> Rep (L' a) -> a0

MonadZip (L' a)

Defined in Data.Fold.L'

Methods

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)

Comonad (L' a)

Defined in Data.Fold.L'

Methods

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

ComonadApply (L' a)

Defined in Data.Fold.L'

Methods

(<@>) :: 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

Apply (L' a)

Defined in Data.Fold.L'

Methods

(<.>) :: 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

Bind (L' a)

Defined in Data.Fold.L'

Methods

(>>-) :: L' a a0 -> (a0 -> L' a b) -> L' a b

join :: L' a (L' a a0) -> L' a a0

Extend (L' a)

Defined in Data.Fold.L'

Methods

duplicated :: L' a a0 -> L' a (L' a a0)

extended :: (L' a a0 -> b) -> L' a a0 -> L' a b

MonadReader [a] (L' a)

Defined in Data.Fold.L'

Methods

ask :: L' a [a]

local :: ([a] -> [a]) -> L' a a0 -> L' a a0

reader :: ([a] -> a0) -> L' a a0

type Corep L'

Defined in Data.Fold.L'

type Corep L' = []

type Rep (L' a)

Defined in Data.Fold.L'

type Rep (L' a) = [a]

Monoidal Foldings

data M a b

A foldMap caught in amber. a.k.a. a monoidal reducer

Constructors

forall m. M (m -> b) (a -> m) (m -> m -> m) m

Instances

Profunctor M

Defined in Data.Fold.M

Methods

dimap :: (a -> b) -> (c -> d) -> M b c -> M a d

lmap :: (a -> b) -> M b c -> M a c

rmap :: (b -> c) -> M a b -> M a c

(#.) :: forall a b c q. Coercible c b => q b c -> M a b -> M a c

(.#) :: forall a b c q. Coercible b a => M b c -> q a b -> M a c

Costrong M

Defined in Data.Fold.M

Methods

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

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

Corepresentable M

Defined in Data.Fold.M

Associated Types

type Corep M :: Type -> Type

Methods

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

Choice M

Defined in Data.Fold.M

Methods

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

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

Closed M

Defined in Data.Fold.M

Methods

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

Folding M

efficient prefix, efficient postfix

Defined in Data.Fold.M

Methods

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

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

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

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

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

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

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

Scan M

Defined in Data.Fold.M

Methods

prefix1 :: a -> M a b -> M a b

postfix1 :: M a b -> a -> M a b

run1 :: a -> M a b -> b

interspersing :: a -> M a b -> M a b

AsRM M

We can convert from a monoidal fold to a lazy right fold

Defined in Data.Fold

Methods

asM :: M a b -> M a b

asR :: M a b -> R a b

AsRM1 M

Defined in Data.Fold

Methods

asM1 :: M a b -> M1 a b

asR1 :: M a b -> R1 a b

Cosieve M FreeMonoid

Defined in Data.Fold.M

Methods

cosieve :: M a b -> FreeMonoid a -> b

Monad (M a)

Defined in Data.Fold.M

Methods

(>>=) :: M a a0 -> (a0 -> M a b) -> M a b

(>>) :: M a a0 -> M a b -> M a b

return :: a0 -> M a a0

Functor (M a)

Defined in Data.Fold.M

Methods

fmap :: (a0 -> b) -> M a a0 -> M a b

(<$) :: a0 -> M a b -> M a a0

MonadFix (M a)

Defined in Data.Fold.M

Methods

mfix :: (a0 -> M a a0) -> M a a0

Applicative (M a)

Defined in Data.Fold.M

Methods

pure :: a0 -> M a a0

(<*>) :: M a (a0 -> b) -> M a a0 -> M a b

liftA2 :: (a0 -> b -> c) -> M a a0 -> M a b -> M a c

(*>) :: M a a0 -> M a b -> M a b

(<*) :: M a a0 -> M a b -> M a a0

Distributive (M a)

Defined in Data.Fold.M

Methods

distribute :: Functor f => f (M a a0) -> M a (f a0)

collect :: Functor f => (a0 -> M a b) -> f a0 -> M a (f b)

distributeM :: Monad m => m (M a a0) -> M a (m a0)

collectM :: Monad m => (a0 -> M a b) -> m a0 -> M a (m b)

Representable (M a)

Defined in Data.Fold.M

Associated Types

type Rep (M a)

Methods

tabulate :: (Rep (M a) -> a0) -> M a a0

index :: M a a0 -> Rep (M a) -> a0

MonadZip (M a)

Defined in Data.Fold.M

Methods

mzip :: M a a0 -> M a b -> M a (a0, b)

mzipWith :: (a0 -> b -> c) -> M a a0 -> M a b -> M a c

munzip :: M a (a0, b) -> (M a a0, M a b)

Comonad (M a)

Defined in Data.Fold.M

Methods

extract :: M a a0 -> a0

duplicate :: M a a0 -> M a (M a a0)

extend :: (M a a0 -> b) -> M a a0 -> M a b

ComonadApply (M a)

Defined in Data.Fold.M

Methods

(<@>) :: M a (a0 -> b) -> M a a0 -> M a b

(@>) :: M a a0 -> M a b -> M a b

(<@) :: M a a0 -> M a b -> M a a0

Apply (M a)

Defined in Data.Fold.M

Methods

(<.>) :: M a (a0 -> b) -> M a a0 -> M a b

(.>) :: M a a0 -> M a b -> M a b

(<.) :: M a a0 -> M a b -> M a a0

liftF2 :: (a0 -> b -> c) -> M a a0 -> M a b -> M a c

Bind (M a)

Defined in Data.Fold.M

Methods

(>>-) :: M a a0 -> (a0 -> M a b) -> M a b

join :: M a (M a a0) -> M a a0

Extend (M a)

Defined in Data.Fold.M

Methods

duplicated :: M a a0 -> M a (M a a0)

extended :: (M a a0 -> b) -> M a a0 -> M a b

MonadReader (FreeMonoid a) (M a)

Defined in Data.Fold.M

Methods

ask :: M a (FreeMonoid a)

local :: (FreeMonoid a -> FreeMonoid a) -> M a a0 -> M a a0

reader :: (FreeMonoid a -> a0) -> M a a0

type Corep M

Defined in Data.Fold.M

type Corep M = FreeMonoid

type Rep (M a)

Defined in Data.Fold.M

type Rep (M a) = FreeMonoid a

Right Foldings

data R a b

right folds / a reversed Moore machine

Constructors

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

Instances

Profunctor R

Defined in Data.Fold.R

Methods

dimap :: (a -> b) -> (c -> d) -> R b c -> R a d

lmap :: (a -> b) -> R b c -> R a c

rmap :: (b -> c) -> R a b -> R a c

(#.) :: forall a b c q. Coercible c b => q b c -> R a b -> R a c

(.#) :: forall a b c q. Coercible b a => R b c -> q a b -> R a c

Costrong R

Defined in Data.Fold.R

Methods

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

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

Corepresentable R

Defined in Data.Fold.R

Associated Types

type Corep R :: Type -> Type

Methods

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

Choice R

Defined in Data.Fold.R

Methods

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

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

Closed R

Defined in Data.Fold.R

Methods

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

Folding R

leaky prefix, efficient postfix

Defined in Data.Fold.R

Methods

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

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

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

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

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

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

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

Scan R

Defined in Data.Fold.R

Methods

prefix1 :: a -> R a b -> R a b

postfix1 :: R a b -> a -> R a b

run1 :: a -> R a b -> b

interspersing :: a -> R a b -> R a b

AsRM R

We can convert from a lazy right fold to a monoidal fold

Defined in Data.Fold

Methods

asM :: R a b -> M a b

asR :: R a b -> R a b

AsRM1 R

Defined in Data.Fold

Methods

asM1 :: R a b -> M1 a b

asR1 :: R a b -> R1 a b

Cosieve R []

Defined in Data.Fold.R

Methods

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

Monad (R a)

Defined in Data.Fold.R

Methods

(>>=) :: R a a0 -> (a0 -> R a b) -> R a b

(>>) :: R a a0 -> R a b -> R a b

return :: a0 -> R a a0

Functor (R a)

Defined in Data.Fold.R

Methods

fmap :: (a0 -> b) -> R a a0 -> R a b

(<$) :: a0 -> R a b -> R a a0

MonadFix (R a)

Defined in Data.Fold.R

Methods

mfix :: (a0 -> R a a0) -> R a a0

Applicative (R a)

Defined in Data.Fold.R

Methods

pure :: a0 -> R a a0

(<*>) :: R a (a0 -> b) -> R a a0 -> R a b

liftA2 :: (a0 -> b -> c) -> R a a0 -> R a b -> R a c

(*>) :: R a a0 -> R a b -> R a b

(<*) :: R a a0 -> R a b -> R a a0

Distributive (R a)

Defined in Data.Fold.R

Methods

distribute :: Functor f => f (R a a0) -> R a (f a0)

collect :: Functor f => (a0 -> R a b) -> f a0 -> R a (f b)

distributeM :: Monad m => m (R a a0) -> R a (m a0)

collectM :: Monad m => (a0 -> R a b) -> m a0 -> R a (m b)

Representable (R a)

Defined in Data.Fold.R

Associated Types

type Rep (R a)

Methods

tabulate :: (Rep (R a) -> a0) -> R a a0

index :: R a a0 -> Rep (R a) -> a0

MonadZip (R a)

Defined in Data.Fold.R

Methods

mzip :: R a a0 -> R a b -> R a (a0, b)

mzipWith :: (a0 -> b -> c) -> R a a0 -> R a b -> R a c

munzip :: R a (a0, b) -> (R a a0, R a b)

Comonad (R a)

Defined in Data.Fold.R

Methods

extract :: R a a0 -> a0

duplicate :: R a a0 -> R a (R a a0)

extend :: (R a a0 -> b) -> R a a0 -> R a b

ComonadApply (R a)

Defined in Data.Fold.R

Methods

(<@>) :: R a (a0 -> b) -> R a a0 -> R a b

(@>) :: R a a0 -> R a b -> R a b

(<@) :: R a a0 -> R a b -> R a a0

Apply (R a)

Defined in Data.Fold.R

Methods

(<.>) :: R a (a0 -> b) -> R a a0 -> R a b

(.>) :: R a a0 -> R a b -> R a b

(<.) :: R a a0 -> R a b -> R a a0

liftF2 :: (a0 -> b -> c) -> R a a0 -> R a b -> R a c

Bind (R a)

Defined in Data.Fold.R

Methods

(>>-) :: R a a0 -> (a0 -> R a b) -> R a b

join :: R a (R a a0) -> R a a0

Extend (R a)

Defined in Data.Fold.R

Methods

duplicated :: R a a0 -> R a (R a a0)

extended :: (R a a0 -> b) -> R a a0 -> R a b

MonadReader [a] (R a)

Defined in Data.Fold.R

Methods

ask :: R a [a]

local :: ([a] -> [a]) -> R a a0 -> R a a0

reader :: ([a] -> a0) -> R a a0

type Corep R

Defined in Data.Fold.R

type Corep R = []

type Rep (R a)

Defined in Data.Fold.R

type Rep (R a) = [a]

Homomorphisms

Scan Homomorphisms

We define f to be a scan homomorphism between p and q when:

f :: forall a b. p a b -> q a b

run1 xs (f φ)        ≡ run1 xs φ
prefix1 xs (f φ)     ≡ f (prefix1 xs φ)
postfix1 (f φ) xs    ≡ f (postfix1 φ xs)
dimap l r (f φ)      ≡ f (dimap l r φ)
pure a               ≡ f (pure a)
f φ <*> f ψ          ≡ f (φ <*> ψ)
return a             ≡ f (return a)
f φ >>= f . k        ≡ f (φ >>= k)
interspersing a (f φ) ≡ f (interspersing a φ)

Furthermore,

left' (f φ) and f (left' φ) should agree whenever either answer is Right

right' (f φ) and f (right' φ) should agree whenever either answer is Left

class AsRM1 p where

Minimal complete definition

Nothing

Methods

asM1 :: p a b -> M1 a b

asM1 is a scan homomorphism to a semigroup reducer

asR1 :: p a b -> R1 a b

asM1 is a scan homomorphism to a right scan

Instances

AsRM1 L

Defined in Data.Fold

Methods

asM1 :: L a b -> M1 a b

asR1 :: L a b -> R1 a b

AsRM1 L'

Defined in Data.Fold

Methods

asM1 :: L' a b -> M1 a b

asR1 :: L' a b -> R1 a b

AsRM1 L1

Defined in Data.Fold

Methods

asM1 :: L1 a b -> M1 a b

asR1 :: L1 a b -> R1 a b

AsRM1 L1'

Defined in Data.Fold

Methods

asM1 :: L1' a b -> M1 a b

asR1 :: L1' a b -> R1 a b

AsRM1 M

Defined in Data.Fold

Methods

asM1 :: M a b -> M1 a b

asR1 :: M a b -> R1 a b

AsRM1 M1

Defined in Data.Fold

Methods

asM1 :: M1 a b -> M1 a b

asR1 :: M1 a b -> R1 a b

AsRM1 R

Defined in Data.Fold

Methods

asM1 :: R a b -> M1 a b

asR1 :: R a b -> R1 a b

AsRM1 R1

Defined in Data.Fold

Methods

asM1 :: R1 a b -> M1 a b

asR1 :: R1 a b -> R1 a b

class AsRM1 p => AsL1' p where

Minimal complete definition

Nothing

Methods

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

Scan homomorphism to a strict Mealy machine

default asL1' :: AsL' p => p a b -> L1' a b

Instances

AsL1' L

Defined in Data.Fold

Methods

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

AsL1' L'

Defined in Data.Fold

Methods

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

AsL1' L1

Defined in Data.Fold

Methods

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

AsL1' L1'

Defined in Data.Fold

Methods

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

Folding Homomorphisms

We define f to be a folding homomorphism between p and q when f is a scan homomorphism and additionally we can satisfy:

run xs (f φ)         ≡ run xs φ
runOf l xs (f φ)     ≡ runOf l xs φ
prefix xs (f φ)      ≡ f (prefix xs φ)
prefixOf l xs (f φ)  ≡ f (prefixOf l xs φ)
postfix (f φ) xs     ≡ f (postfix φ xs)
postfixOf l (f φ) xs ≡ f (postfixOf l φ xs)
extract (f φ)        ≡ extract φ
filtering p (f φ)     ≡ f (filtering p φ)

Note: A law including extend is explicitly excluded. To work consistenly across foldings, use prefix and postfix instead.

class AsRM1 p => AsRM p where

Minimal complete definition

Nothing

Methods

asM :: p a b -> M a b

asM is a folding homomorphism to a monoidal folding

run xs (asM φ)         ≡ run xs φ
prefix xs (asM φ)      ≡ asM (prefix xs φ)
prefixOf l xs (asM φ)  ≡ asM (prefixOf l xs φ)
postfix (asM φ) xs     ≡ asM (postfix φ xs)
postfixOf l (asM φ) xs ≡ asM (postfixOf l φ xs)
left' (asM φ)          ≡ asM (left' φ)
right' (asM φ)         ≡ asM (right' φ)
dimap l r (asM φ)      ≡ asM (dimap l r φ)
extract (asM φ)        ≡ extract φ
pure a                  ≡ asM (pure a)
asM φ <*> asM ψ        ≡ asM (φ <*> ψ)
return a                ≡ asM (return a)
asM φ >>= asM . k      ≡ asM (φ >>= k)
filtering p (asM φ)     ≡ asM (filtering p φ)
interspersing a (asM φ) ≡ asM (interspersing a φ)

asR :: p a b -> R a b

asR is a folding homomorphism to a right folding

run xs (asR φ)         ≡ run xs φ
prefix xs (asR φ)      ≡ asR (prefix xs φ)
prefixOf l xs (asR φ)  ≡ asR (prefixOf l xs φ)
postfix (asR φ) xs     ≡ asR (postfix φ xs)
postfixOf l (asR φ) xs ≡ asR (postfixOf l φ xs)
left' (asR φ)          ≡ asR (left' φ)
right' (asR φ)         ≡ asR (right' φ)
dimap l r (asR φ)      ≡ asR (dimap l r φ)
extract (asR φ)        ≡ extract φ
pure a                  ≡ asR (pure a)
asR φ <*> asR ψ        ≡ asR (φ <*> ψ)
return a                ≡ asR (return a)
asR φ >>= asR . k      ≡ asR (φ >>= k)
filtering p (asR φ)     ≡ asR (filtering p φ)
interspersing a (asR φ) ≡ asR (interspersing a φ)

Instances

AsRM L

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

Defined in Data.Fold

Methods

asM :: L a b -> M a b

asR :: L a b -> R a b

AsRM L'

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

Defined in Data.Fold

Methods

asM :: L' a b -> M a b

asR :: L' a b -> R a b

AsRM M

We can convert from a monoidal fold to a lazy right fold

Defined in Data.Fold

Methods

asM :: M a b -> M a b

asR :: M a b -> R a b

AsRM R

We can convert from a lazy right fold to a monoidal fold

Defined in Data.Fold

Methods

asM :: R a b -> M a b

asR :: R a b -> R a b

class (AsRM p, AsL1' p) => AsL' p where

Methods

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

asL' is a folding homomorphism to a strict left folding

run xs (asL' φ)         ≡ run xs φ
prefix xs (asL' φ)      ≡ asL' (prefix xs φ)
prefixOf l xs (asL' φ)  ≡ asL' (prefixOf l xs φ)
postfix (asL' φ) xs     ≡ asL' (postfix φ xs)
postfixOf l (asL' φ) xs ≡ asL' (postfixOf l φ xs)
left' (asL' φ)          ≡ asL' (left' φ)
right' (asL' φ)         ≡ asL' (right' φ)
dimap l r (asL' φ)      ≡ asL' (dimap l r φ)
extract (asL' φ)        ≡ extract φ
pure a                   ≡ asL' (pure a)
asL' φ <*> asL' ψ       ≡ asL' (φ <*> ψ)
return a                 ≡ asL' (return a)
asL' φ >>= asL' . k     ≡ asL' (φ >>= k)
filtering p (asL' φ)     ≡ asL' (filtering p φ)
interspersing a (asL' φ) ≡ asL' (interspersing a φ)

Instances

AsL' L

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

Defined in Data.Fold

Methods

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

AsL' L'

We can convert a lazy fold to itself

Defined in Data.Fold

Methods

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