hooks2/xyz.junerver.kotlin

Package-level declarations

Types

object None

data class Single<out A>(val first: A)

typealias Tuple0 = None

typealias Tuple1<A> = Single<A>

typealias Tuple10<A, B, C, D, E, F, G, H, I, J> = arrow.core.Tuple10<A, B, C, D, E, F, G, H, I, J>

typealias Tuple2<A, B> = Pair<A, B>

typealias Tuple3<A, B, C> = Triple<A, B, C>

typealias Tuple4<A, B, C, D> = arrow.core.Tuple4<A, B, C, D>

typealias Tuple5<A, B, C, D, E> = arrow.core.Tuple5<A, B, C, D, E>

typealias Tuple6<A, B, C, D, E, F> = arrow.core.Tuple6<A, B, C, D, E, F>

typealias Tuple7<A, B, C, D, E, F, G> = arrow.core.Tuple7<A, B, C, D, E, F, G>

typealias Tuple8<A, B, C, D, E, F, G, H> = arrow.core.Tuple8<A, B, C, D, E, F, G, H>

typealias Tuple9<A, B, C, D, E, F, G, H, I> = arrow.core.Tuple9<A, B, C, D, E, F, G, H, I>

data class WrapBoolean<R>(val condition: Boolean, val result: R?)

一个kotlin实现的类似三元表达式，甚至由于语言的特性，可以用来返回函数：

Properties

val Any?.~~asBoolean~~: Boolean

isAlphabeticOnly

val String.isAlphabeticOnly: Boolean

仅字母

isAlphanumericOnly

val String.isAlphanumericOnly: Boolean

仅数字+字母

val String.isDigitOnly: Boolean

仅数字

val Any?.isNotNull: Boolean

val Any?.isNull: Boolean

全局的空判断扩展属性，这样做空判断时更为优雅

const val TAG: String

Functions

fun Any?.asBoolean(): Boolean

fun Boolean?.asIs(default: Boolean = true): Boolean

可空布尔量的字面值，如果他是空则取默认值

fun Boolean?.asNot(default: Boolean = false): Boolean

可空布尔量字面值取反，如果为空则取默认值

fun Any?.ifTrue(): Any?

一个过滤判断赋值，可以用来过滤空数组、0 Duration、0、false字符串等等，将这些对象直接视为 null

fun String.isEmail(): Boolean

验证是否邮箱

fun String.isMobile(): Boolean

验证是否手机

isNotNullOrEmpty

@ExperimentalContracts

fun String?.isNotNullOrEmpty(): Boolean

fun String.isPhone(): Boolean

验证是否电话

isValidFileName

fun String.isValidFileName(): Boolean

Description: 校验是否为合法文件名

fun Boolean?.~~not~~(default: Boolean = false): Boolean

fun String.~~padLeft~~(len: Int, ch: Char): String

fun String.~~padRight~~(len: Int, ch: Char): String

operator fun <A, B, C, D, E> Tuple4<A, B, C, D>.plus(e: E): Tuple5<A, B, C, D, E>

operator fun <A, B, C, D, E, F> Tuple5<A, B, C, D, E>.plus(f: F): Tuple6<A, B, C, D, E, F>

operator fun <A, B, C, D, E, F, G> Tuple6<A, B, C, D, E, F>.plus(g: G): Tuple7<A, B, C, D, E, F, G>

operator fun <A, B, C, D, E, F, G, H> Tuple7<A, B, C, D, E, F, G>.plus(h: H): Tuple8<A, B, C, D, E, F, G, H>

operator fun <A, B, C, D, E, F, G, H, I> Tuple8<A, B, C, D, E, F, G, H>.plus(i: I): Tuple9<A, B, C, D, E, F, G, H, I>

operator fun <A, B, C, D, E, F, G, H, I, J> Tuple9<A, B, C, D, E, F, G, H, I>.plus(j: J): Tuple10<A, B, C, D, E, F, G, H, I, J>

operator fun <A, B, C> Pair<A, B>.plus(c: C): Triple<A, B, C>

operator fun <A, B, C, D> Triple<A, B, C>.plus(d: D): Tuple4<A, B, C, D>

inline fun <T> printType(t: T): KType

打印泛型

inline fun <T, R> T.runIf(condition: Boolean = true, noinline block: T.() -> R): R?

效果等同于 if(){}，条件达成执行闭包，它不同于if的是，它具有返回值，可以用于一些条件赋值、可空初始化，例如：

inline fun <T, R> T.runUnless(condition: Boolean = true, noinline block: T.() -> R): R?

与上面的效果相反，条件达成则不执行，条件为否定时执行闭包

safeConvertToDouble

fun String.safeConvertToDouble(): Double

字符串安全转换到双精度类型，转换失败返回0

safeConvertToInt

fun String.safeConvertToInt(): Int

字符串安全转换到整型，转换失败返回0

safeConvertToLong

fun String.safeConvertToLong(): Long

字符串安全转换到长整型，转换失败返回0

safeConvertToShort

fun String.safeConvertToShort(): Short

字符串安全转换到短整型类型，转换失败返回0

inline fun <T> Boolean.switches(noinline ifTrue: (Boolean) -> T, noinline ifFalse: (Boolean) -> T): T

一个简单的if-else能返回结果的实现，类似于Either的左右值，它可以更好的将代码变成链式函数调用，也完全可以配合 arrow-kt，将结果封装成Either

inline fun <T> T.then(block: (T) -> Unit)

一个返回Unit的扩展函数，只保障闭包执行，可以看成是无返回值的 let 函数，在一些需要函数返回值的场景可以用来替代显式书写的Unit。

infix fun <A, B, C, D, E> Tuple4<A, B, C, D>.to(e: E): Tuple5<A, B, C, D, E>

infix fun <A, B, C, D, E, F> Tuple5<A, B, C, D, E>.to(f: F): Tuple6<A, B, C, D, E, F>

infix fun <A, B, C, D, E, F, G> Tuple6<A, B, C, D, E, F>.to(g: G): Tuple7<A, B, C, D, E, F, G>

infix fun <A, B, C, D, E, F, G, H> Tuple7<A, B, C, D, E, F, G>.to(h: H): Tuple8<A, B, C, D, E, F, G, H>

infix fun <A, B, C, D, E, F, G, H, I> Tuple8<A, B, C, D, E, F, G, H>.to(i: I): Tuple9<A, B, C, D, E, F, G, H, I>

infix fun <A, B, C, D, E, F, G, H, I, J> Tuple9<A, B, C, D, E, F, G, H, I>.to(j: J): Tuple10<A, B, C, D, E, F, G, H, I, J>

infix fun <A, B, C> Pair<A, B>.to(c: C): Triple<A, B, C>

infix fun <A, B, C, D> Triple<A, B, C>.to(d: D): Tuple4<A, B, C, D>

infix fun <A, B> Single<A>.to(b: B): Pair<A, B>

元组扩展，可以使用 a to b to c 这样的连续中缀函数创建更多元素的元组

fun toBoolean(value: Any?): Boolean

将任意值转换成布尔，类似JS的 Boolean包装器函数

fun <T> Tuple10<T, T, T, T, T, T, T, T, T, T>.toList(): List<T>

fun <T> Tuple4<T, T, T, T>.toList(): List<T>

fun <T> Tuple5<T, T, T, T, T>.toList(): List<T>

fun <T> Tuple6<T, T, T, T, T, T>.toList(): List<T>

fun <T> Tuple7<T, T, T, T, T, T, T>.toList(): List<T>

fun <T> Tuple8<T, T, T, T, T, T, T, T>.toList(): List<T>

fun <T> Tuple9<T, T, T, T, T, T, T, T, T>.toList(): List<T>

fun <T> None.toList(): List<T>

fun <T> Single<T>.toList(): List<T>

fun tuple(): None

fun <A> tuple(first: A): Tuple1<A>

fun <A, B> tuple(first: A, second: B): Tuple2<A, B>

fun <A, B, C> tuple(first: A, second: B, third: C): Tuple3<A, B, C>

fun <A, B, C, D> tuple(first: A, second: B, third: C, fourth: D): Tuple4<A, B, C, D>

fun <A, B, C, D, E> tuple(first: A, second: B, third: C, fourth: D, fifth: E): Tuple5<A, B, C, D, E>

fun <A, B, C, D, E, F> tuple(first: A, second: B, third: C, fourth: D, fifth: E, sixth: F): Tuple6<A, B, C, D, E, F>

fun <A, B, C, D, E, F, G> tuple(first: A, second: B, third: C, fourth: D, fifth: E, sixth: F, seventh: G): Tuple7<A, B, C, D, E, F, G>

fun <A, B, C, D, E, F, G, H> tuple(first: A, second: B, third: C, fourth: D, fifth: E, sixth: F, seventh: G, eighth: H): Tuple8<A, B, C, D, E, F, G, H>

fun <A, B, C, D, E, F, G, H, I> tuple(first: A, second: B, third: C, fourth: D, fifth: E, sixth: F, seventh: G, eighth: H, ninth: I): Tuple9<A, B, C, D, E, F, G, H, I>

fun <A, B, C, D, E, F, G, H, I, J> tuple(first: A, second: B, third: C, fourth: D, fifth: E, sixth: F, seventh: G, eighth: H, ninth: I, tenth: J): Tuple10<A, B, C, D, E, F, G, H, I, J>

infix inline fun <R> WrapBoolean<R>.：(ifFalse: R?): R?

infix inline fun <R> Boolean.？(ifTrue: R?): WrapBoolean<R>