Kotlin-ը զարգանում է. ինչ է բերում 2.2-ը
Ուզո՞ւմ եք իմանալ, թե Kotlin 2.2-ի որ հնարավորություններն են բավականաչափ կայուն production-ի համար, ինչ է փոխվել հենց լեզվում և ոչ միայն գործիքակազմում, կամ որ հնարավորություններն ազդել Kotlin կոդը գրելու և կազմակերպելու ձեր եղանակի վրա։ Ուրեմն այս հոդվածը հենց ձեզ համար է։
Kotlin-ի յուրաքանչյուր թողարկում գալիս է փոփոխությունների ցանկով, որը սովորաբար խառնում է երկու տեսակ փոփոխություն. փոքր, աստիճանական բարելավումներ, որոնք հազիվ եք նկատում, և այնպիսիք, որոնք իրոք փոխում են ձեր ամենօրյա աշխատանքը։ Kotlin 2.2-ը հենց այս օրինաչափությանն է հետևում։ Եթե ուշադիր հետևել եք լեզվի զարգացմանը, հավանաբար հիշում եք, թե ինչպես էին non-local return-ները կամ ուժեղացված string interpolation-ը հայտնվում նախնական (preview) ռեժիմում։ Kotlin 2.2-ում դրանցից մի քանիսը վերջապես կայուն են դարձել՝ լեզվի և կոմպիլյատորի մի քանի նոր հավելումների հետ միասին։ Մյուսները, օրինակ՝ context parameters-ը, դեռ փորձարարական են, բայց ուշադրության արժանի են, մանավանդ եթե գրադարաններ կամ DSL-ներ եք ստեղծում, կամ սիրում եք փորձարկել Kotlin-ի առավել առաջադեմ հնարավորությունները։
Այս համառոտ ակնարկը կենտրոնանում է հենց այն փոփոխությունների վրա, որոնք, հավանաբար, տարբերություն կստեղծեն իրական Kotlin նախագծերում. առանց աղմուկի, առանց լեզվի նախագծման վերացական բանավեճերի, միայն գործնական մասերը։
Ո՞ւմ համար է այս հոդվածը
Այս հոդվածը ուղղված է այն ծրագրավորողներին, ովքեր ամեն օր աշխատում են Kotlin-ով (լինի backend սերվիսներ գրելը, թե գրադարաններ կառուցելը) կամ փորձարկում են Kotlin-ը կողմնակի նախագծերում։
Եթե ինքներդ ձեզ հարցնում եք.
- Kotlin 2.2-ի որ հնարավորություններն են բավականաչափ կայուն production-ի համար։
- Ինչ է փոխվել հենց լեզվում, և ոչ միայն գործիքակազմում։
- Որ հնարավորություններն են կարող ազդել Kotlin կոդը գրելու կամ կազմակերպելու ձեր եղանակի վրա։
ապա այս գրառումը պետք է պատասխանի ձեզ՝ առանց չափազանց խորանալու կոմպիլյատորի ներքին կառուցվածքի կամ լեզվի նախագծման փիլիսոփայության մեջ։ Եթե Kotlin-ը ձեզ համար բոլորովին նոր է, գուցե ավելի լավ է սկսել այլ տեղից. մենք չենք բացատրի հիմնական շարահյուսությունը, այլ կկենտրոնանանք այն բանի վրա, ինչ փոխվել է Kotlin 2.1-ից հետո։
Նախապայմաններ
Հնարավորությունները դիտարկելուց առաջ օգտակար է հստակեցնել, թե ինչն է կայուն, և ինչի համար դեռ պետք է բացահայտ opt-in։ Kotlin 2.2-ում ավելացված լեզվի որոշ հնարավորություններ այժմ կայուն են և պատրաստ production-ի համար։ Մյուսները, մասնավորապես՝ փորձարարականները, ինչպես context parameters-ը, դեռ պետք է միացնել կոմպիլյատորի տարբերակներով։ Այս հնարավորությունները փորձելու համար համոզվեք, որ ձեր build-ը ճիշտ է կարգավորված։
Օրինակ՝ Gradle-ով.
// build.gradle.kts
kotlin {
compilerOptions {
freeCompilerArgs.add("-Xcontext-parameters")
}
}
Թե որ անունն է ձեզ պետք, կախված է կոնկրետ փորձարարական հնարավորությունից, որը ցանկանում եք փորձարկել, և մենք այն կնշենք համապատասխան բաժիններում։ Սկսենք այն հնարավորություններից, որոնք վերջապես կայուն են։
Փորձարարականից դուրս. ինչ է կայունացնում Kotlin 2.2-ը
Նախորդ Kotlin թողարկումների լեզվական մի քանի հնարավորություններ սկսել էին որպես փորձարարական, ինչը նշանակում էր, որ կարելի էր դրանք փորձարկել, բայց չկար երաշխիք, որ դրանք չեն փոխվի։ Kotlin 2.2-ը դրանցից մի քանիսին կայուն կարգավիճակ է շնորհում, այնպես որ դրանք պատրաստ են production-ի և այլևս հատուկ կոմպիլյատորի դրոշակներ չեն պահանջում։
Ստորև՝ համառոտ ամփոփում, թե ինչ է կայուն դարձել Kotlin 2.2-ում։
Ավելի խելամիտ default մեթոդներ JVM-ում
JVM-ը թիրախավորող Kotlin նախագծերի համար Kotlin 2.2-ը մի նուրբ, բայց կարևոր փոփոխություն է բերում ինտերֆեյսներում default մեթոդների իրականացումների մշակման եղանակում։ Այն կարող է ազդել և՛ ձեր բայթկոդի, և՛ երկուական համատեղելիության վրա։ Այս թողարկումից սկսած՝ եթե այլ կերպ չկարգավորեք, Kotlin-ը default մեթոդները թողարկում է անմիջապես ինտերֆեյսներում՝ ժամանակակից Java-ի մոտեցմանը համապատասխան։
Սա փոխարինում է հին լուծումը, երբ Kotlin-ը գեներացնում էր լրացուցիչ DefaultImpls դասեր, որոնք թաքնված կերպով պահում էին default իրականացումները։ Մշակողների մեծ մասի համար գեներացված բայթկոդը դառնում է ավելի պարզ, և Kotlin-ը ավելի շատ նման է Java-ին՝ այնպես, ինչպես կսպասեին Java մշակողները։ Միևնույն ժամանակ պետք է զգուշանալ հնարավոր համատեղելիության խնդիրներից, մասնավորապես, երբ Kotlin-ն ու Java-ն խառնվում են մեկ նախագծում, կամ երբ իրար հետ չկապված գերտիպերը հայտարարում են բախվող default իրականացումներ։
Այս վարքը կառավարվում է նոր կայուն jvmDefault կոմպիլյատորի տարբերակով, որը փոխարինում է ավելի հին -Xjvm-default դրոշակին (այժմ՝ հնացած), օրինակ.
// build.gradle.kts
kotlin {
compilerOptions {
jvmDefault = JvmDefaultMode.ENABLE
}
}
JvmDefaultMode-ն առաջարկում է հետևյալ տարբերակները.
- Enable – Kotlin 2.2-ի կանխադրվածը։ Default մեթոդները թողարկվում են անմիջապես ինտերֆեյսներում, մինչդեռ համատեղելիության կամուրջները և
DefaultImplsդասերը շարունակում են գեներացվել՝ ավելի հին Kotlin կամ Java կոդի հետ երկուական համատեղելիությունը պահպանելու համար։ - No-compatibility – ինտերֆեյսներում թողարկում է միայն default մեթոդները՝ առանց լրացուցիչ համատեղելիության դասերի. խելամիտ ընտրություն նոր կոդային բազաների համար, որոնք Kotlin-ի ավելի հին տարբերակներ աջակցելու կարիք չունեն։
- Disable – ամբողջությամբ անջատում է ինտերֆեյսներում default մեթոդները՝ վերադառնալով Kotlin 2.2-ից առաջվա վարքին՝ միայն
DefaultImpls-ով։
Կանխադրված կարգավորումը հարմար է նախագծերի մեծ մասին և գեներացված բայթկոդը դարձնում է ավելի պարզ։ Սակայն եթե դուք գրադարաններ եք պահպանում, կարևորում եք համատեղելիությունը կամ աշխատում եք Kotlin-ն ու Java-ն խառնող կոդային բազաներում, լավ է ստուգել, թե որ տարբերակն է ձեզ ավելի հարմար։
Non-local break/continue-ը կայուն է դարձել
break-ի և continue-ի օգտագործումը ոչ լոկալ սկոուպների միջով, օրինակ՝ lambda-ների ներսում, այժմ կայուն հնարավորություն է։
Բարելավված string template-ներ՝ բազմակի դոլարներով
$ նշաններ պահանջող template-ներ կամ DSL-ներ ստեղծելը նախկինում անհարմար էր։ Kotlin 2.2-ում multi-dollar string interpolation-ը դառնում է կայուն։
Ավելի խելացի պայմաններ when արտահայտություններում
Արտահայտիչ, ընթեռնելի when արտահայտություններ գրելն այժմ պարզապես ավելի հեշտ է դարձել։ Kotlin 2.2-ը կայուն է դարձնում guard պայմանները, այնպես որ կարող եք լրացուցիչ պայմաններ ավելացնել անմիջապես առանձին ճյուղերին։
Դեռ թխվում է. փորձարարական և beta հնարավորություններ, որոնք արժե փորձել
Kotlin 2.2-ի ամբողջ բովանդակությունը դեռ պատրաստ չէ production-ի համար։ Նոր ավելացված որոշ հնարավորություններ նշված են որպես փորձարարական. կարող եք փորձարկել դրանք, բայց հետագա տարբերակներում դրանք կարող են փոփոխվել կամ հեռացվել։ Դրանք փորձելու համար պետք է բացահայտ միացնել կոմպիլյատորի տարբերակներով։
Օրինակ՝ context parameters-ի համար անհրաժեշտ է ձեր build-ի կոնֆիգուրացիային ավելացնել -Xcontext-parameters արգումենտը, ինչպես ցույց է տրված «Նախապայմաններ» բաժնում։ Ահա, թե ինչ է առաջարկում Kotlin 2.2-ը ցանկացողին, ով պատրաստ է անցնել կայունության սահմանից այն կողմ։
Context parameters. կախվածությունների փոխանցում առանց խառնաշփոթի
Kotlin 2.2-ը ներմուծում է context parameters-ը՝ լեզվական հնարավորություն, որը հեշտացնում է կոնտեքստային տեղեկատվության փոխանցումը կոդով։ Եթե երբևէ ստիպված եք եղել միևնույն օբյեկտները՝ տվյալների բազայի կապերը, օգտատիրոջ տվյալները կամ feature flag-երը, անցկացնել ֆունկցիաների մի քանի շերտերով, գիտեք, թե որքան արագ է դա ուռճացնում մեթոդների ստորագրությունները։
Context parameters-ի միջոցով կարող եք այդ պահանջները նշել ավելի կոկիկ, ավելի կառուցվածքային ձևով՝ առանց ապավինելու գլոբալ վիճակին կամ կախվածությունները ձեռքով փոխանցելուն։ Դրանք կարելի է կիրառել ֆունկցիաների և հատկությունների (property) վրա՝ հայտարարելու համար, որ որոշակի օբյեկտներ պետք է առկա լինեն շրջակա սկոուպում։ Ֆունկցիայի կամ հատկության մարմնի ներսում այդ օբյեկտները անուղղակիորեն հասանելի են՝ առանց բացահայտ պարամետրերի տեսքով փոխանցելու անհրաժեշտության։
Ֆունկցիաների համար շարահյուսությունը հետևյալն է.
interface Dependency {
fun doSomething()
}
interface OtherDependency {
fun doSomethingElse()
}
context(dependency: Dependency, otherDependency: OtherDependency)
fun someFunction() {
// dependency and otherDependency are available implicitly
dependency.doSomething()
otherDependency.doSomethingElse()
}
Իսկ հատկությունների համար context շարահյուսությունը այսպիսին է.
interface Config {
fun isEnabled(feature: String): Boolean
}
context(config: Config)
val isFeatureEnabled: Boolean
get() = config.isEnabled("someFeature")
Այս հնարավորությունը պահում է ձեր կոդը կոկիկ այն դեպքերում, երբ կախվածությունների բացահայտ փոխանցումը ֆունկցիաների ստորագրությունները անհարկի երկար կդարձներ։ Սա հարմար լուծում է, երբ ուզում եք, որ կոնֆիգուրացիան, feature flag-երը կամ տեխնիկական սերվիսները հասանելի լինեն ֆունկցիայի կամ հաշվարկվող հատկության ներսում՝ առանց դրանք ձեր կոդի յուրաքանչյուր շերտով տարածելու։
Context parameters-ը թույլ է տալիս այդ պահանջները նշել բացահայտ՝ հենց այնտեղ, որտեղ դրանք վերաբերում են, և ոչ մի այլ տեղ։ Առայժմ context parameters-ը աշխատում է միայն ֆունկցիաների և հատկությունների հետ։ Քանի որ հնարավորությունը դեռ փորձարարական է, դրա կարողությունները կարող են փոխվել Kotlin-ի առաջիկա թողարկումներում։
Ահա ավելի իրատեսական օրինակ՝ վերցված բազմաշերտ համակարգից.
interface UserContext {
fun currentUser(): String
fun hasRole(role: String): Boolean
}
interface FeatureFlags {
fun isEnabled(feature: String): Boolean
}
interface TransactionManager {
fun <T> inTransaction(fn: () -> T): T
}
class AccountFacade(
private val transactionManager: TransactionManager,
private val accountDeletionService: AccountDeletionService
) {
context(_: UserContext, _: FeatureFlags)
fun deleteAccount(accountId: String) {
transactionManager.inTransaction {
accountDeletionService.deleteAccount(accountId)
}
}
}
class AccountDeletionService {
context(featureFlags: FeatureFlags)
private val isDeleteAccountEnabled: Boolean
get() = featureFlags.isEnabled("deleteAccount")
context(userContext: UserContext, featureFlags: FeatureFlags)
fun deleteAccount(accountId: String) {
if (isDeleteAccountEnabled) {
ensureAdmin()
// perform account deletion logic
println("Account $accountId deleted by user ${userContext.currentUser()}.")
} else {
throw FeatureDisabledException("Account deletion is not enabled.")
}
}
context(userContext: UserContext)
private fun ensureAdmin() {
require(userContext.hasRole("ADMIN")) {
"User ${userContext.currentUser()} does not have ADMIN role."
}
}
}
Այս օրինակում.
UserContextևFeatureFlagsկախվածությունները հասանելի են հենց այնտեղ, որտեղ դրանք պահանջվում են։- Անհրաժեշտություն չկա այս կախվածությունները ձեռքով փոխանցել ֆունկցիայի յուրաքանչյուր կանչով։
- Context parameters-ը հստակ նշում է, թե ինչ է պետք յուրաքանչյուր ֆունկցիային՝ կանչվելու համար, առանց գլոբալ վիճակից կամ թաքնված կախարդանքից կախված լինելու։
- Նաև կնկատեք ընդգծման նշանը (
_), որն օգտագործվում է անանուն context parameters-ի համար. դրանք անհրաժեշտ են ռեզոլյուցիայի համար, բայց անմիջապես չեն օգտագործվում։ Սա թույլ է տալիս կոմպիլյատորին դրանք փոխանցել հետագա՝ առանց սկոուպում չօգտագործվող անուններ ավելացնելու։ Սա օգտակար է, երբ կախվածությունները փոխանցում եք հետագա կանչերին՝ առանց ինքներդ դրանք օգտագործելու։ Սա երևում էAccountFacade.deleteAccount(accountId: String)մեթոդում, որտեղUserContext-ը ևFeatureFlags-ը երկուսն էլ հայտարարված են որպես անանուն context parameters՝_-ով։
Այս նմուշով ավելի հեշտ է կառուցել շերտավոր համակարգեր՝ հստակ սահմաններով և մաքուր ֆունկցիայի ստորագրություններով, մանավանդ երբ գործ ունենք այնպիսի տեխնիկական հարցերի հետ, ինչպիսիք են անվտանգությունը, կոնֆիգուրացիան կամ feature toggle-ները։ Ահա թե ինչպես է նման ֆունկցիայի կանչը երևում գործնականում. դուք մեկ անգամ տրամադրում եք պահանջվող context օբյեկտները, և դրանց վրա ապավինող ցանկացած ֆունկցիա կարող է դրանք անուղղակիորեն օգտագործել։
Ստորև բերված է օրինակ, որը ցույց է տալիս, թե ինչպես է այս նմուշը գործնականում պարզեցնում գործերը.
val userContext = object : UserContext {
override fun currentUser() = "john.doe"
override fun hasRole(role: String) = role == "ADMIN"
}
val featureFlags = object : FeatureFlags {
override fun isEnabled(feature: String) = feature == "deleteAccount"
}
val transactionManager = object : TransactionManager {
override fun <T> inTransaction(fn: () -> T): T = fn()
}
val accountFacade = AccountFacade(
transactionManager = transactionManager,
accountDeletionService = AccountDeletionService()
)
context(userContext, featureFlags) {
accountFacade.deleteAccount("12345")
}
Այս նմուշը թույլ է տալիս կոնտեքստը ստեղծել մեկ անգամ, ապա կանչել ֆունկցիաներ՝ առանց միևնույն օբյեկտները բազմիցս փոխանցելու։ Ձեր կոդը մնում է ընթեռնելի և ազատ boilerplate-ից, մանավանդ ընդհանուր կոնտեքստային կախվածություններ կիսող համակարգերում։
Տիպով առաջնորդվող ավելի խելացի ռեզոլյուցիա՝ ավելի կոկիկ կոդի համար
Kotlin 2.2-ը բերում է context-sensitive resolution՝ փորձարարական հնարավորություն, որը հեշտացնում է enum-ների, sealed class-երի և object հայտարարությունների հետ աշխատանքը, երբ կոմպիլյատորն արդեն գիտի սպասվող տիպը։ Մինչ այժմ, նույնիսկ երբ կոնտեքստը տիպը լիովին պարզ էր դարձնում, դեռ պետք էր գրել enum հաստատունների կամ sealed class անդամների լրիվ անունը։ Context-sensitive resolution-ի դեպքում կոմպիլյատորը ապավինում է շրջակա կոդի տիպային տեղեկատվությանը՝ այդ անունները ձեզ համար ռեզոլվ անելու համար, ուստի կոդը դառնում է ավելի կարճ և պակաս կրկնվող։ Այն փորձելու համար պետք է կոմպիլյատորի կոնֆիգուրացիային ավելացնել -Xcontext-sensitive-resolution արգումենտը։
Ստորև՝ արագ համեմատություն, թե ինչպես է աշխատանքը enum-ների հետ նախկինում և context-sensitive resolution-ը միացրած։ Ահա թե ինչպես է դա երևում այսօր՝ առանց context-sensitive resolution-ի.
enum class BinaryDigit {
ONE,
ZERO,
}
fun toInt(binaryDigit: BinaryDigit): Int = when (binaryDigit) {
BinaryDigit.ONE -> 1
BinaryDigit.ZERO -> 0
}
fun fromInt(value: Int): BinaryDigit = when (value) {
1 -> BinaryDigit.ONE
0 -> BinaryDigit.ZERO
else -> throw IllegalArgumentException("Invalid binary digit value: $value")
}
Իսկ ահա նույն when արտահայտությունը՝ context-sensitive resolution-ը միացրած.
fun toInt(binaryDigit: BinaryDigit): Int = when (binaryDigit) {
ONE -> 1
ZERO -> 0
}
fun fromInt(value: Int): BinaryDigit = when (value) {
1 -> ONE
0 -> ZERO
else -> throw IllegalArgumentException("Invalid binary digit value: $value")
}
Առաջին բանը, որ հավանաբար կնկատեք, այն է, որ context-sensitive resolution-ի դեպքում when արտահայտության ներսում enum հաստատունների համար բացահայտ BinaryDigit որակավորիչն այլևս պարտադիր չէ։ Կոդը նկատելիորեն ավելի կարճ է, ավելի հեշտ ընթեռնելի և պակաս կրկնվող։ Բայց հնարավորությունը ավելին է անում, քան պարզապես enum-ների օգտագործումը պարզեցնելը։ Շրջակա տիպային կոնտեքստն օգտագործելով՝ Kotlin կոմպիլյատորն այժմ անունները ավելի լավ է ռեզոլվ անում բազմաթիվ բնորոշ սցենարներում։ Մասնավորապես, այն հաշվի է առնում արգումենտներից, վերադարձվող տիպերից, հայտարարություններից և նմանատիպ կառուցվածքներից եկող սպասվող տիպերը՝ անունները ավտոմատ ռեզոլվ անելու համար։
Հետևաբար, դրանից օգուտ են քաղում հետևյալ լեզվական հնարավորությունները.
- when արտահայտությունների պայմանները, որոնց սուբյեկտի տիպը հայտնի է
- is-ով տիպերի ստուգումները
- return հայտարարությունները՝ թե՛ անուղղակի, թե՛ բացահայտ
- հավասարության ստուգումներ, ինչպիսիք են == և !=
- վերագրումներ և սկզբնավորումներ
- ֆունկցիաների կանչեր՝ սպասվող արգումենտների տիպերով։
Այս հնարավորությունը համառոտ ամփոփելու համար. context-sensitive resolution-ը թույլ է տալիս կոմպիլյատորին ավտոմատ ռեզոլվ անել enum անդամների, sealed class անդամների և object հայտարարությունների անունները՝ օգտագործելով շրջակա կոնտեքստի սպասվող տիպը։ Այն վերացնում է կրկնվող լրիվ որակավորված անունների անհրաժեշտությունը և կոդը դարձնում ավելի պարզ՝ պահպանելով տիպային անվտանգությունը։
Այլևս կրկնօրինակված անոտացիաներ՝ @all-ի շնորհիվ
Kotlin-ում հատկությունների անոտացիան կարող է ավելի բարդ լինել, քան թվում է։ Պատճառն այն է, որ մեկ val կամ var հայտարարությունը հաճախ համապատասխանում է մի քանի տարրի՝ դաշտ (field), getter, setter և նույնիսկ կոնստրուկտորի պարամետր, երբ հայտարարված է primary կոնստրուկտորում։ Որպեսզի ձեր սեփական անոտացիան կիրառվեր դրանք բոլորի վրա, նախկինում պետք էր ձեռքով թվարկել բոլոր հնարավոր թիրախները, օրինակ.
@Target(
AnnotationTarget.FIELD,
AnnotationTarget.PROPERTY,
AnnotationTarget.PROPERTY_GETTER,
AnnotationTarget.PROPERTY_SETTER,
AnnotationTarget.VALUE_PARAMETER
)
annotation class HexColor
Kotlin 2.2-ը թույլ է տալիս սա պարզեցնել նոր փորձարարական @all մետա-թիրախով։ Դուք հատկությունը անոտացիա եք անում մեկ անգամ, և անոտացիան ավտոմատ կիրառվում է հատկության բոլոր համապատասխան մասերի վրա։ Ի՞նչ տարբերություն է սա ստեղծում գործնականում։ Եկեք արագ համեմատենք, թե ինչպես էին նախկինում անոտացիա անում հատկությունները, և ինչպես է @all մետա-թիրախը դա պարզեցնում
Մինչև Kotlin 2.2՝ կրկնվող, ձեռքով անոտացիա յուրաքանչյուր թիրախի համար.
data class Square(
@field:HexColor
@property:HexColor
@get:HexColor
@param:HexColor
val backgroundColor: String
) {
@field:HexColor
@property:HexColor
@get:HexColor
@set:HexColor
var borderColor: String = backgroundColor
}
Kotlin 2.2-ում @all մետա-թիրախի օգտագործմամբ վերը բերված կոդը կարելի է կրճատել մինչև.
data class Square(
// applies @HexColor to field, property, get, param and set - depending if it's var
@all:HexColor
val backgroundColor: String
) {
// applies @HexColor to field, property, get and set
// param is not applicable here since it's not a constructor parameter
@all:HexColor
var borderColor: String = backgroundColor
}
@all-ը երաշխավորում է, որ անոտացիան հետևողականորեն կիրառվի հատկության յուրաքանչյուր համապատասխան մասի վրա, ուստի պետք չէ կրկնվել այնպիսի թիրախների միջև, ինչպիսիք են դաշտերը, getter-ները կամ կոնստրուկտորի պարամետրերը։ Սա հատկապես օգտակար է վալիդացիայի, սերիալիզացիայի կամ կոդի գեներացիայի համար օգտագործվող սեփական անոտացիաների դեպքում։
Մեր օրինակում ձեր վալիդացիայի տրամաբանությունը կամ կոմպիլյացիայի ժամանակվա գործիքը հետագայում կարող է մշակել @HexColor-ը՝ ստուգելու, որ գույների արժեքները համապատասխանում են սպասվող HEX ձևաչափին։
Քանի որ @all-ը Kotlin 2.2-ում փորձարարական է, այն պետք է բացահայտ միացվի ձեր նախագծում։ Դա անելու համար ավելացրեք -Xannotation-target-all կոմպիլյատորի տարբերակը նույն ձևով, ինչպես նկարագրված է վերևի «Նախապայմաններ» բաժնում։
Օգնական տիպերը պահեք իրենց տեղում՝ nested type alias-ներով
Եթե երբևէ Kotlin DSL եք կառուցել, հավանաբար դիմել եք typealias-ին՝ տգեղ ընդհանրացված (generic) ստորագրությունները կոկիկացնելու համար։ Եվ եթե դա արել եք վերօգտագործելի builder դասում, հավանաբար ցանկացել եք, որ այդ alias-ները ապրեն դասի ներսում, այլ ոչ թե խճողեն վերին մակարդակի անվանատարածքը։ Kotlin 2.2-ը վերջապես դա թույլ է տալիս։
Շնորհիվ nested type alias-ների նոր աջակցության՝ type alias-ները այժմ կարելի է հայտարարել դասերի, օբյեկտների կամ ինտերֆեյսների ներսում, պայմանով, որ alias-ը անուղղակիորեն չի գրավում ընդգրկող հայտարարության տիպի պարամետրը։ Այդ սահմանափակումից բացի՝ հնարավորությունը ձեզ շատ ավելի ազատություն է տալիս ներքին API-ները և DSL-ները կառուցվածքավորելիս։ Դիտարկենք գործնական օրինակ։ Պատկերացրեք, որ գրում եք թեթև վալիդացիայի DSL.
typealias Predicate<T> = (T) -> Boolean
typealias Rule<T> = Pair<String, Predicate<T>>
typealias Error = String
typealias Validator<T> = (T) -> List<Error>
class ValidatorBuilder<T> {
private val rules = mutableListOf<Rule<T>>()
fun rule(error: Error, predicate: Predicate<T>) {
rules += error to predicate
}
fun build(): Validator<T> = { value ->
rules.filterNot { (_, predicate) -> predicate(value) }
.map { (msg, _) -> msg }
}
}
Սա աշխատում է, բայց յուրաքանչյուր type alias գտնվում է վերին մակարդակում։ Փաթեթը ավելի է խճողվում, և բացահայտվում են իրականացման մանրամասներ, որոնք կարևոր են միայն builder-ի ներսում։ Kotlin 2.2-ը թույլ է տալիս սա կոկիկացնել.
class ValidatorBuilder<T> {
typealias Predicate<T> = (T) -> Boolean
typealias Rule<T> = Pair<String, Predicate<T>>
typealias Error = String
typealias Validator<T> = (T) -> List<Error>
private val rules = mutableListOf<Rule<T>>()
fun rule(error: Error, predicate: Predicate<T>) {
rules += error to predicate
}
fun build(): Validator<T> = { value ->
rules.filterNot { (_, predicate) -> predicate(value) }
.map { (msg, _) -> msg }
}
}
Այժմ ամեն ինչ սահմանափակված է այնտեղ, որտեղ իրոք օգտագործվում է։ Ներքին անունները այլևս անտեղի չեն արտահոսում։ Ավտոլրացումը դառնում է ավելի տեղին, ֆայլում կողմնորոշվելը՝ ավելի հեշտ, իսկ ձեր կոդը՝ ավելի հետևողական։ Հիշեք, որ nested type alias-ները չեն կարող անուղղակիորեն հղվել ընդգրկող սկոուպի տիպի պարամետրերին։
Երբ ձեր alias-ը հենվում է generic-ի վրա, այն պետք է հայտարարվի բացահայտ.
class ValidatorBuilder<T> {
// Not allowed – captures T implicitly
// typealias Predicate = (T) -> Boolean
// Allowed – declares T directly
typealias Predicate<T> = (T) -> Boolean
}
Մի քանի կանոն արժե հիշել.
- Բոլոր սովորական typealias կանոնները շարունակում են գործել։
- Դրանք չեն կարող ավելի տեսանելի լինել, քան այն տիպերը, որոնց alias-ն են։
- Դրանք սկոուպավորվում են ինչպես nested դասերը, ուստի կարող են ստվերել արտաքին alias-ները
- Անհրաժեշտության դեպքում կարող եք դրանք նշել
internalկամprivate։ - Դրանք չեն աջակցվում Kotlin Multiplatform-ի
expect/actualհայտարարություններում։
Սա փոքր փոփոխություն է, որը ձեր կոդը դարձնում է ավելի գիտակցված. պակաս աղմուկ, ավելի շատ կառուցվածք։ Այս փոխզիջումը լիովին արժե։ Քանի որ հնարավորությունը դեռ beta է, այն պետք է ձեռքով միացնել՝ կոմպիլյատորի արգումենտներին ավելացնելով -Xnested-type-aliases արգումենտը, ինչպես բացատրված էր ավելի վաղ «Նախապայմաններ» բաժնում։
Եզրափակիչ մտքեր Kotlin 2.2-ի մասին
Kotlin 2.2-ը գուցե վերնագրեր չստեղծի, բայց արժե ուշադիր նայել։ Մի քանի երկար սպասված հնարավորություններ, ինչպիսիք են non-local control flow-ն և when-ում guard պայմանները, վերջապես կայուն են դարձել։ Մյուսները, ինչպիսիք են context parameters-ը, ավելի խելացի անունների ռեզոլյուցիան կամ նոր @all մետա-թիրախը, վկայում են այն մասին, որ լեզուն շարունակում է դառնալ ավելի արտահայտիչ և հարմար։
Նույնիսկ ավելի մասնագիտացված փոփոխությունները, ինչպիսիք են nested type alias-ները կամ JVM մեթոդների գեներացիայի ճշգրտումները, ցույց են տալիս, որ Kotlin թիմը շարունակում է լսել, թե ինչ է իրոք պետք մշակողներին, և վերանայում է հին կանխադրվածները, երբ դա իմաստ ունի։
Անկախ նրանից՝ production կոդ եք գրում, DSL-ներ եք նախագծում, թե պարզապես թարմ եք պահում ձեր գործիքակազմը, Kotlin 2.2-ը առաջարկում է իմաստալից բարելավումներ, որոնք արժե ուսումնասիրել։ Եվ եթե Kotlin-ը ձեզ համար բոլորովին նոր է, սա բավականին լավ պահ է՝ սուզվելու համար։