有一个类,其构造函数的参数列表非常长:
case class ClassA(a: Int, b: String, c: Int /*and so on*/)
我需要对它做一个模式匹配:
val cls = getClassA
cls match {
case ClassA(a, _, _, _, _, /* and so on */) => Some(a)
case ClassA(_, _, c, _, _, /* and so on */) => Some(c)
case _ => None
}
我需要捕捉a或c的值。如果我真的不需要其他参数,可以不通过_来指定
还有比“这就是它的工作方式”更好的解释吗?我的意思是我试过这个:
class TestShortMatch[T <: AnyRef] {
def foo(t: T): Unit = {
val f = (_: Any) match {
case Val(t) => println(t)
case Sup(l) => println(l)
}
}
class Val(t: T)
class Sup(l: Number)
}
和编译器投诉:
Cannot resolve symbol 'Val' Canno
我正在尝试理解Scala对Case类做了什么,使它们在某种程度上对类型擦除警告具有免疫力。
假设我们有以下简单的类结构。它基本上是一个Either
abstract class BlackOrWhite[A, B]
case class Black[A,B]( val left: A ) extends BlackOrWhite[A,B]
case class White[A,B]( val right: B ) extends BlackOrWhite[A,B]
你试着这样使用它:
object Main extends App {
def echo[A,B] ( input:
sealed trait User
case class ExternalUser(name: String, email: String) extends User
case class InternalUser(tag: String, email: String) extends User
val user: User = ...
user match {
case u: ExternalUser =>
println(s"${u.name}")
case InternalUser(tag, email) =>
printl
在scala的代码库中工作,它希望您对某些类定义一种“创建新版本”--例如,如果您有一个类x(a :int,b:String,c:double).它会有这样的功能:
class x( a: Integer, b : String, c : Double) extends CanMakeNew
{
def newValue() = x( a, b, c)
}
我对此没有控制权--但我不愿每次都这样做。或者,嗯..。永远不会。在scala中是否有一种使用反射迭代构造函数参数值的方法?我可以使用反射来查看参数类型--但是由于这个模块还没有打开参数名,而且我也不能打开它--我不能将这些参数与类
我有两个case类,它们的所有变量都是可选的。
假设我有:
case class Size(width: Option[Int], height: Option[Int])
case class Foo(a: Option[String], b: Option[Boolean], c: Option[Char])
给定一个相同类型的case类的集合,我想将它们折叠起来,比较选项值,并保留已定义的值。例如,对于Size
values.foldLeft(x) { (a, b) =>
Size(a.width.orElse(b.width), a.height.orElse(b.heigh
如果我在Some方法中不使用unapply,为什么下面的代码不能工作?
scala> object T {
| def unapply(i:Int) = (i+1,i+2) //Some not used, I get error
| }
defined object T
scala> 1 match {
| case T(x,y) => println(x,y)
| }
<console>:14: error: an unapply result must have a member `def isEmpty: Bool
我想知道是否有一种方法可以知道一个对象是否是case类的实例。我试图寻找一些与unapply匹配的结构类型,我注意到它们继承了Product。我真正需要的函数应该是这样的:
def withCaseClass[T <: /* matcher for case class */](obj:T) ...
我的主要兴趣是确保只有case类可以传递给这个函数。
我有一个来自库类的case,我希望重写unapply方法,以减少需要传递的参数()的数量,以便对其进行模式匹配。我这样做:
object ws1 {
// a library class
case class MyClass(a: Int, b: String, c: String, d: Double /* and many more ones*/)
// my object I created to override unapply of class MyClass
object MyClass {
def unapply(x: Int) = Some(x)
假设我有一个Scala match表达式
foo match {
case Bar(Some(x)) => /* do something */
case Bar(None) => /* do something else */
}
当编译器编译表达式时,它做了多少优化?具体地说,它是向Bar.unapply发出多个调用,还是发出一个调用并多次匹配结果?
为了这篇文章的目的,我们对代码片段进行了微不足道的采样。
case class Person(firstName:String,lstName:String)
这个person类在代码库中被广泛使用。现在,后来的需求发生了变化,决定将phoneNumber添加到person case类中
例如:
case class Person(firstName:String,lstName:String,phoneNumber:String)
同样,在这篇文章中,示例被简化了。在现实中,有更多有趣的事情正在发生。请注意,phoneNumber不是Option,而是必填字段。通常,人们会去更新所有使用Pe
想象一个抽象的A类,它有一组case类。我们不知道有多少个set类,甚至不知道这些case类的名称。
abstract class A(field: String)
//Example of a case class that extends A
case class B(f: String) extends A(f)
现在我有了这个:
a match {
case B(f) => println("f")
}
我想通过一个参数将case类类型传递给一个方法。我希望这样做的原因是因为我将在一个文件中配置一组规则。我想加载这些规则,并使用模式匹配和这些规则提供的一些
我正在尝试理解List在Scala中的实现。特别是,我正在尝试理解如何使用中缀运算符编写匹配表达式,例如:
a match {
case Nil => "An empty list"
case x :: Nil => "A list without a tail"
case x :: xs => "A list with a tail"
}
如何允许匹配表达式为x :: xs而不是List(x, xs)
这个问题的短篇故事在标题里。有一些Java类,例如,我想(不重写它)将它变成一个case类,也就是说,它有apply和unapply方法。
长话短说:我有一个Scala播放应用程序,在那里我定义了一个需要两个间隔的表单,即
import org.joda.time.Interval
case class MyParams(param1: String, interval1: Interval, interval2: Interval)
然后我尝试定义嵌套映射,但是Interval是一个apply类,没有apply/unapply,我不想创建自己的副本。
val myForm = Form {
在以下简化的示例代码中:
case class One[A](a: A) // An identity functor
case class Twice[F[_], A](a: F[A], b: F[A]) // A functor transformer
type Twice1[F[_]] = ({type L[α] = Twice[F, α]}) // We'll use Twice1[F]#L when we'd like to write Twice[F]
trait Applicative[F[_]] // Members omitted
val applicati
通常,您有“对称”匹配,并希望编写如下内容:
def g(p:(Int,Int)) = p match {
case (10,n) | (n,10) => println(n)
case _ => println("nope")
}
这是不允许的,但如果每个备选方案都有相同类型的相同变量,这应该不是问题,因为它可以转换为单独的案例:
def g(p:(Int,Int)) = p match {
case (10,n) => println(n)
case (n,10) => println(n)
case _ => printl
我有我的java枚举,如:FOO("foo"),BAR("bar") .我有一个getValue()方法来返回枚举的值"foo"和"bar",这必须是在Java中。
另一方面,我必须在Scala中匹配这一点:
result match {
case "foo" =>
我想做的是:
result match {
case Enum.FOO.getValue() =>
我知道这个错误:
method getValue is not a case class constructor, nor doe
我正在用我自己的实现替换case类的伴生对象上的unapply方法。在研究了许多与实现unapply相关的不同切点之后,似乎在它们中的大多数都存在null保护,无论是在编译器生成的代码中还是在显式重新定义它的实现中。来自编译器为unapply生成的代码的代码如下所示(其中一些代码使用eq而不是ne): def unapply(location: Location): Option[(Double, Double)] =
if (location ne null)
Some((location.longitude, location.latitude))
else
No
我有两个案例班的人和员工
case class Person(identifier: String) {}
case class Employee (salary: Long) extends Person {}
我收到以下错误:
Unspecified value parameters: identifier: String
Error: case class Employee has case ancestor Person, but case-to-case inheritance is prohibited. To overcome this limitation, use extr
正在使用Lazy Structure Stream,如下所示
import Stream._
sealed trait Stream[+A] {
..
def toList: List[A] = this match {
case Empty => Nil
case Cons(h, t) => println(s"${h()}::t().toList"); h()::t().toList
}
def foldRight[B](z: B) (f: ( A, => B) => B) : B =
给定:
$scala
Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_101).
Type in expressions for evaluation. Or try :help.
scala> :paste
// Entering paste mode (ctrl-D to finish)
object F { def f(a: A) = a.hidden }
case class F(private [this] val hidden: Int)
// Exiting paste mo
我以前使用case类将类对象转换为slick2的数据,但现在我使用另一个play插件,这个插件对象使用case类,我的类是从这个case类继承而来的。所以,我不能用case类作为scala语言中被禁止的用例类固有的。
之前:
case class User()
class UserTable(tag: Tag) extends Table[User](tag, "User") {
...
def * = (...)<>(User.tupled,User.unapply)
}
它起作用了。但现在我需要将上面的代码更改为下面的代码:
case class Ba