Should one combine stateful unfolds or just compose the resulting functions between streams?

[clintonmead]

Lets say I have the following:

data StateAB
data StateBC

data A
data B
data C

unfoldAB :: Streamly.Unfold (StrictState.StateT StateAB m) A B
unfoldAB = _ 

unfoldBC :: Streamly.Unfold (StrictState.StateT StateBC m) B C
unfoldBC = _

initialStateAB :: m StateAB
initialStateAB = _

initialStateBC :: m StateBC
initialStateBC = _

I can combine these into a stream from A -> C like the following:

unfoldManyAB :: Monad m => Stream (StrictState.StateT StateAB m) A -> Stream (StrictState.StateT StateAB m) B
unfoldManyAB = Streamly.unfoldMany unfoldAB

unfoldManyBC :: Monad m => Stream (StrictState.StateT StateBC m) B -> Stream (StrictState.StateT StateBC m) C
unfoldManyBC = Streamly.unfoldMany unfoldBC

runStateTSnd :: Monad m => m s -> Streamly.Stream (StrictState.StateT s m) a -> Streamly.Stream m a
runStateTSnd  = ((snd <$>) .) . Streamly.runStateT

option1 :: Monad m => Stream m A -> Stream m C
option1 = runStateTSnd initialStateBC . unfoldManyBC . Streamly.liftInner . runStateTSnd initialStateAB . unfoldManyAB . Streamly.liftInner 

but note, in this, I am effectively calling Streamly.unfoldMany twice, both for unfoldManyAB and unfoldManyBC

However, with a helper function liftUnfold, I could actually combine these unfolds into one, and run Streamly.unfoldMany only once:

liftUnfold :: (Monad m, MonadTrans n) => Streamly.Unfold m a b -> Streamly.Unfold (n m) a b
liftUnfold (Streamly.Unfold step inject) = Streamly.Unfold (lift . step) (lift . inject)

unfoldABC :: Monad m => Streamly.Unfold (StrictState.StateT StateBC (StrictState.StateT StateAB m)) A C
unfoldABC = Streamly.many unfoldBC (liftUnfold unfoldAB)

unfoldManyABC :: Monad m => Stream (StrictState.StateT StateBC (StrictState.StateT StateAB m)) A -> Stream (StrictState.StateT StateBC (StrictState.StateT StateAB m)) C
unfoldManyABC = Streamly.unfoldMany unfoldABC

option2 :: Monad m => Stream m A -> Stream m C
option2 = runStateTSnd initialStateAB . runStateTSnd initialStateBC . unfoldManyABC . Streamly.liftInner . Streamly.liftInner

My current code has a number of these stateful unfolds which I'm chaining together. In general, should I be combining the unfolds using a lift and Unfold.many, and then calling unfoldMany once? Or should I run unfoldMany lots of times, each producing a Stream m a -> Stream m b style result, and then just compose the streams using ordinary function composition?

Or is this something that I just need to benchmark either way?

My first thought was that lifting the unfolds into one unfold object and combining them with many will concentrate all the functions into one Unfold object, which can then be more easily optimised. However annoyingly to combine n unfolds I actually need n lifts, for example:

data StateCD
data D 

unfoldCD :: Streamly.Unfold (StrictState.StateT StateCD m) C D
unfoldCD = _

unfoldABCD :: Monad m => Streamly.Unfold (StrictState.StateT StateCD (StrictState.StateT StateBC (StrictState.StateT StateAB m))) A D
unfoldABCD = Streamly.many unfoldCD (liftUnfold unfoldABC)

but that's not too terrible. The signatures do start to get messy but they could be omitted.

The other alternative, option1, is to just combine the resulting Stream m a -> Stream m b style functions using usual function composition. The Streams hide the state type, but will jumping back and forth between streams and unfolds inhibit optimisations? Does the fact that Stream has an existential mean that GHC will have more trouble with fusion. Or is it better just to compose functions between streams so I don't have to built a big chain of StateTs?