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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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 :: 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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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 :: 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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
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
Evidence bound by a type signature of the constraint type Functor f
fmap (\LibraryVisibility
x -> InstalledPackageInfo
s { libVisibility :: LibraryVisibility
T.libVisibility = LibraryVisibility
x }) (LibraryVisibility -> f LibraryVisibility
f (InstalledPackageInfo -> LibraryVisibility
T.libVisibility InstalledPackageInfo
s))
{-# INLINE libVisibility #-}