Lectures

We break down Kotlin scope functions as a set of clear contracts: how let, run, with, apply, also differ; when it or this is used inside the block; and what is returned to the outside—an evaluation result or the original object. We reinforce the choice with short practical examples and discuss common mistakes.

We break down how to write linear processing of nullable values in Kotlin without an “if ladder”: use the safe call ?. with the scope function let, close uncertainty with the Elvis operator ?:, and for a multi-line fallback use run { ... }. Using user input examples, we’ll see where to keep null, where to turn it into a default ( 0, 5), and why !! is almost always worse than an explicit scenario.

We break down how to assemble a simple text analyzer as a sequence of clear type transformations: normalization ( trim(), lowercase(), Regex.replace), tokenization ( split + filter with isNotBlank), counting frequencies via groupingBy. eachCount(), selecting top‑N via entries → sortedByDescending → take, and final report formatting with joinToString, padEnd/ padStart. At the end: common mistakes and how to avoid them.

We break down how to turn a “wall of text transformations” into a readable pipeline: we pin down the input/output of each step ( String → List<String> → Map<String, Int>), extract functions normalizeText/ tokenize/ countTokens/ topN/ formatTop and assemble the pipeline via let( ::...). We also show diagnostics between steps using also without breaking the “purity” of the computational functions.

We break down common pitfalls of Kotlin scope functions: why apply/ also often “eat” the computation result, how nested lambdas turn it/ this into confusion, and when “pretty” chains become unnecessary magic. You will learn to choose the right scope function and read expressions by types and return values.