Is this the best way to return `true` only if all ...

# announcements

[dave08]

Is this the best way to return true only if all functions return true? (without putting them all on the same line... there's some code in between them)

var success = func1()
success = success && func2()
success = success && func3()

return success

[Big Chungus]

Why not just chain them?

return func1() && func2() && func3()

[dave08]

I added a comment to the question that there's code in between them, and sometimes conditionals, etc...

[dave08]

I was expecting a =&& ... but there isn't any.

[Big Chungus]

Ah, right. Then this seems to be optimal. Alternatively you could terminate early with false value and only return true if you reach the end

[dave08]

Yeah, but I do need the function to complete in this case. But true, that is another option in some cases. But I'd have to do something like func1().takeUnless { it } ?: return false 😛

[Michael Böiers]

Performance-wise, the code seems optimal. But it doesn’t look nice. This might be an alternative, but at the expense of creating a list. It also would be better if the allTrue() was already there in the standard library 🙂

fun List<Boolean>.allTrue() = all { it }

fun foo() = true
fun bar() = false
fun baz() = true

val results = mutableListOf<Boolean>()

results += foo()

results += bar()

results += baz()

val endResult = results.allTrue()

[dave08]

Actually that gave me an idea 🙂, a pity that value classes can't use vars though...

class CompoundSuccessResult(var result: Boolean) {
		operator fun plusAssign(other: Boolean) { result = result && other }
	}
	
	fun Boolean.toCompoundSuccess() = CompoundSuccessResult(this)

[dave08]

Then:

val results = foo().toCompoundSuccess()
results += bar()
results += baz()

return results.result

[Michael Böiers]

I had the same idea, but let’s just assume the starting value as true:

class Results {
    var allOk: Boolean = true
        private set

    operator fun plusAssign(execution: Boolean) {
        allOk = allOk && execution
    }
}

fun foo() = true
fun bar() = false
fun baz() = true

val results = Results()

results += foo() 

results += bar()

results += baz()

val endResult = results.allOk

[dave08]

Yeah, that might look better, and the naming is also better 🙂

[Michael Böiers]

Could be done in a more generic way with a list of booleans, so that it could offer some useful evaluations like allTrue, anyTrue, allFalse, anyFalse, allTrueButOne etc..

[Roukanken]

imho, in terms of code readability, the best way is to just assign the return values to vals and and them at the end - this way, whoever reads the return of the function or if that uses em, knows exactly what is required for it to pass/return true

eg

val isFeature1 = func1()
val isFeature2 = func2()
val isFeature3 = func3()

return isFeature1 && isFeature2 && isFeature3

ofc, this is not optimal in terms of performance, as all would need to be executed everytime
and does not work if the function calls are variable amount

[dave08]

Yup, that was my problem... sometimes certain calls won't be made, and then it becomes a mess to put the vars in the beginning and isFeature.takeUnless { it } ?: true in that return statement...

[Michael Böiers]

Here’s another solution:

class Runner {
    var allOk: Boolean = true
        private set

    fun check(task: () -> Boolean) = also { allOk = allOk && task() } 
}

fun foo() = true
fun bar() = false
fun baz() = true


fun main() {

    val endResult = Runner()
        .also {
            // arbitrary code
        }
        .check { foo() }
        .also {
            // arbitrary code
        }
        .check { bar() }
        .also {
            // arbitrary code
        }
        .check { baz() }
        .also {
            // arbitrary code
        }
        .allOk

}