Q:

Pointfree style programming in haskell

I have this function 
rulesApply :: [PhrasePair] -> Phrase ->  Phrase

rulesApply pp = try (transformationsApply "*" reflect  pp )

I want to learn how to make it pointfree.
try :: (a -> Maybe a) -> a -> a
try f x = maybe x id (f x)
transformationsApply :: Eq a => a -> ([a] -> [a]) -> ([([a], [a])] -> ([a] -> Maybe [a]))
transformationsApply wc f pfPair list = foldr1 orElse (map (transformationApply wc f list) pfPair)

 rulesApply pp = try (transformationsApply "*" reflect  pp )

(transformationsApply "*" reflect ) pp has type Eq a => ([([a], [a])] -> ([a] -> Maybe [a]))
We see that 
try :: (a -> Maybe a) -> a -> a

so try takes a function (a -> Maybe a) as argument. and we see that return type of (transformationsApply "*" reflect ) pp is ([a] -> Maybe [a])) so we should be able to write.
rulesApply pp = try . (transformationsApply "*" reflect) pp

but this gives compilation error.

A:

Whenever you have something that looks like
\x -> f (g x)

you can turn it into
f . g

In this case, you have
s          x  = f   (g                                 x  )
rulesApply pp = try (transformationsApply "*" reflect  pp )

which can be transformed (by moving the argument to the other side of the equation) into
s          = \x  -> f   (g                                 x  )
rulesApply = \pp -> try (transformationsApply "*" reflect  pp )

which in turn is, according to our rule,
s          = f   . g
rulesApply = try . transformationsApply "*" reflect

A:

It's relatively easy to remove the points, but you should move step by step.
rulesApply pp =  try ( transformationsApply "*" reflect  pp)

=== [partial application]

rulesApply pp =  try ((transformationsApply "*" reflect) pp)

=== [definition of (.)]

rulesApply pp = (try . transformationsApply "*" reflect) pp

=== [eta reduction]

rulesApply    =  try . transformationsApply "*" reflect

