./gradlew run

Flow

sealed class LoadRequest<out T> {
  object Pending : LoadRequest<Nothing>()
  class Success<T>(val data: T) : LoadRequest<T>()
  class Failure(val error: Exception) : LoadRequest<Nothing>()
}

val someFlow: Flow<Foo> = ...
val requestFlow: Flow<LoadRequest<Foo>> = someFlow
  .map { LoadRequest.Success(it) as LoadRequest<Foo> }
  .onStart { emit(LoadRequest.Pending) }
  .catch { emit(LoadRequest.Failure(it) }

as LoadRequest<Foo>

No cast needed

Type mismatch

LoadRequest.Pending

LoadRequest.Failure

LoadRequest.Success<Foo>

import kotlinx.coroutines.*


fun main() {
    repeat(3) {
        GlobalScope.launch {
            println("Hi from ${Thread.currentThread()}")
        }
    }
}

6:14:05 PM: Executing task 'Coroutines_multipleKt.main()'...

> Task :wrapper

BUILD SUCCESSFUL in 184ms
1 actionable task: 1 executed
> Task :compileKotlin
> Task :compileJava NO-SOURCE
> Task :processResources NO-SOURCE
> Task :classes UP-TO-DATE
> Task :Coroutines_multipleKt.main()

BUILD SUCCESSFUL in 712ms
2 actionable tasks: 2 executed
6:14:06 PM: Task execution finished 'Coroutines_multipleKt.main()'.

Hi from Thread[DefaultDispatcher-worker-1 @coroutine#1,5,main] Hi from Thread[DefaultDispatcher-worker-1 @coroutine#2,5,main] Hi from Thread[DefaultDispatcher-worker-1 @coroutine#3,5,main]

ScreenState

emptyScreen()

data class AppState (
    val masterState : ScreenState<MasterData> = ScreenState<MasterData>(),
    val detailState : ScreenState<DetailData> = emptyScreen(),
)

data class MasterData (
    val countriesList : List<CountriesListItem> = emptyList(),
    ...
)
data class DetailData (
    val countryInfo : CountryInfo = CountryInfo(),
    ...
)

List

emptyList()

public interface ScreenState<screenData T> {
    val isLoading: Boolean = false,
    val screenData: T? = null,
}

public fun <T> emptyScreen(): ScreenState <T> = EmptyScreen

internal object EmptyScreen : ScreenState <Nothing> {
}

inline fun <reified T:Any> getResponse(endpoint : String): T? {
	
	val newObj = T()
	....

    }

fun isClass(theObject : Any, theClass : KClass) : Boolean {
    if (theObject is theClass) {
        return true
    }
    return false
}

val verification = isClass(myObject, Person::class)

sealed class Error(val code: String) {
    object Type1 : Error("type1")
    data class Type2(val someParam: String) : Error("type2")
}

// somewhere else in code
if (error.code == Type2.code) { }

var (x, y) = Tuple.Create("hello", "world");
// or
var (x, y) = ("hello", "again");
// or also
var x = ("hello", "again");
x.Item1 // hello
x.Item2 // again
// or also also
var x = (Xpto: "Hello", Yup: "Again")
x.Xpto 
x.Yup

@Serializable
data class BaseResult<T>(val data: T, val foo: Int)

@Serializable
data class SomeData(val bar: String)

// Then when decoding incoming json I do:
val response = Json { ignoreUnknownKeys = true }
    .decodeFromString<BaseResult<SomeData>>(responseBody)

Serializer for class 'SomeData' is not found.
kotlinx.serialization.SerializationException: Serializer for class 'SomeData' is not found.
Mark the class as @Serializable or provide the serializer explicitly.

enum class Status(val value: Int) {
  Ok(0),
  NotOk(1),
  SomeOtherStatus(2)
}

implementation('com.example:MyKMMProject-jvm:1.0')

mongoOperations.findAndModify(searchQuery, update, T::class.java)

.windowed

fun foo(exc: Exception)

fun<T : Throwable> foo(exc: KClass<T>)

fun<T : Throwable> foo(exc: KClass<T> = InvalidParamExc::class)

object1: TestType  = [
	object2=[
		(...)
		random = ...,
		stringList = ["1", "2", "3"]
	],
    object2(),
    object2(),
    (....)
]

object2Mapper

fun TestType.getWithout3(): TestType {
	val returnObject = object1
	returnObject.forEach { object1 ->
		object1.object2.forEach { object2 ->
			object2.stringList.toMutableList.removeAll { item == "3"}
		}
	}
	return returnObject
}

val aggregation = Aggregation.newAggregation(Aggregation.sample(1))
        val commit = mongoOperations.aggregate(aggregation, "commit", Commit::class.java).uniqueMappedResult
        commit?.message
            ?.let { return ResponseEntity<String>(commit.message, HttpStatus.OK) }
            ?: throw ResponseStatusException(HttpStatus.NOT_FOUND, "Unable to find commit")