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

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

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

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

是的!你说对了!Now()或CurrentTime()或任何这种风格的方法签名都没有以某种方式显示引用透明性。但是通过对编译器的指令，它是由系统时钟输入参数化的。

通过输出，Now()可能看起来没有遵循引用透明性。但是系统时钟和它上面的功能的实际行为是坚持的 引用透明性。

我很惊讶，没有一个答案或评论提到共代数或共归纳。通常，同归纳法在对无限数据结构进行推理时被提及，但它也适用于无穷无尽的观察流，例如CPU上的时间寄存器。一个协代数模型隐藏状态;同感应模型观察到这种状态。(正常诱导模型构造状态。)

这是响应式函数式编程中的一个热门话题。如果你对这类东西感兴趣，请阅读以下内容:http://digitalcommons.ohsu.edu/csetech/91/(28页)

Richard B. Kieburtz，“响应式函数式编程”(1997)。CSETech。第91篇(链接)

是的，函数式编程中可以存在一个获得时间的函数，它使用了函数式编程的一个稍微修改过的版本，称为非纯函数式编程(默认的或主要的是纯函数式编程)。

在获取时间(或读取文件，或发射导弹)的情况下，代码需要与外部世界进行交互以完成工作，而这个外部世界并不是基于函数式编程的纯粹基础。为了允许纯函数式编程世界与这个不纯的外部世界进行交互，人们引入了不纯函数式编程。毕竟，不与外部世界交互的软件除了做一些数学计算之外没有任何用处。

很少有函数式编程语言具有这种内嵌的不纯特性，这样就不容易区分哪些代码是不纯的，哪些是纯的(如f#等)，而一些函数式编程语言确保当你做一些不纯的事情时，代码与纯代码相比明显突出，如Haskell。

另一种有趣的方式是，函数式编程中的get time函数将接受一个“world”对象，该对象具有世界的当前状态，如时间、生活在世界中的人数等。然后从世界对象中获取时间，这个世界对象总是纯的，即你在相同的世界状态下通过，你将总是得到相同的时间。

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