函数式编程的副作用是什么？

Question

我正在学习新的Java 8，我看到一个与函数式编程相关的定义是＆＃34;使用仅纯函数创建的程序，无副作用允许＆ ＃34;

其中一个副作用是＆＃34;就地修改数据结构＆＃34;。

我不理解这一行，因为最后我们需要与数据库交谈以存储或检索或更新数据。

修改数据库不起作用意味着我们将如何在函数式编程中与数据库对话？

Answer 1

"Modifying a data structure structure in place" means you directly manipulate the input datastructure (i.e. a List). "Pure functions" mean

• the result is only a function of it's input and not some other hidden state
• the function can be applied multiple times on the same input producing the same result. It will not change the input.

In Object Oriented Programming, you define behaviour of objects. Behaviour could be to provide read access to the state of the object, write access to it, or both. When combining operations of different concerns, you could introduce side effects.

For example a Stack and it's pop() operation. It will produce different results for every call because it changes the state of the stack.

In functional programming, you apply functions to immutable values. Functions represent a flow of data, not a change in state. So functions itself are stateless. And the result of a function is either the original input or a different value than the input, but never a modified input.

OO also knows functions, but those aren't pure in all cases, for example sorting: In non-functional programming you rearrange the elements of a list in the original datastructure ("in-place"). In Java, this is what Collections.sort()` does.

In functional programming, you would apply the sort function on an input value (a List) and thereby produce a new value (a new List) with sorted values. The function itself has no state and the state of the input is not modified.

So to generalize: given the same input value, applying a function to this value produces the same result value

Regarding the database operations. The contents of the database itself represent a state, which is the combination of all its stored values, tables etc (a "snapshot"). Of course you could apply a function to this data producing new data. Typically you store results of operations back to the db, thus changing the state of the entire system, but that doesn't mean you change the state of the function nor it's input data. Reapplying the function again, doesn't violate the pure-function constraints, because you apply the data to new input data. But looking at the entire system as a "datastructure" would violate the constraint, because the function application changes the state of the "input".

So the entire database system could hardly be considered functional, but of course you could operate on the data in a functional way.

But Java allows you to do both (OO and FP) and even mix both paradigms, so you could choose whatever approach fits your needs best.

or to quote from this answer

If you have several needs intermixed, mix your paradigms. Do not restrict yourself to only using the lower right corner of your toolbox.