DEV Community: Praveen Kajla

Demystifying Advanced Kotlin Concepts Pt.2-1

Praveen Kajla — Sat, 14 Oct 2017 12:30:43 +0000

This article is a follow-up to Demystifying Advanced Kotlin Concepts Pt.1

Classes in Kotlin

1.Fields

Remember Classes in Kotlin cannot have fields.

However, sometimes it is necessary to have a backing field (A private field that stores the data exposed by a public property)when using custom accessors.
For these purposes, Kotlin provides an automatic backing field which can be accessed using the field identifier:

Let's create a class Customer having mutable property (using the var keyword) lastPurchased.
We also create custom getter and setter for this property.


class Customer(){

    var lastPurchased:Double = 0.0 // Property type is optional as kotlin provide type inference
        get() = field //field is built-in variable and can only be used in getter and setter
        set(value){
            if(value>100){
                field = value
            }
        }
}

Here getter and setter are optional as kotlin provide default getter and setter .

But since we are conditionally setting the value we need our own getter and setter.


fun main(args: Array<String>) {

    val customer = Customer() // no new keyword needed to instantiate
    println(customer.lastPurchased)
    customer.lastPurchased = 200.0
    println(customer.lastPurchased)
    customer.lastPurchased = 50.0
    println(customer.lastPurchased)

}

If we run this :

output -> 
  0.0
  200.0
  200.0

A backing field for a property is automatically created if :

a custom getter or setter references it through the field identifier
default implementation of at least one of the accessors is used

For cases where field is not enough we can't just use backing field for whatever reasons ,then the only way around it is to create a private property like :


class Customer(){

    private var myCustomField = 10

    ....

2. Late Initialization

Oftentimes we need to have late initialization of a property.

Let's create a controller of web for Customer class above that spits out some data from a repository (database)


interface Repository{
    fun getAll(): List<Customer>
}

class CustomerController(){

    var repository:Repository // ide would show "Property must be initialized or be abstract"

    fun index():String{
        return repository.getAll().toString()
    }
}

Now imagine we want repository to be a property that needs to be initialized by some IoC container i.e. we are not passing this property as a part of constructor but I want it to be initialized later on.

So one solution is to make it nullable i.e.


class CustomerController(){

    var repository:Repository? = null

    fun index():String{
        return repository?.getAll().toString()
    }
}

But then every single time we access repository we need to suffix it with ?.
And also we don't want this to be null or let people reading our code to assume that we want it to be null.

SO kotlin provide modifier lateinit to solve this problem :


class CustomerController(){

    lateinit var repository:Repository // tells the compiler that we are going to initialize it later on.

    ...

However, this is not gonna make everything safe.
If we run without initializing repository


fun main(args: Array<String>) {
    val cc = CustomerController()
    cc.index()
}

We won't get the null reference but :


Exception in thread "main" kotlin.UninitializedPropertyAccessException: lateinit property repository has not been initialized
    at CustomerController.index(Class.kt:15)
    at ClassKt.main(Class.kt:21)

Which makes debugging easier.

3. Nested Classes

Much like nested functions or local functions we can have nested classes in kotlin.

Let's create a class DirectoryExplorer having function listFolder which also encapsulates the functionality to check
permission whether a specific user can access that folder.

class DirectoryExplorer(){

    class PermissionCheck(){

        fun validatePermission(user: String) {

        }

    }

    fun listFolder(folder:String,user:String){

        val permissionCheck = PermissionCheck()
        permissionCheck.validatePermission(user)
    }
}

So we have PermissionCheck as the nested class.
Also, we can access this nested class and create an instance of that.


fun main(args: Array<String>) {
    val de = DirectoryExplorer()
    val pc = DirectoryExplorer.PermissionCheck()
}

If you don't want it to be accessed or instantiated make it private.

Now, what if we want to access properties of the external class inside the nested class.
To do that we would have to use modifier inner as the prefix to the nested class.


class DirectoryExplorer(val user:String){

    inner class PermissionCheck(){
        fun validatePermission() {
            if(user != "Bruce"){

            }
        }
    }
}

fun main(args: Array<String>) {
    val de = DirectoryExplorer("Bruce")
    val pc = DirectoryExplorer.PermissionCheck() //Ide would show "Constructor of inner class PermissionCheck can be called only with receiver of containing class"
}

using inner modifier makes the nested class the part of the actual instance of the external class, that's why we can't access inner class simply.

So it would be accessible as a part of the actual instance of the class i.e.

...

    val pc = DirectoryExplorer().PermissionCheck() 

...

Next: Classes Pt.2

Demystifying Advanced Kotlin Concepts Pt.1

Praveen Kajla — Tue, 03 Oct 2017 03:03:45 +0000

Ever since Google made it official for Android I had a constant urge to learn kotlin. The basics were easy to grasp as I come from the java background, but I was not familiar with the functional programming paradigm. So I stopped learning kotlin after the basics.
Then I learnt functional programming in javascript which was like a gust of wind and it hit me off that concepts are same like HOC, arrow function, pure functions just the syntax is different.This post assumes you know some functional programming principles but don't worry in case you don't. You can watch this awesome introduction.
Enough now, let's board this ship to kotlin.

Functions

01. Local Functions

fun OuterFunction(param:Int){
  val outerVar = 11
  fun localFunction(){
    println(params)
    println(outerVar)
  }
}

Local functions are functions inside a function. Local functions could access outer function's parameters & its local variables (i.e. the closure).

What's the use

This is useful when we want to do code reuse i.e. we don't want to create a top level function or we don't want
to create a member function outside of the class.This way grouping is better.

Note
For other function outside of outerFunction we don't have access to outerFunction's localFunctions .

02. Infix Functions

for extension functions or member functions that have single parameters we can call these using infix notation

infix fun String.extensionFunction(x: Int): Int {
...
}
//can be called as 

val str = "hello"
str extensionFunction 2

useful in UNIT TESTING

03. Anonymous Functions

We have seen higher-order functions where lambda expressions are passed as code blocks.

So Anonymous Functions are slightly different .

fun op(x:Int,op:(Int) -> Int):Int{
  return op(x)
}

lambdas

//called like

op(3,{it*it})
//here {it*it} is lambda expression

Anonymous

//can have multiple returns

op(3,fun(x):Int{
         if(x>10) return 0
         else return x*x
        })

Anonymous functions have full body of a normal function but no name.

04.Inline Functions

A lambda expression in kotlin gives way to anonymous class in java.This adds its overhead and if lambda expression has a closure it would cause an instance to also be created thus adding more memory overhead.

In addition all these lambda expression are impacting the call stack.
It affects performance.

Using Inline Functions we can minimize these impacts.

NonInline


fun op(op:()->Unit){
    println("This is before lambda")
    op()
    println("this is after lambda")
}

fun main(args: Array<String>) {
    op({println("this is the actual function")})
}

you can see decompiled kotlin bytecode here
noninline

Inline


inline fun op(op:()->Unit){
    println("This is before lambda")
    op()
    println("this is after lambda")
}

fun main(args: Array<String>) {
    op({println("this is the actual function")})
}

you can see decompiled kotlin bytecode here
inline

if you compare the two decompiled versions you can see that what inline modifier does is

copy the entire inline function code to where we are invoking that function and it inline(copy) the code of the lambda being passed too

Inline takes a higher order function and inline it(copy and paste contents of that function) being passed in to where it is being called.

So, essentially it's flattening it out, it's saying instead of me invoking this function I'm gonna take the code and I'm gonna paste it there.

And this provides us with optimization because we are eliminating all of that unnecessary anonymous classes or call stack etc.

Of course, it comes with it's own side effects since we are copying and pasting code.
So inline modifier is obviously useful when I'm passing in the lambdas because otherwise it makes no sense.

Note
we can't actually store reference to that lambda function if want to inline it.


inline fun op(op:()->Unit){
    val reference = op //this would say illegal usage
    op()
    println("this is after lambda")
}

fun main(args: Array<String>) {
    op({println("this is the actual function")})
}

If you more than one lambdas passed in as parameters to higher order functions you can specifically tell the compiler to not inline specific lambda function by using noinline modifier in front.

If body of function is large you may don't wanna inline it.

05. Returns And Local Returns

Let's take an example

fun ContainingFunction(){
  val nums=1..100
  numbers.forEach{
    if(it%5==0){
      return
      }
    }
  println("Hello!")
  }

If you run this you would get an empty output i.e. no Hello! printed.
Because the input parameter to forEach function is a lambda expression and
return statement make us return from the containingFuction itself rather than the lambda expression.

So how to retun from lambda rather than containing function

Seems kotln has a way i.e. change the return statement

labels

...
  if(it%5==0){
    return@forEach //i.e. name of the higher order function
  }
...
//or you could define your own labels
numbers.forEach myLabel@{
          if(it%5==0){
            return@myLabel  
         }
   ....

Note
But instead of lambda expression if we use anonymous function as parameter it would return from the anounymous function itself without
any labels

Also non local returns are only allowed in the case where they are invoked from an inline function.
what i means is if we look kotlin's forEach code you can see that it has inline modifer in it

So if we remove inline modifier from forEach it would show error.

06. Lambda Extensions

or lambda receivers

//lambdas
f:() -> Unit
//lambda extension
f:SomeFunctionOrClass.() -> Unit

Take time to look at this sample resthandler

we can see that routeHandler has lambda extension as parameter

fun routeHandler(path:String,f:RouteHandler.() -> Unit):RouteHandler.() -> Unit = f

So all extension functions have access to members of the class they are extending i.e. routeHandler has excess to the request and response members of the the RouteHandler class

This Helps us in creating a very fluent ,expressive DSLs
further example

06. Invoking Instances in Kotlin

or lambda receivers

... main{
...
  val manager = Manager()
  ...
 }
 class Manager{

 }

Now Imagine a scenario in which I want to invoke some functionality of Manager class Just by using the instance
like

manager("do Something")

We can do that with kotlin

We can simply implement a function called invoke which is defined as an operator and which can take any parameter

class Manager{
  operator fun invoke(value:String){
    prinln(value)
   }
}

Next Part: Classes