update( B(firstField = objA.name, secondField = objB.surname) )

update( ::objA )

val objA = A("John", "Walker")

fun update(obj : B) {
    ...
}

data class A (
    val name : String
    val surname : String
)

data class B (
    val firstField : String
    val secondField : String
)

Codewars

build time completed

it

variable?.let { //... }

if (variable != null) { //... }

"creating and linking nodes" example {

"creating and linking nodes"

example

fun main() {
    "creating and linking nodes" example {
        val node1 = Node(value = 1)
        node1.next = node3 // shortened for brevity
        println(node1)
    }
}

java.lang.Object

Map<Class<*>, Any>

Required type: capture of ? extends Object
Provided: Object

TheNewClass:TheParentClass {

var a:Foo

var b:Bar

var c:Baz

}

data class Point<T>(val x:T, val y:T) { }

class BLEConduit(val peripheral:BLEPeripheral):ConnectionConduit {
   var sendBuffer = ubyteArrayOf() 
   var receiveBuffer:UByteArray? = null

myFunc(p1: String, p2: Consumer<*>, p3: String = "") {}
// is not the same as 
myFunc(p1: String, p2: Consumer<*>) { myFunc(p1, p2, "") }
myFunc(p1: String, p2: Consumer<*>, p3: String) {}

/**
* This class does this or that
*

abstract class Task<T : Enum<T>>(
    @field:Id
    @field:Indexed
    open val id: ObjectId?,
    open val group: Group
)

data class Change(
    override val id: ObjectId?,
    override val group: Group
) : Task<Status>(id, group)

enum class Group {
    FIRST,
    SECOND
}

-----


Ambiguous field mapping detected! Both private final ru.whatever.kek.tracker.model.Group ru.whatever.kek.tracker.model.task.Task.group and private final ru.whatever.kek.tracker.model.Group ru.whatever.kek.tracker.model.task.Change.group map to the same field name group! Disambiguate using @Field annotation!

fun parsedElements()

fun getParsedElements()

val parsedElements: List<String> get() = …

!!

contract {
        returns(true) implies (this != null)
    }

    return !this.isNullOrBlank()

var byteArray = this::class.java.classLoader.getResource("abc.jpg").readBytes()

: Any

interface UseCase<in Request : Any, out Response : Any> {
    suspend fun execute(request: Request): Response
}

class UseCaseSpy<Request : Any, Response>(
    private val returnIfNoResponse: (suspend (Request) -> Response)? = null,
    private val allowNullResponse: Boolean = false
): UseCase<Request, Response> {
    var request: Request? = null
    var responseToReturn: Response? = null

    override suspend fun execute(request: Request): Response {
        this.request = request

        val response =  responseToReturn ?: returnIfNoResponse?.invoke(request)

        if (response == null && !allowNullResponse)
            error("Either responseToReturn or returnIfNoResponse needs to be provided.")

        return response
    }
}

execute

Response?

status

message

data

data

member

tournament

{
  "status": true,
  "message": "Success",
  "data": {
    "member": {
      "id": 21,
      "emailAddress": "<mailto:abc@xyz.com|abc@xyz.com>",
      "firstName": "ABC"
    }
  }
}

data class SignInResponse(
    val `data`: Data<Member>
) : BaseResponse()

BaseResponse

open class BaseResponse {
    val status: Boolean  = false
    val message: String  = UNDEFINED
}


@Keep
data class Data<T>(val actualData: T)

actualData

member

tournament

Data

TodoItemInlineEditor(
    item = currentlyEditing,
    onEditItemChange = onEditItemChange,
    onEditDone = onEditDone,
    onRemoveItem = { onRemoveItem(todo) }
)

TodoItemInlineEditor(
    item = currentlyEditing,
    onEditItemChange = {onEditItemChange},           ............................difference 1 writing inside {}
    onEditDone = {onEditDone},                       ............................difference 2 writing inside {}
    onRemoveItem = { onRemoveItem(todo) }
)

@Composable
fun TodoScreen(
    items: List<TodoItem>,
    currentlyEditing: TodoItem?,
    onAddItem: (TodoItem) -> Unit,
    onRemoveItem: (TodoItem) -> Unit,
    onStartEdit: (TodoItem) -> Unit,
    onEditItemChange: (TodoItem) -> Unit,
    onEditDone: () -> Unit
) {
.....
.....
TodoItemInlineEditor(
    item = currentlyEditing,
    onEditItemChange = onEditItemChange,
    onEditDone = onEditDone,
    onRemoveItem = { onRemoveItem(todo) }
)
....
....
}

synchronized

return Builder.builder().withIntParam(intParam).let {
     if (booleanFlag) {
           it.withBoolean()
     } else {
           it
     }
}.build()

return ....apply {
   if (booleanFlag) { withBoolean() }
}