Quick question for the experts out there. I need to process some records. The records come in in an unordered stream of record fields. From each stream of fields I want to produce a Record entry containing the fields I need to do my calculation.
data Record = { field1 :: Type1, field2 :: Type2, ... }
I was thinking this setup might work nice with something like
data RecordF d = RecordF { field1 :: f Type1, field2 :: f Type2, ... }
as I could then have (1) a monoid version I could accumulate use as an accumulator over the stream
type RecordM = RecordF []
and (2) a final version.
type Record = RecordF Identity
This final version seems like it should easily come from the later by pulling the [] (or anything else that has the Apply/Applicative structure) to the outside and then taking the head of the resulting list. While I could write the boilerplate to do this, it seems like something I should be able to do more elegantly. The best I have come up with so far is to use the lens package to give me an isomorphism to a tuple. Then I need a uncurried zip for arbitrarily large tuples. Follow this by an isomorphism back. RecordF (f Type1) (f Type2) ... -> (f Type1, f Type2, ....) -> f (Type1, Type2, ...) -> f (Record Type1 Type2 ...) I can't seem to find any uncurried zip implementations for arbitrarily large tuples (or any other way to do this without writing the boilerplate). Am I missing something? Is there a better way to do this? Thanks! -Tyson PS: It seems the Data.Vinyl package has something along these lines with the rtraverse function https://hackage.haskell.org/package/vinyl-0.5.1/docs/Data-Vinyl-Core.html