// re-implements fold as a functional accumulator
fun <E, R> myFoldFunc(elements: List<E>, initialResult: R, f: (R, E)->R): R {
    // helper that iterates through list
    // accumulator: result so far
    fun helpIterate(accumulator: R, remainingList: List<E>): R {
        return when (remainingList.isEmpty()) {
            true -> accumulator
            false -> helpIterate(
                f(accumulator, remainingList[0]),
                remainingList.drop(1)
            )
        }
    }
    
    return helpIterate(
        initialResult, 
        elements
    )
}

val mt = emptyList<String>()
val myNums = listOf(8, 6, 7, 5, 3, 0, 9)

println("sum (nums): " + myFoldFunc(myNums, 0) { acc,e -> acc + e })

println("count (nums): " + myFoldFunc(myNums, 0) { acc,_ -> acc + 1 })
println("count (empty): " + myFoldFunc(mt, 0) { acc,_ -> acc + 1 })

println("max (nums): " + myFoldFunc<Int, Int?>(myNums, null) { 
    acc,e -> maxOf(e, acc ?: e) 
})

println("max (mt): " + myFoldFunc<String, String?>(mt, null) { 
    acc,e -> maxOf(e, acc ?: e) 
})
println()























// re-implements fold as a functional accumulator
fun <E, R> myFold(elements: List<E>, initialResult: R, f: (R, E)->R): R {
    return when (elements.isEmpty()) {
        true -> initialResult
        false -> myFold(
            elements.drop(1),
            f(initialResult, elements[0]),
            f
        )
    }
}


println("sum (nums): " + myFold(myNums, 0) { acc,e -> acc + e })

println("count (nums): " + myFold(myNums, 0) { acc,_ -> acc + 1 })
println("count (empty): " + myFold(mt, 0) { acc,_ -> acc + 1 })

println("max (nums): " + myFold<Int, Int?>(myNums, null) { 
    acc,e -> maxOf(e, acc ?: e) 
})

println("max (mt): " + myFold<String, String?>(mt, null) { 
    acc,e -> maxOf(e, acc ?: e) 
})
println()













// re-implement the list constructor!
fun <T> buildListImp(n: Int, f: (Int)->T): List<T> {
    var myResult = mutableListOf<T>()
    
    for (i in 0 until n) {
        myResult.add(f(i))
    }
    
    return myResult
}


fun <T> buildListFold(n: Int, f: (Int)->T): List<T> {
    return (0 until n).fold(emptyList<T>()) {
        acc,idx -> acc + listOf(f(idx))
    }
}

println(buildListFold(5) {
    it + 1
})

println(buildListFold(5) {
    outer -> buildListFold(outer + 1) { 
        inner -> buildListFold(inner+1, { "£" }).joinToString("")
    }
})