data Common = ...<br>data A = ...<br>data B = ...<br>data C = ...<br>data Super =<br> SubA { commonFields :: Common, getA :: A }<br> | SubB { commonFields :: Common, getB :: B }<br> | SubC { commonFields :: Common, getC :: C }<br>
<br>foldWithSubtype :: (A -> r) -> (B -> r) -> (C -> r) -> Super -> r<br>foldWithSubtype k _ _ (SubA {getA = a}) = k a<br>foldWithSubtype _ k _ (SubB {getB = b}) = k b<br>
foldWithSubtype _ _ k (SubC {getC = c}) = k c<br><br>foldSuper :: (A -> Common -> r) -> (B -> Common -> r) -> (C -> Common -> r) -> Super -> r<br>foldSuper ka kb kc sup = foldWithSubtype ka kb kc sup $ commonFields sup<br>
<br><br><div class="gmail_quote">On Mon, Mar 12, 2012 at 8:32 AM, Jeff Shaw <span dir="ltr"><<a href="mailto:shawjef3@msu.edu">shawjef3@msu.edu</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
More specifically, if I have a record type from which I construct multiple sub-record types, and I want to store these in a collection which I want to map over while preserving the ability to get at the sub-fields, is there a better way to do it than to have an enumeration for the sub-types and then use Dynamic? I also have a nastier version that doesn't require the enumeration, which throws an exception when fromDynamic can't return a value with one of the expected types.<br>
<br>
{-# LANGUAGE Rank2Types, DeriveDataTypeable #-}<br>
module Super where<br>
<br>
import Data.Dynamic<br>
import Data.Typeable<br>
import Data.Maybe<br>
<br>
data Super a = Super { commonFields :: (), subFields :: a }<br>
deriving Typeable<br>
<br>
data SubTypes = SubA | SubB | SubC<br>
<br>
data A = A { aFields :: () }<br>
deriving Typeable<br>
<br>
data B = B { bFields :: () }<br>
deriving Typeable<br>
<br>
data C = C { cFields :: () }<br>
deriving Typeable<br>
<br>
doSomethingWithSubType :: (Super A -> ()) -> (Super B -> ()) -> (Super C -> ()) -> (SubTypes, Dynamic) -> Maybe ()<br>
doSomethingWithSubType a _ _ (SubA, dynamic) = fromDynamic dynamic >>= return . a<br>
doSomethingWithSubType _ b _ (SubB, dynamic) = fromDynamic dynamic >>= return . b<br>
doSomethingWithSubType _ _ c (SubC, dynamic) = fromDynamic dynamic >>= return . c<br>
<br>
doSomethingWithSubType2 :: (Super A -> ()) -> (Super B -> ()) -> (Super C -> ()) -> Dynamic -> ()<br>
doSomethingWithSubType2 a b c dynamic =<br>
let dynamicAsA = fromDynamic dynamic :: Maybe (Super A)<br>
dynamicAsB = fromDynamic dynamic :: Maybe (Super B)<br>
dynamicAsC = fromDynamic dynamic :: Maybe (Super C) in<br>
head $ catMaybes [ dynamicAsA >>= return . a<br>
, dynamicAsB >>= return . b<br>
, dynamicAsC >>= return . c]<br>
<br>
<br>
______________________________<u></u>_________________<br>
Haskell-Cafe mailing list<br>
<a href="mailto:Haskell-Cafe@haskell.org" target="_blank">Haskell-Cafe@haskell.org</a><br>
<a href="http://www.haskell.org/mailman/listinfo/haskell-cafe" target="_blank">http://www.haskell.org/<u></u>mailman/listinfo/haskell-cafe</a><br>
</blockquote></div><br>