toBePercent = (toBePercent.toFloat() / 100).toString()

dropLast

it.get

Nothing

let finished = false
for (let i = 0; i < restrictions.length && !finished; i++) {

      finished = ...

    }

override fun onOptionsItemSelected(item: MenuItem): Boolean {
    when (item.itemId) {
        R.id.convert -> startActivity(Intent(this, unitConvert::class.java))
    }
    return super.onOptionsItemSelected(item)
}

type CustomReturnType = (a: String, b: Int) => String

export class Foo {
  private aggregator: CustomReturnType[] = [
    (a: String): String => a,
    (a: String, b: Int) => {
      ...
      return "something"
    }
  ]
}

class Foo {
  var aggregator: MutableList<(a: String, b: Int) -> String> = mutableListOf()

  fun first(a: String): String {
    return a
  }

  fun second(a: String, b: Int) {
    ...
    return "something"
  }

  constructor() {
    aggregator.add(first)
    aggregator.add(second)
  }
}

Required: (String, Int) -> String

Found: String

sequence {}

data class MessageWithExpiry(
    val messageSerialized: ByteArray,
    val expiryDate: ZonedDateTime
)

data class Batch(
    val messages: Array<ByteArray>,
    val latestMessageExpiryDate: ZonedDateTime
)

fun batchMessages(messages: Sequence<MessageWithExpiry>): Sequence<Batch> = TODO()

Batch

MessageWithExpiry.messageSerialized

messages

messages

Sequence.scan

Batch.latestMessageExpiryDate

Sequence.map

Sequence.scan

Sequence.reduce

Sequence.fold

export interface Item {
  [label: string]: string[];
}

export interface SequenceMap {
  '1': string[] | Item ;
  '2': string[] | Item ;
}

sealed class

string[] | Item

val urlIds = ArrayList<Long?>

for (u in urls) {
  urlIds.add(u.id)
}

fun File.asSequence(): Sequence<String> {
    val reader = this.bufferedReader()
    return sequence {
        while (true) {
            yield(reader.readLine() ?: break)
        }
    }
}

fun File.asSequence2(): Sequence<String> = this.bufferedReader().let {
  // now sequence { } allows me to have `it` for the reader and `this` for the sequence
}

var

full syntax for any property in Kotlin:

var <propertyName>[: <PropertyType>] [= <property_initializer>]
    [<getter>]
    [<setter>]

Initializer, getter, and setter are optional here, but you need to initialize your variable if you don’t want to specify its type. Otherwise, the compiler will warn you.

class User {
    var firstName: String 
    var lastName: String
}

Cannot inline bytecode built with JVM target 1.8 into bytecode that is being built with JVM target 1.6. Please specify proper '-jvm-target' option

init

Leaking 'this' in constructor of non-final class A

.apply

A

abstract class A(injectedB: B) {
    init {
        injectedB.observeA(this)
    }
    
    val constructedB = B().apply {
        observeA(this@A)
    }
}

class B {
    fun observeA(a: A) {}
}

Given

Issues

Future

Deferred

data class HttpResponse(val status: Int, val body: String)

typealias RequestA = String
typealias ResponseA = String
typealias ErrorA = String

typealias RequestB = String
typealias ResponseB = String
typealias ErrorB = String

fun someFunction(
        callServiceA: (RequestA) -> Result<ResponseA, ErrorA>,
        callServiceB: (RequestB) -> Result<ResponseB, ErrorB>,
        input: String
): HttpResponse =
        callServiceA(input)
                .mapFailure { HttpResponse(409, "please provide a valid id") }
                .flatMap { responseA ->
                    callServiceB(responseA)
                            .mapFailure { HttpResponse(401, "you don't exist") }
                            .map { responseB -> HttpResponse(200, responseB.capitalize()) }
                }.get()

"\b[01]+\b".toRegex().matches("11010011")

"/^[0-1]+$/".toRegex().matches("11010011")

this::class.java.simpleName

let binaryString = "001110110001010001110100110111100100"
console.log(parseInt(binaryString, 2))
// output: 15859142116

var binaryNumber:String = "001110110001010001110100110111100100"
    
    try {
    var retr = binaryNumber.toInt(2)
    println(retr)        
    } catch(error: Throwable){
        println(error)
    }
// java.lang.NumberFormatException: Invalid number format: '001110110001010001110100110111100100'