how to make your own DI in 10 minutes

To understand what just happened, I’ll give you a brief introduction to inline functions. Let's start with this example:

fun main() {
   addFour(16) { result ->
       println(result + 1)
   }
}


fun addFour(value: Int, callback: (Int) -> Unit){
   callback(value + 4)
}

What's going on here?

• We called the function addFourpassing it some value (16).

• Inside the function we added the number 4 to the value.

And returned this result to callback back to the function from which we originally called the method addFour.

To make it even clearer, this is what the code looks like in Java (slightly modified for clarity, but without losing the meaning):

static class Callback{

   public void invoke(int value) {
       System.out.println(value);
   }
}

public static final void main() {
   addFour(16, new Callback());
}

public static final void addFour(int value, Callback callback) {
   callback.invoke(value + 4);
}

This is what we get when converting from Kotlin to Java.

Now let's change our code a little by marking the method addFour modifier inline.

fun main() {
   addFour(16) { result ->
       println(result)
   }
}


inline fun addFour(value: Int, callback: (Int) -> Unit){
   callback(value + 4)
}

It seems like nothing has changed. Let's see what our Java code will look like (slightly modified for understanding, but without losing the meaning):

public static final void main() {
   int value = 16;
   int result = value + 4;
   System.out.println(result);
}

As you can see, we got rid of the unnecessary method call addFour. All the code was inlined instead of calling our method.

Now let's figure it out noInline. To do this, we again slightly modernize our code.

var timeVarious: ((Int) -> Unit)? = null


fun main() {
   addFour(
       value = 16,
       callback = { result -> println(result) },
       secondCallback = { result -> println("second $result") }
   )
}


inline fun addFour(
   value: Int,
   callback: (Int) -> Unit,
   noinline secondCallback: (Int) -> Unit
){
   callback(value + 4)
   timeVarious = secondCallback
   secondCallback(value + 4)
}

We added one more method, but labeled it as noinline. We also added a variable timeVariousinto which we save our noinline lambda. For what? I'll tell you a little later.
What the Java code will look like now (slightly changed for understanding, but without losing the meaning):

static class SecondCallback{

   public void invoke(int value) {
       System.out.println(“second” + value);
   }
}

static SecondCallback timeVarious;

public static final void main() {
   int value = 16;
   SecondCallback secondCallback = new SecondCallback();
   int result = value + 4;
   System.out.println(result);
   secondCallback.invoke(result);
}

All callbackwhich was not marked as noinlinecompletely inlined instead of calling a function addFour. A secondCallback created a special class, as in the example without an inline function.

An inline function allows you to embed all the code inside instead of calling it. A noinline allows you to un-embed certain callback. Why is this necessary?
A variable was created specifically for this purpose timeVarious. Due to the fact that the noinline function is not built in, we can treat it as a separate object and even save it somewhere. And with the first callback such action is not permitted.

inline fun addFour(
   value: Int,
   callback: (Int) -> Unit,
   noinline secondCallback: (Int) -> Unit
){
   timeVarious = callback - // ошибка
   callback(value + 4)
   timeVarious = secondCallback
   secondCallback(value + 4)
}

Now let’s discuss another feature of inline functions, namely – reified. First, let's create the following variable:

val cacheName = mapOf<KClass<*>, String>(
   Int::class to "Int"
)

Just by KClass we will receive a string that is the name of the class. How to get such a string from Map? Quite simple:

fun main() {
   val name = cacheName[Int::class]
}

This syntax doesn't look very attractive. Well, let's try to put it in a separate function:

fun main() {
   val name = superGet<Int>()
}


fun <T: Any> superGet(): String? {
   return cacheName[T::class] // - ошибка
}

But we see a problem: our function simply has nowhere to get an instance KClass during code execution, after all, when moving from function to function, our generic types are erased. An inline function can come to the rescue, because at the place of the call (in the method main) we know exactly what we want to get Int::class. Let's make our function inline:

inline fun <T: Any> superGet(): String? {
   return cacheName[T::class] // - ошибка
}

But this still leads us to an error. Despite the fact that the function was built in, information about the specific type was still erased at the time of insertion, based on the calculation that you simply did not need this type inside the function. That's why the keyword exists reifiedwhich tells the compiler to preserve the class type after inlining. When adding one keyword:

inline fun <reified T: Any> superGet(): String? {
   return cacheName[T::class]
}

After compilation we will get this code:

public static final void main() {
  String name = (String)getCacheName().get(
     Reflection.getOrCreateKotlinClass(Integer.class) 
  );
}

A short example about what it is lazyif you suddenly have doubts about how it works. The following code will count:

val repository by lazy { ExampleRepository() }

fun call(){
   repository.loadData()
}

equivalent to this (just revealed what by is replaced with in the code):

val repository = lazy { ExampleRepository() }

fun call(){
   repository.value.loadData()
}

I think with this view it becomes clear that the first time value is accessed, the variable will simply be initialized. In a simple example it might look like this (simplified example):

object UNINITIALIZED_VALUE


fun <T> lazy(block: () -> T): Lazy<T> = object : Lazy<T> {
   private var initializer: (() -> T)? = block
   private var _value: Any? = UNINITIALIZED_VALUE


   override val value: T
       get() {
           if (_value === UNINITIALIZED_VALUE) {
               _value = initializer!!()
               initializer = null
           }
           @Suppress("UNCHECKED_CAST")
           return _value as T
       }


   override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE
}

Real lazy-the wrapper is a little more complicated, as it supports a couple of modes for creating a variable. What's going on here?

When you first contact value we are checking the variable _valueto see if it has already been initialized. If not, we initialize and return. And if so, then we simply return the saved value.