# Folding Nonempty Structures In Haskell

This is the fifth of a series of articles that illustrates functional programming (FP) concepts. As you go through these articles with code examples in Haskell (a very popular FP language), you gain the grounding for picking up any FP language quickly. Why should you care about FP? See this post.

In the last post, we learned about catamorphism/folds with an example function using `foldr` in Haskell. In this post, we'll learn about the variants for folding nonempty structures and some of their advantages.

Recall the signature of `foldr`:

``````*Main> :t foldr
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b``````

It takes a function, the base case, and a foldable structure as inputs. Because the base case is the output for an empty list input, when the input list is nonempty, we can omit the base case. We use `foldr1` or `foldl1` to tell Haskell that the input list is nonempty:

``````Prelude> sumn = foldr1 (+)
Prelude> :t sumn
sumn :: (Foldable t, Num a) => t a -> a``````

However, if the input list is empty, Haskell throws an exception:

``````Prelude> sumn []
*** Exception: Prelude.foldr1: empty list``````

Not needing to specify the base case avoids certain mispecifications. For example, when you want to sum all elements of a list, the compiler cannot catch the typo of this base case:

``````Prelude> sum = foldr (+) 1
--sum is the sum of all elements in the list plus 1.
Prelude> sum [1,2,3]
7``````

In my last post, I use the example of finding the minimum of a list:

``````findMinFold :: [Int] -> Int
findMinFold = foldr min maxBound``````

Recall that the base case is `maxBound`, of type:

``````Prelude> :t maxBound
maxBound :: Bounded a => a``````

This restricts `a` to be an instance of the `Bounded` typeclass. That is, `findMinFold` only works on any type that are bounded. For example,

``````-- it works on Char
Prelude> findMinFold ['a','b','c']
'a'``````

It does not work on `String`, because `String` or `[Char]` is not bounded:

``````Prelude> findMinFold ["string","works","too"]

<interactive>:3:1: error:
• No instance for (Bounded [Char])
arising from a use of ‘findMinFold’
• In the expression: findMinFold ["string", "works", "too"]
In an equation for ‘it’:
it = findMinFold ["string", "works", "too"]``````

Using nonempty structures folds makes the function polymorphic to any type. Looking at `foldr1`'s signature, you can see that there are no requirement for `a`:

``foldr1 :: (a -> a -> a) -> t a -> a``

Using `foldr1`, `findMin1` is more polymorphic, because it works for even types that are not bounded:

``````findMin1 = foldr1 min

-- it works on Int lists.
Prelude> findMin1 [1,2,3,0]
0

-- it also works on String lists.
Prelude> findMin1 ["string","works","too"]
"string"``````

## Making Use of the `NonEmpty` Type to Avoid Exceptions

`foldr1` and `foldl1` seem really useful, but getting an exception when the list is empty is not ideal. Statically typed languages (including Haskell) can help with this. Statically typed languages type check (verify all functions have the correct input types passed to them) at compile-time as opposed to run-time. We can thus specify that the input type is a nonempty type.

The nonempty list type is already defined for you in Data.List.NonEmpty:

``````data NonEmpty a
a :| [a]``````

The advantage of using it is that Haskell treats it like lists, and thus you can use all the list operations on NonEmpty lists.

``````-- Import the library that supports NonEmpty
Prelude> import Data.List.NonEmpty

--Define findMin1 such that its input type is NonEmpty
Prelude Data.List.NonEmpty> findMin1 = foldr1 min :: (Ord a) => NonEmpty a -> a
Prelude Data.List.NonEmpty> findMin1 (1:|[2,3,0])
0
Prelude Data.List.NonEmpty> findMin1 ("strings":|["works","too"])
"strings"

--Type error occurs when the input list is empty.
Prelude Data.List.NonEmpty> findMin1 []

<interactive>:5:10: error:
• Couldn't match expected type ‘NonEmpty a’ with actual type ‘[a0]’
• In the first argument of ‘findMin1’, namely ‘[]’
In the expression: findMin1 []
In an equation for ‘it’: it = findMin1 []
• Relevant bindings include it :: a (bound at <interactive>:5:1)``````

Okay! You've learned Haskell's many methods for folds (`foldr`, `foldl`, `foldr1`, `foldl1`) and their advantages. In the next post, we'll move on to another recursion scheme: anamorphisms, also referred to as unfolds. Stay tuned! This site uses Akismet to reduce spam. Learn how your comment data is processed.