# Folding Results

Kotlin is a fantastic language. Every day, I find a new function or method that makes programming in it a breeze. One of my go-to functions I keep reaching for recently is [fold](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/fold.html). You can think of `fold` like a `reduce`; however, `reduce` starts with the first value in the list, whereas `fold` starts with the given initial value and the first item in the list.

An example always helps. We have a list of sites for a business and want to calculate the total staff numbers plus the staff at head office. We can pass the head office staff numbers in as the initial value.

```kotlin
val sites = listOf(
    Site("Site A", 150),
    Site("Site B", 120),
    Site("Site C", 80),
    Site("Site D", 200)
)

val headOfficeStaff = 25
val totalStaff = sites.fold(headOfficeStaff) { 
total, site -> total + site.staffCount 
}

println(totalStaff) // 575
```

So, we have a good idea of how to use `fold` now; however, it has some other interesting use cases. When dealing with the `Result` value in Kotlin, `fold` can provide some nice syntax sugar when unwrapping the values. Let's use another example.

We want to fetch the carbon footprint for a given account and year. Internally, the function calls a database to get all footprints for an account and returns a `Result`. We can use fold to process this `Result`.

```kotlin
fun calculateFootprint(account: String, year: Int): Double? {
    return getYearlyFootprintsForAccount(account).fold(
        onFailure = { error ->
            println("Error fetching data: ${error.message}")
            null
        },
        onSuccess = { yearlyFootprints ->
            yearlyFootprints.find { it.year == year }?.carbon
        }
    )
}
```

Honestly, I love `fold`. Not only can you use it for formatting and aggregating data, but it provides a very clean way of processing Result values.