Relude.Extra.Foldable1

Foldable1 is a typeclass like Foldable but for non-empty structures. For example, NonEmpty, Identity.

Foldable1 has all type-safe and total methods like head1, maximum1 in contradiction with Foldable.

Since: 0.3.0

Documentation

class Foldable f => Foldable1 (f :: Type -> Type) where

The class of foldable data structures that cannot be empty.

Since: 0.3.0

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}

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

Combines the elements of a non-empty structure using a binary function f.

>>> foldr1 (+) 0 (1 :| [2, 3])
6
>>> foldr1 (+) 1 $ Identity 3
4

Since: 1.0.0.0

toNonEmpty :: f a -> NonEmpty a

Convert a non-empty data structure 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 element of a non-empty data structure.

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

maximumOn1 :: Ord b => (a -> b) -> f a -> a

The largest element of a non-empty data structure with respect to the given comparison function.

>>> maximumOn1 abs (0 :| [2, 1, -3, -2])
-3

Since: 1.0.0.0

minimumOn1 :: Ord b => (a -> b) -> f a -> a

The smallest element of a non-empty data structure with respect to the given comparison function.

>>> minimumOn1 abs (0 :| [2, 1, -3, -2])
0

Since: 1.0.0.0

Instances

Foldable1 NonEmpty

Since: 0.3.0

Defined in Relude.Extra.Foldable1

Methods

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

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

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

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

maximumOn1 :: Ord b => (a -> b) -> NonEmpty a -> a

minimumOn1 :: Ord b => (a -> b) -> NonEmpty a -> a

Foldable1 Identity

Since: 0.3.0

Defined in Relude.Extra.Foldable1

Methods

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

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

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

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

maximumOn1 :: Ord b => (a -> b) -> Identity a -> a

minimumOn1 :: Ord b => (a -> b) -> Identity a -> a

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

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

toNonEmpty :: [a] -> NonEmpty a

head1 :: [a] -> a

last1 :: [a] -> a

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

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

maximumOn1 :: Ord b => (a -> b) -> [a] -> a

minimumOn1 :: Ord b => (a -> b) -> [a] -> a

Foldable1 ((,) c)

Since: 0.3.0

Defined in Relude.Extra.Foldable1

Methods

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

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

foldr1 :: (a -> b -> b) -> b -> (c, a) -> b

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

maximumOn1 :: Ord b => (a -> b) -> (c, a) -> a

minimumOn1 :: Ord b => (a -> b) -> (c, a) -> a

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

Since: 0.3.0

Defined in Relude.Extra.Foldable1

Methods

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

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

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

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

maximumOn1 :: Ord b => (a -> b) -> Product f g a -> a

minimumOn1 :: Ord b => (a -> b) -> Product f g a -> a

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

Since: 0.3.0

Defined in Relude.Extra.Foldable1

Methods

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

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

foldr1 :: (a -> b -> b) -> b -> Sum f g a -> b

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

maximumOn1 :: Ord b => (a -> b) -> Sum f g a -> a

minimumOn1 :: Ord b => (a -> b) -> Sum f g a -> a

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

Since: 0.3.0

Defined in Relude.Extra.Foldable1

Methods

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

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

foldr1 :: (a -> b -> b) -> b -> Compose f g a -> b

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

maximumOn1 :: Ord b => (a -> b) -> Compose f g a -> a

minimumOn1 :: Ord b => (a -> b) -> 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]

Since: 0.3.0

average1 :: forall a f. (Foldable1 f, Fractional a) => f a -> a

Given a Foldable1 of Fractional elements, computes the average if possible and returns the resulting element.

>>> average1 (42 :| [])
42.0
>>> average1 (1 :| [2,3,4])
2.5

Since: 1.0.0.0