Namaste! Thanks for submitting to r/developersIndia . While participating in this thread, please follow the Community Code of Conduct and rules . It's possible your query is not unique, use site:reddit.com/r/developersindia KEYWORDS on search engines to search posts from developersIndia. You can also use reddit search directly. Recent Announcements & Mega-threads Community Roundup: List of must-read posts & interesting discussions that happened in September 2024 Who's looking for work? - Monthly Megathread - October 2024 I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns. More on reddit.com

The Java virtual machine doesn't have function types. The Kotlin function type compiles, quite literally, into an interface class. Go into your editor and create a class that inherits from ()->Unit like in the example. Intellij will say you need to implement a member from the interface "Kotlin.Function0". That interface is the "real code" and the function type syntax is sugar on top of that. Many Kotlin features are syntax sugar because the JVM literally doesn't support them natively. More on reddit.com

At their core, interfaces are a type. This definition is not that helpful in and of itself, but it's worth keeping in mind for the rest of this comment. When a class implements an interface, it becomes a thing of the type defined by the interface and that means it must provide everything that the type expects. This is what is meant when we say that an interface is a contract. What does this mean practically? Imagine that you are coding a game that involves creatures and as part of the game, you want them to move each turn. You may define an abstract Animal class and add a move() method to it and then subclass it for each creature. public abstract class Creature { ... snip ... public abstract void move(); ... snip ... } public class Dog extends Creature { ... snip ... public void move() { // Dog moves } ... snip ... } public class Cat extends Creature { ... snip ... public void move() { // Cat moves } ... snip ... } These could be used like this ... snip ... List creatures = new List<>(); creatures.add(new Dog()); creatures.add(new Cat()); ... snip ... for (Creature c : creatures) { c.move(); } ... snip ... Suddenly, you need to add vehicles to the game. Well, vehicles move but they are not creatures so extending the Creature class doesn't make sense. You could create another abstract class and process vehicles in their own loop, but what if you then have to add robots? Interfaces to the rescue! public interface Moveable { public void move(); } public abstract class Creature { ... snip ... } public class Dog extends Creature implements Moveable { ... snip ... public void move() { // Dog moves } ... snip ... } public class Cat extends Creature implements Moveable { ... snip ... public void move() { // Cat moves } ... snip ... } public class Car implements Moveable { ... snip ... public void move() { // Car moves } ... snip ... } These could be used in the same way as before ... snip ... List mobile = new List<>(); mobile.add(new Dog()); mobile.add(new Cat()); mobile.add(new Car()); ... snip ... for (Moveable m : mobile) { m.move(); } ... snip ... So, interfaces are a way of giving otherwise unrelated things a common type so that they can be used as that type without caring what they actually do. (Phew!) Edited to correct copy and pissed errors. More on reddit.com

The difference is mostly semantic: what does it "mean" to the person using it? The main, practical, difference is that a functional interface is just a regular object interface that comes with its own factory function- you can make instances by "calling" this auto-generated factory function and passing a lambda. A function type is, well, a function- not an object. The difference is negligible for the downstream implementer of the type. The difference is mostly in how the author intends to use a provided instance of the type. If you do a functional interface, you'll use it with a dot-notation method call, and if you do a function type, you'll just invoke it directly. So, again, it's all about semantics. Do you want to communicate that the thing in question is "an object that does a thing" or do you want to communicate that the thing in question is "an operation"? There is one more difference that's sometimes worth thinking about, which is that since a functional interface is just an interface, it means that a user must pass in something that was explicitly created for the purpose of being used in that way. A function type is obviously satisfied by any function/method that happens to have the same signature. I'm not sure that's ever really a problem, but maybe if you have a bunch of function types and some of them share the same signature, you might pass the wrong thing to the wrong API- maybe forcing an explicit named interface would be the safer option. More on reddit.com