book

The Joy of Kotlin

by Pierre-Yves Saumont

April 2019

Intermediate to advanced

480 pages

13h 22m

English

Manning Publications

Read now

Unlock full access

prefaceacknowledgmentsabout this bookWho should read this bookWhat you’ll learnPushing abstraction furtherImmutabilityReferential transparencyEncapsulated state mutation sharingAbstracting control flow and control structuresUsing the right typesLazinessAudienceHow this book is organized: A roadmapCompleting the exercisesLearning the techniques in this bookAbout the codeliveBook discussionabout the authorabout the cover illustration
1.1 Programming traps1.1.1 Safely handling effects1.1.2 Making programs safer with referential transparency1.2 The benefits of safe programming1.2.1 Using the substitution model to reason about programs1.2.2 Applying safe principles to a simple example1.2.3 Pushing abstraction to the limitSummary
2.1 Fields and variables in Kotlin2.1.1 Omitting the type to simplify2.1.2 Using mutable fields2.1.3 Understanding lazy initialization2.2 Classes and interfaces in Kotlin2.2.1 Making the code even more concise2.2.2 Implementing an interface or extending a class2.2.3 Instantiating a class2.2.4 Overloading property constructors2.2.5 Creating equals and hashCode methods2.2.6 Destructuring data objects2.2.7 Implementing static members in Kotlin2.2.8 Using singletons2.2.9 Preventing utility class instantiation2.3 Kotlin doesn’t have primitives2.4 Kotlin’s two types of collections2.5 Kotlin’s packages2.6 Visibility in Kotlin2.7 Functions in Kotlin2.7.1 Declaring functions2.7.2 Using local functions2.7.3 Overriding functions2.7.4 Using extension functions2.7.5 Using lambdas2.8 Nulls in Kotlin2.8.1 Dealing with nullable types2.8.2 Elvis and the default value2.9 Program flow and control structures2.9.1 Using conditional selectors2.9.2 Using multi-conditional selectors2.9.3 Using loopsKotlin’s unchecked exceptionsAutomatic resource closureKotlin’s smart castsEquality versus identityString interpolationMulti-line stringsVariance: parameterized types and subtyping2.16.1 Why is variance a potential problem?2.16.2 When to use covariance and when to use contravariance2.16.3 Declaration-site variance versus use-site varianceSummary
3.1 What’s a function?3.1.1 Understanding the relationship between two function sets3.1.2 An overview of inverse functions in Kotlin3.1.3 Working with partial functions3.1.4 Understanding function composition3.1.5 Using functions of several arguments3.1.6 Currying functions3.1.7 Using partially-applied functions3.1.8 Functions have no effects3.2 Functions in Kotlin3.2.1 Understanding functions as data3.2.2 Understanding data as functions3.2.3 Using object constructors as functions3.2.4 Using Kotlin’s fun functionsExactness3.2.5 Using object notation versus functional notation3.2.6 Using value functions3.2.7 Using function references3.2.8 Composing functions3.2.9 Reusing functions3.3 Advanced function features3.3.1 What about functions of several arguments?3.3.2 Applying curried functions3.3.3 Implementing higher-order functions3.3.4 Creating polymorphic HOFsTesting function parameters3.3.5 Using anonymous functions3.3.6 Defining local functions3.3.7 Implementing closures3.3.8 Applying functions partially and automatic currying3.3.9 Switching arguments of partially-applied functionsDeclaring the identity functionUsing the right typesSummary
4.1 Corecursion and recursion4.1.1 Implementing corecursion4.1.2 Implementing recursion4.1.3 Differentiating recursive and corecursive functions4.1.4 Choosing recursion or corecursion4.2 Tail Call Elimination4.2.1 Using Tail Call Elimination4.2.2 Switching from loops to corecursion4.2.3 Using recursive value functions4.3 Recursive functions and lists4.3.1 Using doubly recursive functions4.3.2 Abstracting recursion on lists4.3.3 Reversing a list4.3.4 Building corecursive lists4.3.5 The danger of strictness4.4 Memoization4.4.1 Using memoization in loop-based programming4.4.2 Using memoization in recursive functions4.4.3 Using implicit memoization4.4.4 Using automatic memoization4.4.5 Implementing memoization of multi-argument functions4.5 Are memoized functions pure?Summary
5.1 How to classify data collections5.2 Different types of lists5.3 Relative expected list performance5.3.1 Trading time against memory space and complexity5.3.2 Avoiding in-place mutationUpdate in place5.4 What kinds of lists are available in Kotlin?5.4.1 Using persistent data structures5.4.2 Implementing immutable, persistent, singly linked lists5.5 Data sharing in list operations5.6 More list operations5.6.1 Benefiting from object notation5.6.2 Concatenating lists5.6.3 Dropping from the end of a list5.6.4 Using recursion to fold lists with higher-order functions (HOFs)5.6.5 Using variance5.6.6 Creating a stack-safe recursive version of foldRight5.6.7 Mapping and filtering listsSummary

6.1 Problems with the null pointer6.2 How Kotlin handles null references6.3 Alternatives to null references6.4 Using the Option type6.4.1 Getting a value from an Option6.4.2 Applying functions to optional values6.4.3 Dealing with Option composition6.4.4 Option use cases6.4.5 Other ways to combine options6.4.6 Composing List with Option6.4.7 Using Option and when to do soSummary
7.1 The problems with missing data7.2 The Either type7.3 The Result type7.4 Result patterns7.5 Advanced Result handling7.5.1 Applying predicates7.6 Mapping failures7.7 Adding factory functions7.8 Applying effects7.9 Advanced result compositionSummary
8.1 The problem with length8.2 The performance problem8.3 The benefits of memoization8.3.1 Handling memoization drawbacks8.3.2 Evaluating performance improvements8.4 List and Result composition8.4.1 Handling lists returning Result8.4.2 Converting from List<Result> to Result<List>8.5 Common List abstractions8.5.1 Zipping and unzipping lists8.5.2 Accessing elements by their indexThe zero element8.5.3 Splitting listsWhen not to use folds8.5.4 Searching for sublists8.5.5 Miscellaneous functions for working with lists8.6 Automatic parallel processing of lists8.6.1 Not all computations can be parallelized8.6.2 Breaking the list into sublists8.6.3 Processing sublists in parallelSummary
9.7 Strictness versus laziness9.8 Kotlin and strictness9.9 Kotlin and lazinessLaziness implementations9.10.1 Composing lazy values9.10.2 Lifting functions9.10.3 Mapping and flatMapping Lazy9.10.4 Composing Lazy with List9.10.5 Dealing with exceptionsFurther lazy compositions9.11.1 Lazily applying effects9.11.2 Things you can’t do without laziness9.11.3 Creating a lazy list data structureHandling streams9.12.1 Folding streams9.12.2 Tracing evaluation and function application9.12.3 Applying streams to concrete problemsSummary
10.1 The binary tree10.2 Understanding balanced and unbalanced trees10.3 Looking at size, height, and depth in trees10.4 Empty trees and the recursive definition10.5 Leafy trees10.6 Ordered binary trees or binary search trees10.7 Insertion order and the structure of trees10.8 Recursive and non-recursive tree traversal order10.8.1 Traversing recursive trees10.8.2 Non-recursive traversal orders10.9 Binary search tree implementation10.9.1 Understanding variance and trees10.9.2 What about an abstract function in the Tree class?10.9.3 Overloading operators10.9.4 Recursion in trees10.9.5 Removing elements from trees10.9.6 Merging arbitrary treesAbout folding trees10.10.1 Folding with two functions10.10.2 Folding with a single function10.10.3 Choosing a fold implementationAbout mapping treesAbout balancing trees10.12.1 Rotating trees10.12.2 Using the Day-Stout-Warren algorithm10.12.3 Automatically balancing treesSummary
11.1 Better performance and stack safety with self-balancing trees11.1.1 Understanding the basic red-black tree structure11.1.2 Adding an element to the red-black tree11.1.3 Removing elements from the red-black tree11.2 A use case for the red-black tree: Maps11.2.1 Implementing Map11.2.2 Extending maps11.2.3 Using Map with noncomparable keys11.3 Implementing a functional priority queue11.3.1 Looking at the priority queue access protocol11.3.2 Exploring priority queue use cases11.3.3 Looking at implementation requirements11.3.4 The leftist heap data structure11.3.5 Implementing the leftist heap11.3.6 Implementing the queue-like interface11.4 Elements and sorted lists11.5 A priority queue for noncomparable elementsSummary
12.1 What does effects in context mean?12.1.1 Handling effects12.1.2 Implementing effects12.2 Reading data12.2.1 Reading data from the console12.2.2 Reading from a file12.3 Testing with input12.4 Fully functional input/output12.4.1 Making input/output fully functional12.4.2 Implementing purely functional I/O12.4.3 Combining I/O12.4.4 Handling input with IO12.4.5 Extending the IO type12.4.6 Making the IO type stack-safeSummary
13.1 The actor model13.1.1 Understanding asynchronous messaging13.1.2 Handling parallelization13.1.3 Handling actor state mutation13.2 An actor framework implementation13.2.1 Understanding the limitations13.2.2 Designing the actor framework interfaces13.3 The AbstractActor implementation13.4 Putting actors to work13.4.1 Implementing the Ping Pong example13.4.2 Running a computation in parallel13.4.3 Reordering the results13.4.4 Optimizing performanceSummary
14.1 Assertions and data validation14.2 Retries for functions and effects14.3 Reading properties from a file14.3.1 Loading the property file14.3.2 Reading properties as strings14.3.3 Producing better error messages14.3.4 Reading properties as lists14.3.5 Reading enum values14.3.6 Reading properties of arbitrary types14.4 Converting an imperative program: The XML reader14.4.1 Step 1: The imperative solution14.4.2 Step 2: Making an imperative program more functional14.4.3 Step 3: Making the program even more functional14.4.4 Step 4: Fixing the argument type problem14.4.5 Step 5: Making the element-processing function a parameter14.4.6 Step 6: Handling errors on element names14.4.7 Step 7: Additional improvements to the formerly imperative codeSummary
Creating and managing mixed projectsCreating a simple project with GradleImporting your Gradle project into IntelliJAdding dependencies to your projectCreating multi-module projectsAdding dependencies to a multiple module projectJava library methods and Kotlin codeUsing Java primitivesUsing Java numerical object typesFailing fast on null valuesUsing Kotlin and Java string typesImplementing other type conversionsUsing Java varargsSpecifying nullability in JavaCalling getters and settersAccessing Java properties with reserved namesCalling checked exceptionsSAM interfacesKotlin functions and Java codeConverting Kotlin propertiesUsing Kotlin public fieldsStatic fieldsCalling Kotlin functions as Java methodsConverting types from Kotlin to JavaFunction typesSpecific problems with mixed Kotlin/Java projectsSummary
Why property-based testing?Writing the interfaceWriting the testsWhat is property-based testing?Abstraction and property-based testsDependencies for property-based unit testingWriting property based testsCreating your own custom generatorsUsing custom generatorsSimplifying the code through further abstractionSummary
List of IllustrationsList of TablesList of Listings

Content preview from The Joy of Kotlin

Front matter

preface

Although Kotlin appeared in 2011, it’s one of the newest languages in the Java ecosystem. Since then, a version of Kotlin running on the JavaScript virtual machine as been released, as well as a version compiling to native code. This makes Kotlin a much more universal language than Java, although there are great differences between these versions because the Java version relies upon the Java standard library, which isn’t available in the two others. JetBrains, the creator or Kotlin, is working hard to bring each version to an equivalent level, but this will take some time.

The JVM (Java Virtual Machine) version is by far the most used version, and this has seen a great boost when Google decided to adopt Kotlin as an official ...