当我在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)
为什么?
谢谢!
我问的最后一个问题是我在试图理解另一件事时偶然发现的事情......我也无法理解(不是我的一天).
这是一个很长的问题陈述,但至少我希望这个问题可能对许多人有用,而不仅仅是我.
我的代码如下:
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) 考虑以下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)
T(const bool)优先考虑T(const std::string&)?由于上述优先级可能会导致混淆期望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)除了上述解决方案之外,声明explicit T(const bool)避免混淆并不能解决上述问题:在这种情况下,虽然T t = ""现在已被禁止,为什么表格T t("")仍然被允许并打电话T(const bool)?
我想以有效的方式将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,但没有太多其他方式.
我有一个应用程序,我需要处理来自外部源的很多数字(整数或长整数).
数字可以为空.如果它们为null,我总是需要将它们转换为0.
问题似乎微不足道,但我不想写数百次:
if (someNumber == null) {
someNumber = 0;
}
Run Code Online (Sandbox Code Playgroud)
我不喜欢它有两个原因:
我尝试了其他一些方法,可以在这里看到:
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) 我们来看下面的代码:
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在这种情况下,只有最后一个语句被视为按名称调用参数.我无法理解这种差异背后存在什么样的理由.
这是一个简单的重现器,我在其中定义了一个带有隐式重新排序转换的"可交换"对类型.如果函数的参数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) 我刚刚从C++ 14标准(我的重点)中读到了这个:
4.9浮动积分转换[conv.fpint]
1浮点类型的prvalue可以转换为整数类型的prvalue.转换截断; 也就是说,丢弃小数部分.如果截断的值无法在目标类型中表示,则行为未定义. [...]
这让我思考
float值int在截断后无法表示?(这取决于实施吗?)auto x = static_cast<int>(float)不安全?float来int然后(假设你要截断)?如何防止在scala代码中使用特定的隐式?
例如,最近我被https://github.com/scala/scala/blob/68bad81726d15d03a843dc476d52cbbaf52fb168/src/library/scala/io/Codec.scala#L76Codec提供的默认值所困扰。有没有办法确保任何调用a的代码都implicit codec: Codec不会使用所提供的代码fallbackSystemCodec?或者,是否可以阻止所有隐式编解码器?
这是应该使用scalafix进行的吗?
考虑以下代码
#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 …
scala ×5
c++ ×4
java ×2
c++14 ×1
callbyname ×1
compiler-bug ×1
enums ×1
implicit ×1
implicits ×1
overloading ×1
sbt ×1
scalafix ×1
templates ×1
traits ×1