Safe Haskell	Trustworthy
Language	Haskell98

Data.Fold.Class

Synopsis

Documentation

class Choice p => Scan p where #

Minimal complete definition

interspersing

Methods

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

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

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

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

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

Apply a Folding to a single element of input

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

Instances

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 #
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 #
Scan 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' #
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 #
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 #
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 #
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 #
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`
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`
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`
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`
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 #

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