Project with exercises

Why do we need to use functions as objects?

Defining function types

Using function types

Named parameters

Type aliases

A function type is an interface

Tricky braces

Parameters

Trailing lambdas

Result values

Lambda expression examples

An implicit name for a single parameter

Closures

Lambda expressions vs anonymous functions

Exercise: Function types and literals

Exercise: Observable value

Top-level functions references

Method references

Extension function references

Method references and generic types

Bounded function references

Constructor references

Bounded object declaration references

Function overloading and references

Property references

Exercise: Inferred function types

Exercise: Function references

Support for Java SAM interfaces in Kotlin

Functional interfaces

Inline functions

Inline functions with functional parameters

Non-local return

Crossinline and noinline

Reified type parameters

Inline properties

Costs of the inline modifier

Using inline functions

Exercise: Inline functions

forEach and onEach

filter

map

mapNotNull

flatMap

Exercise: Implement map

Exercise: Optimize collection processing

fold

reduce

sum

withIndex and indexed variants

take, takeLast, drop, dropLast and subList

Exercise: Adding element at position

Getting elements at certain positions

Finding an element

Counting elements

any, all and none

Exercise: Implement shop functions

partition

groupBy

Associating to a map

distinct and distinctBy

Exercise: Prime access list

Sorting: sorted, sortedBy and sortedWith

Sorting mutable collections

Maximum and minimum

shuffled and random

Exercise: Top articles

Exercise: Refactor collection processing

zip and zipWithNext

Windowing

joinToString

Map, Set and String processing

Exercise: Passing students list

Exercise: Best students list

Exercise: Functional Quick Sort

Exercise: Powerset

Exercise: All possible partitions of a set

What is a sequence?

Order is important

Sequences do the minimum number of operations

Sequences can be infinite

Sequences do not create collections at every processing step

When aren’t sequences faster?

What about Java streams?

Kotlin Sequence debugging

Summary

Exercise: Understanding sequences

A function type with a receiver

Simple DSL builders

Using apply

Simple DSL-like builders

Multi-level DSLs

DslMarker

A more complex example

When should we use DSLs?

Summary

Exercise: HTML table DSL

Exercise: Creating user table row

let

Mapping a single object

The problem with member extension functions

Moving an operation to the end of processing

Dealing with nullability

also

takeIf and takeUnless

apply

The dangers of careless receiver overloading

with

run

Using scope functions

Exercise: Using scope functions

Exercise: orThrow

Extension function problems

Introducing context receivers

Use cases

Classes with context receivers

Concerns

Summary

Exercise: Logger

Functions and Arrow Core

Memoization

Testing higher-order functions

Error Handling

Working with nullable types

Working with Result

Working with Either

Data Immutability with Arrow Optics

Exercise solutions