我的目的是在Scala中创建一个函数,它接受某种动态查询(类似于模式匹配中的case表达式),并返回List中的匹配实例。假设列表由case class Person的实例组成,它几乎没有具有不同类型的属性。该函数应该能够接受一些字段的值的动态组合,并返回匹配的Person。我专门寻找一个干净的解决方案。使用这种函数的一种可能方法是传递一个具有匿名类型的对象作为查询(“模式”):
def find(?): List<Person> = { ? }
val matches = find(new { val name = "Name"; val gender = Ge
我使用scala反射来获取一个case类的所有字段,这些字段都不是方法。然后,我想看看该类型是基本类型还是字符串(或这些东西的选项)。下面是一个简单的工作示例,它检查字段是否为字符串。
scala> case class SimpleCase(val1: String)
defined class SimpleCase
scala> val members = typeOf[SimpleCase].members.filter(!_.isMethod).toList
members: List[reflect.runtime.universe.Symbol] = List(val
我正在学习Scala,在Programming in Scala 3rd Ed,Ch 10, Page 225,SectOverriding methods and fields,上面写着
统一访问原则只是Scala比Java更统一地处理字段和方法的一个方面。另一个不同之处是,在Scala中,字段和方法属于同一个名称空间。这使得字段可以覆盖无参数方法。例如,您可以将类ArrayElement中内容的实现从一个方法更改为一个字段,而不必修改类元素中内容的抽象方法定义,如清单10.4所示:
我基于这个例子的代码是
用def
abstract class Element {
def co
我想问一下如何在Scala中实现以下功能。考虑一下
scala> case class C(i:Int)
defined class C
scala> val c = C(1)
c: C = C(1)
给出一个感兴趣的领域,在这种情况下
scala> val fname = "i"
fname: String = i
我们希望检索c中字段i的原始值和类型。
首先,天真的尝试包括以下几点,
scala> val f = c.getClass.getDeclaredField(fname)
f: java.lang.reflect.Field = priv
我只需要得到案例类的字段名。我对它的价值不感兴趣。我以为getClass.getDeclaredFields.map(_.getName)会返回一个字段名列表。
scala> case class User(id: Int, name: String)
defined class User
scala> User.getClass.getDeclaredFields
res14: Array[java.lang.reflect.Field] = Array(public static final User$ User$.MODULE$)
scala> User.getCl
这是Scala 2.8.0测试版对这个问题的后续:
新的技术是复制一个case类,例如
case class Person(name:String, email:String)
val bob = Person("Bob", "bob@z.com")
val jill = bob.copy(name = "Jill")
这很好用,除了Scala似乎将我限制在22 (?)case类中的。这可能看起来很多,但在我的情况下是不够的。
对于23,我得到了:“错误:类型Function23不是scala包的成员”。我可以定义自己的Function23,
我有一个这样的Seq:
case class IntPane(
override val duration: FiniteDuration,
override val values: mutable.Map[String, Int],
override val default: Int)
extends BasePane[Int](duration, values, default)
我可以通过调用writes()来序列化它们,使用这个格式化程序:
implicit va
我有一门非案例课,我试着测试它是否平等。它有>22个字段,因此我不能使用Scala2.10.x中的case类:
class Row(
val date: String,
val time: String,
val orderId: String,
val id: String) extends Serializable {
override def toString: String = {
ToStringBuilder.reflectio
我使用Scala2.10.2,并且有两个具有相同字段的case类:
case class Foo(id: String, name: String)
case class Bar(id: String, name: String)
我想做这样的事情:
case class Thing(id: String, name: String)
type Foo = Thing
type Bar = Thing
这是编译的,但是当我尝试创建一个Foo时,我得到:
scala> Bar("a", "b")
<console>:8: error: not f
目前,我正在完成Scala项目,并将其转换为Java。一切都很顺利,但我被这段片段绊倒了:
Pattern fileNamePattern = Pattern.compile("^(\\w+).*(_\\w+\\.xml)$");
new File(filePath).getName match {
case FileNamePattern(first, last) => return first + last
case n => return n
}
我理解正则表达式,一个或多个字母、数字或标点符号,后面
假设函数r返回五个值的元组。
scala> def r = (1,2,3,4,5)
r: (Int, Int, Int, Int, Int)
当我从r分配返回的值时,我得到了大写字母变量的错误。
scala> val (a,b,c,d,E) = r
<console>:13: error: not found: value E
val (a,b,c,d,E) = r
^
如果我不使用大写字母,就不会出现错误。
scala> val (a,b,c,d,e) = r
a: Int = 1
b: Int = 2
c:
有人能告诉我为什么隐式类型转换不适用于==吗
示例:
class BitArray(l: Int, v: Long) {
val length = l
var value = v
def ==(that: BitArray) = value == that.value
def ==(integer: Long) = value == integer
def +(that: BitArray) = new BitArray(length,value+that.value )
def +(integer: Long) = ne
有许多不错的库可用于将Scala案例类写入CSV文件或从CSV文件中读取。我正在寻找更多的东西,它可以处理嵌套的案例类。例如,在这里,Match有两个Players
case class Player(name: String, ranking: Int)
case class Match(place: String, winner: Player, loser: Player)
val matches = List(
Match("London", Player("Jane",7), Player("Fred",23)),
Match
我有一个scala类A,其中有一个方法doSomething。 还有另一个B类 class B(name: String) 还有另一个C类 class C {
def doSomethingElse(b: B): String {
/// some logic
////
}
}
class A(c: C) {
def doSomething(uuid: UUID): String {
val b = new B("hello)
c.doSomethingElse(b)
// some logic
}
} 现在我想使用scalat
我有一个项目正在生成编译时堆栈溢出错误.
我使用Quill作为persistence,它使用宏。我有一个带有600+字段的case类,它表示一个数据库表。
在编译过程中,我得到了以下无限递归:
ervice.scala:27:更新email_user集password_hash =?user_id =?scala.tools.nsc.transform.Erasure$Eraser.adaptMember(Erasure.scala:686) at scala.tools.nsc.transform.Erasure$Eraser.typed1(Erasure.scala:773) at sc
考虑以下代码:
scala> case class Foo(s:String, t:String, r:String) {
| def == (f:Foo) = s == f.s && t == f.t
| }
defined class Foo
scala> val f1 = Foo("s", "t", "r")
f1: Foo = Foo(s,t,r)
scala> val f2 = Foo("s", "t", "r1")
f2:
在Scala中,代数数据类型被编码为sealed一级类型层次结构.示例:
-- Haskell
data Positioning a = Append
| AppendIf (a -> Bool)
| Explicit ([a] -> [a])
// Scala
sealed trait Positioning[A]
case object Append extends Positioning[Nothing]
case class AppendIf[A](condition: A => Boole