Control.Foldl.Statistics

Introduction

Statistical functions from the Statistics.Sample module of the statistics package by Bryan O'Sullivan, implemented as Folds from the foldl package.

This allows many statistics to be computed concurrently with at most two passes over the data, usually by computing the mean first, and passing it to further Folds.

range :: Fold Double Double

The difference between the largest and smallest elements of a sample.

sum' :: Fold Double Double

A numerically stable sum using Kahan-Babuška-Neumaier summation from Numeric.Sum

histogram :: Ord a => Fold a (Map a Int)

Create a histogram of each value of type a. Useful for folding over categorical values, for example, a CSV where you have a data type for a selection of categories.

It should not be used for continuous values which would lead to a high number of keys. One way to avoid this is to use the Profunctor instance for Fold to break your values into categories. For an example of doing this, see ordersOfMagnitude.

histogram' :: (Hashable a, Eq a) => Fold a (HashMap a Int)

Like histogram, but for use when hashmaps would be more efficient for the particular type a.

ordersOfMagnitude :: Fold Double (Map Double Int)

Provides a histogram of the orders of magnitude of the values in a series. Negative values are placed in the 0.0 category due to the behaviour of logBase. it may be useful to use lmap abs on this Fold to get a histogram of the absolute magnitudes.

Statistics of location

mean :: Fold Double Double

Arithmetic mean. This uses Kahan-Babuška-Neumaier summation, so is more accurate than welfordMean unless the input values are very large.

Since foldl-1.2.2, Foldl exports a mean function, so you will have to hide one.

welfordMean :: Fold Double Double

Arithmetic mean. This uses Welford's algorithm to provide numerical stability, using a single pass over the sample data.

Compared to mean, this loses a surprising amount of precision unless the inputs are very large.

meanWeighted :: Fold (Double, Double) Double

Arithmetic mean for weighted sample. It uses a single-pass algorithm analogous to the one used by welfordMean.

harmonicMean :: Fold Double Double

Harmonic mean.

geometricMean :: Fold Double Double

Geometric mean of a sample containing no negative values.

Statistics of dispersion

The variance—and hence the standard deviation—of a sample of fewer than two elements are both defined to be zero.

Many of these Folds take the mean as an argument for constructing the variance, and as such require two passes over the data.

Functions over central moments

centralMoment :: Int -> Double -> Fold Double Double

Compute the kth central moment of a sample. The central moment is also known as the moment about the mean.

This function requires the mean of the data to compute the central moment.

For samples containing many values very close to the mean, this function is subject to inaccuracy due to catastrophic cancellation.

centralMoments :: Int -> Int -> Double -> Fold Double (Double, Double)

Compute the kth and jth central moments of a sample.

This fold requires the mean of the data to be known.

For samples containing many values very close to the mean, this function is subject to inaccuracy due to catastrophic cancellation.

centralMoments' :: Int -> Int -> Double -> Fold Double (Double, Double)

Compute the kth and jth central moments of a sample.

This fold requires the mean of the data to be known.

This variation of centralMoments uses Kahan-Babuška-Neumaier summation to attempt to improve the accuracy of results, which may make computation slower.

skewness :: Double -> Fold Double Double

Compute the skewness of a sample. This is a measure of the asymmetry of its distribution.

A sample with negative skew is said to be left-skewed. Most of its mass is on the right of the distribution, with the tail on the left.

skewness $ U.to [1,100,101,102,103]
==> -1.497681449918257

A sample with positive skew is said to be right-skewed.

skewness $ U.to [1,2,3,4,100]
==> 1.4975367033335198

A sample's skewness is not defined if its variance is zero.

This fold requires the mean of the data to be known.

For samples containing many values very close to the mean, this function is subject to inaccuracy due to catastrophic cancellation.

kurtosis :: Double -> Fold Double Double

Compute the excess kurtosis of a sample. This is a measure of the "peakedness" of its distribution. A high kurtosis indicates that more of the sample's variance is due to infrequent severe deviations, rather than more frequent modest deviations.

A sample's excess kurtosis is not defined if its variance is zero.

This fold requires the mean of the data to be known.

For samples containing many values very close to the mean, this function is subject to inaccuracy due to catastrophic cancellation.

Functions requiring the mean to be known (numerically robust)

These functions use the compensated summation algorithm of Chan et al. for numerical robustness, but require two passes over the sample data as a result.

variance :: Double -> Fold Double Double

Maximum likelihood estimate of a sample's variance. Also known as the population variance, where the denominator is n.

varianceUnbiased :: Double -> Fold Double Double

Unbiased estimate of a sample's variance. Also known as the sample variance, where the denominator is n-1.

stdDev :: Double -> Fold Double Double

Standard deviation. This is simply the square root of the unbiased estimate of the variance.

varianceWeighted :: Double -> Fold (Double, Double) Double

Weighted variance. This is biased estimation. Requires the weighted mean of the input data.

Single-pass functions (faster, less safe)

The functions prefixed with the name fast below perform a single pass over the sample data using Knuth's algorithm. They usually work well, but see below for caveats. These functions are subject to fusion and do not require the mean to be passed.

Note: in cases where most sample data is close to the sample's mean, Knuth's algorithm gives inaccurate results due to catastrophic cancellation.

fastVariance :: Fold Double Double

Maximum likelihood estimate of a sample's variance.

fastVarianceUnbiased :: Fold Double Double

Maximum likelihood estimate of a sample's variance.

fastStdDev :: Fold Double Double

Standard deviation. This is simply the square root of the maximum likelihood estimate of the variance.

fastLMVSK :: Fold Double LMVSK

Efficiently compute the length, mean, variance, skewness and kurtosis with a single pass.

Since: 0.1.1.0

fastLMVSKu :: Fold Double LMVSK

Efficiently compute the length, mean, unbiased variance, skewness and kurtosis with a single pass.

Since: 0.1.3.0

data LMVSK

When returned by fastLMVSK, contains the count, mean, variance, skewness and kurtosis of a series of samples.

Since: 0.1.1.0

Constructors

LMVSK

Fields

• lmvskCount :: !Int
• lmvskMean :: !Double
• lmvskVariance :: !Double
• lmvskSkewness :: !Double
• lmvskKurtosis :: !Double

Instances

Eq LMVSK

Defined in Control.Foldl.Statistics

Methods

(==) :: LMVSK -> LMVSK -> Bool

(/=) :: LMVSK -> LMVSK -> Bool

Show LMVSK

Defined in Control.Foldl.Statistics

Methods

showsPrec :: Int -> LMVSK -> ShowS

show :: LMVSK -> String

showList :: [LMVSK] -> ShowS

data LMVSKState

Instances

Semigroup LMVSKState

Defined in Control.Foldl.Statistics

Methods

(<>) :: LMVSKState -> LMVSKState -> LMVSKState

sconcat :: NonEmpty LMVSKState -> LMVSKState

stimes :: Integral b => b -> LMVSKState -> LMVSKState

Monoid LMVSKState

Defined in Control.Foldl.Statistics

Methods

mempty :: LMVSKState

mappend :: LMVSKState -> LMVSKState -> LMVSKState

mconcat :: [LMVSKState] -> LMVSKState

foldLMVSKState :: Fold Double LMVSKState

Performs the heavy lifting of fastLMVSK. This is exposed because the internal LMVSKState is monoidal, allowing you to run these statistics in parallel over datasets which are split and then combine the results.

Since: 0.1.2.0

getLMVSK :: LMVSKState -> LMVSK

Returns the stats which have been computed in a LMVSKState.

Since: 0.1.2.0

getLMVSKu :: LMVSKState -> LMVSK

Returns the stats which have been computed in a LMVSKState, with the unbiased variance.

Since: 0.1.2.0

Linear Regression

fastLinearReg :: Fold (Double, Double) LinRegResult

Computes the slope, (Y) intercept and correlation of (x,y) pairs, as well as the LMVSK stats for both the x and y series.

>>> F.fold fastLinearReg $ map (\x -> (x,3*x+7)) [1..100]
LinRegResult
  {lrrSlope = 3.0
  , lrrIntercept = 7.0
  , lrrCorrelation = 100.0
  , lrrXStats = LMVSK
      {lmvskCount = 100
      , lmvskMean = 50.5
      , lmvskVariance = 833.25
      , lmvskSkewness = 0.0
      , lmvskKurtosis = -1.2002400240024003}
  , lrrYStats = LMVSK
      {lmvskCount = 100
      , lmvskMean = 158.5
      , lmvskVariance = 7499.25
      , lmvskSkewness = 0.0
      , lmvskKurtosis = -1.2002400240024003}
  }

>>> F.fold fastLinearReg $ map (\x -> (x,0.005*x*x+3*x+7)) [1..100]
LinRegResult
  {lrrSlope = 3.5049999999999994
  , lrrIntercept = -1.5849999999999795
  , lrrCorrelation = 99.93226275740273
  , lrrXStats = LMVSK
      {lmvskCount = 100
      , lmvskMean = 50.5
      , lmvskVariance = 833.25
      , lmvskSkewness = 0.0
      , lmvskKurtosis = -1.2002400240024003}
  , lrrYStats = LMVSK
      {lmvskCount = 100
      , lmvskMean = 175.4175
      , lmvskVariance = 10250.37902625
      , lmvskSkewness = 9.862971188165422e-2
      , lmvskKurtosis = -1.1923628437011482}
  }

Since: 0.1.1.0

foldLinRegState :: Fold (Double, Double) LinRegState

Performs the heavy lifting for fastLinReg. Exposed because LinRegState is a Monoid, allowing statistics to be computed on datasets in parallel and combined afterwards.

Since: 0.1.4.0

getLinRegResult :: LinRegState -> LinRegResult

Produces the slope, Y intercept, correlation and LMVSK stats from a LinRegState.

Since: 0.1.4.0

data LinRegResult

When returned by fastLinearReg, contains the count, slope, intercept and correlation of combining (x,y) pairs.

Since: 0.1.1.0

Constructors

LinRegResult

Fields

• lrrSlope :: !Double
• lrrIntercept :: !Double
• lrrCorrelation :: !Double
• lrrXStats :: !LMVSK
• lrrYStats :: !LMVSK

Instances

Eq LinRegResult

Defined in Control.Foldl.Statistics

Methods

(==) :: LinRegResult -> LinRegResult -> Bool

(/=) :: LinRegResult -> LinRegResult -> Bool

Show LinRegResult

Defined in Control.Foldl.Statistics

Methods

showsPrec :: Int -> LinRegResult -> ShowS

show :: LinRegResult -> String

showList :: [LinRegResult] -> ShowS

data LinRegState

The Monoidal state used to compute linear regression, see fastLinearReg.

Since: 0.1.4.0

Instances

Semigroup LinRegState

Defined in Control.Foldl.Statistics

Methods

(<>) :: LinRegState -> LinRegState -> LinRegState

sconcat :: NonEmpty LinRegState -> LinRegState

stimes :: Integral b => b -> LinRegState -> LinRegState

Monoid LinRegState

Defined in Control.Foldl.Statistics

Methods

mempty :: LinRegState

mappend :: LinRegState -> LinRegState -> LinRegState

mconcat :: [LinRegState] -> LinRegState

lrrCount :: LinRegResult -> Int

The number of elements which make up this LinRegResult Since: 0.1.4.1

correlation :: (Double, Double) -> (Double, Double) -> Fold (Double, Double) Double

Given the mean and standard deviation of two distributions, computes the correlation between them, given the means and standard deviation of the x and y series. The results may be more accurate than those returned by fastLinearReg

References

• Chan, T. F.; Golub, G.H.; LeVeque, R.J. (1979) Updating formulae and a pairwise algorithm for computing sample variances. Technical Report STAN-CS-79-773, Department of Computer Science, Stanford University. ftp://reports.stanford.edu/pub/cstr/reports/cs/tr/79/773/CS-TR-79-773.pdf
• Knuth, D.E. (1998) The art of computer programming, volume 2: seminumerical algorithms, 3rd ed., p. 232.
• Welford, B.P. (1962) Note on a method for calculating corrected sums of squares and products. Technometrics 4(3):419–420. http://www.jstor.org/stable/1266577
• West, D.H.D. (1979) Updating mean and variance estimates: an improved method. Communications of the ACM 22(9):532–535. http://doi.acm.org/10.1145/359146.359153
• John D. Cook. Computing skewness and kurtosis in one pass http://www.johndcook.com/blog/skewness_kurtosis/

class Foldable (t :: * -> *)

Data structures that can be folded.

For example, given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Foldable Tree where
   foldMap f Empty = mempty
   foldMap f (Leaf x) = f x
   foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r

This is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws. Alternatively, one could define foldr:

instance Foldable Tree where
   foldr f z Empty = z
   foldr f z (Leaf x) = f x z
   foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l

Foldable instances are expected to satisfy the following laws:

foldr f z t = appEndo (foldMap (Endo . f) t ) z

foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z

fold = foldMap id

length = getSum . foldMap (Sum . const  1)

sum, product, maximum, and minimum should all be essentially equivalent to foldMap forms, such as

sum = getSum . foldMap Sum

but may be less defined.

If the type is also a Functor instance, it should satisfy

foldMap f = fold . fmap f

which implies that

foldMap f . fmap g = foldMap (f . g)

Minimal complete definition

foldMap | foldr

Instances

Foldable []

Since: base-2.1

Defined in Data.Foldable

Methods

fold :: Monoid m => [m] -> m

foldMap :: Monoid m => (a -> m) -> [a] -> m

foldr :: (a -> b -> b) -> b -> [a] -> b

foldr' :: (a -> b -> b) -> b -> [a] -> b

foldl :: (b -> a -> b) -> b -> [a] -> b

foldl' :: (b -> a -> b) -> b -> [a] -> b

foldr1 :: (a -> a -> a) -> [a] -> a

foldl1 :: (a -> a -> a) -> [a] -> a

toList :: [a] -> [a]

null :: [a] -> Bool

length :: [a] -> Int

elem :: Eq a => a -> [a] -> Bool

maximum :: Ord a => [a] -> a

minimum :: Ord a => [a] -> a

sum :: Num a => [a] -> a

product :: Num a => [a] -> a

Foldable Maybe

Since: base-2.1

Defined in Data.Foldable

Methods

fold :: Monoid m => Maybe m -> m

foldMap :: Monoid m => (a -> m) -> Maybe a -> m

foldr :: (a -> b -> b) -> b -> Maybe a -> b

foldr' :: (a -> b -> b) -> b -> Maybe a -> b

foldl :: (b -> a -> b) -> b -> Maybe a -> b

foldl' :: (b -> a -> b) -> b -> Maybe a -> b

foldr1 :: (a -> a -> a) -> Maybe a -> a

foldl1 :: (a -> a -> a) -> Maybe a -> a

toList :: Maybe a -> [a]

null :: Maybe a -> Bool

length :: Maybe a -> Int

elem :: Eq a => a -> Maybe a -> Bool

maximum :: Ord a => Maybe a -> a

minimum :: Ord a => Maybe a -> a

sum :: Num a => Maybe a -> a

product :: Num a => Maybe a -> a

Foldable Par1

Defined in Data.Foldable

Methods

fold :: Monoid m => Par1 m -> m

foldMap :: Monoid m => (a -> m) -> Par1 a -> m

foldr :: (a -> b -> b) -> b -> Par1 a -> b

foldr' :: (a -> b -> b) -> b -> Par1 a -> b

foldl :: (b -> a -> b) -> b -> Par1 a -> b

foldl' :: (b -> a -> b) -> b -> Par1 a -> b

foldr1 :: (a -> a -> a) -> Par1 a -> a

foldl1 :: (a -> a -> a) -> Par1 a -> a

toList :: Par1 a -> [a]

null :: Par1 a -> Bool

length :: Par1 a -> Int

elem :: Eq a => a -> Par1 a -> Bool

maximum :: Ord a => Par1 a -> a

minimum :: Ord a => Par1 a -> a

sum :: Num a => Par1 a -> a

product :: Num a => Par1 a -> a

Foldable Complex

Defined in Data.Complex

Methods

fold :: Monoid m => Complex m -> m

foldMap :: Monoid m => (a -> m) -> Complex a -> m

foldr :: (a -> b -> b) -> b -> Complex a -> b

foldr' :: (a -> b -> b) -> b -> Complex a -> b

foldl :: (b -> a -> b) -> b -> Complex a -> b

foldl' :: (b -> a -> b) -> b -> Complex a -> b

foldr1 :: (a -> a -> a) -> Complex a -> a

foldl1 :: (a -> a -> a) -> Complex a -> a

toList :: Complex a -> [a]

null :: Complex a -> Bool

length :: Complex a -> Int

elem :: Eq a => a -> Complex a -> Bool

maximum :: Ord a => Complex a -> a

minimum :: Ord a => Complex a -> a

sum :: Num a => Complex a -> a

product :: Num a => Complex a -> a

Foldable Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Min m -> m

foldMap :: Monoid m => (a -> m) -> Min a -> m

foldr :: (a -> b -> b) -> b -> Min a -> b

foldr' :: (a -> b -> b) -> b -> Min a -> b

foldl :: (b -> a -> b) -> b -> Min a -> b

foldl' :: (b -> a -> b) -> b -> Min a -> b

foldr1 :: (a -> a -> a) -> Min a -> a

foldl1 :: (a -> a -> a) -> Min a -> a

toList :: Min a -> [a]

null :: Min a -> Bool

length :: Min a -> Int

elem :: Eq a => a -> Min a -> Bool

maximum :: Ord a => Min a -> a

minimum :: Ord a => Min a -> a

sum :: Num a => Min a -> a

product :: Num a => Min a -> a

Foldable Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Max m -> m

foldMap :: Monoid m => (a -> m) -> Max a -> m

foldr :: (a -> b -> b) -> b -> Max a -> b

foldr' :: (a -> b -> b) -> b -> Max a -> b

foldl :: (b -> a -> b) -> b -> Max a -> b

foldl' :: (b -> a -> b) -> b -> Max a -> b

foldr1 :: (a -> a -> a) -> Max a -> a

foldl1 :: (a -> a -> a) -> Max a -> a

toList :: Max a -> [a]

null :: Max a -> Bool

length :: Max a -> Int

elem :: Eq a => a -> Max a -> Bool

maximum :: Ord a => Max a -> a

minimum :: Ord a => Max a -> a

sum :: Num a => Max a -> a

product :: Num a => Max a -> a

Foldable First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => First m -> m

foldMap :: Monoid m => (a -> m) -> First a -> m

foldr :: (a -> b -> b) -> b -> First a -> b

foldr' :: (a -> b -> b) -> b -> First a -> b

foldl :: (b -> a -> b) -> b -> First a -> b

foldl' :: (b -> a -> b) -> b -> First a -> b

foldr1 :: (a -> a -> a) -> First a -> a

foldl1 :: (a -> a -> a) -> First a -> a

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

elem :: Eq a => a -> First a -> Bool

maximum :: Ord a => First a -> a

minimum :: Ord a => First a -> a

sum :: Num a => First a -> a

product :: Num a => First a -> a

Foldable Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Last m -> m

foldMap :: Monoid m => (a -> m) -> Last a -> m

foldr :: (a -> b -> b) -> b -> Last a -> b

foldr' :: (a -> b -> b) -> b -> Last a -> b

foldl :: (b -> a -> b) -> b -> Last a -> b

foldl' :: (b -> a -> b) -> b -> Last a -> b

foldr1 :: (a -> a -> a) -> Last a -> a

foldl1 :: (a -> a -> a) -> Last a -> a

toList :: Last a -> [a]

null :: Last a -> Bool

length :: Last a -> Int

elem :: Eq a => a -> Last a -> Bool

maximum :: Ord a => Last a -> a

minimum :: Ord a => Last a -> a

sum :: Num a => Last a -> a

product :: Num a => Last a -> a

Foldable Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Option m -> m

foldMap :: Monoid m => (a -> m) -> Option a -> m

foldr :: (a -> b -> b) -> b -> Option a -> b

foldr' :: (a -> b -> b) -> b -> Option a -> b

foldl :: (b -> a -> b) -> b -> Option a -> b

foldl' :: (b -> a -> b) -> b -> Option a -> b

foldr1 :: (a -> a -> a) -> Option a -> a

foldl1 :: (a -> a -> a) -> Option a -> a

toList :: Option a -> [a]

null :: Option a -> Bool

length :: Option a -> Int

elem :: Eq a => a -> Option a -> Bool

maximum :: Ord a => Option a -> a

minimum :: Ord a => Option a -> a

sum :: Num a => Option a -> a

product :: Num a => Option a -> a

Foldable Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

fold :: Monoid m => Identity m -> m

foldMap :: Monoid m => (a -> m) -> Identity a -> m

foldr :: (a -> b -> b) -> b -> Identity a -> b

foldr' :: (a -> b -> b) -> b -> Identity a -> b

foldl :: (b -> a -> b) -> b -> Identity a -> b

foldl' :: (b -> a -> b) -> b -> Identity a -> b

foldr1 :: (a -> a -> a) -> Identity a -> a

foldl1 :: (a -> a -> a) -> Identity a -> a

toList :: Identity a -> [a]

null :: Identity a -> Bool

length :: Identity a -> Int

elem :: Eq a => a -> Identity a -> Bool

maximum :: Ord a => Identity a -> a

minimum :: Ord a => Identity a -> a

sum :: Num a => Identity a -> a

product :: Num a => Identity a -> a

Foldable First

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => First m -> m

foldMap :: Monoid m => (a -> m) -> First a -> m

foldr :: (a -> b -> b) -> b -> First a -> b

foldr' :: (a -> b -> b) -> b -> First a -> b

foldl :: (b -> a -> b) -> b -> First a -> b

foldl' :: (b -> a -> b) -> b -> First a -> b

foldr1 :: (a -> a -> a) -> First a -> a

foldl1 :: (a -> a -> a) -> First a -> a

toList :: First a -> [a]

null :: First a -> Bool

length :: First a -> Int

elem :: Eq a => a -> First a -> Bool

maximum :: Ord a => First a -> a

minimum :: Ord a => First a -> a

sum :: Num a => First a -> a

product :: Num a => First a -> a

Foldable Last

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Last m -> m

foldMap :: Monoid m => (a -> m) -> Last a -> m

foldr :: (a -> b -> b) -> b -> Last a -> b

foldr' :: (a -> b -> b) -> b -> Last a -> b

foldl :: (b -> a -> b) -> b -> Last a -> b

foldl' :: (b -> a -> b) -> b -> Last a -> b

foldr1 :: (a -> a -> a) -> Last a -> a

foldl1 :: (a -> a -> a) -> Last a -> a

toList :: Last a -> [a]

null :: Last a -> Bool

length :: Last a -> Int

elem :: Eq a => a -> Last a -> Bool

maximum :: Ord a => Last a -> a

minimum :: Ord a => Last a -> a

sum :: Num a => Last a -> a

product :: Num a => Last a -> a

Foldable Dual

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Dual m -> m

foldMap :: Monoid m => (a -> m) -> Dual a -> m

foldr :: (a -> b -> b) -> b -> Dual a -> b

foldr' :: (a -> b -> b) -> b -> Dual a -> b

foldl :: (b -> a -> b) -> b -> Dual a -> b

foldl' :: (b -> a -> b) -> b -> Dual a -> b

foldr1 :: (a -> a -> a) -> Dual a -> a

foldl1 :: (a -> a -> a) -> Dual a -> a

toList :: Dual a -> [a]

null :: Dual a -> Bool

length :: Dual a -> Int

elem :: Eq a => a -> Dual a -> Bool

maximum :: Ord a => Dual a -> a

minimum :: Ord a => Dual a -> a

sum :: Num a => Dual a -> a

product :: Num a => Dual a -> a

Foldable Sum

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Sum m -> m

foldMap :: Monoid m => (a -> m) -> Sum a -> m

foldr :: (a -> b -> b) -> b -> Sum a -> b

foldr' :: (a -> b -> b) -> b -> Sum a -> b

foldl :: (b -> a -> b) -> b -> Sum a -> b

foldl' :: (b -> a -> b) -> b -> Sum a -> b

foldr1 :: (a -> a -> a) -> Sum a -> a

foldl1 :: (a -> a -> a) -> Sum a -> a

toList :: Sum a -> [a]

null :: Sum a -> Bool

length :: Sum a -> Int

elem :: Eq a => a -> Sum a -> Bool

maximum :: Ord a => Sum a -> a

minimum :: Ord a => Sum a -> a

sum :: Num a => Sum a -> a

product :: Num a => Sum a -> a

Foldable Product

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Product m -> m

foldMap :: Monoid m => (a -> m) -> Product a -> m

foldr :: (a -> b -> b) -> b -> Product a -> b

foldr' :: (a -> b -> b) -> b -> Product a -> b

foldl :: (b -> a -> b) -> b -> Product a -> b

foldl' :: (b -> a -> b) -> b -> Product a -> b

foldr1 :: (a -> a -> a) -> Product a -> a

foldl1 :: (a -> a -> a) -> Product a -> a

toList :: Product a -> [a]

null :: Product a -> Bool

length :: Product a -> Int

elem :: Eq a => a -> Product a -> Bool

maximum :: Ord a => Product a -> a

minimum :: Ord a => Product a -> a

sum :: Num a => Product a -> a

product :: Num a => Product a -> a

Foldable NonEmpty

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => NonEmpty m -> m

foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m

foldr :: (a -> b -> b) -> b -> NonEmpty a -> b

foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b

foldl :: (b -> a -> b) -> b -> NonEmpty a -> b

foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b

foldr1 :: (a -> a -> a) -> NonEmpty a -> a

foldl1 :: (a -> a -> a) -> NonEmpty a -> a

toList :: NonEmpty a -> [a]

null :: NonEmpty a -> Bool

length :: NonEmpty a -> Int

elem :: Eq a => a -> NonEmpty a -> Bool

maximum :: Ord a => NonEmpty a -> a

minimum :: Ord a => NonEmpty a -> a

sum :: Num a => NonEmpty a -> a

product :: Num a => NonEmpty a -> a

Foldable IntMap

Defined in Data.IntMap.Internal

Methods

fold :: Monoid m => IntMap m -> m

foldMap :: Monoid m => (a -> m) -> IntMap a -> m

foldr :: (a -> b -> b) -> b -> IntMap a -> b

foldr' :: (a -> b -> b) -> b -> IntMap a -> b

foldl :: (b -> a -> b) -> b -> IntMap a -> b

foldl' :: (b -> a -> b) -> b -> IntMap a -> b

foldr1 :: (a -> a -> a) -> IntMap a -> a

foldl1 :: (a -> a -> a) -> IntMap a -> a

toList :: IntMap a -> [a]

null :: IntMap a -> Bool

length :: IntMap a -> Int

elem :: Eq a => a -> IntMap a -> Bool

maximum :: Ord a => IntMap a -> a

minimum :: Ord a => IntMap a -> a

sum :: Num a => IntMap a -> a

product :: Num a => IntMap a -> a

Foldable Tree

Defined in Data.Tree

Methods

fold :: Monoid m => Tree m -> m

foldMap :: Monoid m => (a -> m) -> Tree a -> m

foldr :: (a -> b -> b) -> b -> Tree a -> b

foldr' :: (a -> b -> b) -> b -> Tree a -> b

foldl :: (b -> a -> b) -> b -> Tree a -> b

foldl' :: (b -> a -> b) -> b -> Tree a -> b

foldr1 :: (a -> a -> a) -> Tree a -> a

foldl1 :: (a -> a -> a) -> Tree a -> a

toList :: Tree a -> [a]

null :: Tree a -> Bool

length :: Tree a -> Int

elem :: Eq a => a -> Tree a -> Bool

maximum :: Ord a => Tree a -> a

minimum :: Ord a => Tree a -> a

sum :: Num a => Tree a -> a

product :: Num a => Tree a -> a

Foldable Seq

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Seq m -> m

foldMap :: Monoid m => (a -> m) -> Seq a -> m

foldr :: (a -> b -> b) -> b -> Seq a -> b

foldr' :: (a -> b -> b) -> b -> Seq a -> b

foldl :: (b -> a -> b) -> b -> Seq a -> b

foldl' :: (b -> a -> b) -> b -> Seq a -> b

foldr1 :: (a -> a -> a) -> Seq a -> a

foldl1 :: (a -> a -> a) -> Seq a -> a

toList :: Seq a -> [a]

null :: Seq a -> Bool

length :: Seq a -> Int

elem :: Eq a => a -> Seq a -> Bool

maximum :: Ord a => Seq a -> a

minimum :: Ord a => Seq a -> a

sum :: Num a => Seq a -> a

product :: Num a => Seq a -> a

Foldable FingerTree

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => FingerTree m -> m

foldMap :: Monoid m => (a -> m) -> FingerTree a -> m

foldr :: (a -> b -> b) -> b -> FingerTree a -> b

foldr' :: (a -> b -> b) -> b -> FingerTree a -> b

foldl :: (b -> a -> b) -> b -> FingerTree a -> b

foldl' :: (b -> a -> b) -> b -> FingerTree a -> b

foldr1 :: (a -> a -> a) -> FingerTree a -> a

foldl1 :: (a -> a -> a) -> FingerTree a -> a

toList :: FingerTree a -> [a]

null :: FingerTree a -> Bool

length :: FingerTree a -> Int

elem :: Eq a => a -> FingerTree a -> Bool

maximum :: Ord a => FingerTree a -> a

minimum :: Ord a => FingerTree a -> a

sum :: Num a => FingerTree a -> a

product :: Num a => FingerTree a -> a

Foldable Digit

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Digit m -> m

foldMap :: Monoid m => (a -> m) -> Digit a -> m

foldr :: (a -> b -> b) -> b -> Digit a -> b

foldr' :: (a -> b -> b) -> b -> Digit a -> b

foldl :: (b -> a -> b) -> b -> Digit a -> b

foldl' :: (b -> a -> b) -> b -> Digit a -> b

foldr1 :: (a -> a -> a) -> Digit a -> a

foldl1 :: (a -> a -> a) -> Digit a -> a

toList :: Digit a -> [a]

null :: Digit a -> Bool

length :: Digit a -> Int

elem :: Eq a => a -> Digit a -> Bool

maximum :: Ord a => Digit a -> a

minimum :: Ord a => Digit a -> a

sum :: Num a => Digit a -> a

product :: Num a => Digit a -> a

Foldable Node

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Node m -> m

foldMap :: Monoid m => (a -> m) -> Node a -> m

foldr :: (a -> b -> b) -> b -> Node a -> b

foldr' :: (a -> b -> b) -> b -> Node a -> b

foldl :: (b -> a -> b) -> b -> Node a -> b

foldl' :: (b -> a -> b) -> b -> Node a -> b

foldr1 :: (a -> a -> a) -> Node a -> a

foldl1 :: (a -> a -> a) -> Node a -> a

toList :: Node a -> [a]

null :: Node a -> Bool

length :: Node a -> Int

elem :: Eq a => a -> Node a -> Bool

maximum :: Ord a => Node a -> a

minimum :: Ord a => Node a -> a

sum :: Num a => Node a -> a

product :: Num a => Node a -> a

Foldable Elem

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => Elem m -> m

foldMap :: Monoid m => (a -> m) -> Elem a -> m

foldr :: (a -> b -> b) -> b -> Elem a -> b

foldr' :: (a -> b -> b) -> b -> Elem a -> b

foldl :: (b -> a -> b) -> b -> Elem a -> b

foldl' :: (b -> a -> b) -> b -> Elem a -> b

foldr1 :: (a -> a -> a) -> Elem a -> a

foldl1 :: (a -> a -> a) -> Elem a -> a

toList :: Elem a -> [a]

null :: Elem a -> Bool

length :: Elem a -> Int

elem :: Eq a => a -> Elem a -> Bool

maximum :: Ord a => Elem a -> a

minimum :: Ord a => Elem a -> a

sum :: Num a => Elem a -> a

product :: Num a => Elem a -> a

Foldable ViewL

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => ViewL m -> m

foldMap :: Monoid m => (a -> m) -> ViewL a -> m

foldr :: (a -> b -> b) -> b -> ViewL a -> b

foldr' :: (a -> b -> b) -> b -> ViewL a -> b

foldl :: (b -> a -> b) -> b -> ViewL a -> b

foldl' :: (b -> a -> b) -> b -> ViewL a -> b

foldr1 :: (a -> a -> a) -> ViewL a -> a

foldl1 :: (a -> a -> a) -> ViewL a -> a

toList :: ViewL a -> [a]

null :: ViewL a -> Bool

length :: ViewL a -> Int

elem :: Eq a => a -> ViewL a -> Bool

maximum :: Ord a => ViewL a -> a

minimum :: Ord a => ViewL a -> a

sum :: Num a => ViewL a -> a

product :: Num a => ViewL a -> a

Foldable ViewR

Defined in Data.Sequence.Internal

Methods

fold :: Monoid m => ViewR m -> m

foldMap :: Monoid m => (a -> m) -> ViewR a -> m

foldr :: (a -> b -> b) -> b -> ViewR a -> b

foldr' :: (a -> b -> b) -> b -> ViewR a -> b

foldl :: (b -> a -> b) -> b -> ViewR a -> b

foldl' :: (b -> a -> b) -> b -> ViewR a -> b

foldr1 :: (a -> a -> a) -> ViewR a -> a

foldl1 :: (a -> a -> a) -> ViewR a -> a

toList :: ViewR a -> [a]

null :: ViewR a -> Bool

length :: ViewR a -> Int

elem :: Eq a => a -> ViewR a -> Bool

maximum :: Ord a => ViewR a -> a

minimum :: Ord a => ViewR a -> a

sum :: Num a => ViewR a -> a

product :: Num a => ViewR a -> a

Foldable Set

Defined in Data.Set.Internal

Methods

fold :: Monoid m => Set m -> m

foldMap :: Monoid m => (a -> m) -> Set a -> m

foldr :: (a -> b -> b) -> b -> Set a -> b

foldr' :: (a -> b -> b) -> b -> Set a -> b

foldl :: (b -> a -> b) -> b -> Set a -> b

foldl' :: (b -> a -> b) -> b -> Set a -> b

foldr1 :: (a -> a -> a) -> Set a -> a

foldl1 :: (a -> a -> a) -> Set a -> a

toList :: Set a -> [a]

null :: Set a -> Bool

length :: Set a -> Int

elem :: Eq a => a -> Set a -> Bool

maximum :: Ord a => Set a -> a

minimum :: Ord a => Set a -> a

sum :: Num a => Set a -> a

product :: Num a => Set a -> a

Foldable Hashed

Defined in Data.Hashable.Class

Methods

fold :: Monoid m => Hashed m -> m

foldMap :: Monoid m => (a -> m) -> Hashed a -> m

foldr :: (a -> b -> b) -> b -> Hashed a -> b

foldr' :: (a -> b -> b) -> b -> Hashed a -> b

foldl :: (b -> a -> b) -> b -> Hashed a -> b

foldl' :: (b -> a -> b) -> b -> Hashed a -> b

foldr1 :: (a -> a -> a) -> Hashed a -> a

foldl1 :: (a -> a -> a) -> Hashed a -> a

toList :: Hashed a -> [a]

null :: Hashed a -> Bool

length :: Hashed a -> Int

elem :: Eq a => a -> Hashed a -> Bool

maximum :: Ord a => Hashed a -> a

minimum :: Ord a => Hashed a -> a

sum :: Num a => Hashed a -> a

product :: Num a => Hashed a -> a

Foldable HashSet

Defined in Data.HashSet

Methods

fold :: Monoid m => HashSet m -> m

foldMap :: Monoid m => (a -> m) -> HashSet a -> m

foldr :: (a -> b -> b) -> b -> HashSet a -> b

foldr' :: (a -> b -> b) -> b -> HashSet a -> b

foldl :: (b -> a -> b) -> b -> HashSet a -> b

foldl' :: (b -> a -> b) -> b -> HashSet a -> b

foldr1 :: (a -> a -> a) -> HashSet a -> a

foldl1 :: (a -> a -> a) -> HashSet a -> a

toList :: HashSet a -> [a]

null :: HashSet a -> Bool

length :: HashSet a -> Int

elem :: Eq a => a -> HashSet a -> Bool

maximum :: Ord a => HashSet a -> a

minimum :: Ord a => HashSet a -> a

sum :: Num a => HashSet a -> a

product :: Num a => HashSet a -> a

Foldable Vector

Defined in Data.Vector

Methods

fold :: Monoid m => Vector m -> m

foldMap :: Monoid m => (a -> m) -> Vector a -> m

foldr :: (a -> b -> b) -> b -> Vector a -> b

foldr' :: (a -> b -> b) -> b -> Vector a -> b

foldl :: (b -> a -> b) -> b -> Vector a -> b

foldl' :: (b -> a -> b) -> b -> Vector a -> b

foldr1 :: (a -> a -> a) -> Vector a -> a

foldl1 :: (a -> a -> a) -> Vector a -> a

toList :: Vector a -> [a]

null :: Vector a -> Bool

length :: Vector a -> Int

elem :: Eq a => a -> Vector a -> Bool

maximum :: Ord a => Vector a -> a

minimum :: Ord a => Vector a -> a

sum :: Num a => Vector a -> a

product :: Num a => Vector a -> a

Foldable (Either a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Either a m -> m

foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0

toList :: Either a a0 -> [a0]

null :: Either a a0 -> Bool

length :: Either a a0 -> Int

elem :: Eq a0 => a0 -> Either a a0 -> Bool

maximum :: Ord a0 => Either a a0 -> a0

minimum :: Ord a0 => Either a a0 -> a0

sum :: Num a0 => Either a a0 -> a0

product :: Num a0 => Either a a0 -> a0

Foldable (V1 :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => V1 m -> m

foldMap :: Monoid m => (a -> m) -> V1 a -> m

foldr :: (a -> b -> b) -> b -> V1 a -> b

foldr' :: (a -> b -> b) -> b -> V1 a -> b

foldl :: (b -> a -> b) -> b -> V1 a -> b

foldl' :: (b -> a -> b) -> b -> V1 a -> b

foldr1 :: (a -> a -> a) -> V1 a -> a

foldl1 :: (a -> a -> a) -> V1 a -> a

toList :: V1 a -> [a]

null :: V1 a -> Bool

length :: V1 a -> Int

elem :: Eq a => a -> V1 a -> Bool

maximum :: Ord a => V1 a -> a

minimum :: Ord a => V1 a -> a

sum :: Num a => V1 a -> a

product :: Num a => V1 a -> a

Foldable (U1 :: * -> *)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => U1 m -> m

foldMap :: Monoid m => (a -> m) -> U1 a -> m

foldr :: (a -> b -> b) -> b -> U1 a -> b

foldr' :: (a -> b -> b) -> b -> U1 a -> b

foldl :: (b -> a -> b) -> b -> U1 a -> b

foldl' :: (b -> a -> b) -> b -> U1 a -> b

foldr1 :: (a -> a -> a) -> U1 a -> a

foldl1 :: (a -> a -> a) -> U1 a -> a

toList :: U1 a -> [a]

null :: U1 a -> Bool

length :: U1 a -> Int

elem :: Eq a => a -> U1 a -> Bool

maximum :: Ord a => U1 a -> a

minimum :: Ord a => U1 a -> a

sum :: Num a => U1 a -> a

product :: Num a => U1 a -> a

Foldable ((,) a)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => (a, m) -> m

foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m

foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b

foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b

foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b

foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b

foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0

foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0

toList :: (a, a0) -> [a0]

null :: (a, a0) -> Bool

length :: (a, a0) -> Int

elem :: Eq a0 => a0 -> (a, a0) -> Bool

maximum :: Ord a0 => (a, a0) -> a0

minimum :: Ord a0 => (a, a0) -> a0

sum :: Num a0 => (a, a0) -> a0

product :: Num a0 => (a, a0) -> a0

Foldable (Array i)

Since: base-4.8.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Array i m -> m

foldMap :: Monoid m => (a -> m) -> Array i a -> m

foldr :: (a -> b -> b) -> b -> Array i a -> b

foldr' :: (a -> b -> b) -> b -> Array i a -> b

foldl :: (b -> a -> b) -> b -> Array i a -> b

foldl' :: (b -> a -> b) -> b -> Array i a -> b

foldr1 :: (a -> a -> a) -> Array i a -> a

foldl1 :: (a -> a -> a) -> Array i a -> a

toList :: Array i a -> [a]

null :: Array i a -> Bool

length :: Array i a -> Int

elem :: Eq a => a -> Array i a -> Bool

maximum :: Ord a => Array i a -> a

minimum :: Ord a => Array i a -> a

sum :: Num a => Array i a -> a

product :: Num a => Array i a -> a

Foldable (Arg a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fold :: Monoid m => Arg a m -> m

foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0

toList :: Arg a a0 -> [a0]

null :: Arg a a0 -> Bool

length :: Arg a a0 -> Int

elem :: Eq a0 => a0 -> Arg a a0 -> Bool

maximum :: Ord a0 => Arg a a0 -> a0

minimum :: Ord a0 => Arg a a0 -> a0

sum :: Num a0 => Arg a a0 -> a0

product :: Num a0 => Arg a a0 -> a0

Foldable (Proxy :: * -> *)

Since: base-4.7.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => Proxy m -> m

foldMap :: Monoid m => (a -> m) -> Proxy a -> m

foldr :: (a -> b -> b) -> b -> Proxy a -> b

foldr' :: (a -> b -> b) -> b -> Proxy a -> b

foldl :: (b -> a -> b) -> b -> Proxy a -> b

foldl' :: (b -> a -> b) -> b -> Proxy a -> b

foldr1 :: (a -> a -> a) -> Proxy a -> a

foldl1 :: (a -> a -> a) -> Proxy a -> a

toList :: Proxy a -> [a]

null :: Proxy a -> Bool

length :: Proxy a -> Int

elem :: Eq a => a -> Proxy a -> Bool

maximum :: Ord a => Proxy a -> a

minimum :: Ord a => Proxy a -> a

sum :: Num a => Proxy a -> a

product :: Num a => Proxy a -> a

Foldable (Map k)

Defined in Data.Map.Internal

Methods

fold :: Monoid m => Map k m -> m

foldMap :: Monoid m => (a -> m) -> Map k a -> m

foldr :: (a -> b -> b) -> b -> Map k a -> b

foldr' :: (a -> b -> b) -> b -> Map k a -> b

foldl :: (b -> a -> b) -> b -> Map k a -> b

foldl' :: (b -> a -> b) -> b -> Map k a -> b

foldr1 :: (a -> a -> a) -> Map k a -> a

foldl1 :: (a -> a -> a) -> Map k a -> a

toList :: Map k a -> [a]

null :: Map k a -> Bool

length :: Map k a -> Int

elem :: Eq a => a -> Map k a -> Bool

maximum :: Ord a => Map k a -> a

minimum :: Ord a => Map k a -> a

sum :: Num a => Map k a -> a

product :: Num a => Map k a -> a

Foldable (HashMap k)

Defined in Data.HashMap.Base

Methods

fold :: Monoid m => HashMap k m -> m

foldMap :: Monoid m => (a -> m) -> HashMap k a -> m

foldr :: (a -> b -> b) -> b -> HashMap k a -> b

foldr' :: (a -> b -> b) -> b -> HashMap k a -> b

foldl :: (b -> a -> b) -> b -> HashMap k a -> b

foldl' :: (b -> a -> b) -> b -> HashMap k a -> b

foldr1 :: (a -> a -> a) -> HashMap k a -> a

foldl1 :: (a -> a -> a) -> HashMap k a -> a

toList :: HashMap k a -> [a]

null :: HashMap k a -> Bool

length :: HashMap k a -> Int

elem :: Eq a => a -> HashMap k a -> Bool

maximum :: Ord a => HashMap k a -> a

minimum :: Ord a => HashMap k a -> a

sum :: Num a => HashMap k a -> a

product :: Num a => HashMap k a -> a

Foldable f => Foldable (Rec1 f)

Defined in Data.Foldable

Methods

fold :: Monoid m => Rec1 f m -> m

foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m

foldr :: (a -> b -> b) -> b -> Rec1 f a -> b

foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b

foldl :: (b -> a -> b) -> b -> Rec1 f a -> b

foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b

foldr1 :: (a -> a -> a) -> Rec1 f a -> a

foldl1 :: (a -> a -> a) -> Rec1 f a -> a

toList :: Rec1 f a -> [a]

null :: Rec1 f a -> Bool

length :: Rec1 f a -> Int

elem :: Eq a => a -> Rec1 f a -> Bool

maximum :: Ord a => Rec1 f a -> a

minimum :: Ord a => Rec1 f a -> a

sum :: Num a => Rec1 f a -> a

product :: Num a => Rec1 f a -> a

Foldable (URec Char :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Char m -> m

foldMap :: Monoid m => (a -> m) -> URec Char a -> m

foldr :: (a -> b -> b) -> b -> URec Char a -> b

foldr' :: (a -> b -> b) -> b -> URec Char a -> b

foldl :: (b -> a -> b) -> b -> URec Char a -> b

foldl' :: (b -> a -> b) -> b -> URec Char a -> b

foldr1 :: (a -> a -> a) -> URec Char a -> a

foldl1 :: (a -> a -> a) -> URec Char a -> a

toList :: URec Char a -> [a]

null :: URec Char a -> Bool

length :: URec Char a -> Int

elem :: Eq a => a -> URec Char a -> Bool

maximum :: Ord a => URec Char a -> a

minimum :: Ord a => URec Char a -> a

sum :: Num a => URec Char a -> a

product :: Num a => URec Char a -> a

Foldable (URec Double :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Double m -> m

foldMap :: Monoid m => (a -> m) -> URec Double a -> m

foldr :: (a -> b -> b) -> b -> URec Double a -> b

foldr' :: (a -> b -> b) -> b -> URec Double a -> b

foldl :: (b -> a -> b) -> b -> URec Double a -> b

foldl' :: (b -> a -> b) -> b -> URec Double a -> b

foldr1 :: (a -> a -> a) -> URec Double a -> a

foldl1 :: (a -> a -> a) -> URec Double a -> a

toList :: URec Double a -> [a]

null :: URec Double a -> Bool

length :: URec Double a -> Int

elem :: Eq a => a -> URec Double a -> Bool

maximum :: Ord a => URec Double a -> a

minimum :: Ord a => URec Double a -> a

sum :: Num a => URec Double a -> a

product :: Num a => URec Double a -> a

Foldable (URec Float :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Float m -> m

foldMap :: Monoid m => (a -> m) -> URec Float a -> m

foldr :: (a -> b -> b) -> b -> URec Float a -> b

foldr' :: (a -> b -> b) -> b -> URec Float a -> b

foldl :: (b -> a -> b) -> b -> URec Float a -> b

foldl' :: (b -> a -> b) -> b -> URec Float a -> b

foldr1 :: (a -> a -> a) -> URec Float a -> a

foldl1 :: (a -> a -> a) -> URec Float a -> a

toList :: URec Float a -> [a]

null :: URec Float a -> Bool

length :: URec Float a -> Int

elem :: Eq a => a -> URec Float a -> Bool

maximum :: Ord a => URec Float a -> a

minimum :: Ord a => URec Float a -> a

sum :: Num a => URec Float a -> a

product :: Num a => URec Float a -> a

Foldable (URec Int :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Int m -> m

foldMap :: Monoid m => (a -> m) -> URec Int a -> m

foldr :: (a -> b -> b) -> b -> URec Int a -> b

foldr' :: (a -> b -> b) -> b -> URec Int a -> b

foldl :: (b -> a -> b) -> b -> URec Int a -> b

foldl' :: (b -> a -> b) -> b -> URec Int a -> b

foldr1 :: (a -> a -> a) -> URec Int a -> a

foldl1 :: (a -> a -> a) -> URec Int a -> a

toList :: URec Int a -> [a]

null :: URec Int a -> Bool

length :: URec Int a -> Int

elem :: Eq a => a -> URec Int a -> Bool

maximum :: Ord a => URec Int a -> a

minimum :: Ord a => URec Int a -> a

sum :: Num a => URec Int a -> a

product :: Num a => URec Int a -> a

Foldable (URec Word :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Word m -> m

foldMap :: Monoid m => (a -> m) -> URec Word a -> m

foldr :: (a -> b -> b) -> b -> URec Word a -> b

foldr' :: (a -> b -> b) -> b -> URec Word a -> b

foldl :: (b -> a -> b) -> b -> URec Word a -> b

foldl' :: (b -> a -> b) -> b -> URec Word a -> b

foldr1 :: (a -> a -> a) -> URec Word a -> a

foldl1 :: (a -> a -> a) -> URec Word a -> a

toList :: URec Word a -> [a]

null :: URec Word a -> Bool

length :: URec Word a -> Int

elem :: Eq a => a -> URec Word a -> Bool

maximum :: Ord a => URec Word a -> a

minimum :: Ord a => URec Word a -> a

sum :: Num a => URec Word a -> a

product :: Num a => URec Word a -> a

Foldable (URec (Ptr ()) :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => URec (Ptr ()) m -> m

foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m

foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

toList :: URec (Ptr ()) a -> [a]

null :: URec (Ptr ()) a -> Bool

length :: URec (Ptr ()) a -> Int

elem :: Eq a => a -> URec (Ptr ()) a -> Bool

maximum :: Ord a => URec (Ptr ()) a -> a

minimum :: Ord a => URec (Ptr ()) a -> a

sum :: Num a => URec (Ptr ()) a -> a

product :: Num a => URec (Ptr ()) a -> a

Foldable (Const m :: * -> *)

Since: base-4.7.0.0

Defined in Data.Functor.Const

Methods

fold :: Monoid m0 => Const m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0

foldr :: (a -> b -> b) -> b -> Const m a -> b

foldr' :: (a -> b -> b) -> b -> Const m a -> b

foldl :: (b -> a -> b) -> b -> Const m a -> b

foldl' :: (b -> a -> b) -> b -> Const m a -> b

foldr1 :: (a -> a -> a) -> Const m a -> a

foldl1 :: (a -> a -> a) -> Const m a -> a

toList :: Const m a -> [a]

null :: Const m a -> Bool

length :: Const m a -> Int

elem :: Eq a => a -> Const m a -> Bool

maximum :: Ord a => Const m a -> a

minimum :: Ord a => Const m a -> a

sum :: Num a => Const m a -> a

product :: Num a => Const m a -> a

Bifoldable p => Foldable (Join p)

Defined in Data.Bifunctor.Join

Methods

fold :: Monoid m => Join p m -> m

foldMap :: Monoid m => (a -> m) -> Join p a -> m

foldr :: (a -> b -> b) -> b -> Join p a -> b

foldr' :: (a -> b -> b) -> b -> Join p a -> b

foldl :: (b -> a -> b) -> b -> Join p a -> b

foldl' :: (b -> a -> b) -> b -> Join p a -> b

foldr1 :: (a -> a -> a) -> Join p a -> a

foldl1 :: (a -> a -> a) -> Join p a -> a

toList :: Join p a -> [a]

null :: Join p a -> Bool

length :: Join p a -> Int

elem :: Eq a => a -> Join p a -> Bool

maximum :: Ord a => Join p a -> a

minimum :: Ord a => Join p a -> a

sum :: Num a => Join p a -> a

product :: Num a => Join p a -> a

Foldable (Forget r a)

Defined in Data.Profunctor.Types

Methods

fold :: Monoid m => Forget r a m -> m

foldMap :: Monoid m => (a0 -> m) -> Forget r a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Forget r a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Forget r a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Forget r a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Forget r a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Forget r a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Forget r a a0 -> a0

toList :: Forget r a a0 -> [a0]

null :: Forget r a a0 -> Bool

length :: Forget r a a0 -> Int

elem :: Eq a0 => a0 -> Forget r a a0 -> Bool

maximum :: Ord a0 => Forget r a a0 -> a0

minimum :: Ord a0 => Forget r a a0 -> a0

sum :: Num a0 => Forget r a a0 -> a0

product :: Num a0 => Forget r a a0 -> a0

Foldable f => Foldable (ErrorT e f)

Defined in Control.Monad.Trans.Error

Methods

fold :: Monoid m => ErrorT e f m -> m

foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m

foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b

foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b

foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b

foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b

foldr1 :: (a -> a -> a) -> ErrorT e f a -> a

foldl1 :: (a -> a -> a) -> ErrorT e f a -> a

toList :: ErrorT e f a -> [a]

null :: ErrorT e f a -> Bool

length :: ErrorT e f a -> Int

elem :: Eq a => a -> ErrorT e f a -> Bool

maximum :: Ord a => ErrorT e f a -> a

minimum :: Ord a => ErrorT e f a -> a

sum :: Num a => ErrorT e f a -> a

product :: Num a => ErrorT e f a -> a

Foldable (Tagged s)

Defined in Data.Tagged

Methods

fold :: Monoid m => Tagged s m -> m

foldMap :: Monoid m => (a -> m) -> Tagged s a -> m

foldr :: (a -> b -> b) -> b -> Tagged s a -> b

foldr' :: (a -> b -> b) -> b -> Tagged s a -> b

foldl :: (b -> a -> b) -> b -> Tagged s a -> b

foldl' :: (b -> a -> b) -> b -> Tagged s a -> b

foldr1 :: (a -> a -> a) -> Tagged s a -> a

foldl1 :: (a -> a -> a) -> Tagged s a -> a

toList :: Tagged s a -> [a]

null :: Tagged s a -> Bool

length :: Tagged s a -> Int

elem :: Eq a => a -> Tagged s a -> Bool

maximum :: Ord a => Tagged s a -> a

minimum :: Ord a => Tagged s a -> a

sum :: Num a => Tagged s a -> a

product :: Num a => Tagged s a -> a

Foldable (K1 i c :: * -> *)

Defined in Data.Foldable

Methods

fold :: Monoid m => K1 i c m -> m

foldMap :: Monoid m => (a -> m) -> K1 i c a -> m

foldr :: (a -> b -> b) -> b -> K1 i c a -> b

foldr' :: (a -> b -> b) -> b -> K1 i c a -> b

foldl :: (b -> a -> b) -> b -> K1 i c a -> b

foldl' :: (b -> a -> b) -> b -> K1 i c a -> b

foldr1 :: (a -> a -> a) -> K1 i c a -> a

foldl1 :: (a -> a -> a) -> K1 i c a -> a

toList :: K1 i c a -> [a]

null :: K1 i c a -> Bool

length :: K1 i c a -> Int

elem :: Eq a => a -> K1 i c a -> Bool

maximum :: Ord a => K1 i c a -> a

minimum :: Ord a => K1 i c a -> a

sum :: Num a => K1 i c a -> a

product :: Num a => K1 i c a -> a

(Foldable f, Foldable g) => Foldable (f :+: g)

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :+: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b

foldr1 :: (a -> a -> a) -> (f :+: g) a -> a

foldl1 :: (a -> a -> a) -> (f :+: g) a -> a

toList :: (f :+: g) a -> [a]

null :: (f :+: g) a -> Bool

length :: (f :+: g) a -> Int

elem :: Eq a => a -> (f :+: g) a -> Bool

maximum :: Ord a => (f :+: g) a -> a

minimum :: Ord a => (f :+: g) a -> a

sum :: Num a => (f :+: g) a -> a

product :: Num a => (f :+: g) a -> a

(Foldable f, Foldable g) => Foldable (f :*: g)

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :*: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b

foldr1 :: (a -> a -> a) -> (f :*: g) a -> a

foldl1 :: (a -> a -> a) -> (f :*: g) a -> a

toList :: (f :*: g) a -> [a]

null :: (f :*: g) a -> Bool

length :: (f :*: g) a -> Int

elem :: Eq a => a -> (f :*: g) a -> Bool

maximum :: Ord a => (f :*: g) a -> a

minimum :: Ord a => (f :*: g) a -> a

sum :: Num a => (f :*: g) a -> a

product :: Num a => (f :*: g) a -> a

(Foldable f, Foldable g) => Foldable (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

fold :: Monoid m => Product f g m -> m

foldMap :: Monoid m => (a -> m) -> Product f g a -> m

foldr :: (a -> b -> b) -> b -> Product f g a -> b

foldr' :: (a -> b -> b) -> b -> Product f g a -> b

foldl :: (b -> a -> b) -> b -> Product f g a -> b

foldl' :: (b -> a -> b) -> b -> Product f g a -> b

foldr1 :: (a -> a -> a) -> Product f g a -> a

foldl1 :: (a -> a -> a) -> Product f g a -> a

toList :: Product f g a -> [a]

null :: Product f g a -> Bool

length :: Product f g a -> Int

elem :: Eq a => a -> Product f g a -> Bool

maximum :: Ord a => Product f g a -> a

minimum :: Ord a => Product f g a -> a

sum :: Num a => Product f g a -> a

product :: Num a => Product f g a -> a

(Foldable f, Foldable g) => Foldable (Sum f g)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

fold :: Monoid m => Sum f g m -> m

foldMap :: Monoid m => (a -> m) -> Sum f g a -> m

foldr :: (a -> b -> b) -> b -> Sum f g a -> b

foldr' :: (a -> b -> b) -> b -> Sum f g a -> b

foldl :: (b -> a -> b) -> b -> Sum f g a -> b

foldl' :: (b -> a -> b) -> b -> Sum f g a -> b

foldr1 :: (a -> a -> a) -> Sum f g a -> a

foldl1 :: (a -> a -> a) -> Sum f g a -> a

toList :: Sum f g a -> [a]

null :: Sum f g a -> Bool

length :: Sum f g a -> Int

elem :: Eq a => a -> Sum f g a -> Bool

maximum :: Ord a => Sum f g a -> a

minimum :: Ord a => Sum f g a -> a

sum :: Num a => Sum f g a -> a

product :: Num a => Sum f g a -> a

Foldable f => Foldable (M1 i c f)

Defined in Data.Foldable

Methods

fold :: Monoid m => M1 i c f m -> m

foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m

foldr :: (a -> b -> b) -> b -> M1 i c f a -> b

foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b

foldl :: (b -> a -> b) -> b -> M1 i c f a -> b

foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b

foldr1 :: (a -> a -> a) -> M1 i c f a -> a

foldl1 :: (a -> a -> a) -> M1 i c f a -> a

toList :: M1 i c f a -> [a]

null :: M1 i c f a -> Bool

length :: M1 i c f a -> Int

elem :: Eq a => a -> M1 i c f a -> Bool

maximum :: Ord a => M1 i c f a -> a

minimum :: Ord a => M1 i c f a -> a

sum :: Num a => M1 i c f a -> a

product :: Num a => M1 i c f a -> a

(Foldable f, Foldable g) => Foldable (f :.: g)

Defined in Data.Foldable

Methods

fold :: Monoid m => (f :.: g) m -> m

foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m

foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b

foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b

foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b

foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b

foldr1 :: (a -> a -> a) -> (f :.: g) a -> a

foldl1 :: (a -> a -> a) -> (f :.: g) a -> a

toList :: (f :.: g) a -> [a]

null :: (f :.: g) a -> Bool

length :: (f :.: g) a -> Int

elem :: Eq a => a -> (f :.: g) a -> Bool

maximum :: Ord a => (f :.: g) a -> a

minimum :: Ord a => (f :.: g) a -> a

sum :: Num a => (f :.: g) a -> a

product :: Num a => (f :.: g) a -> a

(Foldable f, Foldable g) => Foldable (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

fold :: Monoid m => Compose f g m -> m

foldMap :: Monoid m => (a -> m) -> Compose f g a -> m

foldr :: (a -> b -> b) -> b -> Compose f g a -> b

foldr' :: (a -> b -> b) -> b -> Compose f g a -> b

foldl :: (b -> a -> b) -> b -> Compose f g a -> b

foldl' :: (b -> a -> b) -> b -> Compose f g a -> b

foldr1 :: (a -> a -> a) -> Compose f g a -> a

foldl1 :: (a -> a -> a) -> Compose f g a -> a

toList :: Compose f g a -> [a]

null :: Compose f g a -> Bool

length :: Compose f g a -> Int

elem :: Eq a => a -> Compose f g a -> Bool

maximum :: Ord a => Compose f g a -> a

minimum :: Ord a => Compose f g a -> a

sum :: Num a => Compose f g a -> a

product :: Num a => Compose f g a -> a

Bifoldable p => Foldable (WrappedBifunctor p a)

Defined in Data.Bifunctor.Wrapped

Methods

fold :: Monoid m => WrappedBifunctor p a m -> m

foldMap :: Monoid m => (a0 -> m) -> WrappedBifunctor p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> WrappedBifunctor p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> WrappedBifunctor p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> WrappedBifunctor p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> WrappedBifunctor p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> WrappedBifunctor p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> WrappedBifunctor p a a0 -> a0

toList :: WrappedBifunctor p a a0 -> [a0]

null :: WrappedBifunctor p a a0 -> Bool

length :: WrappedBifunctor p a a0 -> Int

elem :: Eq a0 => a0 -> WrappedBifunctor p a a0 -> Bool

maximum :: Ord a0 => WrappedBifunctor p a a0 -> a0

minimum :: Ord a0 => WrappedBifunctor p a a0 -> a0

sum :: Num a0 => WrappedBifunctor p a a0 -> a0

product :: Num a0 => WrappedBifunctor p a a0 -> a0

Foldable g => Foldable (Joker g a)

Defined in Data.Bifunctor.Joker

Methods

fold :: Monoid m => Joker g a m -> m

foldMap :: Monoid m => (a0 -> m) -> Joker g a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Joker g a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Joker g a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Joker g a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Joker g a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Joker g a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Joker g a a0 -> a0

toList :: Joker g a a0 -> [a0]

null :: Joker g a a0 -> Bool

length :: Joker g a a0 -> Int

elem :: Eq a0 => a0 -> Joker g a a0 -> Bool

maximum :: Ord a0 => Joker g a a0 -> a0

minimum :: Ord a0 => Joker g a a0 -> a0

sum :: Num a0 => Joker g a a0 -> a0

product :: Num a0 => Joker g a a0 -> a0

Bifoldable p => Foldable (Flip p a)

Defined in Data.Bifunctor.Flip

Methods

fold :: Monoid m => Flip p a m -> m

foldMap :: Monoid m => (a0 -> m) -> Flip p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Flip p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Flip p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Flip p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Flip p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Flip p a a0 -> a0

toList :: Flip p a a0 -> [a0]

null :: Flip p a a0 -> Bool

length :: Flip p a a0 -> Int

elem :: Eq a0 => a0 -> Flip p a a0 -> Bool

maximum :: Ord a0 => Flip p a a0 -> a0

minimum :: Ord a0 => Flip p a a0 -> a0

sum :: Num a0 => Flip p a a0 -> a0

product :: Num a0 => Flip p a a0 -> a0

Foldable (Clown f a :: * -> *)

Defined in Data.Bifunctor.Clown

Methods

fold :: Monoid m => Clown f a m -> m

foldMap :: Monoid m => (a0 -> m) -> Clown f a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Clown f a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Clown f a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Clown f a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Clown f a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Clown f a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Clown f a a0 -> a0

toList :: Clown f a a0 -> [a0]

null :: Clown f a a0 -> Bool

length :: Clown f a a0 -> Int

elem :: Eq a0 => a0 -> Clown f a a0 -> Bool

maximum :: Ord a0 => Clown f a a0 -> a0

minimum :: Ord a0 => Clown f a a0 -> a0

sum :: Num a0 => Clown f a a0 -> a0

product :: Num a0 => Clown f a a0 -> a0

(Foldable f, Bifoldable p) => Foldable (Tannen f p a)

Defined in Data.Bifunctor.Tannen

Methods

fold :: Monoid m => Tannen f p a m -> m

foldMap :: Monoid m => (a0 -> m) -> Tannen f p a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Tannen f p a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Tannen f p a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Tannen f p a a0 -> a0

toList :: Tannen f p a a0 -> [a0]

null :: Tannen f p a a0 -> Bool

length :: Tannen f p a a0 -> Int

elem :: Eq a0 => a0 -> Tannen f p a a0 -> Bool

maximum :: Ord a0 => Tannen f p a a0 -> a0

minimum :: Ord a0 => Tannen f p a a0 -> a0

sum :: Num a0 => Tannen f p a a0 -> a0

product :: Num a0 => Tannen f p a a0 -> a0

(Bifoldable p, Foldable g) => Foldable (Biff p f g a)

Defined in Data.Bifunctor.Biff

Methods

fold :: Monoid m => Biff p f g a m -> m

foldMap :: Monoid m => (a0 -> m) -> Biff p f g a a0 -> m

foldr :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b

foldr' :: (a0 -> b -> b) -> b -> Biff p f g a a0 -> b

foldl :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b

foldl' :: (b -> a0 -> b) -> b -> Biff p f g a a0 -> b

foldr1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0

foldl1 :: (a0 -> a0 -> a0) -> Biff p f g a a0 -> a0

toList :: Biff p f g a a0 -> [a0]

null :: Biff p f g a a0 -> Bool

length :: Biff p f g a a0 -> Int

elem :: Eq a0 => a0 -> Biff p f g a a0 -> Bool

maximum :: Ord a0 => Biff p f g a a0 -> a0

minimum :: Ord a0 => Biff p f g a a0 -> a0

sum :: Num a0 => Biff p f g a a0 -> a0

product :: Num a0 => Biff p f g a a0 -> a0

data RealWorld

RealWorld is deeply magical. It is primitive, but it is not unlifted (hence ptrArg). We never manipulate values of type RealWorld; it's only used in the type system, to parameterise State#.

groupBy :: Ord g => (a -> g) -> Fold a r -> Fold a (Map g r)

Perform a Fold while grouping the data according to a specified group projection function. Returns the folded result grouped as a map keyed by the group.

filtered :: Monoid m => (a -> Bool) -> (a -> m) -> a -> m

>>> fold (handles (filtered even) sum) [1..10]
30

>>> foldM (handlesM (filtered even) (mapM_ print)) [1..10]
2
4
6
8
10

folded :: (Contravariant f, Applicative f, Foldable t) => (a -> f a) -> t a -> f (t a)

folded :: Foldable t => Fold (t a) a

handles folded :: Foldable t => Fold a r -> Fold (t a) r

foldOverM :: Monad m => HandlerM m s a -> FoldM m a b -> s -> m b

(foldOverM f folder xs) folds all values from a Lens, Traversal, Prism or Fold monadically with the given folder

L.foldOverM (folded.f) folder == L.foldM (handlesM f folder)

L.foldOverM folded == L.foldM

handlesM :: HandlerM m a b -> FoldM m b r -> FoldM m a r

(handlesM t folder) transforms the input of a FoldM using a lens, traversal, or prism:

handlesM _1       :: FoldM m a r -> FoldM (a, b) r
handlesM _Left    :: FoldM m a r -> FoldM (Either a b) r
handlesM traverse :: Traversable t => FoldM m a r -> FoldM m (t a) r
handlesM folded   :: Foldable    t => FoldM m a r -> FoldM m (t a) r

handlesM obeys these laws:

handlesM id = id

handlesM (f . g) = handlesM f . handlesM g

handlesM t (pure r) = pure r

handlesM t (f <*> x) = handlesM t f <*> handlesM t x

foldOver :: Handler s a -> Fold a b -> s -> b

(foldOver f folder xs) folds all values from a Lens, Traversal, Prism or Fold with the given folder

>>> foldOver (_Just . both) L.sum (Just (2, 3))
5

>>> foldOver (_Just . both) L.sum Nothing
0

L.foldOver f folder xs == L.fold folder (xs^..f)

L.foldOver (folded.f) folder == L.fold (handles f folder)

L.foldOver folded == L.fold

handles :: Handler a b -> Fold b r -> Fold a r

(handles t folder) transforms the input of a Fold using a lens, traversal, or prism:

handles _1       :: Fold a r -> Fold (a, b) r
handles _Left    :: Fold a r -> Fold (Either a b) r
handles traverse :: Traversable t => Fold a r -> Fold (t a) r
handles folded   :: Foldable    t => Fold a r -> Fold (t a) r

>>> fold (handles traverse sum) [[1..5],[6..10]]
55

>>> fold (handles (traverse.traverse) sum) [[Nothing, Just 2, Just 7],[Just 13, Nothing, Just 20]]
42

>>> fold (handles (filtered even) sum) [1..10]
30

>>> fold (handles _2 mconcat) [(1,"Hello "),(2,"World"),(3,"!")]
"Hello World!"

handles id = id

handles (f . g) = handles f . handles g

handles t (pure r) = pure r

handles t (f <*> x) = handles t f <*> handles t x

prefilterM :: Monad m => (a -> m Bool) -> FoldM m a r -> FoldM m a r

(prefilterM f folder) returns a new Fold where the folder's input is used only when the input satisfies a monadic predicate f.

foldM (prefilterM p folder) list = foldM folder (filter p list)

prefilter :: (a -> Bool) -> Fold a r -> Fold a r

(prefilter f folder) returns a new Fold where the folder's input is used only when the input satisfies a predicate f

This can also be done with handles (handles (filtered f)) but prefilter does not need you to depend on a lens library.

fold (prefilter p folder) list = fold folder (filter p list)

>>> fold (prefilter (>5) Control.Foldl.sum) [1..10]
40

>>> fold Control.Foldl.sum (filter (>5) [1..10])
40

premapM :: Monad m => (a -> m b) -> FoldM m b r -> FoldM m a r

(premapM f folder) returns a new FoldM where f is applied to each input element

premapM return = id

premapM (f <=< g) = premap g . premap f

premapM k (pure r) = pure r

premapM k (f <*> x) = premapM k f <*> premapM k x

premap :: (a -> b) -> Fold b r -> Fold a r

(premap f folder) returns a new Fold where f is applied at each step

fold (premap f folder) list = fold folder (map f list)

>>> fold (premap Sum mconcat) [1..10]
Sum {getSum = 55}

>>> fold mconcat (map Sum [1..10])
Sum {getSum = 55}

premap id = id

premap (f . g) = premap g . premap f

premap k (pure r) = pure r

premap k (f <*> x) = premap k f <*> premap k x

_Fold1 :: (a -> a -> a) -> Fold a (Maybe a)

_Fold1 step returns a new Fold using just a step function that has the same type for the accumulator and the element. The result type is the accumulator type wrapped in Maybe. The initial accumulator is retrieved from the Foldable, the result is None for empty containers.

duplicateM :: Applicative m => FoldM m a b -> FoldM m a (FoldM m a b)

Allows to continue feeding a FoldM even after passing it to a function that closes it.

For pure Folds, this is provided by the Comonad instance.

hoists :: (forall x. m x -> n x) -> FoldM m a b -> FoldM n a b

Shift a FoldM from one monad to another with a morphism such as lift or liftIO; the effect is the same as hoist.

simplify :: FoldM Identity a b -> Fold a b

Simplify a pure FoldM to a Fold

simplify (pure r) = pure r

simplify (f <*> x) = simplify f <*> simplify x

generalize :: Monad m => Fold a b -> FoldM m a b

Generalize a Fold to a FoldM

generalize (pure r) = pure r

generalize (f <*> x) = generalize f <*> generalize x

impurely_ :: Monad m => (forall x. (x -> a -> m x) -> m x -> m x) -> FoldM m a b -> m b

Upgrade a more traditional monadic fold to accept the FoldM type

impurely :: (forall x. (x -> a -> m x) -> m x -> (x -> m b) -> r) -> FoldM m a b -> r

Upgrade a monadic fold to accept the FoldM type

purely_ :: (forall x. (x -> a -> x) -> x -> x) -> Fold a b -> b

Upgrade a more traditional fold to accept the Fold type

purely :: (forall x. (x -> a -> x) -> x -> (x -> b) -> r) -> Fold a b -> r

Upgrade a fold to accept the Fold type

vectorM :: (PrimMonad m, Vector v a) => FoldM m a (v a)

Fold all values into a vector

This is more efficient than vector but is impure

vector :: Vector v a => Fold a (v a)

Fold all values into a vector

hashMap :: (Eq a, Hashable a) => Fold (a, b) (HashMap a b)

Fold pairs into a hash-map.

map :: Ord a => Fold (a, b) (Map a b)

Fold pairs into a map.

hashSet :: (Eq a, Hashable a) => Fold a (HashSet a)

Fold values into a hash-set

set :: Ord a => Fold a (Set a)

Fold values into a set

eqNub :: Eq a => Fold a [a]

O(n^2). Fold values into a list with duplicates removed, while preserving their first occurrences

nub :: Ord a => Fold a [a]

O(n log n). Fold values into a list with duplicates removed, while preserving their first occurrences

revList :: Fold a [a]

Fold all values into a list, in reverse order

list :: Fold a [a]

Fold all values into a list

genericIndex :: Integral i => i -> Fold a (Maybe a)

Like index, except with a more general Integral argument

genericLength :: Num b => Fold a b

Like length, except with a more general Num return value

sink :: (Monoid w, Monad m) => (a -> m w) -> FoldM m a w

Converts an effectful function to a fold

sink (f <> g) = sink f <> sink g -- if `(<>)` is commutative
sink mempty = mempty

mapM_ :: Monad m => (a -> m ()) -> FoldM m a ()

Converts an effectful function to a fold. Specialized version of sink.

randomN :: Vector v a => Int -> FoldM IO a (Maybe (v a))

Pick several random elements, using reservoir sampling

random :: FoldM IO a (Maybe a)

Pick a random element, using reservoir sampling

lookup :: Eq a => a -> Fold (a, b) (Maybe b)

(lookup a) returns the element paired with the first matching item, or Nothing if none matches

findIndex :: (a -> Bool) -> Fold a (Maybe Int)

(findIndex predicate) returns the index of the first element that satisfies the predicate, or Nothing if no element satisfies the predicate

elemIndex :: Eq a => a -> Fold a (Maybe Int)

(elemIndex a) returns the index of the first element that equals a, or Nothing if no element matches

index :: Int -> Fold a (Maybe a)

(index n) returns the nth element of the container, or Nothing if the container has an insufficient number of elements

find :: (a -> Bool) -> Fold a (Maybe a)

(find predicate) returns the first element that satisfies the predicate or Nothing if no element satisfies the predicate

notElem :: Eq a => a -> Fold a Bool

(notElem a) returns False if the container has an element equal to a, True otherwise

elem :: Eq a => a -> Fold a Bool

(elem a) returns True if the container has an element equal to a, False otherwise

minimumBy :: (a -> a -> Ordering) -> Fold a (Maybe a)

Computes the minimum element with respect to the given comparison function

minimum :: Ord a => Fold a (Maybe a)

Computes the minimum element

maximumBy :: (a -> a -> Ordering) -> Fold a (Maybe a)

Computes the maximum element with respect to the given comparison function

maximum :: Ord a => Fold a (Maybe a)

Computes the maximum element

std :: Floating a => Fold a a

Compute a numerically stable (population) standard deviation over all elements

product :: Num a => Fold a a

Computes the product of all elements

sum :: Num a => Fold a a

Computes the sum of all elements

any :: (a -> Bool) -> Fold a Bool

(any predicate) returns True if any element satisfies the predicate, False otherwise

all :: (a -> Bool) -> Fold a Bool

(all predicate) returns True if all elements satisfy the predicate, False otherwise

or :: Fold Bool Bool

Returns True if any element is True, False otherwise

and :: Fold Bool Bool

Returns True if all elements are True, False otherwise

length :: Fold a Int

Return the length of the container

null :: Fold a Bool

Returns True if the container is empty, False otherwise

lastN :: Int -> Fold a [a]

Return the last N elements

lastDef :: a -> Fold a a

Get the last element of a container or return a default value if the container is empty

last :: Fold a (Maybe a)

Get the last element of a container or return Nothing if the container is empty

head :: Fold a (Maybe a)

Get the first element of a container or return Nothing if the container is empty

foldMap :: Monoid w => (a -> w) -> (w -> b) -> Fold a b

Convert a "foldMap" to a Fold

mconcat :: Monoid a => Fold a a

Fold all values within a container using mappend and mempty

postscan :: Traversable t => Fold a b -> t a -> t b

Convert a Fold into a postscan for any Traversable type

"Postscan" means that the first element of the scan is not included

prescan :: Traversable t => Fold a b -> t a -> t b

Convert a Fold into a prescan for any Traversable type

"Prescan" means that the last element of the scan is not included

scan :: Fold a b -> [a] -> [b]

Convert a strict left Fold into a scan

foldM :: (Foldable f, Monad m) => FoldM m a b -> f a -> m b

Like fold, but monadic

fold :: Foldable f => Fold a b -> f a -> b

Apply a strict left Fold to a Foldable container

data Fold a b where

Efficient representation of a left fold that preserves the fold's step function, initial accumulator, and extraction function

This allows the Applicative instance to assemble derived folds that traverse the container only once

A 'Fold a b' processes elements of type a and results in a value of type b.

Constructors

Fold :: Fold a b

Fold step initial extract

Instances

Choice Fold

Defined in Control.Foldl

Methods

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

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

Profunctor Fold

Defined in Control.Foldl

Methods

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

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

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

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

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

Functor (Fold a)

Defined in Control.Foldl

Methods

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

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

Applicative (Fold a)

Defined in Control.Foldl

Methods

pure :: a0 -> Fold a a0

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

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

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

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

Comonad (Fold a)

Defined in Control.Foldl

Methods

extract :: Fold a a0 -> a0

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

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

Semigroupoid Fold

Defined in Control.Foldl

Methods

o :: Fold j k1 -> Fold i j -> Fold i k1

Floating b => Floating (Fold a b)

Defined in Control.Foldl

Methods

pi :: Fold a b

exp :: Fold a b -> Fold a b

log :: Fold a b -> Fold a b

sqrt :: Fold a b -> Fold a b

(**) :: Fold a b -> Fold a b -> Fold a b

logBase :: Fold a b -> Fold a b -> Fold a b

sin :: Fold a b -> Fold a b

cos :: Fold a b -> Fold a b

tan :: Fold a b -> Fold a b

asin :: Fold a b -> Fold a b

acos :: Fold a b -> Fold a b

atan :: Fold a b -> Fold a b

sinh :: Fold a b -> Fold a b

cosh :: Fold a b -> Fold a b

tanh :: Fold a b -> Fold a b

asinh :: Fold a b -> Fold a b

acosh :: Fold a b -> Fold a b

atanh :: Fold a b -> Fold a b

log1p :: Fold a b -> Fold a b

expm1 :: Fold a b -> Fold a b

log1pexp :: Fold a b -> Fold a b

log1mexp :: Fold a b -> Fold a b

Fractional b => Fractional (Fold a b)

Defined in Control.Foldl

Methods

(/) :: Fold a b -> Fold a b -> Fold a b

recip :: Fold a b -> Fold a b

fromRational :: Rational -> Fold a b

Num b => Num (Fold a b)

Defined in Control.Foldl

Methods

(+) :: Fold a b -> Fold a b -> Fold a b

(-) :: Fold a b -> Fold a b -> Fold a b

(*) :: Fold a b -> Fold a b -> Fold a b

negate :: Fold a b -> Fold a b

abs :: Fold a b -> Fold a b

signum :: Fold a b -> Fold a b

fromInteger :: Integer -> Fold a b

Semigroup b => Semigroup (Fold a b)

Defined in Control.Foldl

Methods

(<>) :: Fold a b -> Fold a b -> Fold a b

sconcat :: NonEmpty (Fold a b) -> Fold a b

stimes :: Integral b0 => b0 -> Fold a b -> Fold a b

Monoid b => Monoid (Fold a b)

Defined in Control.Foldl

Methods

mempty :: Fold a b

mappend :: Fold a b -> Fold a b -> Fold a b

mconcat :: [Fold a b] -> Fold a b

data FoldM (m :: * -> *) a b where

Like Fold, but monadic.

A 'FoldM m a b' processes elements of type a and results in a monadic value of type m b.

Constructors

FoldM :: FoldM m a b

FoldM step initial extract

Instances

Functor m => Profunctor (FoldM m)

Defined in Control.Foldl

Methods

dimap :: (a -> b) -> (c -> d) -> FoldM m b c -> FoldM m a d

lmap :: (a -> b) -> FoldM m b c -> FoldM m a c

rmap :: (b -> c) -> FoldM m a b -> FoldM m a c

(#.) :: Coercible c b => q b c -> FoldM m a b -> FoldM m a c

(.#) :: Coercible b a => FoldM m b c -> q a b -> FoldM m a c

Functor m => Functor (FoldM m a)

Defined in Control.Foldl

Methods

fmap :: (a0 -> b) -> FoldM m a a0 -> FoldM m a b

(<$) :: a0 -> FoldM m a b -> FoldM m a a0

Applicative m => Applicative (FoldM m a)

Defined in Control.Foldl

Methods

pure :: a0 -> FoldM m a a0

(<*>) :: FoldM m a (a0 -> b) -> FoldM m a a0 -> FoldM m a b

liftA2 :: (a0 -> b -> c) -> FoldM m a a0 -> FoldM m a b -> FoldM m a c

(*>) :: FoldM m a a0 -> FoldM m a b -> FoldM m a b

(<*) :: FoldM m a a0 -> FoldM m a b -> FoldM m a a0

(Monad m, Floating b) => Floating (FoldM m a b)

Defined in Control.Foldl

Methods

pi :: FoldM m a b

exp :: FoldM m a b -> FoldM m a b

log :: FoldM m a b -> FoldM m a b

sqrt :: FoldM m a b -> FoldM m a b

(**) :: FoldM m a b -> FoldM m a b -> FoldM m a b

logBase :: FoldM m a b -> FoldM m a b -> FoldM m a b

sin :: FoldM m a b -> FoldM m a b

cos :: FoldM m a b -> FoldM m a b

tan :: FoldM m a b -> FoldM m a b

asin :: FoldM m a b -> FoldM m a b

acos :: FoldM m a b -> FoldM m a b

atan :: FoldM m a b -> FoldM m a b

sinh :: FoldM m a b -> FoldM m a b

cosh :: FoldM m a b -> FoldM m a b

tanh :: FoldM m a b -> FoldM m a b

asinh :: FoldM m a b -> FoldM m a b

acosh :: FoldM m a b -> FoldM m a b

atanh :: FoldM m a b -> FoldM m a b

log1p :: FoldM m a b -> FoldM m a b

expm1 :: FoldM m a b -> FoldM m a b

log1pexp :: FoldM m a b -> FoldM m a b

log1mexp :: FoldM m a b -> FoldM m a b

(Monad m, Fractional b) => Fractional (FoldM m a b)

Defined in Control.Foldl

Methods

(/) :: FoldM m a b -> FoldM m a b -> FoldM m a b

recip :: FoldM m a b -> FoldM m a b

fromRational :: Rational -> FoldM m a b

(Monad m, Num b) => Num (FoldM m a b)

Defined in Control.Foldl

Methods

(+) :: FoldM m a b -> FoldM m a b -> FoldM m a b

(-) :: FoldM m a b -> FoldM m a b -> FoldM m a b

(*) :: FoldM m a b -> FoldM m a b -> FoldM m a b

negate :: FoldM m a b -> FoldM m a b

abs :: FoldM m a b -> FoldM m a b

signum :: FoldM m a b -> FoldM m a b

fromInteger :: Integer -> FoldM m a b

(Semigroup b, Monad m) => Semigroup (FoldM m a b)

Defined in Control.Foldl

Methods

(<>) :: FoldM m a b -> FoldM m a b -> FoldM m a b

sconcat :: NonEmpty (FoldM m a b) -> FoldM m a b

stimes :: Integral b0 => b0 -> FoldM m a b -> FoldM m a b

(Monoid b, Monad m) => Monoid (FoldM m a b)

Defined in Control.Foldl

Methods

mempty :: FoldM m a b

mappend :: FoldM m a b -> FoldM m a b -> FoldM m a b

mconcat :: [FoldM m a b] -> FoldM m a b

type Handler a b = forall x. (b -> Const (Dual (Endo x)) b) -> a -> Const (Dual (Endo x)) a

A handler for the upstream input of a Fold

Any lens, traversal, or prism will type-check as a Handler

newtype EndoM (m :: * -> *) a

instance Monad m => Monoid (EndoM m a) where
    mempty = EndoM return
    mappend (EndoM f) (EndoM g) = EndoM (f <=< g)

Constructors

EndoM

Fields

• appEndoM :: a -> m a

Instances

Monad m => Semigroup (EndoM m a)

Defined in Control.Foldl

Methods

(<>) :: EndoM m a -> EndoM m a -> EndoM m a

sconcat :: NonEmpty (EndoM m a) -> EndoM m a

stimes :: Integral b => b -> EndoM m a -> EndoM m a

Monad m => Monoid (EndoM m a)

Defined in Control.Foldl

Methods

mempty :: EndoM m a

mappend :: EndoM m a -> EndoM m a -> EndoM m a

mconcat :: [EndoM m a] -> EndoM m a

type HandlerM (m :: * -> *) a b = forall x. (b -> Const (Dual (EndoM m x)) b) -> a -> Const (Dual (EndoM m x)) a

A Handler for the upstream input of FoldM

Any lens, traversal, or prism will type-check as a HandlerM

class MVector (Mutable v) a => Vector (v :: * -> *) a

Class of immutable vectors. Every immutable vector is associated with its mutable version through the Mutable type family. Methods of this class should not be used directly. Instead, Data.Vector.Generic and other Data.Vector modules provide safe and fusible wrappers.

Minimum complete implementation:

• basicUnsafeFreeze
• basicUnsafeThaw
• basicLength
• basicUnsafeSlice
• basicUnsafeIndexM

Minimal complete definition

basicUnsafeFreeze, basicUnsafeThaw, basicLength, basicUnsafeSlice, basicUnsafeIndexM

Instances

Vector Vector Bool

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool)

basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool)

basicLength :: Vector Bool -> Int

basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool

basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m ()

elemseq :: Vector Bool -> Bool -> b -> b

Vector Vector Char

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char)

basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char)

basicLength :: Vector Char -> Int

basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char

basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m ()

elemseq :: Vector Char -> Char -> b -> b

Vector Vector Double

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double)

basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double)

basicLength :: Vector Double -> Int

basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double

basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m ()

elemseq :: Vector Double -> Double -> b -> b

Vector Vector Float

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float)

basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float)

basicLength :: Vector Float -> Int

basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float

basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m ()

elemseq :: Vector Float -> Float -> b -> b

Vector Vector Int

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int)

basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int)

basicLength :: Vector Int -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int

basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m ()

elemseq :: Vector Int -> Int -> b -> b

Vector Vector Int8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> m (Vector Int8)

basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m (Mutable Vector (PrimState m) Int8)

basicLength :: Vector Int8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8

basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> Vector Int8 -> m ()

elemseq :: Vector Int8 -> Int8 -> b -> b

Vector Vector Int16

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> m (Vector Int16)

basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m (Mutable Vector (PrimState m) Int16)

basicLength :: Vector Int16 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16

basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> Vector Int16 -> m ()

elemseq :: Vector Int16 -> Int16 -> b -> b

Vector Vector Int32

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> m (Vector Int32)

basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m (Mutable Vector (PrimState m) Int32)

basicLength :: Vector Int32 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32

basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> Vector Int32 -> m ()

elemseq :: Vector Int32 -> Int32 -> b -> b

Vector Vector Int64

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64)

basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64)

basicLength :: Vector Int64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64

basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m ()

elemseq :: Vector Int64 -> Int64 -> b -> b

Vector Vector Word

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word)

basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word)

basicLength :: Vector Word -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word

basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m ()

elemseq :: Vector Word -> Word -> b -> b

Vector Vector Word8

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8)

basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8)

basicLength :: Vector Word8 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8

basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m ()

elemseq :: Vector Word8 -> Word8 -> b -> b

Vector Vector Word16

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> m (Vector Word16)

basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m (Mutable Vector (PrimState m) Word16)

basicLength :: Vector Word16 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16

basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> Vector Word16 -> m ()

elemseq :: Vector Word16 -> Word16 -> b -> b

Vector Vector Word32

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> m (Vector Word32)

basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m (Mutable Vector (PrimState m) Word32)

basicLength :: Vector Word32 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32

basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> Vector Word32 -> m ()

elemseq :: Vector Word32 -> Word32 -> b -> b

Vector Vector Word64

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> m (Vector Word64)

basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m (Mutable Vector (PrimState m) Word64)

basicLength :: Vector Word64 -> Int

basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64

basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> Vector Word64 -> m ()

elemseq :: Vector Word64 -> Word64 -> b -> b

Vector Vector ()

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) () -> m (Vector ())

basicUnsafeThaw :: PrimMonad m => Vector () -> m (Mutable Vector (PrimState m) ())

basicLength :: Vector () -> Int

basicUnsafeSlice :: Int -> Int -> Vector () -> Vector ()

basicUnsafeIndexM :: Monad m => Vector () -> Int -> m ()

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) () -> Vector () -> m ()

elemseq :: Vector () -> () -> b -> b

Vector Vector KB2Sum

Defined in Numeric.Sum

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) KB2Sum -> m (Vector KB2Sum)

basicUnsafeThaw :: PrimMonad m => Vector KB2Sum -> m (Mutable Vector (PrimState m) KB2Sum)

basicLength :: Vector KB2Sum -> Int

basicUnsafeSlice :: Int -> Int -> Vector KB2Sum -> Vector KB2Sum

basicUnsafeIndexM :: Monad m => Vector KB2Sum -> Int -> m KB2Sum

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) KB2Sum -> Vector KB2Sum -> m ()

elemseq :: Vector KB2Sum -> KB2Sum -> b -> b

Vector Vector KBNSum

Defined in Numeric.Sum

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) KBNSum -> m (Vector KBNSum)

basicUnsafeThaw :: PrimMonad m => Vector KBNSum -> m (Mutable Vector (PrimState m) KBNSum)

basicLength :: Vector KBNSum -> Int

basicUnsafeSlice :: Int -> Int -> Vector KBNSum -> Vector KBNSum

basicUnsafeIndexM :: Monad m => Vector KBNSum -> Int -> m KBNSum

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) KBNSum -> Vector KBNSum -> m ()

elemseq :: Vector KBNSum -> KBNSum -> b -> b

Vector Vector KahanSum

Defined in Numeric.Sum

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) KahanSum -> m (Vector KahanSum)

basicUnsafeThaw :: PrimMonad m => Vector KahanSum -> m (Mutable Vector (PrimState m) KahanSum)

basicLength :: Vector KahanSum -> Int

basicUnsafeSlice :: Int -> Int -> Vector KahanSum -> Vector KahanSum

basicUnsafeIndexM :: Monad m => Vector KahanSum -> Int -> m KahanSum

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) KahanSum -> Vector KahanSum -> m ()

elemseq :: Vector KahanSum -> KahanSum -> b -> b

Vector Vector a

Defined in Data.Vector

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a)

basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a)

basicLength :: Vector a -> Int

basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a

basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m ()

elemseq :: Vector a -> a -> b -> b

Unbox a => Vector Vector (Complex a)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> m (Vector (Complex a))

basicUnsafeThaw :: PrimMonad m => Vector (Complex a) -> m (Mutable Vector (PrimState m) (Complex a))

basicLength :: Vector (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a)

basicUnsafeIndexM :: Monad m => Vector (Complex a) -> Int -> m (Complex a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> Vector (Complex a) -> m ()

elemseq :: Vector (Complex a) -> Complex a -> b -> b

(Unbox a, Unbox b) => Vector Vector (a, b)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> m (Vector (a, b))

basicUnsafeThaw :: PrimMonad m => Vector (a, b) -> m (Mutable Vector (PrimState m) (a, b))

basicLength :: Vector (a, b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b)

basicUnsafeIndexM :: Monad m => Vector (a, b) -> Int -> m (a, b)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> Vector (a, b) -> m ()

elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0

(Unbox a, Unbox b, Unbox c) => Vector Vector (a, b, c)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> m (Vector (a, b, c))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c) -> m (Mutable Vector (PrimState m) (a, b, c))

basicLength :: Vector (a, b, c) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c)

basicUnsafeIndexM :: Monad m => Vector (a, b, c) -> Int -> m (a, b, c)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> Vector (a, b, c) -> m ()

elemseq :: Vector (a, b, c) -> (a, b, c) -> b0 -> b0

(Unbox a, Unbox b, Unbox c, Unbox d) => Vector Vector (a, b, c, d)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> m (Vector (a, b, c, d))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d) -> m (Mutable Vector (PrimState m) (a, b, c, d))

basicLength :: Vector (a, b, c, d) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d) -> Vector (a, b, c, d)

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d) -> Int -> m (a, b, c, d)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> Vector (a, b, c, d) -> m ()

elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector Vector (a, b, c, d, e)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> m (Vector (a, b, c, d, e))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e) -> m (Mutable Vector (PrimState m) (a, b, c, d, e))

basicLength :: Vector (a, b, c, d, e) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e) -> Vector (a, b, c, d, e)

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e) -> Int -> m (a, b, c, d, e)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> Vector (a, b, c, d, e) -> m ()

elemseq :: Vector (a, b, c, d, e) -> (a, b, c, d, e) -> b0 -> b0

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector Vector (a, b, c, d, e, f)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> m (Vector (a, b, c, d, e, f))

basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e, f) -> m (Mutable Vector (PrimState m) (a, b, c, d, e, f))

basicLength :: Vector (a, b, c, d, e, f) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f)

basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> m ()

elemseq :: Vector (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> b0 -> b0

type family Mutable (v :: * -> *) :: * -> * -> *

Mutable v s a is the mutable version of the pure vector type v a with the state token s

Instances

type Mutable Vector

Defined in Data.Vector.Unboxed.Base

type Mutable Vector = MVector

type Mutable Vector

Defined in Data.Vector

type Mutable Vector = MVector

class Monad m => PrimMonad (m :: * -> *)

Class of monads which can perform primitive state-transformer actions

Minimal complete definition

primitive

Instances

PrimMonad IO

Defined in Control.Monad.Primitive

Associated Types

type PrimState IO :: *

Methods

primitive :: (State# (PrimState IO) -> (#State# (PrimState IO), a#)) -> IO a

PrimMonad (ST s)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ST s) :: *

Methods

primitive :: (State# (PrimState (ST s)) -> (#State# (PrimState (ST s)), a#)) -> ST s a

PrimMonad m => PrimMonad (MaybeT m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (MaybeT m) :: *

Methods

primitive :: (State# (PrimState (MaybeT m)) -> (#State# (PrimState (MaybeT m)), a#)) -> MaybeT m a

PrimMonad m => PrimMonad (ListT m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ListT m) :: *

Methods

primitive :: (State# (PrimState (ListT m)) -> (#State# (PrimState (ListT m)), a#)) -> ListT m a

PrimMonad m => PrimMonad (IdentityT m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (IdentityT m) :: *

Methods

primitive :: (State# (PrimState (IdentityT m)) -> (#State# (PrimState (IdentityT m)), a#)) -> IdentityT m a

(Error e, PrimMonad m) => PrimMonad (ErrorT e m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ErrorT e m) :: *

Methods

primitive :: (State# (PrimState (ErrorT e m)) -> (#State# (PrimState (ErrorT e m)), a#)) -> ErrorT e m a

(Monoid w, PrimMonad m) => PrimMonad (WriterT w m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (WriterT w m) :: *

Methods

primitive :: (State# (PrimState (WriterT w m)) -> (#State# (PrimState (WriterT w m)), a#)) -> WriterT w m a

(Monoid w, PrimMonad m) => PrimMonad (AccumT w m)

Since: primitive-0.6.3.0

Defined in Control.Monad.Primitive

Associated Types

type PrimState (AccumT w m) :: *

Methods

primitive :: (State# (PrimState (AccumT w m)) -> (#State# (PrimState (AccumT w m)), a#)) -> AccumT w m a

(Monoid w, PrimMonad m) => PrimMonad (WriterT w m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (WriterT w m) :: *

Methods

primitive :: (State# (PrimState (WriterT w m)) -> (#State# (PrimState (WriterT w m)), a#)) -> WriterT w m a

PrimMonad m => PrimMonad (StateT s m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (StateT s m) :: *

Methods

primitive :: (State# (PrimState (StateT s m)) -> (#State# (PrimState (StateT s m)), a#)) -> StateT s m a

PrimMonad m => PrimMonad (StateT s m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (StateT s m) :: *

Methods

primitive :: (State# (PrimState (StateT s m)) -> (#State# (PrimState (StateT s m)), a#)) -> StateT s m a

PrimMonad m => PrimMonad (SelectT r m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (SelectT r m) :: *

Methods

primitive :: (State# (PrimState (SelectT r m)) -> (#State# (PrimState (SelectT r m)), a#)) -> SelectT r m a

PrimMonad m => PrimMonad (ExceptT e m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ExceptT e m) :: *

Methods

primitive :: (State# (PrimState (ExceptT e m)) -> (#State# (PrimState (ExceptT e m)), a#)) -> ExceptT e m a

PrimMonad m => PrimMonad (ReaderT r m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ReaderT r m) :: *

Methods

primitive :: (State# (PrimState (ReaderT r m)) -> (#State# (PrimState (ReaderT r m)), a#)) -> ReaderT r m a

PrimMonad m => PrimMonad (ContT r m)

Since: primitive-0.6.3.0

Defined in Control.Monad.Primitive

Associated Types

type PrimState (ContT r m) :: *

Methods

primitive :: (State# (PrimState (ContT r m)) -> (#State# (PrimState (ContT r m)), a#)) -> ContT r m a

(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (RWST r w s m) :: *

Methods

primitive :: (State# (PrimState (RWST r w s m)) -> (#State# (PrimState (RWST r w s m)), a#)) -> RWST r w s m a

(Monoid w, PrimMonad m) => PrimMonad (RWST r w s m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (RWST r w s m) :: *

Methods

primitive :: (State# (PrimState (RWST r w s m)) -> (#State# (PrimState (RWST r w s m)), a#)) -> RWST r w s m a