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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 #-}