有什么好的例子：“程序的操作应该将输入值映射到输出值而不是更改数据”

Question

I came across this sentence in Scala in explaining its functional behavior .

operation of a program should map input of values to output values rather than change data in place

Could somebody explain it with a good example?

Edit: Please explain or give example for the above sentence in its context, please do not make it complicate to get more confusion

Answer 1

The most obvious pattern that this is referring to is the difference between how you would write code which uses collections in Java when compared with Scala. If you were writing scala but in the idiom of Java , then you would be working with collections by mutating data in place. The idiomatic scala code to do the same would favour the mapping of input values to output values.

Let's have a look at a few things you might want to do to a collection:

Filtering

In Java, if I have a List<Trade> and I am only interested in those trades executed with Deutsche Bank , I might do something like:

for (Iterator<Trade> it = trades.iterator(); it.hasNext();) {
    Trade t = it.next();
    if (t.getCounterparty() != DEUTSCHE_BANK) it.remove(); // MUTATION
}

Following this loop, my trades collection only contains the relevant trades. But, I have achieved this using mutation - a careless programmer could easily have missed that trades was an input parameter, an instance variable, or is used elsewhere in the method. As such, it is quite possible their code is now broken . Furthermore, such code is extremely brittle for refactoring for this same reason; a programmer wishing to refactor a piece of code must be very careful to not let mutated collections escape the scope in which they are intended to be used and, vice-versa, that they don't accidentally use an un-mutated collection where they should have used a mutated one.

Compare with Scala:

val db = trades filter (_.counterparty == DeutscheBank) //MAPPING INPUT TO OUTPUT

This creates a new collection ! It doesn't affect anyone who is looking at trades and is inherently safer.

Mapping

Suppose I have a List<Trade> and I want to get a Set<Stock> for the unique stocks which I have been trading. Again, the idiom in Java is to create a collection and mutate it.

Set<Stock> stocks = new HashSet<Stock>();
for (Trade t : trades) stocks.add(t.getStock()); //MUTATION

Using scala the correct thing to do is to map the input collection and then convert to a set:

val stocks = (trades map (_.stock)).toSet  //MAPPING INPUT TO OUTPUT

Or, if we are concerned about performance:

(trades.view map (_.stock)).toSet
(trades.iterator map (_.stock)).toSet

What are the advantages here? Well:

1. My code can never observe a partially-constructed result
2. The application of a function A => B to a Coll[A] to get a Coll[B] is clearer.

Accumulating

Again, in Java the idiom has to be mutation. Suppose we are trying to sum the decimal quantities of the trades we have done:

BigDecimal sum = BigDecimal.ZERO
for (Trade t : trades) {
    sum.add(t.getQuantity()); //MUTATION
}

Again, we must be very careful not to accidentally observe a partially-constructed result! In scala, we can do this in a single expression:

val sum = (0 /: trades)(_ + _.quantity) //MAPPING INTO TO OUTPUT

Or the various other forms:

(trades.foldLeft(0)(_ + _.quantity)
(trades.iterator map (_.quantity)).sum
(trades.view map (_.quantity)).sum

Oh, by the way, there is a bug in the Java implementation! Did you spot it?

Answer 2

I'd say it's the difference between:

var counter = 0
def updateCounter(toAdd: Int): Unit = {
  counter += toAdd
}
updateCounter(8)
println(counter)

and:

val originalValue = 0
def addToValue(value: Int, toAdd: Int): Int = value + toAdd
val firstNewResult = addToValue(originalValue, 8)
println(firstNewResult)

This is a gross over simplification but fuller examples are things like using a foldLeft to build up a result rather than doing the hard work yourself: foldLeft example

Answer 3

What it means is that if you write pure functions like this you always get the same output from the same input, and there are no side effects, which makes it easier to reason about your programs and ensure that they are correct.

so for example the function:

def times2(x:Int) = x*2

is pure, while

def add5ToList(xs: MutableList[Int]) {
    xs += 5
}

is impure because it edits data in place as a side effect. This is a problem because that same list could be in use elsewhere in the the program and now we can't guarantee the behaviour because it has changed.

A pure version would use immutable lists and return a new list

def add5ToList(xs: List[Int]) = {
    5::xs
}

Answer 4

There are plenty examples with collections, which are easy to come by but might give the wrong impression. This concept works at all levels of the language (it doesn't at the VM level, however). One example is the case classes. Consider these two alternatives:

// Java-style
class Person(initialName: String, initialAge: Int) {
    def this(initialName: String) = this(initialName, 0)
    private var name = initialName
    private var age = initialAge
    def getName = name
    def getAge = age
    def setName(newName: String) { name = newName }
    def setAge(newAge: Int) { age = newAge }
}

val employee = new Person("John")
employee.setAge(40) // we changed the object

// Scala-style
case class Person(name: String, age: Int) {
  def this(name: String) = this(name, 0)
}
val employee = new Person("John")
val employeeWithAge = employee.copy(age = 40) // employee still exists!

This concept is applied on the construction of the immutable collection themselves: a List never changes. Instead, new List objects are created when necessary. Use of persistent data structures reduce the copying that would happen on a mutable data structure.