我试图避免像这样的结构:
val result = this.getClass.getSimpleName
if (result.endsWith("$")) result.init else result
好吧,在这个例子中,then和else分支很简单,但你可以对复杂的图像进行成像.我建立了以下内容:
object TernaryOp {
class Ternary[T](t: T) {
def is[R](bte: BranchThenElse[T,R]) = if (bte.branch(t)) bte.then(t) else bte.elze(t)
}
class Branch[T](branch: T => Boolean) {
def ?[R] (then: T => R) = new BranchThen(branch,then)
}
class BranchThen[T,R](val branch: T => Boolean, val then: T => R)
class Elze[T,R](elze: T => R) {
def :: (bt: BranchThen[T,R]) = new BranchThenElse(bt.branch,bt.then,elze)
}
class BranchThenElse[T,R](val branch: T => Boolean, val …最近我偶然发现了一个奇怪的(对我而言)编译器错误消息.请考虑以下代码:
trait Foo {
type Res <: Foo
type Bar[X <: Res]
}
class MyFoo extends Foo {
override type Res = MyFoo
override type Bar[X <: Res] = List[X]
}
type FOO[F <: Foo, R <: Foo, B[_ <: R]] = F { type Res = R;
type Bar[X <: R] = B[X] }
def process[F <: Foo, R <: Foo, B[_ <: R]](f: FOO[F, R, B]) {}
现在,如果我想调用process方法,我必须显式写入类型参数:
process[MyFoo, MyFoo, List](new MyFoo) // fine
如果我写:
process(new …我试图将隐式参数与案例类结合起来,但我陷入困境.
case class C(i: Int)(implicit b: Boolean)
val c1 = C(1)(true)
implicit val b = true
val c2 = C(2)
c1 match {
case C(i)(b) => // doesn´t work
case C(i,b) => // doesn´t work
case C(i) => // works, but wanted: if (b) i else 0
}
根据Scala语言规范,由于编译器为case类生成了提取器对象:我的隐式Boolean不是结果case类的成员,所以它必须在第二个(隐式)参数列表中(我可以'不幸的是,在伴侣对象的apply方法中找到了:
c[tps](ps1 ). . .(psn)带有类型参数tps和值参数的案例类定义ps隐式生成一个提取器对象(第8.1.8节),其定义如下:
object c {
def apply[tps](ps1 ). . .(psn): c[tps] = new c[Ts](xs1 ). . .(xsn)
def unapply[tps](x: c[tps]) =
if …有人能解释一下这到底发生了什么吗？我现在还没有充分考虑到它:
val s = Seq(1D,2D,3D,4D)
case class WithUnit(value: Double, unit: String)
s map { WithUnit(_,"cm") } // works
s map { WithUnit(value = _ , unit = "cm") } // error: missing parameter type for expanded function ((x$2) => value = x$2)
我想编译器不能推断参数类型,因为我写了参数的名称.但为什么不呢？它只是因为陈述参数的名称而不应该更加困难？!
谢谢!
直观地说,以下应该起作用:
case class I(i: Int)
val s = Seq(I(1),I(2),I(3))
s.sortBy(_.i) // works
s.toSeq.sortBy(_.i) // works
s.toSet.toSeq.sortBy(_.i) // doesn´t work
为什么它的表现不如预期？
特质Map[A,+B]有一种方法
def minBy [B] (f: ((A, B)) ? B)(implicit cmp: Ordering[B]): (A, B)
我期望B特性与方法中的特性相同,但后来我仍然无法理解:
val m2 = Map('a -> "1", 'b ->"2" ,'c ->"3")
m2.minBy((t:(Symbol,String))=>Integer.parseInt(t._2))
这里B的Map[A,+B]就是String,不过B的minBy就是Int-或犯错吗？
所以我期望该方法的类型是相当的
def minBy [C] (f: ((A, B)) ? C)(implicit cmp: Ordering[C]): (A, B)
但这不是消息来源所说的.
如果两者都不同,我应该知道哪里？如果他们不是 - 你能发现并指出我的错误吗？
最近我一直在为算术表达式寻找一个合适的语法,但发现只有微不足道的语法pow(..., ...),例如忽略了.然后我自己尝试了,但有时它没有按照预期工作.例如,我错过了-在表达式前允许一元并修复它.也许有人可以看看我目前的方法并改进它.此外,我认为其他人可以利用,因为能够解析算术表达式是一项常见任务.
import scala.math._
import scala.util.parsing.combinator._
import scala.util.Random
class FormulaParser(val constants: Map[String,Double] = Map(), val userFcts: Map[String,String => Double] = Map(), random: Random = new Random) extends JavaTokenParsers {
require(constants.keySet.intersect(userFcts.keySet).isEmpty)
private val allConstants = constants ++ Map("E" -> E, "PI" -> Pi, "Pi" -> Pi) // shouldn´t be empty
private val unaryOps: Map[String,Double => Double] = Map(
"sqrt" -> (sqrt(_)), "abs" -> (abs(_)), "floor" -> (floor(_)), "ceil" -> (ceil(_)), "ln" -> (math.log(_)), "round" -> (round(_)), "signum" …当我浏览Paul Phillips GitHub存储库时,我注意到他经常使用某种结构:
trait A {
// ...
}
object A extends A
例如这里:scala-
improvement ,strings首先,来自Java,我不知道在同一范围内具有相同的特征和特征的对象.
现在我问它有什么好处？与所有特征成员直接定义对象有什么好处？好吧,我知道这个特性可以混入,但我假设在实践中只使用了这个对象.
以下为什么不工作？(是的,我正在使用2.9.0final并打开" -Xexperimental "选项.)
implicit def any2Dynamic(a: Any) = new Dynamic {
def applyDynamic(name: String)(args: Any*) = {
println(a + name)
}
}
"Say".hello // value hello is not a member of java.lang.String
人们可以争论这是多么有意义......如果这将按预期工作,优先权将发生在"Say".toInt:StringLike.toInt或(new Dynamic {...}).applyDynamic("toInt")？
我需要一种更简洁的方法将元组序列转换为地图映射图...作为签名,我得到以下情况Tuple4:
def tuple4Seq2MapOfMaps[A,B,C,D](seq: Seq[(A,B,C,D)]): Map[A,Map[B,Map[C,D]]]
下面的代码显示了我最近的丑陋代码,我坚持(类型A为D任意):
type A = Int
type B = Double
type C = String
type D = Boolean
val tupleSeq = Seq[(A,B,C,D)](
(1,1.0D,"a",true),
(1,1.0D,"b",true),
(1,1.0D,"c",false)
)
val x = tupleSeq.groupBy{ _._1 }.map{ case (k,s) => (k,s.map{ x => (x._2,x._3,x._4) }) }
val y = x.map{ case (k,s) => (k,s.groupBy{_._1}.map{ case (k,s) => (k,s.map{ x => (x._2,x._3) }) }) }
val z = y.map{ case (k1,m) => (k1,m.map{ case …