在Haskell中模拟Go语言的并发通道

func generateStep(ch chan int) {
      for {
          ch <- randomInteger() 
      }
}

func filter(input, output chan int) {
      state int
      for {
          step <- input
          newstate := update(state, step)
          if criteria(newstate, state) {
             state = newstate
          } 
          output <- state
      } 
}

func main() {
    intChan := make(chan int) 
    mcChan  := make(chan int) 
    go generateStep(intChan)
    go filter(intChan, mcChan)
    for i:=0; i<numSteps; i++  {
        x <- mcChan
        accumulateStats(x)
    } 
    printStatisticsAbout(x)
}

import System.Random (randomRIO)
import Control.Concurrent (forkIO)
import Control.Concurrent.Chan (Chan, newChan, readChan, writeChan)
import Control.Monad (forever) -- 用于创建无限循环

-- 辅助函数：模拟Go的 randomInteger()
-- generateStep :: Chan Int -> IO ()
-- func generateStep(ch chan int) { for { ch <- randomInteger() } }
generateStep :: Chan Int -> IO ()
generateStep ch = forever $ do
    r <- randomRIO (1, 100) -- 生成1到100之间的随机整数
    writeChan ch r
    -- putStrLn $ "Generated: " ++ show r -- 调试输出

-- 辅助函数：模拟Go的 update(state, step)
update :: Int -> Int -> Int
update current step = current + step -- 简单的累加更新

-- 辅助函数：模拟Go的 criteria(newstate, state)
criteria :: Int -> Int -> Bool
criteria newState oldState = newState `mod` 2 == 0 -- 只有当新状态为偶数时才接受

-- filterChan :: Chan Int -> Chan Int -> IO ()
-- func filter(input, output chan int) { ... }
filterChan :: Chan Int -> Chan Int -> IO ()
filterChan input output = go 0 -- 初始状态设为0
  where
    go :: Int -> IO ()
    go currentState = do
        step <- readChan input -- 从输入通道读取一个步长
        let newState = update currentState step
        if criteria newState currentState
            then do
                writeChan output newState -- 如果满足条件，将新状态写入输出通道
                -- putStrLn $ "Filtered (accepted): " ++ show newState -- 调试输出
                go newState -- 递归调用，更新状态
            else do
                writeChan output currentState -- 如果不满足条件，将当前状态写入输出通道
                -- putStrLn $ "Filtered (rejected, keeping old): " ++ show currentState -- 调试输出
                go currentState -- 递归调用，保持旧状态

-- mainFunc :: Int -> IO ()
-- func main() { ... }
mainFunc :: Int -> IO ()
mainFunc numSteps = do
    intChan <- newChan -- 创建一个用于整数的通道
    mcChan  <- newChan -- 创建一个用于Monte Carlo结果的通道

    -- 使用 forkIO 启动并发线程，类似于Go的 'go' 关键字
    _ <- forkIO $ generateStep intChan
    _ <- forkIO $ filterChan intChan mcChan

    -- 模拟主循环，从mcChan获取结果并累积统计
    let accumulateStats :: Int -> [Int] -> [Int]
        accumulateStats x stats = x : stats -- 简单地将新值添加到列表头部

    results <- loop numSteps [] mcChan
    putStrLn $ "Simulation completed after " ++ show numSteps ++ " steps."
    putStrLn $ "Final accumulated stats (last " ++ show (min numSteps (length results)) ++ " values): " ++ show (take 10 results) -- 打印前10个结果
    putStrLn $ "Total values accumulated: " ++ show (length results)

  where
    -- 递归函数模拟 Go 的 for 循环
    loop :: Int -> [Int] -> Chan Int -> IO [Int]
    loop 0 acc _ = return (reverse acc) -- 达到步数，反转列表并返回
    loop n acc ch = do
        x <- readChan ch -- 从mcChan读取一个值
        let newAcc = accumulateStats x acc
        -- putStrLn $ "Main received: " ++ show x -- 调试输出
        loop (n - 1) newAcc ch -- 继续下一轮循环

-- 实际运行的入口
main :: IO ()
main = mainFunc 20 -- 运行20个模拟步长