Relude.Extra.Foldable1

Documentation

class Foldable f => Foldable1 f where

The class of foldable data structures that cannot be empty.

Minimal complete definition

foldMap1

Methods

foldMap1 :: Semigroup m => (a -> m) -> f a -> m

Map each element of the non-empty structure to a semigroup, and combine the results.

>>> foldMap1 SG.Sum (1 :| [2, 3, 4])
Sum {getSum = 10}
>>> foldMap1 show (123 :| [456, 789, 0])
"1234567890"

fold1 :: Semigroup m => f m -> m

Combine the elements of a non-empty structure using a semigroup.

>>> fold1 (1 :| [2, 3, 4 :: SG.Sum Int])
Sum {getSum = 10}
>>> fold1 (4 :| [5, 10 :: SG.Product Int])
Product {getProduct = 200}

toNonEmpty :: f a -> NonEmpty a

Convert a non-empty data structre to a NonEmpty list.

>>> toNonEmpty (Identity 2)
2 :| []

head1 :: f a -> a

The first element of a non-empty data structure.

>>> head1 (1 :| [2, 3, 4])
1

last1 :: f a -> a

The last element of a non-empty data structure.

>>> last1 (1 :| [2, 3, 4])
4

maximum1 :: Ord a => f a -> a

The largest element of a non-empty data structure.

>>> maximum1 (32 :| [64, 8, 128, 16])
128

minimum1 :: Ord a => f a -> a

The smallest elemenet of a non-empty data structure.

>>> minimum1 (32 :| [64, 8, 128, 16])
8

Instances

IsListError => Foldable1 []

⚠️CAUTION⚠️ This instance is for custom error display only.

Foldable1 is not supposed to be used with the lists.

In case it is used by mistake, the user will see the following:

>>> head1 [1, 2, 3]
...
... The methods of the 'Foldable1' type class work with non-empty containers.
      However, one of the 'Foldable1' functions is applied to the List.
...
      Possible fixes:
        * Replace []
          with one of the: 'NonEmpty', 'Identity', '(c,)', 'Compose f g', 'Product f g', 'Sum f g'
        * Or use 'Foldable' class for your own risk.
...

Since: 0.6.0.0

Defined in Relude.Extra.Foldable1

Methods

foldMap1 :: Semigroup m => (a -> m) -> [a] -> m

fold1 :: Semigroup m => [m] -> m

toNonEmpty :: [a] -> NonEmpty a

head1 :: [a] -> a

last1 :: [a] -> a

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

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

Foldable1 Identity

Defined in Relude.Extra.Foldable1

Methods

foldMap1 :: Semigroup m => (a -> m) -> Identity a -> m

fold1 :: Semigroup m => Identity m -> m

toNonEmpty :: Identity a -> NonEmpty a

head1 :: Identity a -> a

last1 :: Identity a -> a

maximum1 :: Ord a => Identity a -> a

minimum1 :: Ord a => Identity a -> a

Foldable1 NonEmpty

Defined in Relude.Extra.Foldable1

Methods

foldMap1 :: Semigroup m => (a -> m) -> NonEmpty a -> m

fold1 :: Semigroup m => NonEmpty m -> m

toNonEmpty :: NonEmpty a -> NonEmpty a

head1 :: NonEmpty a -> a

last1 :: NonEmpty a -> a

maximum1 :: Ord a => NonEmpty a -> a

minimum1 :: Ord a => NonEmpty a -> a

Foldable1 ((,) c)

Defined in Relude.Extra.Foldable1

Methods

foldMap1 :: Semigroup m => (a -> m) -> (c, a) -> m

fold1 :: Semigroup m => (c, m) -> m

toNonEmpty :: (c, a) -> NonEmpty a

head1 :: (c, a) -> a

last1 :: (c, a) -> a

maximum1 :: Ord a => (c, a) -> a

minimum1 :: Ord a => (c, a) -> a

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

Defined in Relude.Extra.Foldable1

Methods

foldMap1 :: Semigroup m => (a -> m) -> Product f g a -> m

fold1 :: Semigroup m => Product f g m -> m

toNonEmpty :: Product f g a -> NonEmpty a

head1 :: Product f g a -> a

last1 :: Product f g a -> a

maximum1 :: Ord a => Product f g a -> a

minimum1 :: Ord a => Product f g a -> a

(Foldable1 f, Foldable1 g) => Foldable1 (Sum f g)

Defined in Relude.Extra.Foldable1

Methods

foldMap1 :: Semigroup m => (a -> m) -> Sum f g a -> m

fold1 :: Semigroup m => Sum f g m -> m

toNonEmpty :: Sum f g a -> NonEmpty a

head1 :: Sum f g a -> a

last1 :: Sum f g a -> a

maximum1 :: Ord a => Sum f g a -> a

minimum1 :: Ord a => Sum f g a -> a

(Foldable1 f, Foldable1 g) => Foldable1 (Compose f g)

Defined in Relude.Extra.Foldable1

Methods

foldMap1 :: Semigroup m => (a -> m) -> Compose f g a -> m

fold1 :: Semigroup m => Compose f g m -> m

toNonEmpty :: Compose f g a -> NonEmpty a

head1 :: Compose f g a -> a

last1 :: Compose f g a -> a

maximum1 :: Ord a => Compose f g a -> a

minimum1 :: Ord a => Compose f g a -> a

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

Strictly folds non-empty structure with given function f:

foldl1' f [x0, x1, x2 ...] = f (f x0 x1) x2 ...

>>> foldl1' (++) ([1,2] :| [[3,4], [5,6]])
[1,2,3,4,5,6]