是的，对于一个纯函数来说返回时间是可能的，如果它把时间作为一个参数。不同的时间论据，不同的时间结果。然后形成其他时间函数，并将它们与函数(时间)转换(高阶)函数的简单词汇表结合起来。由于该方法是无状态的，因此这里的时间可以是连续的(与分辨率无关)，而不是离散的，从而极大地提高了模块化。这种直觉是函数式响应式编程(FRP)的基础。

是也不是。

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

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

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

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

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

大多数函数式编程语言都不是纯粹的，也就是说，它们允许函数不仅依赖于它们的值。在这些语言中，完全有可能有一个返回当前时间的函数。从你标记这个问题的语言中，这适用于Scala和f#(以及ML的大多数其他变体)。

在Haskell和Clean等纯语言中，情况就不同了。在Haskell中，当前时间不是通过函数，而是通过所谓的IO操作，这是Haskell封装副作用的方式。

在Clean中，它将是一个函数，但该函数将以一个世界值作为参数，并返回一个新的世界值(除了当前时间)作为结果。类型系统将确保每个世界值只能使用一次(并且每个消耗世界值的函数将产生一个新的世界值)。这样，每次调用time函数时都必须使用不同的参数，因此允许每次返回不同的时间。

另一种解释是:没有函数可以获得当前时间(因为它一直在变化)，但一个动作可以获得当前时间。让我们说getClockTime是一个常量(或者一个零函数，如果你喜欢的话)，它表示获取当前时间的动作。无论什么时候使用，这个动作每次都是一样的，所以它是一个真正的常数。

同样地，我们说print是一个函数，它需要一些时间来表示并将其打印到控制台。由于函数调用在纯函数式语言中不会产生副作用，因此我们将其想象为一个接受时间戳的函数，并返回将其打印到控制台的操作。同样，这是一个真实的函数，因为如果你给它相同的时间戳，它每次都会返回相同的打印操作。

Now, how can you print the current time to the console? Well, you have to combine the two actions. So how can we do that? We cannot just pass getClockTime to print, since print expects a timestamp, not an action. But we can imagine that there is an operator, >>=, which combines two actions, one which gets a timestamp, and one which takes one as argument and prints it. Applying this to the actions previously mentioned, the result is... tadaaa... a new action which gets the current time and prints it. And this is incidentally exactly how it is done in Haskell.

Prelude> System.Time.getClockTime >>= print
Fri Sep  2 01:13:23 東京 (標準時) 2011

因此，从概念上讲，您可以这样看待它:纯函数式程序不执行任何I/O，它定义了一个操作，然后运行时系统执行该操作。该操作每次都是相同的，但执行它的结果取决于执行时的情况。

我不知道这是否比其他解释更清楚，但它有时会帮助我这样思考。

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

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

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

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

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

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

这完全可以用纯功能的方式来完成。有几种方法可以做到这一点，但最简单的方法是让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使用这种技巧，然后通过使用单子隐藏丑陋的部分。