Advanced Kotlin

Introduction

1. Who is this book for?
2. The structure of this book
3. That will be covered?
4. The Kotlin for Developers series
5. Conventions
6. Code conventions
7. Exercises and solutions
8. Acknowledgments

Part 1: Advanced Kotlin features

Generic variance modifiers

1. List variance
2. Consumer variance
3. Function types
4. Exercise: Usage of generic types
5. The Covariant Nothing Object
6. The Covariant Nothing Class
7. Variance modifier limitations
8. UnsafeVariance annotation
9. Variance modifier positions
10. Star projection
11. Summary
12. Exercise: Generic Response
13. Exercise: Generic Consumer

Interface delegation

1. The delegation pattern
2. Delegation and inheritance
3. Kotlin interface delegation support
4. Wrapper classes
5. The decorator pattern
6. Intersection types
7. Limitations
8. Conflicting elements from parents
9. Summary
10. Exercise: ApplicationScope

Property delegation

1. How property delegation works
2. Other getValue and setValue parameters
3. Implementing a custom property delegate
4. Provide a delegate
5. Property delegates in Kotlin stdlib
6. The notNull delegate
7. Exercise: Lateinit delegate
8. The lazy delegate
9. Exercise: Blog Post Properties
10. The observable delegate
11. The vetoable delegate
12. A map as a delegate
13. Review of how variables work
14. Summary
15. Exercise: Mutable lazy delegate

Kotlin Contracts

1. The meaning of a contract
2. How many times do we invoke a function from an argument?
3. Implications of the fact that a function has returned a value
4. Using contracts in practice
5. Summary
6. Exercise: Coroutine time measurement

Part 2: Kotlin on different platforms

Java interoperability

1. Nullable types
2. Kotlin type mapping
3. JVM primitives
4. Collection types
5. Annotation targets
6. Static elements
7. JvmField
8. Using Java accessors in Kotlin
9. JvmName
10. JvmMultifileClass
11. JvmOverloads
12. Unit
13. Function types and function interfaces
14. Tricky names
15. Throws
16. JvmRecord
17. Summary
18. Exercise: Adjust Kotlin for Java usage

Using Kotlin Multiplatform

1. Multiplatform module configuration
2. Expect and actual elements
3. Possibilities
4. Multiplatform libraries
5. A multiplatform mobile application
6. Summary
7. Exercise: Multiplatform LocalDateTime

JavaScript interoperability

1. Setting up a project
2. Using libraries available for Kotlin/JS
3. Using Kotlin/JS
4. Building and linking a package
5. Distributing a package to npm
6. Exposing objects
7. Exposing Flow and StateFlow
8. Adding npm dependencies
9. Frameworks and libraries for Kotlin/JS
10. JavaScript and Kotlin/JS limitations
11. Summary
12. Exercise: Migrating a Kotlin/JVM project to KMP

Part 3: Metaprogramming

Reflection

1. Hierarchy of classes
2. Function references
3. Parameter references
4. Property references
5. Class reference
6. Serialization example
7. Referencing types
8. Type reflection example: Random value
9. Kotlin and Java reflection
10. Breaking encapsulation
11. Summary
12. Exercise: Function caller
13. Exercise: Object serialization to JSON
14. Exercise: Object serialization to XML
15. Exercise: DSL-based dependency injection library

Annotation processing

1. Your first annotation processor
2. Hiding generated classes
3. Summary
4. Exercise: Annotation Processing execution measurement wrapper

Kotlin Symbol Processing

1. Your first KSP processor
2. Testing KSP
3. Dependencies and incremental processing
4. Multiple rounds processing
5. Using KSP on multiplatform projects
6. Summary
7. Exercise: KSP execution measurement wrapper

Kotlin Compiler Plugins

1. Compiler frontend and backend
2. Compiler extensions
3. Popular compiler plugins
4. Making all classes open
5. Changing a type
6. Generate function wrappers
7. Example plugin implementations
8. Summary

Static Code Analysers

1. What are Static Analysers?
2. Types of analysers
3. Kotlin Code Analysers
4. Setting up detekt
5. Writing your first detekt Rule
6. Conclusion

Ending

Exercise solutions