Your example can be written more clearly (IMO) in Haskell like this:
sum $ map (^2) $ filter odd [1..10]
Or, defined as a function:
> let foo = sum . map (^2) . filter odd
> foo [1..10]
165
You can write it without using the composition operator at all, if you prefer:
> let bar xs = sum (map (^2) (filter odd xs))
> bar [1..10]
165
In general, you
can write out your programs as crazy sequences of operators (whose precedence may not be obvious to the reader):
> take 5 . unfoldr (Just . next) getStdGen >>= putStrLn . show
[1336079013,234736121,108049288,410228860,1573295749]
But you don't
have to:
> let infiniteRandoms = unfoldr (Just . next) :: StdGen -> [Int]
> gen let fiveRandoms = take 5 (infiniteRandoms gen)
> putStrLn (show fiveRandoms)
[1336079013,234736121,108049288,410228860,1573295749]
People seem to think Haskell is all about writing your whole program in a single hideous line of code with incomprehensible sequences of arcane operators glued together by a glut of anonymous functions, but that's just bad code.
As for left-to-right vs right-to-left, I have never had a problem with the way Haskell does it. I think if you're coming from a language that does it differently, it makes sense that Haskell would trip you up in that regard. Haskell's composition operator matches the way it's usually written in mathematics, but there's nothing special about it and you could change it to go the other way if you really wanted to (but please don't):
> let g . f = \x -> f (g x)
> let foo = filter odd . map (^2) . sum
> foo [1..10]
165
`(>>>)` from `Control.Arrow` is a more reasonable way to get that sweet left-to-right action but using it might still throw people off:
> let foo = filter odd >>> map (^2) >>> sum
> foo [1..10]
165