Scala - multiple mutable parameter reference or pass-by-reference of pointers to objects

Question

Let's say I have some reusable method (more complicated in real life) that accepts 3 BigDecimal arguments and calculates something. After calculation input params change inside and i need all three of them outside for next calculation and so on.

If only it's just one argument I coulde return it as return value.

What is idiomatic way to do this thing in Scala?

object MutableTest extends App {

  def mutableMethodWithComplicatedButReusableLogic(a: BigDecimal, b: BigDecimal, c: BigDecimal) = {
    a = b + c
    c = b * a
    b = 0
    //All three of changed args should be available outside
  }

  var a: BigDecimal = 10
  var b: BigDecimal = 11
  var c: BigDecimal = 12

  //1. step
  mutableMethodWithComplicatedButReusableLogic(a, b, c)

  //2. step a, b, c should change in step 1 and
  mutableMethodWithComplicatedButReusableLogic(a*b, b, c -1)
  ....

}

This of course ends up with: Compile time Error:(9, 7) reassignment to val a = b + c

Is global variables answer, or some mutable helper holder Object?

Answer 1

I wound't mutate them, just return the computation result in a triplet or a case class instance:

def mutableMethodWithComplicatedButReusableLogic(
    a: BigDecimal, b: BigDecimal, c: BigDecimal
): (BigDecimal, BigDecimal, BigDecimal) = {
  val newA = ... //Compute a
  val newB = ... //Compute b
  val newC = ... //Compute c
  (newA, newB, newC) // Or whatever other cmputation
}

Answer 2

You can use tuple for returning multiple values or Use some wrapper case class which wraps a, b and c.

def mutableMethodWithComplicatedButReusableLogic(a: BigDecimal, b: BigDecimal, c: BigDecimal): (BigDecimal, BigDecimal, BigDecimal) = {
 (b + c, 0, b * (b + c))
}

Usage:

val (a, b, c) = mutableMethodWithComplicatedButReusableLogic(1, 2, 3)

Using case class (that is wrap this triplet with a case class and provide nice name, this is the recommended way as it can improve code maintainability)

case class Wrapper (val a: BigDecimal, val b: BigDecimal, val c: BigDecimal)

def mutableMethodWithComplicatedButReusableLogic(wrapper: Wrapper): Wrapper = {
  Wrapper((wrapper.b + wrapper.c, 0, wrapper.b * (wrapper.b + wraper.c)))
}

usage:

val Wrapper(a, b, c) = mutableMethodWithComplicatedButReusableLogic(Wrapper(1, 2, 3))

General Suggestions

Avoid using mutations as much as you can. Go immutable, this is only way to go bug free when your software grows. Also functions become testable and refactoring is easy. Code becomes declarative and easy to read. Communicate to the outside world from the function using return types. Give nice meaningful names for the return type classes instead of using simple tuples.

Use state only when it can improve the overall performance. Always contain the state inside a container and do not allow can other outside entity to manipulate the state.

This way you will have less problems in life and You can go home early.