标签: implicit

我有一个形式的构造函数:

MyClass(int a,int b,int c);

并使用以下代码调用它:

MyClass my_object(4.0,3.14,0.002);

我想阻止这种从double到int的自动转换,或者至少在编译时得到警告.

似乎"显式"关键字在这些情况下不起作用,对吧？

有一个带有隐式参数的模板类声明:

List.h

template <typename Item, const bool attribute = true>
class List: public OList <item, attribute>
{
    public:
    List() : OList<Item, attribute> () {}
    ....
};

我尝试在不同的头文件中使用fllowing forward声明:

Analysis.h

template <typename T, const bool attribute = true>
class List;

但是G ++显示了这个错误:

List.h:28: error: redefinition of default argument for `bool attribute'
Analysis.h:43: error:   original definition appeared here

如果我使用没有隐式参数的前向声明

template <typename T, const bool attribute>
class List;

编译器不接受这种结构

Analysis.h

void function (List <Object> *list)
{
}

并显示以下错误(即不接受隐含值):

Analysis.h:55: error: wrong number of …

最近对Scala master的一个提交删除了将上下文/视图边界与隐式参数组合的限制.这是一个很大的改进,减少了样板量,但之前做出限制的原因是什么,以及我们现在可以预期的后果是什么？

我需要将两个函数作为参数传递给scala函数.然后,该函数应对它们进行评估并从中获取一个数字,然后对其进行操作.此数字可以是Int,Double或任何其他数字类型.无论它使用什么类型,我都希望该功能能够正常工作.

下面的例子解释了这个问题.

import Numeric.Implicits._

class Arithmetic[T : Numeric](val A: Connector[T], val B: Connector[T]) {
  val sum  = new Connector({ A.value + B.value })
}

class Constant[T](var x: T) {
  val value = new Connector({ x })
}

class Connector[T](f: => T) {
  def value: T = f
  override def toString = value.toString()
}

object Main extends App{
  val n1 = new Constant(1)

  // works
  val n5 = new Constant(5)
  val a = new Arithmetic( n1.value, n5.value )
  println(a.sum)

 // no …

我很难解释主要隐式值或隐式转换所寻求的其他隐式值之间的行为差​​异.具体来说,这有效:

trait Foo[A]
implicit def fooString: Foo[String] = null

implicit def value[A](implicit foo: Foo[A]) = 5

> implicitly[Int]
5

但这不是:

implicit def conversion[A](x: Int)(implicit foo: Foo[A]) = new {
    def aMethod = 5
}

> 1.aMethod
could not find implicit value for parameter foo: test.Foo[A]

变化:

• 搜索是由启动implicitly还是隐式转换
• 寻求的次要隐含值是否是多态的
• 提供的辅助隐式值是否是多态的

我得到以下结果:

Conversion/value  Searching for  Supplied | Works?
----------------  -------------  -------- | ------
     conversion     poly          poly    |  yes
     conversion     poly          mono    |  **no**
     conversion     mono          poly    |  yes
     conversion     mono …

我一直试图了解隐式参数在Scala中的工作原理.据我所知,隐式参数解析如下:

1. 将对象显式传递给方法.
2. 范围中定义的隐式定义.
3. 用作隐式参数的类的伴随对象

然而,当我开始玩这个懒惰的vals时,我得到了一些帮助.懒惰的val似乎只使用最后的解析规则.以下是一些示例代码:

class Bar(val name:String)
object Bar { implicit def bar = new Bar("some default bar") }

class Foo {
  lazy val list = initialize
  def initialize(implicit f:Bar) = {
    println("initialize called with Bar: '" + f.name + "' ...")
    List[Int]()
  }
}

trait NonDefaultBar extends Foo {
  implicit def f = new Bar("mixed in implicit bar")
  def mixedInInit = initialize
  lazy val mixedInList = list
}

object Test {
    def test = {
      println("Case 1: with …

我有以下功能:

def getIntValue(x: Int)(implicit y: Int ) : Int = {x + y}

我到处都看到上述声明.我理解上面的功能正在做什么.这是一个currying函数,它有两个参数.如果省略第二个参数,它将调用返回int的隐式定义.所以我认为这与定义参数的默认值非常相似.

implicit val temp = 3

scala> getIntValue(3)
res8: Int = 6

我想知道上述声明有什么好处？

我有以下代码,它使用spray-json通过该parseJson方法将一些JSON反序列化为case类.

根据隐式JsonFormat [MyCaseClass]的定义位置(在线或从伴随对象导入),以及在定义时是否提供显式类型,代码可能无法编译.

我不明白为什么从配对对象导入隐式需要它在定义时具有显式类型,但如果我把它内联,那不是这种情况？

有趣的是,IntelliJ在所有情况下都正确地定位了隐式参数(通过cmd-shift-p).

我正在使用Scala 2.11.7.

Broken Code - 来自伴侣对象的通配符导入,推断类型:

import SampleApp._
import spray.json._

class SampleApp {
  import MyJsonProtocol._
  val inputJson = """{"children":["a", "b", "c"]}"""
  println(s"Deserialise: ${inputJson.parseJson.convertTo[MyCaseClass]}")
}

object SampleApp {
  case class MyCaseClass(children: List[String])

  object MyJsonProtocol extends DefaultJsonProtocol {
    implicit val myCaseClassSchemaFormat = jsonFormat1(MyCaseClass)
  }
}

结果是:

Cannot find JsonReader or JsonFormat type class for SampleAppObject.MyCaseClass

请注意,显式导入myCaseClassSchemaFormat隐式时会发生同样的事情.

工作代码#1 - 来自伴侣对象的通配符导入,显式类型:

将显式类型添加到随播对象中的JsonFormat会导致代码编译:

import SampleApp._
import spray.json._

class SampleApp {
  import MyJsonProtocol._
  val inputJson = """{"children":["a", …

在Scala中,您可以执行以下操作:

def foo(implicit v: Int) = println(v);
def h(x: Int) = { implicit val i: Int = x; foo }

h(42)
> 42

hcall将foo引用作为闭包.

尝试传递foo给h参数并不奇怪:

def g(x: Int)(f: Int => Unit) = { implicit val i: Int = x; f }

但它不会起作用:

g(1)(foo)
> error: could not find implicit value for parameter v: Int

我认为它正在发生的是foo被称为实际参数的评估.是对的吗？

当传递具有普通参数列表的函数(非隐式)时,不会评估该函数:

def foo2(v: Int) = println("Foo2")
g(1)(foo2)
> Int => Unit = <function1>

这是预期结果,并且foo2 …

我得到一个奇怪的编译器错误,关于实际存在的隐式但由于某种原因无法找到.所以我构建了一个小的测试用例,可以重现神秘的行为.

trait Hide {
  type T
}
object HideString extends Hide {
  override type T = String
}
object HideBool extends Hide {
  override type T = Boolean
}

简单类型用作隐式转换的明确目标.

def id[H <: Hide, C](x : C)(implicit ev : C => H#T) : H#T = ev(x)
def drop[H <: Hide, C](x : C)(implicit ev : C => H#T) : Int = {
  println(ev(x))
  1
}
def idSeq[H <: Hide, C](x : Seq[C])(implicit ev : Seq[C] => Seq[H#T]) : Seq[H#T] = …