标签: implicit

事实上MyClass x = 120;，是否可以创建这样的自定义类？如果是这样，我该怎么做？

在 scala 语言中，隐式解析通常在编译时完成，有时会抛出混淆的错误信息，此类错误的一个著名例子是当 shapeless Generic 抛出错误信息时，如：

error: could not find implicit value for parameter encoder: CsvEncoder[Foo]

（详见https://books.underscore.io/shapeless-guide/shapeless-guide.html）

这个问题的一个解决方案是在运行时运行隐式解析算法（内部应该是图查询算法），这至少有两个好处：

• 调试工具可用于逐步重现解决过程，因此即使错误信息和文档不完整，也很容易发现错误。

• 在许多情况下，类型信息可能无法在编译时确定（例如，类型取决于控制流）。如果隐式转换不能延迟到运行时阶段，那么定义隐式转换的许多好处将无效。

所以我的问题是，Scala 2.x 或 Dotty 中是否存在此功能？还是在路线图上？

非常感谢您的意见。

给定一个案例类和伴随对象，如下所示：

case class Example(a: String)

object Example {
  implicit def concat(b: String): Example =
    Example(this.a + b)
}

如何使隐式方法编译？换句话说，是否可以引用隐式方法已被调用的当前实例？

试图在 Scala 中为一个虚构的 Partial 类型实现 Kleisli 类别（阅读 Bartosz Milewski 的“程序员的类别理论”，这是第 4 章的练习）

object Kleisli {
  type Partial[A, B] = A => Option[B]

  implicit class KleisliOps[A, B](f1: Partial[A, B]) {

    def >=>[C](f2: Partial[B, C]): Partial[A, C] =
      (x: A) =>
        for {
          y <- f1(x)
          z <- f2(y)
        } yield z

    def identity(f: Partial[A, B]): Partial[A, B] = x => f(x)

  }

  val safeRecip: Partial[Double, Double] = {
    case 0d => None
    case x => Some(1d / x)
  }

  val safeRoot: …

为什么这个 Scala 代码

case class Foo[T]() {
  def bar(tt: T): Unit = ???
  def bar_(s: String)(implicit ev : T =:= String): Unit = bar(s)
}

触发此编译错误

[error] type mismatch;
[error]  found   : s.type (with underlying type String)
[error]  required: T
[error]     def foo2(s: String)(implicit ev: T =:= String) = foo(s)

假设我有一个对象，如：

object MyObj {
  def apply(args: List[String])(implicit v: Int): Unit => Int = (_: Unit) => args.length + v
}

如果我想 MyObj.apply，我必须这样做：

implicit val v = 5
val myObj = MyObj(List("a", "b", "c"))
myObj()

但这感觉是多余的。我希望能够做的是：

implicit val v = 5
MyObj(List("a", "b", "c"))()

不幸的是，这似乎不起作用。系统抱怨我遗漏了我隐含的论点，这是有道理的，但令人失望。

有什么方法可以apply直接调用从方法返回的函数，而无需先将其分配给值？

我有一种情况，我使用 typeclass-within-a-typeclass 来重载原始 typeclass 的方法。下面的例子：

abstract class IsArray[A, T: Numeric] {
  def getSingleElem(self: A, idx: Int): T
  def getRef[R](self: A, ref: R)(implicit refTc: RefTC[R]): refTc.Out = refTc.getRef(self, ref)

  trait RefTC[R] {
    type Out
    def getRef(self: A, ref: R): Out
  }
  object RefTC {
    implicit val numsTcForSingleInt = new RefTC[Int] {
      type Out = T
      def getRef(self: A, ref: Int): Out = getSingleElem(self, ref)
    }
    implicit val numsTcForListInt = new RefTC[List[Int]] {
      type Out = List[T]
      def getRef(self: A, ref: List[Int]): …

我在隐式类中有一段代码 -

implicit class Path(bSONValue: BSONValue) {
      def |<[S, T <:{def value:S}] = {
        bSONValue.asInstanceOf[T].value
      }

} 

问题是如果我想|<在 BSONValue 之后调用方法，我需要使用.. 例如

(doc/"_id").|<[String,BSONString]

问题是没有.scala 引发错误，因为它不允许使用中缀表示法的类型参数方法。所以我总是必须 doc/"_id"用(). 他们是否以任何方式使用类型参数方法而不使用.例如

doc/"_id"|<[String,BSONString]

考虑以下示例：

sealed trait ST

object ST{
  case class ST1() extends ST
  case class ST2() extends ST
}

trait TypeClass[A]{
  def doSome(a: A): Unit
}

case class Test[T](t: T)

implicit val tp: TypeClass[Test[_ <: ST]] = ???  //the implicit

def foo[A: TypeClass](a: A) = implicitly[TypeClass[A]].doSome(a)

val v: Test[_ <: ST] = ???

foo(v) //error: implicit not found

斯卡斯蒂

可以看出，所需的隐式在范围内，而编译器无法识别它。

为什么会发生这种情况，是否有解决方法可以调用foo？

我必须开发类 StackMachine[T]。如果 T = Boolean，那么应该有逻辑运算。如果 T = Int,Double,Long 等，应该有算术运算。首先，我开发了类 Stack[T]。

class Stack[T](val stack: List[T]) {
    val length: Int = stack.length
    def isEmpty: Boolean = {length == 0}
    def push(x: T): Stack[T] = {
      new Stack[T](x :: stack)
    }

     def peak: T = {
       if (this.isEmpty)
         throw new ArrayIndexOutOfBoundsException
         else stack.head
     }
    def pop(): Stack[T] = {
      if (this.isEmpty)
        throw new ArrayStoreException()
      val x :: xs = stack
      new Stack[T](xs)
    }

薄的是我不知道如何开发 StackMachine[T] 操作的存在取决于类型。我试过这个：

case class StackMachine[T](val stack:Stack[T]){
    def const(x: T): …