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

可能性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的范围。例如，如何要求标准库计算一个函数，并以纯函数的方式对其返回值进行操作:这是关于副作用而不是参考透明度的。

在Haskell中，我们使用一个叫做monad的结构来处理副作用。单子基本上意味着你将值封装到容器中，并在容器中使用一些函数将值与值之间的函数链接起来。如果容器的类型为:

data IO a = IO (RealWorld -> (a,RealWorld))

我们可以安全地实现IO动作。IO类型的动作是一个函数，它接受一个RealWorld类型的令牌，并返回一个新的令牌和结果。

这背后的想法是，每个IO操作都会改变外部状态，由神奇的令牌RealWorld表示。通过使用单子，我们可以将多个函数链接在一起，从而改变现实世界。一个单子最重要的功能是>>=，发音为bind:

(>>=) :: IO a -> (a -> IO b) -> IO b

>>=取一个动作和一个函数，该函数取这个动作的结果并由此创建一个新的动作。返回类型是新动作。例如，假设现在有一个函数::IO String，它返回一个表示当前时间的String。我们可以用putStrLn函数链接它来打印它:

now >>= putStrLn

或者用do-Notation写，这对命令式程序员来说更熟悉:

do currTime <- now
   putStrLn currTime

所有这些都是纯粹的，因为我们将关于外部世界的突变和信息映射到RealWorld令牌。因此，每次运行此操作时，当然会得到不同的输出，但输入是不相同的:RealWorld令牌是不同的。

这完全可以用纯功能的方式来完成。有几种方法可以做到这一点，但最简单的方法是让time函数不仅返回时间，还返回您必须调用以获得下一次时间测量的函数。

在c#中，你可以这样实现它:

// Exposes mutable time as immutable time (poorly, to illustrate by example)
// Although the insides are mutable, the exposed surface is immutable.
public class ClockStamp {
    public static readonly ClockStamp ProgramStartTime = new ClockStamp();
    public readonly DateTime Time;
    private ClockStamp _next;

    private ClockStamp() {
        this.Time = DateTime.Now;
    }
    public ClockStamp NextMeasurement() {
        if (this._next == null) this._next = new ClockStamp();
        return this._next;
    }
}

(请记住，这是一个简单的示例，而不是实际的示例。特别是，列表节点不能被垃圾收集，因为它们是由ProgramStartTime根的。)

这个“ClockStamp”类就像一个不可变的链表，但实际上节点是按需生成的，所以它们可以包含“当前”时间。任何想要测量时间的函数都应该有一个'clockStamp'参数，并且必须在其结果中返回其最近的时间测量值(这样调用者就不会看到旧的测量值)，如下所示:

// Immutable. A result accompanied by a clockstamp
public struct TimeStampedValue<T> {
    public readonly ClockStamp Time;
    public readonly T Value;
    public TimeStampedValue(ClockStamp time, T value) {
        this.Time = time;
        this.Value = value;
    }
}

// Times an empty loop.
public static TimeStampedValue<TimeSpan> TimeALoop(ClockStamp lastMeasurement) {
    var start = lastMeasurement.NextMeasurement();
    for (var i = 0; i < 10000000; i++) {
    }
    var end = start.NextMeasurement();
    var duration = end.Time - start.Time;
    return new TimeStampedValue<TimeSpan>(end, duration);
}

public static void Main(String[] args) {
    var clock = ClockStamp.ProgramStartTime;
    var r = TimeALoop(clock);
    var duration = r.Value; //the result
    clock = r.Time; //must now use returned clock, to avoid seeing old measurements
}

当然，这有点不方便，必须把最后的测量输入输出，输入输出，输入输出。隐藏样板文件的方法有很多，尤其是在语言设计级别。我认为Haskell使用这种技巧，然后通过使用单子隐藏丑陋的部分。

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

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

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

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

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

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

“当前时间”不是一个函数。它是一个参数。如果您的代码依赖于当前时间，这意味着您的代码是由时间参数化的。

是也不是。

不同的函数式编程语言解决这些问题的方法不同。

在Haskell(一个非常纯粹的Haskell)中，所有这些东西都必须发生在一个叫做I/O单子的东西中——看这里。

你可以把它看作是将另一个输入(和输出)输入到你的函数(世界状态)中，或者更简单地认为是“不确定性”发生的地方，比如得到变化的时间。

像f#这样的其他语言只是内置了一些不纯性，所以你可以有一个函数为相同的输入返回不同的值——就像普通的命令式语言一样。

正如杰弗里·伯卡在他的评论中提到的: 下面是来自Haskell wiki的I/O单子的介绍。