> > sourceToSinkTransducer :: SourceTransducer x y -> SinkTransducer x y
> >
> > I can't find any way to implement the sourceToSinkTransducer function
>
> Indeed that cannot be done because it breaks referential transparency.
>
Ok, thanks for clarifying the reason.
> Food for thought:
>
> You need some sort of side effects (I'm not quite sure which), so
> it'd be interesting to try
>
> newtype Source m x = Source (m (x, Source x))
> newtype Sink m x = Sink (x -> m (Sink x))
>
> where m is an appropriate monad. Will the continuation monad work?
I'm not sure. I'm trying to find the minimal data types that will let me
implement the
higher-level combinators. So far, the best I've found is the CPS and the
following
declarations:
data Source i r = Source {get :: Sink i r -> r}
data Monoid r => Sink i r = Sink {put :: i -> Source i r -> r, close :: r}
newtype Filter x y = Filter { transduce :: forall r. Monoid r => Source x r ->
Sink y r -> r }
newtype Splitter i = Splitter { split :: forall r. Monoid r => Source i r ->
Sink i r ->
Sink i r -> r }
The 'close' function and result type 'r' are there because the streams are
usually finite.
The 'Source' type should really be declared as
data Source i = Source {get :: forall r. Sink i r -> r}
because sources should not depend the result type, but that caused a lot of
problems with
type checking: the two 'r's in Source and Sink declaration are not unified. I
don't see a
way to express my intention.
Anyway, thanks again for the explanation of why it has to be this complicated.
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
