/**
 * Task: Make line `DisNonNullable.nonNull()` not compile
 * Clarification: `DisNonNullable.nonNull()` will always have a non-null value, so it makes sense to not allow that method
 * Clarification: Everything else has to compile just as before, only `DisNonNullable.nonNull()` should fail
 * Clarification: The non-generic parameter type String is chosen only as an example. This hardcoded type is not the focus of the task
 * Restrictions: Mustn't modify main() method, DisNullable and DisNotNullable classes
 */

fun main(args: Array<String>) {
    DisNullable.nonNull()
    DisNonNullable.nonNull()
}

abstract class GenericMapper<T>  {
    abstract fun map(string: String): T

    fun nonNull(): GenericMapper<T> {
        val delegate = this
        return object : GenericMapper<T>() {
            override fun map(string: String): T {
                return delegate.map(string)
            }
        }
    }
}

object DisNullable : GenericMapper<String?>() {
    override fun map(string: String) = string
}

object DisNonNullable : GenericMapper<String>() {
    override fun map(string: String) = string
}

fun main(args: Array<String>) {
  DisNullable.nonNull()
  DisNonNullable.nonNull()
}

// Internal so that there are only two immediate subtypes, but it isn't sealed, so other subtypes of
// those immediate subtypes can be defined in other packages.
abstract class GenericMapper<T> internal constructor() {
  abstract fun map(string: String): T
}

abstract class NullableGenericMapper<T> : GenericMapper<T>()  {

  fun nonNull(): GenericMapper<T> {
    val delegate = this
    return object : GenericMapper<T>() {
      override fun map(string: String): T {
        return delegate.map(string)
      }
    }
  }
}

abstract class NonNullableGenericMapper<T : Any> : GenericMapper<T>()

object DisNullable : NullableGenericMapper<String?>() {
  override fun map(string: String) = string
}

object DisNonNullable : NonNullableGenericMapper<String>() {
  override fun map(string: String) = string
}

"The constraints are arbitrary and it may be impossible to meet them

But I definitely remember that there was a solution, exactly according to these rules

Clarification: `DisNonNullable.nonNull()` will always have a non-null value, so it makes sense to not allow that method

nonNull

GenericMapper<String?>

GenericMapper<String>

map

String

String?

GenericMapper<String>.nonNull()

fun main(args: Array<String>) {
  DisNullable.nonNull()
  DisNonNullable.nonNull()
}

abstract class GenericMapper<T>  {
  abstract fun map(string: String): T
}

fun <T> GenericMapper<T?>.nonNull(): GenericMapper<T> {
  val delegate = this
  return object : GenericMapper<T>() {
    override fun map(string: String): T {
      return delegate.map(string) ?: TODO("handle null")
    }
  }
}

object DisNullable : GenericMapper<String?>() {
  override fun map(string: String) = string
}

object DisNonNullable : GenericMapper<String>() {
  override fun map(string: String) = string
}