But how? Parsing function can return any of the types, we don’t know what was in the bytestring. So we’d need to deal with all variations in any case, no?
Is the difference in that it becomes possible to pattern-match on a type of an element inside the structure, rather than on the structure as a whole? So as long as you don’t need that element, you can access elements that are common without pattern-matching? I guess it’s a marginal benefit…
Or do I still misunderstand?
This is probably a stupid question, but what does this trickery with GADTs and Existential Types give compared to the “normal” way?
import Data.Int (Int8, Int16)
import Data.ByteString (ByteString)
data ParsedImage
= ParsedAs8 (Int, Int, [Int8])
| ParsedAs16 (Int, Int, [Int16])
deriving Show
parseImage :: ByteString -> ParsedImage
parseImage = undefined
imageDimensions :: ByteString -> (Int, Int)
imageDimensions str =
case parseImage str of
ParsedAs8 (w, h, _) -> (w, h)
ParsedAs16 (w, h, _) -> (w, h)
Basically, the same way as a function can return an Either and everyone is happy to pattern-match on the result.
Well, I guess that I can see the value… Leaving copy-pasting problem aside, you might, for instance, want to have a type for a message with moderately complex envelope and a wide variety of possible payload types. It would be useful to have functions that act on the envelope, and treat payload as something opaque.
Thanks for the conversation!