如何覆盖案例类同伴的应用

I think this works exactly how you want it to already. Here's my REPL session:

scala> case class A(val s: String)
defined class A


scala> object A {
| def apply(s: String) = new A(s.toUpperCase)
| }
defined module A


scala> A("hello")
res0: A = A(HELLO)

This is using Scala 2.8.1.final

I don't know how to override the apply method in the companion object (if that is even possible) but you could also use a special type for upper case strings:

class UpperCaseString(s: String) extends Proxy {
val self: String = s.toUpperCase
}


implicit def stringToUpperCaseString(s: String) = new UpperCaseString(s)
implicit def upperCaseStringToString(s: UpperCaseString) = s.self


case class A(val s: UpperCaseString)


println(A("hello"))

The above code outputs:

A(HELLO)

You should also have a look at this question and it's answers: Scala: is it possible to override default case class constructor?

The reason for the conflict is that the case class provides the exact same apply() method (same signature).

First of all I would like to suggest you use require:

case class A(s: String) {
require(! s.toCharArray.exists( _.isLower ), "Bad string: "+ s)
}

This will throw an Exception if the user tries to create an instance where s includes lower case chars. This is a good use of case classes, since what you put into the constructor also is what you get out when you use pattern matching (match).

If this is not what you want, then I would make the constructor private and force the users to only use the apply method:

class A private (val s: String) {
}


object A {
def apply(s: String): A = new A(s.toUpperCase)
}

As you see, A is no longer a case class. I am not sure if case classes with immutable fields are meant for modification of the incoming values, since the name "case class" implies it should be possible to extract the (unmodified) constructor arguments using match.

Another idea while keeping case class and having no implicit defs or another constructor is to make the signature of apply slightly different but from a user perspective the same. Somewhere I have seen the implicit trick, but can´t remember/find which implicit argument it was, so I chose Boolean here. If someone can help me out and finish the trick...

object A {
def apply(s: String)(implicit ev: Boolean) = new A(s.toLowerCase)
}
case class A(s: String)

It works with var variables:

case class A(var s: String) {
// Conversion
s = s.toUpperCase
}

This practice is apparently encouraged in case classes instead of defining another constructor. See here.. When copying an object, you also keep the same modifications.

UPDATE 2016/02/25:
While the answer I wrote below remains sufficient, it's worth also referencing another related answer to this regarding the case class's companion object. Namely, how does one exactly reproduce the compiler generated implicit companion object which occurs when one only defines the case class itself. For me, it turned out to be counter intuitive.

Summary:
You can alter the value of a case class parameter before it is stored in the case class pretty simply while it still remaining a valid(ated) ADT (Abstract Data Type). While the solution was relatively simple, discovering the details was quite a bit more challenging.

Details:
If you want to ensure only valid instances of your case class can ever be instantiated which is an essential assumption behind an ADT (Abstract Data Type), there are a number of things you must do.

For example, a compiler generated copy method is provided by default on a case class. So, even if you were very careful to ensure only instances were created via the explicit companion object's apply method which guaranteed they could only ever contain upper case values, the following code would produce a case class instance with a lower case value:

val a1 = A("Hi There") //contains "HI THERE"
val a2 = a1.copy(s = "gotcha") //contains "gotcha"

Additionally, case classes implement java.io.Serializable. This means that your careful strategy to only have upper case instances can be subverted with a simple text editor and deserialization.

So, for all the various ways your case class can be used (benevolently and/or malevolently), here are the actions you must take:

1. For your explicit companion object:
   1. Create it using exactly the same name as your case class
      • This has access to the case class's private parts
   2. Create an apply method with exactly the same signature as the primary constructor for your case class
      • This will successfully compile once step 2.1 is completed
   3. Provide an implementation obtaining an instance of the case class using the new operator and providing an empty implementation {}
      • This will now instantiate the case class strictly on your terms
      • The empty implementation {} must be provided because the case class is declared abstract (see step 2.1)
2. For your case class:
   1. Declare it abstract
      • Prevents the Scala compiler from generating an apply method in the companion object which is what was causing the "method is defined twice..." compilation error (step 1.2 above)
   2. Mark the primary constructor as private[A]
      • The primary constructor is now only available to the case class itself and to its companion object (the one we defined above in step 1.1)
   3. Create a readResolve method
      1. Provide an implementation using the apply method (step 1.2 above)
   4. Create a copy method
      1. Define it to have exactly the same signature as the case class's primary constructor
      2. For each parameter, add a default value using the same parameter name (ex: s: String = s)
      3. Provide an implementation using the apply method (step 1.2 below)

Here's your code modified with the above actions:

object A {
def apply(s: String, i: Int): A =
new A(s.toUpperCase, i) {} //abstract class implementation intentionally empty
}
abstract case class A private[A] (s: String, i: Int) {
private def readResolve(): Object = //to ensure validation and possible singleton-ness, must override readResolve to use explicit companion object apply method
A.apply(s, i)
def copy(s: String = s, i: Int = i): A =
A.apply(s, i)
}

And here's your code after implementing the require (suggested in the @ollekullberg answer) and also identifying the ideal place to put any sort of caching:

object A {
def apply(s: String, i: Int): A = {
require(s.forall(_.isUpper), s"Bad String: $s")
//TODO: Insert normal instance caching mechanism here
new A(s, i) {} //abstract class implementation intentionally empty
}
}
abstract case class A private[A] (s: String, i: Int) {
private def readResolve(): Object = //to ensure validation and possible singleton-ness, must override readResolve to use explicit companion object apply method
A.apply(s, i)
def copy(s: String = s, i: Int = i): A =
A.apply(s, i)
}

And this version is more secure/robust if this code will be used via Java interop (hides the case class as an implementation and creates a final class which prevents derivations):

object A {
private[A] abstract case class AImpl private[A] (s: String, i: Int)
def apply(s: String, i: Int): A = {
require(s.forall(_.isUpper), s"Bad String: $s")
//TODO: Insert normal instance caching mechanism here
new A(s, i)
}
}
final class A private[A] (s: String, i: Int) extends A.AImpl(s, i) {
private def readResolve(): Object = //to ensure validation and possible singleton-ness, must override readResolve to use explicit companion object apply method
A.apply(s, i)
def copy(s: String = s, i: Int = i): A =
A.apply(s, i)
}

While this directly answers your question, there are even more ways to expand this pathway around case classes beyond instance caching. For my own project needs, I have created an even more expansive solution which I have documented on CodeReview (a StackOverflow sister site). If you end up looking it over, using or leveraging my solution, please consider leaving me feedback, suggestions or questions and within reason, I will do my best to respond within a day.

I faced the same problem and this solution is ok for me:

sealed trait A {
def s:String
}


object A {
private case class AImpl(s:String)
def apply(s:String):A = AImpl(s.toUpperCase)
}

And, if any method is needed, just define it in the trait and override it in the case class.

For the people reading this after April 2017: As of Scala 2.12.2+, Scala allows overriding apply and unapply by default. You can get this behavior by giving -Xsource:2.12 option to the compiler on Scala 2.11.11+ as well.

If you're stuck with older scala where you cant override by default or you dont want to add the compiler flag as @mehmet-emre showed, and you require a case class, you can do the following:

case class A(private val _s: String) {
val s = _s.toUpperCase
}

As of 2020 on Scala 2.13, the above scenario of overriding a case class apply method with same signature works totally fine.

case class A(val s: String)


object A {
def apply(s: String) = new A(s.toUpperCase)
}

the above snippet compiles and runs just fine in Scala 2.13 both in REPL & non-REPL modes.