The pointless-fun package offers some common point-free combinators (common for me at least).
Perhaps the most useful is that it packages up Matt Hellige's classic multicomposition trick. These combinators allow you to easily modify the types of a many-argument function with syntax that looks like giving type signatures. For example,
foo :: A -> B -> C albert :: X -> A beth :: Y -> B carol :: C -> Z bar :: X -> Y -> Z bar = foo $:: albert ~> beth ~> carol
I've found this to be especially helpful for defining non-derivable type class instances for newtypes since it both abstracts away the plumbing and also makes explicit what you mean.
Other prevalent combinators include,
(.:) for binary composition:
(f .: g) x y = f (g x y) -- or, f .: g = curry (f . uncurry g)
This is the same as the common idiom
(f .) . g but more easily extended to multiple uses, due to the fixity declaration.
(.!) for 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)