Ben Gamari
This is a fair point that comes up fairly often. The fact that CPP is required to silence redundant import warnings is quite unfortunate. Others languages have better stories in this area. One example is Rust, which has a quite flexible `#[allow(...)]` pragma which can be used to acknowledge and silence a wide variety of warnings and lints [1].
I can think of a few ways (some better than others) how we might introduce a similar idea for import redundancy checks in Haskell,
1. Attach a `{-# ALLOW redundant_import #-}` pragma to a definition, ... 2. Or alternatively we could make this a idea a bit more precise, {-# ALLOW redundant_import Prelude.(<$>) #-} ... 3. Attach a `{-# ALLOW redundancy_import #-}` pragma to an import, import {-# ALLOW redundant_import #-} Control.Applicative ... 4. Attach a `{-# ALLOW redundancy_import #-}` pragma to a name in an import list, import Control.Applicative ((<$>) {-# ALLOW redundant_import #-})
What I don't like about this solution is how specific it is -- the gut instinct that it can't be the last such extension, if we were to start replacing CPP piecemeal. And after a while, we'd accomodate a number of such extensions.. and they would keep coming.. until it converges to a trainwreck. I think that what instead needs to be done, is this: 1. a concerted effort to summarize *all* uses of CPP in Haskell code 2. a bit of forward thinking, to include desirables that would be easy to get with a more generic solution Personally, I think that any such effort, approached with generality that would be truly satisfying, should inevitably converge to an AST-level mechanism. ..but then I remember how CPP can be used to paper over incompatible syntax changes.. Hmm.. -- с уважениeм / respectfully, Косырев Серёга