import kotlin.also as alsoFromKotlin
infix fun <T> T.also(block: (T) -> Unit): T = alsoFromKotlin(block)

kotlin.also(this, block)

else if

class Test<T: C1> {
  fun getTypeName(): String {
     // Return what is T 
  }
}

fun main(args: Array<String>) {
  val t = Test<String>
  println(t.getTypeName()) // Returns String
}

when

in

when (collection-of-strings) {
  has "string 1" -> handleString1()
  has "string 2" -> handleString2()
  has "string 3" -> handleString3()
  else -> throw Exception()
}

private void prepareLog(int priority, Throwable t, String message, Object... args) {
      // Consume tag even when message is not loggable so that next message is correctly tagged.
      String tag = getTag();

      if (!isLoggable(tag, priority)) {
        return;
      }
      if (message != null && message.length() == 0) {
        message = null;
      }
      if (message == null) {
        if (t == null) {
          return; // Swallow message if it's null and there's no throwable.
        }
        message = getStackTraceString(t);
      } else {
        if (args != null && args.length > 0) {
          message = formatMessage(message, args);
        }
        if (t != null) {
          message += "\n" + getStackTraceString(t);
        }
      }

      log(priority, tag, message, t);
    }

/**
     * No locks are used to synchronize an access to the [Lazy] instance value; if the instance is accessed from multiple threads, its behavior is undefined.
     *
     * This mode should not be used unless the [Lazy] instance is guaranteed never to be initialized from more than one thread.
     */

lazy

val

NONE

members.putIfAbsent(key, value)