Yago's questions

我是 Haskell 新手 :)。我想从 IO 中迭代读取一个元素，如果存在，则从列表中删除该元素。在其他情况下，重复读取直到输入的元素在列表中。我有以下代码：

import Data.List (delete)

main = do
let initialDieRoll = [23,45,98,34]
strength <- askStrength
let dieRollWithoutStrength = removeStrengthFromDieRollLoop strength initialDieRoll
print dieRollWithoutStrength

removeStrengthFromDieRollLoop :: Int -> [Int] -> [Int]
removeStrengthFromDieRollLoop = removeStrengthFromDieRoll

removeStrengthFromDieRoll :: Int -> [Int] -> [Int]
removeStrengthFromDieRoll strength dieRoll = do
if strength `elem` dieRoll then
  delete strength dieRoll
else do
  "Please, choose an element from the initial die roll"
  newStrength <- askStrength
  removeStrengthFromDieRollLoop askStrength dieRoll


askStrength :: IO Int
askStrength = do
putStr "Strength : "
readLn::IO Int

但是，当我请求新的强度时，出现以下错误：

Couldn't match type ‘IO’ with ‘[]’
  Expected: [Int]
  Actual: IO Int
In a stmt of a 'do' block: newStrength <- askStrength
In the expression:
do "Please, choose an element from the initial die roll"
   newStrength <- askStrength
   removeStrengthFromDieRollLoop askStrength dieRoll
In a stmt of a 'do' block:
  if strength `elem` dieRoll then
    delete st

最好的处理方法是什么？如何修复错误？如果值不在初始列表中，每次请求值循环的最佳方法是什么？谢谢。

我正在对 haskell 方法执行以下调用

rollD6 ::  (RandomGen g, Int a) => Int -> ([a], g)
rollD6 times =  roll Die6 times (mkStdGen 6)

rollD6InRange :: (RandomGen g, Int a) => Int -> Int -> Int -> ([a], g)
rollD6InRange times start end = rollR Die6 times start end (mkStdGen 6)

class Roll a where
  roll :: (RandomGen g) => a -> Int -> g -> ([Int], g)
  rollR :: (RandomGen g) => a -> Int -> Int -> Int -> g -> ([Int], g)

instance Roll Die where
  roll Die6 times = generateIntRandomsArray 1 6 times
  roll Die4 times = generateIntRandomsArray 1 4 times
  roll Die20 times = generateIntRandomsArray 1 20 times
  roll Die100 times = generateIntRandomsArray 1 100 times

  rollR Die6  times first last = generateIntRandomsArray first last times
  rollR Die4 times first last = generateIntRandomsArray first last times
  rollR Die20 times first last = generateIntRandomsArray first last times
  rollR Die100 times first last = generateIntRandomsArray first last times

generateIntRandomsArray :: (Eq a, Random a, Num a, RandomGen g) => a -> a -> a -> g -> ([a], g)
generateIntRandomsArray start end = generate
    where generate 0 generator = ([], generator)
          generate numberElements generator =
              let (value, newGenerator) = randomR (start,end) generator
                  (restOfList, finalGenerator) = generate (numberElements-1) newGenerator
              in  (value:restOfList, finalGenerator)

我收到以下错误

src/Merp/Die/Boundary/RollADie.hs:11:26: error:
    • Expected kind ‘* -> Constraint’, but ‘Int’ has kind ‘*’
    • In the type signature:
        rollD6 :: (RandomGen g, Int a) => Int -> ([a], g)
   |
11 | rollD6 ::  (RandomGen g, Int a) => Int -> ([a], g)
   |                          ^^^^^

src/Merp/Die/Boundary/RollADie.hs:14:32: error:
    • Expected kind ‘* -> Constraint’, but ‘Int’ has kind ‘*’
    • In the type signature:
        rollD6InRange :: (RandomGen g, Int a) =>
                         Int -> Int -> Int -> ([a], g)
    |
 14 | rollD6InRange :: (RandomGen g, Int a) => Int -> Int -> Int -> ([a], g)
    |                                ^^^^^

我一直在研究调用的参数，但我无法弄清楚发生了什么。你能告诉我还剩下什么吗？

我对 Haskell 很陌生，我正在尝试创建一个函数来生成有限数字数组，同时考虑到一些开始和结束边界。如果我使用以下功能...

 finiteRandoms :: (Eq n, Num n, RandomGen g, Random a, Num a) => n -> g -> ([a], g)
 finiteRandoms 0 g = ([], g)
 finiteRandoms n g =
     let (value, newGen) = randomR (20,100) g
         (restOfList, finalGen) = finiteRandoms (n-1) newGen
     in  (value:restOfList, finalGen)

我运行以下命令...

finiteRandoms 3 (mkStdGen 3)

我用新的生成器获得了一个 Int 数组

([61,33,82],StdGen {unStdGen = SMGen 9186733390819170434 2092789425003139053})

我想做的是向函数添加两个新参数来标记起点和终点。在我分享的函数中，它代表数字 20 和 100 。像这样的东西

finiteRandoms :: (Eq n, Num n, RandomGen g, Random a, Num a) => n -> n -> n-> g -> ([a], g)
   finiteRandoms 0 start end g = ([], g)
   finiteRandoms n start end g =
         let (value, newGen) = randomR (start,end) g
             (restOfList, finalGen) = finiteRandoms (n-1) newGen
         in  (value:restOfList, finalGen)

但是当我通过 ghci 加载它时，出现以下错误

randomSample.hs:19:10: error: [GHC-83865]
    • Couldn't match expected type: n -> g0 -> ([a0], g0)
                  with actual type: (a1, b)
    • In the pattern: (restOfList, finalGen)
      In a pattern binding:
        (restOfList, finalGen) = finiteRandoms (n - 1) newGen
      In the expression:
        let
          (value, newGen) = randomR (start, end) g
          (restOfList, finalGen) = finiteRandoms (n - 1) newGen
        in (value : restOfList, finalGen)
    • Relevant bindings include
        value :: n (bound at randomSample.hs:18:11)
        end :: n (bound at randomSample.hs:17:24)
        start :: n (bound at randomSample.hs:17:18)
        n :: n (bound at randomSample.hs:17:16)
        finiteRandoms :: n -> n -> n -> g -> ([a], g)
          (bound at randomSample.hs:16:2)
   |
19 |          (restOfList, finalGen) = finiteRandoms (n-1) newGen
   |          ^^^^^^^^^^^^^^^^^^^^^^

randomSample.hs:20:11: error: [GHC-25897]
    • Couldn't match expected type ‘a’ with actual type ‘n’
      ‘n’ is a rigid type variable bound by
        the type signature for:
          finiteRandoms :: forall n g a.
                           (Eq n, Num n, RandomGen g, Random a, Num a) =>
                           n -> n -> n -> g -> ([a], g)
        at randomSample.hs:15:2-92
      ‘a’ is a rigid type variable bound by
        the type signature for:
          finiteRandoms :: forall n g a.
                           (Eq n, Num n, RandomGen g, Random a, Num a) =>
                           n -> n -> n -> g -> ([a], g)
        at randomSample.hs:15:2-92
    • In the first argument of ‘(:)’, namely ‘value’
      In the expression: value : restOfList
      In the expression: (value : restOfList, finalGen)
    • Relevant bindings include
        value :: n (bound at randomSample.hs:18:11)
        end :: n (bound at randomSample.hs:17:24)
        start :: n (bound at randomSample.hs:17:18)
        n :: n (bound at randomSample.hs:17:16)
        finiteRandoms :: n -> n -> n -> g -> ([a], g)
          (bound at randomSample.hs:16:2)
   |
20 |      in  (value:restOfList, finalGen)
   |           ^^^^^
Failed, no modules loaded.

如何参数化这两个边界（开始/结束）？谢谢。