Scala Function versus Dichotomy Class

Question

I just started learning Scala. I am quite satisfied with the design of OO, and even more so with functional programming; although, I programmed long enough so that FP is not completely unnatural for me. From the first day of my Scala adventure, I have had this, let’s say, inconvenience with the obvious dialectic that occurs between OO and FP. It is clear that everyone can go one way or another. My first tendency was to consider classes as their packages, which combine functions that I want to transfer, which balances the scales on the functional side. I feel that there must be a better way to balance the action. I am also not sure how to proceed with some familiar situations within this scenario. For example, if I had the following (artificial) class:

class ValueGenerator { def value() = { "1" } def value(line: String) = { line } } 

in OO programming, I would call value correct signature when I needed to get the result I needed. Methods have the same signature, because they logically correspond to similar actions. In OO, I would pass a reference to the object, and the methods that receive the ValueGenerator object will make a call to the right value , depending on the situation. As far as I can see, at least this is my tendency that a method should pass the norm in Scala. But in this case, although the methods do the same, they do not have the same signature, so they cannot be replaced by each other (or can they?). In other words, can the sender method decide which function to send regardless of the signature of the function? This seems unlikely because the recipient does not know how to call it. What is the right action in such a situation. Or does one go with gut instinct? Is there a rule of thumb you follow when it comes to OO vs FB?

As a note, it was interesting to see that my friend, who also studies Scala, had precise thoughts (or lack thereof) like me on this issue.

Answer 1

They do not have the same signature, and usually you need methods that do not have the same signature in order to have different names. Overloading buys you very little and costs a lot (namely, type of output and implicit resolution).

However, they cannot be replaced by each other, since they do not have the same type. If you converted these methods to functions, you would have the type Function0[String] , and the other would have the type Function1[String, String] .

Answer 2

There is no reason in the code you specified for why you need to have two separate method signatures:

 class ValueGenerator { def value(line: String = "1") = { line } } 

REPL session:

 scala> new ValueGenerator() res1: ValueGenerator = ValueGenerator@fa88fb scala> res1.value("Foo") res2: String = Foo scala> res1.value() res3: String = 1 

Keep in mind that you can only do this with methods. Functions do not support default arguments:

 scala> val f = res1.value(_) f: (String) => String = <function1> scala> f("Bar") res5: String = Bar scala> f() ***Oops*** scala> val f = (line: String) => line f: (String) => String = <function1> scala> val f = (line: String = "1") => line ***Oops*** 

Answer 3

As far as I can see, at least this is my tendency that in Scala the norm should go around the method.

I doubt that this norm (why do you think so?) Or that there is a norm for it in Scala at all.

But in this case, although the methods do the same, they do not have the same signature, so they cannot be replaced by each other (or can they?). In other words, can the sender method decide which function to send regardless of the signature of the function?

They cannot be replaced by each other because they have different signatures, therefore they have different types.

The scenario you are describing sounds like perfect for the OO method: just pass the ValueGenerator object and let the client decide which method to call on that object.