Forem: Amandeep Singh

Higher-order functions and lambdas in Kotlin

Amandeep Singh — Wed, 02 Nov 2022 19:32:20 +0000

Higher-Order Functions:

Functions that return a function as their result, and function types which enable you to define functions as values. Some programming languages are purely functional, meaning the entire application is structured in this
style.
While Kotlin is not a pure functional programming language, it does provide many functional tools to allow developers to express logic in a functional paradigm. Here, we write our code-part after -> sign where type annotation is optional.
We must explicitly declare the type of our lambda expression. If lambda returns no value then we can use Unit
pattern : (Input) -> Output

But to understand Higher-Order functions with examples we need to learn about lambda expressions.

Lambda Expression:

A lambda expression is always surrounded by curly braces {} and arguments are declared inside the curly braces.
Syntax of lambda functions:

val lambda_name : Data_type = { variable -> body_of_function }

It will be easy to understand with an example:
We can use lambda functions to simply add to numbers 'a' and 'b'.

example with type annotation:

val add = { a: Int, b: Int ->
     val num = a + b 
}

example without type annotation:

val add:(Int,Int)-> Int  = { a , b -> 
       val num = a + b
}

Adding two numbers using lambda-functions:


val add = { a: Int, b: Int ->
    val num = a + b
    num.toString()     //convert Integer to String
}
fun main() {
    val result = add(2,3)
    println("The sum of two numbers is: $result")
}

Output:

The sum of two numbers is: 5

We can pass a lambda expression as a parameter to Higher-Order Function. Now we will go through Higher-Order functions:

var greeting = {println("Hello, My name is Amandeep Singh") }

      // using higher-order function
fun higherfunction( greet: () -> Unit ) {     // use of lambda as a parameter

    greet()                               //invokes lambda function

}

fun main() {

     //call higher-order function
    higherfunction(greeting)                 // passing lambda as parameter

}

Output:

Hello, My name is Amandeep Singh

That's it for lambda and Higher-Order functions. Now you have a tight grip over them.

If you have any doubt or suggestion you can share it in the discussion section.
Wanna connect? connect with me on LinkedIn

Functions in Kotlin

Amandeep Singh — Sun, 04 Sep 2022 05:48:06 +0000

Functions are something that we have used already for example the main() function. Functions are used to reuse code very easily. But today we will learn how to create our very own functions.

About Functions:

A block of code that performs a specific task
Breaks a large program into smaller modular chunks
Can take arguments with either named or default values
Functions are declared using the fun keyword and their general syntax is

fun myFunction(parameter1: Int, parameter2: String){

}

Parameters: Function parameters are defined using Pascal notation i.e., First the name of the parameter (example parameter1) followed by the Datatype of the parameter (example: Int). Parameters are separated using commas, and each parameter must be explicitly typed.

Function Arguments

Default Parameters
Required Parameters
Named arguments
Single-expressed functions

Default Parameters: Function parameters can have default values, which are used when you skip the corresponding argument. This reduces the number of overloads.
Default values provide a fallback if no parameter value is passed.

Required Parameters: If no default is specified for a parameter, the corresponding argument is required.

Default vs Required parameters

Named Arguments

When calling a function, you can name one or more of its arguments. This can be helpful when a function has many arguments and it's difficult to associate a value with an argument, especially if it's a boolean or null value.

When you use named arguments in a function call, you can freely change the order they are listed in, and if you want to use their default values, you can just leave these arguments out altogether.

Here we have a function reformat() which has 4 arguments with default values.

fun reformat(
    str: String,
    normalizeCase: Boolean = true,
    upperCaseFirstLetter: Boolean = true,
    divideByCamelHumps: Boolean = false,
    wordSeparator: Char = ' ',
) {
   //Your code
}

It's considered good style to put default arguments after positional arguments, that way callers only have to specify the required arguments.

The advantage of named functions is that we don’t have to name all its arguments when calling the function. you can skip all the default values and call the function like this:

reformat("This is a long String!")

Single-Expressed functions: Kotlin single-expression function is a function where a single expression is assigned to the function, and the expression’s evaluated value is returned when this function is called .
Single-expression functions are compact functions that make your code more concise and readable.
The syntax of Kotlin Single-Expression Function is:

fun functionName(parameters) = expression

An example of single-expressed of function:

fun double(x: Int):Int = x * 2 //single-expressed function

fun main(){
   val x =2 
   val square = double(x)
   println("The square of $x is $square")
}

OUTPUT: The square of 2 is 4

That's it for this Blog. Now you have a tight grip over Kotlin functions. We almost covered functions is Kotlin except Lambdas and higher-order functions, which we will cover in the next blog

If you have doubt in any part you can ask it in the discussion section.
Wanna connect? connect with me on LinkedIn

Objects and Classes in Kotlin

Amandeep Singh — Tue, 16 Aug 2022 15:46:00 +0000

Kotlin supports both object oriented programming (OOP) as well as functional programming. Object oriented programming is based on real time objects and classes.
We have seen classes before, for example our MainActicity() class.
Class is a blueprints of an objects. Classes define methods that operate on their object instances.

Syntax to use classes:

Kotlin classes are declared using keyword class.

class House {
  var color: String = "white"
  var numberOfWindows: Int = 2
  var isForSale: Boolean = false

  fun updateColor(newColor: String){
             newColor = Color
}
}

Objects in Kotlin:

Object is an instance of a class. Usually, you define a class and then create multiple instances of that class. Object is used to access the properties and member function of a class. Kotlin allows to create multiple object of a class.

Syntax of Using Object in Kotlin:

var obj = House()

Using a class:- We use a class by creating a new Object Instance

class House {
    var color: String = "white"

    fun updateColor(newColor: String){
        color = newColor
    }
}

fun main(){

    var myHouse = House()
    myHouse.updateColor("Green") //Updates the color of the House

    println(myHouse.color) // Will Print the new color of the House

}

Output:

Green

If you have doubt in any part you can ask it in the discussion section.
Wanna connect? connect with me on LinkedIn

Operators in Kotlin

Amandeep Singh — Sun, 07 Aug 2022 12:12:00 +0000

In this blog we will cover:

What are operators
Types of operators
Arithmetic Operators
Increment and Decrement Operators
Assignment Operators
Logical Operators
Bitwise Operators

What is an Operator?
An operator, in computer programing, is a symbol that usually represents an action or process. These symbols were adapted from mathematics and logic.
Operators are the backbone of any program and they are used for everything from very simple functions like counting to complex algorithms like security encryption.

We have different types of operators

Now, we will go through each type of operator one by one.
1.Arithmetic Operator: An operator that performs arithmetic operations on groups of variables and numbers is called Arithmetic operator.

fun main(){
    var a = 20 var b = 4 
        println("a + b = " + (a + b))
        println("a - b = " + (a - b))
        println("a * b = " + (a*b))
        println("a / b = " + (a / b))
        println("a % b = " + (a % b))
}

Output:

a + b = 24
a - b = 16
a * b = 80
a / b = 5
a % b = 0

You are familiar with all the operators because you use them in your daily life..but what does "%" this sign does?
This sign is called modulo(%).
OK, but what does it do?
The modulo division operator produces the remainder of an integer division. For example, If 5 and 2 are integers, then the expression:
5 % 2
produces the remainder when 5 is divided by 2, which is 1

2.Increment and Decrement Operators: The increment(++) and decrement operators(--) are important unary operators in Kotlin. Unary operators are those which are applied on a single operand. The increment operator increases the value of the variable by one and the decrement operator decreases the value of the variable by one.

Types of Increment Operators:

Prefix Increment Operator: If you use the ++ operator as a prefix like: ++var, the value of var is incremented by 1, then it returns the value.

fun main(){
    val num = 5
    println("num = "+ num++)//First the value of num is printed and then a1 increases by 1.
}

Output:

num = 5

Postfix Increment Operator: If you use the ++ operator as a postfix like: var++, the original value of var is returned first, then var is incremented by 1.

fun main(){
    val num = 5
    println("num = "+ ++num) //First the value of a2 increases by 1 and then the new value of num is printed.
}

Output:

num = 6

3.Assignment Operators: Assignment operators are used to assigning value to a variable. The left side operand of the assignment operator is a variable and right side operand of the assignment operator is a value. The value on the right side must be of the same data-type of the variable on the left side otherwise the compiler will raise an error. Assignment operator return a Boolean Values.
Different types of assignment operators are shown below:

Here is the code for your better understanding.

fun main(){
    var c = 30
    var d = 40
    println("c > d = "+(c>d))
    println("c < d = "+(c<d))
    println("c >= d = "+(c>=d))
    println("c <= d = "+(c<=d))
    println("c == d = "+(c==d))
    println("c != d = "+(c!=d))
}

Output:

c > d = false
c < d = true
c >= d = false
c <= d = true
c == d = false
c != d = true

4.Logical Operators: Logical operators are generally used for combining two or more relational statements. They return Boolean values. The logical operators are used primarily in the expression evaluation to make a decision. These operators allow the evaluation and manipulation of specific bits within the integer.

The types of Logical operators with their description are tabulated as follows -

fun main(){
    var x = 100
    var y = 25
    var z = 10
    var result = false
    if(x > y && x > z){
    println(x)
}
    if(x < y || x > z){
    println(y)
    }
}

Output:

100
25

5.Bitwise Operators:The bitwise operators are the operators used to perform the operations on the data at the bit-level. When we perform the bitwise operations, then it is also known as bit-level programming. It consists of two digits, either 0 or 1. It is mainly used in numerical computations to make the calculations faster. Bitwise and bit shift operators are used on only two integral types (Int and Long) to perform bit-level operations.

We have different types of bitwise operators in the Kotlin. The following is the list of the bitwise operators:

or: The or function compares corresponding bits of two values. If either of the bits is 1, it gives 1. If not, it gives 0. For example, Let's implement this in our code!

fun main() {

    val number1 = 12
    val number2 = 25
    val result: Int

    result = number1 or number2   // result = number1.or(number2)
    println(result)
}

Output:

and: The and function compares corresponding bits of two values. If both bits are 1, it is evaluated to 1. If either of the bits is 0, it is evaluated to 0. For example, Let's implement this in our code!

fun main() {

    val number1 = 12
    val number2 = 25
    val result: Int

    result = number1 and number2   // result= number1.and(number2)
    println(result)
}

Output:

xor: The xor function compares corresponding bits of two values. If corresponding bits are different, it gives 1. If corresponding bits are same, it gives 0. For example, Let's implement this in our code!

fun main() {

    val number1 = 12
    val number2 = 25
    val result: Int

    result = number1 xor number2   // result= number1.xor(number2)
    println(result)
}

Output:

inv(): The inv() function inverts the bit pattern. It makes every 0 to 1, and every 1 to 0. For example,

Let's implement this in our code!

fun main() {

    val number = 35
    val result: Int

    result = number.inv()
    println(result)
}

Output:

-36

Why are we getting output -36 instead of 220?
It's because the compiler is showing 2's complement of that number; negative notation of the binary number.

For any integer n, 2's complement of n will be -(n+1).
The bitwise complement of 35 is 220 (in decimal). The 2's complement of 220 is -36. Hence, the output is -36 instead of 220.

shl: The shl function shifts bit pattern to the left by certain number of specified bits, and zero bits are shifted into the low-order positions. For example,

Let's implement this in our code!

fun main() {

    val number = 212

    println(number shl 1)
    println(number shl 0)
    println(number shl 4)
}

Output:

424
212
3392

shr: The shr function shifts bit pattern to the right by certain number of specified bits. For example,

Let's implement this in our code!

fun main() {

    val number = 212

    println(number shr 1)
    println(number shr 0)
    println(number shr 8)
}

Output:

106
212
0

ushr: The ushr function shifts zero into the leftmost position. For example,

Let's implement this in our code!

fun main() {

    val number1 = 5
    val number2 = -5

    // Signed right shift
    println(number1 shr 1)

    // Unsigned right shift
    println(number1 ushr 1)

    // Signed right shift
    println(number2 shr 1)

    // Unsigned right shift
    println(number2 ushr 1)
}

Output:

Notice, how signed and unsigned right shift function works differently for 2's complement.

The 2's complement of 2147483645 is 3.

These are they types of operators we have in Kotlin. Hope you understood them well as you will be using them on a regular basis as an android developer😊.

You have doubt in any part you can ask it in the discussion section.
Wanna connect? then connect with me on LinkedIn

Kotlin Basics

Amandeep Singh — Wed, 27 Jul 2022 19:39:00 +0000

In this Kotlin Basics series ,we will cover :-
Operators
Data types
Variables
Conditionals
Lists and arrays
Null safety

Today's Content:

Creating a new project in Android Studio
Hello world in Kotlin
Variables in Kotlin
Datatypes in Kotlin

So to start we need an IDE. I will use Android Studio but you all can use some other IDE's as well such as IntelliJ , Visual Studio Code and others.

Lets get started...
Open Android Studio and select new project.
Select No Activity and click Next

Now a new project window appears with lot of details and it feels very overwhelming to the students seeing it for the first time, but don't worry we will decode it.

1: It is the name by which Android Studio will save your project. Since this is the Kotlin basics lesson I have named it Kotlin-basics

2: You can understand package name as an unique Id which helps to distinguish apps on other devices and Google Playstore. Each project you create on Android will have an unique package name. You don't need to own a .com domain in order to release apps on Play store. It is just a standard. So, Pick some unique name and suffix it with "com. "

3: Save location is the location of the directory and folders in which your current project will be saved. You can use the default location or select your own. As you wish.

4: This is a language selector with two options: Java or Kotlin. In this course we use Kotlin.

5: Minimum SDK is the minimum android version in which your App will run. In this lesson I am using API 21 which is Android-5(Lollipop) and it covers almost 98.6% of Android devices on this planet and that is a huge number.
Using very low API means you will cover a lot more of Android devices but you will not be able to use a lot of latest libraries introduced in higher API's by Google. So, I think API 21 will be a balanced option for most of you all.

Now, lets dive in and select Finish.
If its your first time Android Studio will take time to build Gradle files and import libraries, but the next time onwards it will not take so much time and it is recommended you have a high speed internet connection to load the project as quick as possible.

I have a different theme applied but your workspace should look more or less like this.
Right-Click on com.example.kotlin_baiscs_01 folder then go to
new->Kotlin/class file then give your file a name while the file section is selected and then press Enter.

Now your window should look like this

HELLO WORLD
lets print hello world in Kotlin. First we need to create a main function
fun main(){ println("hello world") }
Now, there are many ways to run your code as pointed in the image

It is necessary to have the fun main() block, this is where your code runs. Though you can have several functions but the main() function is must as it is the starting point of our application. It is a special type of function and not a generic function.

VARIABLES IN KOTLIN

Variables are simply containers for storing values(data values). To create a variable we use var or val. We use var for storing or initializing such type of data that will or may change in our code. On the other hand data stored in val cannot be changed again or we do not want to change once initialized .For example
val name= "Amandeeep" val age= 18
we have the name "Amandeep" in a variable called name and age in a variable called "age".

DATATYPES IN KOTLIN

These are types of DataTypes that we have in Kotlin

Integer types: Kotlin provides a set of built-in types that represent numbers. Unlike other languages we do not need to define the datatype for our variables in Kotlin. For example ```

val one = 1 // Int
val threeBillion = 3000000000 // Long
val oneByte = 1

And if we need to specify our datatype then we can do it as the following :

val one: Int = 1
val 3billion : Long = 3000000000
val oneByte : Byte =1

For integer numbers, there are four types with different sizes and, hence, value ranges.
![range of int datatype](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/97szw0bxa1y8im0a1uj6.png)

- **Floating-point types:**<br/>
Kotlin provides floating-point types **Float** and **Double** for Real numbers[example:(0.4, 3.1415927, 1/2)]
floating point types differ by their decimal place, that is, how many decimal digits they can store.**Float** can store 6 to 7 digits places after decimal while **Double** is more precise as it can store 15 to 16 digits after decimal point.
![range of float and double](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xj8qotnd7nl7x55kh4fh.png)

- **Boolean Data type:**<br/>
The Boolean data type and can only take the values true or false. Boolean values are mostly used for conditional testing, which you will learn more about in a later chapter.

val kotlinIsFun: Boolean = true
val fishIsTasty: Boolean = false

println(kotlinIsFun) // Outputs true
println(fishIsTasty) // Outputs false


- **Character Data type:**<br/>
The Character data type(represented by **char**) is used to store a single character. 
Char data type represents the small letters(a-z), Capital letters(A-Z), digits(0-9) and other symbols. A **char** value must be surrounded by single quotes, like 'A' or 'c'.

val myGrade: Char = 'A'
println(myGrade) // output: A

- **String Data type:**<br/>
The String data type is used to store a sequence of characters (text). String values must be surrounded by double quotes.

- Strings are any sequence of characters enclosed by double quotes.
  val s1 = "Hello world!"
- String literals can contain escape characters
  val s2 = "Hello world!\n" 
_Here, "\n" is an escape character which inserts a newline in the text where it appears._
- Or any arbitrary text delimited by a triple quote (""")
  val text = """ var bikes = 50 """

**That's all for Today. Thank You!!😃**
Till then **keep coding!!**
![Thank You](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wwtohfmjqzep67x70oek.png)

Intro to Android Development

Amandeep Singh — Thu, 14 Jul 2022 20:56:00 +0000

TODAY'S CONTENT: Course overview and Android Studio Setup

What you'll learn in this Bootcamp:

[] How to build a variety of Android apps in Kotlin
[] Kotlin language essentials
[] Best practices for app development
[] Resources to keep learning
[] You will build a lot of apps during this whole Bootcamp and some will be of Industry Standard

What is Android Studio?
To write code for your Android application, you need some kind of environment or code editor that will make your task easy. No doubt, you can write the same code by using any normal text editor but Android Studio is required to build Android applications.You can surely code in other IDE'S(Integrated Developer Environment)
but cannot build apps on them. As the course is structured in teaching what is necessary to be a proficient developer we will not waste time on unnecessary knowledge.

So, Let's Setup Android Studio on your machine!

How to install Android Studio?
In order to install Android Studio in your system, make sure to download the latest version of the Android Studio from Android Studio website. Also, check the system requirements of Android Studio here.

To install Android Studio, you can follow the steps mentioned in the Android Developer website for Android Studio Installation.

After installing, Open Android Studio and it should show you this screen.
Click on "Start a new project"

That's all for today!! Today was just a overview of this Bootcamp.

Stay Connected and keep learning🙌