$ cs launch scala3-repl:3.7.1 -- -Vprint:dropForMap -preview
Welcome to Scala 3.7.1 (1.8.0_452, Java OpenJDK 64-Bit Server VM).
Type in expressions for evaluation. Or try :help.
                                                                                                              
scala>   println:
     |     for
     |       a <- List(1)
     |       b <- List(a)
     |     yield b
     | 
List(1)
[[syntax trees at end of MegaPhase{crossVersionChecks, firstTransform, checkReentrant, elimPackagePrefixes, cookComments, checkLoopingImplicits, betaReduce, inlineVals, expandSAMs, elimRepeated, refchecks, dropForMap}]] // rs$line$1
package <empty> {
  final lazy module val rs$line$1: rs$line$1 = new rs$line$1()
  @SourceFile("rs$line$1") final module class rs$line$1() extends Object() {
    private def writeReplace(): AnyRef =
      new scala.runtime.ModuleSerializationProxy(classOf[rs$line$1.type])
    val res0: Unit =
      println(
        List.apply[Int]([1 : Int]).flatMap[Int]((a: Int) =>
          List.apply[Int]([a : Int]))
      )
  }
}

//> using scala "3.7.2-RC1"
//> using dep "org.typelevel::cats-mtl::1.5.0"
//> using options "-preview", "-Vprint:dropForMap"

// using scala "3.6.4"
// using dep "org.typelevel::cats-mtl::1.5.0"
// using options "-language:experimental.betterFors", "-Vprint:typer"

import cats.{Monad, Eval}
import cats.data.State
import cats.implicits._
import cats.mtl.Stateful

def program[F[_]: Monad](using S: Stateful[F, Int]): F[Int] =
  for
    s <- S.get
    x <- s.pure
  yield x

@main def main =
  println:
    program[[X] =>> State[Int, X]]
    .run(42)

def program[F[_$1]](using evidence$1: cats.Monad[F],
  S: cats.mtl.Stateful[F, Int]): F[Int] =
  cats.implicits.toFlatMapOps[F, Int](S.get)(evidence$1).flatMap[Int]((
    s: Int) =>
    cats.implicits.toFunctorOps[F, Int](
      cats.implicits.catsSyntaxApplicativeId[Int](s).pure[F](evidence$1))(
      evidence$1).map[Int]((x: Int) => x)
  )

def program[F[_ >: Nothing <: Any] >: Nothing <: Any](using 
  evidence$1: cats.Monad[F], S: cats.mtl.Stateful[F, Int]): F[Int] =
  cats.implicits.toFlatMapOps[F, Int](S.get)(evidence$1).flatMap[Int]((
    s: Int) =>
    cats.implicits.catsSyntaxApplicativeId[Int](s).pure[F](evidence$1))

//> using scala "3.7.2-RC1"
//> using dep "dev.zio::zio:2.1.19"
//> using options "-preview" "-Vprint:dropForMap"

// using scala "3.6.4"
// using dep "dev.zio::zio:2.1.19"
// using options "-language:experimental.betterFors" "-Vprint:typer"

import zio._

def program: ZIO[ZState[Int], Nothing, Int] =
  for
    s <- ZIO.getState[Int]
    x <- ZIO.succeed(s)
  yield x

@main def main =
  println:
    ZIO.stateful(42)(program).unsafeRunZio

extension [A](thiz: ZIO[Any, Nothing, A])
  def unsafeRunZio: A =
    Unsafe.unsafe(implicit _ => Runtime.default.unsafe.run(thiz).getOrThrowFiberFailure())

//> using scala "3.7.2-RC1"
//> using dep "io.github.marcinzh::turbolift-core:0.114.0"
//> using options "-preview" "-Vprint:dropForMap"

// using scala "3.6.4"
// using dep "io.github.marcinzh::turbolift-core:0.114.0"
// using options "-language:experimental.betterFors" "-Vprint:typer"

import turbolift.!!
import turbolift.effects.State

case object MyState extends State[Int]
type MyState = MyState.type

def program: Int !! MyState =
  for
    s <- MyState.get
    x <- !!.pure(s)
  yield x

@main def main =
  println:
    program.handleWith(MyState.handler(0)).run

//> using scala "3.7.2-RC1"
//> using dep "io.getkyo::kyo-core::0.19.0"
//> using options "-preview" "-Vprint:dropForMap"

// using scala "3.6.4"
// using dep "io.getkyo::kyo-core::0.18.0"
// using options "-language:experimental.betterFors" "-Vprint:typer"

// Note: kyo is compild against the latest scala version, so we need to use v18 and v19 respectively

import kyo.*

def pure[A](a: A): A < Any = a

def program: Int < Var[Int] =
  for
    s <- Var.get[Int]
    x <- pure(s)
  yield x

@main def main =
  println:
    Var.run(42)(program).eval

//> using scala "3.7.2-RC1"
//> using options "-preview" "-Vprint:dropForMap"

// using scala "3.6.4"
// using options "-language:experimental.betterFors" "-Vprint:typer"


sealed trait Effect[+A, -U]:
  final def map[B](f: A => B): Effect[B, U] = flatMap(a => Pure(f(a)))
  final def flatMap[B, V <: U](f: A => Effect[B, V]): Effect[B, V] = FlatMap(this, f)

object Effect:
  def pure[A](a: A): Effect[A, Any] = Pure(a)

  def run[A](ma: Effect[A, Any]): A =
    ma match
      case Pure(a) => a
      case FlatMap(mb, k) => run(k(run(mb)))

final case class Pure[A](a: A) extends Effect[A, Any]
final case class FlatMap[A, B, U](that: Effect[A, U], f: A => Effect[B, U]) extends Effect[B, U]

type Stateish = Stateish.type
object Stateish:
  case object Get extends Effect[Int, Stateish]
  def get: Effect[Int, Stateish] = Get


  def handle[A, U](initial: Int)(ma: Effect[A, U & Stateish]): Effect[A, U] =
    def loop[A](ma: Effect[A, U & Stateish]): Effect[A, U] =
      ma match
        case Pure(a) => Pure(a)
        case Stateish.Get => Pure(initial)
        case FlatMap(mb: Effect[tB, tU & Stateish], k) => mb match
          case Pure(b) => loop(k(b))
          case Stateish.Get => loop(k(initial.asInstanceOf[tB]))
          case FlatMap(mc, j) => loop(mc.flatMap(c => j(c).flatMap(k)))
    loop(ma)


def program: Effect[Int, Stateish] =
  for
    s <- Stateish.get
    x <- Effect.pure(s)
  yield x

@main def main =
  println:
    Effect.run(Stateish.handle(42)(program))

	get:   Effect[Int, Stateish]
	pure:  Effect[Int, Any]

//> using scala "3.7.2-RC1"
//> using options "-preview" "-Vprint:dropForMap"

// using scala "3.6.4"
// using options "-language:experimental.betterFors" "-Vprint:typer"

final class Implicit()

final class Id[+A](val value: A):
  def map[B](f: A => B)(using Implicit): Id[B] = Id(f(value))
  def flatMap[B](f: A => Id[B]): Id[B] = f(value)
  def run: A = value

def program(using Implicit) =
  for
    a <- Id(42)
    x <- Id(a + 1)
  yield x

@main def main =
  given Implicit = Implicit()
  println(program.run)