diff --git a/CHANGES.txt b/CHANGES.txt
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,5 +1,9 @@
 Changelog for HLint (* = breaking change)
 
+3.2.7, released 2021-01-16
+    #1202, add missing parentheses for Avoid Lambda
+    #1201, allow matching through the & operator (similar to $)
+    #1196, fix removed parens with operator sections in some cases
 3.2.6, released 2020-12-30
     Fixes to the release generation script
 3.2.5, released 2020-12-30
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright Neil Mitchell 2006-2020.
+Copyright Neil Mitchell 2006-2021.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -397,7 +397,7 @@
 
 Getting started on problems in HLint often means wanting to inspect a GHC parse tree to get a sense of what it looks like (to see how to match on it for example). Given a source program `Foo.hs` (say), you can get GHC to print a textual representation of `Foo`'s AST via the `-ddump-parsed-ast` flag e.g. `ghc -fforce-recomp -ddump-parsed-ast -c Foo.hs`.
 
-When you have an [`HsSyn`](https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/hs-syn-type) term in your program, it's quite common to want to print it (e.g. via `Debug.Trace.trace`). Types in `HsSyn` aren't in [`Show`](https://hoogle.haskell.org/?hoogle=Show). Not all types in `HsSyn` are [`Outputable`](https://hoogle.haskell.org/?hoogle=Outputable) but when they are you can call `ppr` to get `SDoc`s. This idiom is common enough that there exists [`unsafePrettyPrint`](https://hackage.haskell.org/package/ghc-lib-parser-ex-8.10.0.16/docs/Language-Haskell-GhclibParserEx-GHC-Utils-Outputable.html#v:unsafePrettyPrint). The function [`showAstData`](https://hoogle.haskell.org/?hoogle=showAstData) can be called on any `HsSyn` term to get output like with the `dump-parsed-ast` flag. The `showAstData` approach is preferable to `ppr` when both choices exist in that two ASTs that differ only in fixity arrangments will render differently with the former.
+When you have an [`HsSyn`](https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/hs-syn-type) term in your program, it's quite common to want to print it (e.g. via `Debug.Trace.trace`). Types in `HsSyn` aren't in [`Show`](https://hoogle.haskell.org/?hoogle=Show). Not all types in `HsSyn` are [`Outputable`](https://hoogle.haskell.org/?hoogle=Outputable) but when they are you can call `ppr` to get `SDoc`s. This idiom is common enough that there exists [`unsafePrettyPrint`](https://hackage.haskell.org/package/ghc-lib-parser-ex-8.10.0.16/docs/Language-Haskell-GhclibParserEx-GHC-Utils-Outputable.html#v:unsafePrettyPrint). The function [`showAstData`](https://hoogle.haskell.org/?hoogle=showAstData) can be called on any `HsSyn` term to get output like with the `dump-parsed-ast` flag. The `showAstData` approach is preferable to `ppr` when both choices exist in that two ASTs that differ only in fixity arrangements will render differently with the former.
 
 ### Acknowledgements
 
diff --git a/data/hlint.yaml b/data/hlint.yaml
--- a/data/hlint.yaml
+++ b/data/hlint.yaml
@@ -1047,6 +1047,7 @@
 # yes = f x where f x = concat . map head -- concatMap head
 # yes = concat . map f . g -- concatMap f . g
 # yes = concat $ map f x -- concatMap f x
+# yes = map f x & concat -- concatMap f x
 # yes = "test" ++ concatMap (' ':) ["of","this"] -- unwords ("test":["of","this"])
 # yes = if f a then True else b -- f a || b
 # yes = not (a == b) -- a /= b
@@ -1201,6 +1202,7 @@
 # no = foo $ (,) x $ do {this is a test; and another test}
 # no = sequence (return x)
 # no = sequenceA (pure a)
+# yes = zipWith func xs ys & sequenceA -- Control.Monad.zipWithM func xs ys
 # {-# LANGUAGE QuasiQuotes #-}; no = f (\url -> [hamlet|foo @{url}|])
 # yes = f ((,) x) -- (x,)
 # yes = f ((,) (2 + 3)) -- (2 + 3,)
@@ -1257,7 +1259,9 @@
 # fromList [] -- Data.Map.Strict.empty
 # test953 = for [] $ \n -> bar n >>= \case {Just n  -> pure (); Nothing -> baz n}
 # f = map (flip (,) "a") "123" -- (,"a")
+# test1196 = map (flip (,) (+ 1)) "123" -- (,(+ 1))
 # f = map ((,) "a") "123" -- ("a",)
+# test1196 = map ((,) (+ 1)) "123" -- ((+ 1),)
 # test979 = flip Map.traverseWithKey blocks \k v -> lots_of_code_goes_here
 # infixl 4 <*! \
 # test993 = f =<< g <$> x <*! y
diff --git a/hlint.cabal b/hlint.cabal
--- a/hlint.cabal
+++ b/hlint.cabal
@@ -1,13 +1,13 @@
 cabal-version:      >= 1.18
 build-type:         Simple
 name:               hlint
-version:            3.2.6
+version:            3.2.7
 license:            BSD3
 license-file:       LICENSE
 category:           Development
 author:             Neil Mitchell <ndmitchell@gmail.com>
 maintainer:         Neil Mitchell <ndmitchell@gmail.com>
-copyright:          Neil Mitchell 2006-2020
+copyright:          Neil Mitchell 2006-2021
 synopsis:           Source code suggestions
 description:
     HLint gives suggestions on how to improve your source code.
diff --git a/src/CmdLine.hs b/src/CmdLine.hs
--- a/src/CmdLine.hs
+++ b/src/CmdLine.hs
@@ -172,7 +172,7 @@
                    ,"To check all Haskell files in 'src' and generate a report type:"
                    ,"  hlint src --report"]
     ] &= program "hlint" &= verbosity
-    &=  summary ("HLint v" ++ showVersion version ++ ", (C) Neil Mitchell 2006-2020")
+    &=  summary ("HLint v" ++ showVersion version ++ ", (C) Neil Mitchell 2006-2021")
     where
         nam xs = nam_ xs &= name [head xs]
         nam_ xs = def &= explicit &= name xs
diff --git a/src/GHC/Util/HsExpr.hs b/src/GHC/Util/HsExpr.hs
--- a/src/GHC/Util/HsExpr.hs
+++ b/src/GHC/Util/HsExpr.hs
@@ -33,6 +33,7 @@
 import Data.Generics.Uniplate.DataOnly
 import Data.List.Extra
 import Data.Tuple.Extra
+import Data.Maybe
 
 import Refact (substVars, toSS)
 import Refact.Types hiding (SrcSpan, Match)
@@ -227,6 +228,7 @@
       )
   where
     gen = noLoc . HsApp noExtField (strToVar "flip")
+        . if isAtom op then id else addParen
 
 -- We're done factoring, but have no variables left, so we shouldn't make a lambda.
 -- @\ -> e@ ==> @e@
@@ -306,5 +308,4 @@
       _ -> False
 
 fromParen1 :: LHsExpr GhcPs -> LHsExpr GhcPs
-fromParen1 (L _ (HsPar _ x)) = x
-fromParen1 x = x
+fromParen1 x = fromMaybe x $ remParen x
diff --git a/src/GHC/Util/Unify.hs b/src/GHC/Util/Unify.hs
--- a/src/GHC/Util/Unify.hs
+++ b/src/GHC/Util/Unify.hs
@@ -26,6 +26,7 @@
 import Language.Haskell.GhclibParserEx.GHC.Types.Name.Reader
 import GHC.Util.HsExpr
 import GHC.Util.View
+import Data.Maybe
 import FastString
 
 isUnifyVar :: String -> Bool
@@ -171,6 +172,7 @@
     | (L _ (OpApp _ lhs1 op1@(L _ (HsVar _ op1')) rhs1)) <- x =
         guard (nm op1' op2') >> (, Nothing) <$> liftA2 (<>) (unifyExp' nm False lhs1 lhs2) (unifyExp' nm False rhs1 rhs2)
     | isDol op2 = unifyExp nm root x $ noLoc (HsApp noExtField lhs2 rhs2)
+    | isAmp op2 = unifyExp nm root x $ noLoc (HsApp noExtField rhs2 lhs2)
     | otherwise  = unifyExp nm root x $ noLoc (HsApp noExtField (noLoc (HsApp noExtField op2 (addPar lhs2))) (addPar rhs2))
         where
           -- add parens around when desugaring the expression, if necessary
@@ -179,6 +181,9 @@
 
 unifyExp nm root x y = (, Nothing) <$> unifyExp' nm root x y
 
+isAmp :: LHsExpr GhcPs -> Bool
+isAmp (L _ (HsVar _ x)) = rdrNameStr x == "&"
+
 -- | If we "throw away" the extra than we have no where to put it, and the substitution is wrong
 noExtra :: Maybe (Subst (LHsExpr GhcPs), Maybe (LHsExpr GhcPs)) -> Maybe (Subst (LHsExpr GhcPs))
 noExtra (Just (x, Nothing)) = Just x
@@ -197,7 +202,11 @@
 -- Brackets are not added when expanding '$' in user code, so tolerate
 -- them in the match even if they aren't in the user code.
 -- Also, allow the user to put in more brackets than they strictly need (e.g. with infix).
-unifyExp' nm root x y | not root, isPar x || isPar y = unifyExp' nm root (fromParen x) (fromParen y)
+unifyExp' nm root x y | not root, isJust x2 || isJust y2 = unifyExp' nm root (fromMaybe x x2) (fromMaybe y y2)
+    where
+        -- Make sure we deal with the weird brackets that can't be removed around sections
+        x2 = remParen x
+        y2 = remParen y
 
 unifyExp' nm root x@(L _ (OpApp _ lhs1 (L _ (HsVar _ (rdrNameStr -> v))) rhs1))
                   y@(L _ (OpApp _ lhs2 (L _ (HsVar _ op2)) rhs2)) =
diff --git a/src/GHC/Util/View.hs b/src/GHC/Util/View.hs
--- a/src/GHC/Util/View.hs
+++ b/src/GHC/Util/View.hs
@@ -12,10 +12,10 @@
 import SrcLoc
 import BasicTypes
 import Language.Haskell.GhclibParserEx.GHC.Types.Name.Reader
+import GHC.Util.Brackets
 
 fromParen :: LHsExpr GhcPs -> LHsExpr GhcPs
-fromParen (L _ (HsPar _ x)) = fromParen x
-fromParen x = x
+fromParen x = maybe x fromParen $ remParen x
 
 fromPParen :: LPat GhcPs -> LPat GhcPs
 fromPParen (L _ (ParPat _ x)) = fromPParen x
diff --git a/src/Hint/Lambda.hs b/src/Hint/Lambda.hs
--- a/src/Hint/Lambda.hs
+++ b/src/Hint/Lambda.hs
@@ -63,6 +63,7 @@
 f = a b (\x -> c x d)  -- (`c` d)
 yes = \x -> a x where -- a
 yes = \x y -> op y x where -- flip op
+yes = \x y -> op z y x where -- flip (op z)
 f = \y -> nub $ reverse y where -- nub . reverse
 f = \z -> foo $ bar $ baz z where -- foo . bar . baz
 f = \z -> foo $ bar x $ baz z where -- foo . bar x . baz