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

Why not just chain them? return func1() && func2() && func3()

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

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

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

😛

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()

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)

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

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

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..

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

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...

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

}