@Suppress("NOTHING_TO_INLINE")
inline infix fun Int.hasBits(bits: Int): Boolean = (this and bits) != 0

object Jackson : ObjectMapper() {
     init {
         enable(SerializationFeature.INDENT_OUTPUT)
         ....
         }
}

inline fun <reified T> Any._as() = this as T

private val converters = mapOf<Class<*>, (String) -> Any>(
        Int::class.java to { s -> s.toInt() },
        Integer::class.java to { s -> s.toInt() },
        Double::class.java to { s -> s.toDouble() },
        Long::class.java to { s -> s.toLong() },
        Date::class.java to { s -> Date(s) }
)

fun <T> getAs(clazz: Class<T>, converter: ((String) -> T)? = null): T {
    val c = converter ?: converters[clazz] ?: throw IllegalArgumentException("Can't auto-cast to $clazz. Add a converter as a second argument.")
    return try {
        c.invoke(value)
    } catch (e: Exception) {
        ...
    } as T
}

class CustomApplication: Application() {

    companion object {
        private var INSTANCE: CustomApplication? = null

        @JvmStatic
        fun get(): CustomApplication = INSTANCE!!
    }

    override fun onCreate() {
        super.onCreate()
        INSTANCE = this
    }
}

class CustomApplication : Application() {

    companion object {
        lateinit var instance: CustomApplication
            private set
    }

    override fun onCreate() {
        super.onCreate()
        instance = this
    }
}

Validator

TypedValidator

asInt

asDouble

dialog = with( AlertDialog.Builder( this ) ) {
        setTitle( "foo" )
        setMessage( "bar" )
        setCancelable(true)
        create()
    }.also {
        it.show()
    }

    or

    dialog = AlertDialog.Builder( this ).run {
        setTitle( "foo" )
        setMessage( "bar" )
        setCancelable(true)
        create()
    }.also {
        it.show()
    }

.run()

class MyActor {

  suspend fun run() {
    while(true) {
      select<Unit> {
        one.onReceive { ... }
        two.onReceive { ... }
      }
    }
  } 

}

class MyActor(private val one: ReceiveChannel<Query>, private val two: ReceiveChannel<Command>)

class MyActor {
  private val _one = Channel<Query>()

  val one: SendChannel<Query>
    get() = _one
}

suspend fun query(query: Query) {
    one.send(query)
  }

data class Record(val first: String, val second: String, val third: String)

val input = listOf(
        Record("a", "aa", "aaa"),
        Record("a", "aa", "aab"),
        Record("a", "ab", "aba"),
        Record("b", "ba", "baa"),
        Record("b", "ba", "bab"),
        Record("b", "bb", "bba"),
        Record("b", "bb", "bbb")
)

val expected = mapOf(
        "a" to mapOf(
                "aa" to listOf("aaa", "aab"),
                "ab" to listOf("aba")
        ),
        "b" to mapOf(
                "ba" to listOf("baa", "bab"),
                "bb" to listOf("bba", "bbb")
        )
)

input.groupBy({ it.first })
        .mapValues {
            it.value.groupBy({ it.second }, { it.third })
        }

when (targetHandler) {
    is HandlerCollection -> targetHandler.apply { addHandler(defaultHandlers) }
    is HandlerWrapper -> targetHandler.apply { handler = defaultHandlers}
}

(targetHandler as? HandlerCollection)?.apply { addHandler(defaultHandlers) }
(targetHandler as? HandlerWrapper)?.apply { handler = defaultHandlers }

val newFragment: Fragment? = if (fragment is CarSearchFragment? && fragment == null) {
            CarSearchFragment()
        } else if (fragment is CarValuationFragment? && fragment == null) {
            CarValuationFragment()
        } else if (fragment is HotDealsFragment? && fragment == null) {
            HotDealsFragment()
        } else if (fragment is FavoritesFragment? && fragment == null) {
            FavoritesFragment()
        } else {
            fragment
        }

if an entry isn’t in the base map, it won’t exist in the final one

mapOverride

mapOverride

fun <T, B> distinct(body: (T) -> B): (T) -> B {
  val lastInput = AtomicReference<T>()
  val lastReturn = AtomicReference<B>()
  return {
    if (lastInput.get() != it) {
      lastInput.set(it)
      lastReturn.set(body(it))
    }
    lastReturn.get()
  }
}

when state == Activated
   when action == MuteMic
      state = ActivatedMuteMicPending
      effect(Effect.DoMuteMic)
      state = Activated

sealed class State {
   object Activated,
   object ActivatedMuteMicPending
}

val updatedDataElementsOne = removeExtraElements(info)
val updatedDataElementsTwo = updateExistingElements(updatedDataElementsOne)
return populateEmptyElements(updatedDataElementsTwo)

object TwoLikelyVariablesMatcher : CondensingMatcher {
    override fun matches(operands: Terms): Boolean {
        operands.filterIsInstance<AnyVariable>()
                .groupBy { it.unsignedName }
                .forEach { (_, variablesWithSameName) ->
                    if(variablesWithSameName.size > 1) return true
                }

        return false
    }

    override fun matches(source: Terms, target: Terms): Boolean {
        TODO("not implemented")
    }
}

@Test
    fun `A two likely variables matcher matches with operands containing exactly two likely variables`() {
        // GIVEN
        val operands = termsOf(
                PositiveVariable("x"),
                mock(),
                PositiveVariable("y"),
                mock(),
                NegativeVariable("x"))

        // THEN
        assertTrue(TwoLikelyVariablesMatcher.matches(operands))
    }

    @Test
    fun `A two likely variables matcher doesn't match with operands containing zero likely variables`() {
        // GIVEN
        val operands = termsOf(
                PositiveVariable("x"),
                PositiveVariable("y"),
                PositiveVariable("z"))

        // THEN
        assertFalse(TwoLikelyVariablesMatcher.matches(operands))
    }

x

y

completedAlert?.let { updatedAlerts += it }
// or
if (completedAlert != null) updatedAlerts += completedAlert

CompletableFuture

asyncDumpReport()

dumpReport()

dumpReport()

`
    /**
     * calls [dumpReport] asynchronously, _if there is not currently such a call in progress_
     */
    private fun asyncDumpReport() {
        val p = promise
        if (p == null || p.getNow(false))
            promise = CompletableFuture.supplyAsync {
                try {
                    dumpReport()
                } finally {}
                true
            }
    }
    private var promise: CompletableFuture<Boolean>? = null
`

listOf(
  CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO>).launch { ddbTools.deleteTableInRegions(destinationTable, destinationRegions) },
  CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO>).launch { jobService.deleteJobTable() },
  CoroutineScope(<http://Dispatchers.IO|Dispatchers.IO>).launch { jobService.deleteCheckpointTable() }).joinAll()