Question

我目前正在尝试使用Haskell中随机生成的数字来加密消息（String）。我们的想法是获取消息，生成一个具有相同长度的随机数字串（或更多，然后采用我需要的长度）。

然后我想基于ASCII表示执行一些操作，然后返回加密的String。

不幸的是，我不熟悉Haskell中的monad，所以它可能是一个非常简单的问题，我无法理解。

generateMyKey string = newStdGen >>= \x ->  print $ concatMap show $ map abs $ rs x
                    where rs x = randomlist (length string) x

randomlist :: Int -> StdGen -> [Int]
randomlist n = take n . unfoldr (Just . random)

所以问题是我从getMyKey中获取了一个IO（），但我希望有一个String，或者至少有一个IO（String）来执行加密机制。

现在我得到一个大的正面（因此是abs +地图）随机数列表，但我无法访问它们。

Answer 1

有两种基本方法可以解决这个问题（一种更复杂但更容易）。如果您只是使用System.Random，则可以通过两种方式生成随机数：通过接受StdGen并保持纯粹，或使用操作系统的随机生成器并保留在IO。在某些时候，您将不得不调用操作系统的随机功能来获取种子或值，但这可能发生在远离实际代码的main中。

为了保持您的功能纯净，您需要传递StdGen并使用函数

random :: Random a => StdGen -> (a, StdGen)
randoms :: Random a => StdGen -> [a]

（注意：我已将RandomGen g => g替换为StdGen，无需为您的案例编写自定义RandomGen实例）

然后，您可以将您的函数generateMyKey编写为

randomList :: Int -> StdGen -> [Int]
randomList n = take n . randoms

generateMyKey :: String -> StdGen -> String
generateMyKey text g
    = concatMap show
    $ map abs
    $ randomList (length text) g

这完全避免了必须住在IO。但要小心，如果你重复使用相同的g，你每次都会生成相同的随机列表。我们可以使用IO及其相关函数

来避免这种情况

randomList :: Int -> IO [Int]
randomList 0 = return []
randomList n = do
    first <- randomIO
    rest <- randomList (n - 1)  -- Recursively generate the rest
    return $ first : rest

generateMyKey :: String -> IO String
generateMyKey text = do
    key <- randomList (length text)
    return $ concatMap show $ map abs $ key

这会带来性能损失，现在我们已经失去了反复生成相同密钥的能力，因此难以可靠地测试我们的功能！我们如何协调这两种方法？

输入包MonadRandom。这个包提供了一个monad（和monad转换器，但你现在不需要担心），它可以让你抽象出如何生成随机数，这样你就可以选择在不同情况下运行代码的方式。如果您需要IO，则可以使用IO。如果您想提供种子，您可以提供种子。这非常方便。您可以使用cabal install MonadRandom安装它并将其用作

import Control.Monad.Random

randomList :: Int -> Rand StdGen [Int]
randomList n = fmap (take n) getRandoms

generateMyKey :: String -> Rand StdGen String
generateMyKey text = do
    key <- randomList (length text)
    return $ concatMap show $ map abs $ key

我们的generateMyKey代码甚至与类型签名以外的IO版本相同！

现在运行它。

main :: IO ()
main = do
    -- Entirely impure, have it automatically grab a StdGen from IO for us
    ioVersion <- evalRandIO $ generateMyKey "password"
    -- Make a StdGen that stays the same every time we run the program, useful for testing
    let pureStdGen = mkStdGen 12345
        pureVersion = evalRand (generateMyKey "password") pureStdGen
    -- Get a StdGen from the system, but still evaluate it purely
    ioStdGen <- getStdGen
    let pureVersion2 = evalRand (generateMyKey "password") ioStdGen
    -- Print out all three versions
    putStrLn ioVersion
    putStrLn pureVersion
    putStrLn pureVersion2

Answer 2

这个问题有很多解决方案，但乍一看似乎你需要让你的整个程序在IO monad中运行，但是你不需要！程序的入口（/退出）点是唯一需要查看IO的地方 - 您可以将随机列表中的任何转换分解为纯函数，即：

import Data.List
import System.Random

generateMyKey :: String -> IO String
generateMyKey string = do
  x <- newStdGen
  let rs = randomlist (length string)
  return $ concatMap show $ map abs $ rs x

randomlist :: Int -> StdGen -> [Int]
randomlist n = take n . unfoldr (Just . random)

change :: String -> String
change = reverse -- for example

main :: IO ()
main = do
  key <- generateMyKey "what"
  putStrLn $ change key

generateMyKey与之前的版本完全相同，只是它现在以编号表示并且返回字符串而不是仅仅打印它。这使我们能够“退出”＃34;来自IO monad内部的随机密钥，并使用常规纯函数对其进行转换，例如change。这使您可以正常推理纯函数，同时仍然从IO中提取您的值。

使用随机数加密消息

2 个答案: