AnyCallback is a rewrite of an existing Kotlin stdlib function

[apatrida]

This question needs redesigned as it enters the realm of "silly" when you can solve this in 1 line of code using first(predicate), none, any, find(predicate), etc. You'd have to list all functions they could not call to make them really want to recurse. If you want a recursive question, then force it with a custom data structure (NodeLinkedList) that doesn't have 10 existing methods that already do the same answer.

If you don't use a custom data structure, the silly factor is that people know they can just call:

return list.any { callback(it) }

Also, the existing Solution1 throws an exception on empty list. Probably not intended but also is not documented?

private object Solution1 {
    private fun anyCallback(list: List<Int>, callback: (Int) -> Boolean): Boolean {
        if (list.size == 1) {
            return callback(list.first())
        }

        // THROWS EXCEPTION ON EMPTY LIST!!!!
        return callback(list.first()) || anyCallback(list.drop(1), callback)
    }
}

the solution could be a little more efficient (don't copy the list, copy a view of the list instead):

internal object Solution2 {
    fun anyCallback(list: List<Int>, callback: (Int) -> Boolean): Boolean {
        if (list.isEmpty()) return false
        return callback(list.first()) || anyCallback(list.subList(1, list.size), callback)
    }
}

Of course that assumes it isn't a LinkedList, but there is always:

internal object Solution3 {
    fun anyCallback(list: List<Int>, callback: (Int) -> Boolean): Boolean {
        fun _randomAccessOptimized(list: List<Int>, callback: (Int) -> Boolean): Boolean {
            if (list.isEmpty()) return false
            return callback(list.first()) || _randomAccessOptimized(list.subList(1, list.size), callback)
        }

        fun _sequentialOptimized(list: List<Int>, callback: (Int) -> Boolean): Boolean {
            if (list.isEmpty()) return false
            return callback(list.first()) || _sequentialOptimized(list.drop(1), callback)
        }


        return if (list is RandomAccess) {
           _randomAccessOptimized(list, callback)
        }
        else {
            _sequentialOptimized(list, callback)
        }
    }
}