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'[:-...@petertodd.org 

Attachment: signature.asc
Description: Digital signature

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Reply via email to