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

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

import Distribution.ModuleName              (ModuleName)
import Distribution.Types.BuildInfo         (BuildInfo)
import Distribution.Types.Library           (Library)
import Distribution.Types.LibraryName       (LibraryName)
import Distribution.Types.LibraryVisibility (LibraryVisibility)
import Distribution.Types.ModuleReexport    (ModuleReexport)

import qualified Distribution.Types.Library as T

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

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

reexportedModules :: Lens' Library [ModuleReexport]
reexportedModules :: LensLike f Library Library [ModuleReexport] [ModuleReexport]
reexportedModules [ModuleReexport] -> f [ModuleReexport]
f Library
s = ([ModuleReexport] -> Library) -> f [ModuleReexport] -> f Library
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\[ModuleReexport]
x -> Library
s { reexportedModules :: [ModuleReexport]
T.reexportedModules = [ModuleReexport]
x }) ([ModuleReexport] -> f [ModuleReexport]
f (Library -> [ModuleReexport]
T.reexportedModules Library
s))
{-# INLINE reexportedModules #-}

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

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

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

libBuildInfo :: Lens' Library BuildInfo
libBuildInfo :: LensLike f Library Library BuildInfo BuildInfo
libBuildInfo BuildInfo -> f BuildInfo
f Library
s = (BuildInfo -> Library) -> f BuildInfo -> f Library
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\BuildInfo
x -> Library
s { libBuildInfo :: BuildInfo
T.libBuildInfo = BuildInfo
x }) (BuildInfo -> f BuildInfo
f (Library -> BuildInfo
T.libBuildInfo Library
s))
{-# INLINE libBuildInfo #-}