时间函数在函数编程中如何存在？

我不得不承认我对函数式编程并不了解。我从这里到那里都读到它，因此知道在函数式编程中，无论调用多少次，函数对于相同的输入都会返回相同的输出。就像数学函数一样，该函数针对函数表达式中涉及的输入参数的相同值求出相同的输出。

例如，考虑一下：

f(x,y) = x*x + y; // It is a mathematical function

无论您使用多少次f(10,4)，它的价值始终是104。这样，无论您在何处编写f(10,4)，都可以将其替换为104，而无需更改整个表达式的值。此属性称为表达式的引用透明性。

由于维基说（链接）

相反，在功能代码中，函数的输出值仅取决于输入到该函数的参数，因此，用参数x的相同值两次调用函数f会两次产生相同的结果f（x）。

函数编程中是否可以存在时间函数（返回当前时间）？

• 如果是，那么它怎么存在？它不违反功能编程的原理吗？它特别违反了引用透明性，而引用透明性是函数式编程的特性之一（如果我正确理解的话）。

• 否则，如何知道函数式编程的当前时间？

解释它的另一种方式是：没有函数可以获取当前时间（因为它不断变化），但是动作可以获取当前时间。假设这getClockTime是一个常量（如果愿意，则为null函数），它表示获取当前时间动作。无论何时使用，该动作都是相同的，因此它是一个实常数。

同样地，假设print有一个函数需要一些时间表示并将其打印到控制台。由于函数调用不能以纯函数语言产生副作用，因此我们可以想象它是一个需要时间戳并返回将其打印到控制台的操作的函数。同样，这是一个实函数，因为如果给它相同的时间戳，它将每次返回相同的打印操作。

现在，如何将当前时间打印到控制台？好吧，您必须结合这两个动作。那么我们该怎么做呢？我们不能仅仅传递getClockTime给print，因为print需要时间戳，而不是动作。但是我们可以想象有一个操作符，>>=它组合了两个操作，一个操作获得时间戳，而一个操作者接受一个时间戳并打印出来。将其应用于前面提到的动作，结果是tadaaa ...一个新动作，它将获取当前时间并打印出来。顺便说一句，这正是在Haskell中完成的方式。

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

因此，从概念上讲，您可以通过以下方式查看它：纯功能程序不执行任何I / O，它定义一个action，然后由运行时系统执行。该行动是相同的每一次，但在执行它的结果取决于在执行时的情况。

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

是的，没有。

不同的函数式编程语言以不同的方式解决它们。

在Haskell（非常纯净的一个）中，所有这些东西都必须在称为I / O Monad的东西中发生-参见此处。

您可以将其视为向功能（世界状态）中添加另一个输入（和输出），或者将其视为“不确定性”（如获取变化的时间）发生的地方更容易。

其他语言（例如F＃）只是内置了一些不纯，因此您可以使用一个函数为同一输入返回不同的值-就像普通的命令式语言一样。

正如Jeffrey Burka在他的评论中提到的：这是直接从Haskell Wiki 上对I / O Monad的很好的介绍。

在Haskell中，使用名为monad的构造来处理副作用。monad基本上意味着将值封装到容器中，并具有一些函数以将函数从值链接到容器内的值。如果我们的容器具有以下类型：

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

我们可以安全地执行IO操作。此类型的意思是：类型的动作IO是一个函数，它接受类型的令牌RealWorld并返回新的令牌以及结果。

其背后的思想是，每个IO操作都会改变由魔术令牌表示的外部状态RealWorld。使用monad，人们可以将多种功能链接在一起，从而将现实世界变异在一起。monad最重要的功能是>>=，发音为bind：

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

>>=执行一个动作，然后执行该动作的结果并由此创建新动作的函数。返回类型是新操作。例如，让我们假设有一个函数now :: IO String，该函数返回代表当前时间的String。我们可以将其与函数链接以将putStrLn其打印出来：

now >>= putStrLn

或用do-Notation 编写，这对命令式程序员更熟悉：

do currTime <- now
   putStrLn currTime

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

大多数函数式编程语言都不是纯语言，即它们允许函数不仅依赖于其值。在这些语言中，完全有可能具有一个返回当前时间的函数。从您用此问题标记的语言中，这适用于Scala和F＃（以及ML的大多数其他变体）。

在像Haskell和Clean这样的纯语言中，情况有所不同。在Haskell中，当前时间将无法通过功能获得，而是通过所谓的IO动作获得，这是Haskell封装副作用的方式。

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

“当前时间”不是功能。它是一个参数。如果您的代码取决于当前时间，则意味着您的代码已按时间参数化。

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

令我惊讶的是，答案或评论都没有提到结余或共生。通常，在推论无限数据结构时会提到协导，但它也适用于无休止的观察流，例如CPU上的时间寄存器。一头大哥大模仿隐藏状态；和协导模型观察该状态。（普通归纳模型构造状态。）

这是反应式功能编程中的热门话题。如果您对这种东西感兴趣，请阅读：http : //digitalcommons.ohsu.edu/csetech/91/（28 pp。）

是的，如果给定时间作为参数，则纯函数有可能返回时间。不同的时间参数，不同的时间结果。然后还形成其他时间函数，并将它们与功能（时间）转换（高阶）函数的简单词汇结合起来。由于该方法是无状态的，因此此处的时间可以是连续的（与分辨率无关），而不是离散的，从而极大地提高了模块性。这种直觉是功能反应式编程（FRP）的基础。

是! 你是对的！Now（）或CurrentTime（）或此类风味的任何方法签名均未以一种方式展现出引用透明性。但是通过向编译器发出指令，可以通过系统时钟输入对其进行参数化。

通过输出，Now（）可能看起来好像不遵循参照透明性。但是，系统时钟及其顶部功能的实际行为是遵循引用透明性的。

是的，在函数式编程中可以使用对函数式编程稍加修改的版本（称为不纯函数式编程）来获取时间函数（默认或主要是纯函数式编程）。

如果需要时间（或读取文件或发射导弹），则代码需要与外部世界交互以完成工作，并且该外部世界并非基于函数式编程的纯粹基础。为了使纯函数式编程世界能够与这种不纯净的外部世界互动，人们引入了不纯净的函数式编程。毕竟，除了进行一些数学计算之外，不与外界交互的软件没有任何用处。

很少有函数式编程语言具有内置的这种杂点功能，因此很难区分出哪些代码是不纯的，哪些是纯净的（例如F＃等），某些函数式编程语言会确保您在做一些不纯净的东西时与纯代码（例如Haskell）相比，该代码显然脱颖而出。

另一种有趣的观察方式是函数编程中的获取时间函数将使用一个“世界”对象，该对象具有世界的当前状态，例如时间，生活在世界上的人数等。然后从该世界获取时间对象将始终是纯净的，即，您通过相同的世界状态时，您将始终获得相同的时间。

您的问题概括了计算机语言的两个相关度量：功能/命令式和纯/不纯。

功能语言定义功能的输入和输出之间的关系，命令式语言以特定的顺序描述要执行的特定操作。

纯语言不会产生或依赖副作用，而不纯净的语言会始终使用它们。

百分之一百的纯程序基本上是无用的。它们可能执行有趣的计算，但是由于它们没有副作用，因此没有输入或输出，因此您永远不会知道它们的计算结果。

为了完全有用，程序必须至少是一种不纯洁的东西。使纯程序有用的一种方法是将其放在薄的不纯包装物中。像这个未经测试的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

您正在学习函数式编程中的一个非常重要的主题，即执行I / O。许多纯语言的实现方式是通过使用嵌入式领域特定的语言，例如，将动作编码的子语言。，它可以有结果。

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

您可能会抱怨，这听起来像是作弊，而且在某种程度上是：通过定义动作并期望运行时执行它们，程序员可以完成普通程序可以执行的所有操作。但是Haskell的强类型系统在程序的纯部分和“不正确”部分之间创建了一个强大的屏障：您不能简单地在当前CPU时间上增加两秒钟，然后打印出来，您必须定义一个导致当前结果的操作。 CPU时间，然后将结果传递给另一个操作，该操作将增加两秒钟并打印结果。不过，编写太多程序被认为是不好的风格，因为与告诉我们一切的 Haskell类型相比，它很难推断出是什么原因造成的，我们可以知道一个值是什么。

示例：clock_t c = time(NULL); printf("%d\n", c + 2);在C中，与main = getCPUTime >>= \c -> print (c + 2*1000*1000*1000*1000)在Haskell中。运算符>>=用于编写动作，将第一个动作的结果传递给导致第二个动作的函数。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 ()

后者看起来势在必行，不是吗？

如果是，那么它怎么存在？它不违反功能编程的原理吗？它特别违反了参照透明性

它不是纯粹从功能意义上存在的。

否则，如何知道函数式编程的当前时间？

首先，了解如何在计算机上检索时间可能很有用。本质上，板上电路可以跟踪时间（这就是计算机通常需要小电池的原因）。然后可能会有一些内部过程设置某个内存寄存器中的时间值。从本质上讲，这归结为可以由CPU检索的值。

对于Haskell，有一个“ IO操作”的概念，它表示可以执行某些IO流程的类型。因此，time我们引用IO Time值而不是引用值。所有这些都是纯粹的功能。我们不是在引用，time而是类似于“读取时间寄存器的值”的内容。

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