Hi guys, I've been thinking about my program's design and come up with an idea that it might be a good fit to use some FP structures.
But I am not very experienced in that field so I thought that maybe you will be so kind and help me 🙂
My problem is following:
I have some input from the user and a data class which wraps it with a meaningful type lets call it RawInput. This rawInput data class is a part of sealed class Input. Another variation of that sealed class is ParsedInput.
Next I have a bunch of processors which take this RawInput and they return Input type so it can be RawInput or ParsedInput.
Because the amount of processors may vary I have a processors dispatcher which takes all these processors and make them process RawInput until the type changes to parsedInput.
This obviously can be replaced by Either, but that's the easy part 🙂
Even if a single processor can't handle the rawInput it can apply some transformations to it. So it is important to pass the result between different processors.
To achieve that I wrote foldUntil function
inline fun <T, R> Iterable<T>.foldUntil(initial: R, operation: (acc: R, T) -> R, until: (acc: R) -> Boolean): R {
var accumulator = initial
for (element in this) {
if (!until(accumulator)) {
break
}
accumulator = operation(accumulator, element)
}
return accumulator
}
and I am using it like that:
processors.foldUntil(rawInput, function={ acc, resolver -> processor.process(acc as RawInput) }, until={ acc -> acc is RawInput })
But I believe that leveraging FP structures it can be done better. Sorry for the long post.