Better or more idiomatic way to apply a sequence of functions in Haskell
notK q = map (uncurry filter) . (zip (kFilters q))


is equivalent to

notK q rows = zipWith filter (kFilters q) rows


Onto making above Haskell less idiomatic and less pointfree and more readable.

notC q = map (filter (/= q))
notD q = (map (\(x, r) -&gt; filter (\y -&gt; abs(y - q) /= x) r)) . (zip [1..])
notK q = map (\(f, r) -&gt; filter f r) . (zip (kFilters q))


These three are logically similar but structurally dissimilar. 

First let's factor out common components, give them meaningful names, and some comments to help those readers without the Developer's Manual.

-- a new queen placed in column q
-- would take a piece placed in column x
-- n rows down
-- because (r, q) and (r+n, x)

-- are on the same column
sameColumn q n x = x == q

-- are on the same diagonal
sameDiagonal q n x = abs(x - q) == n

-- or (n, |q - x|) is in [(1,2),(2,1)]
onKnightMove :: Int -&gt; Int -&gt; Int -&gt; Bool
onKnightMove q n x = (n, abs(x - q)) `elem` [(1,2),(2,1)]


The last one needs a better name still, oh well. At least they are of the same form, with parameter name use consistent among them (and elsewhere).

rowFilterList :: Int -&gt; (Int -&gt; Int -&gt; Int -&gt; Bool) -&gt; [Int -&gt; Bool]
rowFilterList q pred = map (\n x -&gt; not $ pred q n x) [1..]


such that kFilters q = rowFilterList q onKnightMove

filterRows :: Int -&gt; (Int -&gt; Int -&gt; Int -&gt; Bool) -&gt; [[Int]] -&gt; [[Int]]
filterRows q pred rows = zipWith filter (rowFilterList q pred) rows


This way notC q = filterRows q sameColumn and notD q = filterRows q sameDiagonal

notK q . notD q . notC q a repetition is evident. And we now can factor it out easily.

filterWithAll :: Int -&gt; [[Int]] -&gt; [Int -&gt; Int -&gt; Int -&gt; Bool] -&gt; [[Int]]
filterWithAll q rows preds = foldl (\rows' pred -&gt; filterRows q pred rows') rows preds


such that safe q rows = filterWithAll q rows [sameColumn, sameDiagonal, onKnightMove]

By factoring out [sameColumn, sameDiagonal, onKnightMove] as a parameter to place n one could easily generalize place from n super-queens to n queens or n rooks.