Kotlin Design Pattern: Builder

Victor Harlan D. Lacson — Mon, 03 Jan 2022 09:33:23 +0000

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?

Kotlin CSV to Data Class Parser

Victor Harlan D. Lacson — Wed, 17 Jun 2020 07:43:51 +0000

Update: The current version is 0.8.0

Features

1. Simple And Direct

No hard configuration
No invasive annotations to data class
Custom mapping
Nullable Data Types

2. Primitive Types

Short
Int
Long
Float
Double
Boolean
String

3. Support for Java 8 Date Time Apis

LocalTime
LocalDateTime
LocalDate
Custom Formatting

4. Support Custom Data Type Transformation

see documentation

Hello Everyone!!

Hi to those who love Kotlin

To this date, I haven't found one unique implementation on Kotlin CSV parser into Kotlin data class.

So I decided to create one, and it is now available on GitHub Kotlin-Grass.

Unlike some existing Java CSV parsers, it doesn't require to invade your data class with annotation to map CSV file columns to data class fields.

It requires another awesome Kotlin library for reading the CSV, namely Kotlin-CSV. Since this one is implemented in Kotlin Multiplatform I don't intend to reinvent the wheel for reading CSV File.

Let's get back to my Kotlin-Grass, a CSV to data class parser. It is already available at Maven Central for download.

repositories {
  mavenCentral()
}

dependencies {
   //doyaaaaaken's kotlin-csv
   implementation("com.github.doyaaaaaken:kotlin-csv-jvm:0.15.2")
   //kotlin-grass
   implementation("io.github.blackmo18:kotlin-grass-core-jvm:1.0.0")
   implementation("io.github.blackmo18:kotlin-grass-parser-jvm:0.8.0")")
}

Its usage is quite simple and direct nothing more than a plug and play

for example, we have a CSV file with the following data

short,int,long,float,double,boolean,string
0,1,2,3.0,4.0,true,hello

the data class would simply look like

data class PrimitiveTypes(
    val short: Short,
    val int: Int,
    val long: Long,
    val float: Float,
    val double: Double,
    val boolean: Boolean,
    val string: String
)

Yes! No annotation is required. It will automatically map the first line as header to data class fields.

The usage is just like

val csvContents = csvReader().readAllWithHeader(file)
val dataClasses = grass<PrimitiveTypes>().harvest(csvContents)

or the other way

csvReader.open(file) {
    val csvContents = readAllWithHeaderAsSequence()
    val dataClasses = grass<PrimitiveTypes>().harvest(csvContents)
}

You get a list or sequence of object parsed into a data class.

Also your PRs and feature requests are much appreciated if you had any issues.

Happy Hacking

DEV Community: Victor Harlan D. Lacson