小编Dmy*_*tin的帖子

根据cats官方文档：https : //typelevel.org/cats-effect/typeclasses/liftio.html ，如果我们想把东西从IO提升到其他容器，你应该实现LiftIO trait，但示例明确运行unsafeRunXXX方法来获取出了效果，我想知道这是转型的唯一途径吗？

我有一个表面上很简单的宏观问题，我已经用头撞了几个小时，但没有运气。也许有更多经验的人可以提供帮助。

我有以下宏：

import scala.language.experimental.macros
import scala.reflect.macros.blackbox.Context

object MacroObject {
  def run(s: String): Unit =
    macro runImpl

  def runImpl(c: Context)(s: c.Tree): c.Tree = {
    import c.universe._
    println(s)    // <-- I need the macro to know the value of s at compile time
    q"()"
  }
}

问题是：我希望宏知道s传递给它的值——不是 AST s，而是s它本身的值。具体来说，我希望它具有这种行为：

def runTheMacro(str: String): Unit = MacroObject.run(str)

final val HardCodedString1 = "Hello, world!"
runTheMacro(HardCodedString1)    // the macro should print "Hello, world!"
                                 // to the console during macro expansion …

在 Scala 反射中，通常可以使用 TypeCreator 从 Type 构造 TypeTag：

object TypeUtils {

  import ScalaReflection.universe._

  def createTypeTag[T](
      tpe: Type,
      mirror: reflect.api.Mirror[reflect.runtime.universe.type]
  ): TypeTag[T] = {
    TypeTag.apply(
      mirror,
      NaiveTypeCreator(tpe)
    )
  }

  case class NaiveTypeCreator(tpe: Type) extends reflect.api.TypeCreator {

    def apply[U <: reflect.api.Universe with Singleton](
        m: reflect.api.Mirror[U]): U#Type = {
      //          assert(m eq mirror, s"TypeTag[$tpe] defined in $mirror cannot be migrated to $m.")
      tpe.asInstanceOf[U#Type]
    }
  }

不幸的是，事实证明 的输出createTypeTag不可序列化，这与编译时推理创建的 typeTag 不同：

import java.io.{ByteArrayOutputStream, ObjectOutputStream}

import org.apache.spark.sql.catalyst.ScalaReflection
import org.scalatest.FunSpec

class TypeTagFromType extends FunSpec { …

我将使用很棒的库https://tpolecat.github.io/doobie/，它功能齐全。

我正在经历第一个例子，我已经认识到：

Transactor 是一种数据类型，它知道如何连接到数据库、分发连接并清理它们；有了这些知识，它可以转换ConnectionIO ~> IO，这给了我们一个可以运行的程序。

ConnectionIO ~> IO 是范畴论中的自然变换，但从未完全理解，究竟什么是自然变换。

但是，我知道这是从一类到另一类的转变。例如：

F[A] ~> G[A]

是从类别F到G不改变内容的自然转变。

并非一切都可以自然转化，问题是，library doobie 的作者怎么知道，他可以从 进行自然转化ConnectionIO ~> IO？

这是我的代码的简化版本。

我怎样才能避免打电话asInstanceOf（因为这是设计不佳的解决方案的味道）？

sealed trait Location
final case class Single(bucket: String)     extends Location
final case class Multi(buckets: Seq[String]) extends Location

@SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf"))
class Log[L <: Location](location: L, path: String) { // I prefer composition over inheritance
  // I don't want to pass location to this method because it's a property of the object
  // It's a separated function because there is another caller
  private def getSinglePath()(implicit ev: L <:< Single): String = s"fs://${location.bucket}/$path"

  def getPaths(): Seq[String] =
    location match { …

我正在尝试copy()一个具有类型参数的 Scala 案例类。在呼叫站点，该值的类型为Foo[_]。

这按预期编译：

case class Foo[A](id: String, name: String, v1: Bar[A])
case class Bar[A](v: A)

val foo: Foo[_] = Foo[Int]("foo1", "Foo 1", Bar[Int](1))

foo.copy(id = "foo1.1")

但是，如果我添加另一个 type 成员Bar[A]，它将不再编译：

case class Foo[A](id: String, name: String, v1: Bar[A], v2: Bar[A])
case class Bar[A](v: A)

val foo: Foo[_] = Foo[Int]("foo1", "Foo 1", Bar[Int](1), Bar[Int](2))

foo.copy(id = "foo1.1") // compile error, see below

type mismatch;
 found   : Playground.Bar[_$1]
 required: Playground.Bar[Any]
Note: _$1 <: Any, but class …

我在 Scala 3 中定义了以下特征：

trait A[T <: Tuple]\n

然后，我使用 Scala 3 宏创建具有此特征的对象，对元组的实际类型执行进一步检查T；特别是，我想检查元组的所有类型（T_1，\xe2\x80\xa6，T_n）T是否是另一个给定类型的子类型B：

trait B\nprivate def allSubtypesOfB[T <: Tuple: Type](using quotes: Quotes): Boolean = {\n    import quotes.reflect.*\n    case '[Nothing] => false // I don't want nothing to be in T\n    case '[head *: tail] if TypeRepr.of[head] <:< TypeRepr.of[B] => allSubtypesOfB[tail]\n    case '[EmptyTuple] => true\n    case _ => false\n}\n\ninline def createA[T <: Tuple] = ${ createAImpl[T] }\nprivate def createAImpl[T …