DEV Community: Shalveena

What are Lambdas and Higher Order Functions in Kotlin and How Can You Use Them?

Shalveena — Wed, 14 Sep 2022 06:07:09 +0000

Lambdas are widely used in Kotlin so you've most likely come across them, but if you're like me you might be asking, "What exactly is a Lambda? What does it do and how can I use them?"

This article attempts to answer those questions. Specifically:

What a lambda is
How to write a lambda (in other words, the syntax of a lambda)
What a higher order function is and how lambdas are used in higher order functions.

So, what is a lamda?

The simple answer is that lambdas are functions. But more specifically, a lambda is a function that is written as an expression, and that is not declared using the fun keyword.

Here is an example of a regular function:

fun greeting() {
  println("Hello World!")
}

The same function can be written as a lambda:

val greeting = { println("Hello World!")}

You can call the lambda function by using the variable name followed by parentheses: greeting().

val greeting = { println("Hello World!") }

// In the main function:
greeting() // prints: Hello World!

Note: you can also call the lambda function by using greeting.invoke()

Great, now that you know a bit about what a lambda is, we will have a look at how to write (and read) a lambda in the next section.

How to write a lambda? The syntax.

You can write a lambda within curly braces. The parameters are separated from the function body by an arrow. So the parameters are written first, then an arrow and then the function body.

Extending our greeting example, let's give it one parameter so you can see the syntax of a lambda with parameters:

val greeting = { name: String -> println("Hello, $name")}

// In the main function:
greeting("Sam") // prints: Hello, Sam

Function Types

Since Kotlin is a statically typed language, every variable must have a type. In the above example, the greeting variable is of a function type because it holds a function (since a lambda is a function after all). Variables that hold lambdas are of a function type.

Kotlin can infer the function type implicitly, but you can also write it explicitly.

If you were to write out the full syntax of greeting, it would look like:

val greeting: (String) -> Unit = { name: String -> println("Hello, $name")}

The above reads as:

greeting is a variable of a function type
it will hold a function
the function it holds will take a String argument and return Unit.

Short-hand syntax for lambdas

There are three simplifications we can make to the lambda syntax, which makes it easier to read.

1) When the variable declaration has an explicitly declared function type, for example a function type that takes a String and returns Unit (like in the example above), you don't have to explicitly define the parameter of the lambda as being of String type.
This is because Kotlin already knows that the lambda will have a String type parameter since it has been explicitly defined in the variable declaration. This is easier to illustrate through code:

val greeting: (String) -> Unit = { name: String -> println("Hello, $name")}

/* We don't need to explicitly say that the
name parameter will be of String type.
We can simplify it to:
*/

val greeting: (String) -> Unit = { name -> println("Hello, $name")}

2) If the lambda has only one parameter, you don't have to write the parameter. Instead, there is an it keyword that you can use to refer to the parameter. So you can further simplify greeting to:

val greeting: (String) -> Unit = { println("Hello! $it")}

3) You don't need to use the return keyword. This is because the last expression within the lambda's body is treated as the return value. To illustrate, let's change our greeting function to return a String:

val greeting: (String) -> String = {"Hello, $it"}
greeting("Sam") // Will return "Hello, Sam" even though the return keyword was not used in greeting.

What is a higher order function?

Higher order functions are functions and take a function as an argument. Phew, so many "functions" there!

Note: When writing higher order functions, it is best practice in Kotlin to have the function argument as the last parameter.

An example of a higher order function:

fun createLongGreeting (firstSentence: String, secondSentence: String, operation: (String) -> String) : String {
    return "${operation(firstSentence)} $secondSentence"
}

In the above example, createLongGreeting is a higher order function that creates and returns a string template using:

the result of calling an operation (function) on the first sentence, and
the second sentence

It takes 3 arguments:

A string (the firstSentence parameter)
A string (the secondSentence parameter)
A function (the operation parameter)

Okay, so how can lambdas help you when it comes to higher order functions?

Since higher order functions take another function as an argument, you need to be able to pass functions to them. If you try to pass a regular function as the argument, Kotlin will throw an error because it will think you're trying to call the function instead of simply passing it in as an argument. For example if you try the following, it will give you an error:

fun partGreeting(name: String): String {
  return "${name}! It's has been a long time!"
}

createLongGreeting("Sam", "How are you?", partGreeting) // error: Function invocation 'partGreeting(...)' expected. No value passed for parameter 'name'

You need a way to easily pass functions as arguments to the higher order functions. And that's where lambdas come to the rescue.

Passing in a lambda as a parameter to a higher order function

Lambdas allow you to easily pass functions as arguments.

Continuing with the example from above, you can pass a lambda directly into createLongGreeting as its last argument. The lambda must be one that takes a String as it's argument and returns a String.

// The createLongGreeting function
fun createLongGreeting (firstSentence: String, secondSentence: String, operation: (String) -> String) : String {
    return "${operation(firstSentence)} $secondSentence"
}

// In the main function:
// Calling createLongGreeting and passing a lambda directly to it as it's last argument.
val firstGreeting = createLongGreeting("Sam", "How are you?", { name -> "$name! It's been a long time!" })

println(firstGreeting) // Sam! It's been a long time! How are you?

Here is a breakdown of what is happening in the above example:

We call createLongGreeting, passing it:
- "Sam" as it's first argument
- "How are you?" as it's second argument
- A lambda as it's third argument
createLongGreeting calls our lambda, passing it "Sam"
Our lambda returns a string: "Sam! It's been a longtime!"
createLongGreeting creates a string template, inserting the string returned from the lambda call ("Sam! It's been a longtime!") and the string we passed as the second argument ("How are you?")
createLongGreeting returns the string it created in step 4: "Sam! It's been a long time! How are you?"

Trailing lambda syntax

To make our example easier to read, we can actually put the lambda outside the parenthesis:

val firstGreeting = createLongGreeting("Sam", "How are you?") { name -> "$name! It's been a long time!" }

This is known as a trailing lambda syntax.

Assigning a lambda to a variable and passing that variable to the higher order function

Another way we can use lambdas with higher order functions is by assigning the lambda to a variable and passing that variable as an argument to the higher function.

First, we need to make a lambda and assign it to a variable:

val greeting: (String) -> String = {"Hello, $it!"}

Next, we pass greeting to createLongGreeting. Note that we don't call greeting directly. We just pass it to createLongGreeting. It's createLongGreeting that calls greeting when making its string template.

// The createLongGreeting function:
fun createLongGreeting (firstSentence: String, secondSentence: String, operation: (String) -> String) : String {
    return "${operation(firstSentence)} $secondSentence"
}

// Our lambda - the greeting function:
val greeting: (String) -> String = {"Hello, $it!"}

// In the main function, call createLongGreeting and pass it greeting as it's last argument:
val secondGreeting = createLongGreeting("Sam", "How are you?", greeting)
println(secondGreeting) // Hello, Sam! How are you?

As mentioned earlier, if greeting were a regular function (or a single line function) instead of a lambda, we could not pass it to createLongGreeting as above, because Kotlin will think that we are trying to call greeting and give an error. But there is a way to pass a regular function as an argument: we can use the :: symbol to pass the function as a reference.

In the example below, greeting is written as a single line function and passsed to createLongGreeting as a reference:

fun greeting(name: String) = "Hello, $name!"

// In the main function:
val secondGreeting = createLongGreeting("Sam", "How are you?", ::greeting)

Bonus tip: you could capture a user's input, clean it up and use it in `createLongGreeting`:

First, create a function to clean the user's input data:


val cleanUserInput: (String) -> String = { userInput -> userInput.replace(userInput[0], userInput[0].uppercaseChar()).trim()
}

Then, in the main function, prompt the user to enter their name and assign it to a variable:

print("Please enter your name: ")
val usersName = readln()

Finally, call createLongGreeting, passing it the input from the user, the string "Good to see you!" and the cleanUserInput function. The cleanedUserInput function will be called within createLongGreeting to clean the input from the user:

val thirdGreeting = createLongGreeting(usersName, "Good to see you!", cleanUserInput)
println(thirdGreeting) // if the user inputs "hallie", the output would be "Hallie Good to see you!"

So there you have it - now you know more about:

what lambdas are,
how they look like,
how to write them,
what higher order functions are,
and how you can use a lambda to pass a function as an argument to a higher order function.

Thanks for reading!

What the heck is an API? A Beginner's guide to APIs

Shalveena — Wed, 23 Mar 2022 23:52:49 +0000

What is an API?

API is short for Application Programming Interface.

It's how one computer (or software) can talk to another computer (or software).

Basically, an API is where a computer or software application (the client) asks another computer or software application (the server) for some data or to do some task.

In the case of humans, imagine I wanted to talk to you but you were in New York while I was in London. I can't just walk over to you and talk to you face-to-face. But, I can pick up my mobile phone and dial your number. That will cause your phone to ring. You pick up your phone, and we can talk through the use of our mobile phones. It's similar with computers; they can't talk to each other directly. They need an API to enable that communication.

Another way to imagine it is by thinking about making an order at a restaurant. You, the customer, cannot talk directly to the chef and tell her what you want. Instead, you need to go through the waiter. The waiter takes your order and relays that to the chef. The chef then prepares what you want, gives it to the waiter, and the waiter gives it to you. In this example, you are the client computer, the chef is the server and the waiter is the API through which you and the chef communicate.

An example of an API: SWAPI

The Star Wars API (https://swapi.dev/) is an API that provides data about Star Wars. If you ask it for planets/3/ it will give you all the data about planet 3.

OK, so now you sort of know what an API is. But what is a RESTful API?

REST stands for REpresentational State Transfer.

You might be asking yourself, "What in the world does that mean?" This article on Medium explains it really well:

It means when a RESTful API is called, the server will transfer to the client a representation of the state of the requested resource.

For example, when a developer calls Instagram API to fetch a specific user (the resource), the API will return the state of that user, including their name, the number of posts that user posted on Instagram so far, how many followers they have, and more.

The representation of the state can be in a JSON format, and probably for most APIs, this is indeed the case. It can also be in XML or HTML format.

Usually, a RESTful API will return a JSON data structure. JSON stands for Java Script Object Notation and consists of key-value pairs.

HTTP Requests and Responses

HTTP is a communication protocol that computers (or applications) use to communicate with each other. It controls how computers communicate with each other.

The client computer will send a HTTP request for what it wants to the server and the server will return a HTTP response. Note that a RESTful API usually uses HTTP, but it does not have to.

There are four methods used by HTTP requests. These are known as the CRUD methods: Create, Read, Update, and Delete.

GET Requests

Let's take an example: www.facebook.com

When we want to go to Facebook, we are telling our browser to get us data from www.facebook.com and then show it to us. We just want to load the website; we don't want to change or delete anything, we just want to see it. This is the most common type of request.

POST Requests

A POST request is where we request to make a brand new resource. Ideally, when we make a POST request, it will return all the unique identifiers for that new resource to us so that we can then make a GET request using those unique identifiers.

For example, say we want to create a new user on Facebook. We go to the sign up page and put in all our details to create the new user account. We then click 'submit', which sends the request to the server. The server receives it and recognises that it's a POST request (to make a new user; a new resource). It then makes the new user for us and sends us the login information for the new user. We can then use that login information to make a GET request to login to Facebook and see the contents of the page.

Going back to the restaurant metaphor, this is like ordering a pizza: you tell the waiter that you want a Hawaiian pizza. The waiter then tells the chef that you want a Hawaiian pizza. The chef prepares the pizza for you, which the waiter then delivers to you. This is a POST request because you have asked the chef to prepare a brand new resource: a Hawaiian pizza.

DELETE Requests

A DELETE request is where one computer asks another computer to delete a resource. For example, if we want to delete some photos from Facebook, or we want to delete a post from Instagram. When using DELETE, we need to be cautious that we don't delete entire lists by mistake! To avoid this, give the DELETE method a specific endpoint.

PATCH Requests

A PATCH request is when we send a request to update a part of the resource.

For example, taking our restaurant example, imagine that you've finished your meal and the waiter brings you the bill.

While going through the bill to check it, you notice that you were charged the wrong amount for your Hawaiian pizza. You were charged $20 instead of $15. You did have pizza (and that is correctly recorded in the bill), but the amount charged is incorrect. You want that updated.

You notify the waiter of the error and ask for the bill to be corrected. The waiter then tells the chef or whoever is in charge of the bill, the bill is then corrected and the new (corrected) bill is given to you.

Another example would be when you ask a credit agency for your credit file and you want to check whether the details they have are correct. You make the request (GET request), the agency emails you the credit file and then you check it. You notice that they've got your title/prefix wrong: they've recorded you as Mr Sally Potter instead of Ms Sally Potter. You then send the agency an email asking them to correct this small error. This is a PATCH request - the file that the agency sent you was indeed the correct file (your credit file) and it contained all your details, but one of the pieces of information was wrong and you've asked for that to be corrected.

Although we can use PATCH requests to update information, not all browsers and frameworks accept PATCH requests. This is where PUT requests come in (see below).

PUT Requests

A PUT request is when you ask for an entire resource to be updated (not just a part of it).

Going back to the restaurant example, this would be where you look at the bill and notice that you got charged for a beer which you didn't order or drink. What you actually ordered was a bottle of sparkling water. You therefore ask the waiter to please remove the charge for the beer from your bill and add in the sparkling water.

Summary Table for HTTP Requests

HTTP Method	CRUD Operation
POST	Create
GET	READ
PATCH	Update or modify (partially)
PUT	Update (fully) or replace
DELETE	Delete

Responses

When you make a request, the information is conveyed to the server and the server provides a response. The response will be an HTTP status code.

There are different HTTP response status codes, ranging from 100's to 500's. Usually, a response in the 200's indicates that things are good, and a response in the 400's means something on your end is not quite right. For a full list of the different HTTP response status codes visit the MDN docs page on HTTP response status codes.

Further reading

If you're curious and want to read more about Restful APIs and HTTP, here is a good article about REST & HTTP. This article explains the difference between a REST API and a HTTP API.

Photo by Marvin Meyer on Unsplash

Basics of Z Shell for Newbie Developers

Shalveena — Wed, 16 Mar 2022 20:43:38 +0000

I’ve always been a bit scared of the terminal. It brings up images of a black screen with green text, with a hacker furiously typing away at the keyboard.

The terminal is a powerful tool, and pretty unforgiving of mistakes. If you delete something by accident or mess something up, there’s usually no going back.

While setting up my laptop for my new job, I was instructed to enter and execute various commands (that looked like jargon to me!) into the terminal. I had very little idea of what I was doing, but thankfully managed to bumble my way through without destroying anything too badly. But this prompted me to learn a bit more about the terminal and Z Shell, the shell used by most MacBooks.

What is the difference between the terminal and the shell?

The shell is the program that processes the commands we input and outputs the results.

The terminal is like a wrapper that goes around the shell. It allows us to enter commands and it translates the keystrokes for the shell. The terminal supports fonts, colours, etc.

Basics of using Z Shell

Below are the basic commands used to navigate the file system using Z Shell.

cd moves to your home directory
cd Documents moves to the Documents sub-folder
If you want to move to a completely different folder (that is, not a sub-folder within your current directory), use the full pathname. For example: cd /Applications/Rectangle.app
Your home page is usually represented by the symbol ~ So if you want to access a folder that is inside your home directory, you can begin with ~ For example: cd ~/Desktop
cd .. takes you up one level (to the parent directory) pwd prints the current working directory (the directory you’re currently in). This is very helpful if you don’t know where exactly you are.
ls lists the contents of the current directory. Note, you can also use this to find out the contents of a directory without actually going into that directory: ls ~/Desktop will show the contents of the Desktop folder.
You can also add options to the ls command: // list all files (including hidden files) ls -a // list files in long format ls -l // Note: you can also combine them. For example: ls -la

Viewing and editing files

Viewing files

cat Documents/hello will display the text from the file named hello.

If you try to use the cat command on a document that is not a text file, it may stuff up your terminal. If that happens, use the reset command to fix it: reset

Alternatively, less Documents/hello will also show you the content of the file, but with a bit more features. You navigate it using:

spacebar to go down a page
b to move up
q to exit

Editing files

For editing files, you can use Nano or Vim (both are usually already installed in most systems).

Using Nano:
nano tiny_page will open the file named tiny page.

The commands for Nano are then shown on screen. The only things to remember is that the ^ symbol refers to the control key, and “WriteOut” means to save!

Using Vim:
Vim is a pretty scary looking editor. Mostly because the commands and the way it works seems completely different to every other word editor and almost alien! But, it is also very powerful and has a lot of features. I am not a Vim power user, and have only learnt the very basics so that’s what I’m sharing here.

vim tiny_page will open up the file named tiny page.
It first opens up in command mode, which means you cannot edit anything in the file. To edit, first enter insert mode by typing i You can then edit as you like.
To exit insert mode, just press esc key.
To save, press :w
And, most importantly, to exit press :q or :q! to exit without saving.

Opening files

open hello will open the file named hello in using the default application.
If you’ve configured VS Code to be your default editor for git, you can use code hello to open the file named hello in VS Code.
open . will open the current folder.
open -a Preview picture.jpg will open picture.jpg in Preview.
open -a Microsoft/ Word hello will open hello in Microsoft Word.

Creating files and folders

touch hello will create a file named hello. You can create multiple files in one command too: touch file1 file2 file3 will create three files; file1, file2, and file3.
mkdir will make a new folder. You can also create multiple folders in one command: mkdir ~/folder1 ~/folder2 will make two folders (folder 1 and folder 2) inside your home directory.

Moving and renaming files and folders

mv source destination moves the file or folder from the source folder to the destination folder.
mv currentFileName newFileName can be used to rename files.

Getting help: man pages

If you want more information about any of the commands, you can bring up the relevant man page by typing man followed by the command you want information about. For example: man ls

To navigate around the man page, use:

spacebar to move down a page
b to move up
/ to search
n to go to the next match
q to quit

Other tips

Use the up and down arrow to cycle through previous commands you’ve used.
Use tab to autocomplete file and folder names. This has the added advantage that there will be no typos in the names.
file HelloWorld will show the type of the file. For example, whether it is a .jpg file or a .pdf file.

These the basic commands that I’ve learnt so far. I’ll keep learning and sharing as I continue this journey as a budding software developer. Thanks for reading!