Hi, One thing that is hard to do with SYB (as well as with alternative generics packages in Haskell) at present is to query while keeping state that is carried down the tree but not to siblings, and use that in deciding what to return from the query. I propose a new scheme be added to Data.Generics.Schemes, called everythingWithContext (as defined below). An everywhereWithContext might also be useful, but I don't think you would be able to define the transformation using the existing combinators, so I have limited my proposal to everythingWithContext for now. Yours Sincerely, Andrew Miller {- | Summarise all nodes in top-down, left-to-right order, carrying some state down the tree during the computation, but not left-to-right to siblings. Example: Suppose you want to compute the maximum depth of adds in the below simple co-recursive structure, ignoring all the other constructors. You could write code like the following: data MyStructure = SomeConst Int | Add MyStructure MyStructure | Times MyStructure MyStructure | Wrapped Wrapper deriving (Data, Typeable) data Wrapper = Wrapper MyStructure deriving (Data, Typeable) myExample = Add (SomeConst 10) (Add (Wrapped . Wrapper $ (Add (Add (Add (Times (SomeConst 30) (SomeConst 90)) (SomeConst 70)) (SomeConst 40)) (SomeConst 50))) (Add (SomeConst 20) (Add (SomeConst 60) (SomeConst 80)))) computeDepth = everythingWithContext 0 max ((\s -> (0, s)) `mkQ` depthOfAdd) where depthOfAdd (Add _ _) s = (s, s + 1) depthOfAdd _ s = (s, s) main = print $ computeDepth myExample -} everythingWithContext :: s -> (r -> r -> r) -> GenericQ (s -> (r, s)) -> GenericQ r everythingWithContext s0 f q x = foldl f r (gmapQ (everythingWithContext s' f q) x) where (r, s') = q x s0