Best way to choose a state for an Unfold?

[clintonmead]

Bit of a question about how to best use streamly to get well optimised code. Sorry if there's documentation that already answers this, I couldn't find any sorry.

So I've got what I think is a fairly standard unfold, that is something like this form:

data Result = Result 
data SomeData = SomeData
data ExtraData = ExtraData
data BigEnumOfStates = State1 | State2 | State3 | State4 | State5 ExtraData 

data State = State SomeData BigEnumOfStates

f :: State -> Maybe (Result, State)
f (State data bigEnumOfStates) = case bigEnumOfStates of
  State1 -> h1 
  State2 -> h2
  ...

f1 :: SomeData -> Maybe (Result, State)
f1 data =
  let
    ...
    result = ... 
    remainingData :: SomeData
    remainingData = ... 
  in
    -- next state is always state 2 here, but it could be more complicated
    Just (result, State remainingData State2)

f2 :: SomeData -> Maybe (Result, State)
f2 :: ...

So then I can do this:

myUnfold :: Unfold m State Result
myUnfold = Streamly.unfoldr f

So far so good. But it occurred to me that parts (1) and (3) above are basically inverses. Why am I producing a state enum just to pattern match on it and turn it back into a function call? My function f1 knows what function I need to call next (namely f2 in this case), why not just put that directly into the state instead of converting it into an enum. So then it occurred to me that I could do this:

newtype State2 = State2 { unState2 :: Maybe (Result, State2) }

myUnfold2 :: Unfold m State2 Result
myUnfold2 = Streamly.unfoldr unState2

And I can then just write this function, which is just a slightly transformed version of f:

g1 :: SomeData -> State2
g1 data =
  let
    ...
    result = ...
    remainingData :: SomeData
    remainingData = ... 
  in
    -- next state is always state 2 here, but it could be more complicated
    Just (result, g2 remainingData)
    
g2 :: SomeData -> State2 
g2 = ...

And I can just call g1 data or g2 data or whatever depending on what my initial state is to kick off the process.

Now I avoid the pattern match on states at the start of each function. I just have inside my state thunk that resolves to what happens next.

In some way this seems more direct. Instead of basically making a mapping between an enum and a function call through a case statement, and storing the enum in the state as a proxy for the next function to be called (which requires the extra time of a pattern match to result), I'm just storing the next function to be used directly. But there are some issues:

1. This certainly requires laziness and thunks to work.
2. I have just basically hidden a linked list inside a stream using this scheme (as I've got a chained list of thunks) and have I just broken a bunch of optimisations that streamly is designed to apply?

Just thinking out loud, I guess the case match is a pattern match followed by a direct jump (i.e. one that's location is known at compile time). Whereas storing the thunk avoids the pattern match but is an indirect jump. That's two things in the first case but only one in the second but perhaps the latter it a "bigger thing", as perhaps building a thunk is slower than building and enum and pattern matching on it.

But I guess the bigger thing is what is GHC happier to optimise? Is it best to map my "continuation function" to an enum and store that in the state, or just store a thunk to the "continuation function" directly?