From ea3039d585d1c7462084aa4822be230b411d15e9 Mon Sep 17 00:00:00 2001
From: Ben Sima <ben@bsima.me>
Date: Sun, 12 Apr 2020 15:08:11 -0700
Subject: Move Com.Simatime.Go to Control.Concurrent.Go
---
Com/Simatime/Go.hs | 106 ----------------------------------------------
Control/Concurrent/Go.hs | 107 +++++++++++++++++++++++++++++++++++++++++++++++
Run/Que/Server.hs | 2 +-
3 files changed, 108 insertions(+), 107 deletions(-)
delete mode 100644 Com/Simatime/Go.hs
create mode 100644 Control/Concurrent/Go.hs
diff --git a/Com/Simatime/Go.hs b/Com/Simatime/Go.hs
deleted file mode 100644
index 01555f3..0000000
--- a/Com/Simatime/Go.hs
+++ /dev/null
@@ -1,106 +0,0 @@
-{- | An EDSL to make working with concurrent in-process code a bit easier
- to read.
-
-This module is expected to be imported qualified as `Go`. Inspired by
-Golang and Clojure's core.async.
-
-$example
--}
-{-# LANGUAGE NoImplicitPrelude #-}
-{-# LANGUAGE OverloadedStrings #-}
-module Com.Simatime.Go
- (
- -- * Running and forking
- fork
- -- * Channels
- , Channel
- , chan
- , read
- , write
- , mult
- , tap
- )
-where
-
-import Alpha hiding ( read )
-import qualified Control.Concurrent as Concurrent
-import qualified Control.Concurrent.Chan.Unagi.Bounded
- as Chan
-import qualified Data.Aeson as Aeson
-import qualified System.IO.Unsafe as Unsafe
-
--- | A standard channel.
-data Channel a = Channel
- { _in :: Chan.InChan a
- , _out :: Chan.OutChan a
- , _size :: Int
- }
-
-instance Aeson.ToJSON (Channel a) where
- toJSON c = Aeson.String ("#<channel " <> len c <> ">" :: Text)
- where len = show . Unsafe.unsafePerformIO . Chan.estimatedLength . _in
-
--- | Starts a background process.
-fork :: IO () -> IO Concurrent.ThreadId
-fork = Concurrent.forkIO
-
--- | Make a new channel.
-chan :: Int -> IO (Channel a)
-chan n = do
- (i, o) <- Chan.newChan n
- return <| Channel i o n
-
--- | A channel for broadcasting to multiple consumers. See 'mult'.
-type Mult a = Chan.OutChan a
-
--- | Duplicates a channel, but then anything written to the source will
--- be available to both. This is like Clojure's `core.async/mult`
-mult :: Channel a -> IO (Mult a)
-mult = Chan.dupChan . _in
-
--- | Read a value from a 'Mult'. This is like Clojure's `core.async/tap`.
---
--- You can use this to read from a channel in a background process, e.g.:
---
--- >>> c <- Go.chan
--- >>> Go.fork . forever <| Go.mult c >>= Go.tap >>= print
-tap :: Mult a -> IO a
-tap = Chan.readChan
-
--- | Take from a channel. Blocks until a value is received.
-read :: Channel a -> IO a
-read = Chan.readChan . _out
-
--- | Write to a channel. Blocks if the channel is full.
-write :: Channel a -> a -> IO Bool
-write = Chan.tryWriteChan . _in
-
-{- $example
-
-A simple example from ghci:
-
->>> import qualified Com.Simatime.Go as Go
->>> c <- Go.chan :: IO (Go.Channel Text)
->>> Go.write c "test"
->>> Go.read c
-"test"
-
-An example with tap and mult:
-
->>> c <- Go.chan :: IO (Go.Channel Text)
->>> Go.write c "hi"
->>> Go.read c
-"hi"
->>> Go.fork
->>> Go.fork $ forever $ Go.mult c >>= Go.tap >>= \t -> print ("one: " <> t)
-ThreadId 810
->>> Go.fork $ forever $ Go.mult c >>= Go.tap >>= \t -> print ("two: " <> t)
-ThreadId 825
->>> Go.write c "test"
-"two: t"eosnte":
- test"
-
-The text is garbled because the actions are happening concurrently and
-trying to serialize to write the output, but you get the idea.
-
--}
diff --git a/Control/Concurrent/Go.hs b/Control/Concurrent/Go.hs
new file mode 100644
index 0000000..1bb0b86
--- /dev/null
+++ b/Control/Concurrent/Go.hs
@@ -0,0 +1,107 @@
+{- | An EDSL to make working with concurrent in-process code a bit easier
+ to read.
+
+This module is expected to be imported qualified as `Go`. Inspired by
+Golang and Clojure's core.async.
+
+$example
+-}
+{-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE OverloadedStrings #-}
+module Control.Concurrent.Go
+ (
+ -- * Running and forking
+ fork
+ -- * Channels
+ , Channel
+ , chan
+ , read
+ , write
+ , mult
+ , tap
+ )
+where
+
+import Alpha
+import qualified Control.Concurrent as Concurrent
+import qualified Control.Concurrent.Chan.Unagi.Bounded
+ as Chan
+import qualified Data.Aeson as Aeson
+import Data.Text ( Text )
+import qualified System.IO.Unsafe as Unsafe
+
+-- | A standard channel.
+data Channel a = Channel
+ { _in :: Chan.InChan a
+ , _out :: Chan.OutChan a
+ , _size :: Int
+ }
+
+instance Aeson.ToJSON (Channel a) where
+ toJSON c = Aeson.String ("#<channel " <> len c <> ">" :: Text)
+ where len = show . Unsafe.unsafePerformIO . Chan.estimatedLength . _in
+
+-- | Starts a background process.
+fork :: IO () -> IO Concurrent.ThreadId
+fork = Concurrent.forkIO
+
+-- | Make a new channel.
+chan :: Int -> IO (Channel a)
+chan n = do
+ (i, o) <- Chan.newChan n
+ return $ Channel i o n
+
+-- | A channel for broadcasting to multiple consumers. See 'mult'.
+type Mult a = Chan.OutChan a
+
+-- | Duplicates a channel, but then anything written to the source will
+-- be available to both. This is like Clojure's `core.async/mult`
+mult :: Channel a -> IO (Mult a)
+mult = Chan.dupChan . _in
+
+-- | Read a value from a 'Mult'. This is like Clojure's `core.async/tap`.
+--
+-- You can use this to read from a channel in a background process, e.g.:
+--
+-- >>> c <- Go.chan
+-- >>> Go.fork . forever <| Go.mult c >>= Go.tap >>= print
+tap :: Mult a -> IO a
+tap = Chan.readChan
+
+-- | Take from a channel. Blocks until a value is received.
+read :: Channel a -> IO a
+read = Chan.readChan . _out
+
+-- | Write to a channel. Blocks if the channel is full.
+write :: Channel a -> a -> IO Bool
+write = Chan.tryWriteChan . _in
+
+{- $example
+
+A simple example from ghci:
+
+>>> import qualified Control.Concurrent.Go as Go
+>>> c <- Go.chan :: IO (Go.Channel Text)
+>>> Go.write c "test"
+>>> Go.read c
+"test"
+
+An example with tap and mult:
+
+>>> c <- Go.chan :: IO (Go.Channel Text)
+>>> Go.write c "hi"
+>>> Go.read c
+"hi"
+>>> Go.fork
+>>> Go.fork $ forever $ Go.mult c >>= Go.tap >>= \t -> print ("one: " <> t)
+ThreadId 810
+>>> Go.fork $ forever $ Go.mult c >>= Go.tap >>= \t -> print ("two: " <> t)
+ThreadId 825
+>>> Go.write c "test"
+"two: t"eosnte":
+ test"
+
+The text is garbled because the actions are happening concurrently and
+trying to serialize to write the output, but you get the idea.
+
+-}
diff --git a/Run/Que/Server.hs b/Run/Que/Server.hs
index e807502..f729795 100644
--- a/Run/Que/Server.hs
+++ b/Run/Que/Server.hs
@@ -26,7 +26,7 @@ import Alpha hiding ( Text
, modify
, poll
)
-import qualified Com.Simatime.Go as Go
+import qualified Control.Concurrent.Go as Go
import qualified Control.Concurrent.STM as STM
import qualified Control.Exception as Exception
import Control.Monad.Reader ( MonadTrans )
--
cgit v1.2.3