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