interface Foo<T : Any>

interface Foo<T>

yml or yaml

mapping values are not allowed here in "<unicode string>", line 95, column 18: filters:

workflows:
  version: 2

  build_and_test:
    jobs:
      - build_and_setup
          filters:
            branches:
              only: master

CircleCI

class Appender<out T1>(private val value: T1) {
    fun <T2 : T3, T3> addTo(list: List<T2>): List<T3> = (list + value) as List<T3>
}

fun main() {
    val appender = Appender(2.0)
    val list = listOf(1)
    val combined = appender.addTo<Int, Number>(list)
    println(combined)
}

Appender

T3

T3

T1

T2

T1 : T3

T3

listOf(1) + listOf(2.0)

List<Any>

List<Number>

Appender<Nothing>

List<T2>

addTo<T2, T2>

Appender<Nothing>

List + List

public class GenericsJava {
  public static Condition testJooqGenerics(Table<?> table, List<Object> list) {
    Field<Object> myColumn = table.field("MY_COLUMN", Object.class);
    return <http://myColumn.in|myColumn.in>(list);
  }
}

object GenericsKotlin {
    fun testJooqGenerics(table: Table<*>, list: List<Any?>?): Condition {
        val myColumn: Field<Any> = table.field("MY_COLUMN", Any::class.java)
        return myColumn.`in`(list)
    }
}

@Support public abstract fun `in`(vararg p0: Any!): Condition! defined in org.jooq.Field
@Support public abstract fun `in`(p0: (Mutable)Collection<*>!): Condition! defined in org.jooq.Field

sealed class Data<T: Any> {
    class Single<T: Any>@JsonCreator constructor(@JsonValue val single: T?): Data<T>()
    class ListOf<T: Any>@JsonCreator constructor(@JsonValue val list: List<T>): Data<T>()
}

private fun <T: Any> readResponseWithSingleData(
    jsonMapper: ObjectMapper,
    json: String
): Response<T, Data.Single<T>> {
    val typeRef = object : TypeReference<Response<T, Data.Single<T>>>() {}
    return jsonMapper.readValue<Response<T, Data.Single<T>>>(json, typeRef)
}

private fun <T : Any> readResponseWithListOfData(
    jsonMapper: ObjectMapper,
    json: String
): Response<T, Data.ListOf<T>> {
    val typeRef = object : TypeReference<Response<T, Data.ListOf<T>>>() {}
    return jsonMapper.readValue<Response<T, Data.ListOf<T>>>(json, typeRef)
}

LinkedHashMap

List<Set<T>>

clazz: Class<T>

Response

data class Response<T: Any, D: Data<T>> @JsonCreator constructor(
    @JsonProperty("data") val data: Map<String, D>?,
    @JsonProperty("errors") val errors: List<String>?
)

getFoo

foo

val foo: Foo = ...

getFoo

private val foo: Foo = ...
override fun getFoo(): Foo = foo

.javaClass

::class.java

super

open class Foo {
    open fun Int.bar() {
        println("Bar")
    }
}

class FooImpl : Foo() {
    override fun Int.bar() {
        super.bar() // Unresolved reference
    }
}

Foo#bar

FooImpl#bar

Class name may only contain letters and digits

getOrElse

ResultWrapper

sealed class ResultWrapper<out T> {
    data class Success<out T : Any>(val value: T) : ResultWrapper<T>()
    data class Failure<out T : Any>(val failure: Throwable) : ResultWrapper<T>()

    inline fun <B> fold(ifFailure: (Throwable) -> B, ifSuccess: (T) -> B): B =
        when (this) {
            is Failure -> ifFailure(failure)
            is Success -> ifSuccess(value)
        }

    companion object {
        fun <T : Any> just(t: T): ResultWrapper<T> = Success(t)
        fun <T : Any> raise(t: Throwable): ResultWrapper<Throwable> = Failure(t)
    }
}

Success(value=MyModel(....))

Assert.assertEquals(expectedResult, result)

expectedResult

MyModel

Result

Success(value=MyModel(....))

import kotlin.random.Random
var number=3
var rollDice:(Int)->Int={ number:Int->Random.nextInt(1 , 13)/number}
fun roll(number,operation:(Int)->Int):Int
{
    return rollDice(number)
}
println("${roll(number,rollDice)}")