Eu estou tentando criar um canal que pode consumir vários fluxos de entrada. Eu preciso ser capaz de esperar em um ou outro dos fluxos de entrada em nenhuma ordem particular (por exemplo, não alternando) fazendo zip inútil. Não há nada paralelo ou não determinista acontecendo aqui: aguardo em um riacho ou outro. Eu quero ser capaz de escrever código semelhante ao seguinte (ondeawaitA eawaitB aguardar no primeiro ou segundo fluxo de entrada, respectivamente):

do
  _ <- awaitA
  x <- awaitA
  y <- awaitB
  yield (x,y)
  _ <- awaitB
  _ <- awaitB
  y' <- awaitB
  yield (x,y')

A melhor solução que tenho é fazer com que a mônada interna seja outra conduta, por ex.

foo :: Sink i1 (ConduitM i2 o m) ()

Que então permite

awaitA = await
awaitB = lift await

E isso funciona principalmente. Infelizmente, isto parece dificultar muito a fusão do conduto interno antes que o conduto externo esteja totalmente conectado. A primeira coisa que tentei foi:

fuseInner :: Monad m =>
                Conduit i2' m i2 -> 
                Sink i1 (ConduitM i2 o m) () -> 
                Sink i1 (ConduitM i2' o m) ()
fuseInner x = transPipe (x =$=)

Mas isso não funciona, pelo menos quandox é stateful desde(x =$=) é executado várias vezes, efetivamente reiniciandox cada vez.

Existe alguma maneira de escrever o fuseInner, a não ser invadir o interior do conduíte (o que parece ser bastante confuso)? Existe alguma maneira melhor de lidar com vários fluxos de entrada? Estou apenas muito além do que foi projetado para o conduíte?

Obrigado!