//> using dep "io.getkyo::kyo-core:0.17.0"
//> using dep "org.scalatest::scalatest-freespec:3.2.19"

package kyo
import org.scalatest.freespec.AsyncFreeSpec
import org.scalatest.Assertion

class Test extends AsyncFreeSpec {
  def run(v: Assertion < (Abort[Any] & Async & Resource)): Assertion = ???
  given Frame = ???

  "test" in run {
    (for
      size <- Choice.get(Seq(1))
      channel <- Channel.init[Int](size)
      latch <- Latch.init(1)
      pollFiber <- Async.run(
        latch.await.andThen(Async.fill(100, 100)(Abort.run(channel.poll)))
      )
      polled <- pollFiber.get
    yield assert(0 == polled.count(_.toMaybe.flatten.isDefined)))
      .pipe(Choice.run, _.unit, Loop.repeat(1))
      .andThen(succeed)
  }
}

[error] ./defs.scala:21:36
[error] Found:    $proxy38.Absent | $proxy38.Present[Int]
[error] Required: (kyo.Maybe.Absent | kyo.Maybe.Present[Int]) & ($proxy38.Absent | $proxy38.Present[Int])
[error]     yield assert(0 == polled.count(_.toMaybe.flatten.isDefined)))
[error]          

opaque type Queue = Queue.Unsafe
object Queue:
  abstract class Unsafe
  opaque type Unbounded = Queue
  object Unbounded:
    inline def initWith()(f: Unbounded => Unit): Unit =
      f(Unsafe.init())

    opaque type Unsafe <: Queue.Unsafe = Queue
    object Unsafe:
      def init[A](): Unsafe = ???

sealed trait Resource
object Resource:
  def run: Unit =
    Queue.Unbounded.initWith() { q =>
      ???
    }

object outer:
  opaque type Queue = Queue.Unsafe
  object Queue:
    abstract class Unsafe
    opaque type Unbounded = Queue
    object Unbounded:
      opaque type Unsafe <: Queue.Unsafe = Queue
      object Unsafe:
        def init[A](): Unsafe = ???

object Resource:
  def run: Unit =
    // we would generate these as part of inlining
    val $proxy2: outer.type{type Queue = outer.Queue.Unsafe} =
      outer.asInstanceOf[outer.type{type Queue = outer.Queue.Unsafe}]
    val $proxy1: $proxy2.Queue.type{type Unbounded = $proxy2.Queue} =
      $proxy2.Queue.asInstanceOf[$proxy2.Queue.type{type Unbounded = $proxy2.Queue}]
    val $proxy3: $proxy1.Unbounded.type{type Unsafe = $proxy2.Queue} =
      $proxy1.Unbounded.asInstanceOf[$proxy1.Unbounded.type{type Unsafe = $proxy2.Queue}]
    val Unbounded$_this:
      $proxy1.Unbounded.type{type Unsafe = $proxy2.Queue} = $proxy3
    val f$proxy1: (outer.Queue.Unbounded => Unit) & ($proxy1.Unbounded => Unit) =
      ((q: outer.Queue.Unbounded) => ???).asInstanceOf[(outer.Queue.Unbounded => Unit) & ($proxy1.Unbounded => Unit)]

    val app: Unbounded$_this.Unsafe = Unbounded$_this.Unsafe.init()
    f$proxy1(app)

object other:
  sealed abstract class Absent
  case object Absent extends Absent
  case class PresentAbsent(val depth: Int)
  opaque type Present[+A] = A | PresentAbsent
  opaque type Maybe[+A] >: (Absent | Present[A]) = Absent | Present[A]

  extension [A](self: Maybe[A]) {
    inline def flatten[B]: Maybe[B] = if isEmpty then Absent else ???
    inline def isDefined: Boolean = !isEmpty
    def isEmpty: Boolean = self.isInstanceOf[Absent]
  }

class Test {
  def main(): Unit =
    import other.Maybe
    val res: Maybe[Maybe[Int]] = ???
    res.flatten.isDefined
}

20 |    res.flatten.isDefined
   |    ^^^
   |    Found:    (self$proxy1 : (res : other.Maybe[other.Maybe[Int]]) &
   |      $proxy1.Maybe[$proxy1.Maybe[Int]])
   |    Required: other$_this.Maybe[other.Maybe[Int]]

import scala.quoted._

inline def passThorugh(inline condition: Boolean): Any =
  ${ passThorughImpl('{condition}) }

def passThorughImpl(condition: Expr[Boolean])(using Quotes): Expr[Any] = condition

package pack
import Maybe._
opaque type Maybe[+A] >: (Absent | Present[A]) = Absent | Present[A]
object Maybe:
  sealed abstract class Absent
  case object Absent extends Absent
  object internal:
    case class PresentAbsent(val depth: Int)
  opaque type Present[+A] = A | internal.PresentAbsent

  extension [A](self: Maybe[A]) {
    inline def flatten[B]: Maybe[B] = ???
    inline def isDefined: Boolean = ???
  }

object Test {
  def main(): Unit =
    import pack.Maybe
    val res: Maybe[Maybe[Int]] = ???
    passThorugh(res.flatten.isDefined)
}