𝙺𝚘𝚝𝚕𝚒𝚗𝙰𝚕𝚌𝚑𝚎𝚖𝚢

⚗️ 𝚃𝚑𝚒𝚜 𝚙𝚛𝚘𝚓𝚎𝚌𝚝 𝚌𝚘𝚗𝚝𝚊𝚒𝚗𝚜 𝚟𝚊𝚛𝚒𝚘𝚞𝚜 𝚌𝚘𝚗𝚌𝚎𝚙𝚝𝚜 𝚊𝚗𝚍 𝚕𝚎𝚊𝚛𝚗𝚒𝚗𝚐𝚜 𝚘𝚏 𝚔𝚘𝚝𝚕𝚒𝚗 𝚞𝚜𝚎𝚍 𝚏𝚘𝚛 𝚊𝚗𝚍𝚛𝚘𝚒𝚍 𝚍𝚎𝚟𝚎𝚕𝚘𝚙𝚖𝚎𝚗𝚝

𝙲𝙾𝙽𝚃𝙴𝙽𝚃𝚂
𝙺𝚘𝚝𝚕𝚒𝚗 𝙱𝚊𝚜𝚒𝚌 𝙵𝚞𝚗𝚍𝚊𝚖𝚎𝚗𝚝𝚊𝚕𝚜
𝙺𝚘𝚝𝚕𝚒𝚗 𝚌𝚘𝚕𝚕𝚎𝚌𝚝𝚒𝚘𝚗 𝚏𝚞𝚗𝚌𝚝𝚒𝚘𝚗𝚜
𝙺𝚘𝚝𝚕𝚒𝚗 𝙿𝚘𝚠𝚎𝚛𝚜
𝙺𝚘𝚝𝚕𝚒𝚗 𝙲𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜

Kotlin Basic Fundamentals

• 𝚄𝚜𝚒𝚗𝚐 𝚅𝙰𝙻 𝚊𝚗𝚍 𝚅𝙰𝚁 𝚒𝚗 𝚔𝚘𝚝𝚕𝚒𝚗
• 𝚄𝚜𝚒𝚗𝚐 (𝚅𝙰𝙻) 𝚊𝚗𝚍 (𝙲𝙾𝙽𝚂𝚃 𝚅𝙰𝙻) 𝚒𝚗 𝙺𝚘𝚝𝚕𝚒𝚗
• 𝚄𝚜𝚒𝚗𝚐 𝚂𝚝𝚛𝚒𝚗𝚐𝚜 𝚒𝚗 𝙺𝚘𝚝𝚕𝚒𝚗
• 𝚄𝚜𝚒𝚗𝚐 𝚌𝚘𝚖𝚙𝚊𝚛𝚒𝚜𝚘𝚗 𝚘𝚙𝚎𝚛𝚊𝚝𝚘𝚛𝚜
• 𝚆𝚑𝚊𝚝 𝚒𝚜 𝚝𝚑𝚎 𝚜𝚌𝚘𝚙𝚎 𝚒𝚗 𝚔𝚘𝚝𝚕𝚒𝚗
• 𝙻𝚊𝚛𝚐𝚎 𝚝𝚛𝚎𝚎 𝚘𝚏 𝚌𝚘𝚗𝚍𝚒𝚝𝚒𝚘𝚗 𝚜𝚝𝚊𝚝𝚎𝚖𝚎𝚗𝚝𝚜
• 𝙳𝚎𝚏𝚒𝚗𝚒𝚗𝚐 𝚊𝚗𝚍 𝚞𝚜𝚒𝚗𝚐 𝙽𝚞𝚕𝚕𝚊𝚋𝚕𝚎 𝚟𝚊𝚕𝚞𝚎𝚜
• 𝚆𝚑𝚊𝚝 𝚊𝚛𝚎 𝚙𝚊𝚒𝚛𝚜 𝚊𝚗𝚍 𝚝𝚛𝚒𝚙𝚕𝚎𝚝𝚜
• 𝙼𝚎𝚖𝚋𝚎𝚛 𝚁𝚎𝚏𝚎𝚛𝚎𝚗𝚌𝚎 𝚒𝚗 𝙺𝚘𝚝𝚕𝚒𝚗: 𝚄𝚜𝚒𝚗𝚐 (::) 𝙾𝚙𝚎𝚛𝚊𝚝𝚘𝚛
• 𝚆𝚑𝚊𝚝 𝚊𝚛𝚎 𝚝𝚑𝚎 𝚍𝚒𝚏𝚏𝚎𝚛𝚎𝚗𝚌𝚎𝚜 𝚋𝚎𝚝𝚠𝚎𝚎𝚗 𝚊𝚗 𝙴𝚚𝚞𝚊𝚕𝚒𝚝𝚢 𝙾𝚙𝚎𝚛𝚊𝚝𝚘𝚛 𝚊𝚗𝚍 𝚊 𝚁𝚎𝚏𝚎𝚛𝚎𝚗𝚝𝚒𝚊𝚕 𝙴𝚚𝚞𝚊𝚕𝚒𝚝𝚢 𝙾𝚙𝚎𝚛𝚊𝚝𝚘𝚛?
• 𝙻𝚘𝚘𝚙𝚒𝚗𝚐 𝚖𝚎𝚌𝚑𝚊𝚗𝚒𝚜𝚖𝚜 𝚒𝚗 𝚔𝚘𝚝𝚕𝚒𝚗
• 𝙲𝚞𝚜𝚝𝚘𝚖 𝙰𝚌𝚌𝚎𝚜𝚜𝚘𝚛𝚜 𝚒𝚗 𝚔𝚘𝚝𝚕𝚒𝚗
• 𝙴𝚗𝚞𝚖 𝚒𝚗 𝙺𝚘𝚝𝚕𝚒𝚗
• Classes and Interfaces
  • 𝙲𝚕𝚊𝚜𝚜𝚎𝚜
  • 𝙸𝚗𝚑𝚎𝚛𝚒𝚝𝚊𝚗𝚌𝚎
• Kotlin Basic collections
  • 𝚄𝚜𝚒𝚗𝚐 𝚊𝚛𝚛𝚊𝚢𝚜 𝚒𝚗 𝚝𝚑𝚎 𝚌𝚘𝚍𝚎
  • 𝚄𝚜𝚒𝚗𝚐 𝚕𝚒𝚜𝚝 𝚒𝚗 𝚝𝚑𝚎 𝚌𝚘𝚍𝚎
  • 𝚄𝚜𝚒𝚗𝚐 𝙼𝚊𝚙 𝚒𝚗 𝚝𝚑𝚎 𝚌𝚘𝚍𝚎
  • 𝚄𝚜𝚒𝚗𝚐 𝚂𝚎𝚝 𝚒𝚗 𝚝𝚑𝚎 𝚌𝚘𝚍𝚎

Kotlin Collection Functions

Operation	Operators
Removing Duplicates	distinct , toSet . toMutableSet, toHashSet
Combining a list of items to a string	joinToString
Transform a collection into a single result	reduce
Find if all elements are satisfying a particular condition	all
Find a particular element based on a certain condition	single,all
Break the list of items to sub‐chunks of items	chunked
Associating the data using some key	AssociateBy
Using the Intersection and Union	union,intersect
Sorting a collection of objects based on a parameter in the object	sortBy

Kotlin Powers

🪴	🍀	🌿
𝙺𝚘𝚝𝚕𝚒𝚗 𝚂𝚌𝚘𝚙𝚎 𝙵𝚞𝚗𝚌𝚝𝚒𝚘𝚗𝚜	𝙺𝚘𝚝𝚕𝚒𝚗: 𝙲𝚕𝚊𝚜𝚜 𝚟𝚜 𝙳𝚊𝚝𝚊𝙲𝚕𝚊𝚜𝚜	𝚂𝚎𝚊𝚕𝚎𝚍 𝚌𝚕𝚊𝚜𝚜𝚎𝚜
𝙷𝚒𝚐𝚑𝚎𝚛-𝚘𝚛𝚍𝚎𝚛 𝚏𝚞𝚗𝚌𝚝𝚒𝚘𝚗𝚜	𝙺𝚘𝚝𝚕𝚒𝚗 𝙾𝚋𝚓𝚎𝚌𝚝	𝙺𝚘𝚝𝚕𝚒𝚗 𝙲𝚘𝚖𝚙𝚊𝚗𝚒𝚘𝚗 𝙾𝚋𝚓𝚎𝚌𝚝
𝙰𝚗𝚗𝚘𝚝𝚊𝚝𝚒𝚘𝚗𝚜 𝚒𝚗 𝚔𝚘𝚝𝚕𝚒𝚗	𝚃𝚢𝚙𝚎 𝙰𝚕𝚒𝚊𝚜	𝙸𝚗𝚕𝚒𝚗𝚎 𝙵𝚞𝚗𝚌𝚝𝚒𝚘𝚗
𝚂𝚖𝚊𝚛𝚝 𝙲𝚊𝚜𝚝𝚜	𝙽𝚎𝚜𝚝𝚎𝚍 𝚌𝚕𝚊𝚜𝚜 𝚟𝚜 𝙸𝚗𝚗𝚎𝚛 𝚌𝚕𝚊𝚜𝚜	𝚂𝚎𝚊𝚕𝚎𝚍 𝙲𝚕𝚊𝚜𝚜
𝙰𝚗𝚗𝚘𝚝𝚊𝚝𝚒𝚘𝚗𝚜 𝚒𝚗 𝚔𝚘𝚝𝚕𝚒𝚗	𝙶𝚎𝚗𝚎𝚛𝚒𝚌𝚜	𝚁𝚎𝚒𝚏𝚒𝚎𝚍
𝙲𝚛𝚘𝚜𝚜𝚕𝚒𝚗𝚎 𝚖𝚘𝚍𝚒𝚏𝚒𝚎𝚛	𝚍𝚎𝚕𝚎𝚐𝚊𝚝𝚒𝚘𝚗 𝚒𝚗 𝚔𝚘𝚝𝚕𝚒𝚗	𝚂𝚎𝚚𝚞𝚎𝚗𝚌𝚎𝚜
noinline	𝚆𝚑𝚊𝚝 𝚊𝚛𝚎 𝚎𝚡𝚝𝚎𝚗𝚜𝚒𝚘𝚗 𝚏𝚞𝚗𝚌𝚝𝚒𝚘𝚗𝚜?

Kotlin Coroutines

Contents
𝙵𝚞𝚗𝚍𝚊𝚖𝚎𝚗𝚝𝚊𝚕 𝚌𝚘𝚗𝚌𝚎𝚙𝚝𝚜 𝚘𝚏 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜
𝙲𝚘𝚖𝚖𝚞𝚗𝚒𝚌𝚊𝚝𝚒𝚗𝚐 𝚋𝚎𝚝𝚠𝚎𝚎𝚗 𝚌𝚘-𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜
𝙶𝚒𝚜𝚝 𝚎𝚡𝚊𝚖𝚙𝚕𝚎𝚜 𝚘𝚏 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜 𝚒𝚗 𝚊𝚌𝚝𝚒𝚘𝚗
𝙳𝚒𝚏𝚏𝚎𝚛𝚎𝚗𝚌𝚎 𝚋𝚎𝚝𝚠𝚎𝚎𝚗 𝙻𝚒𝚟𝚎𝙳𝚊𝚝𝚊, 𝚂𝚝𝚊𝚝𝚎𝙵𝚕𝚘𝚠, 𝙵𝚕𝚘𝚠, 𝚂𝚑𝚊𝚛𝚎𝚍𝙵𝚕𝚘𝚠
𝙲𝚑𝚊𝚗𝚗𝚎𝚕𝚜 𝚊𝚗𝚍 𝙵𝚕𝚘𝚠𝚜 - 𝚆𝚑𝚎𝚗 𝚝𝚘 𝚞𝚜𝚎 𝚎𝚊𝚌𝚑 𝚘𝚏 𝚝𝚑𝚎𝚖

𝙵𝚞𝚗𝚍𝚊𝚖𝚎𝚗𝚝𝚊𝚕 𝚌𝚘𝚗𝚌𝚎𝚙𝚝𝚜 𝚘𝚏 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜

• 𝚆𝚑𝚊𝚝 𝚒𝚜 𝚌𝚘𝚗𝚌𝚞𝚛𝚛𝚎𝚗𝚌𝚢
• 𝙱𝚕𝚘𝚌𝚔𝚒𝚗𝚐 𝚟𝚜 𝚂𝚞𝚜𝚙𝚎𝚗𝚍𝚒𝚗𝚐
• About asynchronous code, suspending code, co-routines
  • 𝙷𝚘𝚠 𝚊𝚜𝚢𝚗𝚌𝚑𝚛𝚘𝚗𝚘𝚞𝚜 𝚙𝚛𝚘𝚐𝚛𝚊𝚖𝚖𝚒𝚗𝚐 𝚠𝚘𝚛𝚔𝚜
  • 𝙷𝚘𝚠 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜 𝚙𝚛𝚘𝚐𝚛𝚊𝚖𝚖𝚒𝚗𝚐 𝚠𝚘𝚛𝚔𝚜
  • 𝚆𝚑𝚊𝚝 𝚒𝚜 𝚊 𝚌𝚘-𝚛𝚘𝚞𝚝𝚒𝚗𝚎 𝚊𝚗𝚍 𝙷𝚘𝚠 𝚒𝚝 𝚠𝚘𝚛𝚔𝚜
  • 𝚆𝚑𝚊𝚝 𝚒𝚜 𝚜𝚞𝚜𝚙𝚎𝚗𝚍𝚒𝚗𝚐 𝚏𝚞𝚗𝚌𝚝𝚒𝚘𝚗 𝚊𝚗𝚍 𝚑𝚘𝚠 𝚒𝚝 𝚠𝚘𝚛𝚔𝚜
  • 𝙲𝚘𝚖𝚙𝚊𝚛𝚒𝚗𝚐 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎 𝚟𝚜 𝚜𝚞𝚜𝚙𝚎𝚗𝚍 𝚏𝚞𝚗𝚌𝚝𝚒𝚘𝚗
• Context and Scope
  • 𝙳𝚒𝚏𝚏𝚎𝚛𝚎𝚗𝚌𝚎 𝚋𝚎𝚝𝚠𝚎𝚎𝚗 𝚕𝚊𝚞𝚗𝚌𝚑 𝚊𝚗𝚍 𝚠𝚒𝚝𝚑𝙲𝚘𝚗𝚝𝚎𝚡𝚝
  • 𝚁𝚎𝚕𝚊𝚝𝚒𝚘𝚗𝚜𝚑𝚒𝚙 𝚋𝚎𝚝𝚠𝚎𝚎𝚗 𝚜𝚌𝚘𝚙𝚎 𝚊𝚗𝚍 𝚌𝚘𝚗𝚝𝚎𝚡𝚝
  • 𝚄𝚗𝚍𝚎𝚛𝚜𝚝𝚊𝚗𝚍𝚒𝚗𝚐 𝚟𝚒𝚎𝚠-𝚖𝚘𝚍𝚎𝚕 𝚜𝚌𝚘𝚙𝚎
• 𝙷𝚘𝚠 𝚊𝚜𝚢𝚗𝚌/𝚊𝚠𝚊𝚒𝚝 𝚠𝚘𝚛𝚔𝚜
• 𝚄𝚜𝚒𝚗𝚐 𝚓𝚘𝚒𝚗 𝚒𝚗 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜
• Dispatchers
  • 𝙳𝚒𝚏𝚏𝚎𝚛𝚎𝚗𝚝 𝚝𝚢𝚙𝚎𝚜 𝚘𝚏 𝚍𝚒𝚜𝚙𝚊𝚝𝚌𝚑𝚎𝚛𝚜
  • 𝚂𝚝𝚛𝚊𝚝𝚎𝚐𝚒𝚎𝚜 𝚏𝚘𝚛 𝚞𝚜𝚒𝚗𝚐 𝚝𝚑𝚎 𝚍𝚒𝚜𝚙𝚊𝚝𝚌𝚑𝚎𝚛𝚜
  • 𝙳𝚒𝚜𝚙𝚊𝚝𝚌𝚑𝚎𝚛𝚜 𝚁𝚞𝚗𝚗𝚒𝚗𝚐 𝚘𝚗 𝚝𝚑𝚛𝚎𝚊𝚍 𝚍𝚎𝚖𝚘
• Using coroutines sample use cases
  • 𝙲𝚛𝚎𝚊𝚝𝚒𝚗𝚐 𝚊 𝚜𝚒𝚖𝚙𝚕𝚎 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎 𝚌𝚘𝚗𝚝𝚎𝚡𝚝
  • 𝚆𝚊𝚒𝚝 𝚏𝚘𝚛 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎 𝚝𝚘 𝚏𝚒𝚗𝚒𝚜𝚑
  • 𝚂𝚎𝚚𝚞𝚎𝚗𝚝𝚒𝚊𝚕 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜 𝚎𝚡𝚎𝚌𝚞𝚝𝚒𝚘𝚗
• Cancelling the coroutines
  • 𝙱𝚕𝚘𝚌𝚔 𝙳𝚒𝚊𝚐𝚛𝚊𝚖 𝚘𝚏 𝚌𝚊𝚗𝚌𝚎𝚕𝚕𝚊𝚝𝚒𝚘𝚗
• 𝚂𝚒𝚐𝚗𝚒𝚏𝚒𝚌𝚊𝚗𝚌𝚎 𝚘𝚏 𝚎𝚗𝚜𝚞𝚛𝚎 𝚊𝚌𝚝𝚒𝚟𝚎 𝚌𝚘‐𝚘𝚙𝚎𝚛𝚊𝚝𝚒𝚟𝚎 𝚌𝚊𝚗𝚌𝚎𝚕𝚕𝚊𝚝𝚒𝚘𝚗
• 𝚄𝚜𝚒𝚗𝚐 𝙸𝚜𝙰𝚌𝚝𝚒𝚟𝚎 𝚏𝚘𝚛 𝚌𝚘‐𝚘𝚙𝚎𝚛𝚊𝚝𝚒𝚟𝚎 𝚌𝚊𝚗𝚌𝚎𝚕𝚕𝚊𝚝𝚒𝚘𝚗
• 𝙲𝚊𝚗𝚌𝚎𝚕𝚕𝚒𝚗𝚐 𝙲𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎 𝚅𝚜 𝙲𝚊𝚗𝚌𝚎𝚕𝚕𝚒𝚗𝚐 𝙲𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜 𝚌𝚑𝚒𝚕𝚍𝚛𝚎𝚗
• 𝙽𝚘𝚗-𝚌𝚊𝚗𝚌𝚎𝚕𝚕𝚊𝚋𝚕𝚎 𝚓𝚘𝚋
• Structured Concurrency
  • 𝚆𝚑𝚊𝚝 𝚒𝚜 𝚂𝚝𝚛𝚞𝚌𝚝𝚞𝚛𝚎𝚍 𝚌𝚘𝚗𝚌𝚞𝚛𝚛𝚎𝚗𝚌𝚢?
• Jobs
  • 𝙷𝚘𝚠 𝚓𝚘𝚋 𝚒𝚗 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎 𝚠𝚘𝚛𝚔𝚜
  • 𝙹𝚘𝚋-𝙷𝚒𝚎𝚛𝚊𝚛𝚌𝚑𝚢
• Parallel Decomposition
  • 𝙰𝚋𝚘𝚞𝚝 𝚙𝚊𝚛𝚊𝚕𝚕𝚎𝚕 𝚍𝚎𝚌𝚘𝚖𝚙𝚘𝚜𝚒𝚝𝚒𝚘𝚗
  • 𝙰𝚋𝚘𝚞𝚝 𝙰𝚜𝚢𝚗𝚌 𝚊𝚗𝚍 𝙰𝚠𝚊𝚒𝚝
  • 𝙺𝚘𝚝𝚕𝚒𝚗 𝙲𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜 𝚓𝚘𝚒𝚗 𝚟𝚜 𝚊𝚠𝚊𝚒𝚝
• Exception Handling
  • 𝙴𝚡𝚌𝚎𝚙𝚝𝚒𝚘𝚗 𝚑𝚊𝚗𝚍𝚕𝚒𝚗𝚐 𝚒𝚗 𝚕𝚊𝚞𝚗𝚌𝚑
  • 𝙴𝚡𝚌𝚎𝚙𝚝𝚒𝚘𝚗 𝚑𝚊𝚗𝚍𝚕𝚒𝚗𝚐 𝚒𝚗 𝚊𝚜𝚢𝚗𝚌
• 𝚂𝚞𝚙𝚎𝚛𝚟𝚒𝚜𝚘𝚛 𝚂𝚌𝚘𝚙𝚎 𝚊𝚗𝚍 𝚂𝚞𝚙𝚎𝚛𝚟𝚒𝚜𝚘𝚛 𝙹𝚘𝚋 𝚒𝚗 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜
• 𝚆𝚑𝚊𝚝 𝚒𝚜 𝚝𝚊𝚒𝚕𝚛𝚎𝚌 𝚒𝚗 𝚔𝚘𝚝𝚕𝚒𝚗

𝙲𝚘𝚖𝚖𝚞𝚗𝚒𝚌𝚊𝚝𝚒𝚗𝚐 𝚋𝚎𝚝𝚠𝚎𝚎𝚗 𝚌𝚘-𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜

• 𝙰𝚋𝚘𝚞𝚝 𝙲𝚘𝚖𝚖𝚞𝚗𝚒𝚌𝚊𝚝𝚒𝚗𝚐 𝚋𝚎𝚝𝚠𝚎𝚎𝚗 𝚝𝚑𝚎 𝚌𝚘‐𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜
• Kotlin flow
  • 𝙰𝚋𝚘𝚞𝚝 𝙵𝚕𝚘𝚠
  • 𝙵𝚕𝚘𝚠 𝙱𝚞𝚒𝚕𝚍𝚎𝚛𝚜
  • 𝙵𝚕𝚘𝚠 𝙲𝚘𝚗𝚝𝚎𝚡𝚝
  • Composing and Flattening Flows
    • 𝙰𝚋𝚘𝚞𝚝 𝚌𝚘𝚖𝚙𝚘𝚜𝚒𝚗𝚐 𝚊𝚗𝚍 𝚏𝚕𝚊𝚝𝚝𝚎𝚗𝚒𝚗𝚐 𝚏𝚕𝚘𝚠𝚜
    • Composing
      • 𝙱𝚞𝚏𝚏𝚎𝚛𝚒𝚗𝚐
      • 𝙲𝚘𝚗𝚏𝚕𝚊𝚝𝚒𝚘𝚗
      • 𝙲𝚘𝚕𝚕𝚎𝚌𝚝𝚒𝚗𝚐 𝙻𝚊𝚝𝚎𝚜𝚝
      • 𝚉𝚒𝚙𝚙𝚒𝚗𝚐
      • 𝙲𝚘𝚖𝚋𝚒𝚗𝚒𝚗𝚐
    • Flattening
      • 𝚆𝚑𝚊𝚝 𝚒𝚜 𝚖𝚎𝚊𝚗𝚝 𝚋𝚢 𝚏𝚕𝚊𝚝𝚝𝚎𝚗𝚒𝚗𝚐
      • 𝙵𝚕𝚊𝚝𝙼𝚊𝚙𝙲𝚘𝚗𝚌𝚊𝚝 𝚘𝚛 𝙵𝚕𝚊𝚝𝚝𝚎𝚗𝙲𝚘𝚗𝚌𝚊𝚝
      • 𝙵𝚕𝚊𝚝𝙼𝚊𝚙𝙼𝚎𝚛𝚐𝚎 𝚘𝚛 𝙵𝚕𝚊𝚝𝚝𝚎𝚗𝙼𝚎𝚛𝚐𝚎
      • 𝙵𝚕𝚊𝚝𝙼𝚊𝚙𝙻𝚊𝚝𝚎𝚜𝚝 𝚘𝚛 𝙵𝚕𝚊𝚝𝚝𝚎𝚗𝙻𝚊𝚝𝚎𝚜𝚝
  • Operators
    • 𝚃𝚎𝚛𝚖𝚒𝚗𝚊𝚕 𝚘𝚙𝚎𝚛𝚊𝚝𝚘𝚛𝚜
    • 𝙸𝚗𝚝𝚎𝚛𝚖𝚎𝚍𝚒𝚊𝚝𝚎 𝚘𝚙𝚎𝚛𝚊𝚝𝚘𝚛𝚜
    • 𝙻𝚒𝚏𝚎𝚌𝚢𝚌𝚕𝚎 𝙾𝚙𝚎𝚛𝚊𝚝𝚘𝚛𝚜
  • 𝙴𝚡𝚌𝚎𝚙𝚝𝚒𝚘𝚗 𝙷𝚊𝚗𝚍𝚕𝚒𝚗𝚐
• 𝚂𝚝𝚊𝚝𝚎 𝙵𝚕𝚘𝚠 𝚊𝚗𝚍 𝚂𝚑𝚊𝚛𝚎𝚍 𝙵𝚕𝚘𝚠
  • Shared Flow
    • 𝙲𝚛𝚎𝚊𝚝𝚒𝚗𝚐 𝚊 𝚂𝚑𝚊𝚛𝚎𝚍 𝙵𝚕𝚘𝚠 𝚠𝚒𝚝𝚑 𝚂𝚑𝚊𝚛𝚎𝚍‐𝙸𝚗
    • 𝚄𝚜𝚒𝚗𝚐 𝙼𝚞𝚝𝚊𝚋𝚕𝚎 𝚂𝚑𝚊𝚛𝚎𝚍 𝙵𝚕𝚘𝚠
  • State Flow
    • 𝙲𝚛𝚎𝚊𝚝𝚒𝚗𝚐 𝚊 𝚂𝚝𝚊𝚝𝚎 𝙵𝚕𝚘𝚠 𝚠𝚒𝚝𝚑 𝚂𝚝𝚊𝚝𝚎‐𝙸𝚗
    • 𝚄𝚜𝚒𝚗𝚐 𝙼𝚞𝚝𝚊𝚋𝚕𝚎 𝚂𝚝𝚊𝚝𝚎 𝙵𝚕𝚘𝚠
  • Collecting the flows
    • 𝙲𝚘𝚗𝚜𝚞𝚖𝚒𝚗𝚐 𝚝𝚑𝚎 𝚏𝚕𝚘𝚠𝚜 𝚜𝚊𝚏𝚎𝚕𝚢 𝚒𝚗 𝙲𝚘𝚖𝚙𝚘𝚜𝚎
• Kotlin Channels
  • 𝙰𝚋𝚘𝚞𝚝 𝙲𝚑𝚊𝚗𝚗𝚎𝚕𝚜
  • 𝙲𝚘𝚖𝚖𝚞𝚗𝚒𝚌𝚊𝚝𝚒𝚘𝚗 𝚋𝚎𝚝𝚠𝚎𝚎𝚗 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜
  • 𝚄𝚜𝚒𝚗𝚐 𝙿𝚛𝚘𝚍𝚞𝚌𝚎
  • 𝙴𝚗𝚍-𝚝𝚘-𝚎𝚗𝚍 𝚌𝚘𝚖𝚖𝚞𝚗𝚒𝚌𝚊𝚝𝚒𝚘𝚗 𝚝𝚢𝚙𝚎𝚜
  • 𝙲𝚑𝚊𝚗𝚗𝚎𝚕 𝚝𝚢𝚙𝚎𝚜

𝙶𝚒𝚜𝚝 𝚎𝚡𝚊𝚖𝚙𝚕𝚎𝚜 𝚘𝚏 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜 𝚒𝚗 𝚊𝚌𝚝𝚒𝚘𝚗

• 𝚂𝚒𝚗𝚐𝚕𝚎 𝚗𝚎𝚝𝚠𝚘𝚛𝚔 𝚛𝚎𝚚𝚞𝚎𝚜𝚝
• 𝚂𝚎𝚚𝚞𝚎𝚗𝚝𝚒𝚊𝚕 𝚗𝚎𝚝𝚠𝚘𝚛𝚔 𝚛𝚎𝚚𝚞𝚎𝚜𝚝
• 𝙲𝚘𝚗𝚌𝚞𝚛𝚛𝚎𝚗𝚝 𝚗𝚎𝚝𝚠𝚘𝚛𝚔 𝚛𝚎𝚚𝚞𝚎𝚜𝚝
• 𝚅𝚊𝚛𝚒𝚊𝚋𝚕𝚎 𝚗𝚞𝚖𝚋𝚎𝚛 𝚘𝚏 𝚗𝚎𝚝𝚠𝚘𝚛𝚔 𝚛𝚎𝚚𝚞𝚎𝚜𝚝𝚜
• 𝙸𝚖𝚙𝚕𝚎𝚖𝚎𝚗𝚝𝚒𝚗𝚐 𝚊 𝚝𝚒𝚖𝚎𝚘𝚞𝚝 𝚏𝚘𝚛 𝚗𝚎𝚝𝚠𝚘𝚛𝚔 𝚛𝚎𝚚𝚞𝚎𝚜𝚝
• 𝚁𝚎𝚝𝚛𝚢𝚒𝚗𝚐 𝚗𝚎𝚝𝚠𝚘𝚛𝚔 𝚛𝚎𝚚𝚞𝚎𝚜𝚝𝚜 𝚒𝚗 𝚌𝚊𝚜𝚎 𝚘𝚏 𝚏𝚊𝚒𝚕𝚞𝚛𝚎
• 𝙲𝚘𝚖𝚋𝚒𝚗𝚒𝚗𝚐 𝚝𝚒𝚖𝚎𝚘𝚞𝚝 𝚊𝚗𝚍 𝚛𝚎𝚝𝚛𝚢 𝚘𝚏 𝚗𝚎𝚝𝚠𝚘𝚛𝚔 𝚛𝚎𝚚𝚞𝚎𝚜𝚝
• 𝚄𝚜𝚒𝚗𝚐 𝚛𝚘𝚘𝚖 𝚒𝚗 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜
• 𝙰𝚗𝚊𝚕𝚢𝚣𝚒𝚗𝚐 𝚊𝚗𝚍 𝚍𝚎𝚋𝚞𝚐𝚐𝚒𝚗𝚐 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜
• 𝙷𝚘𝚠 𝚝𝚘 𝚙𝚎𝚛𝚏𝚘𝚛𝚖 𝚊 𝚑𝚎𝚊𝚟𝚢 𝚘𝚙𝚎𝚛𝚊𝚝𝚒𝚘𝚗 𝚒𝚗 𝚝𝚑𝚎 𝚋𝚊𝚌𝚔𝚐𝚛𝚘𝚞𝚗𝚍 𝚝𝚑𝚛𝚎𝚊𝚍
• 𝙷𝚘𝚠 𝚝𝚘 𝚙𝚎𝚛𝚏𝚘𝚛𝚖 𝚝𝚑𝚎 𝚌𝚊𝚗𝚌𝚎𝚕𝚕𝚊𝚝𝚒𝚘𝚗
• 𝚄𝚜𝚒𝚗𝚐 𝚖𝚊𝚗𝚢 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜 𝚝𝚘 𝚙𝚊𝚜𝚜 𝚘𝚗 𝚝𝚑𝚎 𝚠𝚘𝚛𝚔
• 𝙷𝚘𝚠 𝚝𝚘 𝚙𝚎𝚛𝚏𝚘𝚛𝚖 𝚎𝚡𝚌𝚎𝚙𝚝𝚒𝚘𝚗 𝚑𝚊𝚗𝚍𝚕𝚒𝚗𝚐 𝚒𝚗 𝚝𝚑𝚎 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜
• 𝙷𝚘𝚠 𝚝𝚘 𝚛𝚞𝚗 𝚝𝚑𝚎 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎 𝚎𝚟𝚎𝚗 𝚒𝚏 𝚝𝚑𝚎 𝚞𝚜𝚎𝚛 𝚕𝚎𝚊𝚟𝚎𝚜 𝚝𝚑𝚎 𝚜𝚌𝚛𝚎𝚎𝚗
• 𝚄𝚜𝚒𝚗𝚐 𝚠𝚘𝚛𝚔 𝚖𝚊𝚗𝚊𝚐𝚎𝚛 𝚊𝚕𝚘𝚗𝚐 𝚠𝚒𝚝𝚑 𝚌𝚘𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜
• 𝙼𝚊𝚔𝚒𝚗𝚐 𝚙𝚊𝚛𝚎𝚗𝚝 𝚌𝚘 𝚛𝚘𝚞𝚝𝚒𝚗𝚎 𝚝𝚘 𝚠𝚊𝚒𝚝 𝚞𝚗𝚝𝚒𝚕 𝚊𝚕𝚕 𝚝𝚑𝚎 𝚌𝚑𝚒𝚕𝚍𝚛𝚎𝚗 𝚌𝚘 𝚛𝚘𝚞𝚝𝚒𝚗𝚎𝚜 𝚊𝚛𝚎 𝚏𝚒𝚗𝚒𝚜𝚑𝚎𝚍
• 𝙲𝚊𝚗𝚌𝚎𝚕𝚒𝚗𝚐 𝚝𝚑𝚎 𝚙𝚊𝚛𝚎𝚗𝚝 𝚊𝚗𝚍 𝚌𝚑𝚒𝚕𝚍 𝚓𝚘𝚋

𝚂𝚞𝚙𝚙𝚘𝚛𝚝 ☕

𝙸𝚏 𝚢𝚘𝚞 𝚏𝚎𝚎𝚕 𝚕𝚒𝚔𝚎 𝚜𝚞𝚙𝚙𝚘𝚛𝚝 𝚖𝚎 𝚊 𝚌𝚘𝚏𝚏𝚎𝚎 𝚏𝚘𝚛 𝚖𝚢 𝚎𝚏𝚏𝚘𝚛𝚝𝚜, 𝙸 𝚠𝚘𝚞𝚕𝚍 𝚐𝚛𝚎𝚊𝚝𝚕𝚢 𝚊𝚙𝚙𝚛𝚎𝚌𝚒𝚊𝚝𝚎 𝚒𝚝.

𝙲𝚘𝚗𝚝𝚛𝚒𝚋𝚞𝚝𝚎 🙋‍♂️

𝚁𝚎𝚊𝚍 𝚌𝚘𝚗𝚝𝚛𝚒𝚋𝚞𝚝𝚒𝚘𝚗 𝚐𝚞𝚒𝚍𝚎𝚕𝚒𝚗𝚎𝚜 𝚏𝚘𝚛 𝚖𝚘𝚛𝚎 𝚒𝚗𝚏𝚘𝚛𝚖𝚊𝚝𝚒𝚘𝚗 𝚛𝚎𝚐𝚊𝚛𝚍𝚒𝚗𝚐 𝚌𝚘𝚗𝚝𝚛𝚒𝚋𝚞𝚝𝚒𝚘𝚗.

𝙵𝚎𝚎𝚍𝚋𝚊𝚌𝚔 ✍️

𝙵𝚎𝚊𝚝𝚞𝚛𝚎 𝚛𝚎𝚚𝚞𝚎𝚜𝚝𝚜 𝚊𝚛𝚎 𝚊𝚕𝚠𝚊𝚢𝚜 𝚠𝚎𝚕𝚌𝚘𝚖𝚎, 𝙵𝚒𝚕𝚎 𝚊𝚗 𝚒𝚜𝚜𝚞𝚎 𝚑𝚎𝚛𝚎.

𝙵𝚒𝚗𝚍 𝚝𝚑𝚒𝚜 𝚙𝚛𝚘𝚓𝚎𝚌𝚝 𝚞𝚜𝚎𝚏𝚞𝚕 ? ❤️

𝚂𝚞𝚙𝚙𝚘𝚛𝚝 𝚒𝚝 𝚋𝚢 𝚌𝚕𝚒𝚌𝚔𝚒𝚗𝚐 𝚝𝚑𝚎 ⭐ 𝚋𝚞𝚝𝚝𝚘𝚗 𝚘𝚗 𝚝𝚑𝚎 𝚞𝚙𝚙𝚎𝚛 𝚛𝚒𝚐𝚑𝚝 𝚘𝚏 𝚝𝚑𝚒𝚜 𝚙𝚊𝚐𝚎. ✌️

𝙻𝚒𝚌𝚎𝚗𝚜𝚎 💳

𝚃𝚑𝚒𝚜 𝚙𝚛𝚘𝚓𝚎𝚌𝚝 𝚒𝚜 𝚕𝚒𝚌𝚎𝚗𝚜𝚎𝚍 𝚞𝚗𝚍𝚎𝚛 𝚝𝚑𝚎 𝙰𝚙𝚊𝚌𝚑𝚎 𝙻𝚒𝚌𝚎𝚗𝚜𝚎 𝟸.𝟶 - 𝚜𝚎𝚎 𝚝𝚑𝚎 𝙻𝙸𝙲𝙴𝙽𝚂𝙴 𝚏𝚒𝚕𝚎 𝚏𝚘𝚛 𝚍𝚎𝚝𝚊𝚒𝚕𝚜.