relude-0.6.0.0: Custom prelude from Kowainik
Copyright(c) 2011-2015 Edward Kmett
(c) 2018-2019 Kowainik
LicenseMIT
MaintainerKowainik <xrom.xkov@gmail.com>
Safe HaskellSafe
LanguageHaskell2010

Relude.Extra.Foldable1

Description

 
Synopsis

Documentation

class Foldable f => Foldable1 f where Source #

The class of foldable data structures that cannot be empty.

Minimal complete definition

foldMap1

Methods

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

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 Source #

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 Source #

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

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

head1 :: f a -> a Source #

The first element of a non-empty data structure.

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

last1 :: f a -> a Source #

The last element of a non-empty data structure.

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

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

The largest element of a non-empty data structure.

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

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

The smallest elemenet of a non-empty data structure.

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

Instances

Instances details
IsListError => Foldable1 [] Source #

⚠️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

Instance details

Defined in Relude.Extra.Foldable1

Methods

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

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

toNonEmpty :: [a] -> NonEmpty a Source #

head1 :: [a] -> a Source #

last1 :: [a] -> a Source #

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

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

Foldable1 Identity Source # 
Instance details

Defined in Relude.Extra.Foldable1

Methods

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

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

toNonEmpty :: Identity a -> NonEmpty a Source #

head1 :: Identity a -> a Source #

last1 :: Identity a -> a Source #

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

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

Foldable1 NonEmpty Source # 
Instance details

Defined in Relude.Extra.Foldable1

Methods

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

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

toNonEmpty :: NonEmpty a -> NonEmpty a Source #

head1 :: NonEmpty a -> a Source #

last1 :: NonEmpty a -> a Source #

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

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

Foldable1 ((,) c) Source # 
Instance details

Defined in Relude.Extra.Foldable1

Methods

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

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

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

head1 :: (c, a) -> a Source #

last1 :: (c, a) -> a Source #

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

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

(Foldable1 f, Foldable1 g) => Foldable1 (Product f g) Source # 
Instance details

Defined in Relude.Extra.Foldable1

Methods

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

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

toNonEmpty :: Product f g a -> NonEmpty a Source #

head1 :: Product f g a -> a Source #

last1 :: Product f g a -> a Source #

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

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

(Foldable1 f, Foldable1 g) => Foldable1 (Sum f g) Source # 
Instance details

Defined in Relude.Extra.Foldable1

Methods

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

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

toNonEmpty :: Sum f g a -> NonEmpty a Source #

head1 :: Sum f g a -> a Source #

last1 :: Sum f g a -> a Source #

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

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

(Foldable1 f, Foldable1 g) => Foldable1 (Compose f g) Source # 
Instance details

Defined in Relude.Extra.Foldable1

Methods

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

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

toNonEmpty :: Compose f g a -> NonEmpty a Source #

head1 :: Compose f g a -> a Source #

last1 :: Compose f g a -> a Source #

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

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

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

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]