How would you structure and format this code? ``` val (rootMountedOrSystemRoot, h...

# getting-started

[Hackintoshfive]

How would you structure and format this code?

val (rootMountedOrSystemRoot, hasSystemPartition) = lines.fold(false to false) { acc, it ->
                        (
                                acc.first
                                        || it.device == "/dev/root" && it.mountpoint == "/"
                                        || it.mountpoint == "/system_root" && it.type != "tmpfs"
                        ) to (
                                acc.second
                                        || it.mountpoint == "/system" && it.type != "tmpfs" && it.device != "none"
                        )
                    }

There's a more generic version in the comments

[Hackintoshfive]

I'll get rid of the scary conditions to make it more readable

[Hackintoshfive]

Here's a more generic example:

(0 until 10).fold(false to false) { acc, it ->
    (
            acc.first
                    || it.mod(2) == 0
    ) to (
            acc.second
                    || it.mod(3) == 0
                    || it.mod(5) == 1
    )
}

[Adam S]

I think it’s confusing to use a pair as the accumulator, so instead I’d use any {} and two variables.

val values = (0 until 10)

val hasEvenNumbers = values.any { it % 2 == 0 }
val hasFooNumbers = values.any { it % 3 == 0 || it % 5 == 1 }

return hasEvenNumbers to hasFooNumbers

[sciack]

In addition I will create function in it type (or extension function) that return true/false based on the 3 original condition, this make everything more readable (if the function has a good name).

[Hackintoshfive]

I can't use any because it's an iterator

[Hackintoshfive]

I mean, I could do two passes, but it's gonna be slower

[Wout Werkman]

Also I'd recommend destructuring the Pair to explain what it represents:

(0 until 10).fold(false to false) { (evenNumbersFound, fooNumbersFound), it ->

[Wout Werkman]

Doing 2 passes using any* on an IntRange will very likely be faster than the fold, which will instantiate a Pair on each iteration

[sciack]

Also the any return the first matching, could be really fast.

[sciack]

And how many object do you have? and in reality complexity is almost the same, is both linear and both condition evaluated. Unless iterating the list is really slow due to some network/os slow call.

[Hackintoshfive]

It's not an IntRange, it's an Iterator. Either I call .toList() before I use .any{}, or I call .fold{}. Iterator reads from the disk and could potentially take a lot of RAM to convert to List.

[Hackintoshfive]

I think that a for-loop is cleanest, to be honest.

[sciack]

Have you try to use a sequence?

[Wout Werkman]

In this case fold is usually a good solution. One thing you could do to allow stopping iteration early is using runningFold and takeWhile

iterator.asSequence()
    .runningFold { acc, it -> /* operation here */ }
    .takeWhile { (left, right) -> !(left && right) } // Will stop as soon as both are true
    .last()

[Hackintoshfive]

Good point, but it's easier to express in a for loop 🤷

[Wout Werkman]

Yes, luckily everyone is free to pick their style, but it's good that you considered sequences 🙂

[Hackintoshfive]

Yes, sequences are good, but I have to ship fewer classes if I use a for loop

[Wout Werkman]

Not trying to convince anyone, but I feel this has to be mentioned. One additional advantage of using functional map-reduce or friends is that they are generally quite easy to parallelize.

[Hackintoshfive]

Well since all I'm doing is binary ORs, I don't think parallelization is a big concern. But I am interested, how would I do this? Obviously the best approach is to split the list into N chunks, OR the elements of each chunk, then OR the chunks, but how would I do this? (I'm also sending to the channel because we've changed topic so much and people might be interested in the new one)