标签: implicit

以下代码在Xcode中生成编译错误:

template <typename T>
struct Foo
{
    Foo(T Value)
    {
    }
};

int main()
{
    Foo MyFoo(123);
    return 0;
}

error: missing template arguments before 'MyFoo'

更改Foo MyFoo(123);以Foo<int> MyFoo(123);修复问题,但编译器是否应该能够找出相应的数据类型？

这是一个编译器错误,还是我误解了隐式模板参数？

我正在阅读C++教程,但它实际上并没有给我两者之间的区别(除了语法).这是教程中的引用.

您还可以在声明时为变量赋值.当我们使用赋值运算符(等号)为变量赋值时,它被称为显式赋值:

int nValue = 5; // explicit assignment

Run Code Online (Sandbox Code Playgroud)

您还可以使用隐式赋值为变量赋值:

int nValue(5); // implicit assignment

Run Code Online (Sandbox Code Playgroud)

即使隐式赋值看起来很像函数调用,编译器也会跟踪哪些名称是变量,哪些是函数,以便可以正确解析它们.

有区别吗？比另一个更优先吗？

我目前正在广泛使用类型类模式作为我的代码中与性能相关的部分.我发现了至少两个潜在的低效率来源.

1. 隐式参数将通过消息调用传递.我不知道这是否真的发生了.也许scalac可以简单地在使用它们的地方插入隐式参数,并从方法签名中删除它们.在手动插入隐式参数的情况下,这可能是不可能的,因为它们可能仅在运行时解析.传递隐式参数有哪些优化适用？

2. 如果类型类实例由a提供def(与a 相反val),则必须在每次调用"类型分类方法"时重新创建对象.JVM可能会解决此问题,这可能会优化对象创建.scalac也可以通过重用这些对象来解决这个问题.有关创建隐式参数对象的优化是什么？

当然,在应用类型类模式时可能还有其他低效率来源.请告诉我他们.

我认为这将正确使用Scala 2.10的新隐式类:

implicit case class IntOps(i: Int) extends AnyVal {
  def twice = i * 2
}

11.twice

显然不是:

<console>:13: error: value twice is not a member of Int
              11.twice
                 ^

我错过了什么(Scala 2.10.0-M6)？

我有一个自定义类,同时实现了==和implicit布尔运算符.

这是处理所有可能的if == /!=语句并获得预期结果的正确方法吗？像这样:

public class Foo
{
    public bool Result { get; set; }

    public static bool operator ==(bool @bool, Foo foo)
    {
        return Equals(foo, @bool);
    }
    public static bool operator !=(bool @bool, Foo foo)
    {
        return NotEquals(foo, @bool);
    }
    public static bool operator ==(Foo foo, bool @bool)
    {
        return Equals(foo, @bool);
    }
    public static bool operator !=(Foo foo, bool @bool)
    {
        return NotEquals(foo, @bool);
    }
    public static bool operator ==(Foo foo, Foo fooB)
    { …

以下代码无法编译:

import scala.language.implicitConversions

trait Base {
  class Wrp[+T](val v: T) // wrapper / internal representation
}

trait BooleanOps extends Base {
  // implicit conversion
  implicit def lift2BooleanOpsCls(x: Boolean): BooleanOpsCls =
    new BooleanOpsCls(new Wrp[Boolean](x))
  class BooleanOpsCls(wx: Wrp[Boolean]) {
    def ||(wy: =>Wrp[Boolean]): Wrp[Boolean] = new Wrp[Boolean](wx.v || wy.v)
  }
}

trait MyExample extends BooleanOps {
  // test method
  def foo(): Wrp[Boolean] = {
    val ret: Wrp[Boolean] = false || new Wrp[Boolean](true)
    ret
  }
}

输出:

MyExample.scala:18: error: type mismatch;
 found   : MyExample.this.Wrp[Boolean] …

我的应用程序代码使用AService

trait AService {
    def registerNewUser (username: String)(implicit tenant: Tenant): Future[Response]
}

注册新用户.Class Tenant是一个简单的案例类:

case class Tenant(val vstNumber:String, val divisionNumber:String) 

Trait AServiceMock通过使用模拟版本的AService来模拟注册逻辑

trait AServiceMock {
  def registrationService = {
    val service = mock[AService]
    service.registerNewUser(anyString) returns Future(fixedResponse)
    service
  }
}

低,每当在AService上调用registerNewUser时,响应将是"fixedResponse"(在别处定义).

我的问题是,如何将隐式租户参数定义为像anyString一样的mockito匹配器？

顺便说一句.我正在使用Mockito和Specs2(和Play2)

在我看来,它很容易实现一个隐式运算符而不是TypeConverter,所以我假设它们不等同,因为框架中普遍存在TypeConverters(请参阅扩展FrameworkElement的任何内容).

但为什么？创建string-> object和object-> string隐式运算符并利用序列化中的那些(XML和XAML)不是更容易吗？

是YAGNI？单一责任？因为您无法在接口中指定运算符重载？

例如,如何编写隐式应用以下内容的表达式:

implicit def intsToString(x: Int, y: Int) = "test"

val s: String = ... //?

谢谢

我使用Scala隐式类来扩展我经常使用的对象.作为一个例子,我有一个类似于Spark上定义的方法DataFrame:

implicit class DataFrameExtensions(df: DataFrame) {
  def deduplicate: Boolean = 
    df.groupBy(df.columns.map(col): _*).count
}

但是如果类已经定义了相同的方法,则不会调用隐式defs.如果我以后升级到定义DataFrame#deduplicate方法的新版Spark,会发生什么？客户端代码将静默切换到新的实现,这可能会导致细微的错误(或明显的错误,这些问题较少).

使用反射,如果在我的隐式定义它之前已经定义,我可以抛出运行时错误.从理论上讲,如果我的隐式方法与现有方法冲突,我可以检测它并重命名我的隐式版本.但是,一旦我升级Spark,运行应用程序并检测问题,使用IDE重命名旧方法为时已晚,因为现在任何引用都引用了本机Spark版本.我将不得不恢复我的Spark版本,通过IDE重命名该方法,然后再次升级.不是世界末日,而是一个伟大的工作流程.DataFramededuplicatedf.deduplicate

有没有更好的方法来处理这种情况？如何安全地使用"皮条客我的图书馆"模式？