为什么"for/comprehension"表达式的数值类型的desugaring和隐式转换与(!)赋值操作相比不一致？
我相信对此有很多一般性的观点,但我无法找出当前行为的简明和合理的解释.[参考:"Scala for/comprehension的行为......" ]为了正确起见,下面的所有翻译都是使用scala编译器生成的("scalac -Xprint:typer -e")
例如,在隐式数字赋值转换期间,Destination类型占主导地位:
来源:var l:Long = 0
结果:val l: Long = 0L
来源:var l:Long = 0.toInt
结果:var l: Long = 0.toInt.toLong
在"for/comprehension"表达式的隐式转换期间,Source类型占主导地位:
来源:for (i:Long <- 0 to 1000000000L) { }
结果:0.to(1000000000L).foreach(((i: Long) => ()))
来源:for (i <- 0L to 1000000000L) { }
结果:scala.this.Predef.longWrapper(0L).to(1000000000L).foreach[Unit](((i: Long) => ()))
numerical types scala list-comprehension implicit-conversion
从书中做一些运动我遇到了疑问.我已经将一些运算符重载定义为类(Stonewt)的友元函数.问题来自这些原型:
friend ostream & operator<<(ostream &os, Stonewt &st);
friend Stonewt operator+(Stonewt &st1, Stonewt &st2);
如果我依赖构造函数进行隐式转换并让编译器完成工作,如下所示(test1和test2是类对象):
cout << "Summing both weights: " << test1 + test2;
我得到这样的错误消息:
无法将'std :: basic_ostream'左值绑定到'std :: basic_ostream &&'
初始化'std :: basic_ostream <_CharT,_Traits>&std :: operator <<的参数1(std :: basic_ostream <_CharT,_Traits> &&,const _Tp&)[with _CharT = char; _Traits = std :: char_traits; _Tp = Stonewt]'
OTOH,如果我执行以下操作,我不会收到任何错误:
Stonewt test3 = test1 + test2;
cout << "Summing both weights: " << test3;
就像编译器获得Stonewt对象一样,它可以转换为Stonewt&(这就是函数所期望的).但如果它得到了其他的东西,它就无法到达Stonewt&.(同样的事情发生在其他运算符重载的其他实例中,如operator*,如果我放一个double并期望编译器通过构造函数将其转换为Stonewt然后到Stonewt&,它不起作用.我必须放一个Stonewt宾语).
我会把整个程序放在你需要的地方:
班级定义:
// stonewt1.h -- revised …c++ compiler-errors operator-overloading friend-function implicit-conversion
我有一个C可以转换为类的类A和一个A*作为参数的函数.我想用a调用它C*,但我似乎无法让转换构造函数工作.我明白了:error: cannot convert ‘C*’ to ‘A*’ for argument ‘1’ to ‘void doSomething(A*)’.我究竟做错了什么？
class C {
};
class A {
public:
A(C* obj) {}
};
void doSomething(A* object);
int main()
{
C* object = new C();
doSomething(object);
}
我试图将以下Scala 2.9隐式转换方法转换为2.10隐式类:
import java.sql.ResultSet
/**
* Implicitly convert a ResultSet to a Stream[ResultSet]. The Stream can then be
* traversed using the usual map, filter, etc.
*
* @param row the Result to convert
* @return a Stream wrapped around the ResultSet
*/
implicit def stream(row: ResultSet): Stream[ResultSet] = {
if (row.next) Stream.cons(row, stream(row))
else {
row.close()
Stream.empty
}
}
我的第一次尝试没有编译:
implicit class ResultSetStream(row: ResultSet) {
def stream: Stream[ResultSet] = {
if (row.next) Stream.cons(row, stream(row))
else {
row.close()
Stream.empty
} …鉴于代码:
public class Filter<T>
{
private bool selected = false;
public bool Selected { get { return selected; } }
private T value;
public T Value { get{ return this.value; } set { this.value = value; selected = true; }
}
public class Test
{
public void filter()
{
DateTime a= new DateTime();
Nullable<DateTime> b = new DateTime(); //Work Like a Charm
Filter<DateTime> c = new DateTime(); //Dosent Work
}
}
在Nullable<T>该new DateTime()可直接分配到变量.在我的班上,它不起作用.我想了解我所缺少的东西.
我觉得这很简单.但我无法用言语来找到答案.
c# class type-conversion conversion-operator implicit-conversion
为什么foo1失败而foo2成功？编译器不应该自动检查Blah的所有超类型吗？
trait Foo[A] {
def bar: A
}
trait Bleh;
case class Blah extends Bleh;
implicit object BlehFoo extends Foo[Bleh]
def foo1[A:Foo](a:A) = a
def foo2[A,B:Foo](a:A)(implicit aToB: A => B) = aToB(a)
// Shouldn't it automatically use Bleh?
foo1(Blah())
// Failure: could not find implicit value for evidence parameter of type Foo[Blah]
foo2(Blah())
// Success: Bleh = Blah()
我正在使用Scala 2.10并且遇到Slick问题(普通查询,java.sql.ResultSet).如果我写像这样的查询
Q.query[String, ResultSet](query).list(rs.getString("id"))
日食会告诉我 could not find implicit value for parameter rconv: scala.slick.jdbc.GetResult[java.sql.ResultSet]
我这个问题最重要的来源(http://slick.typesafe.com/doc/0.11.2/sql.html)没有帮助.如何编写这些隐式转换？ResultSet在Slick中还有其他任何一种代表s的方式吗？
如何检查可变参数模板声明中的所有类型都可以转换为size_t：
// instantiate only if extents params are all convertible to size_t
template<typename T, size_t N>
template<typename... E>
Array<T,N>::Array(E... extents) {
constexpr size_t n = sizeof...(extents);
static_assert(n == N, "Dimensions do not match");
// code for handling variadic template parameters corresponding to dimension sizes
}
具有以下用法：
Array<double, 2> a(5,6); // OK 2-D array of 5*6 values of doubles.
Array<int, 3> a(2,10,15) // OK 3-D array of 2*10*15 values of int.
Array<int, 2> a(2, "d") // Error: "d" is not a …假设我有以下方法:
def main(args: Array[String]): Unit = {
println(Ring(2) + Ring(3) + Ring(-1) + Ring(10))
}
产生:
([2] left->([-1] left-> null,right-> null),right->([3] left-> null,right->([10] left-> null,right->空值)))
我想写一个隐式转换,它允许我以下面的方式编写代码:
def main(args: Array[String]): Unit = {
val r :Ring = 2 + 3 + (-1) + 10
println(r)
}
但是遵循隐式方法
implicit def intToRing(x :Int): Ring = {
new Ring(x)
}
以这种方式工作首先它总结所有元素,然后创建Ring产生的东西:
([14] left-> null,right-> null)
是否有可能实现"非贪婪"的隐式转换,这将成为我想要的东西？
我希望以下代码输出Seq(0),而不是它返回一个函数？
@ Seq(0).orElse(Seq(1))
res2: PartialFunction[Int, Int] = <function1>
我一开始怀疑通过语法将其添加orElse到apply函数上,但是从那时起它没有尝试:
@ Seq(0).apply.orElse(Seq(1))
cmd3.sc:1: missing argument list for method apply in trait SeqLike
....(omit)
我在IntellJ检查过没有implicit conversion.
怎么了？
编辑:我希望是:
Seq.empty.orElse(Seq(1)) == Seq(1)
Seq(0).orElse(Seq(1)) == Seq(0)
谢谢@AndreyTyukin回答.
在一行中,orElse具有不同类型的不同语义,现在不Seq继承,行为也是如此.PartialFunctionOptionorElse