This one may be fairly basic, but I was wondering if there's a common idiom for boxing a parameterized datatype into a non-parameterized one, and accessing the components in a unified manner. (hope I said that right, pretend I mentioned polymorphism somewhere)
module VarExample where
For example if I create a datatype to hold everything about a variable
data Base t = Base { value :: t , name :: String -- , ... more components }
that I want to use as part of a larger data structure, say a heterogeneous list or an AST, I think I have to collect all of the variations under a parameterless datatype declaration. Is this true?
data Var = IntegerT (Base Integer) | DoubleT (Base Double) -- | ... more constructors
type HeterogeneousList = [Var]
If so, it looks like I then need to write something like the following in order to access the name of a given Var, and likewise for other components.
getName :: Var -> String getName (IntegerT b) = name b getName ( DoubleT b) = name b
Doesn't seem bad, but if I have more components and type constructors it can become unwieldy. The following give compile-time errors, but represent what I've tried so far to simplify things.
getBase :: Var -> Base t getBase (IntegerT b) = b getBase ( DoubleT b) = b
getName2 v = name (getBase v)
callBaseFn :: Var -> (Base t -> a) -> a callBaseFn (IntegerT b) fn = fn b callBaseFn ( DoubleT b) fn = fn b
getName3 v = callBaseFn v name
The other option I've thought about is to use the GHC Dynamic module, but it doesn't seem very standard for what there is likely a common idiom. As you can see I'm still somewhat new at this, but would appreciate any help. - Thanks, Scott Williams