book

The Joy of Kotlin

Name: The Joy of Kotlin
Author: Pierre Yves Saumont
ISBN: 9781617295362

by Pierre Yves Saumont

April 2019

Intermediate to advanced

480 pages

13h 22m

English

Manning Publications

Audiobook available

Read now

Unlock full access

The Joy of Kotlin
Copyright
Brief contents
contents
Front matter
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 Making programs safer
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 Functional programming in Kotlin: An overview
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 Programming with functions
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 Recursion, corecursion, and memoization
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 Data handling with lists
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 Dealing with optional data
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 Handling errors and exceptions
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 Advanced list handling
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 Working with laziness
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 More data handling with trees
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 Solving problems with advanced trees
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 Functional input/output
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 Sharing mutable states with actors
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 Solving common problems functionally
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
Appendix A. Mixing Kotlin with Java
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
Appendix B. Property-based testing in Kotlin
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
Index
Lists of Figures, Tables and Listings
List of IllustrationsList of TablesList of Listings

Content preview from The Joy of Kotlin

4 Recursion, corecursion, and memoization

In this chapter

Using recursion and corecursion
Creating recursive functions
Using corecursive (tail recursive) functions
Implementing memoization

Recursive functions are a ubiquitous feature in many programming languages, although those are seldom used in Java. That’s because of the poor implementation of this functionality. Fortunately, Kotlin offers a much better implementation, so that you can use recursion widely.

With recursion, many algorithms are defined recursively. Implementing these algorithms in non-recursive languages consists mainly of translating recursive algorithms into non-recursive ones. Using a language capable of handling recursion not only simplifies coding, but also allows writing ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781617295362Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

The Joy of Kotlin

by Pierre Yves Saumont

4 Recursion, corecursion, and memoization

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.