:: (a -> b) -> (c -> a) -> c -> b

Function composition.
The mathematical symbol for function composition.
composeN f g means give g N inputs and then pass its result to f.
Function composition.
Right-associative compose operator. Read as "compose backward" or "but first". Use this to create long chains of computation that suggest which direction things move in. You may prefer this operator over (.>) for IO actions since it puts the last function first.
>>> let f = print <. negate <. recip <. succ

>>> f 3
-0.25
Or use it anywhere you would use (.). Note that (<.) and (.>) have the same precedence, so they cannot be used together.
>>> -- This doesn't work!

>>> -- print <. succ .> recip .> negate
\ x -> (g <. f) x == g (f x)
\ x -> (h <. g <. f) x == h (g (f x))
Function composition which calls the right-hand function eagerly; i.e., making the left-hand function strict in its first argument.
(f .! g) x = f $! g x
This defines the composition for the sub-category of strict Haskell functions. If the Functor class were parameterized by the domain and codomain categories (e.g., a regular Functor f would be CFunctor (->) (->) f instead) then this would allow us to define functors CFunctor (->) (!->) f where fmap f . fmap g = fmap (f .! g).
Strict variant of function composition. Defined as:
(f . g) x = f $! g $! x
Internally used since version 0.10.0.0. Moved to Data.Function.Between.Strict.Internal module and exposed in version 0.11.0.0.
Compose a non-indexed function with an Indexed function. Mnemonically, the > points to the indexing we want to preserve. This is the same as (.). f . g (and f .> g) gives you the index of g unless g is index-preserving, like a Prism, Iso or Equality, in which case it'll pass through the index of f.
>>> let nestedMap = (fmap Map.fromList . Map.fromList) [(1, [(10, "one,ten"), (20, "one,twenty")]), (2, [(30, "two,thirty"), (40,"two,forty")])]

>>> nestedMap^..(itraversed.>itraversed).withIndex
[(10,"one,ten"),(20,"one,twenty"),(30,"two,thirty"),(40,"two,forty")]
(∘) = (.) U+2218, RING OPERATOR
Wrap the result of a function applied to 1 argument.
Coercible composition. This function allows to write more efficient implementations of function compositions over newtypes.
Composition operator where the first argument must be an identity function up to representational equivalence (e.g. a newtype wrapper or unwrapper), and will be ignored at runtime.
Composition operator where the second argument must be an identity function up to representational equivalence (e.g. a newtype wrapper or unwrapper), and will be ignored at runtime.
Lift a memoizer to work with one more argument.