在“案例类”中具有“私有”构造函数字段有意义吗？

Question

I see some Scala code like this:

case class Team(private val members: List[User]) {
    def removed(member: User): Team = {
        Team(members.filterNot(_ == member))
    }
    def added(member: User): Team = {
        Team(member :: members)
    }
    def allNames: List[String] = members.map(_.name)
}

You can see the Team is a case class , but it has a private field members . And in the body, it has several methods to construct a new Team , and a method allNames which export some information of the private members .

I'm not sure if the usage of case class is good, since I think a case class is a data class, we should not use private fields. For this case, I think a normal class is enough:

class Team(members: List[User]) {
    def removed(member: User): Team = {
        new Team(members.filterNot(_ == member))
    }
    def added(member: User): Team = {
        new Team(member :: members)
    }
    def allNames: List[String] = members.map(_.name)
}

You can see I removed the case , and also private since for a normal class, the fields of constructor is private by default.

But I'm not sure if there is any good reason to write the code in the first approache.

Answer 1

Private vals in case classes are a little surprising because they're not as private as you might imagine if you think other ways of getting that value are just syntactic sugar.

In particular, pattern matching will give you the underlying value:

whatever match {
  case Team(members) => println("I can see "+members.mkString)
}

And the value still plays a role in equality (even if you can't get it by name), and you can create copies with different values using copy .

Sometimes a private val is used to enforce best practices for that class, which is to only use pattern matching to get the values (eg because you will often want to pattern match other things, and this enforces consistency). Sometimes it's an indication that the programmer doesn't understand how it works and thinks its enforcing a complete lack of access to the val.