标签: implicit

给这个类一个implicitInt。

scala> class Foo(implicit val x: Int) { 
     |   def getX = x
     | }
defined class Foo

我可以通过以下方式明确创建一个：

scala> val f = new Foo()(1)
f: Foo = Foo@21aba4f3

但我不能：

scala> val f = new Foo(100)
<console>:18: error: too many arguments for constructor Foo: ()(implicit x: Int)Foo
       val f = new Foo(100)

争论是怎么回事()？

    def p1(c: Int)(implicit b: Int): Unit = {
        println(c + b)
    }

    def p2(a: Int, b: Int): Unit ={
        p1(a)
    }

    p2(5, 6) //result = 11

错误：找不到参数 b 的隐式值：Int

如何解决问题但不要使用此解决方案

 def p2(a: Int, b: Int): Unit ={
        implicit val bb = b
        p1(a)
    }

我正在努力加快 Scala 的速度，但对关键字“ implicit ”的使用有点困惑。

我想我理解隐式参数的概念，其中参数没有显式传入，Scala 将搜索正确类型的值（在调用范围内）。

我对“隐式 val ”的使用感到困惑。

考虑以下代码片段：

case class DemoApp() {
   implicit val foo = CustomerFoo()
}

这与传递到 DemoApp() 类构造函数的参数有关吗？

有人可以澄清一下吗？

谢谢，约翰B

假设我有两个类Person和Business，它们由特质 扩展Entity。

trait Entity
case class Person(name: String) extends Entity
case class Business(id: String) extends Entity

假设我无法更改Entity,Person并且Business（它们位于不同的文件中并且不能更改），我如何定义一个函数，例如 a ，根据实体printEntity打印字段name或？id例如，给定Person和的实例Business，我该如何做这样的事情：

object Main extends App {
  val person1: Person = Person("Aaaa Bbbb")
  val business1: Business = Business("0001")
  
  // How can I do something like this?
  person1.printEntity // would call a function that executes println(id)
  business1.printEntity // would call a function …

Let us say we have the code (<: Monad[F] doesn't work as expected):

class External[F[_] <: Monad[F] : Concurrent](implicit proxy: Proxy[F]) { ... }

class Proxy[F[_] <: Monad[F]](implicit storage: Storage, async: Async[F]) {
  def get(key: String): F[Option[Entry]] = {
    async.blocking(storage.get(key))
  }
}

I would like F[_] to be a Monad, so that proxy.get() have those traits and enables for example (inside External class):

proxy.get(key).flatMap(...)

So far so good, but when trying to instantiate with cats.effect.IO it doesn't work …

我有类似的Option情况， 我需要转换为Scala。我的意思是。ListStringSome(List("abc","def","ghi"))List("abc","def","ghi")Option[List[String]]List[String]

我是 Scala 新手，正在使用它circe来建模和序列化一些 API 响应。我发现自己使用以下样板

sealed trait SomeTrait

object SomeTrait {
    implicit val someEncoder: Encoder[SomeTrait] = deriveEncoder[SomeTrait]
    implicit val someDecoder: Decoder[SomeTrait] = deriveDecoder[SomeTrait]

    <code>
}

相反，我想使用泛型，并定义类似的东西

trait SerializableTrait[A] {
    implicit val someEncoder: Encoder[A] = deriveEncoder[A]
    implicit val someDecoder: Decoder[A] = deriveDecoder[A]
}

然后多次使用扩展：

sealed trait SomeTrait

object SomeTrait extends SerializableTrait[SomeTrain] {

    <code>
}

但我得到的could not find Lazy implicit value of type io.circe.generic.encoding.DerivedAsObjectEncoder解码器也是类似的。

我知道我可能正在尝试实现circle.auto功能，但我想了解这种用法​​有什么问题。理想情况下，我希望编译器dervieEncoder/Decoder仅在实际需要时在非类型参数化特征内评估。

有没有办法在匹配之前调用x上的这个隐式方法来满足匹配的类型要求？

如果我直接调用它,它按预期工作,但我想知道是否可以推断出该调用.

object ImplicitTest extends App {
  implicit def denull[T<:Any](mightBeNull:T):Option[T] = {
    if (mightBeNull == null) None
    else Some(canBeNull)
  }

  var x:String = null
  x match {  //works if i do "denull(x) match {"
    case Some(str:String) =>
      println(str)
    case None => None
  }
}

我正在尝试将数据类型通用编程的Haskell库的一部分移植到Scala.这是我遇到的问题:

我已经Generic使用一些容器类型参数定义了一个特征:

trait Generic[G[_]] {
     // Some function declarations go here
 }

现在我有一个抽象类,Collect有三个类型参数和一个函数声明(它表示一种类型,而不是可以从类型结构中将所有类型的子类收集B到一个类型的容器中):F[_]A

abstract class Collect[F[_],B,A] {
  def collect_ : A => F[B]
}

为了使其延伸通用,前两个类型参数F[_]和B给出,并且A是咖喱(这种效果是使用类型lambda表达式模拟的):

class CollectC[F[_],B] extends Generic[({type C[A] = Collect[F,B,A]})#C] {
    // Function definitions go here
}

问题是我需要最后一个类定义是隐式的,因为稍后在我的代码中我将需要能够编写像

class GUnit[G[_]](implicit gg: Generic[G]) {
    // Some definitions
}

当我只是前面implicit的类定义时,我得到一个错误说implicit classes must accept exactly one primary constructor parameter.有谁遇到过类似的问题？有没有一种已知的解决方法？我目前没有看到如何在保持相同功能的同时重构代码,所以欢迎任何建议.提前致谢!

我使用Spark 2.1.1.

我从以下开始:

import org.apache.spark.sql.types._
val mySchema = StructType(
  StructField("id", IntegerType, true),
  StructField("code", StringType, false),
  StructField("value", DecimalType, false))
val myDS = Seq((1,"000010", 1.0), (2, "000020", 2.0)).as[mySchema]

在这里,我看到mySchema不是一个类型,看了之后Encoders.scala我可以看到我需要通过这里传递一个Product的子类型

def product[T <: Product : TypeTag]: Encoder[T] = ExpressionEncoder()

因此,在看到冒号操作符只是来自什么是Scala上下文和视图边界的隐式参数的语法糖之后？,我可以看到应该有一个隐含的TypeTag [T]可用,但我不明白TypeTag [T]是如何隐含的SQLImplicits.scala.

   /**
   * @since 1.6.1
   * @deprecated use [[newSequenceEncoder]]
   */
  def newProductSeqEncoder[A <: Product : TypeTag]: Encoder[Seq[A]] = ExpressionEncoder() 

即使它被弃用了,当我看到它时

 /** @since 2.2.0 */
  implicit def newSequenceEncoder[T <: Seq[_] : …