if (ocrItem.pattern is DateRegex) {
                        ocrItem.newValue = result.transformToDefaultDate()
                    } else {
                        ocrItem.newValue = result
                    }

sealed class NotificationData(val contactDisplayName: String) {
    class Message(contactDisplayName: String, val contentMessage: String) : NotificationData(contactDisplayName)
    class Join(contactDisplayName: String) : NotificationData(contactDisplayName)
    class File(contactDisplayName: String) : NotificationData(contactDisplayName)
    class Audio(contactDisplayName: String) : NotificationData(contactDisplayName)
}

contactDisplayName

contactDisplayName

open class ParticipantsExtension {
    companion object {
        const val ELEMENT = "participants"
    }

    open fun getElement() = ELEMENT

    fun parse() {
        // common code used with ELEMENT from child
    }
}

class UpdatedParticipantsExtension : ParticipantsExtension() {
    companion object {
        const val ELEMENT = "updated-participants"
    }
    override fun getElement() = ELEMENT
}

class AddedParticipantsExtension : ParticipantsExtension() {
    companion object {
        const val ELEMENT = "added-participants"
    }
    override fun getElement() = ELEMENT
}

ELEMENT

ELEMENT

parse()

companion object {
        fun <T> fromData(data: T): Result<T> {

            return Result(data, null)
        }

        fun <T> fromError(error: Throwable): Result<T> {

            return when (error) {
                is HttpException -> {
                    if (error.code() in 400..499) {

                        if (error.code() == 401) AccountStorage().signOut()

                        mapErrorBody(error, PAErrorModel::class.java)?.let {
                            return Result(null, it)
                        } ?: return Result(null, PAErrorModel("", error.localizedMessage))
                    }

                    return Result(null, PAErrorModel("", error.localizedMessage))
                }
                else -> Result(null, error)
            }
        }
    }

// 1
interface FooFactory {
    fun getFoo(): Foo
}

// 2
interface FooFactory : () -> Foo

// 3
interface FooFactory : () -> Foo {
    override fun invoke(): Foo
}

typealias

var date: LocalDateTime = from
while (date.isBefore(LocalDateTime.now())) {
    getDataFromXXX(date = date)
    date = date.plusHours(1)
}

inputStream.apply { skip(from.toLong()) }.use {
    var bytesLeft = bytesToWrite
    while (bytesLeft != 0) {
        val read = it.read(buffer, 0, Math.min(buffer.size, bytesLeft))
        outputStream.write(buffer, 0, read)
        bytesLeft -= read
    }
}

override fun getOrderInfoList(status: String, chainID: String, debugTag: String): Flowable<Result<List<OrderInfo>>> {
    logger.d(TAG, "Getting order list for status %s", status)
    val fetchFromStorageObservable = storageDataSource.getOrderList(debugTag)
    val observeStorageObservable = storageDataSource.observeOrderList(debugTag)
    // function which fetches from the local storage and takes a throwable that might be re-thrown if there's no data found locally
    val fetchFromStorageOrThrowObservable = fun (t : Throwable) : Observable<Result<List<OrderInfo>>> {
        fetchFromStorageObservable.map {
            if(it.isEmpty()) {
                // re-throw the exception from the Remote source since we got no data from the Local source
                throw t
            }
            it
        }
    }
    val fetchFromRemoteObservable = remoteDataSource.getOrderInfoList(status, chainID).toObservable().onErrorResumeNext { t: Throwable ->
        logger.d(TAG, "order list not received from server")
        // fallback to the local source
        fetchFromStorageOrThrowObservable(t)
    }.flatMap {
        if (it is Result.Success) {
            persisOrderInfoList(it.data)
        }
        fetchFromStorageObservable
    }
    return Observable.concat(fetchFromRemoteObservable, observeStorageObservable).toFlowable(BackpressureStrategy.LATEST)
}

fun String.setCharAt(index: Int, char: Char) = StringBuilder(this)
        .apply {
            setCharAt(index, char)
        }.toString()

data class Foo(val a: String = "hello")

// can I access "hello" somehow, like Foo::class.fields.map { it.defaultValue }

@Target...
annotation class Bar<T>(val value: T)   // nope!

annotation class Bar(val value: Any)   // nope!

private fun getIntent(utterance: String): Intent =
  IntentRunner.processUtterance(utterance)?.let { intent ->
    intent.resolveActivityInfo(packageManager, intent.flags)?.let { activityInfo ->
      if (activityInfo.exported) intent else null
    }
  } ?: Intent(
    Intent.ACTION_VIEW,
    Uri.parse("${BASE_URL}${URLEncoder.encode(utterance, ENCODING)}")
  )

Intent

processUtterance()

resolveActivityInfo()

activityInfo.exported

class DelayUntilReady<T>(private val builder: () -> T) {
    private companion object {
        enum class State { READY, WAIT }
    }

    private val channel: Channel<Unit> = Channel(0)
    private var state: State = State.WAIT

    fun setReady() {
        state = State.READY
        channel.offer(Unit)
    }

    fun setWait() {
        state = State.WAIT
    }

    suspend fun get(): T {
        while (state == State.WAIT) channel.receive()
        return builder.invoke()
    }
}


object Cache {
    private var elements: Map<String, String> = emptyMap()
    private val elementAwait = DelayUntilReady { elements }
    
    @Suppress("FunctionName")
    suspend fun Elements(): Map<String, String> = elementAwait.get()

    fun setupElements(builder: () -> Map<String, String>) {
        elementAwait.setWait()
        // parse
        elements = builder.invoke()

        elementAwait.setReady()
    }
}

Cache

1

class Foo {

	private val logger: Logger by lazy { Logger(getApplicationContext()) } 

	fun aFunctionCalledMultipleTimes() {
		logger.doSomething()
	}
}

2

class Foo {

	fun aFunctionCalledMultipleTimes() {
		val logger = Logger(getApplicationContext())
		logger.doSomething()
	}
}

private fun createSearchIntent(mr: MatcherResult) = 
    mr.slots[THING_KEY]?.let { thing ->
        val suffix = mr.slots[LOCATION_KEY]?.let { "in $it" } ?: ""
            Intent(
                 Intent.ACTION_VIEW,
                 Uri.parse("navigation:q=$thing$suffix")
             )
    }

// 1
data class SomeResult(val typeOne: Bundle? = null, val orTypeTwo: Intent? = null)

if (typeOne == null) 
   doSomething(typeTwo)
else
   doSomething(typeOne!!)

// 2
sealed class SomeResult {
    class TypeOneWrapper(val result: Bundle) : SomeResult

    class TypeTwoWrapper(val result: Intent) : SomeResult
}

when (result) {
  is TypeOneWrapper -> doSomething(result)
  is TypeTwoWrapper -> doSomething(result)
}

sealed class UserInput<out T : Any> {
    data class Value<T : Any>(val output: T) : UserInput<T>()
    object Missing : UserInput<Nothing>()
}

:?

.?

val key = myMap.filterValues { it == "value" }.keys.firstOrNull()

internal fun getString(key: String): String? {
    val (tableName, fieldName) = splitDottedString(key)
    return getString(tableName, fieldName)
}

override fun toString() =
        StringBuilder("MatchResult(\"").apply {
            append(baseString())
            append("\"")
            append(slotString())
            append(if (parameters.isEmpty()) "" else ", parameters: $parameters")
            append(if (skippedWords == 0) "" else ", skippedWords: $skippedWords")
            append(if (aliasedWords == 0) "" else ", aliasedWords: $aliasedWords")
            append(intentName?.let { ", intentName: $it" } ?: "")
            append(", capturedWords: $capturedWords)")
        }.toString()

setOnClickLIstener

DebouncingOnClickListener

View.OnClickListener#onClick(View)

// 1. this doesn't works
fun View.setDebouncingOnClickListener(onSafeClick: (View) -> Unit) {
    setOnClickListener(DebouncingOnClickListener {
        onSafeClick(it)
    })
}

// 2. this works
fun View.setDebouncingOnClickListener(onSafeClick: (View) -> Unit) {
    val listener = DebouncingOnClickListener {
        onSafeClick(it)
    }
    setOnClickListener(listener)
}

fun <T> List<T>.isSameAs(other: List<T>): Boolean {
        if(size != other.size) return false

        forEachIndexed { index, element ->
            if(element !== other[index]) return false
        }

        return true
    }

sealed class Article {
    abstract val title: String
    abstract val body: String
    abstract val updatedAt: Date
    abstract val categories: List<Category>

    data class New(
        override val title: String,
        override val body: String,
        override val updatedAt: Date,
        override val categories: List<Category>
    ) : Article()

    data class Existing(
        override val title: String,
        override val body: String,
        override val updatedAt: Date,
        override val categories: List<Category>,
        val id: UUID
    ) : Article()
}

GET

POST

PUT

DELETE

New

POST

Existing

GET

PUT

DELETE

list.lastOrNull { it is Goods } as? Goods