I have a program with this data structure:
data Element = Element {
elementOrigin :: V,
elementSubs :: [Element]
}
and this important bit of code that operates on it:
transform :: T -> Element -> Element
transform t e = Element {
elementOrigin = tmulv t (elementOrigin e),
elementSubs = map (transform t) (elementSubs e)
}
Where V is a vertex and T is a matrix transformation. The following is true:
transform a (transform b e) == transform (a * b) e
I have read about rewrite rules, such would efficiently rewrite the obvious
transformations. However, given that the program will be applying *many*
transformations to very deep and wide Element trees, and applying those
transformations at many levels, I don't see how the optimizer would be able to
handle all cases, for instance a thunk getting left over from perhaps
evaluation prior to some IO function.
FWIW here's an example "tree-builder" I'm using to test with:
mkElems 0 _ = Element {
elementOrigin = V 0 0,
elementSubs = []
}
mkElems depth width = Element {
elementOrigin = V 0 0,
elementSubs = replicate width $ transform (rotation (pi /
(fromIntegral width))) $ transform (translation $ V 1 1) $ mkElems (depth - 1)
width
}
with depth = width = 5
If I could somehow arrange for the transform function to detect when it
is being applied to a unevaluated thunk, and then modify the thunk in
place, that would basically be the behavior I need. Any suggestions?
--
http://petertodd.org 'peter'[:[email protected]
signature.asc
Description: Digital signature
_______________________________________________ Haskell-Cafe mailing list [email protected] http://www.haskell.org/mailman/listinfo/haskell-cafe
