Kotlin中的contract到底有什么用详解

public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}
 
public inline fun CharSequence?.isNullOrEmpty(): Boolean {
    contract {
        returns(false) implies (this@isNullOrEmpty != null)
    }
 
    return this == null || this.length == 0
}

public inline fun <T, R> T.runWithoutContract(block: T.() -> R): R {
    return block()
}
 
public inline fun CharSequence?.isNullOrEmptyWithoutContract(): Boolean {
    return this == null || this.length == 0
}

fun test() {
    var str1: String = ""
    var str2: String = ""
 
    runWithoutContract {
        str1 = "jayce"
    }
    run {
        str2 = "jayce"
    }
 
    println(str1) //jayce
    println(str2) //jayce
}

@Test
fun test() {
    var str1: String
    var str2: String 
 
    runWithoutContract {
        str1 = "jayce"
    }
    run {
        str2 = "jayce"
    }
 
    println(str1) //编译不通过 （Variable 'str1' must be initialized）
    println(str2) //编译通过
}

fun test() {
    val str: String? = "jayce"
 
    if (!str.isNullOrEmpty()) {
        println(str) //jayce
    }
    if (!str.isNullOrEmptyWithoutContract()) {
        println(str) //jayce
    }
}

fun test() {
    val str: String? = "jayce"
 
    if (!str.isNullOrEmpty()) {
        println(str.length) // 编译通过
    }
 
    if (!str.isNullOrEmptyWithoutContract()) {
        println(str.length) // 编译不通过（Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?）
    }
}

public inline fun contract(builder: ContractBuilder.() -> Unit) { }

public interface ContractBuilder {
      //描述函数正常返回，没有抛出任何异常的情况。
    @ContractsDsl public fun returns(): Returns
 
      //描述函数以value返回的情况，value可以取值为 true|false|null。
    @ContractsDsl public fun returns(value: Any?): Returns
  
      //描述函数以非null值返回的情况。
    @ContractsDsl public fun returnsNotNull(): ReturnsNotNull
 
       //描述lambda会在该函数调用的次数，次数用kind指定
    @ContractsDsl public fun <R> callsInPlace(lambda: Function<R>, kind: InvocationKind = InvocationKind.UNKNOWN): CallsInPlace
}

public interface SimpleEffect : Effect {
      //接收一个Boolean值的表达式 改函数用来表示当SimpleEffect成立之后 保证Boolean值的表达式返回值为true
      //表达式可以传判空代码块（`== null`, `!= null`）判断实例语句 (`is`, `!is`)。
    public infix fun implies(booleanExpression: Boolean): ConditionalEffect
}

public inline fun CharSequence?.isNullOrEmpty(): Boolean {
    contract {
          //返回值为false的情况 returns(false）
                //意味着 implies
                //调用该函数的对象不为空 (this@isNullOrEmpty != null)
        returns(false) implies (this@isNullOrEmpty != null)
    }
  
    return this == null || this.length == 0
}

@ExperimentalContracts //因为该特性还在试验当中 所以需要加上这个注解
fun CharSequence?.isNotNull(): Boolean {
    contract {
          //返回值为true returns(true)
          //意味着implies
          //调用该函数的对象是StringBuilder (this@isNotNull is StringBuilder)
        returns(true) implies (this@isNotNull is StringBuilder)
    }
 
    return this != null
}
 
fun test() {                                                                                               
    val str: String? = "jayce"                                                                             
                                                                                                           
    if (str.isNotNull()) {                                                                                 
        str.append("")//String可是没有这个函数的，因为我们用contract让他强制转换成StringBuilder了 所以才有了这个函数                       
    }                                                                                                      
}

//描述lambda会在该函数调用的次数，次数用kind指定
@ContractsDsl public fun <R> callsInPlace(lambda: Function<R>, kind: InvocationKind = InvocationKind.UNKNOWN): CallsInPlace

public inline fun <T, R> T.run(block: T.() -> R): R {
    contract {
          //block这个函数，刚好调用一次
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}