另一种解释是:没有函数可以获得当前时间(因为它一直在变化)，但一个动作可以获得当前时间。让我们说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，它定义了一个操作，然后运行时系统执行该操作。该操作每次都是相同的，但执行它的结果取决于执行时的情况。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

是也不是。

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

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

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

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

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