Currently, it is:

`sumOfUniques n = foldr (add n) (additiveIdentity n) . unique n`

It should be:

`sumOfUniques n = foldr add additiveIdentity . unique n`

Currently, it is:

`sumOfUniques n = foldr (add n) (additiveIdentity n) . unique n`

It should be:

`sumOfUniques n = foldr add additiveIdentity . unique n`

Hi!

Are you seeing an error? I believe this example should be correct. Remember than in example we’re using our own definition of `Natural`

- a record that contains functions that tell us how to do arithmetic:

```
data Natural a = Natural
{ equal :: a -> a -> Bool
, add : a -> a -> a
, multiply :: a -> a -> a
, additiveIdentity :: a
, multiplicativeIdentity :: a
, displayAsString :: a -> String
}
```

We’ll call `sumOfUniques`

by giving it some particular definition of natural numbers, for example `intNatural`

or `peanoNatural`

. Here’s an example of how we might call it:

```
λ sumOfUniques intNatural [1..10]
55
```

In this example, we’re passing in `intNatural`

, which tells us how to do these operations on `Int`

values. Its’ defined like this:

```
intNatural :: Natural Int
intNatural = Natural
{ equal = (==)
, add = (+)
, multiply = (*)
, additiveIdentity = 0
, multiplicativeIdentity = 1
, displayAsString = show
}
```

If we substitute `intNatural`

for `n`

n in our example, we’d end up with something like this:

```
foldr (add intNatural) (additiveIdentity intNatural) . unique intNatural
```

You can see here that we’re accessing the functions inside of our `Natural`

record and passing them in as arguments to `foldr`

. If we expaned this out another layer, it’ll make a bit more sense:

```
-- First, remember that
add intNatural = (+)
additiveIdentity intNatural = 0
-- so
foldr (add intNatural) (additiveIdentity intNatural) . unique intNatural
-- is the same as
foldr (+) 0 . unique intNatural
```

Later, once we refactor `Natural`

to be a type class instead of a record, we won’t need to explicitly pass around `n`

at all, since that will be part of the constraint in our type class. In that case, we can imagine that our definition would be something like:

```
sumOfUniques :: Natural n => [n] -> n
sumOfUniques = foldr add additiveIdentity . unique
```

1 Like

Hi Rebecca,

Thank you very much for the detailed explanation. Sorry, the example is actually correct.

I was missing the fact that `equal`

and `additiveIdentity`

are actually **field selectors**. Instead, I thought they were the fields: types `a -> a -> Bool`

and `a`

, respectively. That would have been the case if the `Natural a`

would have been pattern-matched against `Natural{..}`

by enabling the `RecordWildCards`

extension.

1 Like