Any advantages over other? Please suggest.

which of

also

,

run

,

let

,

apply

etc should I use: 1. the extension must be lambda that takes one parameter (like let), can't be

this

2. it automatically returns the input just like

apply

does

What is the advantage of using

asSequence

before `filter`s and `map`s?

To stay on the same topice (almost 😛 ), I have a question about data types. For each item, I have a KEY, a PATH and a NAME value. I would like to be able to find the two others quickly if I have any of the three. Is there a kotlin way to do it efficiently? I was thinking of doing a hashmap with a data class that contains the two other value, but then it only works if I searrch by KEY, not by PATH or NAME. Any idea?

So then you mean

internal

?

I have a question that I wanted to ask long ago. Why online Kotlin docs do not display code snippets instantly? One just has to wait few minutes for it to appear

private val items : MutableList<String> by lazy {
        // a lot of init code
    }

how do I exclude my initialisation code into a separate function? I can think of creating something like

private val items : MutableList<String> by lazy {
        init()
}
fun init() : MutableList<String> {...}

but maybe there is more elegant way

Which one makes more sense? I don't care about the return values here

mFilter.run {
            addAction( Intent.ACTION_PACKAGE_INSTALL )
            addAction( Intent.ACTION_PACKAGE_ADDED )
            addAction( Intent.ACTION_PACKAGE_REMOVED )
            addAction( Intent.ACTION_PACKAGE_FULLY_REMOVED )
            addDataScheme("package")
        }

        mFilter.apply {
            addAction( Intent.ACTION_PACKAGE_INSTALL )
            addAction( Intent.ACTION_PACKAGE_ADDED )
            addAction( Intent.ACTION_PACKAGE_REMOVED )
            addAction( Intent.ACTION_PACKAGE_FULLY_REMOVED )
            addDataScheme("package")
        }

Is there a better way to write this?

val launchUri = try {
                if( isAvailable() ) {
                    Uri.parse( "..." )
                } else {
                    Uri.parse("..." )
                }
            } catch ( e : android.content.ActivityNotFoundException ) {
                if( isAvailable() ) {
                    Uri.parse( "..." )
                } else {
                    Uri.parse("..." )
                }
            }

in combi with ktlint, which can automatically configure the formatting options in idea to conform to (afaik) the kotlin style guidelines

@ValV IntelliJ can also provide hints that formatting doesn’t conform. In inspections, search for

formatted according to project settings

and turn it on. Appears under Kotlin. Then if code doesn’t conform to formatting, it will have the colour you chose here with squiggly lines around it. I’m not sure if this will appear in an Analyze run. You may be able to modify the Analyze rules and have IntelliJ expose formatting issues.

I have an object created from Java class

IntegerStringConverter

that trows exceptions like

java.lang.NumberFormatException

, is it possible to catch or suppress them without

try ... catch

block?

Shouldn't this fail at compilation? or does return default to false?

val list = listOf( 1, 2, 3, 4, 5 )
    val evenList = list.filter {
        return
        it % 2 == 0
    }

Confusing not-so-different syntaxes

How can I do generic cast? I need something like:

inline fun <reified T> convert(text: String): Any? {
  return try {
    text to T // something bad is happening here
  } catch (e: Exception) {
    null
  }
}

Hi, I am new to kotlin and just started using Coroutines. I have few doubts. 1. If Coroutines is a language feature then why do we need to add dependencies. 2. How can I try latest 1.3 RC version in Android Studio. I tried following (and of course at its right place)

// Downloaded 1.3. early preview plugin of Kotlin for Android Studio

ext.kotlin_version = '1.3.0-rc-46'
// ext.kotlin_version = '1.3.0-rc-57'
maven { url '<https://dl.bintray.com/kotlin/kotlin-eap>' }
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"

implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-core:0.30.1") {
        exclude group: "org.jetbrains.kotlinx", module: "atomicfu-common"
    }
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:0.30.1'

Above setup giving me error

No route to host (connect failed)

3. What working for me is just

ext.kotlin_version = '1.2.71'

implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-core:0.30.1") {
        exclude group: "org.jetbrains.kotlinx", module: "atomicfu-common"
    }
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:0.30.1'

Please guide me in the right direction. Thanks.

quick question.... do any of you get tired of answering the same questions over and over? what are those questions?

Of course the constructors of classes should be able to access

this

, and default parameters are evaluated in a constructor.

Attempting to use Kotlin PSI (writing a Detekt rule). Trying to find annotation on a function.

function.annotationEntries.any { it.shortName?.identifier == "PublishedApi" }

works but may be false-positive for

some.custom.package.PublishedApi

. How should I fix this, where's annotation FQN?

One more thing: how can I check whether lambda expression will be inlined? I can ascent until I meet ValueArgument/ValueArgumentList/CallExpression, but can't find a way to get method being called.

need to do the following:

val counterWithTwoTags = metric.counterTwoTags("my.counter.name", "key1", "key2")
try{
  someHttpCall()
  counterWithTwoTags("value1", "value2")
catch(Exception e) {
  counterWithTwoTags("errorValue1", "errorValue2")
}

I want to make sure that the

name

for the counter remains immutable, but the the value is not. I was thinking that companion objects was the right way, but this seems more like for static methods.

so if I have something like this:

data class MetricTag<T>(val name: String, var value: T)

I can mutate the value??

How can I marshal

ObservableList<ObservableList<ObservableValue<Any>>>

? Do I need inherit and annotate it? Are there better (Kotlin-specific) ways to marshal an object?

Yeah, it would make my life easier, but I need all the references to print this on a chart (dates on x-axis, values on y-axis) 😁

yes

Use

buildSequence

any particular reason you need XML over JSON?

Is there any way to use

kotlinx.serialization

for a Javascript project to convert my data class to a simple Javascript object and back without all the heavy auto gen code and to string serialization?