implementation(files(./dependency))

repeat(10) {
    foo()
    delay(500) //problem: causes trailing delay
}

foo()
repeat(10) {
    delay(500)
    foo()
}

data class Action(
    val actionGuid: String,
    val actionType: String,
    val allowClose: Boolean,
    val body: String,
    val deepLink: String,
    val deepLinkId: String,
    val deepLinkSubId: String,
    val deepLinkText: String,
    val fuxiActionVersion: Int,
    val imageUrl: String,
    val isAutoClose: Boolean,
    val isDeleteFromCache: Boolean,
    val isHidden: Boolean,
    val isShowClose: Boolean,
    val pageId: String,
    val questions: List<Any>,
    val submitText: String,
    val submitUrl: String,
    val surveyId: String,
    val theme: String,
    val title: String,
    val validFromUtc: String,
    val validToUtc: String
)

@kotlinx.parcelize.Parcelize
data class FuxiNotification(
    val actionGuid: String,
    val actionType: String,
    val allowClose: Boolean,
    val body: String,
    val deepLink: String,
    val deepLinkId: String,
    val deepLinkSubId: String,
    val deepLinkText: String,
    val fuxiActionVersion: Int,
    val imageUrl: String,
    val isAutoClose: Boolean,
    val isDeleteFromCache: Boolean,
    val isHidden: Boolean,
    val isShowClose: Boolean,
    val pageId: String,
    val theme: String,
    val title: String,
    val validFromUtc: String,
    val validToUtc: String
) : Parcelable

// java
var words = List.of("one", "two", "three");
Function<Integer, Predicate<String>> lengthFun = (minLength) -> (str) -> str.length() > minLength;
Predicate<String> isLongerThan2 = lengthFun.apply(2);
Predicate<String> isLongerThan3 = lengthFun.apply(3);

var longerThan2 = words.stream().filter(isLongerThan2).collect(Collectors.toList());
var longerThan3 = words.stream().filter(isLongerThan3).collect(Collectors.toList());

filter { }

abstract class SomeLibraryClass<T> {
    abstract fun test(key: String): T
}

class Item<T : Enum<T>> : SomeLibraryClass<T>() {
    override fun test(key: String): T {
        return enumValueOf(key)
    }
}

reified

test

val bankAccount: BankAccount? = null

bankAccount.toString()

@Seriazlizable

@Serializable
class Document(
    name: String,
) {
    var name: String = name
        private set
}

val courses: Collection<Course> = gson.fromJson(response.string(), Collection<Course>::class.java)

Collection<Course>::class.java

val value = if (someCondition) {
  // compute value
} else {
  null
}

null

[Item(int=1, item=Category1, ItemList={Name=[]})]

null

data class Item(
    	var int: Int,
        var item: String,
        var ItemList: Map<String, List<Item>>
    )
    var defaultcategory = listOf(
        Item(1, "Category1", mapOf("Name" to listOf<Item>()))
    )
    var defaultItems = listOf(
        Item(1, "Item1",mapOf("Name1" to defaultcategory)),
        Item(2, "Item2",mapOf("Name2" to defaultcategory))
    )
    
    defaultItems.forEachIndexed { index, element ->
    	print(element.ItemList["Name1"])
        print("\n")
    }

String.replace(String, String)

if (String.contains(String))

4

13

fun add(a: Int, b: Int, cumulate: (Int) -> Unit): Int {
    cumulate(a + b)
    return a
}

fun main() {
    var answer = 0
    answer += add(4, 5) { answer += it }
    println(answer)
}

answer += x

answer = answer + x

W

class DirectedEdgeWeighted<W> private constructor (val de: DirectedEdge, val w: W, val wAccretion: (W, W) -> W): DirEd by de where W: Any, W: Comparable<W> { ... }

data class

DirectedEdgeWeighted

DirEd

DirectedEdge

W: Any

Unresolved reference

activity_main.xml

<com.test_project.library.buttons.TestButton/>

android:text

activity_main.xml

class Something(val name: String) {
    companion object {
        fun toDto(): Dto(name)
    }
}

data class Dto(val name: String)

Dto.from(foo: Something) = Dto(name = foo.name)

val buffer = ByteBuffer.allocate(4450)

val buffer: (ByteBuffer..ByteBuffer?)

This declaration overrides deprecated member but not marked as deprecated itself. This deprecation won't be inherited in future releases. Please add @Deprecated annotation or suppress

@Json(name = "order_id") val orderId: Int,
@Json(name = "new_delivery_window_id") val newDeliveryWindowId: Int?,
@Json(name = "new_delivery_window_uuid") val newDeliveryWindowUUID: UUID?,
@Json(name = "new_delivery_address_id") val newDeliveryAddressId: Int?,
@Json(name = "otc_items") val otcItems: List<CartOTCItem>?,
@Json(name = "fills") val fills: List<PrescriptionFulfillment>?,
@Json(name = "promo_items") val promoItems: List<PromoItem>?,
@Json(name = "reason") val reason: String?,
@Json(name = "note") val note: String?,
@Json(name = "subtotal") val subtotal: Int?

{
  "order_id": 980,
  "new_delivery_window_id": 14,
  "new_delivery_window_uuid": "8d",
  "new_delivery_address_id": 136,
  "note": "testing note",
  "subtotal": 1000,
  "reason": "testing reason"
}

com.squareup.moshi.JsonDataException: Expected an int but was NULL at path $.createdBy

createdBy

toMetadata

buildMetadata

interface Meta {
    fun buildMetadata(): List<String>
}

interface FeatA : Meta {
   override fun buildMetadata(): List<String> = listOf("A")
}

interface FeatB : Meta {
   override fun buildMetadata(): List<String> = listOf("B")
}

class ObjC: FeatA, FeatB {
    override fun buildMetadata(): List<String> = emptyList()
    fun toMetadata(): List<String> // //What to do here to combine all lists (metadata) from interfaces?
}

fun main() {
    val c = ObjC()
    println(c.toMetadata()) // expecting ["A", "B"]
}

<http://com.my|com.my>.package.MyClass