Any recommended Pluralsight courses for advance Kotlin ?

For SpringBoot Kotlin, any recommended frontend and database?

What's the easiest way to format a class to JSON to use with a REST request?

I have two entities with the same properties (one is basically a DTO) an I want to create the DTO from the Entity. Something comparable to:

class EmployeeModel(val id: Long, val firstName: String, val lastName: String)
class Employee(val id: Long, val firstName: String, val lastName: String)

is there a more idiomatic way of creating one object from the other than:

EmployeeModel(employee.id, employee.firstName, employee.lastName)

Thank you!

I'm getting this error on play.kotlinlang.org:

Exception in thread "main" java.security.AccessControlException: Access control exception due to security reasons in web playground: 
  access denied ("java.util.PropertyPermission" "kotlin.ignore.old.metadata" "read")
    at executors.JavaRunnerExecutor.main (JavaRunnerExecutor.kt:-1)

Hi guys, I am trying to use R2DBC but am getting a “java.lang.IllegalArgumentException: Cannot decode value of type boolean” when trying to serialize the results in a RowMapper

private val myRowMapper = BiFunction<Row, RowMetadata, Person> { row, _ ->
            Person(
                row["Id", Integer::class.java]!!.toInt(), row["NAME", String::class.java]!!,
                row["StudentId", Integer::class.java]!!.toInt(),
                row["GroupId", Integer::class.java]?.toInt(), row["startDate", Instant::class.java]!!,
                row["endDate", Instant::class.java], row["authId", Integer::class.java]!!.toInt(),
                row["statusId", Integer::class.java]?.toInt(),
                row["IS_TEST", Boolean::class.java]!!,
                row["DELETED", Boolean::class.java]
            )
        }

databaseClient.execute(myQuery).bind("Id" to "12345").map(myRowMapper).flow().toList()

data class Person(
val id: Int,
val name: String,
val studentId: Int,
val groupId: Int?,
startDate: Instant,
endDate: Instant?,
authId: Int,
statusId: Int,
isTest: Boolean,
deleted: Boolean?)

Am I doing this correctly. It seems like I have to do an awful lot of conversions just to get a simple data type like Int / Boolean

file2:

import com.file2
fun main() { file2.test() }

Is this the right way to convert float to string in kotlin?

8938.3f.toString()

Hi, I’m gathering arguments to convince my team (java 11, Spring boot) to switch to Kotlin. In the codebase, we are using wrapper classes to specify primitives (eg:

class UserId { String userId; }

), this is a perfect usecase for Inline classes ! In the documentation, it’s noted that

primitive types are usually heavily optimized by the runtime, while their wrappers don't get any special treatment.

Do you have any concrete examples of the kind of optimizations you lose when using wrapper class instead of the primitive type (or the Inline class in KT) ?

is allowed to ask if someone is interested in a Kotlin job as android developer?

https://pl.kotl.in/lkskQc2rY is there anything the compiler could do to make this work?

enum class Foo {
    ONE, TWO
}

fun fooArray(foos: Array<Foo>) {
    println(foos.toList())
}

fun fooVararg(vararg foos: Foo) {
    fooArray(foos) // Type mismatch: inferred type is Array<out Foo> but Array<Foo> was expected
}

in case of final classes (including enums), it's weird that

vararg

should make the

Array

have

out

variance I'm wondering if there's any sense in filing a youtrack issue

I have a situation where I'd like to somehow constrain two generic type parameters where one is the non-null type of the other. Here's a simple example:

class Transformer<T, D>(private val seq: Sequence<T>, private val lambda: (T) -> D) {
    fun process(): Sequence<D> = seq.mapNotNull { lambda(it) }
}

An example usage would be:

val mySeq = Transformer(sequenceOf("abc"), String::toUpperCase)

However, what if we change the API of the Transformer class to allow the incoming sequence to contain null values but, since these are already filtered out in the

process

function before we call the lambda, we want the lambda parameter to only have to deal with not null T values? Concretely, I'd like this to work:

val mySeq = Transformer(sequenceOf("abc", null), String::toUpperCase)

This doesn't compile because T is a nullable String. Is there any way that two generic parameters can be tied like that or some way of specifying that the parameter of the lambda is not null?

what’s the best way to pass a Map<String, Any> by value?

I have a little problem. I created a retriable function, but when I try to call it I always get an error:

Suspension functions can be called only within coroutine body

I couldn't find it, so maybe it doesn't exist, but can I make a generic constraint where something MAYBE extends certain interfaces?

interface Code{
    private val code: String
}

interface Keyable{
    private val key: String
}

fun <T> getThing(obj: T) : Pair<String, String?> where T : Code, T maybe Keyable{
    return obj.code to obj.key //implied that since we're not sure that Keyable is implemented, the field becomes nullable
}

Hi everyone! How do I make

java.text.SimpleDateFormat

 fail if the date string doesn't match exactly? Tried setting

isLenient

to false but it didn't work. Specifically I want that if the format is "yyyy-MM-dd", e.g. "2019-08-05T235959+0200" is NOT parsed. it should only parse if the date string is "2019-08-05"

val str = "2019-08-05T23:59:59+0200"
val format = SimpleDateFormat("yyyy-MM-dd")
format.isLenient = false
format.parse(str) // should return null or crash

Does anyone know this or do I have to check using javap: if I re-set the value of a String thus:

author = someNullableFunction() ?: author

, will the compiler be smart enough to turn the statement into a null check, thus avoiding re-setting a value that is not really changing in situations where the function returns null?

for example in python, it is possible to do stuff like

my_function(*myType)

, and even know kotlin has a spread operator as well it seems to only work on collections and can't be used for stuff like Pair<A, B>

In Android, since Oreo+, Member and Constructor inherit from a new Class:

java.lang.Executable

. So this small code here in Kotlin

// val resolvedClass: Class<*>
// val resolved = mutableMapOf<MemberDec, Member>()
// MemberDec is a sealed class with MethodDec and ConstructorDec as subclasses containing name and parametertypes

resolved[member] = when (member) {
    is MethodDec -> member.findMethod(resolvedClass) // returns Method
    is ConstructorDec -> member.findConstructor(resolvedClass) // returns Constructor<*>
}

This fails because of Kotlin smart casts using a common superclass

java.lang.Executable

that does not exist on all devices.

java.lang.NoClassDefFoundError: Failed resolution of: Ljava/lang/reflect/Executable;
        at com.jaqxues.akrolyb.genhook.FeatureHelper$Companion.resolveMembers(FeatureHelper.kt:164)

I don't know if this is worth a BugReport on BugTracker, just wanted to let you know. The code is shared on Github: https://github.com/jaqxues/Akrolyb/blob/316b4b761c6e9b664141b68b951152b1bd805c89/akrolyb/src/main/java/com/jaqxues/akrolyb/genhook/FeatureHelper.kt#L163 Workaround:

// fixme Explicit "Useless" Cast to Member. Kotlin will otherwise cast to Executable, which is only available in Oreo+
@Suppress("USELESS_CAST")
resolved[member] = when (member) {
    is MethodDec -> member.findMethod(resolvedClass) as Member
    is ConstructorDec -> member.findConstructor(resolvedClass) as Member
}

is it possible to use extension functions in

when

statements?

when(myObject) {
  myCustomExtensionFunctionOnMyObject -> do something
}

Hey! 😄 Does Kotlin automatically use referential equality for Enum types?

Could someone please tell me why I get a

Type mismatch

error in this code?

private fun applyIfPossible(contacts: List<ContactEntity>): Unit {
    contacts.firstOrNull() ?.run { contact ->
        println(contact)
    }
}

of two types*

context: I'm trying to make a function more generic so it takes two types of message, here's code which might make it more clear:

not sure if bug or I'm missing something I am getting warnings on this code

result.andExpect(status().isOk)
    .andReturn()
    .response!! // Problematic line
    .contentAsClass<SomeType>()

inline fun <reified T> MockHttpServletResponse.contentAsClass(): T? =
    TestUtil.convertJsonBytesToObject(this.contentAsString, T::class.java) // This returns T

with

!!

Unnecessary non-null assertion (!!) on a non-null receiver of type MockHttpServletResponse!

without

!!

Call of inline function with nullable extension receiver can provoke NPE in Kotlin 1.2+

method

org.springframework.test.web.servlet.MvcResult.getResponse()

has this docs/signature

/**
 * Return the resulting response.
 * @return the response, never {@code null}
 */
MockHttpServletResponse getResponse();

I'm using current Kotlin & plugin - 1.3.71 any ideas or should I open issue?

Is it possible to create commutative generics, such that Foo<A, B> is the same as Foo<B, A>?

ref this discussion about kotlin smart casts https://discuss.kotlinlang.org/t/what-is-the-reason-behind-smart-cast-being-impossible-to-perform-when-referenced-class-is-in-another-module/2201 when the class in a different module (i.e. artefact that can evolve independently) I agree with the language designers. But it seems like kotlin believes that my tests and my "real" code are in different modules. Is this intentional somehow, or is it a bug?

Hi everyone, I'm writing 2 classes to represent long running operation state. This works but I wonder if there's a way to improve it (e.g. by making both share an interface)?

sealed class VoidOperationState {
    object Progress: VoidOperationState()
    object Success: VoidOperationState()
    data class Failure(val t: Throwable): VoidOperationState()
}

sealed class OperationState<out T> {
    object Progress: OperationState<Nothing>()
    data class Success<out T>(val data: T): OperationState<T>()
    data class Failure(val t: Throwable): OperationState<Nothing>()
}

(Of course I could make

VoidOperationState

just an

OperationState<Unit>

but that's not nice, since I'd have to be always passing the

Unit

to

Success

...

Why can’t

this

be passed to an interface delegate when initializing the delegate?

data class Foo(
    val name: String
): FooExt by FooExtImpl(this)

interface FooExt {
    fun nameExt(): String
}

class FooExtImpl(private val outer: Foo): FooExt {
    override fun nameExt() = "Hello, ${outer.name}"
}

I basically need this exact functionality, I’m not able to directly add

nameExt

to the data class. If delegates could be initialized inside an

init { }

block then that would work but I’m unsure of any actual workarounds for this.

I’d like to be able to refer to an object from within itself, like this:

val r: Runnable = Runnable {
        println("In runnable")
        r.run()
    }

(I know the code would generate a stack overflow; it’s an oversimplification of what I really want to do.) How can I do this? Changing

r

from

val

to

var

has no effect. Do I need to create a second variable and make it refer to the first value?

lateinit var r2: Runnable

    var r: Runnable = Runnable {
        println("In runnable")
        r2.run()
    }
    
    init {
        r2 = r
    }