Hello, I made this a few weeks ago and I just wanted to get some feedback on the implementation and maybe on the usefulness/syntax/design of its use?

Hello how could i do this better

Is there a smarter way to do something like this? Presumably, not creating new regexes each time would be a start. But what about the inefficiency of parsing through the

String

once for each pattern?

fun String.romanizeAccentedChars(): String {
    if (isBlank()) {
        return this
    }
    return this
        .replaceByRegex("[áàâ]", "a")
        .replaceByRegex("[äæ]", "ae")
        .replaceByRegex("[éèêëę]", "e")
        .replaceByRegex("[íîï]", "i")
        .replaceByRegex("[óōô]", "o")
        .replaceByRegex("[öø]", "oe")
        .replaceByRegex("[ūúùû]", "u")
        .replaceByRegex("[ü]", "ue")
        .replaceByRegex("[çć]", "c")
        .replaceByRegex("[ß]", "ss")
}

fun String.replaceByRegex(regexStr: String, replacement: String) =
    replace(regexStr.toRegex(), replacement)

1️⃣:

val serials = devices.map { it.motor.serial }

2️⃣:

val serials = devices.map(Device::motor).map(Motor::serial)

Is there any reason ever to go with 2️⃣?

what is the best way to find the common element from the character array? Suppose I have 2 character array and both arrays have some common characters. How to find those characters?

I've tried many approaches, nothing seems to work.

Is there a nicer way to write this:

val resultOrNull = firstAttemptOrNull() ?: run {
    if (someConditionMet()) {
        secondAttemptOrNull()
    } else {
        null
    }
}

How is this code I did with DI. How could I improve this?

fun main() {
    val capitalsService: CapitalsService = CapitalsServiceImpl(CapitalsRepositoryImpl())
    capitalsService.getCapitals()
}

interface CapitalsService {
    fun getCapitals(): List<Capital>
}

class CapitalsServiceImpl(private val capitalsRepository: CapitalsRepository) : CapitalsService {
    override fun getCapitals(): List<Capital> = capitalsRepository.getCapitals()
}

interface CapitalsRepository {
    fun getCapitals(): List<Capital>
}

class CapitalsRepositoryImpl : CapitalsRepository {
    override fun getCapitals() = listOf(Capital("Paris", Country("France", "Europe", 67399000), 2175601))
}

data class Country(val countryName: String?, val continent: String?, val population: Int?)

data class Capital(val cityName: String?, val capitalOf: Country?, val population: Int?)

is there a way to get this to work without specifying the generic type:

import kotlin.reflect.KClass

class Creator<T:Any>(val clazz: KClass<T>) {
    fun create(entity: T) {}
}

data class Post(val name:String)

class Transaction



inline fun <reified T:Any>Transaction.getCreator(): Creator<T> = Creator(T::class)

// this works:
Transaction().getCreator<Post>().create(Post("name"))
// this does not:
Transaction().getCreator().create(Post("name"))

Can this code be shortened?

fun getValue(value: Value, param: MutableMap<Char, Int>): Pair<Char, Int> {
    return when (value) {
        Value.MIN -> Pair(param.keys.elementAt(param.values.indexOf(param.values.minOrNull() ?: 0)), param.values.minOrNull() ?: 0)
        Value.MAX -> Pair(param.keys.elementAt(param.values.indexOf(param.values.maxOrNull() ?: 0)), param.values.maxOrNull() ?: 0)
    }
}

Thanks, Tom

How is this code for analysing the longest string in a list:

fun getLongestStringFromList(list: List<String>): String {
    val sizesDict = mutableMapOf<String, Int>()

    for (string in list) {
        sizesDict[string] = string.length
    }
    val max = sizesDict.values.indexOf(sizesDict.values.maxOrNull())
    return sizesDict.keys.elementAt(max)
}

It seems to work fine, but could improvements be made to this?

in this code, is there a way to avoid creating IdHandler twice?

internal data class EntityInfo<T:Any>(val idHandler: IDHandler, val classInfo: ClassInfo<T>) {
    constructor(kClass: KClass<T>) : this(Table(kClass), IDHandler(kClass), ClassInfo(kClass, IDHandler(kClass)))
}

if i have a method that takes a kproperty1 for one specific class, why does the kotlin compiler not allow to omit the class name when calling it?

data class Recipe(val id: Long?, val name: String, val description: String?) {
    companion object {
        fun find(field: KProperty1<Recipe, *>) {}
    }
}

this works:

Recipe.find(field = Recipe::id)

and this is red:

Recipe.find(field = ::id)

Is there a better way to define this class? Note, I don’t want to use a generic parameter, because the type of

rawItem

should not be exposed (and I would rather pass around

LazyItems

than

LazyItems<Foo>

). In other words, I want a kind of private

R

generic.

class LazyItems private constructor(
    private val rawItems: List<Any>,
    private val processItem: (Any) -> Item,
) {

    fun consumeItem(): Item {
        val rawItemToConsume = someFun(rawItems) // Any
        return processItem(rawItemToConsume)
    }

    companion object {
        operator fun <R: Any> invoke(
            rawItems: List<R>,
            processItem: (R) -> Item
        ) = LazyItems(rawItems) {
            processItem(it as R)
        }
    }
}

It’s a shame you can’t do something like:

class LazyItems constructor <R : Any> (
    private val rawItems: List<R>,
    private val processItem: (R) -> Item,
) {

it seems i can define 2 methods where the only difference in signature is the number of parameters that their lambda takes:

fun mf(method: suspend () -> String) {
}
fun mf(method: suspend (String) -> String) {
}

and i can call the method that takes one parameter just fine:

mf({string->"string"})

but how can i call the other method?

mf({"string"}) // fails with overload resolution ambiguity

I created a world generator for a game I'm making: Thoughts on it?

import biomes.Biome
import biomes.OakForest
import biomes.Savannah
import kotlin.random.Random

class World {
    private var worldSize: Int = 0
    private var biomes: MutableMap<IntRange, Biome> = mutableMapOf()

    data class PointData(val currentPoint: Int?, val currentBiome: Biome?)

    fun getPointData(point: Int): PointData {
        biomes.keys.forEach {
            if (it.contains(point)) {
                return PointData(point, biomes[it])
            }
        }
        return PointData(null, null)
    }

    companion object {

        fun generateWorld(): World {
            val it = World()
            it.worldSize = (Random.nextInt(100000, 1000000))


            var blocksCovered = 0
            var priorBiomeEndPoint = 0

            while (blocksCovered <= it.worldSize) {
                val possibleBiomes: List<Biome> = listOf(OakForest(), Savannah())
                val rand: Biome = possibleBiomes[Random.nextInt(0, 2)]
                val size = blocksCovered + rand.biomeSize
                it.biomes[priorBiomeEndPoint..size] = rand

                priorBiomeEndPoint = blocksCovered + rand.biomeSize
                blocksCovered += rand.biomeSize
            }

            return it
        }
    }
}

It will return at particular Int Ranges a certain biome:

how do i get a method reference to an overloaded interface function?

fun method() {}
fun method(number: Int, name: String) {}

// this works
val m: ()->Unit = ::method
val m2: (Int, String)->Unit = ::method


interface IImpl {
    fun method()
    fun method(number: Int, name: String)
}
// this does not work
val m: ()->Unit = IImpl::method
val m2: (Int, String)->Unit = IImpl::method

Code for a first app I made: (displpays a random snackbar.)

private lateinit var trueButton: Button
private lateinit var falseButton: Button

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        trueButton = findViewById(R.id.true_button)
        falseButton = findViewById(R.id.false_button)

        trueButton.setOnClickListener { makeSnackbar(R.string.correct_toast, it, themeConfig = RandomSnackbarConfiguration()) }
        falseButton.setOnClickListener { makeSnackbar(R.string.incorrect_toast, it, themeConfig = RandomSnackbarConfiguration()) }
    }
    fun makeSnackbar(resId: Int,
                     viewContext: View,
                     themeConfig: SnackbarThemeConfiguration = DefaultSnackbarConfiguration()) =
            Snackbar.make(viewContext, resId, Snackbar.LENGTH_SHORT)
            .setBackgroundTint(themeConfig.backgroundColor)
            .setTextColor(themeConfig.textColor).let {
                        it.setAnimationMode(BaseTransientBottomBar.ANIMATION_MODE_SLIDE)
                        it.show()
                    }
    abstract class SnackbarThemeConfiguration(val backgroundColor: Int, val textColor: Int)
    class DefaultSnackbarConfiguration() : SnackbarThemeConfiguration(Color.DKGRAY, Color.WHITE)
    class RandomSnackbarConfiguration() : SnackbarThemeConfiguration(
            Color.rgb(Random.nextInt(0,256),
                Random.nextInt(0, 256),
                Random.nextInt(0, 256)),
            Color.rgb(Random.nextInt(0,256),
                    Random.nextInt(0, 256),
                    Random.nextInt(0, 256)))
}

I'm getting into functional programming, here is my implementation of conways game of life. I feel like the content of main() doesnt really fit the functional paradigm, but i can't figure out a better way that doesn't risk stack overflow (unless I use stuff like tailrec which feels like cheating). I tried looking at other peoples implementations online, but they all seem ridiculously complicated. any advice ?

is there a better way to write this? :

users = listOf("klaus", "sepperl")+if (addChris) listOf("chris") else listOf()

Hey folks, in your opinion what is more "Kotlin Idiomatic" way for guard clauses? 🤔

I created this kind of 'VibratorHelper' class to help with vibration, opinions?

class VibratorHelper {
    companion object {
        private val vibrationNotSupportedMessage: String = "Your device (${Build.MANUFACTURER + Build.MODEL} API ${Build.VERSION.SDK_INT}) does not support vibration."

        fun vibrateFor(milliseconds: Long, context: Context) {
            val service = context.getSystemService(VIBRATOR_SERVICE) as Vibrator

            @Suppress("DEPRECATION")
            if (!service.hasVibrator()) Toast.makeText(context, vibrationNotSupportedMessage, Toast.LENGTH_SHORT) else service.vibrate(milliseconds)
        }

        fun vibrateIndefinitely(context: Context) = vibrateFor(Long.MAX_VALUE, context)
    }
}

This message was deleted.

Yea, I don’t think this is just a kotlin concept, and it’s not new. A lot has been written about the dangers of using exceptions for non-exceptional errors, control flow, etc. It’s a lot easier to solve when you have a stronger type system like kotlin does. Functional programming has patterns to solve this that have become pretty popular in modern kotlin. It’s painful to try to adopt if you’re migrating an old codebase, but if you think about this when you’re initially designing and writing code it’s a lot easier.

I’m trying to use dsl marker to allow some methods only on the root , some only on the leaf, and some on both. but it seems to not work. I cannot call `rootAndLeaf`despite it being in an interface without dsl marker. maybe the dsl marker is inherited?

@DslMarker
annotation class MyDSL

@MyDSL
interface RootOnly {
    fun rootOnly()
}
interface RootAndLeaf : RootOnly {
    fun call(function: Leaf.() -> Unit)
    fun rootAndLeaf()
}
@MyDSL
interface Leaf {
    fun leaf()
}

val block: RootAndLeaf.() -> Unit = {
    call {
        leaf()
        rootAndLeaf() // cannot be called by implicit receiver
    }
}

Here, the purpose of implementing

Lazy

is to encourage the result of

suspendableLazy()

to be used as a property (since it doesn’t make sense to use it otherwise):

interface SuspendableLazy<T>: Lazy<suspend () -> T>

fun <T> suspendableLazy(scope: CoroutineScope, provider: suspend () -> T) = object : SuspendableLazy<T> {
    private val computed = scope.async(start = CoroutineStart.LAZY) { provider() }

    override val value: suspend () -> T
        get() = computed::await

    override fun isInitialized() = computed.isCompleted
}

fun <T> suspendableLazy(provider: suspend () -> T) = object : SuspendableLazy<T> {
    @Volatile // since we are using the double-checked pattern
    private var computedLambda: (suspend () -> T)? = null

    private val mutex = Mutex()

    override val value: suspend () -> T
        get() {
            computedLambda?.also {
                return it
            }
            return result@{
                // because now we are inside the lambda being returned
                computedLambda?.also {
                    return@result it()
                }
                mutex.withLock {
                    // because now we have the lock
                    computedLambda?.also {
                        return@withLock it()
                    }
                    provider().also { computedValue ->
                        computedLambda = { computedValue }
                    }
                }
            }
        }

    override fun isInitialized() = computedLambda != null
}

// usage
val fooDelegate by suspendableLazy { /* compute Foo */ }
suspend fun fooValue(): Foo = fooDelegate()

any better way than duplicate code like this? (I'm receive a json response in 1 line, I want to loop char by char to properly display it for debug with the right new lines and indentations)

var c = it.read() // it: InputStream
        while (c != -1) {
            ..
            c = it.read()
        }