val nonOptional = optional ?: Log.e("foo", "optional is not set").also { return }

val imageSource = suspendCoroutine<ImageSource> { cont ->
        MaterialDialog(context).show {
          listItems(
            items = ImageSource.values().map { getString(it.nameRes) },
            selection = { _, i, _ ->
              val imageSource = ImageSource.values()[i]
              cont.resume(imageSource)
            }
          )
        }
      }
      val uri = when (imageSource) {
        ImageSource.GALLERY -> {
          module<SelectPictureFromGalleryModule>().take()
        }
        ImageSource.TAKE_PICTURE -> null
      }

val uri = when (suspendCoroutine<ImageSource> { cont ->
        MaterialDialog(context).show {
          listItems(
            items = ImageSource.values().map { getString(it.nameRes) },
            selection = { _, i, _ ->
              val imageSource = ImageSource.values()[i]
              cont.resume(imageSource)
            }
          )
        }
      }) {
        ImageSource.GALLERY -> {
          module<SelectPictureFromGalleryModule>().take()
        }
        ImageSource.TAKE_PICTURE -> null
      }

JUNIT

CANVAS

Object

@NonNull
    public final String getString(@StringRes int resId, Object... formatArgs) {
        return getResources().getString(resId, formatArgs);
    }

getString

kotlin.Any!

vararg Any

IllegalFormatExceptions

BroadcastChannel#asFlow

consumeEach

enum class EnumA {
    A, B;
    val group = EnumB.values().find { this == it.enumA }
}

enum class EnumB(val enumA: EnumA) {
    A1(EnumA.A),
    B1(EnumA.B),
}

EnumB.values().map { it.enumA } // => [null, null]
EnumA.A.group  // == null
EnumB.values().find { EnumA.A == it.enumA }

null

enum class EnumA(val enumB: EnumB) { A(EnumB.B) }
enum class EnumB(val enumA: EnumA) { B(EnumA.A) }
EnumB.values().map { it.enumA }

[A]

inline fun method(lambda: () -> Unit) // Java needs at the end `return Unit.INSTANCE;`
void method(Runnable lambda) // Kotlin needs to wrap it into `Runnable { }` and you dont have inline

sealed class Bird
class Chicken: Bird()
class Turkey: Bird()

class Egg<T: Bird>

fun <T: Bird> T.layEgg(): Egg<T>

fun <T: Bird> T.layEgg(): Egg<T> {
  return when(this as Bird) {
    is Chicken -> Egg<Chicken>()
    is Turkey -> Egg<Turkey>()
  } as Egg<T>
}

fun main() {
  val egg: Egg<Chicken> = Chicken().layEgg()
}

as Bird

as Egg<T>

inline class Calories(val value : Double)

Calories

operator fun plus

!!

while

const com = {
  to:"guru",
  address: {
    add1: "DC",
    add2: "LA"
  },
  phoneno: 767646
}

const fu = ({address:{add1}, phoneno})=>
{
  console.log(JSON.stringify(add1));
}

fu(com)

value

fold

inline

objects