fun String.()

mapOf<String, String.() -> Unit>(
            "One" to fun String.(){ println(this) }
        )

Type inference failed. Expected type mismatch: inferred type is Pair<String, () -> Unit> but Pair<String, String.() -> Unit> was expected

fun String.()

/**
 * Returns a new list of size [capacity] with elements from the original list, filled with [element] if needed
 */
fun <E> List<E>.fillWith(capacity: Int, element: E?): List<E?> {
    val outList = mutableListOf<E?>()
    repeat(capacity){ outList.add(element) }

    if(this.isEmpty()) return outList

    val sl = this.subList(0, min(capacity, this.size))

    sl.forEachIndexed { index, e ->
        outList[index] = e
    }
    return outList
}

private fun findTheField(fields: List<Field>): Field? {
	if (fields.isEmpty()) {
		return null
	}
	if (fields.size == 1) {
		return fields.first()
	}
	val selectedFields = fields.filter(::someCondition)
	if (selectedFields.size == 1) {
		return selectedFields[0]
	} else {
		throw IllegalArgumentException(
			"Too many fields matching some condition found: ${fields.joinToString(", ")}"
		)
	}
}

ReturnCount

override fun getItemViewType(position: Int): Int {

        return if (hasHeader) {
            if (position == 0) HEADER
            else entryItem(position)
        } else if (position == 0) ITEM_WITH_DATE else entryItem(position + 1)
    }

NetworkInfo#isConnectedOrConnecting

ConnectivityManager.CONNECTIVITY_ACTION

/**
 * Observes network connectivity by consulting the [ConnectivityManager].
 * Observing can run infinitely or automatically be stopped after the first response is received.
 */
class ConnectivityObserver @JvmOverloads constructor(

        val context: Context,
        val onConnectionAvailable: () -> Unit,
        val onConnectionLost: () -> Unit = {},
        val shouldStopAfterFirstResponse: Boolean = false

) {

    private val connectivityManager
        get() = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager

    @Suppress("DEPRECATION")
    private val intentFilter = IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)

    private val broadCastReceiver = object : BroadcastReceiver() {

        @Suppress("DEPRECATION")
        override fun onReceive(context: Context?, intent: Intent?) {
            if (ConnectivityManager.CONNECTIVITY_ACTION != intent?.action) {
                return
            }
            val networkInfo = connectivityManager.activeNetworkInfo
            if (networkInfo != null && networkInfo.isConnectedOrConnecting) {
                onConnectionAvailable.invoke()
            } else {
                onConnectionLost.invoke()
            }
            if (shouldStopAfterFirstResponse) {
                stop()
            }
        }

    }

    private lateinit var networkCallback: ConnectivityManager.NetworkCallback

    init {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            networkCallback = object : ConnectivityManager.NetworkCallback() {

                override fun onAvailable(network: Network) {
                    super.onAvailable(network)
                    onConnectionAvailable.invoke()
                    if (shouldStopAfterFirstResponse) {
                        stop()
                    }
                }

                override fun onLost(network: Network?) {
                    super.onLost(network)
                    onConnectionLost.invoke()
                    if (shouldStopAfterFirstResponse) {
                        stop()
                    }
                }
            }
        }
    }

    fun start() {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
            // Decouple from component lifecycle, use application context.
            // See: <https://developer.android.com/reference/android/content/Context.html#getApplicationContext()>
            context.applicationContext.registerReceiver(broadCastReceiver, intentFilter)
        } else {
            connectivityManager.registerDefaultNetworkCallback(networkCallback)
        }
    }

    fun stop() {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
            context.applicationContext.unregisterReceiver(broadCastReceiver)
        } else {
            connectivityManager.unregisterNetworkCallback(networkCallback)
        }
    }

}

val onConnectionAvailable = TODO()
val connectivityObserver = ConnectivityObserver(context, onConnectionAvailable)
connectivityObserver.start()
connectivityObserver.stop()

val onConnectionAvailable = TODO()
val onConnectionLost = TODO()
ConnectivityObserver(context, 
    onConnectionAvailable, 
    onConnectionLost, 
    shouldStopAfterFirstResponse = true
).start()

@Before

@Before

lateinit

suspend fun awaitSubmissionOfPhoneNumberInput(): String

suspend fun awaitPhoneNumberInputSubmission(): String

source

destination

DataA return ResultA

DataB return ResultB

typealias ListMovieEntity = List<MovieEntity>
typealias ListMovieResponse = List<MovieResponse>

class MovieEntityMapper {

    companion object {
        fun <S : Any, D : Any> from(movies: ListMovie<S>): List<D> = movies.map {
            with(it) {
                when (this) {
                    is MovieEntity -> Movie(id)

                    is MovieResponse -> MovieEntity(id)

                    else -> TODO()
                } as D
            }
        }
    }
}

fun fun1(list: List<A>)
fun fun2(list: List<B>)

// this two function will clashes each other.

var validated = true

        if (validated)
            validated = initProgram()
        if (validated)
            validated = initBuffer()

        return validated

Result

public static ScoreDto score(String email, String name, String surname, Function<String, Boolean> function)

dataProvider

score(
        "<mailto:some_email@domain.com|some_email@domain.com>",
        "John",
        "Doe"
    ) { dataProvider?.apply(it) }

score(
        "<mailto:some_email@domain.com|some_email@domain.com>",
        "John",
        "Doe",
        { dataProvider?.apply(it) }
     )

dataProvider?.let {
    score(
       "<mailto:some_email@domain.com|some_email@domain.com>"
        "John",
        "Doe",
        it
    )
}

someLetter

··A··
·B·B·
C···C
·B·B·
··A··

fun <R> Observable<R>.checkInternetConnection(): Observable<R> {

return if (NetworkUtils.isConnected) this else Observable.error(NoInternetException)

}

fun <R> Observable<R>.mapErrors(): Observable<R> {

return this.onErrorResumeNext { t: Throwable ->

val error = when (t) {

is UnknownHostException -> NoInternetException

else -> t

}

Observable.error(error)

}

}

findViewById<Button>(R.id.test).setOnClickListener(View.OnClickListener {
    if (progressBar.visibility == View.VISIBLE) {
        showProgressBar(false)
    } else {
        showProgressBar(true)
    }
})

fun showProgressBar(visibility: Boolean) {
    progressBar.visibility = if (visibility) {
        View.INVISIBLE
    } else {
        View.VISIBLE
    }
}

val Array<Coordinate>.centroid
    get() = fold(mutableMapOf<Double, Double>()) { acc, coord -> acc.also { it[coord.x] = coord.y } }.run {
        Coordinate(keys.average(), values.average())
    }

private fun changeListener(obj: Any) {
    fun getObjectString(): String {
        val baos = ByteArrayOutputStream()
        ObjectOutputStream(baos).also { it.writeObject(obj) }.also { it.close() }
        return baos.toString()
    }

    var oldValue = getObjectString()
    Thread {
        while (true) {
            val newValue = getObjectString()
            if (oldValue != newValue) {
                println("Change detected")
                oldValue = newValue
            }
            Thread.sleep(250)
        }
    }.start()
}

val elementChanges = listOf("a", "b", "b").zipWithNext { a, b ->
            if(b != a) 1 else 0
        }.sum()

editText.length() in 2 until maxEditLength

@GetMapping(value = ["download-all"], produces = ["application/zip"])
    fun downloadAll(): ByteArray {
        val outputStream = ByteArrayOutputStream(1024)
        val bufferedOutputStream = BufferedOutputStream(outputStream)
        val zipOutputStream = ZipOutputStream(bufferedOutputStream)

        val docIds = docService.getDocIds()

        runBlocking {
            val docStream = docIds
                .map { GlobalScope.async { docService.getDoc(it) } }
                .map { ByteArrayInputStream(it.await()) }
                .map { BufferedInputStream(it) }

            docStream.forEachIndexed { index, bufferedInputStream ->
                val zipEntry = ZipEntry("test${index}.pdf")
                zipOutputStream.putNextEntry(zipEntry)
                bufferedInputStream.copyTo(zipOutputStream, 1024)
                bufferedInputStream.close()
                zipOutputStream.closeEntry()
            }
            zipOutputStream.close()
        }

        return outputStream.toByteArray()
    }

fun String.Companion.joinIfNotNullOrBlank(vararg params: String?, separator: String = ", "): String =
    params.filter { !it.isNullOrBlank() }.joinToString(separator)

val carMst: List<(Mutable)Map<String!, Any!>!>!
val carUserIds: List<(Mutable)Map<String!, Any!>!>!
....
....
val result = ArrayList<Car>()
for (mst in carMst) {
    val userIds = ArrayList<Int>()
    for (uids in carUserIds) {
        if (mst["car_id"] == uids["car_id"]) {
            userIds.add(uids["user_id"] as Int)
        }
    }
    val car = Car(
        mst["car_id"] as Int,
        mst["model"] as String,
        userIds
    )
    result.add(car)
}

Type mismatch: inferred type is (Mutable)List<Task!>? but MutableList<Task> was expected

List<Task> getTasksReport(@NonNull String filter);

override fun getTasksReport(filter: String): MutableList<Task> {
        val response = todoistRestClient.getTasks(TODAY_FILTER)
        val tasks = response.body
        println(tasks)
        return tasks
    }

override fun getTasksReport(filter: String): MutableList<Task> {
        val response = todoistRestClient.getTasks(TODAY_FILTER)
        val tasks = response.body
        println(tasks)
        return tasks as MutableList<Task>
    }