Question

据我所知，Haskell没有全局状态，所以有没有办法编写一个函数f，它将返回f（n - 1）+ 1，其中n是函数调用的数量，f（1）= 0.

它不应接受任何参数，并像func f

一样使用

Prelude> f () 
0
Prelude> f ()
1

Answer 1

不使用像unsafePerform这样的技巧，就不可能像你在示例中所示那样定义一个可以调用的函数。但是，可以定义执行所需操作的IO操作，并且可以像这样使用：

Prelude> x <- f 
Prelude> x
0
Prelude> x <- f
Prelude> x
1

这是一个使用IORefs做你想做的事情的示例程序：

import Data.IORef

main = do counter <- newIORef 0
          let f = do count <- readIORef counter
                     modifyIORef counter (+ 1)
                     return count          
          x <- f
          print x
          x <- f
          print x

Answer 2

您要求在每次调用过程时更新一些（可能是隐藏的）状态，以便函数在给定相同输入的情况下返回不同的结果。

显然，这不是一个引用透明的函数，所以我们必须在Haskell的纯默认模式中添加一些东西。我们通过monad添加计算概念。你只需要选择你需要的monadic环境。

州monad

最精确的方法是通过State monad（不要与“ST”monad混淆）将精确的状态概念添加到程序中：

import Control.Monad.State.Strict 

-- a (stateful) procedure, that returns and increments an internal state counter 
f :: State Int Int 
f = do 
    n <- get 
    put (n+1) 
    return n 

-- Call 'f' a bunch of times, print the final state. 
main = print $ execState code 0 
 where 
    code = do f; f; f; f

现在'f'有一个内部状态组件。

同样，更丰富的环境（如IO）允许使用State，因此您可以使用IO monad（或其他一些包含状态的计算环境）。

Answer 3

如果您喜欢某些内容，只需从ghci命令行输入：

Prelude> :m + Data.IORef
Prelude Data.IORef> n <- newIORef 0
Prelude Data.IORef> let f = do { v <- readIORef n ; writeIORef n (v+1); return v}
Prelude Data.IORef> f
0
Prelude Data.IORef> f
1
Prelude Data.IORef> f
2
Prelude Data.IORef> f
3

你的例子想要调用“f（）”，但这是Haskell没有的C-ism。如果你真的想要那么只需将“f”的定义改为开始

let f _ = do {...

“（）”在Haskell中定义为单位值，它是单位类型“（）”的唯一值。你可以用你想要的任何参数调用“f”;它将被忽略。

Answer 4

尝试这样的事情：

f 1 = 0
f n = f (n-1) + 1

编辑：我似乎误解了你的问题; 没有，你不能在haskell做类似的事情;函数应该是pure。示例中的函数不是纯粹的

自然数序列发生器

4 个答案: