你的问题合并了计算机语言的两种相关衡量标准:函数式/命令式和纯粹/不纯粹。

函数式语言定义了函数的输入和输出之间的关系，命令式语言按照特定的执行顺序描述了特定的操作。

纯粹的语言不会产生或依赖副作用，而不纯粹的语言则自始至终都在使用副作用。

百分之百纯粹的程序基本上是无用的。他们可能会进行有趣的计算，但因为他们没有副作用，他们没有输入或输出，所以你永远不会知道他们计算了什么。

要想有用，一个程序至少要有一点不纯。使纯程序有用的一种方法是将它放在一个薄的非纯包装器中。比如下面这个未经测试的Haskell程序:

-- 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

如果是，那它怎么可能存在?这难道不违反原则吗 函数式编程吗?它尤其违反了参照原则 透明度

它的存在不是纯粹的功能性的。

如果不是，那么如何知道当前时间是泛函的 编程吗?

首先，了解如何在计算机上检索时间可能是有用的。从本质上讲，有一个板载电路来记录时间(这就是电脑通常需要一个小电池的原因)。然后可能会有一些内部进程在某个内存寄存器上设置时间的值。这本质上可以归结为CPU可以检索到的值。

对于Haskell，有一个“IO动作”的概念，它表示一种类型，可以执行一些IO进程。因此，我们不引用时间值，而是引用IO时间值。所有这些都是纯功能性的。我们引用的不是时间，而是“读取时间寄存器的值”之类的东西。

当我们实际执行Haskell程序时，IO操作将实际发生。

在函数式编程中时间函数是如何存在的?

早在1988年，Dave Harrison在定义带有实时处理功能的早期函数式语言时就面临着这个问题。他为Ruth选择的解决方案可以在他的论文《功能性实时编程:Ruth语言及其语义》第50页中找到:

一个唯一的时钟在运行时自动提供给每个Ruth进程，以提供实时信息，[…]

那么这些时钟是如何定义的呢?第61页:

时钟树由一个表示当前时间的非负整数节点和两个包含未来事件时间的子树组成。

此外:

当树被(惰性地)计算时，每个节点都被实例化为节点实例化时的系统时间值，从而使程序引用当前时间。

翻译成Haskell:

type Clock = Tree Time
type Time  = Integer -- must be zero or larger

data Tree a = Node { contents :: a,
                     left     :: Tree a,
                     right    :: Tree a }

除了访问当前时间(带内容)之外，每个Ruth进程还可以提供其他时钟(带左时钟和右时钟)，以便在程序的其他地方使用。如果一个进程不止一次需要当前时间，那么它必须每次都使用一个新节点——实例化后，节点的内容保持不变。

这就是函数式语言中时间函数的存在方式:无论调用它的地方，它总是应用于唯一的输入值(在这里是一个时间树)。

你的问题合并了计算机语言的两种相关衡量标准:函数式/命令式和纯粹/不纯粹。

函数式语言定义了函数的输入和输出之间的关系，命令式语言按照特定的执行顺序描述了特定的操作。

纯粹的语言不会产生或依赖副作用，而不纯粹的语言则自始至终都在使用副作用。

百分之百纯粹的程序基本上是无用的。他们可能会进行有趣的计算，但因为他们没有副作用，他们没有输入或输出，所以你永远不会知道他们计算了什么。

要想有用，一个程序至少要有一点不纯。使纯程序有用的一种方法是将它放在一个薄的非纯包装器中。比如下面这个未经测试的Haskell程序:

-- 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

不引入计划生育的其他概念就可以回答这个问题。

可能性1:time作为函数参数

一门语言包括

语言核心和 标准库。

引用透明性是语言核心的属性，而不是标准库的属性。它绝不是用那种语言编写的程序的属性。

使用OP的符号，应该有一个函数

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

他们会要求标准库获取当前时间，比如1.23，并以该值作为参数f(1.23)(或者只是1.23*v0 + x0，参考透明!)来计算函数。这样代码就能知道当前时间。

可能性2:返回值为时间

回答OP的问题:

函数式编程中是否存在时间函数(返回当前时间)?

是的，但是这个函数必须有一个参数，你必须用不同的输入来计算它，这样它就会返回不同的当前时间，否则它就违反了FP的原则。

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

这是我上面所描述的另一种方法。但话又说回来，首先获取这些不同输入的问题仍然归结为标准库。

可能性3:函数式响应式编程

其思想是函数t()计算为与函数t2配对的当前时间。当需要当前时间时，调用t2()，它会给函数t3，以此类推

(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!

关于FP还有更多，但我认为这超出了op的范围。例如，如何要求标准库计算一个函数，并以纯函数的方式对其返回值进行操作:这是关于副作用而不是参考透明度的。

您正在讨论函数式编程中一个非常重要的主题，即执行I/O。许多纯语言是通过使用嵌入式领域特定语言来实现的，例如，一种子语言，其任务是编码可以产生结果的动作。

例如，Haskell运行时希望我定义一个名为main的操作，该操作由组成程序的所有操作组成。运行时然后执行此操作。大多数情况下，这样做只会执行纯代码。运行时将不时使用计算出的数据执行I/O，并将数据反馈回纯代码。

You might complain that this sounds like cheating, and in a way it is: by defining actions and expecting the runtime to execute them, the programmer can do everything a normal program can do. But Haskell's strong type system creates a strong barrier between pure and "impure" parts of the program: you cannot simply add, say, two seconds to the current CPU time, and print it, you have to define an action that results in the current CPU time, and pass the result on to another action that adds two seconds and prints the result. Writing too much of a program is considered bad style though, because it makes it hard to infer which effects are caused, compared to Haskell types that tell us everything we can know about what a value is.

示例:clock_t c = time(NULL);Printf ("%d\n"， c + 2);在Haskell中，vs. main = getCPUTime >>= \ C -> print (C + 2*1000*1000*1000*1000)操作符>>=用于组合动作，将第一个动作的结果传递给产生第二个动作的函数。这看起来很神秘，Haskell编译器支持语法糖，允许我们编写后面的代码如下:

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 ()

后者看起来很有必要，不是吗?