Kotlin optimizations

[markchristopherng]

Hi,

Will you guys be adding any Kotlin extensions in the future?

[PaulWoitaschek]

There are some things that would be nice for kotlins.

• The bind(x).to(y) syntax is bad as it conflicts with kotlins to extension function.
  It suggest adding a bindToClass method alias because that's more convenient on kotlin
• All that bind-to-withProvider-singletonInInstance could be abstracted into a convenient DSL.
• We could have an extension function on with the scope as the receiver for simpler injection without that Toothpick.inject boilerplate:

fun Scope.inject(target: Any) {
  Toothpick.inject(target, this)
}

[chenthorne]

We've started using a set of custom written extensions that we'd like to make public and incorporate with the toothpick library as a new module. There's a sample project at https://github.com/Leafly-com/toothpick-extensions-sample that has the extension code as well as examples on how it could be used.

• Extensions to allow use of Kotlin class objects (no more .java)
• Simple set of infix functions with a DSL for declaring Modules
• Kotlin Delegate based lazy injection that allows private val dep: Dep by inject()
• Android specific extensions that search for a scope or assume a default one for activities and fragments
• Inject with late created scope but still specify as private class member

Would greatly appreciate feedback.

Quick Preview:

// Inject with Kotlin Class
scope.getInstance(KotlinClass::class)

// In a Module, bind with Kotlin Class
bind(KotlinClass::class)...

// Inject dependency safely without specifying type via reified types
val dependency: Dependency = inject(scope)

// Lazy inject dependency via delegate
val dependency: Dependency by injectLazy(scope)

// Will inject with Toothpick.openScope(activityRef.application, activityRef)
class MyActivity : Activity() {
    private val dependency1: Dependency by inject()
}

// Will inject with lazy provided scope
class MyActivity : Activity() {
    private lateinit var lateScope: Scope
    private val dependency1: Dependency by inject { scope = lateScope }
    ...
}

// Binding functions
bind(Dep::class) providedBy DepProvider()
bind(Dep::class) singletonPovidedBy DepProvider::class
bind(Dep::class) named "DepName" providedBy DepProvider()

// DSL
module {
   Picasso::class providedBy PicassoProvider::class 
}

[dimsuz]

We have a shorter getInstance(), not based on a KClass like yours though, works great for us too:

inline fun <reified T> Scope.instance(tag: String? = null): T = this.getInstance(T::class.java, tag)

val c = scope.instance<MyClass>()
val c1: MyClass = scope.instance()

[chenthorne]

@dimsuz Nice! I'll update to to use that pattern.

[stephanenicolas]

This is getting closed as it has been released in version 3.0.0.