Как я могу эмулировать каналы Go с Haskell?

Недавно я начал читать о языке программирования Go, и я нашел переменные канала очень привлекательной концепцией. Можно ли эмулировать ту же концепцию в Haskell? Возможно, у вас есть тип данных Channel a и структура монады, чтобы включить изменяемое состояние и функции, которые работают как ключевое слово go.

Я не очень хорошо разбираюсь в параллельном программировании, и простой механизм передачи канала, подобный этому в Haskell, действительно облегчит мою жизнь.

ИЗМЕНИТЬ

Люди попросили меня уточнить, какие шаблоны Go были заинтересованы в переводе на Haskell. Итак, Go имеет переменные канала, которые являются первоклассными и могут передаваться и возвращаться функциями. Я могу читать и писать на эти каналы и так легко общаться между подпрограммами, которые могут выполняться одновременно. Go также имеет ключевое слово go, которое согласно спецификации языка инициирует выполнение функции одновременно как независимый поток и продолжает выполнять код без ожидания.

Точный шаблон, который мне интересен, это что-то вроде этого (синтаксис Go является странным - переменные объявляются varName varType вместо обычного инвертированного пути, но я думаю, что это читаемо):

func generateStep(ch chan int) {
      //ch is a variable of type chan int, which is a channel that comunicate integers
      for {
          ch <- randomInteger() //just sends random integers in the channel 
      }

func filter(input, output chan int) {
      state int
      for {
          step <- input  //reads an int from the input channel
          newstate := update(state, step) //update the variable with some update function
          if criteria(newstate, state) {
             state = newstate // if the newstate pass some criteria, accept the update
          } 
          output <- state    //pass it to the output channel
      } 
}

func main() {
    intChan := make(chan int) 
    mcChan  := make(chan int) 
    go generateStep(intChan)     // execute the channels concurrently
    go filter(intChan, mcChan)
    for i:=0; i<numSteps; i++  {
        x <- mcChan        // get values from the filtered channel
        accumulateStats(x)  // calculate some statistics
    } 
    printStatisticsAbout(x)
}

Мой основной интерес - сделать симуляции Монте-Карло, в которых я последовательно создаю конфигурации, пытаясь изменить текущее состояние системы и принять модификацию, если она удовлетворяет некоторым критериям.

Тот факт, что использование этих материалов канала я мог бы написать очень простое, читаемое и маленькое моделирование методом Монте-Карло, которое будет работать параллельно в моем многоядерном процессоре, действительно впечатлило меня.

Проблема заключается в том, что у Go есть некоторые ограничения (особенно, у него нет полиморфизма в том, как я привык в Haskell), и кроме того, мне очень нравится Haskell и я не хочу его продавать. Поэтому вопрос заключается в том, есть ли способ использовать некоторые механики, которые выглядят как код выше, чтобы легко совместить симуляцию в Haskell.

EDIT (2, контекст): Я не научился в области компьютерных наук, особенно в concurrency. Я просто парень, который создает простые программы для решения простых проблем в моей повседневной рутинной работе в дисциплине, не связанной с CS. Я просто нахожу, как Haskell работает интересно и нравится использовать его для выполнения моих маленьких дел.

Я никогда не слышал о одиночных пи-исчислениях или каналах CSP. Извините, если проблема кажется плохой, это, вероятно, моя ошибка с огромным невежеством.

Вы правы, я должен быть более конкретным о том, какой шаблон в Go, который я хотел бы воспроизвести в Haskell, и я попытаюсь изменить вопрос, чтобы быть более конкретным. Но не ожидайте глубоких теоретических вопросов. Дело в том, что из немногих вещей, которые я читал и кодировал, кажется, что у Go есть опрятный способ сделать concurrency (и в моем случае это просто означает, что моя задача сделать все мои ядра жужжащими численными вычислениями проще), и если бы я мог использовать подобный синтаксис в Haskell, я был бы рад.

Ответы

import Control.Concurrent (forkIO)
import Control.Concurrent.Chan (newChan, readChan, writeChan)
import Control.Concurrent.MVar (newMVar, swapMVar, readMVar)

data GoChan a = GoChan { chan :: Chan a, closed :: MVar Bool }

go :: IO () -> IO ThreadId
go = forkIO

make :: IO (GoChan a)
make = do
    ch <- newChan
    cl <- newMVar False
    return $ GoChan ch cl

get :: GoChan a -> IO a
get ch = do
    cl <- readMVar $ closed ch
    if cl
        then error "Can't read from closed channel!"
        else readChan $ chan ch

(=->) :: a -> GoChan a -> IO ()
v =-> ch = do
    cl <- readMVar $ closed ch
    if cl
        then error "Can't write to closed channel!"
        else writeChan (chan ch) v

forRange :: GoChan a -> (a -> IO b) -> IO [b]
forRange ch func = fmap reverse $ range_ ch func []
    where range_ ch func acc = do
        cl <- readMVar $ closed ch
        if cl
            then return ()
            else do
                v <- get ch
                func v
                range_ ch func $ v : acc
close :: GoChan a -> IO ()
close ch = do
    swapMVar (closed ch) True
    return ()

import Control.Monad

generate :: GoChan Int -> IO ()
generate c = do
    forM [1..100] (=-> c)
    close c

process :: GoChan Int -> IO ()
process c = forRange c print

main :: IO ()
main = do
    c <- make
    go $ generate c
    process c