Wat zijn 'context receivers' en hoe werken ze in Kotlin?

Context-ontvangers zijn een experimentele functie in Kotlin die functies, eigenschappen of klassen in staat stelt om het bestaan van instanties van bepaalde typen in de aanroepcontext te vereisen. Dit mechanisme maakt het mogelijk om afhankelijkheden impliciet door te geven.

Hoe ze werken:

1. Declaratie: Ze worden toegevoegd aan de declaratie van een lid met behulp van de syntaxis context(...) before ....

   // Declaratie van een functie die een context van type Logger en Analytics vereist
   context(Logger, Analytics)
   fun processData(data: String) {
       // Kan Logger en Analytics gebruiken zonder ze expliciet door te geven
       log("Verwerking van gegevens: $data")
       trackEvent("DataProcessed", mapOf("size" to data.length))
   }
   
   class Logger { fun log(message: String) { println(message) } }
   class Analytics { fun trackEvent(name: String, params: Map<String, Any>) { println("$name: $params") } }
   

2. Aanroep: Om een functie met context-ontvangers aan te roepen, moeten de instanties van de vereiste typen beschikbaar zijn in de aanroepcontext. Dit kan op verschillende manieren worden bereikt:

   • Door expliciet instanties te maken.
   • Door instanties als context-ontvangers te hebben in externe functies of klassen.
   • Door with of andere scopes te gebruiken om de context te bieden.

   fun main() {
       // Maak de benodigde context-instanties
       val myLogger = Logger()
       val myAnalytics = Analytics()
   
       // Bied de contexten via with
       with(myLogger) {
           with(myAnalytics) {
               // In dit scope zijn myLogger en myAnalytics beschikbaar als contexten
               processData("enkele belangrijke gegevens")
           }
       }
   }
   

3. Interne toegang: Binnen een lid dat is gedeclareerd met context-ontvangers, zijn de instanties van deze typen direct beschikbaar, alsof ze ontvangers of variabelen in de scope zijn.

Voordelen:

• Vermindering van boilerplate: Verwijdert de noodzaak om gedeelde afhankelijkheden expliciet door te geven via functietekens.
• Verbetering van de leesbaarheid: Maakt het mogelijk om je te richten op de bedrijfslogica, niet op het doorgeven van infrastructuurafhankelijkheden.
• Encapsulatie: Geeft duidelijk aan welke contexten nodig zijn om de taak van het lid uit te voeren.

Het is belangrijk op te merken dat context receivers nog steeds een experimentele functie zijn en kunnen veranderen in toekomstige versies van Kotlin.