172 lines
2.5 KiB
Markdown
172 lines
2.5 KiB
Markdown
Folds
|
|
=====
|
|
|
|
Basic Folds
|
|
-----------
|
|
|
|
```haskell
|
|
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
|
|
```
|
|
|
|
```haskell
|
|
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
|
|
```
|
|
|
|
```haskell
|
|
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
|
|
```
|
|
|
|
```haskell
|
|
foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
|
|
```
|
|
|
|
```haskell
|
|
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
|
|
```
|
|
|
|
```haskell
|
|
fold :: Foldable t => Monoid m => t m -> m
|
|
```
|
|
|
|
```haskell
|
|
toList :: Foldable t => t a -> [a]
|
|
```
|
|
|
|
```haskell
|
|
null :: Foldable t => t a -> Bool
|
|
```
|
|
|
|
```haskell
|
|
length :: Foldable t => t a -> Int
|
|
```
|
|
|
|
```haskell
|
|
elem :: (Eq a, Foldable t) => a -> t a -> Bool
|
|
```
|
|
|
|
```haskell
|
|
maximum :: (Ord a, Foldable t) => t a -> a
|
|
```
|
|
|
|
```haskell
|
|
minimum :: (Ord a, Foldable t) => t a -> a
|
|
```
|
|
|
|
```haskell
|
|
sum :: (Num a, Foldable f) => f a -> a
|
|
```
|
|
|
|
```haskell
|
|
product :: (Num a, Foldable f) => f a -> a
|
|
```
|
|
|
|
#### Folding actions
|
|
|
|
```haskell
|
|
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
|
|
```
|
|
|
|
```haskell
|
|
for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
|
|
```
|
|
|
|
*Example*:
|
|
|
|
```haskell
|
|
>>> for_ [1..4] print
|
|
1
|
|
2
|
|
3
|
|
4
|
|
```
|
|
|
|
|
|
#### Applicative Folds
|
|
|
|
```haskell
|
|
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
|
|
```
|
|
|
|
```haskell
|
|
asum :: (Foldable t, Alternative f) => t (f a) -> f a
|
|
```
|
|
|
|
#### Monadic Folds
|
|
|
|
```haskell
|
|
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
|
|
```
|
|
|
|
```haskell
|
|
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
|
|
```
|
|
|
|
```haskell
|
|
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
|
|
```
|
|
|
|
```haskell
|
|
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
|
|
```
|
|
|
|
```haskell
|
|
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
|
|
```
|
|
|
|
```haskell
|
|
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
|
|
```
|
|
|
|
#### Specialized folds
|
|
|
|
```haskell
|
|
concat :: Foldable t => t [a] -> [a]
|
|
```
|
|
|
|
```haskell
|
|
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
|
|
```
|
|
|
|
```haskell
|
|
and :: Foldable t => t Bool -> Bool
|
|
```
|
|
|
|
```haskell
|
|
or :: Foldable t => t Bool -> Bool
|
|
```
|
|
|
|
```haskell
|
|
any :: Foldable t => (a -> Bool) -> t a -> Bool
|
|
```
|
|
|
|
```haskell
|
|
all :: Foldable t => (a -> Bool) -> t a -> Bool
|
|
```
|
|
|
|
```haskell
|
|
maximumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
|
|
```
|
|
|
|
```haskell
|
|
minimumBy :: Foldable t => (a -> a -> Ordering) -> t a -> a
|
|
```
|
|
|
|
#### Searches
|
|
|
|
```haskell
|
|
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
|
|
```
|
|
|
|
```haskell
|
|
find :: Foldable t => (a -> Bool) -> t a -> Maybe a
|
|
```
|
|
|
|
|
|
```haskell
|
|
foldr1May :: (a -> a -> a) -> [a] -> Maybe a
|
|
```
|
|
|
|
```haskell
|
|
foldl1May :: (a -> a -> a) -> [a] -> Maybe a
|
|
```
|