content: {-# LANGUAGE CPP #-}
  {-# LANGUAGE Trustworthy #-}
  #include "lens-common.h"
  -- | Module which does most common imports (and related CPP)
  -- needed across the lens library.
  --
  -- This module is intended to stay in other-modules of lens,
  -- perfectly we'd just use @base-compat-batteries@
  -- and not reinvent the wheel.
  -- That's a reason why this module is different from
  -- other .Internal modules, which are exposed-modules.
  --
  -- Also this is a "fat" Prelude, re-exporting commonly used,
  -- non conflicting symbols.
  --
  module Control.Lens.Internal.Prelude
    ( module Prelude
    , Semigroup (..)
    , Monoid (..)
    , Foldable, foldMap, foldr, foldl, foldl', elem, null, length, traverse_
    , Traversable (..)
    , Applicative (..)
    , (&), (<&>), (<$>), (<$)
    -- * Data types
    , ZipList (..)
    , NonEmpty (..)
    -- * Functors
    , Identity (..)
    , Compose (..)
    , Const (..)
    -- * Control.Applicative
    , Alternative (..), WrappedMonad (..)
  #if !MIN_VERSION_base(4,10,0)
    , liftA2
  #endif
    -- * Data.Coerce
    , Coercible, coerce
    -- * Data.Contravariant
    , Contravariant (..), phantom
    -- * Data.Monoid
    , Endo (..), Dual (..)
    -- * Data.Profunctor
    , Profunctor (..)
    , Choice (..), Cochoice (..)
    , Strong (..), Costrong (..)
    , Corepresentable (..)
    , Sieve (..), Cosieve (..)
    -- * Data.Proxy
    , Proxy (..)
    -- * Data.Tagged
    , Tagged (..)
    -- * Data.Void
    , Void, absurd
    -- * Data.Word
    , Word
    ) where
  
  import Prelude hiding
      ( userError -- hiding something always helps with CPP
      , Applicative (..)
      , Foldable (..)
      , Traversable (..)
      , Monoid (..)
      , (<$>), (<$)
  #if MIN_VERSION_base(4,13,0)
      , Semigroup (..)
  #endif
      , Word
      )
  
  -- Prelude
  import Control.Applicative (Applicative (..), (<$>), (<$)) -- N.B. liftA2
  import Data.Foldable (Foldable, foldMap, elem, foldr, foldl, foldl', traverse_) -- N.B. we don't define Foldable instances, so this way is makes less CPP
  import Data.Monoid (Monoid (..))
  import Data.Semigroup (Semigroup (..))
  import Data.Traversable (Traversable (..))
  import Data.Word (Word)
  
  -- Extras
  import Data.Function ((&))
  import Data.Foldable (length, null)
  
  #if !MIN_VERSION_base(4,10,0)
  import Control.Applicative (liftA2)
  #endif
  
  #if MIN_VERSION_base(4,11,0)
  import Data.Functor ((<&>))
  #endif
  
  import Control.Applicative (Alternative (..), Const (..), WrappedMonad (..), ZipList (..))
  import Data.Coerce (Coercible, coerce)
  import Data.Functor.Compose (Compose (..))
  import Data.Functor.Contravariant (Contravariant (..), phantom)
  import Data.Functor.Identity (Identity (..))
  import Data.List.NonEmpty (NonEmpty (..))
  import Data.Monoid (Endo (..), Dual (..))
  import Data.Profunctor (Strong (..), Choice (..), Cochoice (..), Costrong (..))
  import Data.Profunctor.Rep (Corepresentable (..)) -- N.B. no Representable
  import Data.Profunctor.Sieve (Sieve (..), Cosieve (..))
  import Data.Profunctor.Unsafe (Profunctor (..))
  import Data.Proxy (Proxy (..))
  import Data.Tagged (Tagged (..))
  import Data.Void (Void, absurd)
  
  -- TraversableWithIndex instances for tagged, vector and unordered-containers
  -- We import this here, so the instances propagate through all (most) of @lens@.
  import Data.Functor.WithIndex.Instances ()
  
  #if !(MIN_VERSION_base(4,11,0))
  -- | Infix flipped 'fmap'.
  --
  -- @
  -- ('<&>') = 'flip' 'fmap'
  -- @
  (<&>) :: Functor f => f a -> (a -> b) -> f b
  as <&> f = f <$> as
  {-# INLINE (<&>) #-}
  infixl 1 <&>
  #endif
  