Modify one value in a Scala class constructor in a concise way

Question

If I want to modify one single parameter in a constructor.

In the Scala case class, the apply method will be overridden twice. Unless apply applies ( no pun ) to auxiliary constructor. Related to

• Modifying case class constructor parameter before setting value

• How to override apply in a case class companion

How one can modify one single input from a constructor ?

Criteria :

• The class must hold immutable data. All data must be accessible.

• Note it doesn't have to be case class.

• Additionally , no need to use the apply method.

• no extra unused parameters. In the example below, _fistName is still accessible but unused.

case class Person( lastName: String, _fistName: String, ... ) { lazy val fistName = _fistName.toLowerCase }

Answer 1

Here are two simple approaches.

Using class:

class Person(first: String, last: String) {
  val firstName = first.toLowerCase
  val lastName = last.toLowerCase()
}

val person = new Person("Adam", "Smith")
println(person.firstName + " " + person.lastName) // adam smith

Using trait + object's apply():

trait Person {
  val firstName: String
  val lastName: String
}

object Person {
  def apply(first: String, last: String) = new Person {
    override val firstName: String = first.toLowerCase
    override val lastName: String = last.toLowerCase
  }
}

val person = Person("Adam", "Smith")
println(person.firstName + " " + person.lastName) // adam smith

Note that classes must be instantiated with new, while traits (created with apply()) don't.

Why no case classes? Well, they are designed to serve as ADTs (abstract data types). Basically, they are thought of as containers for some data without any logic. That's why they get apply() out-of-the-box. If you want to override it, then means your class doesn't have the semantics of a case class.

I can see that @prayag took the effort of trying to help you force it into a case class, but seriously, if it doesn't have to be one (and you said so in the question), then don't make it one.

Answer 2

The reference you had posted seems to have lot of answers as well.

Two simple ways I could think of

1. make it abstract case class and define companion object which would mutate the value you want

2. define the member of case class as var and mutate it.

eg. (using scalatest)

 class CaseClassSpecs extends FunSpec {

   describe("case class modify") {

     it("APPROACH 1 : modifies abstract case class member") {

      object Item {
        def apply(itemId: String, itemName: String) :Item = new Item(itemId.toLowerCase, itemName) {}
      }

      abstract case class Item private (val itemId: String, itemName: String)

      val item1 = Item("SKU-ONE", "Shirts")

      assert(item1.itemId == "sku-one")
      assert(item1.itemName == "Shirts")
    }

     it("APPROACH 2 : modifies case class member which is var") {

      case class Item (var itemId: String, itemName: String) {
        itemId = itemId.toLowerCase()
      }

      val item1 = Item("SKU-ONE", "Shirts")

      assert(item1.itemId == "sku-one")
      assert(item1.itemName == "Shirts")
    }
   }
  }