Data.Fold.Class

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