标签: implicit

如果我有这两个构造函数MyClass:

MyClass(int n1);
MyClass(int n1, int n2);

和一个重载(非成员)operator+:

MyClass operator+(MyClass m1, const MyClass& m2);

这使我能够编写如下代码:

MyClass m;
5 + m:

我想通过定义的构造函数使用隐式强制转换,对吗？

有没有办法用构造函数接受2个参数进行隐式转换？代码看起来像这样:

MyClass m;
{15, 8} + m:

？

或者只是从{9,4}到MyClass对象进行显式演员？

我有一个非常有用的隐式类,我想扩展GenIterable:

  import scala.collection.GenIterable
  implicit class WhatUpTho[S<:GenIterable[T],T](s:S) extends GenIterable[T]{
    def whatUpTho = println("sup yo")
  }

不幸的是,编译器不会让我写这个,因为它缺少79所需的方法或属性trait GenIterable.我想将所有WhatUpTho未明确定义的请求推迟到其s参数.

我该如何做到这一点？

鉴于功能

def func(implicit x: Foo, y: Bar): (ThingA => ThingB) = ???`

我无法弄清楚如何在一条线上调用它.显然这可以通过将返回的函数存储在val中来实现:

val f = func // Foo and Bar are implicitly applied
f(ThingA)

但如果没有赋值给val怎么办呢？func(ThingA)很自然地抱怨说func参数太少了.

我可以Foo通过隐式类使用其他方法扩展我的 Scala类：

trait Foo {
  def bar: String
}

object FooExtensions {
  object implicits {
    implicit class FooOps(foo: Foo) {
      def baz: String = "baz"
    }
  }
}

但是我可以模拟这些方法吗？

import org.mockito.Mockito
import org.scalatest.WordSpec
import org.scalatest.mockito.MockitoSugar

class MySpec extends WordSpec with MockitoSugar {
  "My mock" should {
    "handle methods from implicit classes" in {
      import FooExtensions.implicits._
      val foo = mock[Foo]
      Mockito.when(foo.baz).thenReturn("bix") // fails at runtime
    }
  }
}

这编译，但失败

when() requires an argument which has to be 'a method …

我正在尝试做一个flinkscala api hello世界，但是无法复制从https://www.slideshare.net/dataArtisans/apache-flink-datastream-api-basics/20看到的开始的教程片段。

我尝试的副本是：

  val env = StreamExecutionEnvironment.getExecutionEnvironment
  case class Order(user: String, product: String, amount: Double, proctime: Int, rowtime: Int)

  def basic() = {
    val seq = (1 to 50).map { i => Order(s"User" + (i % 10).toString, "Product" + (i % 20), 2.0 * (4 * i +.5 * i * i -.1 * i * i * i), i * 10, i * 3) }
    val ds: DataStream[Order] = env.fromElements(seq:_*)

隐式不起作用，但是

错误：（21，30）找不到类型为org.apache.flink.api.common.typeinfo.TypeInformation [com.blazedb.spark.FlinkDemo.Order]的证据参数的隐含值

这里需要更改什么？

最近，我对隐式函数产生了兴趣。在文档中，我们可以看到几个使用此属性的示例，但我想我不太明白它是如何工作的。

例如，我们可以读到implicit T0 => R实际上是

trait ImplicitFunction1[-T0, R] extends Function1[T0, R] {
  override def apply(implicit x: T0): R
}

写完下面的函数后

val func = {implicit x: Int => 2*x}

我试图以这种方式使用它

implicit val x: Int = 3
println(func)

但它似乎不起作用（只<function1>返回类型，看起来apply根本没有使用过）。如果我有一个方法，它会工作得很好

def func(implicit x: Int) = 2*x

我不确定我在这里错过了什么。

我想支持Json和Parquet文件格式。客户端不必关心其实现，但是必须传递一种类型来标识格式。

到目前为止，我有两个具有此类签名的类：

class ParquetFileWriter[T](val path: String)(implicit val writer: ParquetWriter[T]) extends FileWriter[T]

和

class JsonFileWriter[T](val path: String)(implicit writer: JsonWriter[T]) extends FileWriter[T]

他们扩展的特征：

trait FileWriter[T] {
  def write(items: Seq[T]): Unit
}

我想创建一个工厂类来通过参数构建类：

class Factory {
  def of[T](format: Format): FileWriter[T] = {
    format match {
      case ParquetSpark =>
        new ParquetFileWriter[T](defaultPath)

      case Json =>
        new JsonFileWriter[T](defaultPath)
    }
  }
}

问题是ParquetFileWriter和JsonFileWriter需要隐式变量（当它们从spray.json和com.github.mjakubowski84.parquet4s库到达时，它们不在我的控制范围之内。

如果格式依赖于不同的隐式函数，如何实现工厂格式？我在编译时收到“找不到隐式值”。

我有一个这样的功能：

def getSomething: (String, Future[String]) => String = {
    case (name, surname) if (name == "Joe", surname.map(s => s == "Doe")) => "Is ok"
}

但是编译器说他需要executionContext这里的map函数。我试图做一些魔术：

def getSomething (implicit e: ExecutionContext): (String, Future[String]) => String{...}

或者

 def getSomething: (String, Future[String])(implicit e: ExecutionContext) => String{...}

但它不起作用。是否可以将隐式参数传递给这样的功能？或者我可以用其他方式来做吗？

我有如下代码：

implicit val _ = new MyClass()

我收到以下错误：

Implicit pattern definition binds no variables

为什么？

我正在使用 Scala -> 2.13.3、SBT -> 1.3.13 和 Java -> OpenJDK v14.0.2

我在这个博客上遇到了这个代码块。我想知道h1("Hello World")从h1(children: Frag*).

object TheirCode{
  trait Frag{
    def render: String
  }
  // HTML constructors
  def div(children: Frag*): Frag
  def p(children: Frag*): Frag
  def h1(children: Frag*): Frag
  ...
  implicit def stringFrag(s: String): Frag
}

object MyCode{
  import TheirCode._
  val frag = div(
    h1("Hello World"),
    p("I am a paragraph")
  )
  frag.render // <div><h1>Hello World</h1><p>I am a paragraph</p></div>
}

我猜会implicit def stringFrag自动转换h1(String)为，h1(Frag)但我一直认为方法参数需要隐式前缀才能工作（即implicit h1(children: Frag*)）