    module Distribution.Types.InstalledPackageInfo.Lens (
        InstalledPackageInfo,
        module Distribution.Types.InstalledPackageInfo.Lens
        ) where

    import Distribution.Compat.Lens
    import Distribution.Compat.Prelude
    import Prelude ()

    import Distribution.Backpack                   (OpenModule)
    import Distribution.License                    (License)
    import Distribution.ModuleName                 (ModuleName)
    import Distribution.Package                    (AbiHash, ComponentId, PackageIdentifier, UnitId)
    import Distribution.Types.InstalledPackageInfo (AbiDependency, ExposedModule, InstalledPackageInfo)
    import Distribution.Types.LibraryName          (LibraryName)
    import Distribution.Types.LibraryVisibility    (LibraryVisibility)
    import Distribution.Utils.ShortText            (ShortText)

    import qualified Distribution.SPDX                       as SPDX
    import qualified Distribution.Types.InstalledPackageInfo as T

    sourcePackageId :: Lens' InstalledPackageInfo PackageIdentifier
    sourcePackageId :: Lens' InstalledPackageInfo PackageIdentifier
    sourcePackageId PackageIdentifier -> f PackageIdentifier
    f InstalledPackageInfo
    s = (PackageIdentifier -> InstalledPackageInfo)
    -> f PackageIdentifier -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\PackageIdentifier
    x -> InstalledPackageInfo
    s { sourcePackageId :: PackageIdentifier
    T.sourcePackageId = PackageIdentifier
    x }) (PackageIdentifier -> f PackageIdentifier
    f (InstalledPackageInfo -> PackageIdentifier
    T.sourcePackageId InstalledPackageInfo
    s))
    {-# INLINE sourcePackageId #-}

    installedUnitId :: Lens' InstalledPackageInfo UnitId
    installedUnitId :: Lens' InstalledPackageInfo UnitId
    installedUnitId UnitId -> f UnitId
    f InstalledPackageInfo
    s = (UnitId -> InstalledPackageInfo)
    -> f UnitId -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\UnitId
    x -> InstalledPackageInfo
    s { installedUnitId :: UnitId
    T.installedUnitId = UnitId
    x }) (UnitId -> f UnitId
    f (InstalledPackageInfo -> UnitId
    T.installedUnitId InstalledPackageInfo
    s))
    {-# INLINE installedUnitId #-}

    installedComponentId_ :: Lens' InstalledPackageInfo ComponentId
    installedComponentId_ :: Lens' InstalledPackageInfo ComponentId
    installedComponentId_ ComponentId -> f ComponentId
    f InstalledPackageInfo
    s = (ComponentId -> InstalledPackageInfo)
    -> f ComponentId -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ComponentId
    x -> InstalledPackageInfo
    s { installedComponentId_ :: ComponentId
    T.installedComponentId_ = ComponentId
    x }) (ComponentId -> f ComponentId
    f (InstalledPackageInfo -> ComponentId
    T.installedComponentId_ InstalledPackageInfo
    s))
    {-# INLINE installedComponentId_ #-}

    instantiatedWith :: Lens' InstalledPackageInfo [(ModuleName,OpenModule)]
    instantiatedWith :: Lens' InstalledPackageInfo [(ModuleName, OpenModule)]
    instantiatedWith [(ModuleName, OpenModule)] -> f [(ModuleName, OpenModule)]
    f InstalledPackageInfo
    s = ([(ModuleName, OpenModule)] -> InstalledPackageInfo)
    -> f [(ModuleName, OpenModule)] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[(ModuleName, OpenModule)]
    x -> InstalledPackageInfo
    s { instantiatedWith :: [(ModuleName, OpenModule)]
    T.instantiatedWith = [(ModuleName, OpenModule)]
    x }) ([(ModuleName, OpenModule)] -> f [(ModuleName, OpenModule)]
    f (InstalledPackageInfo -> [(ModuleName, OpenModule)]
    T.instantiatedWith InstalledPackageInfo
    s))
    {-# INLINE instantiatedWith #-}

    sourceLibName :: Lens' InstalledPackageInfo LibraryName
    sourceLibName :: Lens' InstalledPackageInfo LibraryName
    sourceLibName LibraryName -> f LibraryName
    f InstalledPackageInfo
    s = (LibraryName -> InstalledPackageInfo)
    -> f LibraryName -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\LibraryName
    x -> InstalledPackageInfo
    s { sourceLibName :: LibraryName
    T.sourceLibName = LibraryName
    x }) (LibraryName -> f LibraryName
    f (InstalledPackageInfo -> LibraryName
    T.sourceLibName InstalledPackageInfo
    s))
    {-# INLINE sourceLibName #-}

    compatPackageKey :: Lens' InstalledPackageInfo String
    compatPackageKey :: Lens' InstalledPackageInfo String
    compatPackageKey String -> f String
    f InstalledPackageInfo
    s = (String -> InstalledPackageInfo)
    -> f String -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\String
    x -> InstalledPackageInfo
    s { compatPackageKey :: String
    T.compatPackageKey = String
    x }) (String -> f String
    f (InstalledPackageInfo -> String
    T.compatPackageKey InstalledPackageInfo
    s))
    {-# INLINE compatPackageKey #-}

    license :: Lens' InstalledPackageInfo (Either SPDX.License License)
    license :: Lens' InstalledPackageInfo (Either License License)
    license Either License License -> f (Either License License)
    f InstalledPackageInfo
    s = (Either License License -> InstalledPackageInfo)
    -> f (Either License License) -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\Either License License
    x -> InstalledPackageInfo
    s { license :: Either License License
    T.license = Either License License
    x }) (Either License License -> f (Either License License)
    f (InstalledPackageInfo -> Either License License
    T.license InstalledPackageInfo
    s))
    {-# INLINE license #-}

    copyright :: Lens' InstalledPackageInfo ShortText
    copyright :: Lens' InstalledPackageInfo ShortText
    copyright ShortText -> f ShortText
    f InstalledPackageInfo
    s = (ShortText -> InstalledPackageInfo)
    -> f ShortText -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ShortText
    x -> InstalledPackageInfo
    s { copyright :: ShortText
    T.copyright = ShortText
    x }) (ShortText -> f ShortText
    f (InstalledPackageInfo -> ShortText
    T.copyright InstalledPackageInfo
    s))
    {-# INLINE copyright #-}

    maintainer :: Lens' InstalledPackageInfo ShortText
    maintainer :: Lens' InstalledPackageInfo ShortText
    maintainer ShortText -> f ShortText
    f InstalledPackageInfo
    s = (ShortText -> InstalledPackageInfo)
    -> f ShortText -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ShortText
    x -> InstalledPackageInfo
    s { maintainer :: ShortText
    T.maintainer = ShortText
    x }) (ShortText -> f ShortText
    f (InstalledPackageInfo -> ShortText
    T.maintainer InstalledPackageInfo
    s))
    {-# INLINE maintainer #-}

    author :: Lens' InstalledPackageInfo ShortText
    author :: Lens' InstalledPackageInfo ShortText
    author ShortText -> f ShortText
    f InstalledPackageInfo
    s = (ShortText -> InstalledPackageInfo)
    -> f ShortText -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ShortText
    x -> InstalledPackageInfo
    s { author :: ShortText
    T.author = ShortText
    x }) (ShortText -> f ShortText
    f (InstalledPackageInfo -> ShortText
    T.author InstalledPackageInfo
    s))
    {-# INLINE author #-}

    stability :: Lens' InstalledPackageInfo ShortText
    stability :: Lens' InstalledPackageInfo ShortText
    stability ShortText -> f ShortText
    f InstalledPackageInfo
    s = (ShortText -> InstalledPackageInfo)
    -> f ShortText -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ShortText
    x -> InstalledPackageInfo
    s { stability :: ShortText
    T.stability = ShortText
    x }) (ShortText -> f ShortText
    f (InstalledPackageInfo -> ShortText
    T.stability InstalledPackageInfo
    s))
    {-# INLINE stability #-}

    homepage :: Lens' InstalledPackageInfo ShortText
    homepage :: Lens' InstalledPackageInfo ShortText
    homepage ShortText -> f ShortText
    f InstalledPackageInfo
    s = (ShortText -> InstalledPackageInfo)
    -> f ShortText -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ShortText
    x -> InstalledPackageInfo
    s { homepage :: ShortText
    T.homepage = ShortText
    x }) (ShortText -> f ShortText
    f (InstalledPackageInfo -> ShortText
    T.homepage InstalledPackageInfo
    s))
    {-# INLINE homepage #-}

    pkgUrl :: Lens' InstalledPackageInfo ShortText
    pkgUrl :: Lens' InstalledPackageInfo ShortText
    pkgUrl ShortText -> f ShortText
    f InstalledPackageInfo
    s = (ShortText -> InstalledPackageInfo)
    -> f ShortText -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ShortText
    x -> InstalledPackageInfo
    s { pkgUrl :: ShortText
    T.pkgUrl = ShortText
    x }) (ShortText -> f ShortText
    f (InstalledPackageInfo -> ShortText
    T.pkgUrl InstalledPackageInfo
    s))
    {-# INLINE pkgUrl #-}

    synopsis :: Lens' InstalledPackageInfo ShortText
    synopsis :: Lens' InstalledPackageInfo ShortText
    synopsis ShortText -> f ShortText
    f InstalledPackageInfo
    s = (ShortText -> InstalledPackageInfo)
    -> f ShortText -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ShortText
    x -> InstalledPackageInfo
    s { synopsis :: ShortText
    T.synopsis = ShortText
    x }) (ShortText -> f ShortText
    f (InstalledPackageInfo -> ShortText
    T.synopsis InstalledPackageInfo
    s))
    {-# INLINE synopsis #-}

    description :: Lens' InstalledPackageInfo ShortText
    description :: Lens' InstalledPackageInfo ShortText
    description ShortText -> f ShortText
    f InstalledPackageInfo
    s = (ShortText -> InstalledPackageInfo)
    -> f ShortText -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ShortText
    x -> InstalledPackageInfo
    s { description :: ShortText
    T.description = ShortText
    x }) (ShortText -> f ShortText
    f (InstalledPackageInfo -> ShortText
    T.description InstalledPackageInfo
    s))
    {-# INLINE description #-}

    category :: Lens' InstalledPackageInfo ShortText
    category :: Lens' InstalledPackageInfo ShortText
    category ShortText -> f ShortText
    f InstalledPackageInfo
    s = (ShortText -> InstalledPackageInfo)
    -> f ShortText -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\ShortText
    x -> InstalledPackageInfo
    s { category :: ShortText
    T.category = ShortText
    x }) (ShortText -> f ShortText
    f (InstalledPackageInfo -> ShortText
    T.category InstalledPackageInfo
    s))
    {-# INLINE category #-}

    abiHash :: Lens' InstalledPackageInfo AbiHash
    abiHash :: Lens' InstalledPackageInfo AbiHash
    abiHash AbiHash -> f AbiHash
    f InstalledPackageInfo
    s = (AbiHash -> InstalledPackageInfo)
    -> f AbiHash -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\AbiHash
    x -> InstalledPackageInfo
    s { abiHash :: AbiHash
    T.abiHash = AbiHash
    x }) (AbiHash -> f AbiHash
    f (InstalledPackageInfo -> AbiHash
    T.abiHash InstalledPackageInfo
    s))
    {-# INLINE abiHash #-}

    indefinite :: Lens' InstalledPackageInfo Bool
    indefinite :: Lens' InstalledPackageInfo Bool
    indefinite Bool -> f Bool
    f InstalledPackageInfo
    s = (Bool -> InstalledPackageInfo) -> f Bool -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\Bool
    x -> InstalledPackageInfo
    s { indefinite :: Bool
    T.indefinite = Bool
    x }) (Bool -> f Bool
    f (InstalledPackageInfo -> Bool
    T.indefinite InstalledPackageInfo
    s))
    {-# INLINE indefinite #-}

    exposed :: Lens' InstalledPackageInfo Bool
    exposed :: Lens' InstalledPackageInfo Bool
    exposed Bool -> f Bool
    f InstalledPackageInfo
    s = (Bool -> InstalledPackageInfo) -> f Bool -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\Bool
    x -> InstalledPackageInfo
    s { exposed :: Bool
    T.exposed = Bool
    x }) (Bool -> f Bool
    f (InstalledPackageInfo -> Bool
    T.exposed InstalledPackageInfo
    s))
    {-# INLINE exposed #-}

    exposedModules :: Lens' InstalledPackageInfo [ExposedModule]
    exposedModules :: Lens' InstalledPackageInfo [ExposedModule]
    exposedModules [ExposedModule] -> f [ExposedModule]
    f InstalledPackageInfo
    s = ([ExposedModule] -> InstalledPackageInfo)
    -> f [ExposedModule] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[ExposedModule]
    x -> InstalledPackageInfo
    s { exposedModules :: [ExposedModule]
    T.exposedModules = [ExposedModule]
    x }) ([ExposedModule] -> f [ExposedModule]
    f (InstalledPackageInfo -> [ExposedModule]
    T.exposedModules InstalledPackageInfo
    s))
    {-# INLINE exposedModules #-}

    hiddenModules :: Lens' InstalledPackageInfo [ModuleName]
    hiddenModules :: Lens' InstalledPackageInfo [ModuleName]
    hiddenModules [ModuleName] -> f [ModuleName]
    f InstalledPackageInfo
    s = ([ModuleName] -> InstalledPackageInfo)
    -> f [ModuleName] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[ModuleName]
    x -> InstalledPackageInfo
    s { hiddenModules :: [ModuleName]
    T.hiddenModules = [ModuleName]
    x }) ([ModuleName] -> f [ModuleName]
    f (InstalledPackageInfo -> [ModuleName]
    T.hiddenModules InstalledPackageInfo
    s))
    {-# INLINE hiddenModules #-}

    trusted :: Lens' InstalledPackageInfo Bool
    trusted :: Lens' InstalledPackageInfo Bool
    trusted Bool -> f Bool
    f InstalledPackageInfo
    s = (Bool -> InstalledPackageInfo) -> f Bool -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\Bool
    x -> InstalledPackageInfo
    s { trusted :: Bool
    T.trusted = Bool
    x }) (Bool -> f Bool
    f (InstalledPackageInfo -> Bool
    T.trusted InstalledPackageInfo
    s))
    {-# INLINE trusted #-}

    importDirs :: Lens' InstalledPackageInfo [FilePath]
    importDirs :: Lens' InstalledPackageInfo [String]
    importDirs [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { importDirs :: [String]
    T.importDirs = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.importDirs InstalledPackageInfo
    s))
    {-# INLINE importDirs #-}

    libraryDirs :: Lens' InstalledPackageInfo [FilePath]
    libraryDirs :: Lens' InstalledPackageInfo [String]
    libraryDirs [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { libraryDirs :: [String]
    T.libraryDirs = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.libraryDirs InstalledPackageInfo
    s))
    {-# INLINE libraryDirs #-}

    libraryDynDirs :: Lens' InstalledPackageInfo [FilePath]
    libraryDynDirs :: Lens' InstalledPackageInfo [String]
    libraryDynDirs [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { libraryDynDirs :: [String]
    T.libraryDynDirs = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.libraryDynDirs InstalledPackageInfo
    s))
    {-# INLINE libraryDynDirs #-}

    dataDir :: Lens' InstalledPackageInfo FilePath
    dataDir :: Lens' InstalledPackageInfo String
    dataDir String -> f String
    f InstalledPackageInfo
    s = (String -> InstalledPackageInfo)
    -> f String -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\String
    x -> InstalledPackageInfo
    s { dataDir :: String
    T.dataDir = String
    x }) (String -> f String
    f (InstalledPackageInfo -> String
    T.dataDir InstalledPackageInfo
    s))
    {-# INLINE dataDir #-}

    hsLibraries :: Lens' InstalledPackageInfo [String]
    hsLibraries :: Lens' InstalledPackageInfo [String]
    hsLibraries [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { hsLibraries :: [String]
    T.hsLibraries = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.hsLibraries InstalledPackageInfo
    s))
    {-# INLINE hsLibraries #-}

    extraLibraries :: Lens' InstalledPackageInfo [String]
    extraLibraries :: Lens' InstalledPackageInfo [String]
    extraLibraries [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { extraLibraries :: [String]
    T.extraLibraries = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.extraLibraries InstalledPackageInfo
    s))
    {-# INLINE extraLibraries #-}

    extraGHCiLibraries :: Lens' InstalledPackageInfo [String]
    extraGHCiLibraries :: Lens' InstalledPackageInfo [String]
    extraGHCiLibraries [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { extraGHCiLibraries :: [String]
    T.extraGHCiLibraries = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.extraGHCiLibraries InstalledPackageInfo
    s))
    {-# INLINE extraGHCiLibraries #-}

    includeDirs :: Lens' InstalledPackageInfo [FilePath]
    includeDirs :: Lens' InstalledPackageInfo [String]
    includeDirs [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { includeDirs :: [String]
    T.includeDirs = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.includeDirs InstalledPackageInfo
    s))
    {-# INLINE includeDirs #-}

    includes :: Lens' InstalledPackageInfo [String]
    includes :: Lens' InstalledPackageInfo [String]
    includes [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { includes :: [String]
    T.includes = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.includes InstalledPackageInfo
    s))
    {-# INLINE includes #-}

    depends :: Lens' InstalledPackageInfo [UnitId]
    depends :: Lens' InstalledPackageInfo [UnitId]
    depends [UnitId] -> f [UnitId]
    f InstalledPackageInfo
    s = ([UnitId] -> InstalledPackageInfo)
    -> f [UnitId] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[UnitId]
    x -> InstalledPackageInfo
    s { depends :: [UnitId]
    T.depends = [UnitId]
    x }) ([UnitId] -> f [UnitId]
    f (InstalledPackageInfo -> [UnitId]
    T.depends InstalledPackageInfo
    s))
    {-# INLINE depends #-}

    abiDepends :: Lens' InstalledPackageInfo [AbiDependency]
    abiDepends :: Lens' InstalledPackageInfo [AbiDependency]
    abiDepends [AbiDependency] -> f [AbiDependency]
    f InstalledPackageInfo
    s = ([AbiDependency] -> InstalledPackageInfo)
    -> f [AbiDependency] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[AbiDependency]
    x -> InstalledPackageInfo
    s { abiDepends :: [AbiDependency]
    T.abiDepends = [AbiDependency]
    x }) ([AbiDependency] -> f [AbiDependency]
    f (InstalledPackageInfo -> [AbiDependency]
    T.abiDepends InstalledPackageInfo
    s))
    {-# INLINE abiDepends #-}

    ccOptions :: Lens' InstalledPackageInfo [String]
    ccOptions :: Lens' InstalledPackageInfo [String]
    ccOptions [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { ccOptions :: [String]
    T.ccOptions = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.ccOptions InstalledPackageInfo
    s))
    {-# INLINE ccOptions #-}

    cxxOptions :: Lens' InstalledPackageInfo [String]
    cxxOptions :: Lens' InstalledPackageInfo [String]
    cxxOptions [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { cxxOptions :: [String]
    T.cxxOptions = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.cxxOptions InstalledPackageInfo
    s))
    {-# INLINE cxxOptions #-}

    ldOptions :: Lens' InstalledPackageInfo [String]
    ldOptions :: Lens' InstalledPackageInfo [String]
    ldOptions [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { ldOptions :: [String]
    T.ldOptions = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.ldOptions InstalledPackageInfo
    s))
    {-# INLINE ldOptions #-}

    frameworkDirs :: Lens' InstalledPackageInfo [FilePath]
    frameworkDirs :: Lens' InstalledPackageInfo [String]
    frameworkDirs [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { frameworkDirs :: [String]
    T.frameworkDirs = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.frameworkDirs InstalledPackageInfo
    s))
    {-# INLINE frameworkDirs #-}

    frameworks :: Lens' InstalledPackageInfo [String]
    frameworks :: Lens' InstalledPackageInfo [String]
    frameworks [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { frameworks :: [String]
    T.frameworks = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.frameworks InstalledPackageInfo
    s))
    {-# INLINE frameworks #-}

    haddockInterfaces :: Lens' InstalledPackageInfo [FilePath]
    haddockInterfaces :: Lens' InstalledPackageInfo [String]
    haddockInterfaces [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { haddockInterfaces :: [String]
    T.haddockInterfaces = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.haddockInterfaces InstalledPackageInfo
    s))
    {-# INLINE haddockInterfaces #-}

    haddockHTMLs :: Lens' InstalledPackageInfo [FilePath]
    haddockHTMLs :: Lens' InstalledPackageInfo [String]
    haddockHTMLs [String] -> f [String]
    f InstalledPackageInfo
    s = ([String] -> InstalledPackageInfo)
    -> f [String] -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\[String]
    x -> InstalledPackageInfo
    s { haddockHTMLs :: [String]
    T.haddockHTMLs = [String]
    x }) ([String] -> f [String]
    f (InstalledPackageInfo -> [String]
    T.haddockHTMLs InstalledPackageInfo
    s))
    {-# INLINE haddockHTMLs #-}

    pkgRoot :: Lens' InstalledPackageInfo (Maybe FilePath)
    pkgRoot :: Lens' InstalledPackageInfo (Maybe String)
    pkgRoot Maybe String -> f (Maybe String)
    f InstalledPackageInfo
    s = (Maybe String -> InstalledPackageInfo)
    -> f (Maybe String) -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\Maybe String
    x -> InstalledPackageInfo
    s { pkgRoot :: Maybe String
    T.pkgRoot = Maybe String
    x }) (Maybe String -> f (Maybe String)
    f (InstalledPackageInfo -> Maybe String
    T.pkgRoot InstalledPackageInfo
    s))
    {-# INLINE pkgRoot #-}

    libVisibility :: Lens' InstalledPackageInfo LibraryVisibility
    libVisibility :: Lens' InstalledPackageInfo LibraryVisibility
    libVisibility LibraryVisibility -> f LibraryVisibility
    f InstalledPackageInfo
    s = (LibraryVisibility -> InstalledPackageInfo)
    -> f LibraryVisibility -> f InstalledPackageInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\LibraryVisibility
    x -> InstalledPackageInfo
    s { libVisibility :: LibraryVisibility
    T.libVisibility = LibraryVisibility
    x }) (LibraryVisibility -> f LibraryVisibility
    f (InstalledPackageInfo -> LibraryVisibility
    T.libVisibility InstalledPackageInfo
    s))
    {-# INLINE libVisibility #-}