Hi, i got into this while learning lambdas

// this is what i kind of need
fun justFunction(i:Int?=1): Int {
    return 3
}
val b= justFunction(3)
val a = justFunction()

// but i wat to be able do define this behaviour by labdas
val singleParamFun: (i:Int?=1) -> Unit = ..
val aa = singleParamFun()
val bb = singleParamFun(2)

what does not compile for [Unsupported [default value of parameter in function type]] how would you appreach this when you want interface for functions wher eyou want to use defaults?

you have to provide the value <T>

Is there a reason that kotlin doesn't smartcast between number types? I imagine I'm not the only one a little miffed by constantly having to convert ints to doubles and vice versa

Kotlin deliberately avoids implicit casting with numeric types (changing between int and double for example) because it's sometimes the source of subtle bugs.

yeah, i suppose it's alright to just make a helpers folder and add your own casting functions if you really want them. not hard to do

like i almost immediately added one to cast booleans to ints

Yeah, you can write extension vals on

Int

and

Double

or whatever. When doing math I frequently want a

.i

extension val which is a "cast-to-int" call. Usable like

someByte.i

, which keeps the casting from being too distracting in a bunch of mathematically oriented code.

i also like adding functions for lists for adding many of a single kind of item so i can do

li = listOf(a, b) + 1000 * c

assuming c is not a number

probably not a necessary feature, but a nifty one

What's the difference between List and Array, and MutableList and ArrayList?

Lists are Java

List

objects,

Array

is an unoptimized wrapper around java arrays

So when should I use which? I guess I've never fundamentally understood the point of having more than just lists, mutablelists, and maps

and mutablemaps :S

generally speaking, use lists unless you know you need an array

MutableList is an interface that extends

List

with mutating functions,

ArrayList

is a class that implements

MutableList

so when should I use MutableList vs ArrayList?

currently on the JVM

mutableListOf()

yields ArrayLists

is it another case of err on the side of MutableList unless i know i need an arrayList?

more or less, but for different reasons

alright. there sure are a lot of different versions of collections in kotlin 😮

There’s a relatively simple hierarchy here

ArrayList

implements

MutableList

which extends

List

and ArrayList is an entirely separate implementation from Arrays in Java, iirc?

generally speaking, you don’t care how your MutableList was implemented, so calling

mutableListOf()

is fine

ArrayList uses Arrays under the hood to implement the List interface, hence the name.

I mean arraylist is a Java class, it’s a

List

backed by an array

okay, i appreciate it. not trying to use you guys as stackoverflow substitute... was just curious. for some reason i was under the assumption there was a slightly more meta reason for the existence of these various versions of collections.

right

am i the only one that feels like in this field we're inundated with so many acronyms that at some point you stop caring what they stand for?