Kotlin In-Depth [Vol-I]: A Comprehensive Guide to Modern Multi-Paradigm Language

Cover Page
Title Page
Copyright Page
Dedication
About the Author
Acknowledgement
Preface
Errata
Table of Contents
1. Kotlin: Powerful and Pragmatic
    Structure
    Objective
    What is Kotlin?
        Safe
        Multiparadigm
        Concise and expressive
        Interoperable
        Multiplatform
    Kotlin Ecosystem
        Coroutines
        Testing
        Android Development
        Web Development
        Desktop applications
    Getting started with Kotlin
        Setting up an IntelliJ project
        Using REPL
        Kotlin Playground
    Setting up an Eclipse project
    Conclusion
2. Language Fundamentals
    Structure
    Objective
    Basic syntax
        Comments
        Defining a variable
        Identifiers
        Mutable variables
        Expressions and operators
    Basic types
        Integer types
        Floating-Point types
        Arithmetic operations
        Bitwise operations
        Char type
        Numeric conversions
        Boolean type and logical operations
        Comparison and equality
    Strings
        String templates
        Basic String operations
    Arrays
        Constructing an array
        Using arrays
    Conclusion
3. Defining Functions
    Structure
    Objective
    Functions
        The Anatomy of a Kotlin Function
        Positional versus named arguments
        Overloading and default values
        Varargs
        Function scope and visibility
    Packages and imports
        The packages and directory structure
        Using import directives
    Conditionals
        Making decisions with if statements
        Ranges, progressions, and in operation
        When statements and multiple choice
    Loops
        The while/do-while loop
        Iterables and for loop
        Changing loop control-flow: break and continue
        Nested loops and labels
        Tail-recursive functions
    Exception handling
        Throwing an exception
        Handling errors with try statements
    Conclusion
    Questions
4. Working with Classes and Objects
    Structure
    Objective
    Defining a class
        A class anatomy
        Constructors
        Member visibility
        Nested classes
        Local classes
    Nullability
        Nullable types
        Nullability and smart casts
        Not-null assertion operator
        Safe call operator
        Elvis operator
    Properties: beyond simple variables
        Top-level properties
        Late initialization
        Using custom accessors
        Lazy properties and delegates
    Objects
        Object declarations
        Companion objects
        Object expressions
    Conclusion
    Questions
5. Leveraging Advanced Functions and Functional Programming
    Structure
    Objective
    Functional programming in Kotlin
        Higher-order functions
        Functional types
        Lambdas and anonymous functions
        Callable references
        Inline functions and properties
        Non-local control flow
    Extensions
        Extension functions
    Extension properties
    Companion extensions
        Lambdas and functional types with receiver
    Callable references with receiver
        Scope functions
            run / with functions
            run without context
            apply / also functions
        Extensions as class members
    Conclusion
    Questions
6. Using Special-Case Classes
    Structure
    Objective
    Enum classes
        Exhaustive when expressions
        Declaring enums with custom members
        Using common members of enum classes
    Data classes
        Data classes and their operations
        Destructuring declarations
    Inline classes
        Defining an inline class
        Unsigned integers
    Conclusion
    Questions
7. Exploring Collections and I/O
    Structure
    Objective
    Collections
        Collection types
            Iterables
            Collections, Lists, and Sets
            Sequences
            Maps
        Comparables and Comparators
        Creating a Collection
        Basic operations
        Accessing collection elements
        Collective conditions
        Aggregation
        Filtering
        Transformation
        Extracting subcollections
        Ordering
    Files and I/O streams
        Stream utilities
            Creating streams
        URL utilities
        Accessing file content
        File system utilities
    Conclusion
    Questions
8. Understanding Class Hierarchies
    Structure
    Objective
    Inheritance
        Declaring a subclass
        Subclass initialization
        Type checking and casts
        Common methods
    Abstract classes and interfaces
        Abstract classes and members
        Interfaces
        Sealed classes
        Delegation
    Conclusion
    Questions
9. Generics
    Structure
    Objective
    Type parameters
        Generic declarations
        Bounds and constraints
        Type erasure and reification
    Variance
        Variance: distinguishing producers and consumers
        Variance at the declaration site
        Use-site variance with projections
        Star projections
    Type aliases
    Conclusion
    Questions