compose arbitrary number of functions (a->a)

gistfile1.hs

-- Want :: [a -> a] -> a -> a
-- Emulates: an . … . a3 . a2 . a1

Prelude> let a = [reverse, (++ " world"), (++ "!")]

-- Given "olleh", it should:
--   * reverse it:      "hello"
--   * append " world": "hello world"
--   * append "!":      "hello world!"

Prelude> foldr ($) "olleh" a
"dlrow !hello"
Prelude> foldl (\acc x -> x acc) "olleh" a
"hello world!"

Prelude> import Data.Monoid
Prelude Data.Monoid> mconcat a "olleh"
"helloolleh worldolleh!"
Prelude Data.Monoid> let b = map Endo a
Prelude Data.Monoid> mconcat b `appEndo` "olleh"
"dlrow !hello"

Prelude Data.Monoid> let compose = flip (foldl (flip ($)))     -- flip . foldl . flip $ ($)
Prelude Data.Monoid> :t compose
compose :: [c -> c] -> c -> c
Prelude Data.Monoid> compose a "olleh"
"hello world!"

-- Using foldMap Endo:
Prelude Data.Monoid> import Data.Foldable
Prelude Data.Monoid Data.Foldable> (foldMap Endo a) `appEndo` "olleh"
"dlrow !hello"

-- Using Dual . Endo to get the expected order:
Prelude Data.Monoid Data.Foldable> (getDual . foldMap (Dual . Endo) $ a) `appEndo` "olleh"
"hello world!"
Prelude Data.Monoid Data.Foldable> (appEndo .getDual . foldMap (Dual . Endo) $ a) "olleh"
"hello world!"