
Data.Foldable.Speculation 





Synopsis 

fold :: (Foldable f, Monoid m, Eq m) => (Int > m) > f m > m   foldBy :: (Foldable f, Monoid m) => (m > m > Bool) > (Int > m) > f m > m   foldMap :: (Foldable f, Monoid m, Eq m) => (Int > m) > (a > m) > f a > m   foldMapBy :: (Foldable f, Monoid m) => (m > m > Bool) > (Int > m) > (a > m) > f a > m   foldr :: (Foldable f, Eq b) => (Int > b) > (a > b > b) > b > f a > b   foldrBy :: Foldable f => (b > b > Bool) > (Int > b) > (a > b > b) > b > f a > b   foldl :: (Foldable f, Eq b) => (Int > b) > (b > a > b) > b > f a > b   foldlBy :: Foldable f => (b > b > Bool) > (Int > b) > (b > a > b) > b > f a > b   foldr1 :: (Foldable f, Eq a) => (Int > a) > (a > a > a) > f a > a   foldr1By :: Foldable f => (a > a > Bool) > (Int > a) > (a > a > a) > f a > a   foldl1 :: (Foldable f, Eq a) => (Int > a) > (a > a > a) > f a > a   foldl1By :: Foldable f => (a > a > Bool) > (Int > a) > (a > a > a) > f a > a   foldrM :: (Foldable f, Monad m, Eq (m b)) => (Int > m b) > (a > b > m b) > m b > f a > m b   foldrByM :: (Foldable f, Monad m) => (m b > m b > Bool) > (Int > m b) > (a > b > m b) > m b > f a > m b   foldlM :: (Foldable f, Monad m, Eq (m b)) => (Int > m b) > (b > a > m b) > m b > f a > m b   foldlByM :: (Foldable f, Monad m) => (m b > m b > Bool) > (Int > m b) > (b > a > m b) > m b > f a > m b   foldrSTM :: (Foldable f, Eq b) => (Int > STM b) > (a > b > STM b) > STM b > f a > STM b   foldrBySTM :: Foldable f => (b > b > STM Bool) > (Int > STM b) > (a > b > STM b) > STM b > f a > STM b   foldlSTM :: (Foldable f, Eq a) => (Int > STM a) > (a > b > STM a) > STM a > f b > STM a   foldlBySTM :: Foldable f => (a > a > STM Bool) > (Int > STM a) > (a > b > STM a) > STM a > f b > STM a   traverse_ :: (Foldable t, Applicative f, Eq (f ())) => (Int > f c) > (a > f b) > t a > f ()   traverseBy_ :: (Foldable t, Applicative f) => (f () > f () > Bool) > (Int > f c) > (a > f b) > t a > f ()   for_ :: (Foldable t, Applicative f, Eq (f ())) => (Int > f c) > t a > (a > f b) > f ()   forBy_ :: (Foldable t, Applicative f) => (f () > f () > Bool) > (Int > f c) > t a > (a > f b) > f ()   sequenceA_ :: (Foldable t, Applicative f, Eq (f ())) => (Int > f b) > t (f a) > f ()   sequenceByA_ :: (Foldable t, Applicative f, Eq (f ())) => (f () > f () > Bool) > (Int > f b) > t (f a) > f ()   asum :: (Foldable t, Alternative f, Eq (f a)) => (Int > f a) > t (f a) > f a   asumBy :: (Foldable t, Alternative f) => (f a > f a > Bool) > (Int > f a) > t (f a) > f a   mapM_ :: (Foldable t, Monad m, Eq (m ())) => (Int > m c) > (a > m b) > t a > m ()   mapByM_ :: (Foldable t, Monad m) => (m () > m () > Bool) > (Int > m c) > (a > m b) > t a > m ()   forM_ :: (Foldable t, Monad m, Eq (m ())) => (Int > m c) > t a > (a > m b) > m ()   forByM_ :: (Foldable t, Monad m) => (m () > m () > Bool) > (Int > m c) > t a > (a > m b) > m ()   sequence_ :: (Foldable t, Monad m, Eq (m ())) => (Int > m b) > t (m a) > m ()   sequenceBy_ :: (Foldable t, Monad m) => (m () > m () > Bool) > (Int > m b) > t (m a) > m ()   msum :: (Foldable t, MonadPlus m, Eq (m a)) => (Int > m a) > t (m a) > m a   msumBy :: (Foldable t, MonadPlus m) => (m a > m a > Bool) > (Int > m a) > t (m a) > m a   mapSTM_ :: Foldable t => STM Bool > (Int > STM c) > (a > STM b) > t a > STM ()   forSTM_ :: Foldable t => STM Bool > (Int > STM c) > t a > (a > STM b) > STM ()   sequenceSTM_ :: Foldable t => STM Bool > (Int > STM a) > t (STM b) > STM ()   toList :: (Foldable t, Eq a) => (Int > [a]) > t a > [a]   toListBy :: Foldable t => ([a] > [a] > Bool) > (Int > [a]) > t a > [a]   concat :: (Foldable t, Eq a) => (Int > [a]) > t [a] > [a]   concatBy :: Foldable t => ([a] > [a] > Bool) > (Int > [a]) > t [a] > [a]   concatMap :: (Foldable t, Eq b) => (Int > [b]) > (a > [b]) > t a > [b]   concatMapBy :: Foldable t => ([b] > [b] > Bool) > (Int > [b]) > (a > [b]) > t a > [b]   all :: Foldable t => (Int > Bool) > (a > Bool) > t a > Bool   any :: Foldable t => (Int > Bool) > (a > Bool) > t a > Bool   and :: Foldable t => (Int > Bool) > t Bool > Bool   or :: Foldable t => (Int > Bool) > t Bool > Bool   sum :: (Foldable t, Num a) => (Int > a) > t a > a   sumBy :: (Foldable t, Num a) => (a > a > Bool) > (Int > a) > t a > a   product :: (Foldable t, Num a) => (Int > a) > t a > a   productBy :: (Foldable t, Num a) => (a > a > Bool) > (Int > a) > t a > a   maximum :: (Foldable t, Ord a) => (Int > a) > t a > a   maximumBy :: Foldable t => (a > a > Ordering) > (Int > a) > t a > a   minimum :: (Foldable t, Ord a) => (Int > a) > t a > a   minimumBy :: Foldable t => (a > a > Ordering) > (Int > a) > t a > a   elem :: (Foldable t, Eq a) => (Int > Bool) > a > t a > Bool   elemBy :: Foldable t => (a > a > Bool) > (Int > Bool) > a > t a > Bool   notElem :: (Foldable t, Eq a) => (Int > Bool) > a > t a > Bool   notElemBy :: Foldable t => (a > a > Bool) > (Int > Bool) > a > t a > Bool   find :: (Foldable t, Eq a) => (Int > Maybe a) > (a > Bool) > t a > Maybe a   findBy :: Foldable t => (Maybe a > Maybe a > Bool) > (Int > Maybe a) > (a > Bool) > t a > Maybe a 



Speculative folds



Given a valid estimator g, fold g f xs yields the same answer as fold f xs.
g n should supply an estimate of the value of the monoidal summation over the last n elements of the container.
If g n is accurate a reasonable percentage of the time and faster to compute than the fold, then this can
provide increased opportunities for parallelism.



fold using specBy



Given a valid estimator g, foldMap g f xs yields the same answer as foldMap f xs.
g n should supply an estimate of the value of the monoidal summation over the last n elements of the container.
If g n is accurate a reasonable percentage of the time and faster to compute than the fold, then this can
provide increased opportunities for parallelism.





Given a valid estimator g, foldr g f z xs yields the same answer as foldr' f z xs.
g n should supply an estimate of the value returned from folding over the last n elements of the container.
If g n is accurate a reasonable percentage of the time and faster to compute than the fold, then this can
provide increased opportunities for parallelism.





Given a valid estimator g, foldl g f z xs yields the same answer as foldl' f z xs.
g n should supply an estimate of the value returned from folding over the first n elements of the container.
If g n is accurate a reasonable percentage of the time and faster to compute than the fold, then this can
provide increased opportunities for parallelism.












Speculative monadic folds










Speculative transactional monadic folds










Folding actions


Applicative actions



Map each element of a structure to an action, evaluate these actions
from left to right and ignore the results.





for_ is traverse_ with its arguments flipped.












Monadic actions



Map each element of the structure to a monadic action, evaluating these actions
from left to right and ignoring the results.





for_ is mapM_ with its arguments flipped.












Speculative transactional monadic actions



Map each element of the structure to a monadic action, evaluating these actions
from left to right and ignoring the results, while transactional sideeffects from
misspeculated actions are rolled back.



for_ is mapM_ with its arguments flipped.




Specialized folds






































Searches














Produced by Haddock version 2.6.1 