Kotlin Language Documentation (Kotlin)（Z-Library）

【One-Line Pitch】 A practical, reference-style tour of Kotlin's language features and standard library, written for developers who already know how to program and want to write idiomatic, null-safe, concise Kotlin across JVM, JavaScript, and native targets. Best read as a guided reference rather than cover to cover. 【Book Arc】 - **Opening (~0%–10%)**: Establishes Kotlin's multi-target story — JVM, JavaScript (transpiled to ES 5.1), and native — plus the tooling ecosystem (React bindings, dukat for TypeScript definitions, module-system compatibility). Sets the mental model that Kotlin is one language with shared stdlib semantics across platforms. - **Early (~10%–32%)**: Core language fundamentals in reading order: string templates, if-as-expression, nullable types and null checks, coding conventions and formatting, numeric types and literals (no implicit widening), imports and visibility, constructors and initializer blocks, extensions (including member extensions and dispatch vs. extension receivers), generics with bounds and star-projections, and experimental inline classes. - **Middle (~32%–48%)**: Intermediate-to-advanced features: delegated properties (including map-backed and local delegated properties), local and member functions, inline functions with `noinline` and reified-style trade-offs, and the collections model — read-only vs. mutable references, member vs. extension operations, and the standard library's operation vocabulary. - **Late (~48%–end)**: The excerpts thin out here; later material appears to continue standard-library coverage (collection operations such as filtering, transformation, search, sorting) and likely coroutines, interop, and platform-specific guides, but the excerpts do not cover those in detail. 【Key Takeaways】 - **Null safety is a type-system feature, not a convention** (Early): nullable references must be marked explicitly, and smart casts after null checks remove boilerplate — this is Kotlin's signature safety win over Java. - **Expressions over statements** (Early): `if`, `when`, and similar constructs return values, enabling concise function bodies and cleaner branching logic. - **No implicit numeric widening** (Early): `Double` parameters reject `Int`/`Float` arguments; explicit conversions are required, which prevents silent precision bugs but demands attention when porting Java code. - **Extensions are static and receiver-aware** (Early): extension functions can be declared as members, creating dispatch-receiver vs. extension-receiver resolution rules; extension receiver wins name conflicts, resolved via qualified `this`. - **Inline functions trade code size for performance** (Middle): marking higher-order functions `inline` eliminates lambda object allocation and virtual calls, especially valuable in loops; `noinline` gives per-parameter control. - **Delegated properties enable reusable property logic** (Middle): `by` supports lazy initialization, map-backed properties (useful for JSON-like data), and local delegated variables since 1.1. - **Collections separate read-only interfaces from mutable implementations** (Middle): a `List` reference to a `MutableList` blocks mutation at compile time while sharing the same underlying instance — a compile-time discipline, not a deep copy. - **Multiplatform consistency is a design goal** (Opening): the compiler aims for small, readable JS output and stdlib parity across JVM and JS, so language knowledge transfers across targets. 【Reading Tips】 - **Skim the "What's New" changelog sections** (1.1, 1.2, 1.3 features like contracts and inline classes); they read as release notes and are best used to spot features you haven't adopted, not read linearly. - **Deep-read the null-safety, extensions, and inline-function chapters** — these are where Kotlin diverges most from Java and where misconceptions are costliest. - **Treat the coding conventions chapter as a checklist** and configure the IntelliJ formatter to the Kotlin style guide early; it makes later examples feel natural. - **Use the collections chapter as a lookup table** while coding rather than memorizing; note the member-vs-extension distinction to understand what custom implementations must provide. - **Watch for experimental markers** (contracts, inline classes) and check stability status before using them in production. 【Coverage Limits】 The excerpts cover roughly the first half of the book — language fundamentals, extensions, generics, inline functions, and early collections material — with later chapters (coroutines, interop details, platform guides) only hinted at. This guide does not cover content beyond ~48% of the book.