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

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

import Distribution.Types.BuildInfo           (BuildInfo)
import Distribution.Types.ForeignLib          (ForeignLib, LibVersionInfo)
import Distribution.Types.ForeignLibOption    (ForeignLibOption)
import Distribution.Types.ForeignLibType      (ForeignLibType)
import Distribution.Types.UnqualComponentName (UnqualComponentName)
import Distribution.Version                   (Version)

import qualified Distribution.Types.ForeignLib as T

foreignLibName :: Lens' ForeignLib UnqualComponentName
foreignLibName :: LensLike
  f ForeignLib ForeignLib UnqualComponentName UnqualComponentName
foreignLibName UnqualComponentName -> f UnqualComponentName
f ForeignLib
s = (UnqualComponentName -> ForeignLib)
-> f UnqualComponentName -> f ForeignLib
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 (\UnqualComponentName
x -> ForeignLib
s { foreignLibName :: UnqualComponentName
T.foreignLibName = UnqualComponentName
x }) (UnqualComponentName -> f UnqualComponentName
f (ForeignLib -> UnqualComponentName
T.foreignLibName ForeignLib
s))
{-# INLINE foreignLibName #-}

foreignLibType :: Lens' ForeignLib ForeignLibType
foreignLibType :: LensLike f ForeignLib ForeignLib ForeignLibType ForeignLibType
foreignLibType ForeignLibType -> f ForeignLibType
f ForeignLib
s = (ForeignLibType -> ForeignLib) -> f ForeignLibType -> f ForeignLib
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 (\ForeignLibType
x -> ForeignLib
s { foreignLibType :: ForeignLibType
T.foreignLibType = ForeignLibType
x }) (ForeignLibType -> f ForeignLibType
f (ForeignLib -> ForeignLibType
T.foreignLibType ForeignLib
s))
{-# INLINE foreignLibType #-}

foreignLibOptions :: Lens' ForeignLib [ForeignLibOption]
foreignLibOptions :: LensLike
  f ForeignLib ForeignLib [ForeignLibOption] [ForeignLibOption]
foreignLibOptions [ForeignLibOption] -> f [ForeignLibOption]
f ForeignLib
s = ([ForeignLibOption] -> ForeignLib)
-> f [ForeignLibOption] -> f ForeignLib
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 (\[ForeignLibOption]
x -> ForeignLib
s { foreignLibOptions :: [ForeignLibOption]
T.foreignLibOptions = [ForeignLibOption]
x }) ([ForeignLibOption] -> f [ForeignLibOption]
f (ForeignLib -> [ForeignLibOption]
T.foreignLibOptions ForeignLib
s))
{-# INLINE foreignLibOptions #-}

foreignLibBuildInfo :: Lens' ForeignLib BuildInfo
foreignLibBuildInfo :: LensLike f ForeignLib ForeignLib BuildInfo BuildInfo
foreignLibBuildInfo BuildInfo -> f BuildInfo
f ForeignLib
s = (BuildInfo -> ForeignLib) -> f BuildInfo -> f ForeignLib
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 (\BuildInfo
x -> ForeignLib
s { foreignLibBuildInfo :: BuildInfo
T.foreignLibBuildInfo = BuildInfo
x }) (BuildInfo -> f BuildInfo
f (ForeignLib -> BuildInfo
T.foreignLibBuildInfo ForeignLib
s))
{-# INLINE foreignLibBuildInfo #-}

foreignLibVersionInfo :: Lens' ForeignLib (Maybe LibVersionInfo)
foreignLibVersionInfo :: LensLike
  f
  ForeignLib
  ForeignLib
  (Maybe LibVersionInfo)
  (Maybe LibVersionInfo)
foreignLibVersionInfo Maybe LibVersionInfo -> f (Maybe LibVersionInfo)
f ForeignLib
s = (Maybe LibVersionInfo -> ForeignLib)
-> f (Maybe LibVersionInfo) -> f ForeignLib
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 LibVersionInfo
x -> ForeignLib
s { foreignLibVersionInfo :: Maybe LibVersionInfo
T.foreignLibVersionInfo = Maybe LibVersionInfo
x }) (Maybe LibVersionInfo -> f (Maybe LibVersionInfo)
f (ForeignLib -> Maybe LibVersionInfo
T.foreignLibVersionInfo ForeignLib
s))
{-# INLINE foreignLibVersionInfo #-}

foreignLibVersionLinux :: Lens' ForeignLib (Maybe Version)
foreignLibVersionLinux :: LensLike f ForeignLib ForeignLib (Maybe Version) (Maybe Version)
foreignLibVersionLinux Maybe Version -> f (Maybe Version)
f ForeignLib
s = (Maybe Version -> ForeignLib) -> f (Maybe Version) -> f ForeignLib
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 Version
x -> ForeignLib
s { foreignLibVersionLinux :: Maybe Version
T.foreignLibVersionLinux = Maybe Version
x }) (Maybe Version -> f (Maybe Version)
f (ForeignLib -> Maybe Version
T.foreignLibVersionLinux ForeignLib
s))
{-# INLINE foreignLibVersionLinux #-}

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