unsafePerformIO？模板Haskell？还是其他什么？我从未使用过其中任何一个，所以不了解它们的详细信息。我不建议使用unsafePerformIO。我猜 Haskell 报告并没有声明常数函数是记忆化的，因此可能会发生这种情况
randStringUnsafe :: String
randStringUnsafe = unsafePerformIO $ liftM (take 10 . randomRs ('a','z')) newStdGen
对于不同的调用，将会给出不同的结果！使用GHC最有可能会被记忆化，但是没有保证。例如，如果编译器内联函数会怎么样呢？（GHC很可能足够聪明，不这样做，但也不能保证……）。例如
randNumUnsafe :: (Random a, Num a) => [a]
randNumUnsafe = unsafePerformIO $ liftM (take 10 . randomRs (0, 9)) newStdGen
每次调用它时，都会给你不同的结果。
我宁愿选择Template Haskell。这可能有点更加复杂，但是更加安全。我们在一个模块中定义：
{-# LANGUAGE TemplateHaskell #-}
module RandomTH where
import Control.Monad
import System.Random
import Language.Haskell.TH
-- A standard function generating random strings.
randString :: IO String
randString = liftM (take 10 . randomRs ('a','z')) newStdGen
-- .. lifted to Q
randStringQ :: Q String
randStringQ = runIO randString
-- .. lifted to an Q Exp
randStringExp :: Q Exp
randStringExp = randStringQ >>= litE . stringL
-- | Declares a constant `String` function with a given name
-- that returns a random string generated on compile time.
randStringD :: String -> DecsQ
randStringD fname = liftM (: []) $
funD (mkName fname) [clause [] (normalB randStringExp) []]
randStringD 可以用更易读的方式编写 - 如果您有想法，请编辑或评论。）然后，在另一个模块中，我们可以使用它来声明具有给定名称的常量函数：
{-# LANGUAGE TemplateHaskell #-}
$(randStringD "randStr")
main = do
putStrLn randStr
putStrLn randStr
main中创建它。因此：import Control.Monad
import System.Random
-- Some arbitrary functions
f :: String -> Int -> Int -> Int
f rstr x y = length rstr * x * y
-- This one doesn't depend on the random string
g :: Int -> Int
g x = x*x
h :: String -> String -> Int
h rstr str = sum . map fromEnum $ zipWith min rstr str
main :: IO ()
main = do
rstr <- randomString
putStr "The result is: "
print $ f rstr (g 17) (h rstr "other string")
randomString :: IO String
randomString = flip replicateM (randomRIO (' ','~')) =<< randomRIO (1,32)
这可能是我会做的事情。
另一方面，如果你有很多这些函数，你可能会发现将 rstr 传递给它们所有可能会变得笨重。为了抽象化这个问题，您可以使用 Reader monad; 类型为 Reader r a 的值 - 或更一般地说，类型为 MonadReader r m => m a 的值 - 能够 ask 请求一个类型为 r 的值，在顶层传递一次。那样会给你：
{-# LANGUAGE FlexibleContexts #-}
import Control.Applicative
import Control.Monad.Reader
import System.Random
f :: MonadReader String m => Int -> Int -> m Int
f x y = do
rstr <- ask
return $ length rstr * x * y
g :: Int -> Int
g x = x*x
h :: MonadReader String m => String -> m Int
h str = do
rstr <- ask
return . sum . map fromEnum $ zipWith min rstr str
main :: IO ()
main = do
rstr <- randomString
putStr "The result is: "
print $ runReader (f (g 17) =<< h "other string") rstr
randomString :: IO String
randomString = flip replicateM (randomRIO (' ','~')) =<< randomRIO (1,32)
(实际上，由于(r ->)是MonadReader r的一个实例，因此上述函数可以被视为具有类型f :: Int -> Int -> String -> Int等，您可以省略对runReader的调用（并删除FlexibleContexts）-构建的单子计算将仅具有类型String -> Int。但我可能不会费心。
另一种方法，这可能是语言扩展的不必要使用（我肯定更喜欢以上两种方法），是使用隐式参数，它是在动态传递和反映在类型中的变量（有点像MonadReader String m约束）。那将看起来像这样:
{-# LANGUAGE ImplicitParams #-}
import Control.Monad
import System.Random
f :: (?rstr :: String) => Int -> Int -> Int
f x y = length ?rstr * x * y
g :: Int -> Int
g x = x*x
h :: (?rstr :: String) => String -> Int
h str = sum . map fromEnum $ zipWith min ?rstr str
main :: IO ()
main = do
rstr <- randomString
let ?rstr = rstr
putStr "The result is: "
print $ f (g 17) (h "other string")
randomString :: IO String
randomString = flip replicateM (randomRIO (' ','~')) =<< randomRIO (1,32)
现在，我必须承认你可以在顶层做这些事情。例如，有一个标准的hack允许使用unsafePerformIO来获取顶层的IORef；而模板Haskell将允许您在编译时运行一次IO操作，并嵌入结果。但我会避免这两种方法。为什么？基本上，存在一些争议，即“纯粹”是否意味着“完全由语法确定/在程序的任何运行中都不会改变”（我支持这种解释），还是它的意思是“在此次运行中不会改变。”由于这个问题引起了一些问题，例如：Hashable包在某个时候从固定盐切换到随机盐。这在Reddit上引起了轩然大波，并在之前工作正常的代码中引入了错误。该软件包后退了一步，现在允许用户通过环境变量选择此行为，默认为在运行之间的清洁度。
话虽如此，下面介绍如何使用你提到的两种方法——unsafePerformIO和Template Haskell来获取顶层随机数据，以及为什么我不会使用这些技术（除了运行间纯度之外的原因）。 （这是我能想到的仅有的两种方法。）
The unsafePerformIO hack, as it's called, is very fragile; it relies on certain optimizations not being performed, and is generally not a well-liked approach. Doing it this way would look like so:
import Control.Monad
import System.Random
import System.IO.Unsafe
unsafeConstantRandomString :: String
unsafeConstantRandomString = unsafePerformIO $
flip replicateM (randomRIO (' ','~')) =<< randomRIO (1,32)
{-# NOINLINE unsafeConstantRandomString #-}
Seriously, though, see how much the word unsafe is used in the above code? That's because using unsafePerformIO will bite you unless you really know what you're doing, and possibly even then. Even when unsafePerformIO doesn't bite you directly, no less than the authors of GHC would say that it's probably not worth using for this (see the section titled "Crime Doesn't Pay"). Don't do this.
Using Template Haskell for this is like using a nuclear warhead to kill a gnat. An ugly nuclear warhead, to boot. That approach would look like the following:
{-# LANGUAGE TemplateHaskell #-}
import Control.Monad
import System.Random
import Language.Haskell.TH
thConstantRandomString :: String
thConstantRandomString = $(fmap (LitE . StringL) . runIO $
flip replicateM (randomRIO (' ','~')) =<< randomRIO (1,32))
Note also that in the Template Haskell version, you can't abstract the random-string-creation functionality into a separate value randomString :: IO String in the same module, or you'll run afoul of the stage restriction. It is safe, though, unlike the unsafePerformIO hack; at least, safe modulo the concerns about between-run purity mentioned above.
IO 中生成随机数并不意味着下游函数必须使用 IO。以下是一个示例纯函数，它依赖于类型为 A 的值：f :: A -> B
... 这里是生成 A 的 IO 动作：
io :: IO A
我不必修改f就可以使用IO。相反，我使用fmap：
fmap f io :: IO B
unsafeperformIO似乎是可以的，因为文件说明如下：
我们不需要担心为了做到安全，IO计算应该没有副作用并且独立于它的环境。
newStdGen的顺序。import System.Random
import System.IO.Unsafe
randomStr :: String
randomStr = take 10 $ randomRs ('a','z') $ unsafePerformIO newStdGen
main = do
putStrLn randomStr
putStrLn randomStr
import System.Random
main = do
gen <- newStdGen
let str = take 10 $ randomRs ('a','z') gen
putStrLn str
putStrLn $ (reverse . (take 3)) str
putStrLn，它返回一个空的IO操作。
编辑：或者这可能是Reader Monad的地方
str 会随着每次 main 函数的运行而改变，这对我来说是不可行的。想象一下，如果 main 是一个一元函数，并作为参数传递给另一个函数，那么该函数将应用一堆值到 main 中以推断其某些属性。这就是我在处理的问题。 - Drew对于字符串、数字和其他类型：
import System.Random ( newStdGen, randomRs, randomRIO )
main :: IO ()
main = do
s <- randomString 8 ""
putStrLn s
randomString :: Integer -> String -> IO String
randomString 0 str = return str
randomString size str = do
g <- newStdGen
t <- randomRIO ( 0, 2 )
let s = take 1 $ randomRs ( range t ) g
randomString ( size - 1 ) ( str ++ s )
where
range :: Integer -> ( Char, Char )
range i
| i == 0 = ('0', '9')
| i == 1 = ('A', 'Z')
| otherwise = ('a', 'z')
randomStr在程序中不会改变吗？ - DrewunsafePerformIO（我会 - 并且确实使用，见我的回答 - 但不建议），请确保至少正确地指定{-# NOINLINE randomStr #-}。否则，GHC 可能会决定优化方式，这会破坏你的程序。从技术上讲，Haskell 不是惰性的，而是非严格的；惰性只是一种实现策略，并且没有保证“第一次使用值时将生成该值，然后始终相同”。（我说“使用unsafePerformIO会伤害你”是有原因的。） - Antal Spector-Zabusky