Is there a way to infer that the class implementing an abstract class is the caller of a lambda with receiver?

abstract class AbstractFoo<T> {
  operator fun invoke(action: T.() ->Unit) {
    action() // <-- error here: No value passed for parameter 'p1'
  }
}

Is it possible to do something based on a reified T parameter being another something? I wanted something like

inline fun <reified T> foo() {
    when(T) {
       is Foo -> tFoo()
        is Bar -> tBar()
    }
}

anybody have experience using the experimental unsigned types? any words of caution before I move forward with a new project that I plan to use them in?

I accidentally stumbled on this the other day. If my parameter is defined as a function that takes 3 parameters:

class MyClass(private val getString: (Context, Int, Array<String>) -> String)

I can call it with a lambda as such:

MyClass { context, resId, formatArgs -> context.getString(resId, formatArgs) }

But I can also use a method reference for the first parameter and if the signature matches the second and third parameter.

MyClass(Context::getString)

This is really cool. Is there a specific page on the docs where I can read more about this? I would love to learn more but my :google:-fu is failing me on this topic.

site = <http://dto.site|dto.site> ?: <http://this.site|this.site>!!

is this the best way to say use first if not null else use second if that also is null thow?

Is there a proposal out there somewhere for Kotlin to support variadic generic type parameters?

Are there any tools like Findbugs/Spotbugs/Sonarlint that work for Kotlin? Or do those 3 also work for Kotlin?

Is there any simpler way to write it:

if (y) x.getSomething() else null

Note that

x.getSomething().takeIf { y }

isn't identical, because it always calculate

x.getSomething()

.

Reading the docs on Ktor's HttpClient and WebSockets - https://ktor.io/clients/websockets.html Am I reading this right that if I use websockets on my server side, I won't be able to use the HttpClient in my clients on any platform other than JVM/Android, as the engine backing it for iOS/JS doesn't support it yet?

Found this ticket but wonder if there’s any other way to achieve the same result? https://youtrack.jetbrains.com/issue/KT-28298

is it possible to have the spots where I have FOLEY_NEW populated via the results of value on the new annotation?

@Target(AnnotationTarget.FUNCTION)
@Retention
@RabbitListener(
    bindings = [QueueBinding(
        key = [Amqp.FOLEY_NEW],
        value = Queue(Amqp.FOLEY_NEW),
        exchange = Exchange(name = "amq.topic", type = ExchangeTypes.TOPIC  )
    )]
)
annotation class Listener( val value: String )

how do you suggest me making a custom IO dispatcher? (there will be a loop on the main thread which updates coroutines every 20 ms)

How expensive is

MutableList::toList

? Is it just basically a toggle or something, or does it have to copy values into a new object? I imagine that perhaps mutable list is a wrapper for list, but i'm not sure

How reliable is comparing Doubles? Should I create a safe compare function with some small wiggle room? like

fun Double.equals(b: Double): Boolean = abs(this - b) < 1e-20

?

Well I opened a issue on GSON. It does not serialize my objects correctly: https://github.com/google/gson/issues/1524

Hi, I was wondering how you test functions that are private to a file? If you make it private you don't have access to it of course but public doesn't make sense since it's only used in that file

Is there a built-in delegate builder to delegate a property to another one?

private class A {
    var x: Int
}
private val a = A()
var x: Int by a.x // Something like that

I usually use Objects to isolate functionality, like

object TextUtils

for instance, instead of just top level functions, as it is creating an instance, it should be using more memory than an old java static function. Do someone know if an object with only functions its a waste of memory when the functions could be top-level?

I wonder is there is anything wrong conceptually with using interface with default methods as opposed to using an abstract class, given that I don't care about constructors and states?

is there a neat way to group by value and respect adjacency? e.g. ["aa", "aa", "a", "aa"].adjacentGroupBy(String::length) should return [["aa", "aa"], ["a"], ["aa"]]

Anyone here have built an iOS App using Kotlin Native, and can tell how was this experience?

Kotlin confuses which Spring method to call:

<T> T getBean(String name, Class<T> requiredType) throws BeansException;
	Object getBean(String name, Object... args) throws BeansException;

I want to call the former, but Kotlin calls the later and then flags my implementation as not guaranteeing the specified type

fun worker(worker: String): PipelineElementProcessor = try {
    context.getBean(worker, PipelineElementProcessor::javaClass)
}

Is there as solution apart from casting the result to PipelineElementProcessor?

I thought that Spring5 was completely annotated with nullibility information but e.g. the methods in BeanFactory like

/** ...
	 * @param name the name of the bean to retrieve
	 * @return an instance of the bean
	 * @throws NoSuchBeanDefinitionException if there is no bean with the specified name
	 * @throws BeansException if the bean could not be obtained
	 */
	Object getBean(String name) throws BeansException;

doesn’t seem to be?! (code from spring-beans-5.1.5.RELEASE)

i can see why it might not exist because it could be conflated with

subList

since they both take two `Int`s as params.

ADT, enums vs sealed classes I am arguing with a collegue about using an

enum

or

sealed

. The scenario is I have implemented an enum and he is asking me to change to sealed, in the first wave of this discussion I was saying that instead of having a thing like:

sealed class Days {
    object Monday: Days(),
    object Tuesday: Days(),...

is better to use just an enum He almost has convinced me when he complains about using

when

because with enum you have one type.. Thinking about ADTs in our application now I think the sealed class is the right way, it does matter all elements are `object`(singletons) in it. What’s your opinion?

why can I override String.toUpperCase() but not String.toString() via an extension function?? I’m not surprised that I get a warning that my toString-extension is shadowed, but why isn’t that the case with toUpperCase? https://pl.kotl.in/Fqwewe9CL

fun main() {
    val result: String = "xY"
    println("${result.toUpperCase()}-${result.toString()}")
}

fun String.toUpperCase() = "overridde_toUpperCase"
fun String.toString() = "overridde_toString"

leads to output

overridde_toUpperCase-xY

Happy Friday all. I'm having trouble with a

operator fun invoke

that takes a

vararg

. Here's my stripped-down sample code, the trouble is with the syntax

{ fn }

in

main

, it says "Too many arguments for public constructor NamesBuilder() defined in NamesBuilder". :

class NamesBuilder {
    private val names:MutableList<String> = ArrayList()
    
    fun build(): List<String> = names.toList()

    operator fun invoke(vararg data: () -> String): NamesBuilder = this.apply { data.forEach { names.add(it()) } }

    companion object Helper {
        operator fun invoke(vararg data: () -> String): List<String> = NamesBuilder()(*data).build()
    }
}

fun main() {
    val fn: () -> String = { "1" }
    println(NamesBuilder {fn}) // does not work -- Too many arguments...
    println(NamesBuilder.invoke(fn)) // works fine, prints [1]
}

As I understand it, the

{ fn }

syntax should invoke the companion operator fun invoke function... and this works fine if I use

.invoke(fn)

. I've tried numerous variations on this theme but no joy. Can someone help me make this work?

can i overload

Double::div

? i'd like for it to return

0.0

when dividing by

0.0

in this scope

I've been writing a comprehensive

Matrix

class. It extends

MutableList<Vector>

(

Vector

extends

MutableList<Double>

). This allows me to add really nice and intuitive operator functions for row operations like

val A = Matrix(5, 5) { i, j -> 1 }
A.row(2) *= 3
A[0] += Vector(0.0, 1.0, 3.0, 4.0, 5.0)
println(A[2]) // < 3.0, 3.0, 3.0, 3.0, 3.0 >

However, column operations aren't going to work the same way because the row and col getters are as so:

fun row(i: Int) = this[i]
fun col(j: Int) = Vector(numRows) { this[it][j] }

so a row operation is performed on the stored Vector from the MutableList, while the col operation is performed on a newly created Vector that wraps the corresponding values. Does anyone have any ideas how I could allow for col operations in the same intuitive way?