1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
{-# LANGUAGE CPP #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE FlexibleContexts #-}
#if __GLASGOW_HASKELL__ >= 702
{-# LANGUAGE Safe #-}
#endif
{- |
Module : Control.Concurrent.Chan.Lifted
Copyright : Liyang HU, Bas van Dijk
License : BSD-style
Maintainer : Bas van Dijk <v.dijk.bas@gmail.com>
Stability : experimental
This is a wrapped version of "Control.Concurrent.Chan" with types
generalised from 'IO' to all monads in 'MonadBase'.
'Chan.unGetChan' and 'Chan.isEmptyChan' are deprecated in @base@, therefore
they are not included here. Use 'Control.Concurrent.STM.TVar' instead.
-}
module Control.Concurrent.Chan.Lifted
( Chan
, newChan
, writeChan
, readChan
, dupChan
, getChanContents
, writeList2Chan
) where
--------------------------------------------------------------------------------
-- Imports
--------------------------------------------------------------------------------
-- from base:
import Control.Concurrent.Chan ( Chan )
import qualified Control.Concurrent.Chan as Chan
import System.IO ( IO )
import Prelude ( (.) )
-- from transformers-base:
import Control.Monad.Base ( MonadBase, liftBase )
#include "inlinable.h"
--------------------------------------------------------------------------------
-- * Chans
--------------------------------------------------------------------------------
-- | Generalized version of 'Chan.newChan'.
newChan :: MonadBase IO m => m (Chan a)
newChan = liftBase Chan.newChan
{-# INLINABLE newChan #-}
-- | Generalized version of 'Chan.writeChan'.
writeChan :: MonadBase IO m => Chan a -> a -> m ()
writeChan chan = liftBase . Chan.writeChan chan
{-# INLINABLE writeChan #-}
-- | Generalized version of 'Chan.readChan'.
readChan :: MonadBase IO m => Chan a -> m a
readChan = liftBase . Chan.readChan
{-# INLINABLE readChan #-}
-- | Generalized version of 'Chan.dupChan'.
dupChan :: MonadBase IO m => Chan a -> m (Chan a)
dupChan = liftBase . Chan.dupChan
{-# INLINABLE dupChan #-}
-- | Generalized version of 'Chan.getChanContents'.
getChanContents :: MonadBase IO m => Chan a -> m [a]
getChanContents = liftBase . Chan.getChanContents
{-# INLINABLE getChanContents #-}
-- | Generalized version of 'Chan.writeList2Chan'.
writeList2Chan :: MonadBase IO m => Chan a -> [a] -> m ()
writeList2Chan chan = liftBase . Chan.writeList2Chan chan
{-# INLINABLE writeList2Chan #-}
|
