scala是否支持成员分配？
鉴于:
case class C(var x:Int, var y:Int)
val c = C(1,2)
val d = C(3,4)
是否有运营商将d的每个成员分配给c.
在C/C++中你会得到:
struct C{ int x, int y)
C c = {1,2}
C d = {3,4}
c = d
EDIT1
成员分配的最大好处之一是它的自动化
都
c() = d
和
c.copyFrom( d )
两者都有维护问题 - 如果新成员被添加到C成员,很容易忽略将成员添加到用户创建的功能.真正需要的是自动复制这些值的方法.
EDIT2
此行为的另一个用例:
val props:ThirdPartyType = ThirdPartyLibrary.getProperties()
val myprops:ThirdPartyType = MyLibrary.loadPropertiesFromFile()
props @= myprops // magic member-wise assignment
在这里我们可以找到:
我可以:
props.a = myprops.a
props.b = myprops.b
...
但是当我们更新到ThirdParty库的V2时,这种模式会中断.ThirdPartyType获得了我们没有复制的新成员.
这不能通过反思来解决吗？
为什么不能在case语句中放置表达式？:
x match {
case <VALUE EXPR> => {}
}
例如
x match {
case (1+2) => {}
}
不允许,但是
val someval = (1+new java.util.Random().nextInt())
x match {
case someval => {}
}
是.似乎如果允许第二种情况,那么第一种情况也是如此.
我正在尝试添加这样的映射列表:
val typ:Type = symbol.typeSignature
typ match {
case typeOf[collection.immutable.List[Any]] => { return a function to handle this type }
case typeOf[...] => {}
case typeOf[...] => {}
... many
}
如果我在spark工作中使用scala并行集合会发生什么？(通常会生成作业以处理多个线程上的集合的分区).或者就此而言,可能会启动子线程的工作？
spark的JVM是否限制了对单个内核的执行,或者它是否可以在多个内核上进行合理的分配(可能是在同一个节点上？)
在scala中是否有一种方法可以明确地要求隐式转换,或者我是否必须始终为此目的定义函数？
import collection.JavaConversions._
...
def toScalaCollections( v:Any ) : Any = {
v match {
case v2:java.lang.Map[Any] => v2.implicitly[ scala.collection.Map[Any] ]
case v2:java.lang.Iterable[Any] => v2.implicitly[ scala.collection.Iterable[Any] ]
...
}
}
是否有一种隐含在语言中的运算符？
NB.很明显,我可以通过定义来解决问题
import collection.JavaConversions._
...
def toScalaCollections( v:Any ) : Any = {
v match {
case v2:java.lang.Map[Any] => toScalaMap(v2)
case v2:java.lang.Iterable[Any] => toScalaList(v2)
...
}
}
我的观点是,有可能不必这样做吗？
我正在一个装饰器上实现不可变类的某些行为。我想要一个从namedtuple继承的类（具有属性不变性），并且还想添加一些新方法。像这样 ...但是正确防止将新属性分配给新类。
从namedtuple继承时，应定义__new__并设置__slots__为空元组（以保持不变性）：
def define_new(clz):
def __new(cls, *args, **kwargs):
return super(clz, cls).__new__(cls, *args, **kwargs)
clz.__new__ = staticmethod(__new) # delegate namedtuple.__new__ to namedtuple
return clz
@define_new
class C(namedtuple('Foo', "a b c")):
__slots__ = () # Prevent assignment of new vars
def foo(self): return "foo"
C(1,2,3).x = 123 # Fails, correctly
太好了 但是现在我想将__slots__任务移到装饰器中：
def define_new(clz):
def __new(cls, *args, **kwargs):
return super(clz, cls).__new__(cls, *args, **kwargs)
#clz.__slots__ = ()
clz.__slots__ = (123) # just for testing
clz.__new__ …>>> import sys
>>> print '{0:64b}'.format(sys.maxint)
111111111111111111111111111111111111111111111111111111111111111
>>> print '{0:16x}'.format(sys.maxint)
7fffffffffffffff
什么？7是哪里来的？
这也不符合我对2的补码的理解。