I can accomplish this with star types, but I'd rather have the type safety (and also the intellij help from knowing the type)

When creating a class from another class which have the exact same field names as the parameters for the constructur, like this:

fun fromData(data: Food) = DTOFood(
  id = data.id,
  whenCreated = data.whenCreated,
  whenModified = data.whenModified,
  singularName = data.singularName,
  pluralName = data.pluralName,
  singularNameIsStandard = data.singularNameIsStandard,
  searchTags = data.searchTags,
  category = data.category
)

Is there like a helper function available or how do you write a helper function like that to avoid having to do this?

What you think about having additional parameterized constructor that would be used to pass in mock objects for unit testing only? Would you consider it a bad design since test only code is being inserted to production code? I’m working on a very small project and do not want to add the complexity of a dependency injection framework and thinking about injecting mocks into the class this way only when doing unit testing. Wondering if people find this as a bad design. Another way would be

@VisibleForTesting

annotation to assign mocks to variables directly but I find injecting mocks via the constructor is easier to read and clarify which objects needs to be mocked.

I know this is a total non-issue, but why does adding kotlin to a

build.gradle

require so many steps? Groovy, for example, only requires

apply plugin: 'groovy'

. Just curious about this

Are there interfaces associated with overloadable operators? E.g. a

Plus

for the

plus()

method. It would be great to be able to define

sum()

on an

Iterable<Plus>

, for instance.

Is there a better unit test code coverage tool than Jacoco for Kotlin ? It appears Jacoco analyzes the byte code generated from Kotlin compiler so results are slightly off from what you would expect from reading Kotlin source code.

What would be the right way to generate an UUID in kotlin?

I just noticed the source link for Unit is broken on the kotlinlang website. Wasn't sure the best place to report... https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-unit/index.html Click on the Unit source link. It looks like the latest version isn't there, because if you change the url from https://github.com/JetBrains/kotlin/blob/1.2.51/core/builtins/src/kotlin/Unit.kt#L22 to (1.2.50) its there https://github.com/JetBrains/kotlin/blob/1.2.50/core/builtins/src/kotlin/Unit.kt#L22

@Gta there is no

then

in kotlin

When should I consider making a function

infix

? Is there a rule of thumb? Is it worth considering when writing a sort of DSL?

Just ran this and it works, time to clean it up. Thanks @karelpeeters and @Seri

Hi, what is the possible ways to localize enum ?

What does mean "Replacing Cs with Ks in libraries"? https://pusher.com/state-of-kotlin

A question came up on another Slack: what's the best way to diff two huge data classes? https://github.com/SQiShER/java-object-diff ?

isn't there another better stlib fun instead calling

dropWhile

+

drop

?

if (file.exists())
        file.readLines()
                .dropWhile { !it.startsWith('#') }.drop(1)

@Lucas Ł I'll be damned it worked! You don't know how many hours you saved me I tried everything from sublist to Arraylist(listToBeCopied) my last resort was to json serialize the whole shit and deserialize it again hoping this would make a new deep copy of object inside the list

you're welcome 😂, another way would be to make the object Parcelable and re-create it

It would need to cover things like

val y = x++

too. I'd say submit a YouTrack issue.

Hi there. Is there some alternative in

Kotlin

to Guava's

EvictingQueue

? https://google.github.io/guava/releases/15.0/api/docs/com/google/common/collect/EvictingQueue.html

is there any tool to translate lombok-java into kotlin ?

Are we allowed to write our own kotlinx libraries ?(ie kotlinx.SOMELIBRARY)

I mean, if “intelligibility” is your goal, why not just manually null-check? it’s about the same number of characters

@karelpeeters there is something similar

is it a design or technical reason to allow destructurization only for local variables and lambdas? I'm looking for top level variables

Hello, currently I'm working with a legacy method that throws an exception when error occurs. I could wrap it with a new one and rethrow to an upper layer, but also, I could create a sealed class to represent the response of the method (success or error). What do you think is the best approach. I would prefer to used sealed classes (or maybe a functional Either) than rethrowing errors.

<!here> It’s not often that we use notifications on #general, but today calls for a celebration. If you haven’t noticed, you now have history in Slack! We’re extremely grateful to Slack and specifically to @sam for helping put this in motion.

is this the first community who has slack subscription?

And now's a good time to ask: Should we be posting our knowledge to this isolated platform which is not indexed by search engines? Doesn't this slow down the dissemination of knowledge? 🤔 (I know, many channels aren't affected by this)

Can we access the JNI via Kotlin? (where is the

native

keyword)