your "flexible" solution voids all typesafety though

I have this snippet

.assertValueAt(2) {
                it is ImageChangeEvent.ImageUpdated
                        && it.position == 0
                        && it.changedFields.contains(CollectImage.IMAGE_MODE)
                        && it.image.imageMode == newImageMode
            }

The Kotlin Lint plugin complaints about this with

Line must not begin with "&&"

. Is this actually true? I couldn’t find anything in the coding conventions

Since

set(value) = ...

for custom setters on variable is also allowed, I'd say it's no problem.

Unit

is just a normal return type and value in Kotlin.

@travis Option 1 means

catch exception

->

put it in a Result

->

rethrow another/the same exception

, so definitely Option 2

private fun String.endpoint() = File(this).name.split("?")[0]

vs

private val String.endpoint
  get() = File(this).name.split("?")[0]

Is the idiomatic way to call nullable lambdas

lamdba?.invoke()

?

Depends on case and constant name

is that limit fix or customizable?

Hello Guys, I have a question about code style. We are developing a UI test helper library for Android Instrumentation tests and thought having common assertions in separate files can be convenient. But we are not sure if we should declare those functions top-level or in an object such as “ImageViewAssertions”. *So my question is: * When do you use top-level (root package) functions and when do you put them inside objects ?

Hi guys. I want to limit amount of Kotlin features and code style, so it doesn’t compile or at least shows warnings for incorrect style. Is it possible ?

what is the preferred style to write multiline condition expressions? 1:

val c = if (a !== b)
    "1" else
    "2"

2:

val c = if (a !== b)
    "1"
else
    "2"

3:

val c = if (a !== b) "1"
else "2"

4:

val c = if (a !== b) {
    "1"
} else {
    "2"
}

if the if and else are both single-line expressions I’m kinda partial to this

val result = if (condition) first
             else second

could not find any information in https://kotlinlang.org/docs/reference/coding-conventions.html

!

is a single, slender character that’s easier to gloss over than

not

is

yeah, i also think that it preceding the rest of the call bothers me, but what are you gonna do with unary operators?

the feature disparity between the two formatters is quite intentional. the focus for the Kotlin formatter is to support the official Kotlin style guide. we do not want to encourage people to bring all of their accumulated code formatting idiosyncrasies to Kotlin

and the reason why we aren’t going to endorse “align fields in columns” in the official style guide is exactly what @egorand says: one of the guiding principles of the official style guide is to avoid whitespace changes induced by changing the length of identifiers as much as possible

It's so hard for me to avoid the temptation to just include all functionality corresponding to an object within that object itself

If I have an

enum

class, is it better to declare it inside a data class (where it logically belongs) or top-level outside of the class declaration?

https://ktor.io/quickstart/code-style.html#with-star-imports who uses this in projects?

@elizarov any good articles discussing “Kotlin-style design and prefer extensions over members”?

Do you always put all the property declarations in a class before any method declaration, or do you make exceptions (like a property used in just one method further down)?

For constructor param indentation when each is on a separate line, is it supposed to be 4 or 8? Android studio defaults to 8 but ktlint flags it as 4...

there’s no consensus even between the two style guides that I know of • https://kotlinlang.org/docs/reference/coding-conventions.html#class-header-formatting • https://developer.android.com/kotlin/style-guide#continuation_indent I prefer the Kotlin one personally 😄

convinced everyone to use the 4...weird that Android Studio's default isn't 4. The examples in the guides seem to prefer 4: fun <T> Iterable<T>.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "" ): String { (though that's method call parameters vs. constructor params which the Android style guide doesn't cover) and from the Kotlin style guide class Person( id: Int, name: String, surname: String ) : Human(id, name) { ... }

Is there any recomendation for enum usage?

Hi Is it possible to compose extension functions ? Let's say I have an extension function :

val myFunc: A.() -> Unit = { // this: A
    customField = "value" 
}
val otherFunc: A.() -> Unit = { // this: A
    otherField = "other"
}

I want to have a function that is the combination of both above I don't know how to write this.

Don't you find yourself in a situation, when you start writing

with

then realize that the type is nullable and fallback to

?.apply{}

? Relevant question on SO: https://stackoverflow.com/questions/35723226/how-to-use-kotlins-with-expression-for-nullable-types

Hello, I have a public interface called "Foo" and it has an internal default

object

implementation. What's the preferred way to get the implementation's instance? 1️⃣ Companion object as the default implementation

interface Foo {
  companion object : Foo {
    // default implementation goes here

2️⃣ Quasi constructor

interface Foo {
  companion object {
    operator fun invoke(): Foo = DefaultFooImpl

3️⃣ Top level method

fun defaultFoo(): Foo = DefaultFooImpl

Oh interesting. How would you translate the snippet above into free-form?