# Gleam: Difference of Squares

Problem on Exercism and on Project Euler

```
pub fn square_of_sum(n: Int) -> Int {}
pub fn sum_of_squares(n: Int) -> Int {}
pub fn difference(n: Int) -> Int {
square_of_sum(n) - sum_of_squares(n)
}
```

### First Iteration: Recursion

Since the square of the sum first takes the sum, my first notion was to use recursion to loop through the range. of numbers being summed.

```
pub fn square_of_sum(n: Int) -> Int {
let s = sum(n)
s * s
}
fn sum(n: Int) -> Int {
case n {
1 -> 1
_ -> n + sum(n - 1)
}
}
```

The public function is a wrapper that simply takes the result of the recursive function and squares it. Since Gleam has implicit returns, just multiplying the value by itself being the last statement is the result.

In the recursive function, there is the base case and the recursive case. The base case, which would usually be 0, but adding 0 to any value results in that value, thus it's 1. If n equals 1, return 1, thereby stopping the call chain. For the recursive case, which is for any positive integer greater than 1, add the current number to the result of recursing n - 1.

I used recursion for the `sum_of_squares`

as well, but I didn't need a wrapper function in this case.

```
pub fn sum_of_squares(n: Int) -> Int {
case n {
1 -> 1
_ -> n * n + sum_of_squares(n - 1)
}
}
```

I didn't need the wrapper in this case because given the last function, we saw that the sum of values was the recursive action, while squaring a value is a single action. Summing the squares is thus a recursive action that performs the action of squaring in each frame. When the recursive action was internal, there needed to be a function that takes the result and uses it.

### Second Iteration: List stdlib

Looking at others' solutions, I saw that I could use lists instead. So rather than recursion, I used built-in functions for implementing changes.

```
pub fn square_of_sum(n: Int) -> Int {
list.range(1, n)
|> list.reduce(fn(acc, x) { acc + x })
|> result.unwrap(0)
|> fn(x) { x * x }
}
```

Here, a list is created of values from 1 to n. That list is then reduced by adding all the elements, but the reduce function of the list std library returns a result, which will either be `Error(Nil)`

or `Ok(<sum>)`

, so the result has to be extracted and then I have the result piped to a function that squares the passed value.

I did the same for `sum_of_squares`

.

```
pub fn sum_of_squares(n: Int) -> Int {
list.range(1, n)
|> list.reduce(fn(acc, x) { acc + {x * x} })
|> result.unwrap(0)
}
```

### Third Iteration: Iterator stdlib

Reading a little more about Gleam, I found a more direct solution using an iterator.

```
pub fn square_of_sum(n: Int) -> Int {
iterator.range(1, n)
|> iterator.fold(0, fn(acc, x) { acc + x })
|> fn(x) { x * x }
}
```

The reason I don't use a built-in function like `int.power`

is because it returns a result, either `Ok`

or `Error`

, which I would then need to unwrap before using. However, an alternative could be:

```
pub fn square_of_sum(n: Int) -> Int {
list.range(1, n)
|> int.sum
|> fn(x) { x * x }
}
```

The iterator std library has both reduce and fold. I chose to use fold because reduce returns a result. In this case, the numbers are generated in the function, not provided, so it's guaranteed that the `int.sum`

and `iterator.fold`

would iterate on a list of numbers.