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 :: LensLike
  f
  InstalledPackageInfo
  InstalledPackageInfo
  PackageIdentifier
  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 :: LensLike f InstalledPackageInfo InstalledPackageInfo UnitId 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_ :: LensLike
  f InstalledPackageInfo InstalledPackageInfo ComponentId 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 :: LensLike
  f
  InstalledPackageInfo
  InstalledPackageInfo
  [(ModuleName, OpenModule)]
  [(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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo LibraryName 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 :: LensLike f InstalledPackageInfo InstalledPackageInfo String 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 :: LensLike
  f
  InstalledPackageInfo
  InstalledPackageInfo
  (Either License License)
  (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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo ShortText 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo ShortText 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo ShortText 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo ShortText 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo ShortText 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo ShortText 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo ShortText 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo ShortText 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo ShortText 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo AbiHash 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 :: LensLike f InstalledPackageInfo InstalledPackageInfo Bool 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 :: LensLike f InstalledPackageInfo InstalledPackageInfo Bool 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 :: LensLike
  f
  InstalledPackageInfo
  InstalledPackageInfo
  [ExposedModule]
  [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 :: LensLike
  f
  InstalledPackageInfo
  InstalledPackageInfo
  [ModuleName]
  [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 :: LensLike f InstalledPackageInfo InstalledPackageInfo Bool 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 #-}

libraryDirsStatic :: Lens' InstalledPackageInfo [FilePath]
libraryDirsStatic :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [String]
libraryDirsStatic [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 { libraryDirsStatic :: [String]
T.libraryDirsStatic = [String]
x }) ([String] -> f [String]
f (InstalledPackageInfo -> [String]
T.libraryDirsStatic InstalledPackageInfo
s))
{-# INLINE libraryDirsStatic #-}

libraryDynDirs :: Lens' InstalledPackageInfo [FilePath]
libraryDynDirs :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike f InstalledPackageInfo InstalledPackageInfo String 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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 #-}

extraLibrariesStatic :: Lens' InstalledPackageInfo [String]
extraLibrariesStatic :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [String]
extraLibrariesStatic [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 { extraLibrariesStatic :: [String]
T.extraLibrariesStatic = [String]
x }) ([String] -> f [String]
f (InstalledPackageInfo -> [String]
T.extraLibrariesStatic InstalledPackageInfo
s))
{-# INLINE extraLibrariesStatic #-}

extraGHCiLibraries :: Lens' InstalledPackageInfo [String]
extraGHCiLibraries :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [UnitId] [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 :: LensLike
  f
  InstalledPackageInfo
  InstalledPackageInfo
  [AbiDependency]
  [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f InstalledPackageInfo InstalledPackageInfo [String] [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 :: LensLike
  f
  InstalledPackageInfo
  InstalledPackageInfo
  (Maybe String)
  (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 :: LensLike
  f
  InstalledPackageInfo
  InstalledPackageInfo
  LibraryVisibility
  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 #-}