@Deprecated("Use removeAt(index) instead.", ReplaceWith("removeAt(index)"))\nfun remove(index: Int) {\n}\n @Deprecated 어노테이션은 최대 3가지 파라미터를 받는다.\nmessage: 사용중단 예고 이유replaceWith: 옛 버전을 대신할 수 있는 패턴 제시level: 점진적인 사용 중단을 지원 제공\nWARNING: 경고만 함ERROR: 컴파일되지 못하게 막음.HIDDEN: 컴파일되지 못하게 막으며, 예전에 컴파일된 코드와의 이진호환성만 유지::class를 클래스 이름 뒤에 넣어야 한다.@를 넣지 말라.[])를 사용, arrayOf 함수 사용@get:JvmName(\"obtainCertificate\")@JvmName("performCalculation")\nfun calculate(): Int {\n return (2 + 2) - 1\n}\n calculate 함수를 자바 쪽에서 performCalculation()로 호출하게 한다.class CertificateManager {\n @get:JvmName("obtainCertificate")\n @set:JvmName("putCertificate")\n var certificate: String = "-----BEGIN CERTIFICATE-----"\n}\n certificate 프로퍼티를 obtainCertificate, putCertificate 라는 이름으로 사용할 수 있다.사용 지점 타깃을 지정할 때 지원하는 타깃 목록
\n코틀린에는 컴파일러 경고를 무시하기 위한 @Suppress 어노테이션이 있다.
data class Person(val name: String, val age: Int)\n\nfun main() {\n val person = Person("Alice", 29)\n println(serialize(person))\n}\n fun main() {\n val json = """{"name": "Alice", "age": 29"}"""\n println(deserialize<Person>(json))\n}\n data class Person(\n @JsonName("alias") val firstName: String,\n @JsonExclude val age: Int? = null\n)\n @JsonExclude 어노테이션을 사용하면 직렬화나 역직렬화할 때 무시해야 하는 프로퍼티를 표시할 수 있다.\n@JsonName 어노테이션을 사용하면 프로퍼티를 표현하는 키/값 쌍의 키로 프로퍼티 이름 대신 어노테이션이 지정한 문자열을 쓰게 할 수 있다.annotation class JsonExclude\n annotation class JsonName(val name: String)\n val로 선언@Target(AnnotationTarget.PROPERTY)\nannotation class JsonExclude\n @Target 메타어노테이션은 어노테이션을 적용할 수 있는 요소의 유형을 지정@Target을 지정하지 않으면 모든 선언에 적용할 수 있는 어노테이션이 된다.@Target(AnnotationTarget.ANNOTATION_CLASS)\nannotation class BindingAnnotation\n\n@BindingAnnotation\nannotation class MyBinding\n ANNOTATION_CLASS를 타깃으로 지정하자.interface Company {\n val name: String\n}\n\ndata class CompanyImpl(override val name: String) : Company\n\ndata class Person(\n val name: String,\n @DeserializeInterface(CompanyImpl::class) val company: Company\n)\n @DeserializeInterface는 인터페이스 타입인 프로퍼티에 대한 역직렬화를 제어할 때 쓰는 어노테이션이다.annotation class DeserializeInterface(val targetClass: KClass<out Any>)\n interface ValueSerializer<T> {\n fun toJsonValue(value: T): Any?\n fun fromJsonValue(jsonValue: Any?): T\n}\n data class Person(\n val name: String,\n @CustomSerializer(DateSerializer::class) val birthDate: Date\n)\n annotation class CustomSerializer(val serializerClass: KClass<out ValueSerializer<*>>)\n KClass<out 자신의 클래스 이름>KClass<out 자신의 클래스 이름<*>> 처럼 타입인자를 *로 바꾼다.interface KClass<T : Any> {\n val simpleName: String?\n val qualifiedName: String?\n val members: Collection<KCallable<*>>\n val constructors: Collection<KFunction<T>>\n val nestedClasses: Collection<KClass<*>>\n // ...\n}\n KClass 선언을 찾아보면 클래스 내부를 살펴볼 때 사용할 수 있는 다양하고 유용한 메서드를 볼 수 있다.interface KCallable<out R> {\n fun call(vararg args: Any?): R\n // ...\n}\n KCallable은 함수와 프로퍼티를 아우르는 공통 상위 인터페이스다.call을 사용할 때는 함수 인자를 vararg 리스트로 전달fun foo(x: Int) = println(x)\n\nfun main() {\n val kFunction = ::foo\n kFunction.call(42)\n}\n ::foo 식의 값 타입이 KCallable 클래스의 인스턴스이다.fun sum(x: Int, y: Int) = x + y\n\nfun main() {\n val kFunction = KFunction2<Int, Int, Int> = ::sum\n println(kFunction.invoke(1, 2) + kFunction.invoke(3, 4))\n kFunction(1)\n // error\n}\n var counter = 0\n\nfun main() {\n val kProperty = ::counter\n kProperty.setter.call(21)\n println(kProperty.get())\n}\n KProperty0이나, KMutableProperty0 인터페이스의 인스턴스로 표현\nKProperty1은 제네릭 클래스이다.fun serialize(obj: Any): String\n StringBuilder 인스턴스 안에 구축한다.private fun StringBuilder.serializeObject(x: Any) {\n append(/*...*/)\n}\n fun serialize(obj: Any): String = buildString { serializeObject(obj) }\n serializeObject에 위임한다.private fun StringBuilder.serializeObject(obj: Any) {\n val kClass = obj::class as KClass<Any>\n val properties = kClass.memberProperties\n\n properties.joinToStringBuilder(\n this, prefix = "{", postfix = "}"\n ) { prop ->\n serializeString(prop.name)\n append(": ")\n serializePropertyValue(prop.get(obj))\n }\n}\n 어노테이션을 지원하기 위해 serializeObject를 어떻게 수정할지 알아본다.
val properties = kClass.memberProperties.filter { it.findAnnotation<JsonExclude>() == null }\n @JsonExclude 어노테이션이 붙지 않은 프로퍼티만 남길 수 있다.val jsonNameAnn = prop.findAnnotation<JsonName>()\nval propName = jsonNameAnn?.name ?: prop.name\n private fun StringBuilder.serializeObject(obj: Any) {\n (obj::class as KClass<Any>)\n .memberProperties\n .filter { it.findAnnotation<JsonExclude>() == null }\n .joinToStringBuilder(this, prefix = "{", postfix = "}") {\n serializeProperty(it, obj)\n }\n}\n @JsonExclude 어노테이션한 프로퍼티를 제외시킨다.private fun StringBuilder.serializeObject(prop: KProperty1<Any, *>, obj: Any) {\n val jsonNameAnn = prop.findAnnotation<JsonName>()\n val propName = jsonNameAnn?.name ?: prop.name\n serializeString(propName)\n append(": ")\n serializePropertyValue(prop.get(obj))\n}\n @JsonName에 따라 프로퍼티 이름을 처리한다.fun KProperty<*>.getSerializer(): ValueSerializer<Any?>? {\n val customSerializerAnn = findAnnotation<CustomSerializer>() ?: return null\n val serializerClass = customSerializerAnn.serializerClass\n\n val valueSerializer = serializerClass.objectInstance\n ?: serializerClass.createInstance()\n @Suppress("UNCHECKED_CAST")\n return valueSerializer as ValueSerializer<Any?>\n}\n private fun StringBuilder.serializeProperty(\n prop: KProperty1<Any, *>, obj: Any\n) {\n val jsonNameAnn = prop.findAnnotation<JsonName>()\n val propName = jsonNameAnn?.name ?: prop.name\n serializeString(propName)\n append(": ")\n\n val value = prop.get(obj)\n val jsonValue = prop.getSerializer()?.toJsonValue(value) ?: value\n serializePropertyValue(jsonValue)\n}\n serializeProperty 구현 안에서 getSerializer를 사용할 수 있다.interface KCallable<out R> {\n fun callBy(args: Map<KParameter, Any?>): R\n // ...\n}\n KCallable.call은 디폴트 파라미터 값을 지원하지 않는다.KCallable.callBy는 디폴트 파라미터 값을 지원한다.object BooleanSerializer : ValueSerializer<Boolean> {\n override fun fromJsonValue(jsonValue: Any?): Boolean {\n if (jsonValue !is Boolean) throw JkidException("Boolean Expected")\n return jsonValue\n }\n override fun toJsonValue(value: Boolean) = value\n}\n class ClassInfoCache {\n private val cacheData = mutableMapOf<KClass<*>, ClassInfo<*>>()\n\n @Suppress("UNCHECKED_CAST")\n operator fun <T : Any> get(cls: KClass<T>): ClassInfo<T> =\n cacheData.getOrPut(cls) { ClassInfo(cls) } as ClassInfo<T>\n}\n fun main() {\n println("I'm on ${Thread.currentThread().name}")\n thread {\n println("And I'm on ${Thread.currentThread().name}")\n }\n}\n 코틀린은 스레드에 대한 대안으로 코루틴이라는 추상화를 도입
\nfun login(credentials: Credentials): UserID\nfun loadUserData(userID: UserID): UserData\nfun showData(data: UserData)\n\nfun showUserInfo(credentials: Credentials) {\n val userID = login(credentials)\n val userData = loadUserData(userID)\n showData(userData)\n}\n suspend fun login(credentials: Credentials): UserID\nsuspend fun loadUserData(userID: UserID): UserData\nfun showData(data: UserData)\n\nfun showUserInfo(credentials: Credentials) {\n val userID = login(credentials)\n val userData = loadUserData(userID)\n showData(userData)\n}\n suspend 변경자는 함수가 실행을 잠시 멈출 수도 있다는 뜻\nlogin과 loadUserData의 구현도 코틀린 코루틴을 고려해 작성돼야 한다.fun loginAsync(credentials: Credentials, callback: (UserID) -> Unit) {}\nfun loadUserDataAsync(userID: UserID, callback: (UserData) -> Unit) {}\nfun showData(data: UserData) {}\n\nfun showUserInfo(credentials: Credentials) {\n loginAsync(credentials) { userID ->\n loadUserDataAsync(userID) { userData ->\n showData(userData)\n }\n }\n}\n fun loginAsync(credentials: Credentials): CompletableFuture<UserID>\nfun loadUserDataAsync(userID: UserID): CompletableFuture<UserData>\nfun showData(data: UserData)\n\nfun showUserInfo(credentials: Credentials) {\n loginAsync(credentials)\n .thenCompose { loadUserDataAsync(it) }\n .thenAccept { showData(it) }\n}\n CompletableFuture을 사용하면 콜백 지옥을 피할 수 있지만 새로운 연산자의 의미를 배워야 한다.fun login(credentials: Credentials): Single<UserID>\nfun loadUserData(userID: UserID): Single<UserData>\nfun showData(data: UserData)\n\nfun showUserInfo(credentials: Credentials) {\n login(credentials)\n .flatMap { loadUserData(it) }\n .doOnSuccess { showData(it) }\n .subscribe()\n}\n 위와 비교해보면 코루틴을 사용하는 접근 방식에서는 함수에 suspend 변경자만 추가하면 된다.
suspend fun mySuspendingFunction() {}\n\nfun main() {\n mySuspendingFunction() // error\n}\n suspend로 하면 호출 가능runBlocking은 블로킹 코드와 일시 중단 함수의 세계를 연결할 때 쓰인다.launch는 값을 반환하지 않는 새로운 코루틴을 시작할 때 쓰인다.async는 비동기적으로 값을 계산할 때 쓰인다.suspend fun doSomethingSlowly() {\n delay(500.milliseconds)\n println("I'm done")\n}\n\nfun main() = runBlocking {\n doSomethingSlowly()\n}\n runBlocking을 사용할 때는 하나의 스레드를 블로킹한다.private var zeroTime = System.currentTimeMillis()\nfun log(message: Any?) =\n println("${System.currentTimeMillis() - zeroTime} " + "[${Thread.currentThread().name}] $message")\n\nfun main() = runBlocking {\n log("The first, parent, coroutine starts")\n launch {\n log("The second coroutine starts and is ready to be suspended")\n delay(100.milliseconds)\n log("The second coroutine is resumed")\n }\n launch {\n log("The third coroutine can run in the meantime")\n }\n log("The first coroutine has launched two more coroutines")\n}\n -Dkotlinx.coroutines.debug JVM 옵션 포함 실행38 [main @coroutine#1] The first, parent, coroutine starts\n52 [main @coroutine#1] The first coroutine has launched two more coroutines\n53 [main @coroutine#2] The second coroutine starts and is ready to be suspended\n58 [main @coroutine#3] The third coroutine can run in the meantime\n163 [main @coroutine#2] The second coroutine is resumed\n launch를 사용해 새로운 기본 코루틴을 시작할 수 잇다.suspend fun slowlyAddNumbers(a: Int, b: Int): Int {\n log("Waiting a bit before calculating $a + $b")\n delay(100.milliseconds * a)\n return a + b\n}\n\nfun main() = runBlocking {\n log("Starting the async computation")\n val myFirstDeferred = async { slowlyAddNumbers(2, 2) }\n val mySecondDeferred = async { slowlyAddNumbers(4, 4) }\n log("Waiting for the deferred value to be available")\n log("The first result: ${myFirstDeferred.await()}")\n log("The second result: ${mySecondDeferred.await()}")\n}\n 44 [main @coroutine#1] Starting the async computation\n60 [main @coroutine#1] Waiting for the deferred value to be available\n65 [main @coroutine#2] Waiting a bit before calculating 2 + 2\n71 [main @coroutine#3] Waiting a bit before calculating 4 + 4\n287 [main @coroutine#1] The first result: 4\n481 [main @coroutine#1] The second result: 8\n async를 호출할 때마다 새로운 코루틴을 시작함으로써 두 계산이 동시에 일어나게 했다.await를 호출하면 그 Deferred에서 결괏값이 사용 가능해질 때까지 루트 코루틴이 일시 중단된다.Deferred 객체는 아직 사용할 수 없는 값을 나타낸다.\n| 빌더 | \n반환값 | \n쓰임새 | \n
|---|---|---|
runBlocking | \n람다가 계산한 값 | \n블로킹 코드와 넌블로킹 코드 사이를 연결 | \n
launch | \nJob | \n발사 후 망각 코루틴 시작(부수 효과가 있음) | \n
async | \nDeferred<T> | \n값을 비동기로 계산(값을 기다릴 수 있음) | \n
Dispatchers.Main의 실제 값은 사용하는 프레임워크에 따라 다르다.Dispatchers.IO에서 실행된 코루틴은 자동으로 확장되는 스레드 풀에서 실행| 디스패처 | \n스레드 개수 | \n쓰임새 | \n
|---|---|---|
Dispatchers.Default | \nCPU 코어 수 | \n일반적인 연산, CPU 집약적인 작업 | \n
Dispatchers.Main | \n1 | \nUI 프레임워크의 맥락에서만 작업 | \n
Dispatchers.IO | \n64 + CPU 코어 개수(단, 최대 64개만 병렬 실행) | \n블로킹 IO 작업, 네트워크 작업, 파일 작업 | \n
Dispatchers.Unconfined | \n아무 스레드나 | \n즉시 스케줄링해야 하는 특별한 경우 | \n
limitedParallelism(n) | \n커스텀(n) | \n커스텀 시나리오 | \n
fun main() {\n runBlocking {\n log("Doing some work")\n launch(Dispatchers.Default) {\n log("Doing some background work")\n }\n }\n}\n 45 [main @coroutine#1] Doing some work\n63 [DefaultDispatcher-worker-2 @coroutine#2] Doing some background work\n launch(Dispatchers.Default) {\n val result = performBackgroundOperation()\n withContext(Dispatchers.Main) {\n updateUI(result)\n }\n}\n withContext 함수에 다른 디스패처를 전달fun main() {\n runBlocking {\n launch(Dispatchers.Default) {\n var x = 0\n repeat(10_000) {\n x++\n }\n println(x)\n }\n }\n}\n fun main() {\n runBlocking {\n var x = 0\n repeat(10_000) {\n launch(Dispatchers.Default) {\n x++\n }\n }\n delay(1.seconds)\n println(x)\n }\n}\n fun main() = runBlocking {\n val mutex = Mutex()\n var x = 0\n repeat(10_000) {\n launch(Dispatchers.Default) {\n mutex.withLock {\n x++\n }\n }\n }\n delay(1.seconds)\n println(x)\n}\n Mutex 잠금을 통해 코드 임계 영역이 한 번에 하나의 코루틴만 실행되게 보장할 수 있다.CoroutineContext라는 형태로 제공CoroutineContext는 여러 요소로 이뤄진 집합CoroutineContext에는 코루틴의 생명주기와 취소를 관리하는 Job 객체 포함CoroutineContext에는 CoroutineNmae, CoroutineExceptionHandler와 같은 메타데이터도 포함suspend fun introspect() {\n log(coroutineContext)\n}\n\nfun main() {\n runBlocking {\n introspect()\n }\n}\n 39 [main @coroutine#1] [CoroutineId(1), "coroutine#1":BlockingCoroutine{Active}@32709393, BlockingEventLoop@3d99d22e]\n fun main() {\n runBlocking(Dispatchers.IO + CoroutineName("Coolroutine")) {\n introspect()\n }\n}\n 43 [DefaultDispatcher-worker-1 @Coolroutine#1] [CoroutineName(Coolroutine), CoroutineId(1), "Coolroutine#1":BlockingCoroutine{Active}@1be729a6, Dispatchers.IO]\n | 일반 구문 | \n간결한 구문 | \n사용한 언어 특성 | \n
|---|---|---|
StringUtil.capitalizes(s) | \ns.capitalize() | \n확장 함수 | \n
1.to(\"one\") | \n1 to \"one\" | \n중위 호출 | \n
set.add(2) | \nset += 2 | \n연산자 오버로딩 | \n
map.get(\"key\") | \nmap[\"key\"] | \nget 메소드에 대한 관례 | \n
file.use({ f -> f.read() }) | \nfile.use { it.read() } | \n람다를 괄호 밖으로 빼내는 관례 | \n
sb.append(\"yes\") | \nwith(sb) { append(\"yes\") append(\"no\") } | \n수신 객체 지정 람다 | \n
SELECT country.name, COUNT(customer.id)\nFROM country\n JOIN customer ON customer.country_id = country.id\nGROUP BY country.name\nORDER BY COUNT(customer.id) DESC LIMIT 1;\n (Country innerJoin Customer)\n .slice(Country.name, Count(Customer.id))\n .selectAll()\n .groupBy(Country.name)\n .orderBy(Count(Customer.id), order = SortOrder.DESC)\n .limit(1)\n kotlinx.html로 HTML을 만들 수 있다.fun buildString(\n builderAction: (StringBuilder) -> Unit\n): String {\n val sb = StringBuilder()\n builderAction(sb)\n return sb.toString()\n}\n\nfun main() {\n val s = buildString {\n it.append("Hello, ")\n it.append("World!")\n }\n println(s)\n}\n buildString 정의StringBuilder 인스턴스를 참조해야 한다.fun buildString(\n builderAction: StringBuilder.() -> Unit\n): String {\n val sb = StringBuilder()\n sb.builderAction()\n return sb.toString()\n}\n\nfun main() {\n val s = buildString {\n this.append("Hello, ")\n this.append("World!")\n }\n println(s)\n}\n val appendExcl: StringBuilder.() -> Unit =\n { this.append("!") }\n\n\nfun main() {\n val stringBuilder = StringBuilder("Hi")\n stringBuilder.appendExcl()\n println(stringBuilder)\n println(buildString(appendExcl))\n}\n fun builderString(builderAction: StringBuilder.() -> Unit): String =\n StringBuilder().apply(builderAction).toString()\n builderString 구현은 더 짧다.apply와 with는 모두 자신이 제공받은 수신 객체를 갖고 확장 함수 타입의 람다를 호출fun createSimpleTable() = createHTML().table {\n tr {\n td { +"cell" }\n }\n}\n open class Tag\n\nclass TABLE : Tag {\n fun tr(init: TR.() -> Unit)\n}\n\nclass TR : Tag {\n fun td(init: TD.() -> Unit)\n}\n\nclass TD : Tag\n fun createSimpleTable() = createHTML().table {\n this@table.tr {\n (this@tr).td {\n +"cell"\n }\n }\n}\n @DslMarker\nannotation class HtmlTagMarker\n @DslMarker 어노테이션을 사용해 내포된 람다에서 외부 람다의 수신 객체에 접근하지 못하게 제한할 수 있다.@DslMarker\nannotation class HtmlTagMarker\n\n@HtmlTagMarker\nopen class Tag(val name: String) {\n private val children = mutableListOf<Tag>()\n\n protected fun <T : Tag> doInit(child: T, init: T.() -> Unit) {\n child.init()\n children.add(child)\n }\n\n override fun toString() = "<$name>${children.joinToString("")}</$name>"\n}\n\nfun table(init: TABLE.() -> Unit) = TABLE().apply(init)\n\nclass TABLE : Tag("table") {\n fun tr(init: TR.() -> Unit) = doInit(TR(), init)\n}\n\nclass TR : Tag("tr") {\n fun td(init: TD.() -> Unit) = doInit(TD(), init)\n}\n\nclass TD : Tag("td")\n\nfun createTable() = table {\n tr {\n td {\n }\n }\n}\n fun buildBookList() = createHTML().body {\n ul {\n li { a("#1") { +"The Three-Body Problem" } }\n li { a("#2") { +"The Cartesian Product Problem" } }\n li { a("#3") { +"The Conjugation Problem" } }\n }\n\n h2 { id = "1"; +"The Three-Body Problem" }\n p { +"The Three-Body Problem is a classic physics problem from the early 20th century." }\n\n h2 { id = "2"; +"The Cartesian Product Problem" }\n p { +"The Cartesian product is a useful mathematical construct for a wide variety of problems." }\n\n h2 { id = "3"; +"The Conjugation Problem" }\n p { +"The Conjugation Problem is a classic computational problem from the 1970s." }\n}\n fun buildBookList() = createHTML().body {\n listWithToc {\n item(\n "The Three-Body Problem",\n "The Three-Body Problem is a classic physics problem from the early 20th century."\n )\n item(\n "The Cartesian Product Problem",\n "The Cartesian product is a useful mathematical construct for a wide variety of problems."\n )\n item(\n "The Conjugation Problem",\n "The Conjugation Problem is a classic computational problem from the 1970s."\n )\n\n }\n}\n @HtmlTagMarker\nclass LISTWITHTOC {\n val entries = mutableListOf<Pair<String, String>>()\n fun item(headline: String, body: String) {\n entries += headline to body\n }\n}\n @HtmlTagMarker 어노테이션을 붙여 DSL 영역 규칙을 따르게 할 수 있다.fun BODY.listWithToc(block: LISTWITHTOC.() -> Unit) {\n val listWithToc = LISTWITHTOC()\n listWithToc.block()\n ul {\n for ((index, entry) in listWithToc.entries.withIndex()) {\n li {\n a("#${index}") { +entry.first }\n }\n }\n }\n for ((index, entry) in listWithToc.entries.withIndex()) {\n h2 { id = "$index"; +entry.first }\n p { +entry.second }\n }\n}\n class Greeter(val greeting: String) {\n operator fun invoke(name: String) {\n println("$greeting, $name!")\n }\n}\n\nfun main() {\n val bavarianGreeter = Greeter("Servus")\n bavarianGreeter("Dmitry")\n}\n invoke 메소드 정의invoke 메서드의 시그니처에 대한 요구사항은 없다.dependencies {\n testImplementation(kotlin("test"))\n implementation("org.jetbrains.exposed:exposed-core:0.40.1")\n implementation("org.jetbrains.exposed:exposed-dao:0.40.1")\n}\n dependencies.implementation("org.jetbrains.exposed:exposed-core:0.40.1")\n\ndependencies {\n implementation("org.jetbrains.exposed:exposed-core:0.40.1")\n}\n invoke를 사용한 것이다.class DependencyHandler {\n fun implementation(coordinate: String) {\n println("Added dependency on $coordinate")\n }\n\n operator fun invoke(body: DependencyHandler.() -> Unit) {\n body()\n }\n}\n\nfun main() {\n val dependencies = DependencyHandler()\n dependencies.implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")\n dependencies {\n implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.5.0")\n }\n}\n invoke 사용invoke 메서드로 인해 DSL API의 유연성이 훨씬 커진다.class PrefixTest {\n @Test\n fun testKPrefix() {\n val s = "kotlin".uppercase()\n s should startWith("K")\n }\n}\n infix fun <T> T.should(matcher: Matcher<T>) = matcher.test(this)\n\ninterface Matcher<T> {\n fun test(value: T)\n}\n\nfun startWith(prefix: String): Matcher<String> {\n return object : Matcher<String> {\n override fun test(value: String) {\n if (!value.startsWith(prefix)) {\n throw AssertionError("$value does not start with $prefix")\n }\n }\n }\n}\n val Int.days: Duration\n get() = this.toDuration(DurationUnit.DAYS)\n\nval Int.hours: Duration\n get() = this.toDuration(DurationUnit.HOURS)\n Table 클래스의 integer, varchar 등의 메서드는 외부에서 호출할 수 없지만, 멤버 확장 함수를 통해 제한된 범위 내에서만 사용하도록 할 수 있다.