# How can we create a generic Array Extension that sums Number types in Swift?

I think I found a reasonable way of doing it, borrowing some ideas from scalaz and starting from your proposed implementation. Basically what we want is to have typeclasses that represents monoids.

In other words, we need:

- an associative function
- an identity value (i.e. a zero)

Here's a proposed solution, which works around the swift type system limitations

First of all, our friendly `Addable`

typeclass

```
protocol Addable {
class func add(lhs: Self, _ rhs: Self) -> Self
class func zero() -> Self
}
```

Now let's make `Int`

implement it.

```
extension Int: Addable {
static func add(lhs: Int, _ rhs: Int) -> Int {
return lhs + rhs
}
static func zero() -> Int {
return 0
}
}
```

So far so good. Now we have all the pieces we need to build a generic `sum function:

```
extension Array {
func sum<T : Addable>() -> T {
return self.map { $0 as T }.reduce(T.zero()) { T.add($0, $1) }
}
}
```

Let's test it

```
let result: Int = [1,2,3].sum() // 6, yay!
```

Due to limitations of the type system, you need to explicitly cast the result type, since the compiler is not able to figure by itself that `Addable`

resolves to `Int`

.

So you cannot just do:

```
let result = [1,2,3].sum()
```

I think it's a bearable drawback of this approach.

Of course, this is completely generic and it can be used on any class, for any kind of monoid.
The reason why I'm not using the default `+`

operator, but I'm instead defining an `add`

function, is that this allows **any** type to implement the `Addable`

typeclass. If you use `+`

, then a type which has no `+`

operator defined, then you need to implement such operator in the global scope, which I kind of dislike.

Anyway, here's how it would work if you need for instance to make both `Int`

and `String`

'multipliable', given that `*`

is defined for `Int`

but not for `String.

```
protocol Multipliable {
func *(lhs: Self, rhs: Self) -> Self
class func m_zero() -> Self
}
func *(lhs: String, rhs: String) -> String {
return rhs + lhs
}
extension String: Multipliable {
static func m_zero() -> String {
return ""
}
}
extension Int: Multipliable {
static func m_zero() -> Int {
return 1
}
}
extension Array {
func mult<T: Multipliable>() -> T {
return self.map { $0 as T }.reduce(T.m_zero()) { $0 * $1 }
}
}
let y: String = ["hello", " ", "world"].mult()
```

Now array of `String`

can use the method `mult`

to perform a reverse concatenation (just a silly example), and the implementation uses the `*`

operator, newly defined for `String`

, whereas `Int`

keeps using its usual `*`

operator and we only need to define a zero for the monoid.

For code cleanness, I much prefer having the whole typeclass implementation to live in the `extension`

scope, but I guess it's a matter of taste.

Here's a silly implementation:

```
extension Array {
func sum(arr:Array<Int>) -> Int {
return arr.reduce(0, {(e1:Int, e2:Int) -> Int in return e1 + e2})
}
func sum(arr:Array<Double>) -> Double {
return arr.reduce(0, {(e1:Double, e2:Double) -> Double in return e1 + e2})
}
}
```

It's silly because you have to say `arr.sum(arr)`

. In other words, it isn't encapsulated; it's a "free" function `sum`

that just happens to be hiding inside Array. Thus I failed to solve the problem you're *really* trying to solve.

In Swift 2, you can solve it like this:

Define the monoid for addition as protocol

```
protocol Addable {
init()
func +(lhs: Self, rhs: Self) -> Self
static var zero: Self { get }
}
extension Addable {
static var zero: Self { return Self() }
}
```

In addition to other solutions, this explicitly defines the zero element using the standard initializer.

Then declare Int and Double as Addable:

```
extension Int: Addable {}
extension Double: Addable {}
```

Now you can define a sum() method for all Arrays storing Addable elements:

```
extension Array where Element: Addable {
func sum() -> Element {
return self.reduce(Element.zero, combine: +)
}
}
```

As of Swift 2 it's possible to do this using protocol extensions. (See The Swift Programming Language: Protocols for more information).

First of all, the `Addable`

protocol:

```
protocol Addable: IntegerLiteralConvertible {
func + (lhs: Self, rhs: Self) -> Self
}
extension Int : Addable {}
extension Double: Addable {}
// ...
```

Next, extend `SequenceType`

to add sequences of `Addable`

elements:

```
extension SequenceType where Generator.Element: Addable {
var sum: Generator.Element {
return reduce(0, combine: +)
}
}
```

Usage:

```
let ints = [0, 1, 2, 3]
print(ints.sum) // Prints: "6"
let doubles = [0.0, 1.0, 2.0, 3.0]
print(doubles.sum) // Prints: "6.0"
```