gbajaj

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CustomRecordExample {

  // Your static nested class is defined here
  static class Record {
    int first;

gbajaj

import java.util.ArrayList;
import java.util.Arrays;

// Your ArrayList of Integers
ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));

// Convert it to a primitive int[] array
int[] primitiveArray = arrayList.stream()
                                .mapToInt(Integer::intValue)
                                .toArray();

gbajaj

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Collectors;

int[] primitiveArray = {1, 2, 3, 4, 5};

// Use Arrays.stream() to convert the int[] to an IntStream, then collect it
ArrayList<Integer> arrayList = Arrays.stream(primitiveArray)
                                     .boxed() // Converts int to Integer
                                     .collect(Collectors.toCollection(ArrayList::new));

gbajaj

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

/**
 * A ViewModel to manage the logic of a single item in our shopping cart.
 */
class ShoppingCartItemViewModel {

    // A private MutableStateFlow to hold the current quantity of the item.
    // This will be updated by the UI when the user clicks the '+' or '-' buttons.

gbajaj

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

/**
 * A ViewModel to manage the logic of a single item in our shopping cart.
 */
class ShoppingCartItemViewModel {

    // A private MutableStateFlow to hold the current quantity of the item.
    // This will be updated by the UI when the user clicks the '+' or '-' buttons.

gbajaj

fun <T, R> Flow<T>.flatMapLatest(transform: suspend (T) -> Flow<R>): Flow<R> = flow {
    // This coroutineScope is key to managing cancellation of the inner flow
    coroutineScope {
        var previousJob: Job? = null

        collect { value ->
            // Cancel any ongoing inner flow collection
            previousJob?.cancelAndJoin()

            // Launch new inner flow collector in a new coroutine

gbajaj

fun <T> Flow<T>.distinctUntilChanged(comparator: (T, T) -> Boolean): Flow<T> = flow {
    var previous: T? = null
    var isFirst = true

    collect { value ->
        if (isFirst || !comparator(previous!!, value)) {
            emit(value)
            previous = value
            isFirst = false
        }

gbajaj

import kotlinx.coroutines.*

class Debouncer(private val delayMs: Long = 300) {
    private var debounceJob: Job? = null

    fun submit(scope: CoroutineScope, action: () -> Unit) {
        debounceJob?.cancel()
        debounceJob = scope.launch {
            delay(delayMs)
            action()

gbajaj

fun testGist() {
  println("Hello world!")
}

gbajaj

	#region Using declarations
	using System;
	using System.Collections.Generic;
	using System.ComponentModel;
	using System.ComponentModel.DataAnnotations;
	using System.Linq;
	using System.Text;
	using System.Threading.Tasks;
	using System.Windows;
	using System.Windows.Input;