标签: implicit-conversion

Scala特征和隐式转换混淆

当我在Scala REPL(2.7.7)上手动输入时,以下行有效:

trait myTrait {
  override def toString = "something"
}
implicit def myTraitToString(input: myTrait): String = input.toString
object myObject extends myTrait
val s: String = myObject
Run Code Online (Sandbox Code Playgroud)

但是,如果我尝试使用它编译文件,我会收到以下错误:

[error] myTrait.scala:37: expected start of definition
[error] implicit def myTraitToString(input: myTrait): String = input.toString
[error]          ^
Run Code Online (Sandbox Code Playgroud)

为什么?

谢谢!

scala traits implicit-conversion

7
推荐指数
1
解决办法
3500
查看次数

不发生隐式转换

我问的最后一个问题是我在试图理解另一件事时偶然发现的事情......我也无法理解(不是我的一天).

这是一个很长的问题陈述,但至少我希望这个问题可能对许多人有用,而不仅仅是我.

我的代码如下:

template <typename T> class V;
template <typename T> class S;

template <typename T>
class V
{
public:
 T x;

 explicit V(const T & _x)
 :x(_x){}

 V(const S<T> & s)
 :x(s.x){}
};

template <typename T>
class S
{
public:
 T &x;

 explicit S(V<T> & v)
 :x(v.x)
 {}
};

template <typename T>
V<T> operator+(const V<T> & a, const V<T> & b)
{
 return V<T>(a.x + b.x);
}

int main()
{
 V<float> a(1);
 V<float> b(2);
 S<float> c( b );

 b …
Run Code Online (Sandbox Code Playgroud)

c++ templates implicit-conversion

7
推荐指数
2
解决办法
1292
查看次数

构造函数解析顺序的问题

考虑以下T的构造函数:

struct T {
    T(const bool) { std::cout << "T(const bool)" << endl; }
    T(const std::string&) { std::cout << "T(const std::string&)" << endl; }
};

T t("");
Run Code Online (Sandbox Code Playgroud)
  1. 为什么在构造t时T(const bool)优先考虑T(const std::string&)?
  2. 由于上述优先级可能会导致混淆期望T(const std::string&)被调用的用户,T(const std::string&)在将字符串文字传递给T的构造函数时,我可以做什么来隐式调用.现在,我发现的唯一工作是添加另一个构造函数,最高优先权:

    T(const char* s)
    {
        std::cout << "T(const char*)" << endl;
        *this = std::string(s);
    }
    
    Run Code Online (Sandbox Code Playgroud)
  3. 除了上述解决方案之外,声明explicit T(const bool)避免混淆并不能解决上述问题:在这种情况下,虽然T t = ""现在已被禁止,为什么表格T t("")仍然被允许并打电话T(const bool)?

c++ overloading operator-overloading implicit-conversion

7
推荐指数
1
解决办法
188
查看次数

如何将java.util.List [java.lang.Double]转换为Scala的List [Double]?

我想以有效的方式将Java双打的Java列表(java.util.List [java.lang.Double])转换为Scala双精度的Scala列表(List [Double]).

目前我正在映射将每个Double值转换为Scala Double的列表.我不想映射每个值,我正在寻找一种更有效的方法.

import collection.JavaConversions._
import collection.mutable.Buffer

val j: java.util.List[java.lang.Double] = Buffer(new java.lang.Double(1.0), new java.lang.Double(2.0))
val s: List[Double] = ...
Run Code Online (Sandbox Code Playgroud)

我已经看过来自Scala的文档 - > Java,但没有太多其他方式.

java scala implicit-conversion

7
推荐指数
1
解决办法
6079
查看次数

很好地编写了一个在java中可以为null的数字

我有一个应用程序,我需要处理来自外部源的很多数字(整数或长整数).

数字可以为空.如果它们为null,我总是需要将它们转换为0.

问题似乎微不足道,但我不想写数百次:

if (someNumber == null) {
    someNumber = 0;
} 
Run Code Online (Sandbox Code Playgroud)

我不喜欢它有两个原因:

  1. 我不喜欢为这么简单的任务写三行代码,特别是因为我需要做很多次
  2. 我不喜欢"改变"someNumber(为someNumber变量赋值)

我尝试了其他一些方法,可以在这里看到:

  public static void main(String[] args) {
    Integer zeroOrNull = new Random().nextBoolean() ? 0 : null;


    // version1: this is nasty (I already mentioned why)
    if (zeroOrNull == null) {
      zeroOrNull = 0;
    }

    // version2: this seems to much for so simple task...
    zeroOrNull = Optional.ofNullable(zeroOrNull).orElseGet(() -> 0);

    // version3: creating an util might be considerable. Is there already such predefined util …
Run Code Online (Sandbox Code Playgroud)

java type-conversion implicit-conversion

7
推荐指数
1
解决办法
133
查看次数

对call-by-name参数的Scala隐式转换的工作方式不同,具体取决于函数是否过载

我们来看下面的代码:

import scala.language.implicitConversions
class Foo
implicit def int2Foo(a: => Int): Foo = new Foo
def bar(foo: Foo) = {}
def bar(foo: Boolean) = {}
bar {
  println("Hello")
  64
}
Run Code Online (Sandbox Code Playgroud)

此代码不显示任何信息,因为该块包含println("Hello")被视为=> Int它转化为Foo通过int2Foo.但是如果省略重载函数,就会发生令人惊讶的事情bar(foo: Boolean)

import scala.language.implicitConversions
class Foo
implicit def int2Foo(a: => Int): Foo = new Foo
def bar(foo: Foo) = {}
bar {
  println("Hello")
  64
}
Run Code Online (Sandbox Code Playgroud)

这会打印,Hello因为它会对块进行求值,64在这种情况下,只有最后一个语句被视为按名称调用参数.我无法理解这种差异背后存在什么样的理由.

scala implicit-conversion callbyname

7
推荐指数
1
解决办法
226
查看次数

Scala隐式转换在某些条件下应用,但在其他条件下不适用

这是一个简单的重现器,我在其中定义了一个带有隐式重新排序转换的"可交换"对类型.如果函数的参数f位于预先存在的命名值(t在示例中),则编译器会按预期应用隐式转换.但是,如果我尝试f直接调用literal CommutativePair,它会因类型错误而失败.在这种情况下,编译器不应用隐式重新排序转换.

object repro {
  import scala.language.implicitConversions

  case class CommutativePair[A, B](a: A, b: B)

  object CommutativePair {
    // Support a kind of commutative behavior via an implicit reordering
    implicit def reorderPair[B, A](pair: CommutativePair[B, A]) =
      CommutativePair(pair.b, pair.a)
  }

  // The idea is to allow a call to 'f' with Pair[Int, String] as well,
  // via implicit reorder.
  def f(p: CommutativePair[String, Int]) = p.toString

  val t = CommutativePair(3, "c")

  // This works: the implicit …
Run Code Online (Sandbox Code Playgroud)

scala implicit compiler-bug implicit-conversion implicits

7
推荐指数
1
解决办法
341
查看次数

没有未定义的行为[c ++],哪些浮点值无法转换为int?

我刚刚从C++ 14标准(我的重点)中读到了这个:

4.9浮动积分转换[conv.fpint]

1浮点类型的prvalue可以转换为整数类型的prvalue.转换截断; 也就是说,丢弃小数部分.如果截断的值无法在目标类型中表示,则行为未定义. [...]

这让我思考

  1. 哪个(如果有的话)float值int在截断后无法表示?(这取决于实施吗?)
  2. 如果有,这是否意味着auto x = static_cast<int>(float)不安全?
  3. 什么是转换的适当/安全的方式float来int然后(假设你要截断)?

c++ type-conversion implicit-conversion c++14

7
推荐指数
2
解决办法
1016
查看次数

从Scala项目中排除特定的隐式对象

如何防止在scala代码中使用特定的隐式?

例如,最近我被https://github.com/scala/scala/blob/68bad81726d15d03a843dc476d52cbbaf52fb168/src/library/scala/io/Codec.scala#L76Codec提供的默认值所困扰。有没有办法确保任何调用a的代码都implicit codec: Codec不会使用所提供的代码fallbackSystemCodec?或者,是否可以阻止所有隐式编解码器?

这是应该使用scalafix进行的吗?

scala sbt implicit-conversion scalafix

7
推荐指数
1
解决办法
254
查看次数

涉及老式枚举和整数类型的重载解析

考虑以下代码

#include <iostream>

using namespace std;

enum myEnum { a, b, c };

void test(myEnum e) {
  cout << "myEnum overload" << endl;
}

void test(unsigned int i) {
  cout << "unsigned int overload" << endl;
}

int main() {
  test(a);
  test(1);
  test(1u);  

  return 0;
}
Run Code Online (Sandbox Code Playgroud)

(我知道enum class比enum这种事情更安全,但是我使用的是带有旧式枚举的开源代码。)

当我用g ++ 4.4.7编译并运行它时,我得到了

myEnum overload
unsigned int overload
unsigned int overload
Run Code Online (Sandbox Code Playgroud)

也就是说,编译器更喜欢转换int,而unsigned int不是将其转换为myEnum。这就是我想要的,但是我想知道是否总是可以保证。该标准并未明确规定底层类型myEnum应该是什么,因此我认为也许是这样int,也许会更受欢迎unsigned int。

但是当我注释掉unsigned …

c++ enums overload-resolution implicit-conversion

7
推荐指数
1
解决办法
60
查看次数