This was a pretty neat video about the top languages and how they became popular.

Is there any reason why Kotlin chooses Double as default type for decimals over Float?

Why do I need to cast the result of the

map

operation in the following sample :

sealed class Request<T> {
    object Pending : Request<Nothing>()
    class Success<T>(val result: T) : Request<T>()
    class Failure(val error: Throwable) : Request<Nothing>()
}

val sourceFlow: Flow<Foo> = getFooFlow()
sourceFlow.map { Request.Success(it) as Request<Foo> }
    .onStart { emit(Request.Pending) }
    .catch { emit(Request.Failure(it) }
    .onEach { ... }
    .launchIn(scope)

Will this kind of issue be fixed by the new Kotlin inference ? Or is there a workaround (other than creating a typed temporary variable) ?

This message was deleted.

I have a data class foo

kotlin
data class Foo(
    val a: Int,
    val b: String,
    val c: Int
    val d: Int
) {}

And I have another data class partialFoo, where I have partial fields of foo

kotlin
data class PartialFoo(
    val a: Int,
    val b: String
) {}

Is there any way that I can copy the fields of class instance of

Foo

to class instance of

PartialFoo

?

kotlin experimental unsigned types can’t be shifted? (at least, not UShort?)

for example, I have a byte array, I want to grab bytes.slice(3 until 5) and get a UShort from them

Those annotations won't come from the plugin I don't think, they should come from a dependency defined in your build gradle -> dependency block

Why does the kotlin github repo README file not translate to other languages?

Is there a channel for discussing the Android Dev Summit stuff?

howdy! I was wondering if KMongo has coro support for GridFS

I am using DynamDBMapper annotations on a data class (AWS Java SDK). The mapper uses a default Java constructor pattern when deserializing an object, assigning properties through setters after object instantiation. Is there anything I can do on my end to retain read-only

val

attributes in the class constructor? I had to change everything to

var

and I hate mutability ...

sorry wrong window

Why can't we create generic wrapper classes, like

class Wrapper<T> (val value: T) : T by value

?

import kotlin.random.Random

val x= Random().nextInt(from :1,until :7)
        println(x)

why is this code showing

incomplete code

I've found a way to keep using

ResultWrapper<out T>

but I'm curious now how to implement

Either

on the execute method. I found a way like

data class Success<out T : Any>(val value: T) : ResultWrapper<T>()

UInt… is it 32 bits? Or is it “it depends” similar question for ULong 64 or “guess and see”

does kotlin (jvm) have any kind of weak identity map, or an equivalent feature (ie, to let my code effectively add a property to an arbitrary object)? I know Java has WeakHashMap but I want the map to be based on identity, not hashCode.

Is there a difference between it and this in kotlin? If so, why do different scoping functions use one but not the other?

hey guys, scratching my head over

@JvmOverloads

on a data class constructor- it doesn’t seem that every permutation of the constructor is created to match default parameters

We are suddenly experiencing a version problem. After emptying the gradle cache the build fails without changing anything else.

> Could not resolve all files for configuration ':api:testCompileClasspath'.
   > Could not find org.jetbrains.kotlin:kotlin-stdlib-common:1.3.60-eap-76.
     Required by:
         project :api > org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2-1.3.60-eap-76
   > Could not find org.jetbrains.kotlin:kotlin-stdlib-common:1.3.60-eap-76.
     Required by:
         project :api > org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.3.50 > org.jetbrains.kotlin:kotlin-stdlib:1.3.50
         project :api > org.jetbrains.kotlin:kotlin-test:1.3.50 > org.jetbrains.kotlin:kotlin-test-common:1.3.50
         project :api > org.jetbrains.kotlin:kotlin-test-junit5:1.3.50 > org.jetbrains.kotlin:kotlin-test-annotations-common:1.3.50

This is in the gradle file.

plugins {
    id 'org.springframework.boot' version '2.1.8.RELEASE'
    id 'org.jetbrains.kotlin.jvm' version '1.3.50'
    id "org.jetbrains.kotlin.plugin.spring" version "1.3.50"
}

allprojects {

    apply plugin: 'kotlin'
    apply plugin: 'io.spring.dependency-management'
    apply plugin: 'kotlin-spring'

    repositories {
        mavenCentral()
        jcenter()
    }
}

Is anyone else experiencing this? Any suggestions?

I’m confused by something. HashMap has a filterKeys (among others) method. But they’re defined as Map interface things. It seems I then have to cast the result back to HashMap, e.g. this.modifyRegistry { registry -> registry.filterKeys { oid -> keepOIDs.contains(oid) } as HashMap } I don’t understand why it doesn’t know that registry is a HashMap<PlanID, Plan>. I’ve typed it that way everywhere. But without that

as Hashmap

I get warnings/errors. I feel like I’m missing some piece of the puzzle that it wasn’t obvious/apparent to me to put the as Hashmap there.

So, I just realized that with

as?

it does not trigger the

init {}

method, and I'm losing some info here when doing the casting from

Serializable

<http://java.io|java.io>

interface that is setup in

init{} block

. So, I'm wondering if there is a way to invoke the

init {}

when casting with

as?

?

Any news on Kotlin 1.4?

gonna do an intro to kotlin presentation at my company. slideware then a coding exercise. curious if anyone has any good coding exercises they’ve found useful for something similiar. something that actually solves a real-ish problem, and is useful for highlighting a good amount of the features that makes kotlin interesting. (something a bit more complicated than the individual kotlin koans)

On the flow page, they use an event stream as an example of a flow use. Is this really a good use case? If you consider a typical event loop, it seems like it should be producing values all the time, regardless of whether or not anything is there to receive them. Isn't that more like a Channel?

Hi all. I set out to convince my employer to start using inline classes in our android codebase while they are still experimental. Does anyone have any arguments for or against using them while they are still experimental aside from the obvious experimental status and the fact that inline classes are awesome.

What can I pass to a Java method that expects a

Void!

?

Has anyone used Firebase in their Kotlin applications?

Anyway I can make this work somehow ?

fun <T> foo(aClass: java.lang.Class<T>): MutableList<T> {
  return mutableListOf()
}

inline fun <reified T:Any> bar(t: T): MutableList<T> {
  // fails here: expected: MutableList<T>, found: MutableList<out T>
  return foo(t::class.java) 
}