是的。 你们是正确的! 如今或现在或现在,或以任何方式签署这种fl,都不是以某种方式表现出参考性透明度。 但是,根据对汇编者的指令,它被系统束缚了输入。

By output, Now() might look like not following referential transparency. But actual behaviour of the system clock and the function on top of it is adheres to referential transparency.

是的,在职能方案拟订中,可以使用一个略为修改的功能性方案拟订版本,称为“功能性功能性方案”(缺省或主要内容是纯功能性方案)。

In case of getting the time (or reading file, or launching missile) the code needs to interact with the outer world to get the job done and this outer world is not based on the pure foundations of functional programming. To allow a pure functional programming world to interact with this impure outside world, people have introduced impure functional programming. After all, software which doesn t interact with the outside world isn t any useful other than doing some mathematical computations.

Few functional programming programming languages have this impurity feature inbuilt in them such that it is not easy to separate out which code is impure and which is pure (like F#, etc.) and some functional programming languages make sure that when you do some impure stuff that code is clearly stand out as compared to pure code, like Haskell.

Another interesting way to see this would be that your get time function in functional programming would take a "world" object which has the current state of the world like time, number of people living in the world, etc. Then getting time from which world object would be always pure i.e you pass in the same world state you will always get the same time.

Your question conflates two related measures of a computer language: functional/imperative and pure/impure.

一种功能性语言界定了各项职能的投入和产出之间的关系,一种必须使用的语言描述特定业务,以便具体开展工作。

纯语言不会产生或取决于副作用,而一种杂质的语言在整个使用。

One-hundred percent pure programs are basically useless. They may perform an interesting calculation, but because they cannot have side effects they have no input or output so you would never know what they calculated.

To be useful at all, a program has to be at least a smidge impure. One way to make a pure program useful is to put it inside a thin impure wrapper. Like this untested Haskell program:

-- this is a pure function, written in functional style.
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

-- This is an impure wrapper around the pure function, written in imperative style
-- It depends on inputs and produces outputs.
main = do
    putStrLn "Please enter the input parameter"
    inputStr <- readLine
    putStrLn "Starting time:"
    getCurrentTime >>= print
    let inputInt = read inputStr    -- this line is pure
    let result = fib inputInt       -- this is also pure
    putStrLn "Result:"
    print result
    putStrLn "Ending time:"
    getCurrentTime >>= print

You re broaching a very important subject in functional programming, that is, performing I/O. The way many pure languages go about it is by using embedded domain-specific languages, e.g., a sublanguage whose task it is to encode actions, which can have results.

例如,Haskell的操作时间预计我会确定一项名为main<>/code>的行动,由构成我的方案的所有行动组成。 其后,该手术会执行。 多数时候,在这样做时,它执行的是纯粹的法典。 从时间来看,运行时间将使用计算数据进行I/O,并将反馈数据反馈为纯代码。

type Clock = Integer -- To make it more similar to the C code

-- An action that returns nothing, but might do something
main :: IO ()
main = do
    -- An action that returns an Integer, which we view as CPU Clock values
    c <- getCPUTime :: IO Clock
    -- An action that prints data, but returns nothing
    print (c + 2*1000*1000*1000*1000) :: IO ()

对Haskell而言,有一种概念是,一个国际交易日志的行动,可以用来开展一些国际交易日志的工作。 因此,不提及<代码> 我们参考了<代码>IO Time数值。 所有这些都将是完全有效的。 我们指的是<条码>日,但与的意思大致相同的内容为。

When we actually execute the Haskell program, the IO action would actually take place.

It can be answered without introducing other concepts of FP.

Possibility 1: time as function argument

A language consists of

1. language core and
2. standard library.

Referential transparency is a property of language core, but not standard library. By no means is it a property of programs written in that language.

Using OP s notation, should one have a function

f(t) = t*v0 + x0; // mathematical function that knows current time

They would ask standard library to get current time, say 1.23, and compute the function with that value as an argument f(1.23) (or just 1.23*v0 + x0, referential transparency!). That way the code gets to know the current time.

Possibility 2: time as return value

Answering OP s question:

Can a time function (which returns the current time) exist in functional programming?

Yes, but that function has to have an argument and you would have to compute it with different inputs so it returns different current time, otherwise it would violate the principals of FP.

f(s) = t(s)*v0 + x0; // mathematical function t(s) returns current time

This is an alternative approach to what I ve described above. But then again, the question of obtaining those different inputs s in the first place still comes down to standard library.

Possibility 3: functional reactive programming

这一设想是:<代码>t(<>t(>>)评价目前与功能t 2搭配的情况。 当现在再次需要使用<代码>t2()时,该编码将行使<代码>t<3>/code>的功能。

(x, t2) = t(); // it s x o clock now
...
(x2, t3) = t2(); // now it s already x2 o clock
...
t(); x; // both evaluate to the initial time, referential transparency!

私营部门司有更多的工作要做,但我认为这超出了禁止化学武器组织的范围。 例如,人们如何要求标准图书馆对一项功能进行认证,并完全以功能性的方式对其收益价值采取行动:一种是附带影响而不是参考性透明度。