Create a gist now

Instantly share code, notes, and snippets.

BIjection between Twan van Laarhoven's Pipe and the data types from Conduit
import Control.Monad
data Pipe m i o r =
NeedInput (i -> Pipe m i o r) (Pipe m () o r)
| HaveOutput (Pipe m i o r) (m ()) o
| Finished (Maybe i) r
| PipeM (m (Pipe m i o r)) (m r)
data Void
unused = error "unused"
absurd = error "Cannot happen because of Void"
data Sink i m o =
Processing (i -> Sink i m o) (SinkClose m o)
| Done (Maybe i) o
| SinkM (m (Sink i m o))
type SinkClose m o = m o
toSinkClose :: Monad m => Pipe m () Void r -> SinkClose m r
toSinkClose (NeedInput _ _) = unused
toSinkClose (HaveOutput _ _ _) = absurd
toSinkClose (Finished _ _) = unused
toSinkClose (PipeM _ a) = a
toSink :: Monad m => Pipe m i Void r -> Sink i m r
toSink (NeedInput a b) = Processing (toSink . a) (toSinkClose b)
toSink (HaveOutput _ _ _) = absurd
toSink (Finished a b) = Done a b
toSink (PipeM a _) = SinkM (toSink `liftM` a)
fromSink :: Monad m => Sink i m r -> Pipe m i Void r
fromSink (Processing a b) = NeedInput (fromSink . a) (PipeM unused b)
fromSink (Done a b) = Finished a b
fromSink (SinkM a) = PipeM (fromSink `liftM` a) unused
data Conduit i m o =
NeedInput' (i -> Conduit i m o) (ConduitClose m o)
| HaveOutput' (Conduit i m o) (m ()) o
| Finished' (Maybe i)
| ConduitM (m (Conduit i m o)) (m ())
type ConduitClose m o = Source m o
toConduit :: Monad m => Pipe m i o () -> Conduit i m o
toConduit (NeedInput a b) = NeedInput' (toConduit . a) (toSource b)
toConduit (HaveOutput a b c) = HaveOutput' (toConduit a) b c
toConduit (Finished a ()) = Finished' a
toConduit (PipeM a b) = ConduitM (toConduit `liftM` a) b
fromConduit :: Monad m => Conduit i m o -> Pipe m i o ()
fromConduit (NeedInput' a b) = NeedInput (fromConduit . a) (fromSource b)
fromConduit (HaveOutput' a b c) = HaveOutput (fromConduit a) b c
fromConduit (Finished' a) = Finished a ()
fromConduit (ConduitM a b) = PipeM (fromConduit `liftM` a) b
data Source m a =
Open (Source m a) (m ()) a
| Closed
| SourceM (m (Source m a)) (m ())
toSource :: Monad m => Pipe m () a () -> Source m a
toSource (NeedInput f m) = unused
toSource (HaveOutput a b c) = Open (toSource a) b c
toSource (Finished _ _) = Closed
toSource (PipeM a b) = SourceM (toSource `liftM` a) b
fromSource :: Monad m => Source m a -> Pipe m () a ()
fromSource (Open a b c) = HaveOutput (fromSource a) b c
fromSource Closed = Finished unused unused
fromSource (SourceM a b) = PipeM (fromSource `liftM` a) b
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment