Kotlin Standard Library JRE 8 Extension

import kotlin.streams.*
import kotlin.text.*

import kotlin.streams.*
import java.util.stream.Stream

// Convert Java 8 Stream to Kotlin Sequence
val stream = Stream.of("apple", "banana", "cherry")
val sequence = stream.asSequence()

// Convert Kotlin Sequence back to Java 8 Stream
val backToStream = sequence.asStream()

// Collect stream directly to List
val list = Stream.of(1, 2, 3, 4, 5).toList()
println(list) // [1, 2, 3, 4, 5]

/**
 * Creates a Sequence instance that wraps the original stream iterating through its elements
 */
fun <T> Stream<T>.asSequence(): Sequence<T>

/**
 * Creates a Sequence instance that wraps the original IntStream iterating through its elements  
 */
fun IntStream.asSequence(): Sequence<Int>

/**
 * Creates a Sequence instance that wraps the original LongStream iterating through its elements
 */
fun LongStream.asSequence(): Sequence<Long>

/**
 * Creates a Sequence instance that wraps the original DoubleStream iterating through its elements
 */
fun DoubleStream.asSequence(): Sequence<Double>

/**
 * Creates a sequential Stream instance that produces elements from the original sequence
 */
fun <T> Sequence<T>.asStream(): Stream<T>

/**
 * Returns a List containing all elements produced by this stream
 */
fun <T> Stream<T>.toList(): List<T>

/**
 * Returns a List containing all elements produced by this IntStream
 */
fun IntStream.toList(): List<Int>

/**
 * Returns a List containing all elements produced by this LongStream
 */
fun LongStream.toList(): List<Long>

/**
 * Returns a List containing all elements produced by this DoubleStream
 */
fun DoubleStream.toList(): List<Double>

import kotlin.streams.*
import java.util.stream.Stream
import java.util.stream.IntStream

// Stream to Sequence conversion
val stream = Stream.of("hello", "world", "kotlin")
val sequence = stream.asSequence()
val uppercased = sequence.map { it.uppercase() }.toList()

// IntStream to List
val numbers = IntStream.range(1, 6).toList() // [1, 2, 3, 4, 5]

// Sequence to Stream
val kotlinSequence = sequenceOf(1, 2, 3, 4, 5)
val javaStream = kotlinSequence.asStream()
val sum = javaStream.mapToInt { it }.sum()

/**
 * Returns a named group with the specified name
 * @param name The name of the capture group
 * @return An instance of MatchGroup if the group was matched, null otherwise
 * @throws UnsupportedOperationException if getting named groups isn't supported on the current platform
 */
operator fun MatchGroupCollection.get(name: String): MatchGroup?

import kotlin.text.*

val regex = "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})".toRegex()
val matchResult = regex.find("2023-12-25")
if (matchResult != null) {
    val year = matchResult.groups["year"]?.value  // "2023"
    val month = matchResult.groups["month"]?.value // "12"
    val day = matchResult.groups["day"]?.value    // "25"
}

// Java 8 Stream types
java.util.stream.Stream<T>
java.util.stream.IntStream  
java.util.stream.LongStream
java.util.stream.DoubleStream

// Kotlin types
kotlin.sequences.Sequence<T>
kotlin.collections.List<T>
kotlin.text.MatchGroup
kotlin.text.MatchGroupCollection

// Old (deprecated)
implementation 'org.jetbrains.kotlin:kotlin-stdlib-jre8:1.2.71'

// New (recommended)  
implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.2.71'