Scala Collection Compat

import scala.collection.compat._

import scala.jdk.CollectionConverters._
import scala.jdk.OptionConverters._
import scala.util.chaining._
import scala.util.Using  // For resource management (Scala 2.11 only)

import scala.collection.compat._

// Safe string parsing (returns Option types)
val num = "42".toIntOption  // Some(42)
val bad = "abc".toIntOption  // None

// New collection methods
val numbers = List(1, 2, 3, 4, 5)
val maxValue = numbers.maxOption  // Some(5)
val minValue = List.empty[Int].minOption  // None

// Method chaining
import scala.util.chaining._
val result = List(1, 2, 3)
  .tap(println)  // prints List(1, 2, 3) for debugging
  .pipe(_.sum)   // transforms to sum: 6

// Backported collections
import scala.collection.compat.immutable._
val lazyList = LazyList.from(1)  // infinite lazy sequence
val arraySeq = ArraySeq(1, 2, 3)  // immutable array-backed sequence

type Factory[-A, +C] = CanBuildFrom[Nothing, A, C]  // On 2.11/2.12

trait BuildFrom[-From, -A, +C] {
  def fromSpecific(from: From)(it: IterableOnce[A]): C
  def newBuilder(from: From): mutable.Builder[A, C]
}

implicit class StringOps(s: String) {
  def toBooleanOption: Option[Boolean]
  def toByteOption: Option[Byte]
  def toShortOption: Option[Short]
  def toIntOption: Option[Int]
  def toLongOption: Option[Long]
  def toFloatOption: Option[Float]
  def toDoubleOption: Option[Double]
}

implicit class TraversableOnceExtensionMethods[A](self: TraversableOnce[A]) {
  def minOption[B >: A](implicit ord: Ordering[B]): Option[A]
  def maxOption[B >: A](implicit ord: Ordering[B]): Option[A]
  def minByOption[B](f: A => B)(implicit cmp: Ordering[B]): Option[A]
  def maxByOption[B](f: A => B)(implicit cmp: Ordering[B]): Option[A]
}

implicit class TraversableLikeExtensionMethods[A, Repr](self: GenTraversableLike[A, Repr]) {
  def tapEach[U](f: A => U)(implicit bf: CanBuildFrom[Repr, A, Repr]): Repr
  def partitionMap[A1, A2, That, Repr1, Repr2](f: A => Either[A1, A2]): (Repr1, Repr2)
  def groupMap[K, B, That](key: A => K)(f: A => B): Map[K, That]
  def groupMapReduce[K, B](key: A => K)(f: A => B)(reduce: (B, B) => B): Map[K, B]
  def distinctBy[B, That](f: A => B): That
}

// LazyList - replacement for Stream
final class LazyList[+A] extends AbstractSeq[A] with LinearSeq[A] {
  def head: A
  def tail: LazyList[A]
  def isEmpty: Boolean
  def force: this.type
  def knownSize: Int
}

object LazyList {
  def from[A](coll: GenTraversableOnce[A]): LazyList[A]
  def iterate[A](start: => A)(f: A => A): LazyList[A]
  def continually[A](elem: => A): LazyList[A]
  def unfold[A, S](init: S)(f: S => Option[(A, S)]): LazyList[A]
}

// ArraySeq - immutable array-backed sequence  
abstract class ArraySeq[+T] extends AbstractSeq[T] with IndexedSeq[T] {
  def length: Int
  def apply(index: Int): T
  def unsafeArray: Array[T]
}

object ArraySeq {
  def apply[T](elems: T*)(implicit elemTag: ClassTag[T]): ArraySeq[T]
  def unsafeWrapArray[T](x: Array[T]): ArraySeq[T]
  def empty[T <: AnyRef]: ArraySeq[T]
}

implicit class MapExtensionMethods[K, V](self: Map[K, V]) {
  def foreachEntry[U](f: (K, V) => U): Unit
}

implicit class ImmutableMapExtensionMethods[K, V](self: immutable.Map[K, V]) {
  def updatedWith[V1 >: V](key: K)(remappingFunction: Option[V] => Option[V1]): Map[K, V1]
}

implicit class MutableMapExtensionMethods[K, V](self: mutable.Map[K, V]) {
  def updateWith(key: K)(remappingFunction: Option[V] => Option[V]): Option[V]
}

object CollectionConverters extends DecorateAsJava with DecorateAsScala

final class ChainingOps[A](private val self: A) {
  def tap[U](f: A => U): A  // Apply function for side effects, return original
  def pipe[B](f: A => B): B  // Transform value with function
}

trait ChainingSyntax {
  implicit def scalaUtilChainingOps[A](a: A): ChainingOps[A]
}

object chaining extends ChainingSyntax

implicit class IteratorExtensionMethods[A](self: Iterator[A]) {
  def nextOption(): Option[A]
  def sameElements[B >: A](that: TraversableOnce[B]): Boolean
  def tapEach[U](f: A => U): Iterator[A]
}

class SizeCompareOps(it: Traversable[_]) {
  def <(size: Int): Boolean
  def <=(size: Int): Boolean  
  def ==(size: Int): Boolean
  def !=(size: Int): Boolean
  def >=(size: Int): Boolean
  def >(size: Int): Boolean
}

implicit class RichOption[A](o: Option[A]) extends AnyVal {
  def toJava: java.util.Optional[A]
}

implicit class RichOptional[A](o: java.util.Optional[A]) extends AnyVal {
  def toScala: Option[A]
}

object Using {
  def apply[R: Releasable, A](resource: => R)(f: R => A): Try[A]
  
  object Manager {
    def apply[A](f: Manager => A): Try[A]
  }
}

trait Releasable[-R] {
  def release(resource: R): Unit
}

class nowarn extends scala.annotation.StaticAnnotation
class unused extends scala.annotation.StaticAnnotation