Hello Everyone,
I am starting to lean towards the declarative programming paradigm in Kotlin, also applying design patterns.
What is Imperative Programming?
You give the computer a set of instructions to follow and the computer does what you want in an easy-to-follow sequence.
What is Declarative Programming?
As a process of constantly defining what things are. This is referred to as declarative programming.
Some of the examples I found online it seems to me is in the form of imperative style. So I tried to construct a builder design pattern in declarative way with immutability in mind.
for the code example below
I declared an interface DailySetup with an implementation of data class DailySetuImpl as follows.
Then create a function dailySetup that returns an instance of DailySetup and accepts a higher order function that can access all properties of DailySetupImpl
approach 1
fun main() { val setup = dailySetup { constant = 1 timeFunction = 1 timeMult = 1 } println("calculated setup: "+setup.calculate()) } fun DailySetup.calculate(): Int { return (this.timeFunction*this.timeMult)+this.constant } interface DailySetup { val constant: Int val timeFunction: Int val timeMult: Int } data class DailySetupImpl private constructor( override var constant: Int = 0, override var timeFunction: Int = 0, override var timeMult: Int = 0 ): DailySetup { companion object { fun default () = DailySetupImpl() } } fun dailySetup(block: DailySetupImpl.()-> Unit): DailySetup { return DailySetupImpl.default().apply(block) } approach 2
fun main() { val setup = DailySetupBuilder.create { constant = 1 timeFunction = 1 timeMult = 1 } println("calculated setup: "+setup.calculate()) } fun DailySetup.calculate(): Int { return (this.timeFunction*this.timeMult)+this.constant } interface DailySetup { val constant: Int val timeFunction: Int val timeMult: Int } data class DailySetupImpl private constructor( override var constant: Int = 0, override var timeFunction: Int = 0, override var timeMult: Int = 0 ): DailySetup { companion object { fun default () = DailySetupImpl() } } class DailySetupBuilder { companion object { fun create(block: DailySetupImpl.()-> Unit): DailySetup { return DailySetupImpl.default().apply(block) } } } approach 3
we can utilize sealed classes, sealed classes cannot be explicitly initialized
... sealed class DailySetupImpl( override var constant: Int = 0, override var timeFunction: Int = 0, override var timeMult: Double = 0.0, override var internalObj: SetupInternalObj? = null ): DailySetup { object DEFAULT: DailySetupImpl() } class DailySetupBuilder { companion object { fun create(block: DailySetupImpl.()-> Unit): DailySetup { return DailySetupImpl.DEFAULT.apply(block) } } } In this way, I think, it is created via declarative way. What do you think of this approach?
Top comments (0)