{-# LANGUAGE RankNTypes #-}

-- | Copyright: (c) 2020-2021 berberman
-- SPDX-License-Identifier: MIT
-- Maintainer: berberman <berberman@yandex.com>
-- Stability: experimental
-- Portability: portable
-- Lenses from "Distribution.Compat.Lens"
module Distribution.Uusi.Lens
  ( module Distribution.Compat.Lens,
    lens,
    (<&>),
    mapped,
    HasVersionedPackage (..),
    HasComponentialPackage (..),
  )
where

import Data.Functor ((<&>))
import Data.Functor.Identity
import Distribution.Compat.Lens
import Distribution.Types.Dependency
import Distribution.Types.ExeDependency
import Distribution.Types.LegacyExeDependency
import Distribution.Types.PackageName
import Distribution.Types.UnqualComponentName
import Distribution.Types.VersionRange
import Distribution.Uusi.Types

lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
lens :: forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens s -> a
sa s -> b -> t
sbt a -> f b
afb s
s = s -> b -> t
sbt s
s forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
afb (s -> a
sa s
s)
{-# INLINE lens #-}

mapped :: Functor f => ASetter (f a) (f b) a b
mapped :: forall (f :: * -> *) a b. Functor f => ASetter (f a) (f b) a b
mapped a -> Identity b
f = forall a. a -> Identity a
Identity forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. Identity a -> a
runIdentity forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Identity b
f)
{-# INLINE mapped #-}

class HasVersionedPackage a where
  versionedPackage :: Lens' a VersionedPackage
  myPkgName :: Lens' a PackageName
  myVersionRange :: Lens' a VersionRange

  myPkgName = forall a. HasVersionedPackage a => Lens' a VersionedPackage
versionedPackage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. HasVersionedPackage a => Lens' a PackageName
myPkgName
  {-# INLINE myPkgName #-}
  myVersionRange = forall a. HasVersionedPackage a => Lens' a VersionedPackage
versionedPackage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. HasVersionedPackage a => Lens' a VersionRange
myVersionRange
  {-# INLINE myVersionRange #-}

instance HasVersionedPackage VersionedPackage where
  versionedPackage :: Lens' VersionedPackage VersionedPackage
versionedPackage = forall a. a -> a
id
  myPkgName :: Lens' VersionedPackage PackageName
myPkgName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens VersionedPackage -> PackageName
_myPkgName (\(VersionedPackage PackageName
_ VersionRange
range) PackageName
name -> PackageName -> VersionRange -> VersionedPackage
VersionedPackage PackageName
name VersionRange
range)
  {-# INLINE myPkgName #-}
  myVersionRange :: Lens' VersionedPackage VersionRange
myVersionRange = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens VersionedPackage -> VersionRange
_myVersionRange (\(VersionedPackage PackageName
name VersionRange
_) VersionRange
range -> PackageName -> VersionRange -> VersionedPackage
VersionedPackage PackageName
name VersionRange
range)
  {-# INLINE myVersionRange #-}

class HasComponentialPackage a where
  componentialPackage :: Lens' a ComponentialPackage
  myComponentName :: Lens' a UnqualComponentName
  myCorePackage :: Lens' a VersionedPackage
  myComponentName = forall a. HasComponentialPackage a => Lens' a ComponentialPackage
componentialPackage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. HasComponentialPackage a => Lens' a UnqualComponentName
myComponentName
  {-# INLINE myComponentName #-}
  myCorePackage = forall a. HasComponentialPackage a => Lens' a ComponentialPackage
componentialPackage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. HasComponentialPackage a => Lens' a VersionedPackage
myCorePackage
  {-# INLINE myCorePackage #-}

instance HasComponentialPackage ComponentialPackage where
  componentialPackage :: Lens' ComponentialPackage ComponentialPackage
componentialPackage = forall a. a -> a
id
  myComponentName :: Lens' ComponentialPackage UnqualComponentName
myComponentName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ComponentialPackage -> UnqualComponentName
_myComponentName (\(ComponentialPackage VersionedPackage
core UnqualComponentName
_) UnqualComponentName
name -> VersionedPackage -> UnqualComponentName -> ComponentialPackage
ComponentialPackage VersionedPackage
core UnqualComponentName
name)
  {-# INLINE myComponentName #-}
  myCorePackage :: Lens' ComponentialPackage VersionedPackage
myCorePackage = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens ComponentialPackage -> VersionedPackage
_myCorePackage (\(ComponentialPackage VersionedPackage
_ UnqualComponentName
name) VersionedPackage
core -> VersionedPackage -> UnqualComponentName -> ComponentialPackage
ComponentialPackage VersionedPackage
core UnqualComponentName
name)
  {-# INLINE myCorePackage #-}

instance HasVersionedPackage Dependency where
  versionedPackage :: Lens' Dependency VersionedPackage
versionedPackage =
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
      (\(Dependency PackageName
name VersionRange
range NonEmptySet LibraryName
_) -> PackageName -> VersionRange -> VersionedPackage
VersionedPackage PackageName
name VersionRange
range)
      (\(Dependency PackageName
_ VersionRange
_ NonEmptySet LibraryName
lib) (VersionedPackage PackageName
name VersionRange
range) -> PackageName
-> VersionRange -> NonEmptySet LibraryName -> Dependency
Dependency PackageName
name VersionRange
range NonEmptySet LibraryName
lib)
  {-# INLINE versionedPackage #-}

instance HasVersionedPackage ExeDependency where
  versionedPackage :: Lens' ExeDependency VersionedPackage
versionedPackage =
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
      (\(ExeDependency PackageName
name UnqualComponentName
_ VersionRange
range) -> PackageName -> VersionRange -> VersionedPackage
VersionedPackage PackageName
name VersionRange
range)
      (\(ExeDependency PackageName
_ UnqualComponentName
component VersionRange
_) (VersionedPackage PackageName
name VersionRange
range) -> PackageName -> UnqualComponentName -> VersionRange -> ExeDependency
ExeDependency PackageName
name UnqualComponentName
component VersionRange
range)
  {-# INLINE versionedPackage #-}

instance HasComponentialPackage ExeDependency where
  componentialPackage :: Lens' ExeDependency ComponentialPackage
componentialPackage =
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
      (\x :: ExeDependency
x@(ExeDependency PackageName
_ UnqualComponentName
component VersionRange
_) -> VersionedPackage -> UnqualComponentName -> ComponentialPackage
ComponentialPackage (ExeDependency
x forall s a. s -> Getting a s a -> a
^. forall a. HasVersionedPackage a => Lens' a VersionedPackage
versionedPackage) UnqualComponentName
component)
      ( \ExeDependency
x (ComponentialPackage VersionedPackage
core UnqualComponentName
component) ->
          ExeDependency
x forall a b. a -> (a -> b) -> b
& forall a. HasComponentialPackage a => Lens' a VersionedPackage
myCorePackage forall s t a b. ASetter s t a b -> b -> s -> t
.~ VersionedPackage
core
            forall a b. a -> (a -> b) -> b
& forall a. HasComponentialPackage a => Lens' a UnqualComponentName
myComponentName forall s t a b. ASetter s t a b -> b -> s -> t
.~ UnqualComponentName
component
      )
  {-# INLINE componentialPackage #-}

instance HasVersionedPackage LegacyExeDependency where
  versionedPackage :: Lens' LegacyExeDependency VersionedPackage
versionedPackage =
    forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens
      (\(LegacyExeDependency String
name VersionRange
range) -> PackageName -> VersionRange -> VersionedPackage
VersionedPackage (String -> PackageName
mkPackageName String
name) VersionRange
range)
      (\LegacyExeDependency
_ (VersionedPackage PackageName
name VersionRange
range) -> String -> VersionRange -> LegacyExeDependency
LegacyExeDependency (PackageName -> String
unPackageName PackageName
name) VersionRange
range)
  {-# INLINE versionedPackage #-}