Kotlin​ ​Quick​ ​Reference

This​ ​reference​ ​summarizes​ ​the​ ​topics​ ​covered​ ​in​ ​the​ ​Kotlin​ ​Bootcamp​ ​course​ ​in​ ​the​ ​form​ ​of​ ​code
snippets.​ ​See​ ​the​ ​Kotlin​ ​Language​ ​Documentation​​ ​for​ ​full​ ​reference.​ ​See​ ​the​ ​Kotlin​ ​Koans​​ ​for​ ​more
snippets​ ​to​ ​practice​ ​with.​ ​See​ ​the​ ​Kotlin​ ​Bootcamp​ ​course​ ​if​ ​you​ ​need​ ​anything​ ​explained.

Lesson​ ​0

Lesson​ ​1
Hello​ ​Kotlin​ ​function
Hello​ ​Kotlin​ ​program
Operators
Type​ ​conversion
Number​ ​formatting
val​ ​(immutable)​ ​&​ ​var​ ​(mutable)
Nullability
Strings​ ​/​ ​String​ ​Templates
if/else
When
listOf​ ​/​ ​mutableListOf
arrayOf​ ​/​ ​mutableArrayOf​ ​/​ ​intArray…
for​ ​loop
for​ ​(element​ ​in​ ​swarm)​ ​{...}

Lesson​ ​2
Functions
Compact​ ​Functions
Filters
Lambas​ ​(anonymous​ ​functions)
Higher​ ​order​ ​functions​ ​(fun​ ​with​ ​fun​ ​arg)

Lesson​ ​3
Class
Visibility
Inheritance
Abstract​ ​classes
Interfaces
Data​ ​Classes
Composition
Singleton​ ​/​ ​object
enum

Lesson​ ​4
 Pairs
Lists
Mapping
Constants
Extension​ ​functions
Property​ ​extensions
Generic​ ​classes
Generics:​ ​Full​ ​example
Generic​ ​constraint
In​ ​and​ ​Out​ ​Types
Generic​ ​functions​ ​and​ ​methods
Inline​ ​/​ ​reified
Annotations
Reflection
Annotations​ ​for​ ​getters​ ​and​ ​setters
Labeled​ ​breaks

Lesson​ ​5
Lambda​ ​recap
Higher​ ​order​ ​function
Standard​ ​Library:​ ​apply​ ​&​ ​run
Standard​ ​Library:​ ​with​ ​&​ ​repeat
Inline
Lambda​ ​instead​ ​ofSAM

Lesson​ ​0

● Install​ ​JDK​​ ​if​ ​you​ ​don't​ ​have​ ​it

● Link​ ​to​ ​downloading​ ​ ​IntelliJ
● Starting​ ​the​ ​interpreter:​ ​Tools​ ​>​ ​Kotlin​ ​>​ ​Kotlin​ ​REPL

Lesson​ ​1

Hello​ ​Kotlin​ ​function Hello​ ​Kotlin​ ​program

fun​ p ​ rintHello​ ​()​ ​{ fun​ ​main​ ​(args:​ ​Array<String>)​ ​{

​ ​ ​ ​ p​ rintln​ ​("Hello​ ​Kotlin") ​ ​ ​ ​println("Hello​ ​${args[0]}​ ​")
} }

printHello()

Operators Type​ ​conversion

*,​ ​fish.times(6) 1.toLong()
/,​ ​fish.div(10) 1.toString()
+,​ ​fish.plus(3)
-,​ ​fish.minus(3)

Number​ ​formatting val​ ​(immutable)​ ​&​ ​var​ ​(mutable)

​ neMillion​ ​=​ ​1_000_000

val​ o ​ quarium​ ​=​ ​"my​ a
val​ a ​ quarium"
val​ s​ ocialSecurityNumber​ ​=​ ​999_99_9999L var​ f​ ish​ ​=​ ​50
var​ s ​ nails​ ​:​ ​Int​ ​=​ 1​ 2

Nullability Strings​ ​/​ ​String​ ​Templates

var​ ​rocks:​ ​Int​ ​=​ ​null​ ​//Error "hello"​ ​+​ ​"fish"​ ​+​ ​"!"
var​ ​marbles:​ ​Int?​ ​=​ ​null "I​ ​have​ ​$numberOfFish​ ​fish"
fishFoodTreats?.dec() "Print​ ​${​ ​numberOfFish​ ​+​ ​5​ ​}​ ​fish"
"fish"​ ​==​ ​"fish"
var​ l ​ otsOfFish:​ ​List<String?>​ ​= val​ ​message​ ​=​ ​"You​ ​are​ ​${​ ​if​ ​(length​ ​<
​ ​ ​ ​ l​ istOf(null,​ ​null) 5)​ ​"fried"​ ​else​ ​"safe"​ ​}​ ​fish"

return​ ​fishFoodTreats?.dec()​ ​?:0

goldfish!!.eat

if/else When

if​ ​(numberOfFish​ ​>​ ​numberOfPlants)​ ​{ when​ ​(numberOfFish)​ ​{

​ ​ ​ ​ ​println("Good​ ​ratio!") ​ ​ ​0​ ​ ​->​ ​println("Empty​ ​tank")
}​ ​else​ ​{ ​ ​ ​in​ ​1..50​ ​->​ ​println("Got​ ​fish!")
​ ​ ​ ​ ​println("unhealthy​ ​ratio") ​ ​ ​else​ ​->​ ​println("Perfect!")
} }

if​ ​(fish​ ​in​ ​1..100)​ ​println(fish)

val​ ​isHot​ ​=
​ ​ ​if​ ​(temperature​ ​>​ ​90)​ ​true​ ​else​ ​false

listOf​ ​/​ ​mutableListOf arrayOf​ ​/​ ​mutableArrayOf​ ​/​ ​intArray…

val​ m ​ yList​ ​= val​ s ​ chool​ ​=

​ ​ ​ ​ m​ utableListOf("tuna",,"shark") ​ ​ ​ ​ a​ rrayOf("tuna","salmon","shark")

myList.remove("shark")​ ​//​ ​OK! val​ ​mix​ ​=​ ​arrayOf("fish",​ ​2)

val​ ​swarm​ ​=​ ​listOf(fish,​ ​plants) println(Arrays.toString(intArrayOf(2,

"foo")))
 val​ ​bigSwarm​ ​=​ ​arrayOf(swarm,
arrayOf("dolphin","whale","orka"))

val​ ​array​ ​=​ ​Array​ ​(5)​ ​{​ ​it​ ​*​ ​2​ ​}

for​ ​loop

for​ ​(element​ ​in​ ​swarm)​ ​{...}

for​ ​((index,​ ​element)​ ​in
swarm.withIndex())​ ​{
​ ​ ​ ​ ​println("Fish​ ​at​ ​$index​ ​is
$element")
}
for​ ​(i​ ​in​ ​'b'..'g')​ ​print(i)

for​ ​(i​ ​in​ ​1..5)​ ​print(i)

for​ ​(i​ ​in​ ​5​ ​downTo​ ​1)​ ​print(i)

for​ ​(i​ ​in​ ​3..6​ ​step​ ​2)​ ​print(i)​ ​//

Prints:​ ​35

Lesson​ ​2

Functions Compact​ ​Functions

fun​ ​randomDay():​ ​String​ ​{return fun​ ​isTooHot(temperature:​ ​Int)​ ​=

"Monday"} temperature​ ​>​ ​30

fun​ ​fishFood​ ​(hour:​ ​Int,​ ​day:​ ​String​ ​= fun​ ​shouldChangeWater​ ​(day:​ ​String,
"Tuesday"):​ ​String​ ​{} temperature:​ ​Int​ ​=​ ​22,​ ​dirty:​ ​Int​ ​=
20):​ ​Boolean​ ​{
fun​ ​isTooHot(temperature:​ ​Int):​ ​Boolean ​ ​ ​ ​ ​return​ ​when​ ​{
=​ ​temperature​ ​>​ ​30 ​ ​ ​ ​ ​ ​ ​ ​isTooHot(temperature)->​ ​true
​ ​ ​ ​ ​ ​ ​ ​else​ ​ ​->​ ​false
​ ​ ​ ​ ​}
}

fun​ ​getDirtySensorReading()​ ​=​ ​return​ ​20

fun​ ​shouldChangeWater​ ​(day:​ ​String,

temperature:​ ​Int​ ​=​ ​22,​ ​dirty:​ ​Int​ ​=
getDirtySensorReading())​ ​{...}

Filters Lambdas​ ​(anonymous​ ​functions)

{​ ​println("Hello")​ ​}()
 println(​ ​decorations.filter​ ​{it[0]​ ​==
'p'}) val​ ​waterFilter​ ​=​ ​{​ ​dirty:​ I
​ nt​ -​ >​ ​dirty
/​ ​2​ ​}
val​ ​waterFilter​ ​:​ ​(Int)​ ​->​ I​ nt​ =​ ​ ​{
dirty​ ​->​ ​dirty​ ​/​ ​2​ ​}

Higher​ ​order​ ​functions​ ​(fun​ ​with​ ​fun​ ​arg)

fun​ ​updateDirty(dirty:​ ​Int,​ ​operation:

(Int)​ ​->​ ​Int):​ ​Int​ ​{
​ ​ ​ ​return​ ​operation(dirty)
}
updateDirty(50,​ ​::increaseDirty)

Lesson​ ​3

Class Visibility

class​ ​Aquarium(var​ ​length:​ ​Int​ ​=​ 1 ​ 00, package:

var​ ​width:​ ​Int​ ​=​ ​20,​ ​var​ ​height:​ I​ nt​ ​= public​​ ​-​ ​default.​ ​Everywhere
40)​ ​{ private​​ ​-​ ​file
internal​​ ​-​ ​module
constructor(numOfFish:​ ​Int):​ ​this()​ ​{

​ ​ ​ ​ i ​ nit​ ​{ class:
​ ​ ​ ​ ​ ​//​ ​do​ ​stuff sealed​​ ​-​ ​only​ ​subclass​ ​in​ ​same​ ​file
​ ​ ​ ​ }​
inside​ ​class:
​ ​ ​ ​ ​val​ ​volume:​ I ​ nt public​​ ​-​ ​default.​ ​Everywhere.
​ ​ ​ ​ ​ ​ ​ ​get()​ ​{ private​​ ​-​ ​inside​ ​class,​ ​not​ ​subclasses
​ ​ ​ ​ ​ ​ ​ ​ ​ ​return​ w​ ​ ​*​ ​h​ ​*​ ​l​ ​/​ ​1000 protected​​ ​-​ ​inside​ ​class​ ​and​ ​subclasses
​ ​ ​ ​ ​ ​ ​ ​}
internal​​ ​-​ ​module
​ ​ ​ ​ i ​ nit​ ​{
​ ​ ​ ​ ​ ​ ​ ​//​ ​do​ ​stuff​ ​with​ ​volume
​ ​ ​ ​ }​
}

Inheritance Abstract​ ​classes

open​ ​class​ ​Aquarium​ ​…..​ ​{ abstract​ ​class​ ​AquariumFish​ ​{

​ ​ ​ ​ ​open​ ​var​ ​water​ ​=​ ​volume​ ​*​ ​0.9 ​ ​ ​ ​abstract​ ​val​ ​color:​ ​String
}
​ ​ ​ ​ ​open​ ​var​ ​volume
} class​ ​Shark:​ A ​ quariumFish()​ ​{
​ ​ ​ ​ ​override​ v​ al​ ​color​ ​=​ ​"gray"
class​ ​TowerTank​ ​():​ ​Aquarium()​ ​{ }
override​ ​var​ ​volume:​ ​Int class​ ​Plecostomus:​ ​AquariumFish()​ ​{
​ ​ ​ ​get()​ ​=​ ​(w​ ​*​ ​h​ ​*​ ​l​ ​/​ ​1000​ ​* ​ ​ ​ ​ ​override​ ​val​ ​color​ ​=​ ​"gold"
PI).toInt() }
​ ​ ​ ​set(value)​ ​{
​ ​ ​ ​ ​ ​ ​ ​h​ ​=​ ​(value​ ​*​ ​1000)​ ​/​ ​(w​ ​*​ ​l)}
}

Interfaces Composition

interface​ ​FishAction​ ​ ​{ fun​ ​main​ ​(args:​ ​Array<String>)​ ​{

​ ​ ​ ​fun​ ​eat() ​ ​ ​ ​delegate()
} }

class​ ​Shark:​ ​AquariumFish(),​ ​FishAction

{ fun​ ​delegate()​ ​{
​ ​ ​ ​override​ ​val​ ​color​ ​=​ ​"gray" ​ ​ ​ ​val​ ​pleco​ ​=​ ​Plecostomus()
​ ​ ​ ​override​ ​fun​ ​eat()​ ​{ ​ ​ ​ ​println("Fish​ ​has​ ​has​ ​color
​ ​ ​ ​ ​ ​ ​ ​println("hunt​ ​and​ ​eat​ ​fish") ${pleco.color}")
​ ​ ​ ​} ​ ​ ​ ​pleco.eat()
} }

fun​ ​feedFish(fish:​ ​FishAction)​ ​{ interface​ ​FishAction​ ​{

​ ​ ​ ​//​ ​make​ ​some​ ​food​ ​then ​ ​ ​ ​fun​ ​eat()
​ ​ ​ ​ ​fish.eat() }
}
interface​ ​FishColor​ ​{
​ ​ ​ ​val​ ​color:​ ​String
}

Data​ ​Classes object​ ​GoldColor​ ​:​ ​FishColor​ ​{

​ ​ ​ ​override​ ​val​ ​color​ ​=​ ​"gold"
data​ ​class​ ​Decorations(val​ ​rocks: }
String,​ ​val​ ​wood:​ ​String,​ ​val​ ​diver:
String){ class​ ​PrintingFishAction(val​ ​food:
} String)​ ​:​ ​FishAction​ ​{
​ ​ ​ ​override​ ​fun​ ​eat()​ ​{
val​ ​d​ ​=​ ​Decorations("crystal",​ ​"wood", ​ ​ ​ ​ ​ ​ ​ ​println(food)
"diver") ​ ​ ​ ​}
val​ ​(rock,​ ​wood,​ ​diver)​ ​=​ ​d }

class​ ​Plecostomus​ ​(fishColor:​ F ​ ishColor

dataClassInstance1.equals(dataClassInst =​ ​GoldColor):
ance2) ​ ​ ​ ​ ​ ​ ​ ​FishAction​ ​by
val PrintingFishAction("eat​ ​a​ ​lot​ o ​ f
dataClassInstance3.copy(dataClassInstan algae"),
ce2) ​ ​ ​ ​ ​ ​ ​ ​FishColor​ ​by​ ​fishColor
 Singleton​ ​/​ ​object enum

object​ ​Database enum​ ​class​ ​Color(val​ ​rgb:​ ​Int)​ ​{

​ ​ ​ ​RED(0xFF0000),​ ​GREEN(0x00FF00),
object​ ​MobyDickWhale​ ​{ BLUE(0x0000FF);
​ ​ ​ ​ ​val​ ​author​ ​=​ ​"Herman​ ​Melville" }
} Color.RED

Lesson​ ​4

Pairs Lists

val​ ​equipment​ ​=​ ​"fishnet"​ ​to​ ​"catching val​ ​testList​ ​=

fish" listOf(11,12,13,14,15,16,17,18,19,20)
println(equipment.first) listOf<Int>(1,2,3,4,5,6,7,8,9,0).revers
println(equipment.second) ed()

val​ ​(tool,​ ​use)​ ​=​ ​fishnet var​ ​symptoms​ ​=​ ​mutableListOf("white

val​ ​fishnetString​ ​=​ ​fishnet.toString() spots",​ ​"red​ ​spots",​ ​"not​ ​eating",
println(fishnet.toList()) "bloated",​ ​"belly​ ​up")
symptoms.add("white​ ​fungus")
symptoms.remove("white​ ​fungus")
Nesting​ ​with​ ​parentheses: symptoms.contains("red")
val​ ​equip​ ​=​ ​("fishnet"​ ​to​ ​"catching println(symptoms.subList(4,
fish")​ ​to​ ​("of​ ​big​ ​size"​ ​to​ ​"and symptoms.size))
strong")
equipment.first.first listOf(1,​ ​5,​ ​3).sum()
listOf("a",​ ​"b",​ ​"cc").sumBy​ ​{
it.length​ ​}

Mapping Constants

val​ ​cures​ ​=​ h

​ ashMapOf("white​ ​spots"​ ​to const​ ​val​ C
​ ONSTANT​ ​=​ "​ top-level
"Ich",​ ​"red​ s ​ ores"​ ​to​ ​"hole​ ​disease") constant"​ / ​ /​ ​compile​ t​ ime

println(cures["white​ ​spots"]) object​ ​Constants​ ​{

const​ ​val​ ​CONSTANT2​ ​=​ ​"object​ ​constant"
cures.getOrDefault("bloating",​ ​"sorry, }
I​ ​don't​ ​know")
class​ ​MyClass​ { ​
cures.getOrElse("bloating")​ ​{"No​ ​cure ​ ​ ​ ​ ​companion​ o ​ bject​ ​{
for​ ​this"} ​ ​ ​ ​ ​ ​ ​ ​ ​const​ v ​ al​ ​CONSTANT3​ ​=​ ​"constant
in​ ​companion"
val​ ​inventory​ ​=​ ​mutableMapOf("fish​ ​net" ​ ​ ​ ​ ​}
to​ ​1) }

inventory.put("tank​ ​scrubber",​ ​3)

inventory.remove("fish​ ​net")

Extension​ ​functions Property​ ​extensions

fun​ ​String.hasSpaces():​ ​Boolean​ ​{ val​ ​AquariumPlant.isGreen:​ ​Boolean

​ ​ ​ ​val​ ​found​ ​=​ ​this.find​ ​{​ ​it​ ​==​ ​'​ ​'​ ​} ​ ​ ​ ​get()​ ​=​ ​color​ ​==​ ​"green"
​ ​ ​ ​return​ ​found​ ​!=​ ​null
} fun​ ​propertyExample()​ ​{
​ ​ ​ ​val​ ​plant​ ​=​ ​GreenLeafyPlant(30)
fun​ ​extensionExample()​ ​{ ​ ​ ​ ​plant.isGreen​ ​//​ ​true
​ ​ ​ ​“Does​ ​it​ ​have​ ​spaces?”.hasSpaces() }
}

⇒​ f​ un​ S ​ tring.hasSpaces()​ ​=​ ​find​ ​{​ ​it

==​ '​ ​ ​'​ }​ ​ ​!=​ ​null

fun​ ​AquariumPlant.isRed()​ ​=​ ​color​ ​==

"red"

fun​ ​AquariumPlant?.pull()​ ​{
​ ​ ​ ​this?.apply​ ​{
​ ​ ​ ​ ​ ​ ​ ​println("removing​ ​$this")
​ ​ ​ ​}
}

Generic​ ​classes Generics:​ ​Full​ ​example

open​ ​class​ ​WaterSupply(var

class​ ​MyList<T>​ ​{ needsProcessed:​ ​Boolean)
​ ​ ​ ​fun​ ​get(pos:​ ​Int):​ ​T​ ​{
​ ​ ​ ​TODO("implement") class​ ​TapWater​ ​:​ ​WaterSupply(true)​ ​{
} ​ ​ ​ ​fun​ ​addChemicalCleaners()​ ​{
fun​ ​addItem(item:​ ​T)​ ​{} ​ ​ ​ ​ ​ ​ ​ ​needsProcessed​ ​=​ ​false
} ​ ​ ​ ​}
}
fun​ ​workWithMyList()​ ​{
​ ​ ​ ​val​ ​intList:​ ​MyList<String> class​ ​FishStoreWater​ ​:
​ ​ ​ ​val​ ​fishList:​ ​MyList<Fish> WaterSupply(false)
}
class​ ​LakeWater​ ​:​ ​WaterSupply(true)​ ​{
​ ​ ​ ​fun​ ​filter()​ ​{
​ ​ ​ ​ ​ ​ ​ ​needsProcessed​ ​=​ ​false
​ ​ ​ ​}
}

class​ ​Aquarium<T>(val​ ​waterSupply:​ ​T)

fun​ ​genericsExample()​ ​{
​ ​ ​ ​val​ ​aquarium​ ​=​ ​Aquarium(TapWater())
 aquarium.waterSupply.addChemicalCleanes
()
}

Generic​ ​constraint In​ ​and​ ​Out​ ​Types

Non-nullable: class​ ​Aquarium<out​ ​T:​ ​WaterSupply>(val

class​ ​Aquarium<T:​ ​Any>(val​ ​waterSupply: waterSupply:​ ​T)​ ​{​ ​…}
T)
interface​ ​Cleaner<in​ ​T:​ ​WaterSupply>​ ​{
class​ ​Aquarium<T:​ ​WaterSupply>(val ​ ​ ​ ​fun​ ​clean(waterSupply:​ ​T)
waterSupply:​ ​T) }

Generic​ ​functions​ ​and​ ​methods Inline​ ​/​ ​reified

fun​ ​<T:​ ​WaterSupply> inline​ ​fun​ ​<reified​ ​R:​ W

​ aterSupply>
isWaterClean(aquarium:​ ​Aquarium<T>)​ ​{ hasWaterSupplyOfType()​ = ​ ​ ​waterSupply​ ​is
​ ​ ​ ​println("aquarium​ ​water​ ​is​ ​clean: R
${aquarium.waterSupply.needsProcessed}"
) inline​ ​fun​ ​<reified​ ​T:​ W
​ aterSupply>
} WaterSupply.isOfType()​ = ​ ​ ​this​ ​is​ ​T

fun​ ​genericsFunExample()​ ​{ inline​ ​fun​ ​<reified​ ​R:​ ​WaterSupply>

​ ​ ​ ​val​ ​aquarium​ ​=​ ​Aquarium(TapWater()) Aquarium<*>.hasWaterSupplyOfType()​ ​=
waterSupply​ ​is​ ​R
​ ​ ​ ​isWaterClean(aquarium)
}

fun​ ​<R:​ ​WaterSupply>

hasWaterSupplyOfType()​ ​=​ ​waterSupply​ ​is
R

Annotations Reflection

@file:JvmName(“InteropFish”) val​ ​classobj=Plant::class

@JvmStatic​ ​fun​ ​interop() for(m​ ​in
classobj.declaredMemberFunctions){
annotation​ ​class​ ​ImAPlant ​ ​ ​println(m.name)
@ImAPlant​ ​class​ ​Plant{...} }

​ lantObject​ ​=​ ​Plant::class

val​ p
for​ (​ a​ ​in​ ​plantObject.annotations)​ ​{

println(a.annotationClass.simpleName)
}
 Annotations​ ​for​ ​getters​ ​and​ ​setters Labeled​ ​breaks

@Target(PROPERTY_GETTER) fun​ ​labels()​ ​{

annotation​ ​class​ ​OnGet ​ ​ ​ ​loop@​ ​for​ ​(i​ ​in​ ​1..100)​ ​{
@Target(PROPERTY_SETTER) ​ ​ ​ ​ ​ ​ ​ ​for​ ​(j​ ​in​ ​1..100)​ ​{
Annotation​ ​class​ ​OnSet ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​if​ ​(i​ ​>​ ​10)​ ​break@loop
​ ​ ​ ​ ​ ​ ​ ​}
@ImAPlant​ ​class​ ​Plant​ ​{ ​ ​ ​ ​}
​ ​ ​ ​@get:OnGet }
​ ​ ​ ​val​ ​isGrowing:​ ​Boolean​ ​=​ ​true

​ ​ ​ @​ set:OnSet
​ ​ ​ v​ ar​ ​needsFood:​ ​boolean​ ​=​ ​false
}

Lesson​ ​5

Lambda​ ​recap Higher​ ​order​ ​function

myFish.filter​ ​{ fun​ ​myWith(name:​ ​String,​ ​block:

it.name.contains("i")}.joinToString​ ​(" String.()​ ​->​ ​Unit)​ ​{
")​ ​{​ ​it.name​ ​} ​ ​ ​ ​ ​name.block()
}

Standard​ ​Library:​ ​apply​ ​&​ ​run Standard​ ​Library:​ ​with​ ​&​ ​repeat

fish.run​ ​{ with(fish.name)​ ​{
​ ​ ​ ​name ​ ​ ​ ​println(name)
} }

val​ f ​ ish2​ =
​ ​ F​ ish().apply​ ​{ repeat(3)​ ​{​ ​rep​ ​->
​ ​ ​ ​ ​ ​name​ =​ ​ “​ sharky” ​ ​ ​ ​ ​println("​ ​current​ ​repetition:
} $rep")}

Inline Lambda​ ​instead​ ​ofSAM

Inline​ ​fun​ ​myWith(name:​ S

​ tring, fun​ ​example()​ ​{
operation:​ ​String.()​ ​->​ U​ nit)​ ​{ ​ ​ ​ ​runNow​ ​{
​ ​ ​ ​ ​name.operation() ​ ​ ​ ​ ​ ​ ​println(“Passing​ ​a​ ​lambda​ ​as​ ​a
} Runnable”)
}